dt-extensions-sdk 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

{dt_extensions_sdk-1.5.1.dist-info → dt_extensions_sdk-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dt-extensions-sdk
-Version: 1.5.1
+Version: 1.6.0
 Project-URL: Documentation, https://github.com/dynatrace-extensions/dt-extensions-python-sdk#readme
 Project-URL: Issues, https://github.com/dynatrace-extensions/dt-extensions-python-sdk/issues
 Project-URL: Source, https://github.com/dynatrace-extensions/dt-extensions-python-sdk

{dt_extensions_sdk-1.5.1.dist-info → dt_extensions_sdk-1.6.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-dynatrace_extension/__about__.py,sha256=5K7C4flDpJDmdHw8pNksZ4c9GLxQrwNkYMwLMvckJ-I,110
-dynatrace_extension/__init__.py,sha256=BvQuknmA7ti3WJi3zEXZfY7aAxJrie37VNitWICsUvI,752
+dynatrace_extension/__about__.py,sha256=ni-lNZjGGk8HaFm6WRu8u-nPm9ucCp8I4xM0ONtz83c,110
+dynatrace_extension/__init__.py,sha256=fe3nw1UVecc0cGu9R7J82V1A0n7c-Z_Z4C_LuNXU6WU,813
 dynatrace_extension/cli/__init__.py,sha256=HCboY_eJPoqjFmoPDsBL8Jk6aNvank8K7JpkVrgwzUM,123
 dynatrace_extension/cli/main.py,sha256=OTjJ4XHJvvYXj10a7WFFHVNnkyECPg1ClW6Os8piN8k,20168
 dynatrace_extension/cli/schema.py,sha256=d8wKUodRiaU3hfSZDWVNpD15lBfhmif2oQ-k07IxcaA,3230
@@ -17,20 +17,21 @@ dynatrace_extension/cli/create/extension_template/extension_name/__init__.py.tem
 dynatrace_extension/cli/create/extension_template/extension_name/__main__.py.template,sha256=cS79GVxJB-V-gocu4ZOjmZ54HXJNg89eXdLf89zDHJQ,1249
 dynatrace_extension/sdk/__init__.py,sha256=RsqQ1heGyCmSK3fhuEKAcxQIRCg4gEK0-eSkIehL5Nc,86
 dynatrace_extension/sdk/activation.py,sha256=KIoPWMZs3tKiMG8XhCfeNgRlz2vxDKcAASgSACcEfIQ,1456
-dynatrace_extension/sdk/callback.py,sha256=--GyC5aDAhgRix8QLHHvp7KjYMIECTecy9jJWX0wyj8,6488
-dynatrace_extension/sdk/communication.py,sha256=_u3VdftaI8N59Qxjtn9H0pJetWMhhrC6fNLPEixHmFw,19142
+dynatrace_extension/sdk/callback.py,sha256=K2jUacVU5FJZaeZgZPOMVLhXr_L39Sz_munYeMMm48w,6688
+dynatrace_extension/sdk/communication.py,sha256=Kbar_SpeIJInQZ8oYXhuH6ZknZX89wfHKJQ2LevhFSw,23280
 dynatrace_extension/sdk/event.py,sha256=J261imbFKpxfuAQ6Nfu3RRcsIQKKivy6fme1nww2g-8,388
-dynatrace_extension/sdk/extension.py,sha256=2mFDECsqZziYLGuxY3sYoVyWfWlhgc0ZUYwuUiXJQaA,45192
+dynatrace_extension/sdk/extension.py,sha256=WnC6VR3aixivaOgOJvokZTZEoQcEfOjelhJlH4wiuDo,48041
 dynatrace_extension/sdk/helper.py,sha256=m4gGHtIKYkfANC2MOGdxKUZlmH5tnZO6WTNqll27lyY,6476
 dynatrace_extension/sdk/metric.py,sha256=-kq7JWpk7UGvcjqafTt-o6k4urwhsGVXmnuQg7Sf9PQ,3622
 dynatrace_extension/sdk/runtime.py,sha256=7bC4gUJsVSHuL_E7r2EWrne95nm1BjZiMGkyNqA7ZCU,2796
 dynatrace_extension/sdk/snapshot.py,sha256=LnWVCtCK4NIEV3_kX-ly_LGHpNBSeErtsxCI1PH3L28,7521
+dynatrace_extension/sdk/throttled_logger.py,sha256=JXDiHh8syl8R0gJ-wfxmmBqvGCBMQX4pxPkxscaCsXo,3292
 dynatrace_extension/sdk/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dynatrace_extension/sdk/vendor/mureq/LICENSE,sha256=8AVcgZgiT_mvK1fOofXtRRr2f1dRXS_K21NuxQgP4VM,671
 dynatrace_extension/sdk/vendor/mureq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dynatrace_extension/sdk/vendor/mureq/mureq.py,sha256=znF4mvzk5L03CLNozRz8UpK-fMijmSkObDFwlbhwLUg,14656
-dt_extensions_sdk-1.5.1.dist-info/METADATA,sha256=ItVzENof2_FYkmDls53v9pCU8hexGrmaQDRkPc2BBuE,2721
-dt_extensions_sdk-1.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dt_extensions_sdk-1.5.1.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
-dt_extensions_sdk-1.5.1.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
-dt_extensions_sdk-1.5.1.dist-info/RECORD,,
+dt_extensions_sdk-1.6.0.dist-info/METADATA,sha256=ckrExeLigD1EqXceNjdUAsvIurRkCL9ziupMsXsl_QY,2721
+dt_extensions_sdk-1.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dt_extensions_sdk-1.6.0.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
+dt_extensions_sdk-1.6.0.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
+dt_extensions_sdk-1.6.0.dist-info/RECORD,,

dynatrace_extension/__about__.py

@@ -3,4 +3,4 @@
 # SPDX-License-Identifier: MIT
 
 
-__version__ = "1.5.1"
+__version__ = "1.6.0"

dynatrace_extension/__init__.py

@@ -6,7 +6,7 @@
 # ruff: noqa: F401
 
 from .sdk.activation import ActivationConfig, ActivationType
-from .sdk.communication import Status, StatusValue
+from .sdk.communication import EndpointStatus, EndpointStatuses, IgnoreStatus, MultiStatus, Status, StatusValue
 from .sdk.event import Severity
 from .sdk.extension import DtEventType, Extension
 from .sdk.helper import (

dynatrace_extension/sdk/callback.py

@@ -9,7 +9,7 @@ from datetime import datetime, timedelta
 from timeit import default_timer as timer
 
 from .activation import ActivationType
-from .communication import MultiStatus, Status, StatusValue
+from .communication import EndpointStatuses, IgnoreStatus, MultiStatus, Status, StatusValue
 
 
 class WrappedCallback:
@@ -65,6 +65,10 @@ class WrappedCallback:
                 self.status = ret
             elif isinstance(ret, MultiStatus):
                 self.status = ret.build()
+            elif isinstance(ret, EndpointStatuses):
+                self.status = ret
+            elif isinstance(ret, IgnoreStatus):
+                self.status = ret
             else:
                 self.status = Status(StatusValue.OK)
         except Exception as e:

dynatrace_extension/sdk/communication.py

@@ -12,6 +12,7 @@ from collections.abc import Generator, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
+from threading import RLock
 from typing import Any, TypeVar
 
 from .vendor.mureq.mureq import HTTPException, Response, request
@@ -38,9 +39,14 @@ class StatusValue(Enum):
     INVALID_CONFIG_ERROR = "INVALID_CONFIG_ERROR"
     AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR"
     DEVICE_CONNECTION_ERROR = "DEVICE_CONNECTION_ERROR"
+    WARNING = "WARNING"
     UNKNOWN_ERROR = "UNKNOWN_ERROR"
 
 
+class IgnoreStatus:
+    pass
+
+
 class Status:
     def __init__(self, status: StatusValue = StatusValue.EMPTY, message: str = "", timestamp: int | None = None):
         self.status = status
@@ -57,12 +63,16 @@ class Status:
         return json.dumps(self.to_json())
 
     def is_error(self) -> bool:
+        # WARNING is treated as an error
         return self.status not in (StatusValue.OK, StatusValue.EMPTY)
 
+    def is_warning(self) -> bool:
+        return self.status == StatusValue.WARNING
+
 
 class MultiStatus:
     def __init__(self):
-        self.statuses = []
+        self.statuses: list[Status] = []
 
     def add_status(self, status: StatusValue, message):
         self.statuses.append(Status(status, message))
@@ -73,15 +83,120 @@ class MultiStatus:
             return ret
 
         messages = []
+        all_ok = True
+        all_err = True
+        any_warning = False
+
         for stored_status in self.statuses:
-            print(stored_status)  # noqa: T201
+            if stored_status.message != "":
+                messages.append(stored_status.message)
+
+            if stored_status.is_warning():
+                any_warning = True
+
             if stored_status.is_error():
-                ret.status = stored_status.status
-            messages.append(stored_status.message)
-        ret.message = "\n".join(messages)
+                all_ok = False
+            else:
+                all_err = False
+
+        ret.message = ", ".join(messages)
+
+        if any_warning:
+            ret.status = StatusValue.WARNING
+        elif all_ok:
+            ret.status = StatusValue.OK
+        elif all_err:
+            ret.status = StatusValue.GENERIC_ERROR
+        else:
+            ret.status = StatusValue.WARNING
+
         return ret
 
 
+class EndpointStatus:
+    def __init__(self, endpoint_hint: str, short_status: StatusValue, message: str):
+        self.endpoint = endpoint_hint
+        self.status: StatusValue = short_status
+        self.message = message
+
+    def __str__(self):
+        return str(self.__dict__)
+
+
+class EndpointStatuses:
+    class TooManyEndpointStatusesError(Exception):
+        pass
+
+    class MergeConflictError(Exception):
+        def __init__(self, first: EndpointStatus, second: EndpointStatus):
+            super().__init__(f"Endpoint Statuses conflict while merging - first: {first}; second: {second}")
+
+    def __init__(self, total_endpoints_number: int):
+        self._lock = RLock()
+        self._faulty_endpoints: dict[str, EndpointStatus] = {}
+        self._num_endpoints = total_endpoints_number
+
+    def add_endpoint_status(self, status: EndpointStatus):
+        with self._lock:
+            if status.status == StatusValue.OK:
+                self.clear_endpoint_error(status.endpoint)
+            else:
+                if len(self._faulty_endpoints) == self._num_endpoints:
+                    message = "Cannot add another endpoint status. \
+                    The number of reported statuses already has reached preconfigured maximum of {self._num_endpoints} endpoints."
+                    raise EndpointStatuses.TooManyEndpointStatusesError(message)
+
+                self._faulty_endpoints[status.endpoint] = status
+
+    def clear_endpoint_error(self, endpoint_hint: str):
+        with self._lock:
+            try:
+                del self._faulty_endpoints[endpoint_hint]
+            except KeyError:
+                pass
+
+    def merge(self, other: EndpointStatuses):
+        with self._lock:
+            with other._lock:
+                self._num_endpoints += other._num_endpoints
+
+                for endpoint, status in other._faulty_endpoints.items():
+                    if endpoint not in self._faulty_endpoints.keys():
+                        self._faulty_endpoints[endpoint] = status
+                    else:
+                        self._num_endpoints -= 1
+                        raise EndpointStatuses.MergeConflictError(
+                            self._faulty_endpoints[endpoint], other._faulty_endpoints[endpoint]
+                        )
+
+    def build_common_status(self) -> Status:
+        with self._lock:
+            ok_count = self._num_endpoints - len(self._faulty_endpoints)
+            nok_count = len(self._faulty_endpoints)
+
+            if nok_count == 0:
+                return Status(StatusValue.OK, f"Endpoints OK: {self._num_endpoints} NOK: 0")
+
+            error_messages = []
+            for ep_status in self._faulty_endpoints.values():
+                error_messages.append(f"{ep_status.endpoint} - {ep_status.status.value} {ep_status.message}")
+            common_msg = ", ".join(error_messages)
+
+            # Determine status value
+            all_endpoints_faulty = nok_count == self._num_endpoints
+            has_warning_status = StatusValue.WARNING in [
+                ep_status.status for ep_status in self._faulty_endpoints.values()
+            ]
+
+            if all_endpoints_faulty and not has_warning_status:
+                status_value = StatusValue.GENERIC_ERROR
+            else:
+                status_value = StatusValue.WARNING
+
+            message = f"Endpoints OK: {ok_count} NOK: {nok_count} NOK_reported_errors: {common_msg}"
+            return Status(status=status_value, message=message)
+
+
 class CommunicationClient(ABC):
     """
     Abstract class for extension communication

dynatrace_extension/sdk/extension.py

@@ -20,11 +20,20 @@ from typing import Any, ClassVar, NamedTuple
 
 from .activation import ActivationConfig, ActivationType
 from .callback import WrappedCallback
-from .communication import CommunicationClient, DebugClient, HttpClient, Status, StatusValue
+from .communication import (
+    CommunicationClient,
+    DebugClient,
+    EndpointStatuses,
+    HttpClient,
+    IgnoreStatus,
+    Status,
+    StatusValue,
+)
 from .event import Severity
 from .metric import Metric, MetricType, SfmMetric, SummaryStat
 from .runtime import RuntimeProperties
 from .snapshot import Snapshot
+from .throttled_logger import StrictThrottledHandler, ThrottledHandler
 
 HEARTBEAT_INTERVAL = timedelta(seconds=50)
 METRIC_SENDING_INTERVAL = timedelta(seconds=30)
@@ -51,6 +60,33 @@ extension_logger.setLevel(logging.INFO)
 extension_logger.addHandler(error_handler)
 extension_logger.addHandler(std_handler)
 
+throttled_err_handler = ThrottledHandler(sys.stderr)
+throttled_err_handler.addFilter(lambda record: record.levelno >= logging.ERROR)
+throttled_err_handler.setFormatter(formatter)
+
+throttled_std_handler = ThrottledHandler(sys.stdout)
+throttled_std_handler.addFilter(lambda record: record.levelno < logging.ERROR)
+throttled_std_handler.setFormatter(formatter)
+
+throttled_logger = logging.getLogger(f"THROTTLED_{__name__}")
+throttled_logger.setLevel(logging.INFO)
+throttled_logger.addHandler(throttled_err_handler)
+throttled_logger.addHandler(throttled_std_handler)
+
+strict_throttled_err_handler = StrictThrottledHandler(sys.stderr)
+strict_throttled_err_handler.addFilter(lambda record: record.levelno >= logging.ERROR)
+strict_throttled_err_handler.setFormatter(formatter)
+
+strict_throttled_std_handler = StrictThrottledHandler(sys.stdout)
+strict_throttled_std_handler.addFilter(lambda record: record.levelno < logging.ERROR)
+strict_throttled_std_handler.setFormatter(formatter)
+
+strict_throttled_logger = logging.getLogger(f"STRICT_THROTTLED_{__name__}")
+strict_throttled_logger.setLevel(logging.INFO)
+strict_throttled_logger.addHandler(strict_throttled_err_handler)
+strict_throttled_logger.addHandler(strict_throttled_std_handler)
+
+
 api_logger = logging.getLogger("api")
 api_logger.setLevel(logging.INFO)
 api_logger.addHandler(error_handler)
@@ -164,6 +200,8 @@ class Extension:
             return
 
         self.logger = extension_logger
+        self.throttled_logger = throttled_logger
+        self.strict_throttled_logger = strict_throttled_logger
         self.logger.name = name
 
         self.extension_config: str = ""
@@ -380,7 +418,7 @@ class Extension:
         Optional method that can be implemented by subclasses.
         The query method is always scheduled to run every minute.
         """
-        pass
+        return IgnoreStatus()
 
     def initialize(self):
         """Callback to be executed when the extension starts.
@@ -458,10 +496,10 @@ class Extension:
         key: str,
         value: float | str | int | SummaryStat,
         dimensions: dict[str, str] | None = None,
-        device_address: str | None = None,
         techrule: str | None = None,
         timestamp: datetime | None = None,
         metric_type: MetricType = MetricType.GAUGE,
+        device_address: str | None = None,
     ) -> None:
         """Report a metric.
 
@@ -980,33 +1018,77 @@ class Extension:
                 )
 
     def _build_current_status(self):
-        overall_status = Status(StatusValue.OK)
-
         if self._initialization_error:
-            overall_status.status = StatusValue.GENERIC_ERROR
-            overall_status.message = self._initialization_error
-            return overall_status
+            return Status(StatusValue.OK, self._initialization_error)
 
-        internal_callback_error = False
         messages = []
+
+        # Check for internal errors
         with self._internal_callbacks_results_lock:
+            overall_status_value = Status(StatusValue.OK)
+            internal_callback_error = False
+
             for callback, result in self._internal_callbacks_results.items():
                 if result.is_error():
                     internal_callback_error = True
-                    overall_status.status = result.status
-                    messages.append(f"{callback}: {result.message}")
+                    overall_status_value = result.status
+                    messages.append(f"{callback}: {result.status} - {result.message}")
+
             if internal_callback_error:
-                overall_status.message = "\n".join(messages)
-                return overall_status
+                return Status(overall_status_value, "\n".join(messages))
+
+        # Handle regular statuses, merge all EndpointStatuses
+        ep_status_merged = EndpointStatuses(0)
+        all_ok = True
+        all_err = True
+        any_warning = False
 
         for callback in self._scheduled_callbacks:
-            if callback.status.is_error():
-                overall_status.status = callback.status.status
-                messages.append(f"{callback}: {callback.status.message}")
+            if isinstance(callback.status, IgnoreStatus):
+                continue
+
+            if isinstance(callback.status, EndpointStatuses):
+                try:
+                    ep_status_merged.merge(callback.status)
+                except EndpointStatuses.MergeConflictError as e:
+                    self.logger.exception(e)
                 continue
-            if callback.status.message is not None and callback.status.message != "":
-                messages.append(f"{callback}: {callback.status.message}")
-        overall_status.message = "\n".join(messages)
+
+            if callback.status.is_warning():
+                any_warning = True
+
+            if callback.status.is_error():
+                all_ok = False
+            else:
+                all_err = False
+
+            if callback.status.is_error() or (callback.status.message is not None and callback.status.message != ""):
+                messages.append(f"{callback.name()}: {callback.status.status.value} - {callback.status.message}")
+
+        # Handle merged EndpointStatuses
+        if ep_status_merged._num_endpoints > 0:
+            ep_status_merged = ep_status_merged.build_common_status()
+            messages.insert(0, ep_status_merged.message)
+
+            if ep_status_merged.is_warning():
+                any_warning = True
+
+            if ep_status_merged.is_error():
+                all_ok = False
+            else:
+                all_err = False
+
+        # Build overall status
+        overall_status = Status(StatusValue.OK, "\n".join(messages))
+        if any_warning:
+            overall_status.status = StatusValue.WARNING
+        elif all_ok:
+            overall_status.status = StatusValue.OK
+        elif all_err:
+            overall_status.status = StatusValue.GENERIC_ERROR
+        else:
+            overall_status.status = StatusValue.WARNING
+
         return overall_status
 
     def _update_cluster_time_diff(self):

dynatrace_extension/sdk/throttled_logger.py

@@ -0,0 +1,68 @@
+import logging
+import threading
+import time
+
+
+class ThrottledHandler(logging.StreamHandler):
+    def __init__(self, stream, log_repeat_interval=3600, cache_clean_interval=3600):
+        super().__init__(stream)
+        self.record_to_last_print_time = {}
+        self.log_repeat_interval = log_repeat_interval
+        self.record_cache_last_clean_timestamp = time.time()
+        self.record_cache_clean_interval = cache_clean_interval
+        self.record_cache_clean_lock = threading.Lock()
+
+    def emit(self, record):
+        current_time = time.time()
+        if record.msg not in self.record_to_last_print_time.keys():
+            super().emit(record)
+            self.record_to_last_print_time[record.msg] = current_time
+            return
+        last_print_time = self.record_to_last_print_time[record.msg]
+        if (last_print_time - current_time) > self.log_repeat_interval:
+            self.record_to_last_print_time[record.msg] = current_time
+            super().emit(record)
+        self.cleanup(current_time)
+
+    def cleanup(self, current_time):
+        if (self.record_cache_last_clean_timestamp - current_time) > self.record_cache_clean_interval:
+            with self.record_cache_clean_lock:
+                keys_to_remove = []
+                for record_message, last_print_time in self.record_to_last_print_time.items():
+                    if (current_time - last_print_time) > self.log_repeat_interval:
+                        keys_to_remove.append(record_message)
+                for key in keys_to_remove:
+                    del self.record_to_last_print_time[key]
+
+
+class StrictThrottledHandler(logging.StreamHandler):
+    def __init__(self, stream, log_repeat_interval=3600, cache_clean_interval=3600):
+        super().__init__(stream)
+        self.record_to_last_print_time = {}
+        self.log_repeat_interval = log_repeat_interval
+        self.record_cache_last_clean_timestamp = time.time()
+        self.record_cache_clean_interval = cache_clean_interval
+        self.record_cache_clean_lock = threading.Lock()
+
+    def emit(self, record):
+        current_time = time.time()
+        log_identifier = f"{record.filename}:{record.lineno}"
+        if log_identifier not in self.record_to_last_print_time.keys():
+            super().emit(record)
+            self.record_to_last_print_time[log_identifier] = current_time
+            return
+        last_print_time = self.record_to_last_print_time[log_identifier]
+        if (last_print_time - current_time) > self.log_repeat_interval:
+            self.record_to_last_print_time[log_identifier] = current_time
+            super().emit(record)
+        self.cleanup(current_time)
+
+    def cleanup(self, current_time):
+        if (self.record_cache_last_clean_timestamp - current_time) > self.record_cache_clean_interval:
+            with self.record_cache_clean_lock:
+                keys_to_remove = []
+                for record_message, last_print_time in self.record_to_last_print_time.items():
+                    if (current_time - last_print_time) > self.log_repeat_interval:
+                        keys_to_remove.append(record_message)
+                for key in keys_to_remove:
+                    del self.record_to_last_print_time[key]