[Experiment] New scope step2

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.sentry_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

@@ -14,6 +14,9 @@ API Docs
 .. autoclass:: sentry_sdk.client._Client
     :members:
 
+.. autoclass:: sentry_sdk.client.NoopClient
+    :members:
+
 .. autoclass:: sentry_sdk.Transport
     :members:
 

sentry_sdk/api.py

@@ -1,6 +1,8 @@
 import inspect
 
+from sentry_sdk import scope
 from sentry_sdk._types import TYPE_CHECKING
+from sentry_sdk.client import Client, NoopClient
 from sentry_sdk.hub import Hub
 from sentry_sdk.scope import Scope
 from sentry_sdk.tracing import NoOpSpan, Transaction
@@ -77,6 +79,79 @@ def scopemethod(f):
     return f
 
 
+def clientemethod(f):
+    # type: (F) -> F
+    f.__doc__ = "%s\n\n%s" % (
+        "Alias for :py:meth:`sentry_sdk._Client.%s`" % f.__name__,
+        inspect.getdoc(getattr(Client, f.__name__)),
+    )
+    return f
+
+
+def sentry_is_initialized():
+    # type: () -> bool
+    """
+    Returns whether Sentry has been initialized or not.
+    If an client is available Sentry is initialized.
+
+    .. versionadded:: 1.XX.0
+    """
+    client = Client.get_client()
+    if client.__class__ == NoopClient:
+        return False
+    else:
+        return True
+
+
+@clientemethod
+def get_client():
+    # type: () -> Union[Client, NoopClient]
+    return Client.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()
+
+
+def set_current_scope(new_current_scope):
+    # type: (Scope) -> None
+    """
+    Sets the given scope as the new current scope overwritting the existing current scope.
+
+    :param new_current_scope: The scope to set as the new current scope.
+
+    .. versionadded:: 1.XX.0
+    """
+
+    scope.sentry_current_scope.set(new_current_scope)
+
+
+def set_isolation_scope(new_isolation_scope):
+    # type: (Scope) -> None
+    """
+    Sets the given scope as the new isolation scope overwritting the existing isolation scope.
+
+    :param new_isolation_scope: The scope to set as the new isolation scope.
+
+    .. versionadded:: 1.XX.0
+    """
+    scope.sentry_isolation_scope.set(new_isolation_scope)
+
+
 @hubmethod
 def capture_event(
     event,  # type: Event

sentry_sdk/client.py

@@ -152,6 +152,12 @@ def _get_options(*args, **kwargs):
 
 
 class NoopClient:
+    """
+    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:: 1.XX.0
+    """
+
     def __repr__(self):
         # type: () -> str
         return "<{} id={}>".format(self.__class__.__name__, id(self))
@@ -241,7 +247,7 @@ class _Client(NoopClient):
     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):
@@ -261,7 +267,12 @@ def __setstate__(self, state):
 
     @classmethod
     def get_client(cls):
-        # type: () -> Union[_Client, NoopClient]
+        # type: () -> Union[Client, NoopClient]
+        """
+        Returns the current :py:class:`sentry_sdk.Client`. If no client is available a :py:class:`sentry_sdk.client.NoopClient` is returned.
+
+        .. versionadded:: 1.XX.0
+        """
         client = Scope.get_current_scope().client
         if client is not None:
             return client

sentry_sdk/scope.py

@@ -210,6 +210,11 @@ def __init__(self, ty=None, client=None):
     @classmethod
     def get_current_scope(cls):
         # type: () -> Scope
+        """
+        Returns the current scope.
+
+        .. versionadded:: 1.XX.0
+        """
         scope = sentry_current_scope.get()
         if scope is None:
             scope = Scope(ty="current")
@@ -220,6 +225,11 @@ def get_current_scope(cls):
     @classmethod
     def get_isolation_scope(cls):
         # type: () -> Scope
+        """
+        Returns the isolation scope.
+
+        .. versionadded:: 1.XX.0
+        """
         scope = sentry_isolation_scope.get()
         if scope is None:
             scope = Scope(ty="isolation")
@@ -230,6 +240,11 @@ def get_isolation_scope(cls):
     @classmethod
     def get_global_scope(cls):
         # type: () -> Scope
+        """
+        Returns the global scope.
+
+        .. versionadded:: 1.XX.0
+        """
         global SENTRY_GLOBAL_SCOPE
         if SENTRY_GLOBAL_SCOPE is None:
             SENTRY_GLOBAL_SCOPE = Scope(ty="global")
@@ -239,24 +254,45 @@ def get_global_scope(cls):
     @property
     def is_forked(self):
         # type: () -> bool
+        """
+        Weither this scope is a fork of another scope.
+
+        .. versionadded:: 1.XX.0
+        """
         return self.original_scope is not None
 
     def fork(self):
         # type: () -> Scope
+        """
+        Returns a fork of this scope.
+
+        .. versionadded:: 1.XX.0
+        """
         self.original_scope = self
         return copy(self)
 
     def isolate(self):
         # type: () -> None
         """
-        Create a new isolation scope for this scope.
+        Creates a new isolation scope for this scope.
+        The new isolation scope will be a fork of the current isolation scope.
+
+        .. versionadded:: 1.XX.0
         """
         isolation_scope = Scope.get_isolation_scope()
         forked_isolation_scope = isolation_scope.fork()
         sentry_isolation_scope.set(forked_isolation_scope)
 
     def set_client(self, client=None):
         # type: (Optional[sentry_sdk.Client]) -> None
+        """
+        Sets the client for this scope.
+
+        :param client: The client to use in this scope.
+            If `None` the client of the scope will be deleted.
+
+        .. versionadded:: 1.XX.0
+        """
         self.client = client
 
     def _load_trace_data_from_env(self):