def __call__(self, environ, start_response):
# type: (Dict[str, str], Callable[..., Any]) -> _ScopedResponse
if _wsgi_middleware_applied.get(False):
return self.app(environ, start_response)
_wsgi_middleware_applied.set(True)
try:
hub = Hub(Hub.current)
with hub:
with capture_internal_exceptions():
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope._name = "wsgi"
scope.add_event_processor(
_make_wsgi_event_processor(environ))
span = Span.continue_from_environ(environ)
span.op = "http.server"
span.transaction = "generic WSGI request"
with hub.start_span(span) as span:
try:
rv = self.app(
environ,
functools.partial(_sentry_start_response,
start_response, span),
)
except BaseException:
reraise(*_capture_exception(hub))
finally:
_wsgi_middleware_applied.set(False)
return _ScopedResponse(hub, rv)
def __call__(self, environ, start_response):
# type: (Dict[str, str], Callable[..., Any]) -> _ScopedResponse
if _wsgi_middleware_applied.get(False):
return self.app(environ, start_response)
_wsgi_middleware_applied.set(True)
try:
hub = Hub(Hub.current)
with auto_session_tracking(hub, session_mode="request"):
with hub:
with capture_internal_exceptions():
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope._name = "wsgi"
scope.add_event_processor(
_make_wsgi_event_processor(environ))
transaction = Transaction.continue_from_environ(
environ, op="http.server", name="generic WSGI request")
with hub.start_transaction(
transaction,
custom_sampling_context={"wsgi_environ": environ}):
try:
rv = self.app(
environ,
partial(_sentry_start_response, start_response,
transaction),
)
except BaseException:
reraise(*_capture_exception(hub))
finally:
_wsgi_middleware_applied.set(False)
return _ScopedResponse(hub, rv)
async def _run_app(self, scope, callback):
# type: (Any, Any) -> Any
if _asgi_middleware_applied.get(False):
return await callback()
_asgi_middleware_applied.set(True)
try:
hub = Hub(Hub.current)
with hub:
with hub.configure_scope() as sentry_scope:
sentry_scope.clear_breadcrumbs()
sentry_scope._name = "asgi"
processor = functools.partial(self.event_processor,
asgi_scope=scope)
sentry_scope.add_event_processor(processor)
if scope["type"] in ("http", "websocket"):
span = Span.continue_from_headers(dict(scope["headers"]))
span.op = "{}.server".format(scope["type"])
else:
span = Span()
span.op = "asgi.server"
span.set_tag("asgi.type", scope["type"])
span.transaction = "generic ASGI request"
with hub.start_span(span) as span:
try:
return await callback()
except Exception as exc:
_capture_exception(hub, exc)
raise exc from None
finally:
_asgi_middleware_applied.set(False)
async def _run_app(self, scope, callback):
# type: (Any, Any) -> Any
is_recursive_asgi_middleware = _asgi_middleware_applied.get(False)
if is_recursive_asgi_middleware:
try:
return await callback()
except Exception as exc:
_capture_exception(Hub.current, exc)
raise exc from None
_asgi_middleware_applied.set(True)
try:
hub = Hub(Hub.current)
with auto_session_tracking(hub, session_mode="request"):
with hub:
with hub.configure_scope() as sentry_scope:
sentry_scope.clear_breadcrumbs()
sentry_scope._name = "asgi"
processor = partial(self.event_processor,
asgi_scope=scope)
sentry_scope.add_event_processor(processor)
ty = scope["type"]
if ty in ("http", "websocket"):
transaction = Transaction.continue_from_headers(
self._get_headers(scope),
op="{}.server".format(ty),
)
else:
transaction = Transaction(op="asgi.server")
transaction.name = _DEFAULT_TRANSACTION_NAME
transaction.set_tag("asgi.type", ty)
with hub.start_transaction(
transaction,
custom_sampling_context={"asgi_scope": scope}):
# XXX: Would be cool to have correct span status, but we
# would have to wrap send(). That is a bit hard to do with
# the current abstraction over ASGI 2/3.
try:
return await callback()
except Exception as exc:
_capture_exception(hub, exc)
raise exc from None
finally:
_asgi_middleware_applied.set(False)
async def inner():
# type: () -> Any
hub = Hub.current
if hub.get_integration(AioHttpIntegration) is None:
return await old_handle(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(Hub.current) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope.add_event_processor(
_make_request_processor(weak_request))
span = Span.continue_from_headers(request.headers)
span.op = "http.server"
# If this transaction name makes it to the UI, AIOHTTP's
# URL resolver did not find a route or died trying.
span.transaction = "generic AIOHTTP request"
with hub.start_span(span):
try:
response = await old_handle(self, request)
except HTTPException as e:
span.set_http_status(e.status_code)
raise
except Exception:
# This will probably map to a 500 but seems like we
# have no way to tell. Do not set span status.
reraise(*_capture_exception(hub))
span.set_http_status(response.status)
return response
def __call__(self, environ, start_response):
hub = Hub(Hub.current)
with hub:
with capture_internal_exceptions():
with hub.configure_scope() as scope:
scope._name = "wsgi"
scope.add_event_processor(
_make_wsgi_event_processor(environ))
try:
rv = self.app(environ, start_response)
except Exception:
reraise(*_capture_exception(hub))
return _ScopedResponse(hub, rv)
def _handle_request_impl(self):
# type: (RequestHandler) -> Generator[None, None, None]
hub = Hub.current
integration = hub.get_integration(TornadoIntegration)
if integration is None:
yield
weak_handler = weakref.ref(self)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
processor = _make_event_processor(weak_handler) # type: ignore
scope.add_event_processor(processor)
transaction = Transaction.continue_from_headers(
self.request.headers,
op="http.server",
# Like with all other integrations, this is our
# fallback transaction in case there is no route.
# sentry_urldispatcher_resolve is responsible for
# setting a transaction name later.
name="generic Tornado request",
)
with hub.start_transaction(
transaction, custom_sampling_context={"tornado_request": self.request}
):
yield
async def inner():
# type: () -> Any
hub = Hub.current
if hub.get_integration(AioHttpIntegration) is None:
return await old_handle(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(Hub.current) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope.add_event_processor(
_make_request_processor(weak_request))
# If this transaction name makes it to the UI, AIOHTTP's
# URL resolver did not find a route or died trying.
with hub.start_span(transaction="generic AIOHTTP request"):
try:
response = await old_handle(self, request)
except HTTPException:
raise
except Exception:
reraise(*_capture_exception(hub))
return response
async def cobraHandlerWrapper(websocket, path, app, redisUrls: str):
userAgent = websocket.requestHeaders.get('User-Agent',
'unknown-user-agent')
with Hub(Hub.current):
with configure_scope() as scope:
scope.set_tag("user_agent", userAgent)
await cobraHandler(websocket, path, app, redisUrls, userAgent)
async def wrap(*args, **kwargs):
with Hub(Hub.current) as hub:
with hub.push_scope() as scope:
scope.add_event_processor(_process_ws)
for key, builder in ext._scopes.items():
scope.set_extra(key, await builder())
try:
return await dispatch_method(*args, **kwargs)
except Exception as exc:
_capture_exception(hub, exc)
raise
def __call__(self, environ, start_response):
# type: (Dict[str, str], Callable) -> _ScopedResponse
hub = Hub(Hub.current)
with hub:
with capture_internal_exceptions():
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope._name = "wsgi"
scope.set_span_context(
SpanContext.continue_from_environ(environ))
scope.add_event_processor(
_make_wsgi_event_processor(environ))
try:
rv = self.app(environ, start_response)
except BaseException:
reraise(*_capture_exception(hub))
return _ScopedResponse(hub, rv)
async def sentry_execute_request_handler(self, *args, **kwargs):
hub = Hub.current
integration = hub.get_integration(TornadoIntegration)
if integration is None:
return await old_execute(self, *args, **kwargs)
weak_handler = weakref.ref(self)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.add_event_processor(_make_event_processor(weak_handler))
return await old_execute(self, *args, **kwargs)
def inner(*args, **kwargs):
with Hub(Hub.current) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
try:
return f(*args, **kwargs)
except Exception:
_capture_and_reraise()
finally:
if flush:
_flush_client()
async def sentry_execute_request_handler(self, *args, **kwargs):
# type: (Any, *Any, **Any) -> Any
hub = Hub.current
weak_handler = weakref.ref(self)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
processor = _make_event_processor(weak_handler)
scope.add_event_processor(processor)
return await old_execute(self, *args, **kwargs)
def _run_app(self, scope, callback):
# type: (Any, Any) -> Any
if _asgi_middleware_applied.get(False):
response = yield from callback()
return response
_asgi_middleware_applied.set(True)
try:
hub = Hub(Hub.current)
with hub:
with hub.configure_scope() as sentry_scope:
sentry_scope.clear_breadcrumbs()
sentry_scope._name = "asgi"
processor = functools.partial(self.event_processor,
asgi_scope=scope)
sentry_scope.add_event_processor(processor)
if scope["type"] in ("http", "websocket"):
span = Span.continue_from_headers(dict(scope["headers"]))
span.op = "{}.server".format(scope["type"])
else:
span = Span()
span.op = "asgi.server"
span.set_tag("asgi.type", scope["type"])
span.transaction = "generic ASGI request"
with hub.start_span(span) as span:
# XXX: Would be cool to have correct span status, but we
# would have to wrap send(). That is a bit hard to do with
# the current abstraction over ASGI 2/3.
try:
response = yield from callback()
return response
except Exception as exc:
_capture_exception(hub, exc)
raise exc from None
finally:
_asgi_middleware_applied.set(False)
def sentry_execute_request_handler(self, *args, **kwargs):
# type: (RequestHandler, *Any, **Any) -> Any
hub = Hub.current
integration = hub.get_integration(TornadoIntegration)
if integration is None:
return old_execute(self, *args, **kwargs)
weak_handler = weakref.ref(self)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.add_event_processor(_make_event_processor(weak_handler))
result = yield from old_execute(self, *args, **kwargs)
return result
def __call__(self, environ, start_response):
# type: (Dict[str, str], Callable) -> _ScopedResponse
hub = Hub(Hub.current)
with hub:
with capture_internal_exceptions():
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope._name = "wsgi"
scope.add_event_processor(
_make_wsgi_event_processor(environ))
span = Span.continue_from_environ(environ)
span.op = "http.server"
span.transaction = "generic WSGI request"
with hub.span(span):
try:
rv = self.app(environ, start_response)
except BaseException:
reraise(*_capture_exception(hub))
return _ScopedResponse(hub, rv)
async def sentry_execute_request_handler(self, *args, **kwargs):
# type: (Any, *Any, **Any) -> Any
hub = Hub.current
integration = hub.get_integration(TornadoIntegration)
if integration is None:
return await old_execute(self, *args, **kwargs)
weak_handler = weakref.ref(self)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
processor = _make_event_processor(weak_handler) # type: ignore
scope.add_event_processor(processor)
return await old_execute(self, *args, **kwargs)
async def wrap(*args, **kwargs):
with Hub(Hub.current) as hub:
with hub.push_scope() as scope:
scope.add_event_processor(_process_http)
for key, builder in ext._scopes.items():
scope.set_extra(key, await builder())
try:
return await dispatch_method(*args, **kwargs)
except HTTPResponse:
raise
except Exception as exc:
scope.set_extra("body_params", await
current.request.body_params)
_capture_exception(hub, exc)
raise
async def sentry_handle_request(self, request, *args, **kwargs):
hub = Hub.current
if hub.get_integration(SanicIntegration) is None:
return old_handle_request(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.add_event_processor(_make_request_processor(weak_request))
response = old_handle_request(self, request, *args, **kwargs)
if isawaitable(response):
response = await response
return response
async def wrap(*args, **kwargs):
with Hub(Hub.current) as hub:
with hub.push_scope() as scope:
scope.add_event_processor(_process_ws)
for key, builder in ext._scopes.items():
scope.set_extra(key, await builder())
txn = Transaction.continue_from_headers(
current.request._scope["headers"], op="websocket.server")
txn.set_tag("asgi.type", "websocket")
with hub.start_transaction(txn):
try:
return await dispatch_method(*args, **kwargs)
except Exception as exc:
_capture_exception(hub, exc)
raise
async def _run_app(self, scope, callback):
hub = Hub.current
with Hub(hub) as hub:
with hub.configure_scope() as sentry_scope:
sentry_scope._name = "asgi"
sentry_scope.transaction = scope.get(
"path") or "unknown asgi request"
processor = functools.partial(self.event_processor,
asgi_scope=scope)
sentry_scope.add_event_processor(processor)
try:
await callback()
except Exception as exc:
hub.capture_exception(exc)
raise exc from None
async def _hub_enter(request):
# type: (Request) -> None
hub = Hub.current
request.ctx._sentry_do_integration = (
hub.get_integration(SanicIntegration) is not None
)
if not request.ctx._sentry_do_integration:
return
weak_request = weakref.ref(request)
request.ctx._sentry_hub = Hub(hub)
request.ctx._sentry_hub.__enter__()
with request.ctx._sentry_hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope.add_event_processor(_make_request_processor(weak_request))
async def _legacy_handle_request(self, request, *args, **kwargs):
# type: (Any, Request, *Any, **Any) -> Any
hub = Hub.current
if hub.get_integration(SanicIntegration) is None:
return old_handle_request(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope.add_event_processor(_make_request_processor(weak_request))
response = old_handle_request(self, request, *args, **kwargs)
if isawaitable(response):
response = await response
return response
async def inner():
hub = Hub.current
if hub.get_integration(AioHttpIntegration) is None:
return old_handle(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(Hub.current) as hub:
with hub.configure_scope() as scope:
scope.add_event_processor(_make_request_processor(weak_request))
try:
response = await old_handle(self, request)
except HTTPException:
raise
except Exception:
reraise(*_capture_exception(hub))
return response
async def sentry_app_handle(self, request, *args, **kwargs):
# type: (Any, Request, *Any, **Any) -> Any
hub = Hub.current
if hub.get_integration(AioHttpIntegration) is None:
return await old_handle(self, request, *args, **kwargs)
weak_request = weakref.ref(request)
with Hub(hub) as hub:
# Scope data will not leak between requests because aiohttp
# create a task to wrap each request.
with hub.configure_scope() as scope:
scope.clear_breadcrumbs()
scope.add_event_processor(
_make_request_processor(weak_request))
transaction = Transaction.continue_from_headers(
request.headers,
op="http.server",
# If this transaction name makes it to the UI, AIOHTTP's
# URL resolver did not find a route or died trying.
name="generic AIOHTTP request",
)
with hub.start_transaction(
transaction,
custom_sampling_context={"aiohttp_request": request}):
try:
response = await old_handle(self, request)
except HTTPException as e:
transaction.set_http_status(e.status_code)
raise
except (asyncio.CancelledError, ConnectionResetError):
transaction.set_status("cancelled")
raise
except Exception:
# This will probably map to a 500 but seems like we
# have no way to tell. Do not set span status.
reraise(*_capture_exception(hub))
transaction.set_http_status(response.status)
return response
def sentry_patched_perform_job(self, job, *args, **kwargs):
hub = Hub.current
integration = hub.get_integration(RqIntegration)
if integration is None:
return old_perform_job(self, job, *args, **kwargs)
with Hub(hub) as hub:
with hub.configure_scope() as scope:
scope.add_event_processor(
_make_event_processor(weakref.ref(job)))
rv = old_perform_job(self, job, *args, **kwargs)
if self.is_horse:
# We're inside of a forked process and RQ is
# about to call `os._exit`. Make sure that our
# events get sent out.
#
# Closing the client should not affect other jobs since
# we're in a different process
hub.client.close()
return rv
def capture_message(message, level):
with Hub(Hub.current) as hub:
_capture_message(hub, message, level=level)
def capture_exception(exception):
with Hub(Hub.current) as hub:
_capture_exception(hub, exception)
logger = logging.getLogger(__name__)
_client = Client(
dsn=SENTRY_DSN,
default_integrations=False,
integrations=[
ExcepthookIntegration(),
DedupeIntegration(),
StdlibIntegration(),
ModulesIntegration(),
ArgvIntegration(),
],
max_breadcrumbs=5,
attach_stacktrace=True,
)
_hub = Hub(_client)
def report(msg=None, **kw):
if not _hub:
return
try:
extra = kw.pop('extra', {})
with sentry_sdk.push_scope() as scope:
for k, v in extra.items():
scope.set_extra(k, v)
scope.level = kw.pop('level', logging.ERROR)
if 'user' in kw:
scope.user = kw.get('user')
