localstack 4.13.2.dev3__py3-none-any.whl → 4.13.2.dev53__py3-none-any.whl

{localstack-4.13.2.dev3.dist-info → localstack-4.13.2.dev53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack
-Version: 4.13.2.dev3
+Version: 4.13.2.dev53
 Summary: The LocalStack Command Line Interface
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0
@@ -24,7 +24,7 @@ Requires-Dist: cryptography
 Requires-Dist: dnslib>=0.9.10
 Requires-Dist: dnspython>=1.16.0
 Requires-Dist: docker>=6.1.1
-Requires-Dist: plux>=1.10
+Requires-Dist: plux>=1.14.0
 Requires-Dist: psutil>=5.4.8
 Requires-Dist: python-dotenv>=0.19.1
 Requires-Dist: pyyaml>=5.1

{localstack-4.13.2.dev3.dist-info → localstack-4.13.2.dev53.dist-info}/RECORD

@@ -1,7 +1,7 @@
 localstack_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/config.py,sha256=kjt-tEH5TG3EPtHReLr23DzAw5XI_hZF5d8GEzCfuns,67164
 localstack_cli/constants.py,sha256=Z65z7evTRQGRf1buYMMvLwKZOI0XfzlUsNmeUGcONzQ,6304
-localstack_cli/version.py,sha256=SFLLRw8MUMPC4Sz9qchuuWw3ogigwBorq4pH1XS9imw,719
+localstack_cli/version.py,sha256=3I42U3YyhfokzXbjISyosAx6wqRUCvQ9vOovMDUic5U,721
 localstack_cli/cli/__init__.py,sha256=S0u4eNluwhhLkiCC8UZNjhh27Pk-W7jeUiEv4k3VrXo,176
 localstack_cli/cli/console.py,sha256=eMz2PfQRDG493uzXFqQZTbYTC4NhO6UOpx4ZricsGLI,346
 localstack_cli/cli/core_plugin.py,sha256=bVbkbhIOegsfQvD3BF_T477K6v6yjK0lRn4eE5PpnSI,382
@@ -22,16 +22,17 @@ localstack_cli/pro/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 localstack_cli/pro/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/pro/core/config.py,sha256=hyf7eKNfeYnH3jeKyRUV-IGJI2oWnx0o9_xzjHueYkc,24822
 localstack_cli/pro/core/constants.py,sha256=xlaC6U4ZeAqMmAhOcVPsQyXTND-rt4k20tAxSc7m_Qk,1780
+localstack_cli/pro/core/plugins.py,sha256=AoQO5XbG2JpmeFQ6q1QCphMV_uzuwPFZnmhlaKC2bac,3252
 localstack_cli/pro/core/bootstrap/__init__.py,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
 localstack_cli/pro/core/bootstrap/auth.py,sha256=jl2jkaAR6pFpGPXFLQIB_o2I8BHaA_h199McIk7gdIk,8800
-localstack_cli/pro/core/bootstrap/decryption.py,sha256=4TygJZz3E1fV6HskmdNqUaaCQh8cWAKAVbSYAGd9MRQ,5894
 localstack_cli/pro/core/bootstrap/dns_utils.py,sha256=qEUKKGbWK2iDDOaKND91fz3saYODDQxNk8LLAe5KEp8,2207
 localstack_cli/pro/core/bootstrap/entitlements.py,sha256=zU84AANqZVCKZ0_yXFRLJaUBkN_hV9xlYMsV3QDEJvw,3757
-localstack_cli/pro/core/bootstrap/licensingv2.py,sha256=1hhW6wQX9vASWPgB2otqzsLcu5o8hFbm1KnzG27Z1q4,51780
+localstack_cli/pro/core/bootstrap/licensingv2.py,sha256=OMmti11WHtmB6HbyK3zG1XhISU5iTk35K9tRFmhUeZY,46216
 localstack_cli/pro/core/bootstrap/pods_client.py,sha256=l6D1eXHoCWW-jfbB0LVdT4H0Mg_EuYoftLQTVyEBD6I,33263
 localstack_cli/pro/core/bootstrap/extensions/__init__.py,sha256=m1UNp2aCa8M_mCdU1KhvfAWldfeLMPSM7ssyxkRYfKo,65
 localstack_cli/pro/core/bootstrap/extensions/__main__.py,sha256=hBnA5G6RkVF7iNQCPT4F0befFLwvJAYUdThZ7oNmJEI,3000
 localstack_cli/pro/core/bootstrap/extensions/autoinstall.py,sha256=90Y_vxD3ogU3wUDnj3sAiuU0Ot4KSpTG9Gp2wXZKfqY,1825
+localstack_cli/pro/core/bootstrap/extensions/bootstrap.py,sha256=iFKTYDTpZAZVHSz2W2fPXTYRNoJP-XTc_to4Ki0GS_I,3412
 localstack_cli/pro/core/bootstrap/extensions/repository.py,sha256=OmriRzU1JvWYgaqr1d0Rsrq-tJSOS1goPZ0KwPR65I8,12267
 localstack_cli/pro/core/bootstrap/pods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/pro/core/bootstrap/pods/api_types.py,sha256=yFuiRB6Hau52QHLt9eGjJRg-Rp9S_nAkBCvvcekufZo,950
@@ -55,10 +56,15 @@ localstack_cli/pro/core/cli/localstack.py,sha256=Z3_7W7UgUGoNgh3m9NS6JjX9nFU1o9O
 localstack_cli/pro/core/cli/replicator.py,sha256=sreAt9hSSDyAHj2wLM2EYClVTLK97pWybAiAu4_veuA,11189
 localstack_cli/pro/core/cli/state.py,sha256=iS8_qSqoxUlQj21nrVToazqjfM7PfBs-3RqoiwpIKn0,6696
 localstack_cli/pro/core/cli/tree_view.py,sha256=K443WkwIxNRDi_rzPiQW5wBTq3dCgzfTiGbVNpeIJ68,7254
+localstack_cli/runtime/__init__.py,sha256=sdfCHRYcw9uvUZsUNzRPh1vEh9kx8w1v1wgOORYnfZs,231
+localstack_cli/runtime/exceptions.py,sha256=qDUqgzcBIxKP8ts0MlGJXskK5w1QWnOyuuZu1yUPzjM,228
+localstack_cli/runtime/hooks.py,sha256=peE2r7BtbVNiiI_YcrDzVZm7CnzVER_EybcZsv0HBh8,2288
+localstack_cli/testing/__init__.py,sha256=2Bk9bgTCK00hAmxbIuHCt7x50RRB9q_ciciIwCpPfGQ,48
+localstack_cli/testing/config.py,sha256=xDm8m4iizy3C2bhZ9Ls-XV9RQcDhHW-33f8Yimj6GEM,151
 localstack_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/utils/archives.py,sha256=JHiMWmVhxxEruylj1LoUwJdruQmGbLPNORPTlTFBwek,9825
 localstack_cli/utils/batching.py,sha256=pPRrbb9Ty5pHUMQHjS0tagIxBMPVUdzDaZz-iZPk8Is,8636
-localstack_cli/utils/bootstrap.py,sha256=fC2-tE2S9Lp91IvsteJZ0KaDNhKiz_oPS6bXDTsDJhM,51612
+localstack_cli/utils/bootstrap.py,sha256=AQ2TD2ZQYeNwBopRjlRj7IKkDSD6HPNjMuxvA_mFAOI,51481
 localstack_cli/utils/checksum.py,sha256=Lt19VzwsUYEvPqCsQR8_RoeekOklDYX5aY8A2z9udAw,9730
 localstack_cli/utils/collections.py,sha256=EVP_HRN7MHSrPmNqWSjMnoZ8T2yeX09M3ROqf84YAHM,18515
 localstack_cli/utils/common.py,sha256=zxmwRRpLEqcHb3iSqcxnvK2eeU9QZGuraXVumzaf9aU,6503
@@ -90,23 +96,17 @@ localstack_cli/utils/analytics/cli.py,sha256=FXN-MduXf3H-VJU0rPIuxiUHRw2qktcQRHs
 localstack_cli/utils/analytics/client.py,sha256=ct6DS6yF1E-zwS_aAik5jEZmDoaUChChuf26VklPPzw,3425
 localstack_cli/utils/analytics/events.py,sha256=_YHZf_7nKluUi_ZZfvI4QId3onXKisuAXGISugbzNeQ,563
 localstack_cli/utils/analytics/logger.py,sha256=ufQ-M9G_MyhZrh9Ech1MJnKMlRBormZOh4ujs0FfdA0,1401
-localstack_cli/utils/analytics/metadata.py,sha256=hEen4GT4WWgjuJ0eEk9KRbezQ8WZGsfJ8XoKjtlNOMc,7556
+localstack_cli/utils/analytics/metadata.py,sha256=RMbiRLnEKTTsF-hzoWK372it_WbB1UD7JRrQBVO0skA,7311
 localstack_cli/utils/analytics/publisher.py,sha256=kcQLuZlWsg7aNCOj7rXk5MXT8J8JskFQDOYnSr1_3d8,5032
-localstack_cli/utils/analytics/service_providers.py,sha256=9ZrapP28KyY8uzAAwl_H87KicNGTo9-ZD0ddQnNHUx0,786
 localstack_cli/utils/analytics/service_request_aggregator.py,sha256=bdRX-SSv66_wipmCTtBrJREOzCHBG_zKoj0EmUd0rwg,4112
-localstack_cli/utils/analytics/metrics/__init__.py,sha256=APJa7ulgGseR4dl4EPAhKOEuXxxNiP0f_MwLbNmgc4Y,233
-localstack_cli/utils/analytics/metrics/api.py,sha256=5TfPqbvfgikMhQYSoT5hOaxTpNUIJo2iQYFOb0e0DgQ,1595
-localstack_cli/utils/analytics/metrics/counter.py,sha256=LgmY5p0zQJ5CqR-V_QyqOOWkquKFSq9UJLu0JsZtqqw,6834
-localstack_cli/utils/analytics/metrics/publisher.py,sha256=aQ4ny9SYWNff2XHU6PD0_fNzPHtijNJYhdfypiasS9M,1352
-localstack_cli/utils/analytics/metrics/registry.py,sha256=LMMGNlxYX3I3IeRC2-84B2ehlqA2EBb4Ic1ZP8-n8y4,2822
 localstack_cli/utils/container_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/utils/container_utils/container_client.py,sha256=EjCAIP6WPuI8w01iECo3VuoHzkcpLhz9VlJsPFJ-msI,59629
 localstack_cli/utils/container_utils/docker_cmd_client.py,sha256=4UPKOZTyu2TgPlEc5JpNgm1hvNcT5cp7CEmZjX9Hu2I,40086
 localstack_cli/utils/container_utils/docker_sdk_client.py,sha256=6lnBhjT03otVGBm15WDq3LAfZnxLc4Q1lyjHAyFHsbM,40460
 localstack_cli/utils/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 localstack_cli/utils/server/tcp_proxy.py,sha256=0ehOD5muo2cBCg0boXzKhzF14KfwlJ7VUtM5i8X7M5A,4006
-localstack-4.13.2.dev3.dist-info/METADATA,sha256=MWeqCkXHPdsmbctx59WUfU8M7FjrU0j5ACP8-hj-Fiw,2706
-localstack-4.13.2.dev3.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-localstack-4.13.2.dev3.dist-info/entry_points.txt,sha256=-XGpYRc-r6x3LIbKbTAlmNSYx5uaQ2LZOoI00lSZ3wI,201
-localstack-4.13.2.dev3.dist-info/top_level.txt,sha256=02blzxjv7TnyriE5gkWIM_UqKTSBiCFPgRG5ZBO5R0Y,15
-localstack-4.13.2.dev3.dist-info/RECORD,,
+localstack-4.13.2.dev53.dist-info/METADATA,sha256=W6nIj7w2PCotu0C2VWaC_MTjEM7MxKS8ex6shusRQok,2709
+localstack-4.13.2.dev53.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+localstack-4.13.2.dev53.dist-info/entry_points.txt,sha256=ogxbxjXC9xK1eksf9CUvOEl09SY2qpUt19SVya0WYAY,933
+localstack-4.13.2.dev53.dist-info/top_level.txt,sha256=02blzxjv7TnyriE5gkWIM_UqKTSBiCFPgRG5ZBO5R0Y,15
+localstack-4.13.2.dev53.dist-info/RECORD,,

localstack-4.13.2.dev53.dist-info/entry_points.txt

@@ -0,0 +1,17 @@
+[console_scripts]
+localstack = localstack_cli.cli.main:main
+
+[localstack_cli.hooks.configure_localstack_container]
+configure_extensions_dev_container = localstack_cli.pro.core.plugins:configure_extensions_dev_container
+configure_pro_container = localstack_cli.pro.core.plugins:configure_pro_container
+set_analytics_header = localstack_cli.utils.analytics.metadata:set_analytics_header
+
+[localstack_cli.hooks.prepare_host]
+activate_pro_key_on_host = localstack_cli.pro.core.plugins:activate_pro_key_on_host
+configure_extensions_dev_host = localstack_cli.pro.core.plugins:configure_extensions_dev_host
+patch_community_pro_detection = localstack_cli.pro.core.plugins:patch_community_pro_detection
+publish_invocation_metadata = localstack_cli.utils.analytics.metadata:publish_invocation_metadata
+
+[localstack_cli.plugins.cli]
+core = localstack_cli.cli.core_plugin:CoreCliPlugin
+pro = localstack_cli.pro.core.cli.localstack:ProCliPlugins

localstack_cli/pro/core/bootstrap/extensions/bootstrap.py

@@ -0,0 +1,97 @@
+"""Hooks for extension developer mode on the host CLI."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from tempfile import gettempdir
+
+from localstack_cli import config
+from localstack_cli.utils.bootstrap import Container
+from localstack_cli.utils.container_utils.container_client import BindMount
+from localstack_cli.utils.json import FileMappedDocument
+from localstack_cli.utils.strings import md5
+
+LOG = logging.getLogger(__name__)
+
+_ENTRYPOINT_SCRIPT = """#!/bin/bash
+echo "=================================================="
+echo "LocalStack extension developer mode enabled"
+shopt -s nullglob
+
+pkgs=$(echo /opt/code/localstack/.venv/lib/python3*/site-packages)
+
+echo "import localstack_extensions_resolve;localstack_extensions_resolve.resolve()" > ${pkgs}/localstack-extensions-resolve.pth
+
+cat << EOF >> ${pkgs}/localstack_extensions_resolve.py
+import os
+import sys
+import glob
+
+base_dirs_visited = set()
+
+def append_pth_recursively(base_dir):
+    if base_dir in base_dirs_visited:
+        return
+    base_dirs_visited.add(base_dir)
+
+    for f in glob.glob(f"{base_dir}/*.pth", recursive=True):
+        with open(f, "r") as fd:
+            abs_path = os.path.abspath(os.path.dirname(f))
+            lines = fd.readlines()
+            for line in lines:
+                if line := line.strip():
+                    if "import" in line:
+                        continue
+                    module_dir = os.path.abspath(os.path.join(abs_path, line)) if not os.path.isabs(line) else line
+                    if os.path.exists(module_dir) and os.path.isdir(module_dir):
+                        if module_dir not in sys.path:
+                            sys.path.append(module_dir)
+                        append_pth_recursively(module_dir)
+
+
+def resolve():
+    append_pth_recursively(os.path.dirname(__file__))
+EOF
+
+for d in /opt/code/extensions/* ;
+do
+    echo "- mounting extension ${d}"
+    find ${d} -type d -name "site-packages" >> ${pkgs}/localstack-extensions-venv.pth
+    echo ${d} >> ${pkgs}/localstack-extensions-venv.pth
+done
+echo "Resuming normal execution, ..."
+echo "=================================================="
+exec /usr/local/bin/docker-entrypoint.sh
+"""
+
+_host_extension_dirs: list[str] = []
+
+
+def run_on_configure_host_hook():
+    """Load extension directories from ~/.localstack/extensions-dev.json."""
+    doc = FileMappedDocument(os.path.join(config.CONFIG_DIR, "extensions-dev.json"))
+
+    for extensions_spec in doc.get("extensions", []):
+        path = extensions_spec.get("host_path")
+        if path and os.path.exists(path):
+            _host_extension_dirs.append(path)
+
+
+def run_on_configure_localstack_container_hook(container: Container):
+    """Configure container for extension dev mode."""
+    # Create and mount custom entrypoint script
+    h = md5(_ENTRYPOINT_SCRIPT)
+    file = Path(gettempdir(), f"docker-entrypoint-{h}.sh")
+    if not file.exists():
+        file.write_text(_ENTRYPOINT_SCRIPT, newline="\n", encoding="utf-8")
+        file.chmod(0o777)
+
+    container.config.volumes.add(BindMount(str(file), f"/tmp/{file.name}"))
+    container.config.entrypoint = f"/tmp/{file.name}"
+
+    # Mount extension directories
+    for ext_dir in _host_extension_dirs:
+        target = os.path.join("/opt/code/extensions", os.path.basename(ext_dir))
+        container.config.volumes.add(BindMount(ext_dir, target, read_only=True))

localstack_cli/pro/core/bootstrap/licensingv2.py

@@ -1,8 +1,6 @@
 import base64
-import binascii
 import copy
 import dataclasses
-import hashlib
 import hmac
 import json
 import logging
@@ -26,9 +24,8 @@ from localstack_cli.pro.core.bootstrap.entitlements import (
     ProductInfo,
 )
 from localstack_cli.pro.core.constants import PLATFORM_PLUGIN_NAMESPACE
-from localstack_cli.utils.files import load_file
 from localstack_cli.utils.objects import singleton_factory
-from localstack_cli.utils.strings import md5, to_str
+from localstack_cli.utils.strings import md5
 from plux import Plugin, PluginDisabled, PluginLifecycleListener, PluginSpec
 
 LOG = logging.getLogger(__name__)
@@ -446,20 +443,6 @@ class LicensingClient:
         """
         raise NotImplementedError
 
-    def decode_decryption_key(self, credentials: Credentials, license: License) -> bytes:
-        raise NotImplementedError
-
-
-class LicenseSecretDecoder:
-    """
-    Class to decode the ``license_secret`` field from the given license. The field contains a secret which is
-    the decryption key for the localstack code.
-    """
-
-    def decode_license_secret(self, license: LicenseV1) -> bytes:  # noqa
-        raise NotImplementedError
-
-
 #####################
 # v1 implementation #
 #####################
@@ -518,64 +501,6 @@ class LicenseParser:
             raise LicenseFormatError(f"error parsing license file: {e}") from e
 
 
-class AESLicenseV1SecretDecoder(LicenseSecretDecoder):
-    """
-    Uses a custom AES encryption scheme to decode the source decryption key from the license key. This is
-    mostly obfuscation and not really a trust mechanism.
-
-    The shared key is the sha256 digest of the licensing credentials concatenated with the license signature.
-    """
-
-    scheme = "LS1.0"
-
-    def __init__(self, credentials: Credentials):
-        self.credentials = credentials
-
-    def decode_license_secret(self, license: LicenseV1) -> bytes:  # noqa
-        if not license.signature:
-            raise LicenseFormatError("license is not signed")
-
-        # use the signature of the license as well as the credentials to encode the license key
-        hash_ = hashlib.sha256()
-        hash_.update(self.credentials.to_bytes())
-        hash_.update(binascii.unhexlify(license.signature))  # use the byte value, not the string
-        key = hash_.digest()
-
-        # extract the scheme from the base64 encoded string
-        license_secret = base64.b64decode(license.license_secret)
-        parts = license_secret.split(b":", maxsplit=1)
-        if len(parts) != 2:  # noqa PLR2004
-            raise LicenseFormatError("invalid license key format")
-        scheme, secret = parts
-
-        if scheme.decode("utf-8") != self.scheme:
-            raise ValueError(f"unknown scheme {scheme}")
-
-        iv = secret[:16]
-        encrypted_data = secret[16:]
-
-        return self._aes_decrypt(key, iv, encrypted_data)
-
-    def _aes_decrypt(self, key: bytes, iv: bytes, encrypted_data: bytes):
-        from cryptography.hazmat.primitives import padding
-        from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-        # Create an AES cipher with the provided key and CBC mode
-        cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
-
-        # Create a decryptor object using the AES cipher
-        decryptor = cipher.decryptor()
-
-        # Decrypt the encrypted data
-        decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
-
-        # Remove PKCS7 padding from the decrypted data
-        unpadder = padding.PKCS7(128).unpadder()
-        unpadded_data = unpadder.update(decrypted_data)
-
-        return unpadded_data + unpadder.finalize()
-
-
 class LicenseV1ClientBase(LicensingClient):
     def validate_license(self, credentials: Credentials, license: LicenseV1):
         try:
@@ -640,17 +565,6 @@ class LicenseV1Client(LicenseV1ClientBase):
         license_.offline_data["localstack_version"] = VERSION
         return license_
 
-    def decode_decryption_key(self, credentials: Credentials, license: LicenseV1) -> bytes:
-        key = base64.b64decode(license.license_secret)
-        parts = key.split(b":", maxsplit=1)
-        scheme = to_str(parts[0])
-        if scheme == AESLicenseV1SecretDecoder.scheme:
-            decoder = AESLicenseV1SecretDecoder(credentials)
-        else:
-            raise LicenseFormatError(f"unknown license key scheme {scheme}")
-
-        return decoder.decode_license_secret(license)
-
     def _get_machine_data(self) -> dict:
         from localstack_cli.utils.analytics.metadata import get_client_metadata
 
@@ -826,10 +740,9 @@ class LicensedLocalstackEnvironment:
 
     def activate(self, offline_only: bool = False):
         """
-        This high-level method first activates the license using credentials from the environment, and then
-        enables code decryption if necessary. Once completed, it sets ``self.license`` to the license document
-        that was activated. This method will also set the env var ``PRO_ACTIVATED=1`` after successful license
-        activation and code decryption.
+        This high-level method activates the license using credentials from the environment.
+        Once completed, it sets ``self.license`` to the license document that was activated.
+        This method will also set the env var ``PRO_ACTIVATED=1`` after successful license activation.
 
         See ``activate_license`` for the activation algorithm.
 
@@ -854,9 +767,6 @@ class LicensedLocalstackEnvironment:
 
             self.activate_license(offline_only)
 
-            if not self.is_decryption_enabled():
-                self.enable_decryption()
-
             os.environ[constants.ENV_PRO_ACTIVATED] = "1"
 
     def activate_license(self, offline_only: bool = False):
@@ -974,55 +884,6 @@ class LicensedLocalstackEnvironment:
         """
         return self.product_entitlements.has_entitlement(product_name)
 
-    def enable_decryption(self):
-        """
-        Called by ``activate`` to read the source decryption key from the license key and register the
-        ``DecryptionHandler`` into the sys path.
-        """
-        if not self.activated or not self.license:
-            raise ValueError("license not yet activated")
-
-        from localstack_cli.pro.core.bootstrap.decryption import (
-            DecryptionHandler,
-            init_source_decryption,
-        )
-        from localstack_cli.pro.core.config import ROOT_FOLDER
-
-        decryption_handler = DecryptionHandler(
-            self.client.decode_decryption_key(self.require_valid_credentials(), self.license)
-        )
-
-        try:
-            file_name = f"{ROOT_FOLDER}/localstack/pro/core/utils/decryption_check.py.enc"
-            encrypted_file_content = load_file(file_name, mode="rb")
-            if not encrypted_file_content:
-                raise ValueError(
-                    "Decryption check file not found. Are you using localstack pro in host mode?"
-                )
-            file_content = decryption_handler.decrypt(encrypted_file_content)
-            if b"decryption_check" not in file_content:
-                raise ValueError("Decryption resulted in invalid python file")
-        except Exception as e:
-            raise LicenseActivationError(
-                "Error while trying to perform code activation. You may be using a "
-                "version of LocalStack that is not within your license agreement."
-            ) from e
-
-        init_source_decryption(decryption_handler)
-
-    def is_decryption_enabled(self) -> bool:
-        """
-        Checks whether decryption is enabled. Decryption can be enabled in a test environment when the
-        source code is available. So this can return true even if a license has not been activated.
-
-        :return: true if the normally encrypted source code can be accessed.
-        """
-        try:
-            from localstack_cli.pro.core.utils.decryption_check import decryption_check  # noqa
-
-            return True
-        except ImportError:
-            return False
 
     def save_license(self):
         """

localstack_cli/pro/core/plugins.py

@@ -0,0 +1,81 @@
+"""
+Pro plugin hooks for the LocalStack CLI.
+
+These hooks are executed on the host machine when running CLI commands like `localstack start`.
+They handle license activation, container configuration, and extension developer mode.
+
+Note: This file was extracted from localstack-pro-core/localstack/pro/core/plugins.py
+and rewritten to contain only CLI-relevant functionality.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from localstack_cli import config as localstack_config
+from localstack_cli.config import HostAndPort
+from localstack_cli.pro.core import config as pro_config
+from localstack_cli.pro.core.bootstrap import licensingv2
+from localstack_cli.runtime import hooks
+from localstack_cli.runtime.exceptions import LocalstackExit
+from localstack_cli.utils.bootstrap import Container
+
+LOG = logging.getLogger(__name__)
+
+
+def modify_gateway_listen_config(cfg):
+    """
+    Modifies the localstack config to additionally listen to port 443.
+    Needs to be called before any edge URLs are resolved using the config.
+    """
+    if os.getenv("GATEWAY_LISTEN") is None:
+        host = "0.0.0.0" if localstack_config.in_docker() else "127.0.0.1"
+        cfg.GATEWAY_LISTEN.append(HostAndPort(host=host, port=443))
+
+
+@hooks.prepare_host(priority=200)
+def patch_community_pro_detection():
+    """This is currently needed to make localstack core aware of the `localstack auth set-token`
+    functionality, where we set the key into the ``~/.localstack/auth.json`` file that community does not
+    yet know about. ``is_api_key_configured`` is used in the LocalStack CLI to determine whether to start
+    the localstack or localstack-pro container image."""
+    from localstack_cli.utils import bootstrap
+
+    bootstrap.is_auth_token_configured = pro_config.is_auth_token_configured
+
+
+@hooks.prepare_host(priority=100, should_load=pro_config.ACTIVATE_PRO)
+def activate_pro_key_on_host():
+    """Activate license on host (needed for DNS forward and EC2 daemon)."""
+    try:
+        licensingv2.get_licensed_environment().activate()
+    except licensingv2.LicensingError as e:
+        raise LocalstackExit(reason=e.get_user_friendly(), code=55)
+
+
+@hooks.configure_localstack_container(priority=10, should_load=pro_config.ACTIVATE_PRO)
+def configure_pro_container(container: Container):
+    """Configure the LocalStack container for pro features."""
+    modify_gateway_listen_config(localstack_config)
+    container.configure(licensingv2.configure_container_licensing)
+
+
+@hooks.prepare_host(should_load=pro_config.ACTIVATE_PRO and pro_config.EXTENSION_DEV_MODE)
+def configure_extensions_dev_host():
+    """Load extension directories from ~/.localstack/extensions-dev.json."""
+    from localstack_cli.pro.core.bootstrap.extensions.bootstrap import run_on_configure_host_hook
+
+    run_on_configure_host_hook()
+
+
+@hooks.configure_localstack_container(
+    should_load=pro_config.ACTIVATE_PRO and pro_config.EXTENSION_DEV_MODE
+)
+def configure_extensions_dev_container(container: Container):
+    """Configure container for extension developer mode."""
+    from localstack_cli.pro.core.bootstrap.extensions.bootstrap import (
+        run_on_configure_localstack_container_hook,
+    )
+
+    run_on_configure_localstack_container_hook(container)

localstack_cli/runtime/__init__.py

@@ -0,0 +1,6 @@
+"""Runtime utilities for the LocalStack CLI."""
+
+from localstack_cli.runtime import hooks  # noqa: F401
+
+# get_current_runtime is not available in the standalone CLI - only in the full LocalStack runtime
+get_current_runtime = None

localstack_cli/runtime/exceptions.py

@@ -0,0 +1,7 @@
+class LocalstackExit(Exception):
+    """Raised to gracefully exit LocalStack."""
+
+    def __init__(self, reason: str = None, code: int = 1):
+        self.reason = reason
+        self.code = code
+        super().__init__(reason)

localstack_cli/runtime/hooks.py

@@ -0,0 +1,73 @@
+import functools
+
+from plux import PluginManager, plugin
+
+# plugin namespace constants
+HOOKS_CONFIGURE_LOCALSTACK_CONTAINER = "localstack_cli.hooks.configure_localstack_container"
+HOOKS_PREPARE_HOST = "localstack_cli.hooks.prepare_host"
+
+
+def hook(namespace: str, priority: int = 0, **kwargs):
+    """
+    Decorator for creating functional plugins that have a hook_priority attribute. Hooks with a higher priority value
+    will be executed earlier.
+    """
+
+    def wrapper(fn):
+        fn.hook_priority = priority
+        return plugin(namespace=namespace, **kwargs)(fn)
+
+    return wrapper
+
+
+def hook_spec(namespace: str):
+    """
+    Creates a new hook decorator bound to a namespace.
+
+    on_infra_start = hook_spec("localstack.hooks.on_infra_start")
+
+    @on_infra_start()
+    def foo():
+        pass
+
+    # run all hooks in order
+    on_infra_start.run()
+    """
+    fn = functools.partial(hook, namespace=namespace)
+    # attach hook manager and run method to decorator for convenience calls
+    fn.manager = HookManager(namespace)
+    fn.run = fn.manager.run_in_order
+    return fn
+
+
+class HookManager(PluginManager):
+    def load_all_sorted(self, propagate_exceptions=False):
+        """
+        Loads all hook plugins and sorts them by their hook_priority attribute.
+        """
+        plugins = self.load_all(propagate_exceptions)
+        # the hook_priority attribute is part of the function wrapped in the FunctionPlugin
+        plugins.sort(
+            key=lambda _fn_plugin: getattr(_fn_plugin.fn, "hook_priority", 0), reverse=True
+        )
+        return plugins
+
+    def run_in_order(self, *args, **kwargs):
+        """
+        Loads and runs all plugins in order them with the given arguments.
+        """
+        for fn_plugin in self.load_all_sorted():
+            fn_plugin(*args, **kwargs)
+
+    def __str__(self):
+        return f"HookManager({self.namespace})"
+
+    def __repr__(self):
+        return self.__str__()
+
+
+configure_localstack_container = hook_spec(HOOKS_CONFIGURE_LOCALSTACK_CONTAINER)
+"""Hooks to configure the LocalStack container before it starts. Executed on the host when invoking the CLI."""
+
+prepare_host = hook_spec(HOOKS_PREPARE_HOST)
+"""Hooks to prepare the host that's starting LocalStack. Executed on the host when invoking the CLI."""

localstack_cli/testing/__init__.py

@@ -0,0 +1 @@
+"""Testing utilities for the LocalStack CLI."""

localstack_cli/testing/config.py

@@ -0,0 +1,4 @@
+"""Testing configuration constants."""
+
+# Secondary test account ID for multi-account testing scenarios
+SECONDARY_TEST_AWS_ACCOUNT_ID = "886468871268"

localstack_cli/utils/analytics/metadata.py

@@ -5,11 +5,7 @@ import platform
 
 from localstack_cli import config
 from localstack_cli.constants import VERSION
-try:
-    from localstack_cli.runtime import get_current_runtime, hooks
-except ImportError:
-    get_current_runtime = None
-    hooks = None
+from localstack_cli.runtime import get_current_runtime, hooks
 from localstack_cli.utils.bootstrap import Container
 from localstack_cli.utils.files import rm_rf
 from localstack_cli.utils.functions import call_safe
@@ -237,20 +233,18 @@ def get_system() -> str:
     return platform.system().lower()
 
 
-# Runtime-only hooks - only register when running inside LocalStack runtime
-if hooks is not None:
-    @hooks.prepare_host()
-    def prepare_host_machine_id():
-        # lazy-init machine ID into cache on the host, which can then be used in the container
-        get_machine_id()
+@hooks.prepare_host()
+def publish_invocation_metadata():
+    """Lazy-init machine ID into cache on the host, which can then be used in the container."""
+    get_machine_id()
 
-    @hooks.configure_localstack_container()
-    def _mount_machine_file(container: Container):
-        from localstack_cli.utils.container_utils.container_client import BindMount
 
-        # mount tha machine file from the host's CLI cache directory into the appropriate location in the
-        # container
-        machine_file = os.path.join(config.dirs.cache, "machine.json")
-        if os.path.isfile(machine_file):
-            target = os.path.join(config.dirs.for_container().cache, "machine.json")
-            container.config.volumes.add(BindMount(machine_file, target, read_only=True))
+@hooks.configure_localstack_container()
+def set_analytics_header(container: Container):
+    """Mount the machine file from the host's CLI cache directory into the container."""
+    from localstack_cli.utils.container_utils.container_client import BindMount
+
+    machine_file = os.path.join(config.dirs.cache, "machine.json")
+    if os.path.isfile(machine_file):
+        target = os.path.join(config.dirs.for_container().cache, "machine.json")
+        container.config.volumes.add(BindMount(machine_file, target, read_only=True))

localstack_cli/utils/bootstrap.py

@@ -21,10 +21,7 @@ from localstack_cli.config import (
     load_environment,
 )
 from localstack_cli.constants import VERSION
-try:
-    from localstack_cli.runtime import hooks
-except ImportError:
-    hooks = None  # Runtime hooks not available in standalone CLI
+from localstack_cli.runtime import hooks
 from localstack_cli.utils.container_networking import get_main_container_name
 from localstack_cli.utils.container_utils.container_client import (
     BindMount,
@@ -1218,8 +1215,7 @@ def configure_container(container: Container):
         container.config.additional_flags = f"{container.config.additional_flags} {user_flags}"
 
     # get additional parameters from plux
-    if hooks:
-        hooks.configure_localstack_container.run(container)
+    hooks.configure_localstack_container.run(container)
 
     if config.DEVELOP:
         container.config.ports.add(config.DEVELOP_PORT)
@@ -1256,8 +1252,7 @@ def prepare_host(console):
             console.print_exception()
 
     setup_logging()
-    if hooks:
-        hooks.prepare_host.run()
+    hooks.prepare_host.run()
 
 
 def start_infra_in_docker(console, cli_params: dict[str, Any] = None):

localstack_cli/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.13.2.dev3'
-__version_tuple__ = version_tuple = (4, 13, 2, 'dev3')
+__version__ = version = '4.13.2.dev53'
+__version_tuple__ = version_tuple = (4, 13, 2, 'dev53')
 
 __commit_id__ = commit_id = None

localstack-4.13.2.dev3.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[console_scripts]
-localstack = localstack_cli.cli.main:main
-
-[localstack_cli.plugins.cli]
-core = localstack_cli.cli.core_plugin:CoreCliPlugin
-pro = localstack_cli.pro.core.cli.localstack:ProCliPlugins

localstack_cli/pro/core/bootstrap/decryption.py

@@ -1,160 +0,0 @@
-import inspect
-import os.path
-import sys
-import tempfile
-import tokenize
-import traceback
-from importlib.abc import MetaPathFinder, SourceLoader
-from importlib.util import spec_from_file_location
-
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from localstack_cli.utils.files import load_file
-from localstack_cli.utils.patch import patch
-from localstack_cli.utils.strings import to_str
-
-
-class DecryptionHandler:
-    decryption_key: bytes
-
-    def __init__(self, decryption_key: bytes):
-        self.decryption_key = decryption_key
-
-    def decrypt(self, content) -> bytes:
-        iv = b"\0" * 16
-        cipher = Cipher(algorithms.AES(self.decryption_key), modes.CBC(iv))
-        decryptor = cipher.decryptor()
-
-        decrypted = decryptor.update(content) + decryptor.finalize()
-        # Remove padding bytes
-        decrypted = decrypted.partition(b"\0")[0]
-        return decrypted
-
-
-class EncryptedFileFinder(MetaPathFinder):
-    decryption_handler: DecryptionHandler
-
-    def __init__(self, decryption_handler: DecryptionHandler):
-        self.decryption_handler = decryption_handler
-
-    def find_spec(self, fullname, path, target=None):
-        # convert to list - "path" may be an instance of _NamespacePath (which doesn't support indexing)
-        if path and not isinstance(path, list):
-            path = list(getattr(path, "_path", []))
-
-        if not path:
-            return None
-
-        name = fullname.split(".")[-1]
-
-        file_path = os.path.join(path[0], name + ".py")
-        enc = file_path + ".enc"
-
-        if not os.path.isfile(enc):
-            return None
-
-        if os.path.isfile(file_path):
-            # file already exists in decrypted state, let next import handler handle it
-            return None
-
-        return spec_from_file_location(
-            fullname, enc, loader=DecryptingLoader(enc, self.decryption_handler)
-        )
-
-
-class DecryptingLoader(SourceLoader):
-    decryption_handler: DecryptionHandler
-
-    def __init__(self, encrypted_file, decryption_handler: DecryptionHandler):
-        self.encrypted_file = encrypted_file
-        self.decryption_handler = decryption_handler
-
-    def get_filename(self, fullname):
-        return self.encrypted_file
-
-    def get_data(self, filename):
-        with open(filename, "rb") as f:
-            data = f.read()
-        data = self.decryption_handler.decrypt(data)
-        return data
-
-
-def init_source_decryption(decryption_handler: DecryptionHandler):
-    # insert custom file loader into meta_path
-    sys.meta_path.insert(0, EncryptedFileFinder(decryption_handler))
-    # patch traceback/inspect to gracefully handle encrypted source files
-    patch_traceback_lines()
-    patch_inspect_findsource()
-    patch_tokenize_open(decryption_handler)
-
-
-def patch_traceback_lines():
-    """Patch traceback to gracefully handle encrypted source files. This is required to avoid
-    UnicodeDecodeError errors when traceback attempts to access the binary file content."""
-
-    # make sure we apply the patch only once
-    if getattr(traceback.FrameSummary, "_ls_patch_applied", None):
-        return
-
-    @property
-    def line(self):
-        try:
-            return line_orig.fget(self)
-        except Exception:
-            self._line = ""
-            return self._line
-
-    line_orig = traceback.FrameSummary.line
-    traceback.FrameSummary.line = line
-    traceback.FrameSummary._ls_patch_applied = True
-
-
-def patch_inspect_findsource():
-    """Patch inspect to gracefully handle encrypted source files. This is required to avoid
-    "SyntaxError: invalid or missing encoding declaration" when attempting to access the binary file content.
-    """
-
-    # TODO: this patch is likely no longer required, should be handled by patch_tokenize_open(..) below
-
-    # make sure we apply the patch only once
-    if getattr(inspect, "_ls_patch_applied", None):
-        return
-
-    def findsource(*args, **kwargs):
-        try:
-            return findsource_orig(*args, **kwargs)
-        except Exception:
-            return [], 0
-
-    findsource_orig = inspect.findsource
-    inspect.findsource = findsource
-    inspect._ls_patch_applied = True
-
-
-def patch_tokenize_open(decryption_handler: DecryptionHandler):
-    """
-    Patch to gracefully handle encrypted source files. This is required to properly retrieve the source
-    code of encrypted Python files when requested. In particular, it enables the use of code inspection utilities
-    in the `inspect` module, for example inspect.getsource(..) which returns the source code of a given module.
-
-    Note: this patch still leaves the in-memory file decryption of the `DecryptingLoader(..)` above intact,
-    and hence has no negative impact on the runtime performance of decrypting the source files on startup.
-    """
-
-    @patch(tokenize.open)
-    def tokenize_open(fn, filename, *args, **kwargs):
-        try:
-            return fn(filename, *args, **kwargs)
-        except Exception as e:
-            # Special handling for loading encrypted python files. In case we run inspect.getsource(..) on
-            # an encrypted module, we'd receive the following error message:
-            #  SyntaxError: invalid or missing encoding declaration for '/.../my_module.py.enc'
-            if "missing encoding declaration" in str(e) and filename.endswith(".py.enc"):
-                # below we load the content of the encrypted file, decrypt it via `decryption_handler`,
-                # then store it to a temporary file, and call tokenize.open(..) on the now plaintext file
-                content = load_file(filename, mode="rb")
-                content_decrypted = to_str(decryption_handler.decrypt(content))
-                with tempfile.NamedTemporaryFile("w+t") as fp:
-                    fp.write(content_decrypted)
-                    fp.seek(0)
-                    return fn(fp.name, *args, **kwargs)
-            raise

localstack_cli/utils/analytics/metrics/__init__.py

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

localstack_cli/utils/analytics/metrics/api.py

@@ -1,58 +0,0 @@
-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
-    _schema_version: int
-
-    def __init__(self, namespace: str, name: str, schema_version: int = 1):
-        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
-
-        if schema_version is None:
-            raise ValueError("An explicit schema_version is required for Counter metrics")
-
-        if not isinstance(schema_version, int):
-            raise TypeError("Schema version must be an integer.")
-
-        if schema_version <= 0:
-            raise ValueError("Schema version must be greater than zero.")
-
-        self._schema_version = schema_version
-
-    @property
-    def namespace(self) -> str:
-        return self._namespace
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def schema_version(self) -> int:
-        return self._schema_version
-
-    @abstractmethod
-    def collect(self) -> list[Payload]:
-        """
-        Collects and returns metric data. Subclasses must implement this to return collected metric data.
-        """
-        pass

localstack_cli/utils/analytics/metrics/counter.py

@@ -1,212 +0,0 @@
-import threading
-from collections import defaultdict
-from dataclasses import dataclass
-from typing import Any
-
-from localstack_cli 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
-    schema_version: int
-
-    def as_dict(self) -> dict[str, Any]:
-        return {
-            "namespace": self.namespace,
-            "name": self.name,
-            "value": self.value,
-            "type": self.type,
-            "schema_version": self.schema_version,
-        }
-
-
-@dataclass(frozen=True)
-class LabeledCounterPayload:
-    """A data object storing the value of a LabeledCounter metric."""
-
-    namespace: str
-    name: str
-    value: int
-    type: str
-    schema_version: int
-    labels: dict[str, str | float]
-
-    def as_dict(self) -> dict[str, Any]:
-        payload_dict = {
-            "namespace": self.namespace,
-            "name": self.name,
-            "value": self.value,
-            "type": self.type,
-            "schema_version": self.schema_version,
-        }
-
-        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().__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, schema_version: int = 1):
-        Metric.__init__(self, namespace=namespace, name=name, schema_version=schema_version)
-        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 []
-
-        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 []
-
-        return [
-            CounterPayload(
-                namespace=self._namespace,
-                name=self.name,
-                value=self._count,
-                type=self._type,
-                schema_version=self._schema_version,
-            )
-        ]
-
-
-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[str | float | None, ...]
-    _counters_by_label_values: defaultdict[tuple[str | float | None, ...], ThreadSafeCounter]
-
-    def __init__(self, namespace: str, name: str, labels: list[str], schema_version: int = 1):
-        super().__init__(namespace=namespace, name=name, schema_version=schema_version)
-
-        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: 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 []
-
-        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 = dict(zip(self._labels, label_values, strict=False))
-
-            payload.append(
-                LabeledCounterPayload(
-                    namespace=self._namespace,
-                    name=self.name,
-                    value=counter.count,
-                    type=self._type,
-                    schema_version=self._schema_version,
-                    labels=labels_dict,
-                )
-            )
-
-        return payload

localstack_cli/utils/analytics/metrics/publisher.py

@@ -1,45 +0,0 @@
-from datetime import datetime
-
-from localstack_cli import config
-
-try:
-    from localstack_cli.runtime import hooks
-except ImportError:
-    hooks = None
-
-from localstack_cli.utils.analytics import get_session_id
-from localstack_cli.utils.analytics.events import Event, EventMetadata
-from localstack_cli.utils.analytics.publisher import AnalyticsClientPublisher
-
-from .registry import MetricRegistry
-
-
-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())]
-        )
-
-
-# Register the hook if runtime is available
-if hooks is not None:
-    publish_metrics = hooks.on_infra_shutdown()(publish_metrics)

localstack_cli/utils/analytics/metrics/registry.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import logging
-import threading
-from dataclasses import dataclass
-from typing import Any
-
-from .api import Metric, Payload
-
-LOG = logging.getLogger(__name__)
-
-
-@dataclass
-class MetricPayload:
-    """
-    A data object storing the value of all metrics collected during the execution of the application.
-    """
-
-    _payload: list[Payload]
-
-    @property
-    def payload(self) -> list[Payload]:
-        return self._payload
-
-    def __init__(self, payload: list[Payload]):
-        self._payload = payload
-
-    def as_dict(self) -> dict[str, list[dict[str, Any]]]:
-        return {"metrics": [payload.as_dict() for payload in self._payload]}
-
-
-@dataclass(frozen=True)
-class MetricRegistryKey:
-    """A unique identifier for a metric, composed of namespace and name."""
-
-    namespace: str
-    name: str
-
-
-class MetricRegistry:
-    """
-    A Singleton class responsible for managing all registered metrics.
-    Provides methods for retrieving and collecting metrics.
-    """
-
-    _instance: MetricRegistry = None
-    _mutex: threading.Lock = threading.Lock()
-
-    def __new__(cls):
-        # avoid locking if the instance already exist
-        if cls._instance is None:
-            with cls._mutex:
-                # Prevents race conditions when multiple threads enter the first check simultaneously
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        if not hasattr(self, "_registry"):
-            self._registry = {}
-
-    @property
-    def registry(self) -> dict[MetricRegistryKey, Metric]:
-        return self._registry
-
-    def register(self, metric: Metric) -> None:
-        """
-        Registers a metric instance.
-
-        Raises a TypeError if the object is not a Metric,
-        or a ValueError if a metric with the same namespace and name is already registered
-        """
-        if not isinstance(metric, Metric):
-            raise TypeError("Only subclasses of `Metric` can be registered.")
-
-        if not metric.namespace:
-            raise ValueError("Metric 'namespace' must be defined and non-empty.")
-
-        registry_unique_key = MetricRegistryKey(namespace=metric.namespace, name=metric.name)
-        if registry_unique_key in self._registry:
-            raise ValueError(
-                f"A metric named '{metric.name}' already exists in the '{metric.namespace}' namespace"
-            )
-
-        self._registry[registry_unique_key] = metric
-
-    def collect(self) -> MetricPayload:
-        """
-        Collects all registered metrics.
-        """
-        payload = [
-            metric
-            for metric_instance in self._registry.values()
-            for metric in metric_instance.collect()
-        ]
-
-        return MetricPayload(payload=payload)

localstack_cli/utils/analytics/service_providers.py

@@ -1,22 +0,0 @@
-try:
-    from localstack_cli.runtime import hooks
-except ImportError:
-    # Runtime not available - this module requires runtime dependencies
-    pass
-else:
-    @hooks.on_runtime_ready()
-    def publish_provider_assignment():
-        """
-        Publishes the service provider assignment to the analytics service.
-        """
-
-        from localstack_cli.config import SERVICE_PROVIDER_CONFIG
-        from localstack_cli.services.plugins import SERVICE_PLUGINS
-        from localstack_cli.utils.analytics import log
-
-        provider_assignment = {
-            service: f"localstack.aws.provider/{service}:{SERVICE_PROVIDER_CONFIG[service]}"
-            for service in SERVICE_PLUGINS.list_available()
-        }
-
-        log.event("ls_service_provider_assignment", provider_assignment)