(1) Add new scopes related API (but not yet calling it)

docs/api.rst

@@ -41,6 +41,19 @@ Distributed Tracing
 .. autofunction:: sentry_sdk.api.get_traceparent
 
 
+New Scopes/Client APIs
+======================
+
+.. autofunction:: sentry_sdk.api.get_client
+.. autofunction:: sentry_sdk.api.is_initialized
+.. autofunction:: sentry_sdk.api.get_current_scope
+.. autofunction:: sentry_sdk.api.get_isolation_scope
+.. autofunction:: sentry_sdk.api.get_global_scope    
+
+.. autofunction:: sentry_sdk.api.set_current_scope
+.. autofunction:: sentry_sdk.api.set_isolation_scope
+
+
 Managing Scope (advanced)
 =========================
 

docs/apidocs.rst

@@ -11,6 +11,12 @@ API Docs
 .. autoclass:: sentry_sdk.Client
     :members:
 
+.. autoclass:: sentry_sdk.client.BaseClient
+    :members:
+
+.. autoclass:: sentry_sdk.client.NonRecordingClient
+    :members:
+
 .. autoclass:: sentry_sdk.client._Client
     :members:
 

sentry_sdk/__init__.py

@@ -19,26 +19,35 @@
     "init",
     "integrations",
     # From sentry_sdk.api
+    "add_breadcrumb",
     "capture_event",
-    "capture_message",
     "capture_exception",
-    "add_breadcrumb",
+    "capture_message",
     "configure_scope",
-    "push_scope",
+    "continue_trace",
     "flush",
+    "get_baggage",
+    "get_client",
+    "get_current_scope",
+    "get_current_span",
+    "get_global_scope",
+    "get_isolation_scope",
+    "get_traceparent",
+    "is_initialized",
+    "isolated_scope",
     "last_event_id",
-    "start_span",
-    "start_transaction",
-    "set_tag",
+    "new_scope",
+    "push_scope",
     "set_context",
+    "set_current_scope",
     "set_extra",
-    "set_user",
+    "set_isolation_scope",
     "set_level",
     "set_measurement",
-    "get_current_span",
-    "get_traceparent",
-    "get_baggage",
-    "continue_trace",
+    "set_tag",
+    "set_user",
+    "start_span",
+    "start_transaction",
     "trace",
 ]
 

sentry_sdk/api.py

@@ -2,7 +2,7 @@
 
 from sentry_sdk._types import TYPE_CHECKING
 from sentry_sdk.hub import Hub
-from sentry_sdk.scope import Scope
+from sentry_sdk.scope import Scope, new_scope, isolated_scope
 from sentry_sdk.tracing import NoOpSpan, Transaction
 
 if TYPE_CHECKING:
@@ -15,6 +15,7 @@
     from typing import ContextManager
     from typing import Union
 
+    from sentry_sdk.client import BaseClient
     from sentry_sdk._types import (
         Event,
         Hint,
@@ -36,26 +37,35 @@ def overload(x):
 
 # When changing this, update __all__ in __init__.py too
 __all__ = [
+    "add_breadcrumb",
     "capture_event",
-    "capture_message",
     "capture_exception",
-    "add_breadcrumb",
+    "capture_message",
     "configure_scope",
-    "push_scope",
+    "continue_trace",
     "flush",
+    "get_baggage",
+    "get_client",
+    "get_current_scope",
+    "get_current_span",
+    "get_global_scope",
+    "get_isolation_scope",
+    "get_traceparent",
+    "is_initialized",
+    "isolated_scope",
     "last_event_id",
-    "start_span",
-    "start_transaction",
-    "set_tag",
+    "new_scope",
+    "push_scope",
     "set_context",
+    "set_current_scope",
     "set_extra",
-    "set_user",
+    "set_isolation_scope",
     "set_level",
     "set_measurement",
-    "get_current_span",
-    "get_traceparent",
-    "get_baggage",
-    "continue_trace",
+    "set_tag",
+    "set_user",
+    "start_span",
+    "start_transaction",
 ]
 
 
@@ -77,6 +87,53 @@ def scopemethod(f):
     return f
 
 
+def is_initialized():
+    # type: () -> bool
+    """
+    Returns whether Sentry has been initialized or not.
+    If a client is available Sentry is initialized.
+
+    .. versionadded:: 2.0.0
+    """
+    return Scope.get_client().is_active()
+
+
+@scopemethod
+def get_client():
+    # type: () -> BaseClient
+    return Scope.get_client()
+
+
+@scopemethod
+def get_current_scope():
+    # type: () -> Scope
+    return Scope.get_current_scope()
+
+
+@scopemethod
+def get_isolation_scope():
+    # type: () -> Scope
+    return Scope.get_isolation_scope()
+
+
+@scopemethod
+def get_global_scope():
+    # type: () -> Scope
+    return Scope.get_global_scope()
+
+
+@scopemethod
+def set_current_scope(new_current_scope):
+    # type: (Scope) -> None
+    return Scope.set_current_scope(new_current_scope)
+
+
+@scopemethod
+def set_isolation_scope(new_isolation_scope):
+    # type: (Scope) -> None
+    return Scope.set_isolation_scope(new_isolation_scope)
+
+
 @hubmethod
 def capture_event(
     event,  # type: Event

sentry_sdk/client.py

@@ -46,10 +46,12 @@
     from typing import Type
     from typing import Union
 
+    from sentry_sdk._types import Event, Hint
     from sentry_sdk.integrations import Integration
+    from sentry_sdk.metrics import MetricsAggregator
     from sentry_sdk.scope import Scope
-    from sentry_sdk._types import Event, Hint
     from sentry_sdk.session import Session
+    from sentry_sdk.transport import Transport
 
 
 _client_init_debug = ContextVar("client_init_debug")
@@ -151,19 +153,101 @@ def _get_options(*args, **kwargs):
     module_not_found_error = ImportError  # type: ignore
 
 
-class _Client(object):
-    """The client is internally responsible for capturing the events and
+class BaseClient(object):
+    """
+    The basic definition of a client that is used for sending data to Sentry.
+
+    .. versionadded:: 2.0.0
+    """
+
+    def __init__(self, options=None):
+        # type: (Optional[Dict[str, Any]]) -> None
+        self.options = (
+            options if options is not None else DEFAULT_OPTIONS
+        )  # type: Dict[str, Any]
+
+        self.transport = None  # type: Optional[Transport]
+        self.monitor = None  # type: Optional[Monitor]
+        self.metrics_aggregator = None  # type: Optional[MetricsAggregator]
+
+    def __getstate__(self, *args, **kwargs):
+        # type: (*Any, **Any) -> Any
+        return {"options": {}}
+
+    def __setstate__(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        pass
+
+    @property
+    def dsn(self):
+        # type: () -> Optional[str]
+        return None
+
+    def should_send_default_pii(self):
+        # type: () -> bool
+        return False
+
+    def is_active(self):
+        # type: () -> bool
+        """
+        Returns whether the client is active (able to send data to Sentry)
+
+        .. versionadded:: 2.0.0
+        """
+        return False
+
+    def capture_event(self, *args, **kwargs):
+        # type: (*Any, **Any) -> Optional[str]
+        return None
+
+    def capture_session(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        return None
+
+    def get_integration(self, *args, **kwargs):
+        # type: (*Any, **Any) -> Optional[Integration]
+        return None
+
+    def close(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        return None
+
+    def flush(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        return None
+
+    def __enter__(self):
+        # type: () -> BaseClient
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):
+        # type: (Any, Any, Any) -> None
+        return None
+
+
+class NonRecordingClient(BaseClient):
+    """
+    A client that does not send any events to Sentry. This is used as a fallback when the Sentry SDK is not yet initialized.
+
+    .. versionadded:: 2.0.0
+    """
+
+    pass
+
+
+class _Client(BaseClient):
+    """
+    The client is internally responsible for capturing the events and
     forwarding them to sentry through the configured transport.  It takes
     the client options as keyword arguments and optionally the DSN as first
     argument.
 
-    Alias of :py:class:`Client`. (Was created for better intelisense support)
+    Alias of :py:class:`sentry_sdk.Client`. (Was created for better intelisense support)
     """
 
     def __init__(self, *args, **kwargs):
         # type: (*Any, **Any) -> None
-        self.options = get_options(*args, **kwargs)  # type: Dict[str, Any]
-
+        super(_Client, self).__init__(options=get_options(*args, **kwargs))
         self._init_impl()
 
     def __getstate__(self):
@@ -303,6 +387,15 @@ def _capture_envelope(envelope):
 
         self._setup_instrumentation(self.options.get("functions_to_trace", []))
 
+    def is_active(self):
+        # type: () -> bool
+        """
+        Returns whether the client is active (able to send data to Sentry)
+
+        .. versionadded:: 2.0.0
+        """
+        return True
+
     @property
     def dsn(self):
         # type: () -> Optional[str]
@@ -569,7 +662,6 @@ def capture_event(
         :param hint: Contains metadata about the event that can be read from `before_send`, such as the original exception object or a HTTP request object.
 
         :param scope: An optional :py:class:`sentry_sdk.Scope` to apply to events.
-            The `scope` and `scope_kwargs` parameters are mutually exclusive.
 
         :returns: An event ID. May be `None` if there is no DSN set or of if the SDK decided to discard the event for other reasons. In such situations setting `debug=True` on `init()` may help.
         """