dt-extensions-sdk 1.6.2__py3-none-any.whl → 1.7.1__py3-none-any.whl

{dt_extensions_sdk-1.6.2.dist-info → dt_extensions_sdk-1.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dt-extensions-sdk
-Version: 1.6.2
+Version: 1.7.1
 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.6.2.dist-info → dt_extensions_sdk-1.7.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-dynatrace_extension/__about__.py,sha256=uZeHsX4wU-dHKHK20ZzwGRiucP5EB7Tc5e3tA3HD7_4,110
-dynatrace_extension/__init__.py,sha256=fe3nw1UVecc0cGu9R7J82V1A0n7c-Z_Z4C_LuNXU6WU,813
+dynatrace_extension/__about__.py,sha256=EKqfngohTaiZ-afjIydbqpFds5q6Y6m0tK_D6Wyw2Dc,110
+dynatrace_extension/__init__.py,sha256=MJNJYCFWLEwPmBLoETWFZddyUCMDgZfKkRycmmGM_w4,806
 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,21 +17,22 @@ 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=K2jUacVU5FJZaeZgZPOMVLhXr_L39Sz_munYeMMm48w,6688
-dynatrace_extension/sdk/communication.py,sha256=Kbar_SpeIJInQZ8oYXhuH6ZknZX89wfHKJQ2LevhFSw,23280
+dynatrace_extension/sdk/callback.py,sha256=woumpcWID09QHGc_rSrukNslVG8Qo0UQEgv8VTB6m7c,6681
+dynatrace_extension/sdk/communication.py,sha256=-ccvNz0NYLSDXbqcpnWEqrGKZ4AgTy9XMyu8xnd_qEU,18418
 dynatrace_extension/sdk/event.py,sha256=J261imbFKpxfuAQ6Nfu3RRcsIQKKivy6fme1nww2g-8,388
-dynatrace_extension/sdk/extension.py,sha256=lq7owgrM5q4a69z3y0uXNbV2Hs8gbEaH4cm8iSIRww0,48325
+dynatrace_extension/sdk/extension.py,sha256=BAdvQbXl03RGSPw_hYm1y5_9aZZia8fFzIZ0dpoZedo,49681
 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/status.py,sha256=TG00-Aenp6D5aFbNxJeQYEyasthAW_vi9-OsutpNC58,8425
 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.6.2.dist-info/METADATA,sha256=y6htvO16O5Sk8dLxA8c78xtUpfsri2Njz28CzE5e9zk,2721
-dt_extensions_sdk-1.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dt_extensions_sdk-1.6.2.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
-dt_extensions_sdk-1.6.2.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
-dt_extensions_sdk-1.6.2.dist-info/RECORD,,
+dt_extensions_sdk-1.7.1.dist-info/METADATA,sha256=5Fq2vrh0GcZ4VTUgAnNnRxgU7-xuhaKb4gY4evc48bs,2721
+dt_extensions_sdk-1.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dt_extensions_sdk-1.7.1.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
+dt_extensions_sdk-1.7.1.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
+dt_extensions_sdk-1.7.1.dist-info/RECORD,,

dynatrace_extension/__about__.py

@@ -3,4 +3,4 @@
 # SPDX-License-Identifier: MIT
 
 
-__version__ = "1.6.2"
+__version__ = "1.7.1"

dynatrace_extension/__init__.py

@@ -6,7 +6,6 @@
 # ruff: noqa: F401
 
 from .sdk.activation import ActivationConfig, ActivationType
-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 (
@@ -25,3 +24,4 @@ from .sdk.helper import (
     schedule_function,
 )
 from .sdk.metric import Metric, MetricType, SummaryStat
+from .sdk.status import EndpointStatus, EndpointStatuses, IgnoreStatus, MultiStatus, Status, StatusValue

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 EndpointStatuses, IgnoreStatus, MultiStatus, Status, StatusValue
+from .status import EndpointStatuses, IgnoreStatus, MultiStatus, Status, StatusValue
 
 
 class WrappedCallback:

dynatrace_extension/sdk/communication.py

@@ -10,11 +10,10 @@ import sys
 from abc import ABC, abstractmethod
 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 .status import Status
 from .vendor.mureq.mureq import HTTPException, Response, request
 
 CONTENT_TYPE_JSON = "application/json;charset=utf-8"
@@ -30,173 +29,6 @@ MAX_METRIC_REQUEST_SIZE = 1_000_000  # actually 1_048_576
 HTTP_BAD_REQUEST = 400
 
 
-class StatusValue(Enum):
-    EMPTY = ""
-    OK = "OK"
-    GENERIC_ERROR = "GENERIC_ERROR"
-    INVALID_ARGS_ERROR = "INVALID_ARGS_ERROR"
-    EEC_CONNECTION_ERROR = "EEC_CONNECTION_ERROR"
-    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
-        self.message = message
-        self.timestamp = timestamp
-
-    def to_json(self) -> dict:
-        status = {"status": self.status.value, "message": self.message}
-        if self.timestamp:
-            status["timestamp"] = self.timestamp  # type: ignore
-        return status
-
-    def __repr__(self):
-        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: list[Status] = []
-
-    def add_status(self, status: StatusValue, message):
-        self.statuses.append(Status(status, message))
-
-    def build(self) -> Status:
-        ret = Status(StatusValue.OK)
-        if len(self.statuses) == 0:
-            return ret
-
-        messages = []
-        all_ok = True
-        all_err = True
-        any_warning = False
-
-        for stored_status in self.statuses:
-            if stored_status.message != "":
-                messages.append(stored_status.message)
-
-            if stored_status.is_warning():
-                any_warning = True
-
-            if stored_status.is_error():
-                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
@@ -250,6 +82,10 @@ class CommunicationClient(ABC):
     def send_dt_event(self, event: dict) -> None:
         pass
 
+    @abstractmethod
+    def send_sfm_logs(self, sfm_logs: dict | list[dict]) -> list[dict | None]:
+        pass
+
 
 class HttpClient(CommunicationClient):
     """
@@ -261,6 +97,7 @@ class HttpClient(CommunicationClient):
         self._extension_config_url = f"{base_url}/extconfig/{datasource_id}"
         self._metric_url = f"{base_url}/mint/{datasource_id}"
         self._sfm_url = f"{base_url}/sfm/{datasource_id}"
+        self._sfm_logs_url = f"{base_url}/sfmlogs/{datasource_id}"
         self._keep_alive_url = f"{base_url}/alive/{datasource_id}"
         self._timediff_url = f"{base_url}/timediffms"
         self._events_url = f"{base_url}/logs/{datasource_id}"
@@ -417,7 +254,13 @@ class HttpClient(CommunicationClient):
 
     def send_events(self, events: dict | list[dict], eec_enrichment: bool = True) -> list[dict | None]:
         self.logger.debug(f"Sending log events: {events}")
+        return self._send_events(self._events_url, events, eec_enrichment)
+
+    def send_sfm_logs(self, sfm_logs: dict | list[dict]):
+        self.logger.debug(f"Sending SFM logs: {sfm_logs}")
+        return self._send_events(self._sfm_logs_url, sfm_logs)
 
+    def _send_events(self, url, events: dict | list[dict], eec_enrichment: bool = True) -> list[dict | None]:
         responses = []
         if isinstance(events, dict):
             events = [events]
@@ -426,7 +269,7 @@ class HttpClient(CommunicationClient):
         for batch in batches:
             try:
                 eec_response = self._make_request(
-                    self._events_url,
+                    url,
                     "POST",
                     batch,
                     extra_headers={"Content-Type": CONTENT_TYPE_JSON, "eec-enrichment": str(eec_enrichment).lower()},
@@ -583,6 +426,17 @@ class DebugClient(CommunicationClient):
 
         return activation_config_string
 
+    def send_sfm_logs(self, sfm_logs: dict | list[dict]) -> list[dict | None]:
+        if isinstance(sfm_logs, dict):
+            sfm_logs = [sfm_logs]
+
+        self.logger.info(f"send_sfm_logs: {len(sfm_logs)} logs")
+
+        if self.print_metrics:
+            for log in sfm_logs:
+                self.logger.info(f"send_sfm_log: {log}")
+        return []
+
 
 def divide_into_batches(
     items: Sequence[dict | str], max_size_bytes: int, join_with: str | None = None

dynatrace_extension/sdk/extension.py

@@ -20,19 +20,12 @@ from typing import Any, ClassVar, NamedTuple
 
 from .activation import ActivationConfig, ActivationType
 from .callback import WrappedCallback
-from .communication import (
-    CommunicationClient,
-    DebugClient,
-    EndpointStatuses,
-    HttpClient,
-    IgnoreStatus,
-    Status,
-    StatusValue,
-)
+from .communication import CommunicationClient, DebugClient, HttpClient
 from .event import Severity
 from .metric import Metric, MetricType, SfmMetric, SummaryStat
 from .runtime import RuntimeProperties
 from .snapshot import Snapshot
+from .status import EndpointStatuses, EndpointStatusesMap, IgnoreStatus, Status, StatusValue
 from .throttled_logger import StrictThrottledHandler, ThrottledHandler
 
 HEARTBEAT_INTERVAL = timedelta(seconds=50)
@@ -285,6 +278,13 @@ class Extension:
         # Error message from caught exception in self.initialize()
         self._initialization_error: str = ""
 
+        # Map of all Endpoint Statuses
+        self._sfm_logs_allowed = not self.extension_name.startswith("custom:")
+        if not self._sfm_logs_allowed:
+            self.logger.warning("SFM logs not allowed for custom extensions.")
+
+        self._ep_statuses = EndpointStatusesMap(send_sfm_logs_function=self._send_sfm_logs)
+
         self._parse_args()
 
         for function, interval, args, activation_type in Extension.schedule_decorators:
@@ -1037,8 +1037,7 @@ class Extension:
             if internal_callback_error:
                 return Status(overall_status_value, "\n".join(messages))
 
-        # Handle regular statuses, merge all EndpointStatuses
-        ep_status_merged = EndpointStatuses(0)
+        # Handle regular statuses, report all EndpointStatuses
         all_ok = True
         all_err = True
         any_warning = False
@@ -1048,10 +1047,7 @@ class Extension:
                 continue
 
             if isinstance(callback.status, EndpointStatuses):
-                try:
-                    ep_status_merged.merge(callback.status)
-                except EndpointStatuses.MergeConflictError as e:
-                    self.logger.exception(e)
+                self._ep_statuses.update_ep_statuses(callback.status)
                 continue
 
             if callback.status.is_warning():
@@ -1066,8 +1062,9 @@ class Extension:
                 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()
+        if self._ep_statuses.contains_any_status():
+            self._ep_statuses.send_ep_logs()
+            ep_status_merged = self._ep_statuses.build_common_status()
             messages.insert(0, ep_status_merged.message)
 
             if ep_status_merged.is_warning():
@@ -1081,17 +1078,13 @@ class Extension:
         # Build overall status
         overall_status = Status(StatusValue.OK, "\n".join(messages))
         if any_warning:
-            # TODO WARNING STATUS: to be restored after EEC 1.313 is released
-            # overall_status.status = StatusValue.WARNING
-            overall_status.status = StatusValue.GENERIC_ERROR
+            overall_status.status = StatusValue.WARNING
         elif all_ok:
             overall_status.status = StatusValue.OK
         elif all_err:
             overall_status.status = StatusValue.GENERIC_ERROR
         else:
-            # TODO WARNING STATUS: to be restored after EEC 1.313 is released
-            # overall_status.status = StatusValue.WARNING
-            overall_status.status = StatusValue.GENERIC_ERROR
+            overall_status.status = StatusValue.WARNING
 
         return overall_status
 
@@ -1225,3 +1218,33 @@ class Extension:
                 raise FileNotFoundError(msg)
 
         return Snapshot.parse_from_file(snapshot_file)
+
+    def _send_sfm_logs_internal(self, logs: dict | list[dict]):
+        try:
+            responses = self._client.send_sfm_logs(logs)
+
+            for response in responses:
+                with self._internal_callbacks_results_lock:
+                    self._internal_callbacks_results[self._send_sfm_logs_internal.__name__] = Status(StatusValue.OK)
+                    if not response or "error" not in response or "message" not in response["error"]:
+                        return
+                    self._internal_callbacks_results[self._send_sfm_logs_internal.__name__] = Status(
+                        StatusValue.GENERIC_ERROR, response["error"]["message"]
+                    )
+        except Exception as e:
+            api_logger.error(f"Error sending SFM logs: {e!r}", exc_info=True)
+            with self._internal_callbacks_results_lock:
+                self._internal_callbacks_results[self._send_sfm_logs_internal.__name__] = Status(
+                    StatusValue.GENERIC_ERROR, str(e)
+                )
+
+    def _send_sfm_logs(self, logs: dict | list[dict]):
+        if not self._sfm_logs_allowed or not logs:
+            return
+
+        for log in logs:
+            log.update(self._metadata)
+            log["dt.extension.config.label"] = self.monitoring_config_name
+            log.pop("monitoring.configuration", None)
+
+        self._internal_executor.submit(self._send_sfm_logs_internal, logs)

dynatrace_extension/sdk/status.py

@@ -0,0 +1,259 @@
+import json
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+from threading import Lock
+
+from .event import Severity
+
+
+class DynatraceDeprecatedError(Exception):
+    pass
+
+
+class StatusValue(Enum):
+    EMPTY = ""
+    OK = "OK"
+    GENERIC_ERROR = "GENERIC_ERROR"
+    INVALID_ARGS_ERROR = "INVALID_ARGS_ERROR"
+    EEC_CONNECTION_ERROR = "EEC_CONNECTION_ERROR"
+    INVALID_CONFIG_ERROR = "INVALID_CONFIG_ERROR"
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR"
+    DEVICE_CONNECTION_ERROR = "DEVICE_CONNECTION_ERROR"
+    WARNING = "WARNING"
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+
+    def is_error(self) -> bool:
+        # WARNING is treated as an error
+        return self not in (StatusValue.OK, StatusValue.EMPTY)
+
+    def is_warning(self) -> bool:
+        return self == StatusValue.WARNING
+
+
+class IgnoreStatus:
+    pass
+
+
+class Status:
+    def __init__(self, status: StatusValue = StatusValue.EMPTY, message: str = "", timestamp: int | None = None):
+        self.status = status
+        self.message = message
+        self.timestamp = timestamp
+
+    def to_json(self) -> dict:
+        status = {"status": self.status.value, "message": self.message}
+        if self.timestamp:
+            status["timestamp"] = self.timestamp  # type: ignore
+        return status
+
+    def __repr__(self):
+        return json.dumps(self.to_json())
+
+    def is_error(self) -> bool:
+        # WARNING is treated as an error
+        return self.status.is_error()
+
+    def is_warning(self) -> bool:
+        return self.status.is_warning()
+
+
+class MultiStatus:
+    def __init__(self) -> None:
+        self.statuses: list[Status] = []
+
+    def add_status(self, status: StatusValue, message):
+        self.statuses.append(Status(status, message))
+
+    def build(self) -> Status:
+        ret = Status(StatusValue.OK)
+        if len(self.statuses) == 0:
+            return ret
+
+        messages = []
+        all_ok = True
+        all_err = True
+        any_warning = False
+
+        for stored_status in self.statuses:
+            if stored_status.message != "":
+                messages.append(stored_status.message)
+
+            if stored_status.is_warning():
+                any_warning = True
+
+            if stored_status.is_error():
+                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 | None = None):
+        self.endpoint = endpoint_hint
+        self.status: StatusValue = short_status
+        self.message = message
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+    def __eq__(self, other):
+        return isinstance(other, EndpointStatus) and self.__dict__ == other.__dict__
+
+
+class EndpointStatuses:
+    def __init__(self, total_endpoints_number=None) -> None:
+        if total_endpoints_number is not None:
+            msg = (
+                "EndpointStatuses.__init__: usage of `total_endpoints_number` parameter is abandoned. "
+                "Use other class methods to explicitly report all status changes for any endpoint."
+            )
+            raise DynatraceDeprecatedError(msg)
+
+        self._lock = Lock()
+        self._endpoints_statuses: dict[str, EndpointStatus] = {}
+
+    def add_endpoint_status(self, status: EndpointStatus):
+        with self._lock:
+            self._endpoints_statuses[status.endpoint] = status
+
+
+class StatusState(Enum):
+    INITIAL = "INITIAL"
+    NEW = "NEW"
+    ONGOING = "ONGOING"
+
+
+@dataclass
+class EndpointStatusRecord:
+    ep_status: EndpointStatus
+    last_sent: datetime | None
+    state: StatusState
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+
+class EndpointStatusesMap:
+    RESENDING_INTERVAL = timedelta(hours=2)
+
+    def __init__(self, send_sfm_logs_function: Callable) -> None:
+        self._lock = Lock()
+        self._ep_records: dict[str, EndpointStatusRecord] = {}
+        self._send_sfm_logs_function = send_sfm_logs_function
+        self._logs_to_send: list[str] = []
+
+    def contains_any_status(self) -> bool:
+        return len(self._ep_records) > 0
+
+    def update_ep_statuses(self, new_ep_statuses: EndpointStatuses):
+        with self._lock:
+            with new_ep_statuses._lock:
+                for endpoint, ep_status in new_ep_statuses._endpoints_statuses.items():
+                    if endpoint not in self._ep_records.keys():
+                        self._ep_records[endpoint] = EndpointStatusRecord(
+                            ep_status=ep_status, last_sent=None, state=StatusState.INITIAL
+                        )
+                    elif ep_status != self._ep_records[endpoint].ep_status:
+                        self._ep_records[endpoint] = EndpointStatusRecord(
+                            ep_status=ep_status, last_sent=None, state=StatusState.NEW
+                        )
+
+    def send_ep_logs(self):
+        logs_to_send = []
+
+        with self._lock:
+            for ep_record in self._ep_records.values():
+                if self._should_be_reported(ep_record):
+                    logs_to_send.append(
+                        self._prepare_ep_status_log(
+                            ep_record.ep_status.endpoint,
+                            ep_record.state,
+                            ep_record.ep_status.status,
+                            ep_record.ep_status.message,
+                        )
+                    )
+                    ep_record.last_sent = datetime.now()
+                    ep_record.state = StatusState.ONGOING
+
+        if logs_to_send:
+            self._send_sfm_logs_function(logs_to_send)
+
+    def _should_be_reported(self, ep_record: EndpointStatusRecord):
+        if ep_record.ep_status.status == StatusValue.OK:
+            return ep_record.state == StatusState.NEW
+        elif ep_record.state in (StatusState.INITIAL, StatusState.NEW):
+            return True
+        elif ep_record.state == StatusState.ONGOING and (
+            ep_record.last_sent is None or datetime.now() - ep_record.last_sent >= self.RESENDING_INTERVAL
+        ):
+            return True
+        else:
+            return False
+
+    def _prepare_ep_status_log(
+        self, endpoint_name: str, prefix: StatusState, status_value: StatusValue, status_message: str
+    ) -> dict:
+        level = Severity.ERROR.value
+
+        if status_value.is_error() is False:
+            level = Severity.INFO.value
+        elif status_value.is_warning():
+            level = Severity.WARN.value
+
+        ep_status_log = {
+            "device.address": endpoint_name,
+            "level": level,
+            "message": f"{endpoint_name}: [{prefix.value}] - {status_value.value} {status_message}",
+        }
+
+        return ep_status_log
+
+    def build_common_status(self) -> Status:
+        with self._lock:
+            # Summarize all statuses
+            ok_count = 0
+            nok_count = 0
+            error_messages = []
+            has_warning_status = False
+
+            for ep_record in self._ep_records.values():
+                ep_status = ep_record.ep_status
+                if ep_status.status.is_warning():
+                    has_warning_status = True
+
+                if ep_status.status.is_error():
+                    nok_count += 1
+                    error_messages.append(f"{ep_status.endpoint} - {ep_status.status.value} {ep_status.message}")
+                else:
+                    ok_count += 1
+
+            # Early return if all OK
+            if nok_count == 0:
+                return Status(StatusValue.OK, f"Endpoints OK: {ok_count} NOK: 0")
+
+            # Build final status if some errors present
+            common_msg = ", ".join(error_messages)
+            all_endpoints_faulty = ok_count == 0
+
+            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)