feat: Initial commit

mitsuhiko · mitsuhiko · commit f9b10756f685 · 2018-06-19T00:48:08.000+02:00
diff --git a/sentry_sdk/__init__.py b/sentry_sdk/__init__.py
@@ -0,0 +1,2 @@
+from .api import *
+from .api import __all__
diff --git a/sentry_sdk/_compat.py b/sentry_sdk/_compat.py
@@ -0,0 +1,28 @@
+import sys
+
+
+PY2 = sys.version_info[0] == 2
+
+if PY2:
+    import urlparse
+    text_type = unicode
+    import Queue as queue
+    number_types = (int, long, float)
+
+    def implements_str(cls):
+        cls.__unicode__ = cls.__str__
+        cls.__str__ = lambda x: unicode(x).encode('utf-8')
+        return cls
+else:
+    import urllib.parse as urlparse
+    import queue
+    text_type = str
+    implements_str = lambda x: x
+    number_types = (int, float)
+
+
+def with_metaclass(meta, *bases):
+    class metaclass(type):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
diff --git a/sentry_sdk/api.py b/sentry_sdk/api.py
@@ -0,0 +1,62 @@
+import atexit
+
+from .hub import Hub
+from .client import Client
+
+
+__all__ = ['Hub', 'Client']
+
+
+def public(f):
+    __all__.append(f.__name__)
+    return f
+
+
+class _InitGuard(object):
+
+    def __init__(self, client):
+        self._client = client
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):
+        c = self._client
+        if c is not None:
+            c.close()
+
+
+@public
+def init(*args, **kwargs):
+    client = Client(*args, **kwargs)
+    if client.dsn is not None:
+        Hub.main.bind_client(client)
+    return _InitGuard(client)
+
+
+@public
+def capture_event(event):
+    hub = Hub.current
+    if hub is not None:
+        return hub.capture_event(event)
+
+
+@public
+def capture_message(message, level=None):
+    hub = Hub.current
+    if hub is not None:
+        return hub.capture_message(message, level)
+
+
+@public
+def capture_exception(error=None):
+    hub = Hub.current
+    if hub is not None:
+        return hub.capture_exception(error)
+
+
+@public
+def add_breadcrumb(crumb):
+    hub = Hub.current
+    if hub is not None:
+        return hub.add_breadcrumb(crumb)
diff --git a/sentry_sdk/client.py b/sentry_sdk/client.py
@@ -0,0 +1,76 @@
+import os
+import uuid
+
+from .utils import Dsn
+from .transport import Transport
+from .consts import DEFAULT_OPTIONS, SDK_INFO
+
+
+NO_DSN = object()
+
+
+class Client(object):
+
+    def __init__(self, dsn=None, *args, **kwargs):
+        if dsn is NO_DSN:
+            dsn = None
+        else:
+            if dsn is None:
+                dsn = os.environ.get('SENTRY_DSN')
+            if not dsn:
+                dsn = None
+            else:
+                dsn = Dsn(dsn)
+        options = dict(DEFAULT_OPTIONS)
+        options.update(*args, **kwargs)
+        self.options = options
+        if dsn is None:
+            self._transport = None
+        else:
+            self._transport = Transport(dsn)
+            self._transport.start()
+
+    @property
+    def dsn(self):
+        """The DSN that created this event."""
+        if self._transport is not None:
+            return self._transport.dsn
+
+    @classmethod
+    def disabled(cls):
+        """Creates a guarnateed to be disabled client."""
+        return cls(NO_DSN)
+
+    def _prepare_event(self, event, scope):
+        if event.get('event_id') is None:
+            event['event_id'] = uuid.uuid4().hex
+
+        if scope is not None:
+            scope.apply_to_event(event)
+
+        for key in 'release', 'environment', 'server_name':
+            if event.get(key) is None:
+                event[key] = self.options[key]
+        if event.get('sdk') is None:
+            event['sdk'] = SDK_INFO
+
+        if event.get('platform') is None:
+            event['platform'] = 'python'
+
+    def capture_event(self, event, scope=None):
+        """Captures an event."""
+        if self._transport is None:
+            return
+        self._prepare_event(event, scope)
+        self._transport.capture_event(event)
+
+    def drain_events(self, timeout=None):
+        if timeout is None:
+            timeout = self.options['drain_timeout']
+        if self._transport is not None:
+            self._transport.drain_events(timeout)
+
+    def close(self):
+        self.drain_events()
+        if self._transport is not None:
+            self._transport.close()
diff --git a/sentry_sdk/consts.py b/sentry_sdk/consts.py
@@ -0,0 +1,17 @@
+import socket
+
+VERSION = '0.1'
+DEFAULT_SERVER_NAME = socket.gethostname() if hasattr(socket, 'gethostname') else None
+DEFAULT_OPTIONS = {
+    'with_locals': True,
+    'max_breadcrumbs': 100,
+    'release': None,
+    'environment': None,
+    'server_name': DEFAULT_SERVER_NAME,
+    'drain_timeout': 2.0,
+}
+
+SDK_INFO = {
+    'name': 'sentry-python',
+    'version': VERSION,
+}
diff --git a/sentry_sdk/hub.py b/sentry_sdk/hub.py
@@ -0,0 +1,168 @@
+import sys
+import copy
+import linecache
+from threading import local
+from contextlib import contextmanager
+
+from ._compat import with_metaclass
+from .scope import Scope
+from .utils import exceptions_from_error_tuple, create_event, \
+    skip_internal_frames
+
+
+_local = local()
+
+
+class HubMeta(type):
+
+    @property
+    def current(self):
+        try:
+            rv = _local.hub
+        except AttributeError:
+            _local.hub = rv = Hub(GLOBAL_HUB)
+        return rv
+
+    @property
+    def main(self):
+        return GLOBAL_HUB
+
+
+class _HubManager(object):
+
+    def __init__(self, hub):
+        self._old = Hub.current
+        _local.hub = hub
+
+    def __exit__(self, exc_type, exc_value, tb):
+        _local.hub = self._old
+
+
+class _ScopeManager(object):
+
+    def __init__(self, hub):
+        self._hub = hub
+
+    def __exit__(self, exc_type, exc_value, tb):
+        self._hub.stack.pop()
+
+
+class Hub(with_metaclass(HubMeta)):
+
+    def __init__(self, client_or_hub=None, scope=None):
+        if isinstance(client_or_hub, Hub):
+            hub = client_or_hub
+            client, other_scope = hub._stack[-1]
+            if scope is None:
+                hub._flush_event_processors()
+                scope = copy.copy(other_scope)
+        else:
+            client = client_or_hub
+        if scope is None:
+            scope = Scope()
+        self._stack = [(client, scope)]
+        self._pending_processors = []
+
+    def __enter__(self):
+        return _HubManager(self)
+
+    def run(self, callback):
+        """Runs a callback in the context of the hub.  Alternatively the
+        with statement can be used on the hub directly.
+        """
+        with self:
+            callback()
+
+    @property
+    def client(self):
+        """Returns the current client on the hub."""
+        return self._stack[-1][0]
+
+    def bind_client(self, new):
+        """Binds a new client to the hub."""
+        top = self._stack[-1]
+        self._stack[-1] = (new, top[1])
+
+    def capture_event(self, event):
+        """Captures an event."""
+        self._flush_event_processors()
+        client, scope = self._stack[-1]
+        if client is not None:
+            client.capture_event(event, scope)
+            return event.get('event_id')
+
+    def capture_message(self, message, level=None):
+        """Captures a message."""
+        if self.client is None:
+            return
+        if level is None:
+            level = 'info'
+        event = create_event()
+        event['message'] = message
+        if level is not None:
+            event['level'] = level
+        return self.capture_event(event)
+
+    def capture_exception(self, error=None):
+        """Captures an exception."""
+        client = self.client
+        if client is None:
+            return
+        if error is None:
+            exc_type, exc_value, tb = sys.exc_info()
+        else:
+            tb = getattr(error, '__traceback__', None)
+            if tb is not None:
+                exc_type = type(error)
+                exc_value = error
+            else:
+                exc_type, exc_value, tb = sys.exc_info()
+                tb = skip_internal_frames(tb)
+                if exc_value is not error:
+                    tb = None
+                    exc_value = error
+                    exc_type = type(error)
+
+        event = create_event()
+        event['exception'] = {
+            'values': exceptions_from_error_tuple(
+                exc_type, exc_value, tb, client.options['with_locals'])
+        }
+        return self.capture_event(event)
+
+    def add_breadcrumb(self, crumb):
+        """Adds a breadcrumb."""
+        client, scope = self._stack[-1]
+        if client is None:
+            return
+        if callable(crumb):
+            crumb = crumb()
+        if crumb is not None:
+            scope.breadcrumbs.append(crumb)
+        while len(scope.breadcrumbs) >= client.options['max_breadcrumbs']:
+            scope.breadcrumbs.popleft()
+
+    def add_event_processor(self, factory):
+        """Registers a new event processor with the top scope."""
+        self._pending_processors.append(factory)
+
+    def push_scope(self):
+        """Pushes a new layer on the scope stack."""
+        client, scope = self._stack[-1]
+        self._stack.append((client, copy.copy(scope)))
+        return _ScopeManager(self)
+
+    @contextmanager
+    def configure_scope(self):
+        """Reconfigures the scope."""
+        yield self._stack[-1][1]
+
+    def _flush_event_processors(self):
+        rv = self._pending_processors
+        self._pending_processors = []
+        top = self._stack[-1][1]
+        for factory in rv:
+            top._event_processors.append(factory())
+
+
+GLOBAL_HUB = Hub()
diff --git a/sentry_sdk/scope.py b/sentry_sdk/scope.py
diff --git a/sentry_sdk/transport.py b/sentry_sdk/transport.py
diff --git a/sentry_sdk/utils.py b/sentry_sdk/utils.py

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from .api import *`
	`2`	`+from .api import __all__`