FM / integrations

/opt/cloudlinux/venv/lib/python3.11/site-packages/sentry_sdk/integrations/

/opt/cloudlinux/venv/lib/python3.11/site-packages/sentry_sdk/integrations

Name	Size	Mode	Actions
django/	-	0755	rm
grpc/	-	0755	rm
opentelemetry/	-	0755	rm
redis/	-	0755	rm
spark/	-	0755	rm
__pycache__/	-	0755	rm
aiohttp.py	11553	0644	edit dl rm
argv.py	963	0644	edit dl rm
arq.py	6737	0644	edit dl rm
asgi.py	11821	0644	edit dl rm
asyncio.py	3049	0644	edit dl rm
atexit.py	1846	0644	edit dl rm
aws_lambda.py	15815	0644	edit dl rm
beam.py	5689	0644	edit dl rm
boto3.py	4542	0644	edit dl rm
bottle.py	6471	0644	edit dl rm
celery.py	19100	0644	edit dl rm
chalice.py	4769	0644	edit dl rm
cloud_resource_context.py	6755	0644	edit dl rm
dedupe.py	1184	0644	edit dl rm
excepthook.py	2260	0644	edit dl rm
executing.py	2041	0644	edit dl rm
falcon.py	7984	0644	edit dl rm
fastapi.py	4496	0644	edit dl rm
flask.py	7907	0644	edit dl rm
gcp.py	8213	0644	edit dl rm
gnu_backtrace.py	2930	0644	edit dl rm
httpx.py	5005	0644	edit dl rm
huey.py	4700	0644	edit dl rm
logging.py	9181	0644	edit dl rm
loguru.py	3051	0644	edit dl rm
modules.py	2110	0644	edit dl rm
pure_eval.py	4554	0644	edit dl rm
pymongo.py	6007	0644	edit dl rm
pyramid.py	7442	0644	edit dl rm
quart.py	7377	0644	edit dl rm
rq.py	5411	0644	edit dl rm
sanic.py	11326	0644	edit dl rm
serverless.py	1975	0644	edit dl rm
socket.py	2945	0644	edit dl rm
sqlalchemy.py	4244	0644	edit dl rm
starlette.py	23211	0644	edit dl rm
starlite.py	10089	0644	edit dl rm
stdlib.py	8251	0644	edit dl rm
threading.py	2937	0644	edit dl rm
tornado.py	7342	0644	edit dl rm
trytond.py	1745	0644	edit dl rm
wsgi.py	9581	0644	edit dl rm
_wsgi_common.py	4537	0644	edit dl rm
__init__.py	6827	0644	edit dl rm

Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/sentry_sdk/integrations/quart.py (7377B)

from __future__ import absolute_import

import inspect
import threading

from sentry_sdk.hub import _should_send_default_pii, Hub
from sentry_sdk.integrations import DidNotEnable, Integration
from sentry_sdk.integrations._wsgi_common import _filter_headers
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
from sentry_sdk.scope import Scope
from sentry_sdk.tracing import SOURCE_FOR_STYLE
from sentry_sdk.utils import (
    capture_internal_exceptions,
    event_from_exception,
)

from sentry_sdk._functools import wraps
from sentry_sdk._types import TYPE_CHECKING

if TYPE_CHECKING:
    from typing import Any
    from typing import Dict
    from typing import Union

from sentry_sdk._types import EventProcessor

try:
    import quart_auth  # type: ignore
except ImportError:
    quart_auth = None

try:
    from quart import (  # type: ignore
        has_request_context,
        has_websocket_context,
        Request,
        Quart,
        request,
        websocket,
    )
    from quart.scaffold import Scaffold  # type: ignore
    from quart.signals import (  # type: ignore
        got_background_exception,
        got_request_exception,
        got_websocket_exception,
        request_started,
        websocket_started,
    )
    from quart.utils import is_coroutine_function  # type: ignore
except ImportError:
    raise DidNotEnable("Quart is not installed")

TRANSACTION_STYLE_VALUES = ("endpoint", "url")

class QuartIntegration(Integration):
    identifier = "quart"

transaction_style = ""

def __init__(self, transaction_style="endpoint"):
        # type: (str) -> None
        if transaction_style not in TRANSACTION_STYLE_VALUES:
            raise ValueError(
                "Invalid value for transaction_style: %s (must be in %s)"
                % (transaction_style, TRANSACTION_STYLE_VALUES)
            )
        self.transaction_style = transaction_style

@staticmethod
    def setup_once():
        # type: () -> None

request_started.connect(_request_websocket_started)
        websocket_started.connect(_request_websocket_started)
        got_background_exception.connect(_capture_exception)
        got_request_exception.connect(_capture_exception)
        got_websocket_exception.connect(_capture_exception)

patch_asgi_app()
        patch_scaffold_route()

def patch_asgi_app():
    # type: () -> None
    old_app = Quart.__call__

async def sentry_patched_asgi_app(self, scope, receive, send):
        # type: (Any, Any, Any, Any) -> Any
        if Hub.current.get_integration(QuartIntegration) is None:
            return await old_app(self, scope, receive, send)

middleware = SentryAsgiMiddleware(lambda *a, **kw: old_app(self, *a, **kw))
        middleware.__call__ = middleware._run_asgi3
        return await middleware(scope, receive, send)

Quart.__call__ = sentry_patched_asgi_app

def patch_scaffold_route():
    # type: () -> None
    old_route = Scaffold.route

def _sentry_route(*args, **kwargs):
        # type: (*Any, **Any) -> Any
        old_decorator = old_route(*args, **kwargs)

def decorator(old_func):
            # type: (Any) -> Any

if inspect.isfunction(old_func) and not is_coroutine_function(old_func):

@wraps(old_func)
                def _sentry_func(*args, **kwargs):
                    # type: (*Any, **Any) -> Any
                    hub = Hub.current
                    integration = hub.get_integration(QuartIntegration)
                    if integration is None:
                        return old_func(*args, **kwargs)

with hub.configure_scope() as sentry_scope:
                        if sentry_scope.profile is not None:
                            sentry_scope.profile.active_thread_id = (
                                threading.current_thread().ident
                            )

return old_func(*args, **kwargs)

return old_decorator(_sentry_func)

return old_decorator(old_func)

return decorator

Scaffold.route = _sentry_route

def _set_transaction_name_and_source(scope, transaction_style, request):
    # type: (Scope, str, Request) -> None

try:
        name_for_style = {
            "url": request.url_rule.rule,
            "endpoint": request.url_rule.endpoint,
        }
        scope.set_transaction_name(
            name_for_style[transaction_style],
            source=SOURCE_FOR_STYLE[transaction_style],
        )
    except Exception:
        pass

async def _request_websocket_started(app, **kwargs):
    # type: (Quart, **Any) -> None
    hub = Hub.current
    integration = hub.get_integration(QuartIntegration)
    if integration is None:
        return

with hub.configure_scope() as scope:
        if has_request_context():
            request_websocket = request._get_current_object()
        if has_websocket_context():
            request_websocket = websocket._get_current_object()

# Set the transaction name here, but rely on ASGI middleware
        # to actually start the transaction
        _set_transaction_name_and_source(
            scope, integration.transaction_style, request_websocket
        )

evt_processor = _make_request_event_processor(
            app, request_websocket, integration
        )
        scope.add_event_processor(evt_processor)

def _make_request_event_processor(app, request, integration):
    # type: (Quart, Request, QuartIntegration) -> EventProcessor
    def inner(event, hint):
        # type: (Dict[str, Any], Dict[str, Any]) -> Dict[str, Any]
        # if the request is gone we are fine not logging the data from
        # it.  This might happen if the processor is pushed away to
        # another thread.
        if request is None:
            return event

with capture_internal_exceptions():
            # TODO: Figure out what to do with request body. Methods on request
            # are async, but event processors are not.

request_info = event.setdefault("request", {})
            request_info["url"] = request.url
            request_info["query_string"] = request.query_string
            request_info["method"] = request.method
            request_info["headers"] = _filter_headers(dict(request.headers))

if _should_send_default_pii():
                request_info["env"] = {"REMOTE_ADDR": request.access_route[0]}
                _add_user_to_event(event)

return event

return inner

async def _capture_exception(sender, exception, **kwargs):
    # type: (Quart, Union[ValueError, BaseException], **Any) -> None
    hub = Hub.current
    if hub.get_integration(QuartIntegration) is None:
        return

# If an integration is there, a client has to be there.
    client = hub.client  # type: Any

event, hint = event_from_exception(
        exception,
        client_options=client.options,
        mechanism={"type": "quart", "handled": False},
    )

hub.capture_event(event, hint=hint)

def _add_user_to_event(event):
    # type: (Dict[str, Any]) -> None
    if quart_auth is None:
        return

user = quart_auth.current_user
    if user is None:
        return

with capture_internal_exceptions():
        user_info = event.setdefault("user", {})

user_info["id"] = quart_auth.current_user._auth_id

cmd: