[MISC] Config hash (#1166)

* Use Patroni API for is_restart_pending

* Cached props

* Magic sleep and legacy rel names

* Hash config value and restart only on change

* Tweaks

* Legacy interface fix

* Fix legacy test

* Increase idle period

* Wrong username

* Remove copypasta

Author: dragomirp

lib/charms/tempo_coordinator_k8s/v0/charm_tracing.py

@@ -266,20 +266,20 @@ def _remove_stale_otel_sdk_packages():
         if name.startswith("opentelemetry_"):
             otel_distributions[name].append(distribution)
 
-    otel_logger.debug(f"Found {len(otel_distributions)} opentelemetry distributions")
+    otel_logger.debug("Found %d opentelemetry distributions", len(otel_distributions))
 
     # If we have multiple distributions with the same name, remove any that have 0 associated files
     for name, distributions_ in otel_distributions.items():
         if len(distributions_) <= 1:
             continue
 
         otel_logger.debug(
-            f"Package {name} has multiple ({len(distributions_)}) distributions."
+            "Package %s has multiple (%d) distributions.", name, len(distributions_)
         )
         for distribution in distributions_:
             if not distribution.files:  # Not None or empty list
                 path = distribution._path  # type: ignore
-                otel_logger.info(f"Removing empty distribution of {name} at {path}.")
+                otel_logger.info("Removing empty distribution of %s at %s.", name, path)
                 shutil.rmtree(path)
 
     otel_logger.debug("Successfully applied _remove_stale_otel_sdk_packages patch. ")
@@ -350,7 +350,7 @@ def _remove_stale_otel_sdk_packages():
 # Increment this PATCH version before using `charmcraft publish-lib` or reset
 # to 0 if you are raising the major API version
 
-LIBPATCH = 10
+LIBPATCH = 11
 
 PYDEPS = ["opentelemetry-exporter-otlp-proto-http==1.21.0"]
 
@@ -430,7 +430,8 @@ def _prune(self, queue: Sequence[bytes]) -> Sequence[bytes]:
         if overflow > 0:
             n_dropped_spans += overflow
             logger.warning(
-                f"charm tracing buffer exceeds max history length ({self._max_event_history_length} events)"
+                "charm tracing buffer exceeds max history length (%d events)",
+                self._max_event_history_length,
             )
 
         new_spans = deque(queue[-self._max_event_history_length :])
@@ -446,19 +447,21 @@ def _prune(self, queue: Sequence[bytes]) -> Sequence[bytes]:
             # only do this once
             if not logged_drop:
                 logger.warning(
-                    f"charm tracing buffer exceeds size limit ({self._max_buffer_size_mib}MiB)."
+                    "charm tracing buffer exceeds size limit (%dMiB).",
+                    self._max_buffer_size_mib,
                 )
             logged_drop = True
 
         if n_dropped_spans > 0:
             dev_logger.debug(
-                f"charm tracing buffer overflow: dropped {n_dropped_spans} older spans. "
-                f"Please increase the buffer limits, or ensure the spans can be flushed."
+                "charm tracing buffer overflow: dropped %d older spans. "
+                "Please increase the buffer limits, or ensure the spans can be flushed.",
+                n_dropped_spans,
             )
         return new_spans
 
     def _save(self, spans: Sequence[ReadableSpan], replace: bool = False):
-        dev_logger.debug(f"saving {len(spans)} new spans to buffer")
+        dev_logger.debug("saving %d new spans to buffer", len(spans))
         old = [] if replace else self.load()
         queue = old + [self._serialize(spans)]
         new_buffer = self._prune(queue)
@@ -480,7 +483,7 @@ def _write(self, spans: Sequence[bytes]):
         # ensure the destination folder exists
         db_file_dir = self._db_file.parent
         if not db_file_dir.exists():
-            dev_logger.info(f"creating buffer dir: {db_file_dir}")
+            dev_logger.info("creating buffer dir: %s", db_file_dir)
             db_file_dir.mkdir(parents=True)
 
         self._db_file.write_bytes(self._SPANSEP.join(spans))
@@ -496,15 +499,15 @@ def load(self) -> List[bytes]:
         try:
             spans = self._db_file.read_bytes().split(self._SPANSEP)
         except Exception:
-            logger.exception(f"error parsing {self._db_file}")
+            logger.exception("error parsing %s", self._db_file)
             return []
         return spans
 
     def drop(self, n_spans: Optional[int] = None):
         """Drop some currently buffered spans from the cache file."""
         current = self.load()
         if n_spans:
-            dev_logger.debug(f"dropping {n_spans} spans from buffer")
+            dev_logger.debug("dropping %d spans from buffer", n_spans)
             new = current[n_spans:]
         else:
             dev_logger.debug("emptying buffer")
@@ -693,7 +696,7 @@ def _get_tracing_endpoint(
         )
 
     dev_logger.debug(
-        f"Setting up span exporter to endpoint: {tracing_endpoint}/v1/traces"
+        "Setting up span exporter to endpoint: %s/v1/traces", tracing_endpoint
     )
     return f"{tracing_endpoint}/v1/traces"
 
@@ -711,13 +714,17 @@ def _get_server_cert(
 
     if server_cert is None:
         logger.warning(
-            f"{charm_type}.{server_cert_attr} is None; sending traces over INSECURE connection."
+            "%s.%s is None; sending traces over INSECURE connection.",
+            charm_type,
+            server_cert_attr,
         )
         return
     if not isinstance(server_cert, (str, Path)):
         logger.warning(
-            f"{charm_type}.{server_cert_attr} has unexpected type {type(server_cert)}; "
-            f"sending traces over INSECURE connection."
+            "%s.%s has unexpected type %s; sending traces over INSECURE connection.",
+            charm_type,
+            server_cert_attr,
+            type(server_cert),
         )
         return
     path = Path(server_cert)
@@ -862,13 +869,13 @@ def wrap_init(self: CharmBase, framework: Framework, *args, **kwargs):
 
         # log a trace id, so we can pick it up from the logs (and jhack) to look it up in tempo.
         root_trace_id = hex(span.get_span_context().trace_id)[2:]  # strip 0x prefix
-        logger.debug(f"Starting root trace with id={root_trace_id!r}.")
+        logger.debug("Starting root trace with id=%r.", root_trace_id)
 
         span_token = opentelemetry.context.attach(ctx)  # type: ignore
 
         @contextmanager
         def wrap_event_context(event_name: str):
-            dev_logger.debug(f"entering event context: {event_name}")
+            dev_logger.debug("entering event context: %s", event_name)
             # when the framework enters an event context, we create a span.
             with _span("event: " + event_name) as event_context_span:
                 if event_context_span:
@@ -1059,7 +1066,7 @@ def _autoinstrument(
         Minimum 10MiB.
     :param buffer_path: path to buffer file to use for saving buffered spans.
     """
-    dev_logger.debug(f"instrumenting {charm_type}")
+    dev_logger.debug("instrumenting %s", charm_type)
     _setup_root_span_initializer(
         charm_type,
         tracing_endpoint_attr,
@@ -1083,12 +1090,12 @@ def trace_type(cls: _T) -> _T:
     It assumes that this class is only instantiated after a charm type decorated with `@trace_charm`
     has been instantiated.
     """
-    dev_logger.debug(f"instrumenting {cls}")
+    dev_logger.debug("instrumenting %s", cls)
     for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
-        dev_logger.debug(f"discovered {method}")
+        dev_logger.debug("discovered %s", method)
 
         if method.__name__.startswith("__"):
-            dev_logger.debug(f"skipping {method} (dunder)")
+            dev_logger.debug("skipping %s (dunder)", method)
             continue
 
         # the span title in the general case should be:
@@ -1134,7 +1141,7 @@ def trace_function(function: _F, name: Optional[str] = None) -> _F:
 
 
 def _trace_callable(callable: _F, qualifier: str, name: Optional[str] = None) -> _F:
-    dev_logger.debug(f"instrumenting {callable}")
+    dev_logger.debug("instrumenting %s", callable)
 
     # sig = inspect.signature(callable)
     @functools.wraps(callable)

src/backups.py

@@ -12,6 +12,7 @@
 import tempfile
 import time
 from datetime import datetime, timezone
+from functools import cached_property
 from io import BytesIO
 from pathlib import Path
 from subprocess import TimeoutExpired, run
@@ -86,7 +87,7 @@ def __init__(self, charm, relation_name: str):
         self.framework.observe(self.charm.on.list_backups_action, self._on_list_backups_action)
         self.framework.observe(self.charm.on.restore_action, self._on_restore_action)
 
-    @property
+    @cached_property
     def stanza_name(self) -> str:
         """Stanza name, composed by model and cluster name."""
         return f"{self.model.name}.{self.charm.cluster_name}"