localstack-core 4.5.1.dev21__py3-none-any.whl → 4.5.1.dev23__py3-none-any.whl

localstack/services/apigateway/analytics.py

@@ -1,5 +1,5 @@
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
-invocation_counter = Counter(
+invocation_counter = LabeledCounter(
     namespace="apigateway", name="rest_api_execute", labels=["invocation_type"]
 )

localstack/services/apigateway/next_gen/execute_api/handlers/analytics.py

@@ -1,7 +1,7 @@
 import logging
 
 from localstack.http import Response
-from localstack.utils.analytics.metrics import LabeledCounterMetric
+from localstack.utils.analytics.metrics import LabeledCounter
 
 from ..api import RestApiGatewayHandler, RestApiGatewayHandlerChain
 from ..context import RestApiInvocationContext
@@ -10,9 +10,9 @@ LOG = logging.getLogger(__name__)
 
 
 class IntegrationUsageCounter(RestApiGatewayHandler):
-    counter: LabeledCounterMetric
+    counter: LabeledCounter
 
-    def __init__(self, counter: LabeledCounterMetric):
+    def __init__(self, counter: LabeledCounter):
         self.counter = counter
 
     def __call__(

localstack/services/cloudformation/{usage.py → analytics.py}

@@ -1,7 +1,7 @@
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
 COUNTER_NAMESPACE = "cloudformation"
 
-resources = Counter(
+resources = LabeledCounter(
     namespace=COUNTER_NAMESPACE, name="resources", labels=["resource_type", "missing"]
 )

localstack/services/cloudformation/engine/v2/change_set_model_executor.py

@@ -115,7 +115,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
             node_resource = self._get_node_resource_for(
                 resource_name=depends_on_resource_logical_id, node_template=self._node_template
             )
-            self.visit_node_resource(node_resource)
+            self.visit(node_resource)
 
         return array_identifiers_delta
 
@@ -257,6 +257,7 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
         resource_provider = resource_provider_executor.try_load_resource_provider(resource_type)
 
         extra_resource_properties = {}
+        event = ProgressEvent(OperationStatus.SUCCESS, resource_model={})
         if resource_provider is not None:
             # TODO: stack events
             try:
@@ -271,11 +272,15 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     exc_info=LOG.isEnabledFor(logging.DEBUG),
                 )
                 stack = self._change_set.stack
-                stack_status = stack.status
-                if stack_status == StackStatus.CREATE_IN_PROGRESS:
-                    stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
-                elif stack_status == StackStatus.UPDATE_IN_PROGRESS:
-                    stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
+                match stack.status:
+                    case StackStatus.CREATE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
+                    case StackStatus.UPDATE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
+                    case StackStatus.DELETE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.DELETE_FAILED, reason=reason)
+                    case _:
+                        raise NotImplementedError(f"Unexpected stack status: {stack.status}")
                 # update resource status
                 stack.set_resource_status(
                     logical_resource_id=logical_resource_id,
@@ -288,8 +293,6 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     resource_status_reason=reason,
                 )
                 return
-        else:
-            event = ProgressEvent(OperationStatus.SUCCESS, resource_model={})
 
         self.resources.setdefault(logical_resource_id, {"Properties": {}})
         match event.status:
@@ -341,13 +344,15 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 )
                 # TODO: duplication
                 stack = self._change_set.stack
-                stack_status = stack.status
-                if stack_status == StackStatus.CREATE_IN_PROGRESS:
-                    stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
-                elif stack_status == StackStatus.UPDATE_IN_PROGRESS:
-                    stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
-                else:
-                    raise NotImplementedError(f"Unhandled stack status: '{stack.status}'")
+                match stack.status:
+                    case StackStatus.CREATE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.CREATE_FAILED, reason=reason)
+                    case StackStatus.UPDATE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.UPDATE_FAILED, reason=reason)
+                    case StackStatus.DELETE_IN_PROGRESS:
+                        stack.set_stack_status(StackStatus.DELETE_FAILED, reason=reason)
+                    case _:
+                        raise NotImplementedError(f"Unhandled stack status: '{stack.status}'")
                 stack.set_resource_status(
                     logical_resource_id=logical_resource_id,
                     # TODO
@@ -358,8 +363,8 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                     else ResourceStatus.UPDATE_FAILED,
                     resource_status_reason=reason,
                 )
-            case any:
-                raise NotImplementedError(f"Event status '{any}' not handled")
+            case other:
+                raise NotImplementedError(f"Event status '{other}' not handled")
 
     def create_resource_provider_payload(
         self,
@@ -387,7 +392,9 @@ class ChangeSetModelExecutor(ChangeSetModelPreproc):
                 previous_resource_properties = before_properties_value or {}
             case ChangeAction.Remove:
                 resource_properties = before_properties_value or {}
-                previous_resource_properties = None
+                # previous_resource_properties = None
+                # HACK: our providers use a mix of `desired_state` and `previous_state` so ensure the payload is present for both
+                previous_resource_properties = resource_properties
             case _:
                 raise NotImplementedError(f"Action '{action}' not handled")
 

localstack/services/cloudformation/resource_provider.py

@@ -19,7 +19,7 @@ from plux import Plugin, PluginManager
 
 from localstack import config
 from localstack.aws.connect import InternalClientFactory, ServiceLevelClientFactory
-from localstack.services.cloudformation import usage
+from localstack.services.cloudformation import analytics
 from localstack.services.cloudformation.deployment_utils import (
     check_not_found_exception,
     convert_data_types,
@@ -581,7 +581,7 @@ class ResourceProviderExecutor:
         # 2. try to load community resource provider
         try:
             plugin = plugin_manager.load(resource_type)
-            usage.resources.labels(resource_type=resource_type, missing=False).increment()
+            analytics.resources.labels(resource_type=resource_type, missing=False).increment()
             return plugin.factory()
         except ValueError:
             # could not find a plugin for that name
@@ -600,7 +600,7 @@ class ResourceProviderExecutor:
             f'No resource provider found for "{resource_type}"',
         )
 
-        usage.resources.labels(resource_type=resource_type, missing=True).increment()
+        analytics.resources.labels(resource_type=resource_type, missing=True).increment()
 
         if config.CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES:
             # TODO: figure out a better way to handle non-implemented here?

localstack/services/cloudformation/v2/entities.py

@@ -43,6 +43,7 @@ class Stack:
     status_reason: StackStatusReason | None
     stack_id: str
     creation_time: datetime
+    deletion_time: datetime | None
 
     # state after deploy
     resolved_parameters: dict[str, str]
@@ -67,6 +68,7 @@ class Stack:
         self.status_reason = None
         self.change_set_ids = change_set_ids or []
         self.creation_time = datetime.now(tz=timezone.utc)
+        self.deletion_time = None
 
         self.stack_name = request_payload["StackName"]
         self.change_set_name = request_payload.get("ChangeSetName")
@@ -118,6 +120,7 @@ class Stack:
         result = {
             "ChangeSetId": self.change_set_id,
             "CreationTime": self.creation_time,
+            "DeletionTime": self.deletion_time,
             "StackId": self.stack_id,
             "StackName": self.stack_name,
             "StackStatus": self.status,

localstack/services/cloudformation/v2/provider.py

@@ -1,5 +1,6 @@
 import copy
 import logging
+from datetime import datetime, timezone
 from typing import Any
 
 from localstack.aws.api import RequestContext, handler
@@ -101,7 +102,7 @@ def find_change_set_v2(
                     # TODO: check for active stacks
                     if (
                         stack_candidate.stack_name == stack_name
-                        and stack.status != StackStatus.DELETE_COMPLETE
+                        and stack_candidate.status != StackStatus.DELETE_COMPLETE
                     ):
                         stack = stack_candidate
                         break
@@ -175,10 +176,10 @@ class CloudformationProviderV2(CloudformationProvider):
             # on a CREATE an empty Stack should be generated if we didn't find an active one
             if not active_stack_candidates and change_set_type == ChangeSetType.CREATE:
                 stack = Stack(
-                    context.account_id,
-                    context.region,
-                    request,
-                    structured_template,
+                    account_id=context.account_id,
+                    region_name=context.region,
+                    request_payload=request,
+                    template=structured_template,
                     template_body=template_body,
                 )
                 state.stacks_v2[stack.stack_id] = stack
@@ -240,7 +241,7 @@ class CloudformationProviderV2(CloudformationProvider):
         after_template = structured_template
 
         # create change set for the stack and apply changes
-        change_set = ChangeSet(stack, request)
+        change_set = ChangeSet(stack, request, template=after_template)
 
         # only set parameters for the changeset, then switch to stack on execute_change_set
         change_set.populate_update_graph(
@@ -309,6 +310,9 @@ class CloudformationProviderV2(CloudformationProvider):
                 change_set.stack.resolved_resources = result.resources
                 change_set.stack.resolved_parameters = result.parameters
                 change_set.stack.resolved_outputs = result.outputs
+                # if the deployment succeeded, update the stack's template representation to that
+                # which was just deployed
+                change_set.stack.template = change_set.template
             except Exception as e:
                 LOG.error(
                     "Execute change set failed: %s", e, exc_info=LOG.isEnabledFor(logging.WARNING)
@@ -458,5 +462,37 @@ class CloudformationProviderV2(CloudformationProvider):
             # aws will silently ignore invalid stack names - we should do the same
             return
 
-        # TODO: actually delete
-        stack.set_stack_status(StackStatus.DELETE_COMPLETE)
+        # shortcut for stacks which have no deployed resources i.e. where a change set was
+        # created, but never executed
+        if stack.status == StackStatus.REVIEW_IN_PROGRESS and not stack.resolved_resources:
+            stack.set_stack_status(StackStatus.DELETE_COMPLETE)
+            stack.deletion_time = datetime.now(tz=timezone.utc)
+            return
+
+        # create a dummy change set
+        change_set = ChangeSet(stack, {"ChangeSetName": f"delete-stack_{stack.stack_name}"})  # noqa
+        change_set.populate_update_graph(
+            before_template=stack.template,
+            after_template=None,
+            before_parameters=stack.resolved_parameters,
+            after_parameters=None,
+        )
+
+        change_set_executor = ChangeSetModelExecutor(change_set)
+
+        def _run(*args):
+            try:
+                stack.set_stack_status(StackStatus.DELETE_IN_PROGRESS)
+                change_set_executor.execute()
+                stack.set_stack_status(StackStatus.DELETE_COMPLETE)
+                stack.deletion_time = datetime.now(tz=timezone.utc)
+            except Exception as e:
+                LOG.warning(
+                    "Failed to delete stack '%s': %s",
+                    stack.stack_name,
+                    e,
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                )
+                stack.set_stack_status(StackStatus.DELETE_FAILED)
+
+        start_worker_thread(_run)

localstack/services/events/analytics.py

@@ -1,6 +1,6 @@
 from enum import StrEnum
 
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
 
 class InvocationStatus(StrEnum):
@@ -11,4 +11,6 @@ class InvocationStatus(StrEnum):
 # number of EventBridge rule invocations per target (e.g., aws:lambda)
 # - status label can be `success` or `error`, see InvocationStatus
 # - service label is the target service name
-rule_invocation = Counter(namespace="events", name="rule_invocations", labels=["status", "service"])
+rule_invocation = LabeledCounter(
+    namespace="events", name="rule_invocations", labels=["status", "service"]
+)

localstack/services/kinesis/resource_providers/aws_kinesis_stream.py

@@ -149,7 +149,7 @@ class KinesisStreamProvider(ResourceProvider[KinesisStreamProperties]):
             client.describe_stream(StreamARN=model["Arn"])
             return ProgressEvent(
                 status=OperationStatus.IN_PROGRESS,
-                resource_model={},
+                resource_model=model,
             )
         except client.exceptions.ResourceNotFoundException:
             return ProgressEvent(

localstack/services/lambda_/analytics.py

@@ -1,12 +1,12 @@
 from enum import StrEnum
 
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
 NAMESPACE = "lambda"
 
-hotreload_counter = Counter(namespace=NAMESPACE, name="hotreload", labels=["operation"])
+hotreload_counter = LabeledCounter(namespace=NAMESPACE, name="hotreload", labels=["operation"])
 
-function_counter = Counter(
+function_counter = LabeledCounter(
     namespace=NAMESPACE,
     name="function",
     labels=[
@@ -38,7 +38,7 @@ class FunctionStatus(StrEnum):
     invocation_error = "invocation_error"
 
 
-esm_counter = Counter(namespace=NAMESPACE, name="esm", labels=["source", "status"])
+esm_counter = LabeledCounter(namespace=NAMESPACE, name="esm", labels=["source", "status"])
 
 
 class EsmExecutionStatus(StrEnum):

localstack/services/sns/analytics.py

@@ -2,8 +2,10 @@
 Usage analytics for SNS internal endpoints
 """
 
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
 # number of times SNS internal endpoint per resource types
 # (e.g. PlatformMessage invoked 10x times, SMSMessage invoked 3x times, SubscriptionToken...)
-internal_api_calls = Counter(namespace="sns", name="internal_api_call", labels=["resource_type"])
+internal_api_calls = LabeledCounter(
+    namespace="sns", name="internal_api_call", labels=["resource_type"]
+)

localstack/services/stepfunctions/{usage.py → analytics.py}

@@ -2,10 +2,10 @@
 Usage reporting for StepFunctions service
 """
 
-from localstack.utils.analytics.metrics import Counter
+from localstack.utils.analytics.metrics import LabeledCounter
 
 # Initialize a counter to record the usage of language features for each state machine.
-language_features_counter = Counter(
+language_features_counter = LabeledCounter(
     namespace="stepfunctions",
     name="language_features_used",
     labels=["query_language", "uses_variables"],

localstack/services/stepfunctions/asl/static_analyser/usage_metrics_static_analyser.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 from typing import Final
 
-import localstack.services.stepfunctions.usage as UsageMetrics
+from localstack.services.stepfunctions import analytics
 from localstack.services.stepfunctions.asl.antlr.runtime.ASLParser import ASLParser
 from localstack.services.stepfunctions.asl.component.common.query_language import (
     QueryLanguageMode,
@@ -40,7 +40,7 @@ class UsageMetricsStaticAnalyser(StaticAnalyser):
             uses_variables = analyser.uses_variables
 
             # Count.
-            UsageMetrics.language_features_counter.labels(
+            analytics.language_features_counter.labels(
                 query_language=language_used, uses_variables=uses_variables
             ).increment()
         except Exception as e:

localstack/utils/analytics/metrics/__init__.py

@@ -0,0 +1,6 @@
+"""LocalStack metrics instrumentation framework"""
+
+from .counter import Counter, LabeledCounter
+from .registry import MetricRegistry, MetricRegistryKey
+
+__all__ = ["Counter", "LabeledCounter", "MetricRegistry", "MetricRegistryKey"]

localstack/utils/analytics/metrics/api.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Protocol
+
+
+class Payload(Protocol):
+    def as_dict(self) -> dict[str, Any]: ...
+
+
+class Metric(ABC):
+    """
+    Base class for all metrics (e.g., Counter, Gauge).
+    Each subclass must implement the `collect()` method.
+    """
+
+    _namespace: str
+    _name: str
+
+    def __init__(self, namespace: str, name: str):
+        if not namespace or namespace.strip() == "":
+            raise ValueError("Namespace must be non-empty string.")
+        self._namespace = namespace
+
+        if not name or name.strip() == "":
+            raise ValueError("Metric name must be non-empty string.")
+        self._name = name
+
+    @property
+    def namespace(self) -> str:
+        return self._namespace
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @abstractmethod
+    def collect(self) -> list[Payload]:
+        """
+        Collects and returns metric data. Subclasses must implement this to return collected metric data.
+        """
+        pass

localstack/utils/analytics/metrics/counter.py

@@ -0,0 +1,209 @@
+import threading
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any, Optional, Union
+
+from localstack import config
+
+from .api import Metric
+from .registry import MetricRegistry
+
+
+@dataclass(frozen=True)
+class CounterPayload:
+    """A data object storing the value of a Counter metric."""
+
+    namespace: str
+    name: str
+    value: int
+    type: str
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "namespace": self.namespace,
+            "name": self.name,
+            "value": self.value,
+            "type": self.type,
+        }
+
+
+@dataclass(frozen=True)
+class LabeledCounterPayload:
+    """A data object storing the value of a LabeledCounter metric."""
+
+    namespace: str
+    name: str
+    value: int
+    type: str
+    labels: dict[str, Union[str, float]]
+
+    def as_dict(self) -> dict[str, Any]:
+        payload_dict = {
+            "namespace": self.namespace,
+            "name": self.name,
+            "value": self.value,
+            "type": self.type,
+        }
+
+        for i, (label_name, label_value) in enumerate(self.labels.items(), 1):
+            payload_dict[f"label_{i}"] = label_name
+            payload_dict[f"label_{i}_value"] = label_value
+
+        return payload_dict
+
+
+class ThreadSafeCounter:
+    """
+    A thread-safe counter for any kind of tracking.
+    This class should not be instantiated directly, use Counter or LabeledCounter  instead.
+    """
+
+    _mutex: threading.Lock
+    _count: int
+
+    def __init__(self):
+        super(ThreadSafeCounter, self).__init__()
+        self._mutex = threading.Lock()
+        self._count = 0
+
+    @property
+    def count(self) -> int:
+        return self._count
+
+    def increment(self, value: int = 1) -> None:
+        """Increments the counter unless events are disabled."""
+        if config.DISABLE_EVENTS:
+            return
+
+        if value <= 0:
+            raise ValueError("Increment value must be positive.")
+
+        with self._mutex:
+            self._count += value
+
+    def reset(self) -> None:
+        """Resets the counter to zero unless events are disabled."""
+        if config.DISABLE_EVENTS:
+            return
+
+        with self._mutex:
+            self._count = 0
+
+
+class Counter(Metric, ThreadSafeCounter):
+    """
+    A thread-safe, unlabeled counter for tracking the total number of occurrences of a specific event.
+    This class is intended for metrics that do not require differentiation across dimensions.
+    For use cases where metrics need to be grouped or segmented by labels, use `LabeledCounter` instead.
+    """
+
+    _type: str
+
+    def __init__(self, namespace: str, name: str):
+        Metric.__init__(self, namespace=namespace, name=name)
+        ThreadSafeCounter.__init__(self)
+
+        self._type = "counter"
+
+        MetricRegistry().register(self)
+
+    def collect(self) -> list[CounterPayload]:
+        """Collects the metric unless events are disabled."""
+        if config.DISABLE_EVENTS:
+            return list()
+
+        if self._count == 0:
+            # Return an empty list if the count is 0, as there are no metrics to send to the analytics backend.
+            return list()
+
+        return [
+            CounterPayload(
+                namespace=self._namespace, name=self.name, value=self._count, type=self._type
+            )
+        ]
+
+
+class LabeledCounter(Metric):
+    """
+    A thread-safe counter for tracking occurrences of an event across multiple combinations of label values.
+    It enables fine-grained metric collection and analysis, with each unique label set stored and counted independently.
+    Use this class when you need dimensional insights into event occurrences.
+    For simpler, unlabeled use cases, see the `Counter` class.
+    """
+
+    _type: str
+    _labels: list[str]
+    _label_values: tuple[Optional[Union[str, float]], ...]
+    _counters_by_label_values: defaultdict[
+        tuple[Optional[Union[str, float]], ...], ThreadSafeCounter
+    ]
+
+    def __init__(self, namespace: str, name: str, labels: list[str]):
+        super(LabeledCounter, self).__init__(namespace=namespace, name=name)
+
+        if not labels:
+            raise ValueError("At least one label is required; the labels list cannot be empty.")
+
+        if any(not label for label in labels):
+            raise ValueError("Labels must be non-empty strings.")
+
+        if len(labels) > 6:
+            raise ValueError("Too many labels: counters allow a maximum of 6.")
+
+        self._type = "counter"
+        self._labels = labels
+        self._counters_by_label_values = defaultdict(ThreadSafeCounter)
+        MetricRegistry().register(self)
+
+    def labels(self, **kwargs: Union[str, float, None]) -> ThreadSafeCounter:
+        """
+        Create a scoped counter instance with specific label values.
+
+        This method assigns values to the predefined labels of a labeled counter and returns
+        a ThreadSafeCounter object that allows tracking metrics for that specific
+        combination of label values.
+
+        :raises ValueError:
+            - If the set of keys provided labels does not match the expected set of labels.
+        """
+        if set(self._labels) != set(kwargs.keys()):
+            raise ValueError(f"Expected labels {self._labels}, got {list(kwargs.keys())}")
+
+        _label_values = tuple(kwargs[label] for label in self._labels)
+
+        return self._counters_by_label_values[_label_values]
+
+    def collect(self) -> list[LabeledCounterPayload]:
+        if config.DISABLE_EVENTS:
+            return list()
+
+        payload = []
+        num_labels = len(self._labels)
+
+        for label_values, counter in self._counters_by_label_values.items():
+            if counter.count == 0:
+                continue  # Skip items with a count of 0, as they should not be sent to the analytics backend.
+
+            if len(label_values) != num_labels:
+                raise ValueError(
+                    f"Label count mismatch: expected {num_labels} labels {self._labels}, "
+                    f"but got {len(label_values)} values {label_values}."
+                )
+
+            # Create labels dictionary
+            labels_dict = {
+                label_name: label_value
+                for label_name, label_value in zip(self._labels, label_values)
+            }
+
+            payload.append(
+                LabeledCounterPayload(
+                    namespace=self._namespace,
+                    name=self.name,
+                    value=counter.count,
+                    type=self._type,
+                    labels=labels_dict,
+                )
+            )
+
+        return payload

localstack/utils/analytics/metrics/publisher.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from localstack import config
+from localstack.runtime import hooks
+from localstack.utils.analytics import get_session_id
+from localstack.utils.analytics.events import Event, EventMetadata
+from localstack.utils.analytics.publisher import AnalyticsClientPublisher
+
+from .registry import MetricRegistry
+
+
+@hooks.on_infra_shutdown()
+def publish_metrics() -> None:
+    """
+    Collects all the registered metrics and immediately sends them to the analytics service.
+    Skips execution if event tracking is disabled (`config.DISABLE_EVENTS`).
+
+    This function is automatically triggered on infrastructure shutdown.
+    """
+    if config.DISABLE_EVENTS:
+        return
+
+    collected_metrics = MetricRegistry().collect()
+    if not collected_metrics.payload:  # Skip publishing if no metrics remain after filtering
+        return
+
+    metadata = EventMetadata(
+        session_id=get_session_id(),
+        client_time=str(datetime.now()),
+    )
+
+    if collected_metrics:
+        publisher = AnalyticsClientPublisher()
+        publisher.publish(
+            [Event(name="ls_metrics", metadata=metadata, payload=collected_metrics.as_dict())]
+        )