Initital Monitor impl

Author: sl0thentr0py

sentry_sdk/client.py

@@ -32,6 +32,7 @@
 from sentry_sdk.envelope import Envelope
 from sentry_sdk.profiler import has_profiling_enabled, setup_profiler
 from sentry_sdk.scrubber import EventScrubber
+from sentry_sdk.monitor import Monitor
 
 from sentry_sdk._types import TYPE_CHECKING
 
@@ -211,6 +212,7 @@ def _capture_envelope(envelope):
  self.transport = make_transport(self.options)
 
  self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
+ self.monitor = Monitor()
 
  request_bodies = ("always", "never", "small", "medium")
  if self.options["request_bodies"] not in request_bodies:
@@ -568,6 +570,7 @@ def close(
  if self.transport is not None:
  self.flush(timeout=timeout, callback=callback)
  self.session_flusher.kill()
+ self.monitor.kill()
  self.transport.kill()
  self.transport = None
 

sentry_sdk/monitor.py

@@ -0,0 +1,83 @@
+import os
+import time
+from threading import Thread, Lock
+
+import sentry_sdk
+from sentry_sdk._types import TYPE_CHECKING
+
+if TYPE_CHECKING:
+ from typing import Optional
+
+
+class Monitor(object):
+ """
+ Performs health checks in a separate thread once every interval seconds
+ and updates the internal state. Other parts of the SDK only read this state
+ and act accordingly.
+ """
+
+ name = "sentry.monitor"
+
+ def __init__(self, interval=60):
+ # type: (int) -> None
+ self.interval = interval # type: int
+ self._healthy = True
+ self._thread = None # type: Optional[Thread]
+ self._thread_lock = Lock()
+ self._thread_for_pid = None # type: Optional[int]
+ self._running = True
+
+ def _ensure_running(self):
+ # type: () -> None
+ if self._thread_for_pid == os.getpid() and self._thread is not None:
+ return None
+
+ with self._thread_lock:
+ if self._thread_for_pid == os.getpid() and self._thread is not None:
+ return None
+
+ def _thread():
+ # type: (...) -> None
+ while self._running:
+ time.sleep(self.interval)
+ if self._running:
+ self.check_health()
+
+ thread = Thread(name=self.name, target=_thread)
+ thread.daemon = True
+ thread.start()
+ self._thread = thread
+ self._thread_for_pid = os.getpid()
+
+ return None
+
+ def _is_transport_rate_limited(self):
+ # type: () -> bool
+ transport = (
+ sentry_sdk.Hub.current.client and sentry_sdk.Hub.current.client.transport
+ )
+ if transport and hasattr(transport, "_is_rate_limited"):
+ return transport._is_rate_limited()
+ return False
+
+ def check_health(self):
+ # type: () -> None
+ """
+ Perform the actual health checks,
+ currently only checks if the transport is rate-limited.
+ TODO: augment in the future with more checks.
+ """
+ if self._is_transport_rate_limited():
+ self._healthy = False
+
+ def is_healthy(self):
+ # type: () -> bool
+ return self._healthy
+
+ def kill(self):
+ # type: () -> None
+ self._running = False
+
+ def __del__(self):
+ # type: () -> None
+ self.kill()

sentry_sdk/transport.py

@@ -311,6 +311,10 @@ def _disabled(bucket):
 
  return _disabled(category) or _disabled(None)
 
+ def _is_rate_limited(self):
+ # type: () -> bool
+ return any(ts > datetime.utcnow() for ts in self._disabled_until.values())
+
  def _send_event(
  self, event # type: Event
  ):