sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/integrations/unleash.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from functools import wraps
 from typing import Any
 
@@ -14,14 +15,14 @@ class UnleashIntegration(Integration):
     identifier = "unleash"
 
     @staticmethod
-    def setup_once():
-        # type: () -> None
+    def setup_once() -> None:
         # Wrap and patch evaluation methods (class methods)
         old_is_enabled = UnleashClient.is_enabled
 
         @wraps(old_is_enabled)
-        def sentry_is_enabled(self, feature, *args, **kwargs):
-            # type: (UnleashClient, str, *Any, **Any) -> Any
+        def sentry_is_enabled(
+            self: UnleashClient, feature: str, *args: Any, **kwargs: Any
+        ) -> Any:
             enabled = old_is_enabled(self, feature, *args, **kwargs)
 
             # We have no way of knowing what type of unleash feature this is, so we have to treat

sentry_sdk/integrations/wsgi.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 from functools import partial
 
@@ -25,22 +26,26 @@ if TYPE_CHECKING:
     from typing import Callable
     from typing import Dict
     from typing import Iterator
+    from typing import Iterable
     from typing import Any
     from typing import Tuple
+    from typing import List
     from typing import Optional
-    from typing import TypeVar
     from typing import Protocol
 
     from sentry_sdk.utils import ExcInfo
     from sentry_sdk._types import Event, EventProcessor
 
-    WsgiResponseIter = TypeVar("WsgiResponseIter")
-    WsgiResponseHeaders = TypeVar("WsgiResponseHeaders")
-    WsgiExcInfo = TypeVar("WsgiExcInfo")
+    WsgiResponseIter = Iterable[bytes]
+    WsgiResponseHeaders = List[Tuple[str, str]]
 
     class StartResponse(Protocol):
-        def __call__(self, status, response_headers, exc_info=None):  # type: ignore
-            # type: (str, WsgiResponseHeaders, Optional[WsgiExcInfo]) -> WsgiResponseIter
+        def __call__(
+            self,
+            status: str,
+            response_headers: WsgiResponseHeaders,
+            exc_info: Optional[ExcInfo] = None,
+        ) -> WsgiResponseIter:
             pass
 
 
@@ -58,13 +63,11 @@ ENVIRON_TO_ATTRIBUTE = {
 }
 
 
-def wsgi_decoding_dance(s, charset="utf-8", errors="replace"):
-    # type: (str, str, str) -> str
+def wsgi_decoding_dance(s: str, charset: str = "utf-8", errors: str = "replace") -> str:
     return s.encode("latin1").decode(charset, errors)
 
 
-def get_request_url(environ, use_x_forwarded_for=False):
-    # type: (Dict[str, str], bool) -> str
+def get_request_url(environ: Dict[str, str], use_x_forwarded_for: bool = False) -> str:
     """Return the absolute URL without query string for the given WSGI
     environment."""
     script_name = environ.get("SCRIPT_NAME", "").rstrip("/")
@@ -88,19 +91,19 @@ class SentryWsgiMiddleware:
 
     def __init__(
         self,
-        app,  # type: Callable[[Dict[str, str], Callable[..., Any]], Any]
-        use_x_forwarded_for=False,  # type: bool
-        span_origin=None,  # type: Optional[str]
-        http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: Tuple[str, ...]
-    ):
-        # type: (...) -> None
+        app: Callable[[Dict[str, str], Callable[..., Any]], Any],
+        use_x_forwarded_for: bool = False,
+        span_origin: Optional[str] = None,
+        http_methods_to_capture: Tuple[str, ...] = DEFAULT_HTTP_METHODS_TO_CAPTURE,
+    ) -> None:
         self.app = app
         self.use_x_forwarded_for = use_x_forwarded_for
         self.span_origin = span_origin
         self.http_methods_to_capture = http_methods_to_capture
 
-    def __call__(self, environ, start_response):
-        # type: (Dict[str, str], Callable[..., Any]) -> _ScopedResponse
+    def __call__(
+        self, environ: Dict[str, str], start_response: Callable[..., Any]
+    ) -> _ScopedResponse:
         if _wsgi_middleware_applied.get(False):
             return self.app(environ, start_response)
 
@@ -144,8 +147,12 @@ class SentryWsgiMiddleware:
 
         return _ScopedResponse(scope, response)
 
-    def _run_original_app(self, environ, start_response, span):
-        # type: (dict[str, str], StartResponse, Optional[Span]) -> Any
+    def _run_original_app(
+        self,
+        environ: dict[str, str],
+        start_response: StartResponse,
+        span: Optional[Span],
+    ) -> Any:
         try:
             return self.app(
                 environ,
@@ -159,14 +166,13 @@ class SentryWsgiMiddleware:
             reraise(*_capture_exception())
 
 
-def _sentry_start_response(  # type: ignore
-    old_start_response,  # type: StartResponse
-    span,  # type: Optional[Span]
-    status,  # type: str
-    response_headers,  # type: WsgiResponseHeaders
-    exc_info=None,  # type: Optional[WsgiExcInfo]
-):
-    # type: (...) -> WsgiResponseIter
+def _sentry_start_response(
+    old_start_response: StartResponse,
+    span: Optional[Span],
+    status: str,
+    response_headers: WsgiResponseHeaders,
+    exc_info: Optional[ExcInfo] = None,
+) -> WsgiResponseIter:
     with capture_internal_exceptions():
         status_int = int(status.split(" ", 1)[0])
         if span is not None:
@@ -181,8 +187,7 @@ def _sentry_start_response(  # type: ignore
         return old_start_response(status, response_headers, exc_info)
 
 
-def _get_environ(environ):
-    # type: (Dict[str, str]) -> Iterator[Tuple[str, str]]
+def _get_environ(environ: Dict[str, str]) -> Iterator[Tuple[str, str]]:
     """
     Returns our explicitly included environment variables we want to
     capture (server name, port and remote addr if pii is enabled).
@@ -198,8 +203,7 @@ def _get_environ(environ):
             yield key, environ[key]
 
 
-def get_client_ip(environ):
-    # type: (Dict[str, str]) -> Optional[Any]
+def get_client_ip(environ: Dict[str, str]) -> Optional[Any]:
     """
     Infer the user IP address from various headers. This cannot be used in
     security sensitive situations since the value may be forged from a client,
@@ -218,8 +222,7 @@ def get_client_ip(environ):
     return environ.get("REMOTE_ADDR")
 
 
-def _capture_exception():
-    # type: () -> ExcInfo
+def _capture_exception() -> ExcInfo:
     """
     Captures the current exception and sends it to Sentry.
     Returns the ExcInfo tuple to it can be reraised afterwards.
@@ -253,13 +256,11 @@ class _ScopedResponse:
 
     __slots__ = ("_response", "_scope")
 
-    def __init__(self, scope, response):
-        # type: (sentry_sdk.Scope, Iterator[bytes]) -> None
+    def __init__(self, scope: sentry_sdk.Scope, response: Iterator[bytes]) -> None:
         self._scope = scope
         self._response = response
 
-    def __iter__(self):
-        # type: () -> Iterator[bytes]
+    def __iter__(self) -> Iterator[bytes]:
         iterator = iter(self._response)
 
         while True:
@@ -273,8 +274,7 @@ class _ScopedResponse:
 
             yield chunk
 
-    def close(self):
-        # type: () -> None
+    def close(self) -> None:
         with sentry_sdk.use_isolation_scope(self._scope):
             try:
                 self._response.close()  # type: ignore
@@ -284,8 +284,9 @@ class _ScopedResponse:
                 reraise(*_capture_exception())
 
 
-def _make_wsgi_event_processor(environ, use_x_forwarded_for):
-    # type: (Dict[str, str], bool) -> EventProcessor
+def _make_wsgi_event_processor(
+    environ: Dict[str, str], use_x_forwarded_for: bool
+) -> EventProcessor:
     # It's a bit unfortunate that we have to extract and parse the request data
     # from the environ so eagerly, but there are a few good reasons for this.
     #
@@ -305,8 +306,7 @@ def _make_wsgi_event_processor(environ, use_x_forwarded_for):
     env = dict(_get_environ(environ))
     headers = _filter_headers(dict(_get_headers(environ)))
 
-    def event_processor(event, hint):
-        # type: (Event, Dict[str, Any]) -> Event
+    def event_processor(event: Event, hint: Dict[str, Any]) -> Event:
         with capture_internal_exceptions():
             # if the code below fails halfway through we at least have some data
             request_info = event.setdefault("request", {})
@@ -327,8 +327,9 @@ def _make_wsgi_event_processor(environ, use_x_forwarded_for):
     return event_processor
 
 
-def _prepopulate_attributes(wsgi_environ, use_x_forwarded_for=False):
-    # type: (dict[str, str], bool) -> dict[str, str]
+def _prepopulate_attributes(
+    wsgi_environ: dict[str, str], use_x_forwarded_for: bool = False
+) -> dict[str, str]:
     """Extract span attributes from the WSGI environment."""
     attributes = {}
 

sentry_sdk/logger.py

@@ -1,24 +1,40 @@
 # NOTE: this is the logger sentry exposes to users, not some generic logger.
+from __future__ import annotations
 import functools
 import time
-from typing import Any
 
-from sentry_sdk import get_client, get_current_scope
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+from sentry_sdk import get_client
 from sentry_sdk.utils import safe_repr
 
+OTEL_RANGES = [
+    # ((severity level range), severity text)
+    # https://opentelemetry.io/docs/specs/otel/logs/data-model
+    ((1, 4), "trace"),
+    ((5, 8), "debug"),
+    ((9, 12), "info"),
+    ((13, 16), "warn"),
+    ((17, 20), "error"),
+    ((21, 24), "fatal"),
+]
+
 
-def _capture_log(severity_text, severity_number, template, **kwargs):
-    # type: (str, int, str, **Any) -> None
+def _capture_log(
+    severity_text: str, severity_number: int, template: str, **kwargs: Any
+) -> None:
     client = get_client()
-    scope = get_current_scope()
 
-    attrs = {
+    attrs: dict[str, str | bool | float | int] = {
         "sentry.message.template": template,
-    }  # type: dict[str, str | bool | float | int]
+    }
     if "attributes" in kwargs:
         attrs.update(kwargs.pop("attributes"))
     for k, v in kwargs.items():
-        attrs[f"sentry.message.parameters.{k}"] = v
+        attrs[f"sentry.message.parameter.{k}"] = v
 
     attrs = {
         k: (
@@ -36,7 +52,6 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
 
     # noinspection PyProtectedMember
     client._capture_experimental_log(
-        scope,
         {
             "severity_text": severity_text,
             "severity_number": severity_number,
@@ -51,6 +66,22 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
 trace = functools.partial(_capture_log, "trace", 1)
 debug = functools.partial(_capture_log, "debug", 5)
 info = functools.partial(_capture_log, "info", 9)
-warning = functools.partial(_capture_log, "warning", 13)
+warning = functools.partial(_capture_log, "warn", 13)
 error = functools.partial(_capture_log, "error", 17)
 fatal = functools.partial(_capture_log, "fatal", 21)
+
+
+def _otel_severity_text(otel_severity_number: int) -> str:
+    for (lower, upper), severity in OTEL_RANGES:
+        if lower <= otel_severity_number <= upper:
+            return severity
+
+    return "default"
+
+
+def _log_level_to_otel(level: int, mapping: dict[Any, int]) -> tuple[int, str]:
+    for py_level, otel_severity_number in sorted(mapping.items(), reverse=True):
+        if level >= py_level:
+            return otel_severity_number, _otel_severity_text(otel_severity_number)
+
+    return 0, "default"

sentry_sdk/monitor.py

@@ -1,14 +1,15 @@
+from __future__ import annotations
 import os
 import time
 from threading import Thread, Lock
 
-import sentry_sdk
 from sentry_sdk.utils import logger
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional
+    from sentry_sdk.transport import Transport
 
 
 MAX_DOWNSAMPLE_FACTOR = 10
@@ -23,21 +24,19 @@ class Monitor:
 
     name = "sentry.monitor"
 
-    def __init__(self, transport, interval=10):
-        # type: (sentry_sdk.transport.Transport, float) -> None
-        self.transport = transport  # type: sentry_sdk.transport.Transport
-        self.interval = interval  # type: float
+    def __init__(self, transport: Transport, interval: float = 10) -> None:
+        self.transport: Transport = transport
+        self.interval: float = interval
 
         self._healthy = True
-        self._downsample_factor = 0  # type: int
+        self._downsample_factor: int = 0
 
-        self._thread = None  # type: Optional[Thread]
+        self._thread: Optional[Thread] = None
         self._thread_lock = Lock()
-        self._thread_for_pid = None  # type: Optional[int]
+        self._thread_for_pid: Optional[int] = None
         self._running = True
 
-    def _ensure_running(self):
-        # type: () -> None
+    def _ensure_running(self) -> None:
         """
         Check that the monitor has an active thread to run in, or create one if not.
 
@@ -52,8 +51,7 @@ class Monitor:
             if self._thread_for_pid == os.getpid() and self._thread is not None:
                 return None
 
-            def _thread():
-                # type: (...) -> None
+            def _thread() -> None:
                 while self._running:
                     time.sleep(self.interval)
                     if self._running:
@@ -74,13 +72,11 @@ class Monitor:
 
         return None
 
-    def run(self):
-        # type: () -> None
+    def run(self) -> None:
         self.check_health()
         self.set_downsample_factor()
 
-    def set_downsample_factor(self):
-        # type: () -> None
+    def set_downsample_factor(self) -> None:
         if self._healthy:
             if self._downsample_factor > 0:
                 logger.debug(
@@ -95,8 +91,7 @@ class Monitor:
                 self._downsample_factor,
             )
 
-    def check_health(self):
-        # type: () -> None
+    def check_health(self) -> None:
         """
         Perform the actual health checks,
         currently only checks if the transport is rate-limited.
@@ -104,21 +99,14 @@ class Monitor:
         """
         self._healthy = self.transport.is_healthy()
 
-    def is_healthy(self):
-        # type: () -> bool
+    def is_healthy(self) -> bool:
         self._ensure_running()
         return self._healthy
 
     @property
-    def downsample_factor(self):
-        # type: () -> int
+    def downsample_factor(self) -> int:
         self._ensure_running()
         return self._downsample_factor
 
-    def kill(self):
-        # type: () -> None
+    def kill(self) -> None:
         self._running = False
-
-    def __del__(self):
-        # type: () -> None
-        self.kill()

sentry_sdk/opentelemetry/consts.py

@@ -1,5 +1,4 @@
 from opentelemetry.context import create_key
-from sentry_sdk.tracing_utils import Baggage
 
 
 # propagation keys
@@ -13,14 +12,22 @@ SENTRY_USE_CURRENT_SCOPE_KEY = create_key("sentry_use_current_scope")
 SENTRY_USE_ISOLATION_SCOPE_KEY = create_key("sentry_use_isolation_scope")
 
 # trace state keys
-TRACESTATE_SAMPLED_KEY = Baggage.SENTRY_PREFIX + "sampled"
-TRACESTATE_SAMPLE_RATE_KEY = Baggage.SENTRY_PREFIX + "sample_rate"
-TRACESTATE_SAMPLE_RAND_KEY = Baggage.SENTRY_PREFIX + "sample_rand"
+SENTRY_PREFIX = "sentry-"
+TRACESTATE_SAMPLED_KEY = SENTRY_PREFIX + "sampled"
+TRACESTATE_SAMPLE_RATE_KEY = SENTRY_PREFIX + "sample_rate"
+TRACESTATE_SAMPLE_RAND_KEY = SENTRY_PREFIX + "sample_rand"
 
 # misc
 OTEL_SENTRY_CONTEXT = "otel"
 SPAN_ORIGIN = "auto.otel"
 
+# resource semconv attributes
+# Not all of these are stable yet, so defining them here rather than importing.
+# https://github.com/open-telemetry/semantic-conventions/blob/main/docs/resource/README.md#service
+RESOURCE_SERVICE_NAME = "service.name"
+RESOURCE_SERVICE_NAMESPACE = "service.namespace"
+RESOURCE_SERVICE_VERSION = "service.version"
+
 
 class SentrySpanAttribute:
     DESCRIPTION = "sentry.description"

sentry_sdk/opentelemetry/contextvars_context.py

@@ -1,46 +1,50 @@
-from typing import cast, TYPE_CHECKING
+from __future__ import annotations
+from typing import TYPE_CHECKING
 
-from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace import get_current_span, set_span_in_context
+from opentelemetry.trace.span import INVALID_SPAN
 from opentelemetry.context import Context, get_value, set_value
 from opentelemetry.context.contextvars_context import ContextVarsRuntimeContext
 
 import sentry_sdk
+from sentry_sdk.tracing import Span
 from sentry_sdk.opentelemetry.consts import (
     SENTRY_SCOPES_KEY,
     SENTRY_FORK_ISOLATION_SCOPE_KEY,
     SENTRY_USE_CURRENT_SCOPE_KEY,
     SENTRY_USE_ISOLATION_SCOPE_KEY,
 )
+from sentry_sdk.opentelemetry.scope import PotelScope, validate_scopes
 
 if TYPE_CHECKING:
-    from typing import Optional
     from contextvars import Token
-    import sentry_sdk.opentelemetry.scope as scope
 
 
 class SentryContextVarsRuntimeContext(ContextVarsRuntimeContext):
-    def attach(self, context):
-        # type: (Context) -> Token[Context]
-        scopes = get_value(SENTRY_SCOPES_KEY, context)
+    def attach(self, context: Context) -> Token[Context]:
+        scopes = validate_scopes(get_value(SENTRY_SCOPES_KEY, context))
 
-        should_fork_isolation_scope = context.pop(
-            SENTRY_FORK_ISOLATION_SCOPE_KEY, False
+        should_fork_isolation_scope = bool(
+            context.pop(SENTRY_FORK_ISOLATION_SCOPE_KEY, False)
         )
-        should_fork_isolation_scope = cast("bool", should_fork_isolation_scope)
 
         should_use_isolation_scope = context.pop(SENTRY_USE_ISOLATION_SCOPE_KEY, None)
-        should_use_isolation_scope = cast(
-            "Optional[scope.PotelScope]", should_use_isolation_scope
+        should_use_isolation_scope = (
+            should_use_isolation_scope
+            if isinstance(should_use_isolation_scope, PotelScope)
+            else None
         )
 
         should_use_current_scope = context.pop(SENTRY_USE_CURRENT_SCOPE_KEY, None)
-        should_use_current_scope = cast(
-            "Optional[scope.PotelScope]", should_use_current_scope
+        should_use_current_scope = (
+            should_use_current_scope
+            if isinstance(should_use_current_scope, PotelScope)
+            else None
         )
 
         if scopes:
-            scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
-            (current_scope, isolation_scope) = scopes
+            current_scope = scopes[0]
+            isolation_scope = scopes[1]
         else:
             current_scope = sentry_sdk.get_current_scope()
             isolation_scope = sentry_sdk.get_isolation_scope()
@@ -60,6 +64,12 @@ class SentryContextVarsRuntimeContext(ContextVarsRuntimeContext):
         else:
             new_scope = current_scope.fork()
 
+            # carry forward a wrapped span reference since the otel context is always the
+            # source of truth for the active span
+            current_span = get_current_span(context)
+            if current_span != INVALID_SPAN:
+                new_scope._span = Span(otel_span=get_current_span(context))
+
         if should_use_isolation_scope:
             new_isolation_scope = should_use_isolation_scope
         elif should_fork_isolation_scope:

sentry_sdk/opentelemetry/propagator.py

@@ -1,4 +1,4 @@
-from typing import cast
+from __future__ import annotations
 
 from opentelemetry import trace
 from opentelemetry.context import (
@@ -20,7 +20,9 @@ from opentelemetry.trace import (
     SpanContext,
     TraceFlags,
 )
+from opentelemetry.semconv.trace import SpanAttributes
 
+import sentry_sdk
 from sentry_sdk.consts import (
     BAGGAGE_HEADER_NAME,
     SENTRY_TRACE_HEADER_NAME,
@@ -30,13 +32,17 @@ from sentry_sdk.opentelemetry.consts import (
     SENTRY_TRACE_KEY,
     SENTRY_SCOPES_KEY,
 )
-from sentry_sdk.tracing_utils import Baggage, extract_sentrytrace_data
+from sentry_sdk.tracing_utils import (
+    Baggage,
+    extract_sentrytrace_data,
+    should_propagate_trace,
+)
+from sentry_sdk.opentelemetry.scope import validate_scopes
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from typing import Optional, Set
-    import sentry_sdk.opentelemetry.scope as scope
 
 
 class SentryPropagator(TextMapPropagator):
@@ -44,8 +50,12 @@ class SentryPropagator(TextMapPropagator):
     Propagates tracing headers for Sentry's tracing system in a way OTel understands.
     """
 
-    def extract(self, carrier, context=None, getter=default_getter):
-        # type: (CarrierT, Optional[Context], Getter[CarrierT]) -> Context
+    def extract(
+        self,
+        carrier: CarrierT,
+        context: Optional[Context] = None,
+        getter: Getter[CarrierT] = default_getter,
+    ) -> Context:
         if context is None:
             context = get_current()
 
@@ -87,22 +97,29 @@ class SentryPropagator(TextMapPropagator):
         modified_context = trace.set_span_in_context(span, context)
         return modified_context
 
-    def inject(self, carrier, context=None, setter=default_setter):
-        # type: (CarrierT, Optional[Context], Setter[CarrierT]) -> None
-        if context is None:
-            context = get_current()
-
-        scopes = get_value(SENTRY_SCOPES_KEY, context)
-        if scopes:
-            scopes = cast("tuple[scope.PotelScope, scope.PotelScope]", scopes)
-            (current_scope, _) = scopes
-
-            # TODO-neel-potel check trace_propagation_targets
-            # TODO-neel-potel test propagator works with twp
-            for key, value in current_scope.iter_trace_propagation_headers():
-                setter.set(carrier, key, value)
+    def inject(
+        self,
+        carrier: CarrierT,
+        context: Optional[Context] = None,
+        setter: Setter[CarrierT] = default_setter,
+    ) -> None:
+        scopes = validate_scopes(get_value(SENTRY_SCOPES_KEY, context))
+        if not scopes:
+            return
+
+        (current_scope, _) = scopes
+
+        span = current_scope.span
+        if span:
+            span_url = span.get_attribute(SpanAttributes.HTTP_URL)
+            if span_url and not should_propagate_trace(
+                sentry_sdk.get_client(), span_url
+            ):
+                return
+
+        for key, value in current_scope.iter_trace_propagation_headers():
+            setter.set(carrier, key, value)
 
     @property
-    def fields(self):
-        # type: () -> Set[str]
+    def fields(self) -> Set[str]:
         return {SENTRY_TRACE_HEADER_NAME, BAGGAGE_HEADER_NAME}