sentry-sdk 2.26.1__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/api.py

@@ -1,14 +1,22 @@
 import inspect
-import warnings
 from contextlib import contextmanager
 
 from sentry_sdk import tracing_utils, Client
 from sentry_sdk._init_implementation import init
-from sentry_sdk.consts import INSTRUMENTER
-from sentry_sdk.scope import Scope, _ScopeManager, new_scope, isolation_scope
-from sentry_sdk.tracing import NoOpSpan, Transaction, trace
+from sentry_sdk.tracing import trace
 from sentry_sdk.crons import monitor
 
+# TODO-neel-potel make 2 scope strategies/impls and switch
+from sentry_sdk.scope import Scope as BaseScope
+from sentry_sdk.opentelemetry.scope import (
+    PotelScope as Scope,
+    new_scope,
+    isolation_scope,
+    use_scope,
+    use_isolation_scope,
+)
+
+
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -16,46 +24,26 @@ if TYPE_CHECKING:
 
     from typing import Any
     from typing import Dict
-    from typing import Generator
     from typing import Optional
-    from typing import overload
     from typing import Callable
     from typing import TypeVar
-    from typing import ContextManager
     from typing import Union
+    from typing import Generator
 
-    from typing_extensions import Unpack
-
-    from sentry_sdk.client import BaseClient
-    from sentry_sdk._types import (
-        Event,
-        Hint,
-        Breadcrumb,
-        BreadcrumbHint,
-        ExcInfo,
-        MeasurementUnit,
-        LogLevelStr,
-        SamplingContext,
-    )
-    from sentry_sdk.tracing import Span, TransactionKwargs
+    import sentry_sdk
 
     T = TypeVar("T")
     F = TypeVar("F", bound=Callable[..., Any])
-else:
-
-    def overload(x):
-        # type: (T) -> T
-        return x
 
 
 # When changing this, update __all__ in __init__.py too
 __all__ = [
     "init",
+    "add_attachment",
     "add_breadcrumb",
     "capture_event",
     "capture_exception",
     "capture_message",
-    "configure_scope",
     "continue_trace",
     "flush",
     "get_baggage",
@@ -69,11 +57,9 @@ __all__ = [
     "isolation_scope",
     "last_event_id",
     "new_scope",
-    "push_scope",
     "set_context",
     "set_extra",
     "set_level",
-    "set_measurement",
     "set_tag",
     "set_tags",
     "set_user",
@@ -81,6 +67,8 @@ __all__ = [
     "start_transaction",
     "trace",
     "monitor",
+    "use_scope",
+    "use_isolation_scope",
 ]
 
 
@@ -104,7 +92,7 @@ def clientmethod(f):
 
 @scopemethod
 def get_client():
-    # type: () -> BaseClient
+    # type: () -> sentry_sdk.client.BaseClient
     return Scope.get_client()
 
 
@@ -124,7 +112,7 @@ def is_initialized():
 
 @scopemethod
 def get_global_scope():
-    # type: () -> Scope
+    # type: () -> BaseScope
     return Scope.get_global_scope()
 
 
@@ -152,8 +140,8 @@ def last_event_id():
 
 @scopemethod
 def capture_event(
-    event,  # type: Event
-    hint=None,  # type: Optional[Hint]
+    event,  # type: sentry_sdk._types.Event
+    hint=None,  # type: Optional[sentry_sdk._types.Hint]
     scope=None,  # type: Optional[Any]
     **scope_kwargs,  # type: Any
 ):
@@ -164,7 +152,7 @@ def capture_event(
 @scopemethod
 def capture_message(
     message,  # type: str
-    level=None,  # type: Optional[LogLevelStr]
+    level=None,  # type: Optional[sentry_sdk._types.LogLevelStr]
     scope=None,  # type: Optional[Any]
     **scope_kwargs,  # type: Any
 ):
@@ -176,7 +164,7 @@ def capture_message(
 
 @scopemethod
 def capture_exception(
-    error=None,  # type: Optional[Union[BaseException, ExcInfo]]
+    error=None,  # type: Optional[Union[BaseException, sentry_sdk._types.ExcInfo]]
     scope=None,  # type: Optional[Any]
     **scope_kwargs,  # type: Any
 ):
@@ -185,108 +173,27 @@ def capture_exception(
 
 
 @scopemethod
-def add_breadcrumb(
-    crumb=None,  # type: Optional[Breadcrumb]
-    hint=None,  # type: Optional[BreadcrumbHint]
-    **kwargs,  # type: Any
-):
-    # type: (...) -> None
-    return get_isolation_scope().add_breadcrumb(crumb, hint, **kwargs)
-
-
-@overload
-def configure_scope():
-    # type: () -> ContextManager[Scope]
-    pass
-
-
-@overload
-def configure_scope(  # noqa: F811
-    callback,  # type: Callable[[Scope], None]
+def add_attachment(
+    bytes=None,  # type: Union[None, bytes, Callable[[], bytes]]
+    filename=None,  # type: Optional[str]
+    path=None,  # type: Optional[str]
+    content_type=None,  # type: Optional[str]
+    add_to_transactions=False,  # type: bool
 ):
     # type: (...) -> None
-    pass
-
-
-def configure_scope(  # noqa: F811
-    callback=None,  # type: Optional[Callable[[Scope], None]]
-):
-    # type: (...) -> Optional[ContextManager[Scope]]
-    """
-    Reconfigures the scope.
-
-    :param callback: If provided, call the callback with the current scope.
-
-    :returns: If no callback is provided, returns a context manager that returns the scope.
-    """
-    warnings.warn(
-        "sentry_sdk.configure_scope is deprecated and will be removed in the next major version. "
-        "Please consult our migration guide to learn how to migrate to the new API: "
-        "https://docs.sentry.io/platforms/python/migration/1.x-to-2.x#scope-configuring",
-        DeprecationWarning,
-        stacklevel=2,
+    return get_isolation_scope().add_attachment(
+        bytes, filename, path, content_type, add_to_transactions
     )
 
-    scope = get_isolation_scope()
-    scope.generate_propagation_context()
-
-    if callback is not None:
-        # TODO: used to return None when client is None. Check if this changes behavior.
-        callback(scope)
-
-        return None
-
-    @contextmanager
-    def inner():
-        # type: () -> Generator[Scope, None, None]
-        yield scope
-
-    return inner()
-
-
-@overload
-def push_scope():
-    # type: () -> ContextManager[Scope]
-    pass
-
 
-@overload
-def push_scope(  # noqa: F811
-    callback,  # type: Callable[[Scope], None]
+@scopemethod
+def add_breadcrumb(
+    crumb=None,  # type: Optional[sentry_sdk._types.Breadcrumb]
+    hint=None,  # type: Optional[sentry_sdk._types.BreadcrumbHint]
+    **kwargs,  # type: Any
 ):
     # type: (...) -> None
-    pass
-
-
-def push_scope(  # noqa: F811
-    callback=None,  # type: Optional[Callable[[Scope], None]]
-):
-    # type: (...) -> Optional[ContextManager[Scope]]
-    """
-    Pushes a new layer on the scope stack.
-
-    :param callback: If provided, this method pushes a scope, calls
-        `callback`, and pops the scope again.
-
-    :returns: If no `callback` is provided, a context manager that should
-        be used to pop the scope again.
-    """
-    warnings.warn(
-        "sentry_sdk.push_scope is deprecated and will be removed in the next major version. "
-        "Please consult our migration guide to learn how to migrate to the new API: "
-        "https://docs.sentry.io/platforms/python/migration/1.x-to-2.x#scope-pushing",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    if callback is not None:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            with push_scope() as scope:
-                callback(scope)
-        return None
-
-    return _ScopeManager()
+    return get_isolation_scope().add_breadcrumb(crumb, hint, **kwargs)
 
 
 @scopemethod
@@ -321,7 +228,7 @@ def set_user(value):
 
 @scopemethod
 def set_level(value):
-    # type: (LogLevelStr) -> None
+    # type: (sentry_sdk._types.LogLevelStr) -> None
     return get_isolation_scope().set_level(value)
 
 
@@ -334,23 +241,33 @@ def flush(
     return get_client().flush(timeout=timeout, callback=callback)
 
 
-@scopemethod
-def start_span(
-    **kwargs,  # type: Any
-):
-    # type: (...) -> Span
+def start_span(**kwargs):
+    # type: (Any) -> sentry_sdk.tracing.Span
+    """
+    Start and return a span.
+
+    This is the entry point to manual tracing instrumentation.
+
+    A tree structure can be built by adding child spans to the span.
+    To start a new child span within the span, call the `start_child()` method.
+
+    When used as a context manager, spans are automatically finished at the end
+    of the `with` block. If not using context managers, call the `finish()`
+    method.
+    """
     return get_current_scope().start_span(**kwargs)
 
 
-@scopemethod
 def start_transaction(
-    transaction=None,  # type: Optional[Transaction]
-    instrumenter=INSTRUMENTER.SENTRY,  # type: str
-    custom_sampling_context=None,  # type: Optional[SamplingContext]
-    **kwargs,  # type: Unpack[TransactionKwargs]
+    transaction=None,  # type: Optional[sentry_sdk.tracing.Span]
+    **kwargs,  # type: Any
 ):
-    # type: (...) -> Union[Transaction, NoOpSpan]
+    # type: (...) -> sentry_sdk.tracing.Span
     """
+    .. deprecated:: 3.0.0
+        This function is deprecated and will be removed in a future release.
+        Use :py:meth:`sentry_sdk.start_span` instead.
+
     Start and return a transaction on the current scope.
 
     Start an existing transaction if given, otherwise create and start a new
@@ -374,27 +291,18 @@ def start_transaction(
 
     :param transaction: The transaction to start. If omitted, we create and
         start a new transaction.
-    :param instrumenter: This parameter is meant for internal use only. It
-        will be removed in the next major version.
-    :param custom_sampling_context: The transaction's custom sampling context.
     :param kwargs: Optional keyword arguments to be passed to the Transaction
         constructor. See :py:class:`sentry_sdk.tracing.Transaction` for
         available arguments.
     """
-    return get_current_scope().start_transaction(
-        transaction, instrumenter, custom_sampling_context, **kwargs
+    return start_span(
+        span=transaction,
+        **kwargs,
     )
 
 
-def set_measurement(name, value, unit=""):
-    # type: (str, float, MeasurementUnit) -> None
-    transaction = get_current_scope().transaction
-    if transaction is not None:
-        transaction.set_measurement(name, value, unit)
-
-
 def get_current_span(scope=None):
-    # type: (Optional[Scope]) -> Optional[Span]
+    # type: (Optional[Scope]) -> Optional[sentry_sdk.tracing.Span]
     """
     Returns the currently active span if there is one running, otherwise `None`
     """
@@ -421,13 +329,11 @@ def get_baggage():
     return None
 
 
-def continue_trace(
-    environ_or_headers, op=None, name=None, source=None, origin="manual"
-):
-    # type: (Dict[str, Any], Optional[str], Optional[str], Optional[str], str) -> Transaction
+@contextmanager
+def continue_trace(environ_or_headers):
+    # type: (Dict[str, Any]) -> Generator[None, None, None]
     """
-    Sets the propagation context from environment or headers and returns a transaction.
+    Sets the propagation context from environment or headers to continue an incoming trace.
     """
-    return get_isolation_scope().continue_trace(
-        environ_or_headers, op, name, source, origin
-    )
+    with get_isolation_scope().continue_trace(environ_or_headers):
+        yield

sentry_sdk/client.py

@@ -6,9 +6,8 @@ from collections.abc import Mapping
 from datetime import datetime, timezone
 from importlib import import_module
 from typing import TYPE_CHECKING, List, Dict, cast, overload
-import warnings
 
-from sentry_sdk._compat import PY37, check_uwsgi_thread_support
+from sentry_sdk._compat import check_uwsgi_thread_support
 from sentry_sdk.utils import (
     AnnotatedValue,
     ContextVar,
@@ -20,7 +19,6 @@ from sentry_sdk.utils import (
     get_type_name,
     get_default_release,
     handle_in_app,
-    is_gevent,
     logger,
 )
 from sentry_sdk.serializer import serialize
@@ -30,14 +28,14 @@ from sentry_sdk.consts import (
     SPANDATA,
     DEFAULT_MAX_VALUE_LENGTH,
     DEFAULT_OPTIONS,
-    INSTRUMENTER,
     VERSION,
     ClientConstructor,
 )
-from sentry_sdk.integrations import _DEFAULT_INTEGRATIONS, setup_integrations
+from sentry_sdk.integrations import setup_integrations
 from sentry_sdk.integrations.dedupe import DedupeIntegration
 from sentry_sdk.sessions import SessionFlusher
 from sentry_sdk.envelope import Envelope
+
 from sentry_sdk.profiler.continuous_profiler import setup_continuous_profiler
 from sentry_sdk.profiler.transaction_profiler import (
     has_profiling_enabled,
@@ -59,7 +57,6 @@ if TYPE_CHECKING:
 
     from sentry_sdk._types import Event, Hint, SDKInfo, Log
     from sentry_sdk.integrations import Integration
-    from sentry_sdk.metrics import MetricsAggregator
     from sentry_sdk.scope import Scope
     from sentry_sdk.session import Session
     from sentry_sdk.spotlight import SpotlightClient
@@ -115,9 +112,6 @@ def _get_options(*args, **kwargs):
     if rv["server_name"] is None and hasattr(socket, "gethostname"):
         rv["server_name"] = socket.gethostname()
 
-    if rv["instrumenter"] is None:
-        rv["instrumenter"] = INSTRUMENTER.SENTRY
-
     if rv["project_root"] is None:
         try:
             project_root = os.getcwd()
@@ -126,9 +120,6 @@ def _get_options(*args, **kwargs):
 
         rv["project_root"] = project_root
 
-    if rv["enable_tracing"] is True and rv["traces_sample_rate"] is None:
-        rv["traces_sample_rate"] = 1.0
-
     if rv["event_scrubber"] is None:
         rv["event_scrubber"] = EventScrubber(
             send_default_pii=(
@@ -142,24 +133,9 @@ def _get_options(*args, **kwargs):
         )
         rv["socket_options"] = None
 
-    if rv["enable_tracing"] is not None:
-        warnings.warn(
-            "The `enable_tracing` parameter is deprecated. Please use `traces_sample_rate` instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return rv
 
 
-try:
-    # Python 3.6+
-    module_not_found_error = ModuleNotFoundError
-except Exception:
-    # Older Python versions
-    module_not_found_error = ImportError  # type: ignore
-
-
 class BaseClient:
     """
     .. versionadded:: 2.0.0
@@ -177,7 +153,6 @@ class BaseClient:
 
         self.transport = None  # type: Optional[Transport]
         self.monitor = None  # type: Optional[Monitor]
-        self.metrics_aggregator = None  # type: Optional[MetricsAggregator]
         self.log_batcher = None  # type: Optional[LogBatcher]
 
     def __getstate__(self, *args, **kwargs):
@@ -303,7 +278,7 @@ class _Client(BaseClient):
                 function_obj = getattr(module_obj, function_name)
                 setattr(module_obj, function_name, trace(function_obj))
                 logger.debug("Enabled tracing for %s", function_qualname)
-            except module_not_found_error:
+            except ModuleNotFoundError:
                 try:
                     # Try to import a class
                     # ex: "mymodule.submodule.MyClassName.member_function"
@@ -356,26 +331,7 @@ class _Client(BaseClient):
 
             self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
 
-            self.metrics_aggregator = None  # type: Optional[MetricsAggregator]
             experiments = self.options.get("_experiments", {})
-            if experiments.get("enable_metrics", True):
-                # Context vars are not working correctly on Python <=3.6
-                # with gevent.
-                metrics_supported = not is_gevent() or PY37
-                if metrics_supported:
-                    from sentry_sdk.metrics import MetricsAggregator
-
-                    self.metrics_aggregator = MetricsAggregator(
-                        capture_func=_capture_envelope,
-                        enable_code_locations=bool(
-                            experiments.get("metric_code_locations", True)
-                        ),
-                    )
-                else:
-                    logger.info(
-                        "Metrics not supported on Python 3.6 and lower with gevent."
-                    )
-
             self.log_batcher = None
             if experiments.get("enable_logs", False):
                 from sentry_sdk._log_batcher import LogBatcher
@@ -390,19 +346,6 @@ class _Client(BaseClient):
                     )
                 )
 
-            if self.options["_experiments"].get("otel_powered_performance", False):
-                logger.debug(
-                    "[OTel] Enabling experimental OTel-powered performance monitoring."
-                )
-                self.options["instrumenter"] = INSTRUMENTER.OTEL
-                if (
-                    "sentry_sdk.integrations.opentelemetry.integration.OpenTelemetryIntegration"
-                    not in _DEFAULT_INTEGRATIONS
-                ):
-                    _DEFAULT_INTEGRATIONS.append(
-                        "sentry_sdk.integrations.opentelemetry.integration.OpenTelemetryIntegration",
-                    )
-
             self.integrations = setup_integrations(
                 self.options["integrations"],
                 with_defaults=self.options["default_integrations"],
@@ -450,6 +393,13 @@ class _Client(BaseClient):
                 except Exception as e:
                     logger.debug("Can not set up continuous profiler. (%s)", e)
 
+            from sentry_sdk.opentelemetry.tracing import (
+                patch_readable_span,
+                setup_sentry_tracing,
+            )
+
+            patch_readable_span()
+            setup_sentry_tracing()
         finally:
             _client_init_debug.set(old_debug)
 
@@ -457,7 +407,6 @@ class _Client(BaseClient):
 
         if (
             self.monitor
-            or self.metrics_aggregator
             or self.log_batcher
             or has_profiling_enabled(self.options)
             or isinstance(self.transport, BaseHttpTransport)
@@ -524,7 +473,7 @@ class _Client(BaseClient):
                         )
                 return None
 
-            event = event_
+            event = event_  # type: Optional[Event]  # type: ignore[no-redef]
             spans_delta = spans_before - len(
                 cast(List[Dict[str, object]], event.get("spans", []))
             )
@@ -621,7 +570,7 @@ class _Client(BaseClient):
             and event is not None
             and event.get("type") != "transaction"
         ):
-            new_event = None
+            new_event = None  # type: Optional[Event]
             with capture_internal_exceptions():
                 new_event = before_send(event, hint or {})
             if new_event is None:
@@ -638,7 +587,7 @@ class _Client(BaseClient):
                 if event.get("exception"):
                     DedupeIntegration.reset_last_seen()
 
-            event = new_event
+            event = new_event  # type: Optional[Event]  # type: ignore[no-redef]
 
         before_send_transaction = self.options["before_send_transaction"]
         if (
@@ -662,13 +611,15 @@ class _Client(BaseClient):
                         quantity=spans_before + 1,  # +1 for the transaction itself
                     )
             else:
-                spans_delta = spans_before - len(new_event.get("spans", []))
+                spans_delta = spans_before - len(
+                    cast(List[Dict[str, object]], new_event.get("spans", []))
+                )
                 if spans_delta > 0 and self.transport is not None:
                     self.transport.record_lost_event(
                         reason="before_send", data_category="span", quantity=spans_delta
                     )
 
-            event = new_event
+            event = new_event  # type: Optional[Event]  # type: ignore[no-redef]
 
         return event
 
@@ -915,7 +866,7 @@ class _Client(BaseClient):
             log["attributes"]["sentry.trace.parent_span_id"] = span.span_id
 
         if log.get("trace_id") is None:
-            transaction = current_scope.transaction
+            transaction = current_scope.root_span
             propagation_context = isolation_scope.get_active_propagation_context()
             if transaction is not None:
                 log["trace_id"] = transaction.trace_id
@@ -987,13 +938,15 @@ class _Client(BaseClient):
         """
         if self.transport is not None:
             self.flush(timeout=timeout, callback=callback)
+
             self.session_flusher.kill()
-            if self.metrics_aggregator is not None:
-                self.metrics_aggregator.kill()
+
             if self.log_batcher is not None:
                 self.log_batcher.kill()
+
             if self.monitor:
                 self.monitor.kill()
+
             self.transport.kill()
             self.transport = None
 
@@ -1014,10 +967,10 @@ class _Client(BaseClient):
             if timeout is None:
                 timeout = self.options["shutdown_timeout"]
             self.session_flusher.flush()
-            if self.metrics_aggregator is not None:
-                self.metrics_aggregator.flush()
+
             if self.log_batcher is not None:
                 self.log_batcher.flush()
+
             self.transport.flush(timeout=timeout, callback=callback)
 
     def __enter__(self):