dt-extensions-sdk 1.1.21__py3-none-any.whl → 1.1.23__py3-none-any.whl

dynatrace_extension/sdk/helper.py

@@ -1,191 +1,191 @@
-# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
-#
-# SPDX-License-Identifier: MIT
-
-from datetime import datetime, timedelta
-from typing import Callable, Dict, List, Optional, Union
-
-from .activation import ActivationConfig, ActivationType
-from .communication import Status
-from .event import Severity
-from .extension import DtEventType, Extension
-from .metric import MetricType, SummaryStat
-
-
-class _HelperExtension(Extension):
-    @property
-    def is_helper(self) -> bool:
-        return True
-
-
-def report_metric(
-    key: str,
-    value: Union[float, str, int, SummaryStat],
-    dimensions: Optional[Dict[str, str]] = None,
-    techrule: Optional[str] = None,
-    timestamp: Optional[datetime] = None,
-    metric_type: MetricType = MetricType.GAUGE,
-) -> None:
-    """Reports a metric using the MINT protocol
-    By default, it reports a gauge metric
-
-
-    :param key: The metric key, must follow the MINT specification
-    :param value: The metric value, can be a simple value or a SummaryStat
-    :param dimensions: A dictionary of dimensions
-    :param techrule: The techrule of the metric, defaults to None
-    :param timestamp: The timestamp of the metric, defaults to the current time
-    :param metric_type: The type of the metric, defaults to MetricType.GAUGE
-    """
-    _HelperExtension().report_metric(key, value, dimensions, techrule, timestamp, metric_type)
-
-
-def report_mint_lines(lines: List[str]) -> None:
-    """Reports mint lines using the MINT protocol.
-    These lines are not validated before being sent.
-
-    :param lines: A list of mint lines, example: ["my_metric 1", "my_other_metric 2"]
-    """
-    _HelperExtension().report_mint_lines(lines)
-
-
-def report_dt_event(
-    event_type: DtEventType,
-    title: str,
-    start_time: Optional[int] = None,
-    end_time: Optional[int] = None,
-    timeout: Optional[int] = None,
-    entity_selector: Optional[str] = None,
-    properties: Optional[dict[str, str]] = None,
-) -> None:
-    """
-    Reports a custom event v2 using event ingest
-
-    For reference see: https://www.dynatrace.com/support/help/dynatrace-api/environment-api/events-v2/post-event
-
-    :param event_type: The event type chosen from type Enum (required)
-    :param title: The title of the event (required)
-    :param start_time: The start time of event in UTC ms, if not set, current timestamp (optional)
-    :param end_time: The end time of event in UTC ms, if not set, current timestamp + timeout (optional)
-    :param timeout: The timeout of event in minutes, if not set, 15 (optional)
-    :param entity_selector: The entity selector, if not set, the event is associated with environment entity (optional)
-    :param properties: A map of event properties (optional)
-    """
-    _HelperExtension().report_dt_event(event_type, title, start_time, end_time, timeout, entity_selector, properties)
-
-
-def report_dt_event_dict(event: dict):
-    """
-    Reports a custom event v2 using event ingest using provided dictionary resembling required json
-
-    For reference see: https://www.dynatrace.com/support/help/dynatrace-api/environment-api/events-v2/post-event
-    """
-    _HelperExtension().report_dt_event_dict(event)
-
-
-def schedule(
-    callback: Callable,
-    interval: Union[timedelta, int],
-    args: Optional[tuple] = None,
-    activation_type: Optional[ActivationType] = None,
-) -> None:
-    """Schedules a callback to be called periodically
-
-    :param callback: The callback to be called
-    :param interval: The time interval between invocations, can be a timedelta object, or an int representing the number of seconds
-    :param args: Arguments to the callback, if any
-    :param activation_type: Optional activation type when this callback should run, can be 'ActivationType.LOCAL' or 'ActivationType.REMOTE'
-
-    """
-    _HelperExtension().schedule(callback, interval, args, activation_type)
-
-
-def schedule_function(
-    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
-):
-    def decorator(function):
-        schedule(function, interval, args=args, activation_type=activation_type)
-
-    return decorator
-
-
-def schedule_method(
-    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
-):
-    def decorator(function):
-        Extension.schedule_decorators.append((function, interval, args, activation_type))
-
-    return decorator
-
-
-def report_event(
-    title: str,
-    description: str,
-    properties: Optional[dict] = None,
-    timestamp: Optional[datetime] = None,
-    severity: Union[Severity, str] = Severity.INFO,
-) -> None:
-    """Reports an event using the MINT protocol
-
-    :param title: The title of the event
-    :param description: The description of the event
-    :param properties: A dictionary of properties
-    :param timestamp: The timestamp of the event, defaults to the current time
-    :param severity: The severity of the event, defaults to Severity.INFO
-    """
-    _HelperExtension().report_event(title, description, properties, timestamp, severity)
-
-
-def report_log_event(log_event: dict):
-    """Reports a custom log event using log ingest
-
-    :param log_event: The log event dictionary, reference: https://www.dynatrace.com/support/help/shortlink/log-monitoring-log-data-ingestion
-    """
-    _HelperExtension().report_log_event(log_event)
-
-
-def report_log_events(log_events: List[dict]):
-    """Reports a list of custom log events using log ingest
-
-    :param log_events: The list of log events
-    """
-    _HelperExtension().report_log_events(log_events)
-
-
-def report_log_lines(log_lines: List[Union[str, bytes]]):
-    """Reports a list of log lines using log ingest
-
-    :param log_lines: The list of log lines
-    """
-    _HelperExtension().report_log_lines(log_lines)
-
-
-def run_extension():
-    """Starts the extension loop"""
-    _HelperExtension().run()
-
-
-def get_activation_config():
-    return _HelperExtension().get_activation_config()
-
-
-def get_helper_extension():
-    return _HelperExtension()
-
-
-def dt_fastcheck():
-    def wrapper(fast_check_callback: Callable[[ActivationConfig, str], Status]):
-        _HelperExtension().register_fastcheck(fast_check_callback=fast_check_callback)
-
-    return wrapper
-
-
-def log(message: str, severity: Severity):
-    """
-    Logs provided message into the extension's log file.
-    Only two severities are supported: INFO and ERROR
-    """
-    if severity == Severity.INFO:
-        _HelperExtension().logger.info(message)
-    elif severity == Severity.ERROR:
-        _HelperExtension().logger.error(message)
+# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
+#
+# SPDX-License-Identifier: MIT
+
+from datetime import datetime, timedelta
+from typing import Callable, Dict, List, Optional, Union
+
+from .activation import ActivationConfig, ActivationType
+from .communication import Status
+from .event import Severity
+from .extension import DtEventType, Extension
+from .metric import MetricType, SummaryStat
+
+
+class _HelperExtension(Extension):
+    @property
+    def is_helper(self) -> bool:
+        return True
+
+
+def report_metric(
+    key: str,
+    value: Union[float, str, int, SummaryStat],
+    dimensions: Optional[Dict[str, str]] = None,
+    techrule: Optional[str] = None,
+    timestamp: Optional[datetime] = None,
+    metric_type: MetricType = MetricType.GAUGE,
+) -> None:
+    """Reports a metric using the MINT protocol
+    By default, it reports a gauge metric
+
+
+    :param key: The metric key, must follow the MINT specification
+    :param value: The metric value, can be a simple value or a SummaryStat
+    :param dimensions: A dictionary of dimensions
+    :param techrule: The techrule of the metric, defaults to None
+    :param timestamp: The timestamp of the metric, defaults to the current time
+    :param metric_type: The type of the metric, defaults to MetricType.GAUGE
+    """
+    _HelperExtension().report_metric(key, value, dimensions, techrule, timestamp, metric_type)
+
+
+def report_mint_lines(lines: List[str]) -> None:
+    """Reports mint lines using the MINT protocol.
+    These lines are not validated before being sent.
+
+    :param lines: A list of mint lines, example: ["my_metric 1", "my_other_metric 2"]
+    """
+    _HelperExtension().report_mint_lines(lines)
+
+
+def report_dt_event(
+    event_type: DtEventType,
+    title: str,
+    start_time: Optional[int] = None,
+    end_time: Optional[int] = None,
+    timeout: Optional[int] = None,
+    entity_selector: Optional[str] = None,
+    properties: Optional[dict[str, str]] = None,
+) -> None:
+    """
+    Reports a custom event v2 using event ingest
+
+    For reference see: https://www.dynatrace.com/support/help/dynatrace-api/environment-api/events-v2/post-event
+
+    :param event_type: The event type chosen from type Enum (required)
+    :param title: The title of the event (required)
+    :param start_time: The start time of event in UTC ms, if not set, current timestamp (optional)
+    :param end_time: The end time of event in UTC ms, if not set, current timestamp + timeout (optional)
+    :param timeout: The timeout of event in minutes, if not set, 15 (optional)
+    :param entity_selector: The entity selector, if not set, the event is associated with environment entity (optional)
+    :param properties: A map of event properties (optional)
+    """
+    _HelperExtension().report_dt_event(event_type, title, start_time, end_time, timeout, entity_selector, properties)
+
+
+def report_dt_event_dict(event: dict):
+    """
+    Reports a custom event v2 using event ingest using provided dictionary resembling required json
+
+    For reference see: https://www.dynatrace.com/support/help/dynatrace-api/environment-api/events-v2/post-event
+    """
+    _HelperExtension().report_dt_event_dict(event)
+
+
+def schedule(
+    callback: Callable,
+    interval: Union[timedelta, int],
+    args: Optional[tuple] = None,
+    activation_type: Optional[ActivationType] = None,
+) -> None:
+    """Schedules a callback to be called periodically
+
+    :param callback: The callback to be called
+    :param interval: The time interval between invocations, can be a timedelta object, or an int representing the number of seconds
+    :param args: Arguments to the callback, if any
+    :param activation_type: Optional activation type when this callback should run, can be 'ActivationType.LOCAL' or 'ActivationType.REMOTE'
+
+    """
+    _HelperExtension().schedule(callback, interval, args, activation_type)
+
+
+def schedule_function(
+    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
+):
+    def decorator(function):
+        schedule(function, interval, args=args, activation_type=activation_type)
+
+    return decorator
+
+
+def schedule_method(
+    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
+):
+    def decorator(function):
+        Extension.schedule_decorators.append((function, interval, args, activation_type))
+
+    return decorator
+
+
+def report_event(
+    title: str,
+    description: str,
+    properties: Optional[dict] = None,
+    timestamp: Optional[datetime] = None,
+    severity: Union[Severity, str] = Severity.INFO,
+) -> None:
+    """Reports an event using the MINT protocol
+
+    :param title: The title of the event
+    :param description: The description of the event
+    :param properties: A dictionary of properties
+    :param timestamp: The timestamp of the event, defaults to the current time
+    :param severity: The severity of the event, defaults to Severity.INFO
+    """
+    _HelperExtension().report_event(title, description, properties, timestamp, severity)
+
+
+def report_log_event(log_event: dict):
+    """Reports a custom log event using log ingest
+
+    :param log_event: The log event dictionary, reference: https://www.dynatrace.com/support/help/shortlink/log-monitoring-log-data-ingestion
+    """
+    _HelperExtension().report_log_event(log_event)
+
+
+def report_log_events(log_events: List[dict]):
+    """Reports a list of custom log events using log ingest
+
+    :param log_events: The list of log events
+    """
+    _HelperExtension().report_log_events(log_events)
+
+
+def report_log_lines(log_lines: List[Union[str, bytes]]):
+    """Reports a list of log lines using log ingest
+
+    :param log_lines: The list of log lines
+    """
+    _HelperExtension().report_log_lines(log_lines)
+
+
+def run_extension():
+    """Starts the extension loop"""
+    _HelperExtension().run()
+
+
+def get_activation_config():
+    return _HelperExtension().get_activation_config()
+
+
+def get_helper_extension():
+    return _HelperExtension()
+
+
+def dt_fastcheck():
+    def wrapper(fast_check_callback: Callable[[ActivationConfig, str], Status]):
+        _HelperExtension().register_fastcheck(fast_check_callback=fast_check_callback)
+
+    return wrapper
+
+
+def log(message: str, severity: Severity):
+    """
+    Logs provided message into the extension's log file.
+    Only two severities are supported: INFO and ERROR
+    """
+    if severity == Severity.INFO:
+        _HelperExtension().logger.info(message)
+    elif severity == Severity.ERROR:
+        _HelperExtension().logger.error(message)

dynatrace_extension/sdk/metric.py

@@ -1,118 +1,118 @@
-# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
-#
-# SPDX-License-Identifier: MIT
-
-from datetime import datetime
-from enum import Enum
-from typing import Dict, Optional, Union
-
-# https://bitbucket.lab.dynatrace.org/projects/ONE/repos/schemaless-metrics-spec/browse/limits.md
-LIMIT_DIMENSIONS_COUNT = 50
-LIMIT_LINE_LENGTH = 2000
-
-CLIENT_FACING_SFM_NAMESPACE = "dsfm"
-INTERNAL_SFM_NAMESPACE = "isfm"
-
-
-class SummaryStat:
-    def __init__(
-        self,
-        value_min: float,
-        value_max: float,
-        value_sum: float,
-        value_count: float,
-    ):
-        self.value_min = value_min
-        self.value_max = value_max
-        self.value_sum = value_sum
-        self.value_count = value_count
-
-    def __str__(self):
-        return f"min={self.value_min},max={self.value_max},sum={self.value_sum},count={self.value_count}"
-
-
-class MetricType(Enum):
-    GAUGE = "gauge"
-    COUNT = "count"
-    DELTA = "count,delta"
-
-
-class Metric:
-    def __init__(
-        self,
-        key: str,
-        value: Union[float, int, str, SummaryStat],
-        dimensions: Optional[Dict[str, str]] = None,
-        metric_type: MetricType = MetricType.GAUGE,
-        timestamp: Optional[datetime] = None,
-    ):
-        self.key: str = key
-        self.value: Union[float, int, str, SummaryStat] = value
-        if dimensions is None:
-            dimensions = {}
-        self.dimensions: Dict[str, str] = dimensions
-        self.metric_type: MetricType = metric_type
-        self.timestamp: Optional[datetime] = timestamp
-
-    def __hash__(self):
-        return hash(self._key_and_dimensions())
-
-    def __eq__(self, other):
-        return self._key_and_dimensions() == other._key_and_dimensions()
-
-    def to_mint_line(self) -> str:
-        # Add key and dimensions
-        line = f"{self._key_and_dimensions()}"
-
-        # Add value
-        if self.metric_type == MetricType.DELTA:
-            line = f"{line} {self.metric_type.value}={self.value}"
-        else:
-            line = f"{line} {self.metric_type.value},{self.value}"
-
-        # Add timestamp
-        if self.timestamp is not None:
-            timestamp = int(self.timestamp.timestamp() * 1000)
-            line = f"{line} {timestamp}"
-
-        return line
-
-    def __repr__(self):
-        return self.to_mint_line()
-
-    def _key_and_dimensions(self):
-        if not self.dimensions:
-            return f"{self.key}"
-
-        dimensions_string = ",".join([f'{k}="{v}"' for k, v in self.dimensions.items()])
-        return f"{self.key},{dimensions_string}"
-
-    def validate(self) -> bool:
-        if len(self.dimensions) > LIMIT_DIMENSIONS_COUNT:
-            msg = f"Metric dimension count of {len(self.dimensions)} exceeds limit of {LIMIT_DIMENSIONS_COUNT} for {self.key}"
-            raise ValueError(msg)
-
-        line_length = len(self.to_mint_line())
-        if line_length > LIMIT_LINE_LENGTH:
-            msg = f"Metric line length {line_length} exceeds limit of {LIMIT_LINE_LENGTH} for {self.key}"
-            raise ValueError(msg)
-        return True
-
-
-class SfmMetric(Metric):
-    def __init__(
-        self,
-        key: str,
-        value: Union[float, int, str, SummaryStat],
-        dimensions: Optional[Dict[str, str]] = None,
-        metric_type: MetricType = MetricType.GAUGE,
-        timestamp: Optional[datetime] = None,
-        client_facing: bool = False,
-    ):
-        key = create_sfm_metric_key(key, client_facing)
-        super().__init__(key, value, dimensions, metric_type, timestamp)
-
-
-def create_sfm_metric_key(key: str, client_facing: bool = False) -> str:
-    namespace = CLIENT_FACING_SFM_NAMESPACE if client_facing else INTERNAL_SFM_NAMESPACE
-    return f"{namespace}:datasource.python.{key}"
+# SPDX-FileCopyrightText: 2023-present Dynatrace LLC
+#
+# SPDX-License-Identifier: MIT
+
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Optional, Union
+
+# https://bitbucket.lab.dynatrace.org/projects/ONE/repos/schemaless-metrics-spec/browse/limits.md
+LIMIT_DIMENSIONS_COUNT = 50
+LIMIT_LINE_LENGTH = 2000
+
+CLIENT_FACING_SFM_NAMESPACE = "dsfm"
+INTERNAL_SFM_NAMESPACE = "isfm"
+
+
+class SummaryStat:
+    def __init__(
+        self,
+        value_min: float,
+        value_max: float,
+        value_sum: float,
+        value_count: float,
+    ):
+        self.value_min = value_min
+        self.value_max = value_max
+        self.value_sum = value_sum
+        self.value_count = value_count
+
+    def __str__(self):
+        return f"min={self.value_min},max={self.value_max},sum={self.value_sum},count={self.value_count}"
+
+
+class MetricType(Enum):
+    GAUGE = "gauge"
+    COUNT = "count"
+    DELTA = "count,delta"
+
+
+class Metric:
+    def __init__(
+        self,
+        key: str,
+        value: Union[float, int, str, SummaryStat],
+        dimensions: Optional[Dict[str, str]] = None,
+        metric_type: MetricType = MetricType.GAUGE,
+        timestamp: Optional[datetime] = None,
+    ):
+        self.key: str = key
+        self.value: Union[float, int, str, SummaryStat] = value
+        if dimensions is None:
+            dimensions = {}
+        self.dimensions: Dict[str, str] = dimensions
+        self.metric_type: MetricType = metric_type
+        self.timestamp: Optional[datetime] = timestamp
+
+    def __hash__(self):
+        return hash(self._key_and_dimensions())
+
+    def __eq__(self, other):
+        return self._key_and_dimensions() == other._key_and_dimensions()
+
+    def to_mint_line(self) -> str:
+        # Add key and dimensions
+        line = f"{self._key_and_dimensions()}"
+
+        # Add value
+        if self.metric_type == MetricType.DELTA:
+            line = f"{line} {self.metric_type.value}={self.value}"
+        else:
+            line = f"{line} {self.metric_type.value},{self.value}"
+
+        # Add timestamp
+        if self.timestamp is not None:
+            timestamp = int(self.timestamp.timestamp() * 1000)
+            line = f"{line} {timestamp}"
+
+        return line
+
+    def __repr__(self):
+        return self.to_mint_line()
+
+    def _key_and_dimensions(self):
+        if not self.dimensions:
+            return f"{self.key}"
+
+        dimensions_string = ",".join([f'{k}="{v}"' for k, v in self.dimensions.items()])
+        return f"{self.key},{dimensions_string}"
+
+    def validate(self) -> bool:
+        if len(self.dimensions) > LIMIT_DIMENSIONS_COUNT:
+            msg = f"Metric dimension count of {len(self.dimensions)} exceeds limit of {LIMIT_DIMENSIONS_COUNT} for {self.key}"
+            raise ValueError(msg)
+
+        line_length = len(self.to_mint_line())
+        if line_length > LIMIT_LINE_LENGTH:
+            msg = f"Metric line length {line_length} exceeds limit of {LIMIT_LINE_LENGTH} for {self.key}"
+            raise ValueError(msg)
+        return True
+
+
+class SfmMetric(Metric):
+    def __init__(
+        self,
+        key: str,
+        value: Union[float, int, str, SummaryStat],
+        dimensions: Optional[Dict[str, str]] = None,
+        metric_type: MetricType = MetricType.GAUGE,
+        timestamp: Optional[datetime] = None,
+        client_facing: bool = False,
+    ):
+        key = create_sfm_metric_key(key, client_facing)
+        super().__init__(key, value, dimensions, metric_type, timestamp)
+
+
+def create_sfm_metric_key(key: str, client_facing: bool = False) -> str:
+    namespace = CLIENT_FACING_SFM_NAMESPACE if client_facing else INTERNAL_SFM_NAMESPACE
+    return f"{namespace}:datasource.python.{key}"