dt-extensions-sdk 1.1.22__py3-none-any.whl → 1.1.24__py3-none-any.whl

dynatrace_extension/cli/schema.py

@@ -1,129 +1,129 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import yaml
-
-
-class ExtensionYaml:
-    def __init__(self, yaml_file: Path):
-        self._file = yaml_file
-        self._data = yaml.safe_load(yaml_file.read_text())
-
-    @property
-    def name(self) -> str:
-        return self._data.get("name", "")
-
-    @property
-    def version(self) -> str:
-        return self._data.get("version", "")
-
-    @property
-    def min_dynatrace_version(self) -> str:
-        return self._data.get("minDynatraceVersion", "")
-
-    @property
-    def author(self) -> Author:
-        return Author(self._data.get("author", {}))
-
-    @property
-    def python(self) -> Python:
-        return Python(self._data.get("python", {}))
-
-    def validate(self):
-        """
-        Checks that the files under 'python.activation' exist and are valid json files
-        """
-        if self.python.activation.remote and self.python.activation.remote.path:
-            self._validate_json_file(self.python.activation.remote.path)
-
-        if self.python.activation.local and self.python.activation.local.path:
-            self._validate_json_file(self.python.activation.local.path)
-
-    def _validate_json_file(self, raw_path: str):
-        path = Path(Path(self._file).parent / raw_path)
-        if not path.exists():
-            msg = f"Extension yaml validation failed, file {path} does not exist"
-            raise ValueError(msg)
-
-        # Parse the file to make sure it is valid json
-        with path.open() as f:
-            json.load(f)
-
-    def zip_file_name(self) -> str:
-        return f"{self.name.replace(':', '_')}-{self.version}.zip"
-
-
-class Python:
-    def __init__(self, data: dict):
-        self._data = data
-
-    @property
-    def runtime(self) -> Runtime:
-        return Runtime(self._data.get("runtime", {}))
-
-    @property
-    def activation(self):
-        return Activation(self._data.get("activation", {}))
-
-
-class Runtime:
-    def __init__(self, data: dict):
-        self._data = data
-
-    @property
-    def module(self) -> str:
-        return self._data.get("module", "datasourcepy")
-
-    @property
-    def version(self) -> Version:
-        return Version(self._data.get("version", {}))
-
-
-class Version:
-    def __init__(self, data: dict):
-        self._data = data
-
-    @property
-    def min_version(self) -> str:
-        return self._data.get("min", "")
-
-    @property
-    def max_version(self) -> str:
-        return self._data.get("max", "")
-
-
-class Activation:
-    def __init__(self, data: dict):
-        self._data = data
-
-    @property
-    def remote(self) -> ActivationInstance | None:
-        if data := self._data.get("remote"):
-            return ActivationInstance(data)
-        return None
-
-    @property
-    def local(self) -> ActivationInstance | None:
-        if data := self._data.get("local"):
-            return ActivationInstance(data)
-        return None
-
-
-class ActivationInstance:
-    def __init__(self, data: dict):
-        self._data = data
-
-    @property
-    def path(self) -> str:
-        return self._data.get("path", "")
-
-
-class Author:
-    def __init__(self, _data: dict):
-        self._data = _data
-
-    @property
-    def name(self) -> str:
-        return self._data.get("name", "")
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import yaml
+
+
+class ExtensionYaml:
+    def __init__(self, yaml_file: Path):
+        self._file = yaml_file
+        self._data = yaml.safe_load(yaml_file.read_text())
+
+    @property
+    def name(self) -> str:
+        return self._data.get("name", "")
+
+    @property
+    def version(self) -> str:
+        return self._data.get("version", "")
+
+    @property
+    def min_dynatrace_version(self) -> str:
+        return self._data.get("minDynatraceVersion", "")
+
+    @property
+    def author(self) -> Author:
+        return Author(self._data.get("author", {}))
+
+    @property
+    def python(self) -> Python:
+        return Python(self._data.get("python", {}))
+
+    def validate(self):
+        """
+        Checks that the files under 'python.activation' exist and are valid json files
+        """
+        if self.python.activation.remote and self.python.activation.remote.path:
+            self._validate_json_file(self.python.activation.remote.path)
+
+        if self.python.activation.local and self.python.activation.local.path:
+            self._validate_json_file(self.python.activation.local.path)
+
+    def _validate_json_file(self, raw_path: str):
+        path = Path(Path(self._file).parent / raw_path)
+        if not path.exists():
+            msg = f"Extension yaml validation failed, file {path} does not exist"
+            raise ValueError(msg)
+
+        # Parse the file to make sure it is valid json
+        with path.open() as f:
+            json.load(f)
+
+    def zip_file_name(self) -> str:
+        return f"{self.name.replace(':', '_')}-{self.version}.zip"
+
+
+class Python:
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def runtime(self) -> Runtime:
+        return Runtime(self._data.get("runtime", {}))
+
+    @property
+    def activation(self):
+        return Activation(self._data.get("activation", {}))
+
+
+class Runtime:
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def module(self) -> str:
+        return self._data.get("module", "datasourcepy")
+
+    @property
+    def version(self) -> Version:
+        return Version(self._data.get("version", {}))
+
+
+class Version:
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def min_version(self) -> str:
+        return self._data.get("min", "")
+
+    @property
+    def max_version(self) -> str:
+        return self._data.get("max", "")
+
+
+class Activation:
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def remote(self) -> ActivationInstance | None:
+        if data := self._data.get("remote"):
+            return ActivationInstance(data)
+        return None
+
+    @property
+    def local(self) -> ActivationInstance | None:
+        if data := self._data.get("local"):
+            return ActivationInstance(data)
+        return None
+
+
+class ActivationInstance:
+    def __init__(self, data: dict):
+        self._data = data
+
+    @property
+    def path(self) -> str:
+        return self._data.get("path", "")
+
+
+class Author:
+    def __init__(self, _data: dict):
+        self._data = _data
+
+    @property
+    def name(self) -> str:
+        return self._data.get("name", "")

dynatrace_extension/sdk/__init__.py

@@ -1,3 +1,3 @@
-# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
-#
-# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
+#
+# SPDX-License-Identifier: MIT

dynatrace_extension/sdk/activation.py

@@ -1,43 +1,43 @@
-# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
-#
-# SPDX-License-Identifier: MIT
-
-from enum import Enum
-from typing import List
-
-
-class ActivationType(Enum):
-    REMOTE = "remote"
-    LOCAL = "local"
-
-
-class ActivationConfig(dict):
-    def __init__(self, activation_context_json: dict):
-        self._activation_context_json = activation_context_json
-        self.version: str = self._activation_context_json.get("version", "")
-        self.enabled: bool = self._activation_context_json.get("enabled", True)
-        self.description: str = self._activation_context_json.get("description", "")
-        self.feature_sets: List[str] = self._activation_context_json.get("featureSets", [])
-        self.type: ActivationType = ActivationType.REMOTE if self.remote else ActivationType.LOCAL
-        super().__init__()
-
-    @property
-    def config(self) -> dict:
-        return self.remote if self.remote else self.local
-
-    @property
-    def remote(self) -> dict:
-        return self._activation_context_json.get("pythonRemote", {})
-
-    @property
-    def local(self) -> dict:
-        return self._activation_context_json.get("pythonLocal", {})
-
-    def __getitem__(self, item):
-        return self.config[item]
-
-    def get(self, key, default=None):
-        return self.config.get(key, default)
-
-    def __repr__(self):
-        return f"ActivationConfig(version='{self.version}', enabled={self.enabled}, description='{self.description}', type={self.type}, config={self.config})"
+# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
+#
+# SPDX-License-Identifier: MIT
+
+from enum import Enum
+from typing import List
+
+
+class ActivationType(Enum):
+    REMOTE = "remote"
+    LOCAL = "local"
+
+
+class ActivationConfig(dict):
+    def __init__(self, activation_context_json: dict):
+        self._activation_context_json = activation_context_json
+        self.version: str = self._activation_context_json.get("version", "")
+        self.enabled: bool = self._activation_context_json.get("enabled", True)
+        self.description: str = self._activation_context_json.get("description", "")
+        self.feature_sets: List[str] = self._activation_context_json.get("featureSets", [])
+        self.type: ActivationType = ActivationType.REMOTE if self.remote else ActivationType.LOCAL
+        super().__init__()
+
+    @property
+    def config(self) -> dict:
+        return self.remote if self.remote else self.local
+
+    @property
+    def remote(self) -> dict:
+        return self._activation_context_json.get("pythonRemote", {})
+
+    @property
+    def local(self) -> dict:
+        return self._activation_context_json.get("pythonLocal", {})
+
+    def __getitem__(self, item):
+        return self.config[item]
+
+    def get(self, key, default=None):
+        return self.config.get(key, default)
+
+    def __repr__(self):
+        return f"ActivationConfig(version='{self.version}', enabled={self.enabled}, description='{self.description}', type={self.type}, config={self.config})"

dynatrace_extension/sdk/callback.py

@@ -1,134 +1,134 @@
-# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
-#
-# SPDX-License-Identifier: MIT
-
-import logging
-import random
-from datetime import datetime, timedelta
-from timeit import default_timer as timer
-from typing import Callable, Dict, Optional, Tuple
-
-from .activation import ActivationType
-from .communication import Status, StatusValue
-
-
-class WrappedCallback:
-    def __init__(
-        self,
-        interval: timedelta,
-        callback: Callable,
-        logger: logging.Logger,
-        args: Optional[Tuple] = None,
-        kwargs: Optional[Dict] = None,
-        running_in_sim=False,
-        activation_type: Optional[ActivationType] = None,
-    ):
-        self.callback: Callable = callback
-        if args is None:
-            args = ()
-        self.callback_args = args
-        if kwargs is None:
-            kwargs = {}
-        self.callback_kwargs = kwargs
-        self.interval: timedelta = interval
-        self.logger = logger
-        self.running: bool = False
-        self.status = Status(StatusValue.OK)
-        self.executions_total = 0  # global counter
-        self.executions_per_interval = 0  # counter per interval = 1 min by default
-        self.duration = 0  # global counter
-        self.duration_interval_total = 0  # counter per interval = 1 min by default
-        self.cluster_time_diff = 0
-        self.start_timestamp = self.get_current_time_with_cluster_diff()
-        self.running_in_sim = running_in_sim
-        self.activation_type = activation_type
-        self.ok_count = 0  # counter per interval = 1 min by default
-        self.timeouts_count = 0  # counter per interval = 1 min by default
-        self.exception_count = 0  # counter per interval = 1 min by default
-
-    def get_current_time_with_cluster_diff(self):
-        return datetime.now() + timedelta(milliseconds=self.cluster_time_diff)
-
-    def __call__(self):
-        self.logger.debug(f"Running scheduled callback {self}")
-        self.start_timestamp = self.get_current_time_with_cluster_diff()
-        self.running = True
-        self.executions_total += 1
-        self.executions_per_interval += 1
-        self.next_run = datetime.now() + self.interval
-        start_time = timer()
-        failed = False
-        try:
-            self.callback(*self.callback_args, **self.callback_kwargs)
-            self.status = Status(StatusValue.OK)
-        except Exception as e:
-            failed = True
-            self.logger.exception(f"Error running callback {self}: {e!r}")
-            self.status = Status(StatusValue.GENERIC_ERROR, repr(e))
-            self.exception_count += 1
-
-        self.running = False
-        self.duration = timer() - start_time
-        self.duration_interval_total += self.duration
-        self.logger.debug(f"Ran scheduled callback {self} in {self.duration:.2f} seconds")
-        if self.duration > self.interval.total_seconds():
-            message = f"Callback {self} took {self.duration:.4f} seconds to execute, which is longer than the interval of {self.interval.total_seconds()}s"
-            self.logger.warning(message)
-            self.status = Status(StatusValue.GENERIC_ERROR, message)
-            self.timeouts_count += 1
-        elif not failed:
-            self.ok_count += 1
-
-    def __repr__(self):
-        return f"Method={self.callback.__name__}"
-
-    def name(self):
-        return self.callback.__name__
-
-    def initial_wait_time(self) -> float:
-        if not self.running_in_sim:
-            """
-            Here we chose a random second between 1 and 59 to start the callback
-            This is to distribute load for extension running on this host
-            When running from the simulator, this is not done
-            """
-
-            now = self.get_current_time_with_cluster_diff()
-            random_second = random.randint(1, 59)  # noqa: S311
-            next_execution = datetime.now().replace(second=random_second, microsecond=0)
-            if next_execution <= now:
-                # The random chosen second already passed this minute
-                next_execution += timedelta(minutes=1)
-            wait_time = (next_execution - now).total_seconds()
-            self.logger.debug(f"Randomly choosing next execution time for callback {self} to be {next_execution}")
-            return wait_time
-        return 0
-
-    def get_adjusted_metric_timestamp(self) -> datetime:
-        """
-        Callbacks can't run all together, so they must start at random times
-        This means that when reporting metrics for a callback, we need to consider
-        the time the callback was started, instead of the current timestamp
-        this is done to avoid situations like:
-        - 14:00:55 - callback A runs
-        - 14:01:03 - 8 seconds later, a metric is reported
-        - 14:01:55 - callback A runs again (60 seconds after the first run)
-        - 14:01:58 - 3 seconds later a metric is reported
-        In this scenario a metric is reported twice in the same minute
-        This can also cause minutes where a metric is not reported at all, creating gaps
-
-        Here we calculate the metric timestamp based on the start timestamp of the callback
-        If the callback started in the last minute, we use the callback start timestamp
-        between 60 seconds and 120 seconds, we use the callback timestamp + 1 minute
-        between 120 seconds and 180 seconds, we use the callback timestamp + 2 minutes, and so forth
-        """
-        now = self.get_current_time_with_cluster_diff()
-        minutes_since_start = int((now - self.start_timestamp).total_seconds() / 60)
-        return self.start_timestamp + timedelta(minutes=minutes_since_start)
-
-    def clear_sfm_metrics(self):
-        self.ok_count = 0
-        self.timeouts_count = 0
-        self.duration_interval_total = 0
-        self.exception_count = 0
-        self.executions_per_interval = 0
+# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
+#
+# SPDX-License-Identifier: MIT
+
+import logging
+import random
+from datetime import datetime, timedelta
+from timeit import default_timer as timer
+from typing import Callable, Dict, Optional, Tuple
+
+from .activation import ActivationType
+from .communication import Status, StatusValue
+
+
+class WrappedCallback:
+    def __init__(
+        self,
+        interval: timedelta,
+        callback: Callable,
+        logger: logging.Logger,
+        args: Optional[Tuple] = None,
+        kwargs: Optional[Dict] = None,
+        running_in_sim=False,
+        activation_type: Optional[ActivationType] = None,
+    ):
+        self.callback: Callable = callback
+        if args is None:
+            args = ()
+        self.callback_args = args
+        if kwargs is None:
+            kwargs = {}
+        self.callback_kwargs = kwargs
+        self.interval: timedelta = interval
+        self.logger = logger
+        self.running: bool = False
+        self.status = Status(StatusValue.OK)
+        self.executions_total = 0  # global counter
+        self.executions_per_interval = 0  # counter per interval = 1 min by default
+        self.duration = 0  # global counter
+        self.duration_interval_total = 0  # counter per interval = 1 min by default
+        self.cluster_time_diff = 0
+        self.start_timestamp = self.get_current_time_with_cluster_diff()
+        self.running_in_sim = running_in_sim
+        self.activation_type = activation_type
+        self.ok_count = 0  # counter per interval = 1 min by default
+        self.timeouts_count = 0  # counter per interval = 1 min by default
+        self.exception_count = 0  # counter per interval = 1 min by default
+
+    def get_current_time_with_cluster_diff(self):
+        return datetime.now() + timedelta(milliseconds=self.cluster_time_diff)
+
+    def __call__(self):
+        self.logger.debug(f"Running scheduled callback {self}")
+        self.start_timestamp = self.get_current_time_with_cluster_diff()
+        self.running = True
+        self.executions_total += 1
+        self.executions_per_interval += 1
+        self.next_run = datetime.now() + self.interval
+        start_time = timer()
+        failed = False
+        try:
+            self.callback(*self.callback_args, **self.callback_kwargs)
+            self.status = Status(StatusValue.OK)
+        except Exception as e:
+            failed = True
+            self.logger.exception(f"Error running callback {self}: {e!r}")
+            self.status = Status(StatusValue.GENERIC_ERROR, repr(e))
+            self.exception_count += 1
+
+        self.running = False
+        self.duration = timer() - start_time
+        self.duration_interval_total += self.duration
+        self.logger.debug(f"Ran scheduled callback {self} in {self.duration:.2f} seconds")
+        if self.duration > self.interval.total_seconds():
+            message = f"Callback {self} took {self.duration:.4f} seconds to execute, which is longer than the interval of {self.interval.total_seconds()}s"
+            self.logger.warning(message)
+            self.status = Status(StatusValue.GENERIC_ERROR, message)
+            self.timeouts_count += 1
+        elif not failed:
+            self.ok_count += 1
+
+    def __repr__(self):
+        return f"Method={self.callback.__name__}"
+
+    def name(self):
+        return self.callback.__name__
+
+    def initial_wait_time(self) -> float:
+        if not self.running_in_sim:
+            """
+            Here we chose a random second between 1 and 59 to start the callback
+            This is to distribute load for extension running on this host
+            When running from the simulator, this is not done
+            """
+
+            now = self.get_current_time_with_cluster_diff()
+            random_second = random.randint(1, 59)  # noqa: S311
+            next_execution = datetime.now().replace(second=random_second, microsecond=0)
+            if next_execution <= now:
+                # The random chosen second already passed this minute
+                next_execution += timedelta(minutes=1)
+            wait_time = (next_execution - now).total_seconds()
+            self.logger.debug(f"Randomly choosing next execution time for callback {self} to be {next_execution}")
+            return wait_time
+        return 0
+
+    def get_adjusted_metric_timestamp(self) -> datetime:
+        """
+        Callbacks can't run all together, so they must start at random times
+        This means that when reporting metrics for a callback, we need to consider
+        the time the callback was started, instead of the current timestamp
+        this is done to avoid situations like:
+        - 14:00:55 - callback A runs
+        - 14:01:03 - 8 seconds later, a metric is reported
+        - 14:01:55 - callback A runs again (60 seconds after the first run)
+        - 14:01:58 - 3 seconds later a metric is reported
+        In this scenario a metric is reported twice in the same minute
+        This can also cause minutes where a metric is not reported at all, creating gaps
+
+        Here we calculate the metric timestamp based on the start timestamp of the callback
+        If the callback started in the last minute, we use the callback start timestamp
+        between 60 seconds and 120 seconds, we use the callback timestamp + 1 minute
+        between 120 seconds and 180 seconds, we use the callback timestamp + 2 minutes, and so forth
+        """
+        now = self.get_current_time_with_cluster_diff()
+        minutes_since_start = int((now - self.start_timestamp).total_seconds() / 60)
+        return self.start_timestamp + timedelta(minutes=minutes_since_start)
+
+    def clear_sfm_metrics(self):
+        self.ok_count = 0
+        self.timeouts_count = 0
+        self.duration_interval_total = 0
+        self.exception_count = 0
+        self.executions_per_interval = 0