File Manager

X7ROOT File Manager

Current Path: /opt/hc_python/lib/python3.12/site-packages/sentry_sdk/integrations/django

opt / hc_python / lib / python3.12 / site-packages / sentry_sdk / integrations / django /

?? ..
?? __init__.py(28.25 KB)
?? __pycache__
?? asgi.py(9.04 KB)
?? caching.py(9.37 KB)
?? middleware.py(6.4 KB)
?? signals_handlers.py(3.71 KB)
?? tasks.py(1.58 KB)
?? templates.py(6.6 KB)
?? transactions.py(4.68 KB)
?? views.py(4.46 KB)

Editing: middleware.py

"""
Create spans from Django middleware invocations
"""

from functools import wraps
from typing import TYPE_CHECKING

from django import VERSION as DJANGO_VERSION

import sentry_sdk
from sentry_sdk.consts import OP, SPANDATA
from sentry_sdk.tracing_utils import has_span_streaming_enabled
from sentry_sdk.utils import (
    ContextVar,
    capture_internal_exceptions,
    transaction_from_function,
)

if TYPE_CHECKING:
    from typing import Any, Callable, Optional, TypeVar, Union

from sentry_sdk.traces import StreamedSpan
    from sentry_sdk.tracing import Span

F = TypeVar("F", bound=Callable[..., Any])

_import_string_should_wrap_middleware = ContextVar(
    "import_string_should_wrap_middleware"
)

DJANGO_SUPPORTS_ASYNC_MIDDLEWARE = DJANGO_VERSION >= (3, 1)

if not DJANGO_SUPPORTS_ASYNC_MIDDLEWARE:
    _asgi_middleware_mixin_factory = lambda _: object
else:
    from .asgi import _asgi_middleware_mixin_factory

def patch_django_middlewares() -> None:
    from django.core.handlers import base

old_import_string = base.import_string

def sentry_patched_import_string(dotted_path: str) -> "Any":
        rv = old_import_string(dotted_path)

if _import_string_should_wrap_middleware.get(None):
            rv = _wrap_middleware(rv, dotted_path)

return rv

base.import_string = sentry_patched_import_string

old_load_middleware = base.BaseHandler.load_middleware

def sentry_patched_load_middleware(*args: "Any", **kwargs: "Any") -> "Any":
        _import_string_should_wrap_middleware.set(True)
        try:
            return old_load_middleware(*args, **kwargs)
        finally:
            _import_string_should_wrap_middleware.set(False)

base.BaseHandler.load_middleware = sentry_patched_load_middleware

def _wrap_middleware(middleware: "Any", middleware_name: str) -> "Any":
    from sentry_sdk.integrations.django import DjangoIntegration

def _check_middleware_span(
        old_method: "Callable[..., Any]",
    ) -> "Optional[Union[Span, StreamedSpan]]":
        integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
        if integration is None or not integration.middleware_spans:
            return None

function_name = transaction_from_function(old_method)

description = middleware_name
        function_basename = getattr(old_method, "__name__", None)
        if function_basename:
            description = "{}.{}".format(description, function_basename)

span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
        middleware_span: "Union[Span, StreamedSpan]"
        if span_streaming:
            middleware_span = sentry_sdk.traces.start_span(
                name=description,
                attributes={
                    "sentry.op": OP.MIDDLEWARE_DJANGO,
                    "sentry.origin": DjangoIntegration.origin,
                    SPANDATA.MIDDLEWARE_NAME: middleware_name,
                },
            )
        else:
            middleware_span = sentry_sdk.start_span(
                op=OP.MIDDLEWARE_DJANGO,
                name=description,
                origin=DjangoIntegration.origin,
            )
            middleware_span.set_tag("django.function_name", function_name)
            middleware_span.set_tag("django.middleware_name", middleware_name)

return middleware_span

def _get_wrapped_method(old_method: "F") -> "F":
        with capture_internal_exceptions():

def sentry_wrapped_method(*args: "Any", **kwargs: "Any") -> "Any":
                middleware_span = _check_middleware_span(old_method)

if middleware_span is None:
                    return old_method(*args, **kwargs)

with middleware_span:
                    return old_method(*args, **kwargs)

try:
                # fails for __call__ of function on Python 2 (see py2.7-django-1.11)
                sentry_wrapped_method = wraps(old_method)(sentry_wrapped_method)

# Necessary for Django 3.1
                sentry_wrapped_method.__self__ = old_method.__self__  # type: ignore
            except Exception:
                pass

return sentry_wrapped_method  # type: ignore

return old_method

class SentryWrappingMiddleware(
        _asgi_middleware_mixin_factory(_check_middleware_span)  # type: ignore
    ):
        sync_capable = getattr(middleware, "sync_capable", True)
        async_capable = DJANGO_SUPPORTS_ASYNC_MIDDLEWARE and getattr(
            middleware, "async_capable", False
        )

def __init__(
            self,
            get_response: "Optional[Callable[..., Any]]" = None,
            *args: "Any",
            **kwargs: "Any",
        ) -> None:
            if get_response:
                self._inner = middleware(get_response, *args, **kwargs)
            else:
                self._inner = middleware(*args, **kwargs)
            self.get_response = get_response
            self._call_method = None
            if self.async_capable:
                super().__init__(get_response)

# We need correct behavior for `hasattr()`, which we can only determine
        # when we have an instance of the middleware we're wrapping.
        def __getattr__(self, method_name: str) -> "Any":
            if method_name not in (
                "process_request",
                "process_view",
                "process_template_response",
                "process_response",
                "process_exception",
            ):
                raise AttributeError()

old_method = getattr(self._inner, method_name)
            rv = _get_wrapped_method(old_method)
            self.__dict__[method_name] = rv
            return rv

def __call__(self, *args: "Any", **kwargs: "Any") -> "Any":
            if hasattr(self, "async_route_check") and self.async_route_check():
                return self.__acall__(*args, **kwargs)

f = self._call_method
            if f is None:
                self._call_method = f = self._inner.__call__

middleware_span = _check_middleware_span(old_method=f)

if middleware_span is None:
                return f(*args, **kwargs)

with middleware_span:
                return f(*args, **kwargs)

for attr in (
        "__name__",
        "__module__",
        "__qualname__",
    ):
        if hasattr(middleware, attr):
            setattr(SentryWrappingMiddleware, attr, getattr(middleware, attr))

return SentryWrappingMiddleware

X7ROOT File Manager

Editing: middleware.py

Upload File

Create Folder