Linter fixes

Author: DtDamianGrzes

dynatrace_extension/sdk/extension.py

@@ -3,14 +3,10 @@
 # SPDX-License-Identifier: MIT
 
 import logging
-import sched
 import signal
 import sys
 import threading
 import time
-from apscheduler.schedulers.background import BackgroundScheduler
-from apscheduler.executors.pool import ThreadPoolExecutor
-from apscheduler.triggers.interval import IntervalTrigger
 from argparse import ArgumentParser
 from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
@@ -20,6 +16,10 @@
 from threading import Lock, RLock, active_count
 from typing import Any, ClassVar, NamedTuple
 
+from apscheduler.executors.pool import ThreadPoolExecutor  # type: ignore
+from apscheduler.schedulers.background import BackgroundScheduler  # type: ignore
+from apscheduler.triggers.interval import IntervalTrigger  # type: ignore
+
 from .activation import ActivationConfig, ActivationType
 from .callback import WrappedCallback
 from .communication import CommunicationClient, DebugClient, HttpClient
@@ -175,9 +175,9 @@ def _add_sfm_metric(metric: Metric, sfm_metrics: list[Metric] | None = None):
 
 
 class ExecutorType(str, Enum):
-    CALLBACKS = 'callbacks'
-    INTERNAL = 'internal'
-    HEARTBEAT = 'heartbeat'
+    CALLBACKS = "callbacks"
+    INTERNAL = "internal"
+    HEARTBEAT = "heartbeat"
 
 
 class Extension:
@@ -249,11 +249,13 @@ def __init__(self, name: str = "") -> None:
         self._running_callbacks_lock: Lock = Lock()
 
         # Scheduler and executors for the callbacks and internal methods
-        self._scheduler = BackgroundScheduler(executors={
-            ExecutorType.CALLBACKS: ThreadPoolExecutor(max_workers=CALLBACKS_THREAD_POOL_SIZE),
-            ExecutorType.INTERNAL: ThreadPoolExecutor(max_workers=INTERNAL_THREAD_POOL_SIZE),
-            ExecutorType.HEARTBEAT: ThreadPoolExecutor(max_workers=HEARTBEAT_THREAD_POOL_SIZE)
-        })
+        self._scheduler = BackgroundScheduler(
+            executors={
+                ExecutorType.CALLBACKS: ThreadPoolExecutor(max_workers=CALLBACKS_THREAD_POOL_SIZE),
+                ExecutorType.INTERNAL: ThreadPoolExecutor(max_workers=INTERNAL_THREAD_POOL_SIZE),
+                ExecutorType.HEARTBEAT: ThreadPoolExecutor(max_workers=HEARTBEAT_THREAD_POOL_SIZE),
+            }
+        )
 
         # Extension metrics
         self._metrics_lock = RLock()
@@ -376,10 +378,12 @@ def _schedule_callback(self, callback: WrappedCallback):
         callback.running_in_sim = self._running_in_sim
         self._scheduled_callbacks.append(callback)
 
-        self._scheduler.add_job(self._run_callback, args=[callback],
+        self._scheduler.add_job(
+            self._run_callback,
+            args=[callback],
             executor=ExecutorType.CALLBACKS,
             trigger=IntervalTrigger(seconds=callback.interval.total_seconds()),
-            next_run_time=datetime.now() + timedelta(seconds=callback.initial_wait_time())
+            next_run_time=datetime.now() + timedelta(seconds=callback.initial_wait_time()),
         )
 
     def schedule(
@@ -813,10 +817,15 @@ def _parse_args(self):
 
         if not self._is_fastcheck:
             try:
-                # TODO: is it surely okay to schedule hearbeat this way? Originally it was scheduled in the very same scheduler, which would starve heartbeat if any callback took too long
+                # TODO: is it surely okay to schedule hearbeat this way? Originally it was scheduled in the very same scheduler,
+                # which would starve heartbeat if any callback took too long
                 # On the other hand, those callbacks inserted specific potentially risky jobs to different executors, so it should be okay?
                 # Why did heartbeat have a different priority (higher or lower?)
-                self._scheduler.add_job(self._heartbeat, executor=ExecutorType.HEARTBEAT, trigger=IntervalTrigger(seconds=HEARTBEAT_INTERVAL.total_seconds()))
+                self._scheduler.add_job(
+                    self._heartbeat,
+                    executor=ExecutorType.HEARTBEAT,
+                    trigger=IntervalTrigger(seconds=HEARTBEAT_INTERVAL.total_seconds()),
+                )
                 self.initialize()
                 if not self.is_helper:
                     self.schedule(self.query, timedelta(minutes=1))
@@ -870,40 +879,49 @@ def _run_callback(self, callback: WrappedCallback):
             with self._running_callbacks_lock:
                 self._running_callbacks.pop(current_thread_id, None)
 
-
     def _start_extension_loop(self):
         api_logger.debug(f"Starting main loop for monitoring configuration: '{self.monitoring_config_name}'")
 
         # These were scheduled before the extension started, schedule them now
         for callback in self._scheduled_callbacks_before_run:
             self._schedule_callback(callback)
 
-                
-        self._scheduler.add_job(self._send_metrics, executor=ExecutorType.INTERNAL,
+        self._scheduler.add_job(
+            self._send_metrics,
+            executor=ExecutorType.INTERNAL,
             trigger=IntervalTrigger(seconds=METRIC_SENDING_INTERVAL.total_seconds()),
-            next_run_time=datetime.now())
+            next_run_time=datetime.now(),
+        )
 
-        self._scheduler.add_job(self._send_buffered_events, executor=ExecutorType.INTERNAL,
+        self._scheduler.add_job(
+            self._send_buffered_events,
+            executor=ExecutorType.INTERNAL,
             trigger=IntervalTrigger(seconds=METRIC_SENDING_INTERVAL.total_seconds()),
-            next_run_time=datetime.now())
+            next_run_time=datetime.now(),
+        )
 
-        self._scheduler.add_job(self._send_sfm_metrics, executor=ExecutorType.INTERNAL,
+        self._scheduler.add_job(
+            self._send_sfm_metrics,
+            executor=ExecutorType.INTERNAL,
             trigger=IntervalTrigger(seconds=SFM_METRIC_SENDING_INTERVAL.total_seconds()),
-            next_run_time=datetime.now())
+            next_run_time=datetime.now(),
+        )
 
-        self._scheduler.add_job(self._update_cluster_time_diff, executor=ExecutorType.INTERNAL,
+        self._scheduler.add_job(
+            self._update_cluster_time_diff,
+            executor=ExecutorType.INTERNAL,
             trigger=IntervalTrigger(seconds=TIME_DIFF_INTERVAL.total_seconds()),
-            next_run_time=datetime.now())
+            next_run_time=datetime.now(),
+        )
 
         self._scheduler.start()
-        
+
         try:
             while self._scheduler.running:
                 time.sleep(1)
         except Exception:
             self._scheduler.shutdown()
 
-
     def _send_metrics(self):
         with self._metrics_lock:
             with self._internal_callbacks_results_lock:
@@ -1167,11 +1185,6 @@ def _send_buffered_events(self):
     def _send_dt_event(self, event: dict[str, str | int | dict[str, str]]):
         self._client.send_dt_event(event)
 
-    def _get_and_set_next_internal_callback_timestamp(self, callback_name: str, interval: timedelta):
-        next_timestamp = self._next_internal_callbacks_timestamps[callback_name]
-        self._next_internal_callbacks_timestamps[callback_name] += interval
-        return next_timestamp.timestamp()
-
     def get_version(self) -> str:
         """Return the extension version."""
         return self.activation_config.version

dynatrace_extension/sdk/status.py

@@ -159,7 +159,7 @@ def __init__(self, send_sfm_logs_function: Callable) -> None:
         self._ep_records: dict[str, EndpointStatusRecord] = {}
         self._send_sfm_logs_function = send_sfm_logs_function
         self._logs_to_send: list[str] = []
-        self._datetime_now = datetime.now # Mockable datetime function
+        self._datetime_now = datetime.now  # Mockable datetime function
 
     def contains_any_status(self) -> bool:
         return len(self._ep_records) > 0

pyproject.toml

@@ -73,7 +73,8 @@ dependencies = [
     "ruff>=0.9.10",
     "typer[all]",
     "pyyaml",
-    "pytest"
+    "pytest",
+    "apscheduler"
 ]
 
 [tool.hatch.envs.lint.scripts]

tests/sdk/test_endpoints_sfm.py

@@ -12,7 +12,7 @@ def setUp(self, extension_name=""):
         self.ext.logger = MagicMock()
         self.ext._running_in_sim = True
         self.ext._client = MagicMock()
-        self.ext._client.send_sfm_logs = MagicMock(side_effect=lambda *args, **kwargs: [])
+        self.ext._client.send_sfm_logs = MagicMock()
         self.ext._is_fastcheck = False
         self.i = 0
         self.test_cases = None

tests/sdk/test_extension.py

@@ -1,7 +1,7 @@
 import threading
 import time
 import unittest
-from datetime import datetime, timedelta
+from datetime import timedelta
 from unittest.mock import MagicMock, mock_open, patch
 
 import pytest

tests/sdk/test_status.py

@@ -28,7 +28,7 @@ def callback():
         ext._running_in_sim = True
         ext._client = DebugClient("", "", MagicMock())
         ext._is_fastcheck = False
-        ext.schedule(callback, timedelta(seconds=1))        
+        ext.schedule(callback, timedelta(seconds=1))
         ext._scheduler.start()
         time.sleep(0.1)
         status = ext._build_current_status()