scout-apm 3.3.0__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl

scout_apm/django/apps.py

@@ -0,0 +1,137 @@
+# coding=utf-8
+
+import sys
+
+import django
+from django.apps import AppConfig
+from django.conf import settings
+from django.core.signals import got_request_exception
+from django.test.signals import setting_changed
+
+if django.VERSION < (3, 1):
+    from django.views.debug import get_safe_settings
+else:
+    from django.views.debug import SafeExceptionReporterFilter
+
+    def get_safe_settings():
+        return SafeExceptionReporterFilter().get_safe_settings()
+
+
+import scout_apm.core
+from scout_apm.core.config import scout_config
+from scout_apm.core.error import ErrorMonitor
+from scout_apm.django.instruments.huey import ensure_huey_instrumented
+from scout_apm.django.instruments.sql import ensure_sql_instrumented
+from scout_apm.django.instruments.template import ensure_templates_instrumented
+from scout_apm.django.request import get_request_components
+
+
+class ScoutApmDjangoConfig(AppConfig):
+    name = "scout_apm"
+    verbose_name = "Scout Apm (Django)"
+
+    def ready(self):
+        self.update_scout_config_from_django_settings()
+        setting_changed.connect(self.on_setting_changed)
+
+        # Finish installing the agent. If the agent isn't installed for any
+        # reason, return without installing instruments
+        installed = scout_apm.core.install()
+        if not installed:
+            return
+
+        if scout_config.value("errors_enabled"):
+            got_request_exception.connect(self.on_got_request_exception)
+
+        self.install_middleware()
+
+        # Setup Instruments
+        ensure_huey_instrumented()
+        ensure_sql_instrumented()
+        ensure_templates_instrumented()
+
+    def update_scout_config_from_django_settings(self, **kwargs):
+        for name in dir(settings):
+            self.on_setting_changed(name)
+
+    def on_got_request_exception(self, request, **kwargs):
+        """
+        Process this exception with the error monitoring solution.
+        """
+        ErrorMonitor.send(
+            sys.exc_info(),
+            request_components=get_request_components(request),
+            request_path=request.path,
+            request_params=dict(request.GET.lists()),
+            session=dict(request.session.items())
+            if hasattr(request, "session")
+            else None,
+            environment=get_safe_settings(),
+        )
+
+    def on_setting_changed(self, setting, **kwargs):
+        cast = None
+        if setting == "BASE_DIR":
+            scout_name = "application_root"
+            cast = str
+        elif setting.startswith("SCOUT_"):
+            scout_name = setting.replace("SCOUT_", "").lower()
+        else:
+            return
+
+        try:
+            value = getattr(settings, setting)
+        except AttributeError:
+            # It was removed
+            scout_config.unset(scout_name)
+        else:
+            if cast is not None:
+                value = cast(value)
+            scout_config.set(**{scout_name: value})
+
+    def install_middleware(self):
+        """
+        Attempts to insert the ScoutApm middleware as the first middleware
+        (first on incoming requests, last on outgoing responses).
+        """
+        from django.conf import settings
+
+        # If MIDDLEWARE is set, update that, with handling of tuple vs array forms
+        if getattr(settings, "MIDDLEWARE", None) is not None:
+            timing_middleware = "scout_apm.django.middleware.MiddlewareTimingMiddleware"
+            view_middleware = "scout_apm.django.middleware.ViewTimingMiddleware"
+
+            if isinstance(settings.MIDDLEWARE, tuple):
+                if timing_middleware not in settings.MIDDLEWARE:
+                    settings.MIDDLEWARE = (timing_middleware,) + settings.MIDDLEWARE
+                if view_middleware not in settings.MIDDLEWARE:
+                    settings.MIDDLEWARE = settings.MIDDLEWARE + (view_middleware,)
+            else:
+                if timing_middleware not in settings.MIDDLEWARE:
+                    settings.MIDDLEWARE.insert(0, timing_middleware)
+                if view_middleware not in settings.MIDDLEWARE:
+                    settings.MIDDLEWARE.append(view_middleware)
+
+        # Otherwise, we're doing old style middleware, do the same thing with
+        # the same handling of tuple vs array forms
+        else:
+            timing_middleware = (
+                "scout_apm.django.middleware.OldStyleMiddlewareTimingMiddleware"
+            )
+            view_middleware = "scout_apm.django.middleware.OldStyleViewMiddleware"
+
+            if isinstance(settings.MIDDLEWARE_CLASSES, tuple):
+                if timing_middleware not in settings.MIDDLEWARE_CLASSES:
+                    settings.MIDDLEWARE_CLASSES = (
+                        timing_middleware,
+                    ) + settings.MIDDLEWARE_CLASSES
+
+                if view_middleware not in settings.MIDDLEWARE_CLASSES:
+                    settings.MIDDLEWARE_CLASSES = settings.MIDDLEWARE_CLASSES + (
+                        view_middleware,
+                    )
+            else:
+                if timing_middleware not in settings.MIDDLEWARE_CLASSES:
+                    settings.MIDDLEWARE_CLASSES.insert(0, timing_middleware)
+                if view_middleware not in settings.MIDDLEWARE_CLASSES:
+                    settings.MIDDLEWARE_CLASSES.append(view_middleware)

scout_apm/django/instruments/huey.py

@@ -0,0 +1,30 @@
+# coding=utf-8
+
+import logging
+
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+huey_instrumented = False
+
+
+def ensure_huey_instrumented():
+    global huey_instrumented
+    if huey_instrumented:
+        return
+    huey_instrumented = True
+
+    # Avoid importing if not installed
+    if "huey.contrib.djhuey" not in settings.INSTALLED_APPS:  # pragma: no cover
+        return
+
+    try:
+        from huey.contrib.djhuey import HUEY
+    except ImportError:  # pragma: no cover
+        return
+
+    from scout_apm.huey import attach_scout_handlers
+
+    attach_scout_handlers(HUEY)
+    logger.debug("Instrumented huey.contrib.djhuey")

scout_apm/django/instruments/sql.py

@@ -0,0 +1,140 @@
+# coding=utf-8
+
+import logging
+
+import django
+import wrapt
+from django.db import connections
+from django.db.backends.signals import connection_created
+from django.db.backends.utils import CursorWrapper
+
+from scout_apm.core.tracked_request import TrackedRequest
+
+logger = logging.getLogger(__name__)
+
+sql_instrumented = False
+
+
+def ensure_sql_instrumented():
+    global sql_instrumented
+    if sql_instrumented:
+        return
+    sql_instrumented = True
+
+    if django.VERSION >= (2, 0):
+        for connection in connections.all():
+            install_db_execute_hook(connection=connection)
+        connection_created.connect(install_db_execute_hook)
+        logger.debug("Installed DB connection created signal handler")
+    else:
+        CursorWrapper.execute = execute_wrapper(CursorWrapper.execute)
+        CursorWrapper.executemany = executemany_wrapper(CursorWrapper.executemany)
+
+        logger.debug("Monkey patched SQL")
+
+
+def db_execute_hook(execute, sql, params, many, context):
+    """
+    Database instrumentation hook for Django 2.0+
+    https://docs.djangoproject.com/en/2.0/topics/db/instrumentation/
+    """
+    if many:
+        operation = "SQL/Many"
+    else:
+        operation = "SQL/Query"
+
+    if sql is not None:
+        tracked_request = TrackedRequest.instance()
+        span = tracked_request.start_span(operation=operation)
+        span.tag("db.statement", sql)
+
+    try:
+        return execute(sql, params, many, context)
+    finally:
+        if sql is not None:
+            tracked_request.stop_span()
+            if tracked_request.n_plus_one_tracker.should_capture_backtrace(
+                sql=sql,
+                duration=span.duration(),
+                count=(1 if not many else len(params)),
+            ):
+                span.capture_backtrace()
+
+
+def install_db_execute_hook(connection, **kwargs):
+    """
+    Install db_execute_hook on the given database connection.
+
+    Rather than use the documented API of the `execute_wrapper()` context
+    manager, directly insert the hook. This is done because:
+    1. Deleting the context manager closes it, so it's not possible to enter
+       it here and not exit it, unless we store it forever in some variable
+    2. We want to be the first hook, so we can capture every query (although
+       potentially later hooks will change the SQL)
+    3. We want to be idempotent and only install the hook once
+    """
+    if db_execute_hook not in connection.execute_wrappers:
+        connection.execute_wrappers.insert(0, db_execute_hook)
+
+
+@wrapt.decorator
+def execute_wrapper(wrapped, instance, args, kwargs):
+    """
+    CursorWrapper.execute() wrapper for Django < 2.0
+    """
+    try:
+        sql = _extract_sql(*args, **kwargs)
+    except TypeError:
+        sql = None
+
+    if sql is not None:
+        tracked_request = TrackedRequest.instance()
+        span = tracked_request.start_span(operation="SQL/Query")
+        span.tag("db.statement", sql)
+
+    try:
+        return wrapped(*args, **kwargs)
+    finally:
+        if sql is not None:
+            tracked_request.stop_span()
+            if tracked_request.n_plus_one_tracker.should_capture_backtrace(
+                sql, span.duration()
+            ):
+                span.capture_backtrace()
+
+
+def _extract_sql(sql, *args, **kwargs):
+    return sql
+
+
+@wrapt.decorator
+def executemany_wrapper(wrapped, instance, args, kwargs):
+    """
+    CursorWrapper.executemany() wrapper for Django < 2.0
+    """
+    try:
+        sql, param_list = _extract_sql_param_list(*args, **kwargs)
+    except TypeError:
+        sql = None
+        param_list = None
+
+    if sql is not None:
+        tracked_request = TrackedRequest.instance()
+        span = tracked_request.start_span(operation="SQL/Many")
+        span.tag("db.statement", sql)
+
+    try:
+        return wrapped(*args, **kwargs)
+    finally:
+        if sql is not None:
+            tracked_request.stop_span()
+            if tracked_request.n_plus_one_tracker.should_capture_backtrace(
+                sql=sql,
+                duration=span.duration(),
+                count=len(param_list),
+            ):
+                span.capture_backtrace()
+
+
+def _extract_sql_param_list(sql, param_list, *args, **kwargs):
+    return sql, param_list

scout_apm/django/instruments/template.py

@@ -0,0 +1,35 @@
+# coding=utf-8
+
+import logging
+
+from django.template import Template
+from django.template.loader_tags import BlockNode
+
+from scout_apm.core.stacktracer import trace_method
+
+logger = logging.getLogger(__name__)
+
+templates_instrumented = False
+
+
+def ensure_templates_instrumented():
+    global templates_instrumented
+    if templates_instrumented:
+        return
+    templates_instrumented = True
+
+    @trace_method(Template)
+    def __init__(self, *args, **kwargs):
+        name = args[2] if len(args) >= 3 else "<Unknown Template>"
+        return ("Template/Compile", {"name": name})
+
+    @trace_method(Template)
+    def render(self, *args, **kwargs):
+        name = self.name if self.name is not None else "<Unknown Template>"
+        return ("Template/Render", {"name": name})
+
+    @trace_method(BlockNode, "render")
+    def render_block(self, *args, **kwargs):
+        return ("Block/Render", {"name": self.name})
+
+    logger.debug("Monkey patched Templates")

scout_apm/django/middleware.py

@@ -0,0 +1,211 @@
+# coding=utf-8
+
+from django.conf import settings
+from django.urls import get_urlconf
+
+from scout_apm.core.config import scout_config
+from scout_apm.core.queue_time import track_request_queue_time
+from scout_apm.core.tracked_request import TrackedRequest
+from scout_apm.core.web_requests import create_filtered_path, ignore_path
+from scout_apm.django.request import get_controller_name
+
+
+def track_request_view_data(request, tracked_request):
+    path = request.path
+    tracked_request.tag(
+        "path",
+        create_filtered_path(
+            path, [(k, v) for k, vs in request.GET.lists() for v in vs]
+        ),
+    )
+    if ignore_path(path):
+        tracked_request.tag("ignore_transaction", True)
+
+    if scout_config.value("collect_remote_ip"):
+        try:
+            # Determine a remote IP to associate with the request. The value is
+            # spoofable by the requester so this is not suitable to use in any
+            # security sensitive context.
+            user_ip = (
+                request.META.get("HTTP_X_FORWARDED_FOR", "").split(",")[0]
+                or request.META.get("HTTP_CLIENT_IP", "").split(",")[0]
+                or request.META.get("REMOTE_ADDR", None)
+            )
+            tracked_request.tag("user_ip", user_ip)
+        except Exception:
+            pass
+
+    # Django's request.user caches in this attribute on first access. We only
+    # want to track the user if the application code has touched request.user
+    # because touching it causes session access, which adds "Cookie" to the
+    # "Vary" header.
+    user = getattr(request, "_cached_user", None)
+    if user is not None:
+        try:
+            tracked_request.tag("username", user.get_username())
+        except Exception:
+            pass
+
+    tracked_request.tag("urlconf", get_urlconf(settings.ROOT_URLCONF))
+
+
+class MiddlewareTimingMiddleware(object):
+    """
+    Insert as early into the Middleware stack as possible (outermost layers),
+    so that other middlewares called after can be timed.
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        if not scout_config.value("monitor"):
+            return self.get_response(request)
+
+        tracked_request = TrackedRequest.instance()
+
+        queue_time = request.META.get("HTTP_X_QUEUE_START") or request.META.get(
+            "HTTP_X_REQUEST_START", ""
+        )
+        track_request_queue_time(queue_time, tracked_request)
+
+        with tracked_request.span(
+            operation="Middleware",
+            should_capture_backtrace=False,
+        ):
+            return self.get_response(request)
+
+
+class ViewTimingMiddleware(object):
+    """
+    Insert as deep into the middleware stack as possible, ideally wrapping no
+    other middleware. Designed to time the View itself
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        """
+        Wrap a single incoming request with start and stop calls.
+        This will start timing, but relies on the process_view callback to
+        capture more details about what view was really called, and other
+        similar info.
+
+        If process_view isn't called, then the request will not
+        be recorded.  This can happen if a middleware further along the stack
+        doesn't call onward, and instead returns a response directly.
+        """
+        if not scout_config.value("monitor"):
+            return self.get_response(request)
+
+        tracked_request = TrackedRequest.instance()
+
+        # This operation name won't be recorded unless changed later in
+        # process_view
+        with tracked_request.span(operation="Unknown", should_capture_backtrace=False):
+            response = self.get_response(request)
+            track_request_view_data(request, tracked_request)
+            if 500 <= response.status_code <= 599:
+                tracked_request.tag("error", "true")
+            return response
+
+    def process_view(self, request, view_func, view_args, view_kwargs):
+        """
+        Capture details about the view_func that is about to execute
+        """
+        if not scout_config.value("monitor"):
+            return
+        tracked_request = TrackedRequest.instance()
+        tracked_request.is_real_request = True
+
+        span = tracked_request.current_span()
+        if span is not None:
+            span.operation = get_controller_name(request)
+            tracked_request.operation = span.operation
+
+    def process_exception(self, request, exception):
+        """
+        Mark this request as having errored out
+
+        Does not modify or catch or otherwise change the exception thrown
+        """
+        if not scout_config.value("monitor"):
+            return
+        TrackedRequest.instance().tag("error", "true")
+
+
+class OldStyleMiddlewareTimingMiddleware(object):
+    """
+    Insert as early into the Middleware stack as possible (outermost layers),
+    so that other middlewares called after can be timed.
+    """
+
+    def process_request(self, request):
+        if not scout_config.value("monitor"):
+            return
+        tracked_request = TrackedRequest.instance()
+        request._scout_tracked_request = tracked_request
+
+        queue_time = request.META.get("HTTP_X_QUEUE_START") or request.META.get(
+            "HTTP_X_REQUEST_START", ""
+        )
+        track_request_queue_time(queue_time, tracked_request)
+
+        tracked_request.start_span(
+            operation="Middleware", should_capture_backtrace=False
+        )
+
+    def process_response(self, request, response):
+        # Only stop span if there's a request, but presume we are balanced,
+        # i.e. that custom instrumentation within the application is not
+        # causing errors
+        tracked_request = getattr(request, "_scout_tracked_request", None)
+        if tracked_request is not None:
+            if 500 <= response.status_code <= 599:
+                tracked_request.tag("error", "true")
+            tracked_request.stop_span()
+        return response
+
+
+class OldStyleViewMiddleware(object):
+    def process_view(self, request, view_func, view_func_args, view_func_kwargs):
+        tracked_request = getattr(request, "_scout_tracked_request", None)
+        if tracked_request is None:
+            # Looks like OldStyleMiddlewareTimingMiddleware didn't run, so
+            # don't do anything
+            return
+
+        tracked_request.is_real_request = True
+
+        span = tracked_request.start_span(
+            operation=get_controller_name(request), should_capture_backtrace=False
+        )
+        # Save the span into the request, so we can check
+        # if we're matched up when stopping
+        request._scout_view_span = span
+
+    def process_response(self, request, response):
+        tracked_request = getattr(request, "_scout_tracked_request", None)
+        if tracked_request is None:
+            # Looks like OldStyleMiddlewareTimingMiddleware didn't run, so
+            # don't do anything
+            return response
+
+        track_request_view_data(request, tracked_request)
+
+        # Only stop span if we started, but presume we are balanced, i.e. that
+        # custom instrumentation within the application is not causing errors
+        span = getattr(request, "_scout_view_span", None)
+        if span is not None:
+            tracked_request.stop_span()
+        return response
+
+    def process_exception(self, request, exception):
+        tracked_request = getattr(request, "_scout_tracked_request", None)
+        if tracked_request is None:
+            # Looks like OldStyleMiddlewareTimingMiddleware didn't run, so
+            # don't do anything
+            return
+
+        tracked_request.tag("error", "true")

scout_apm/django/request.py

@@ -0,0 +1,144 @@
+# coding=utf-8
+
+from scout_apm.core.web_requests import RequestComponents
+
+
+def get_controller_name(request):
+    view_func = request.resolver_match.func
+    view_name = request.resolver_match._func_path
+    if hasattr(view_func, "view_class"):
+        view_func = view_func.view_class
+        view_name = "{}.{}".format(view_func.__module__, view_func.__name__)
+
+    django_admin_components = _get_django_admin_components(view_func)
+    if django_admin_components:
+        view_name = "{}.{}.{}".format(
+            django_admin_components.module,
+            django_admin_components.controller,
+            django_admin_components.action,
+        )
+
+    django_rest_framework_components = _get_django_rest_framework_components(
+        request, view_func
+    )
+    if django_rest_framework_components is not None:
+        view_name = "{}.{}.{}".format(
+            django_rest_framework_components.module,
+            django_rest_framework_components.controller,
+            django_rest_framework_components.action,
+        )
+
+    # Seems to be a Tastypie Resource. Need to resort to some stack inspection
+    # to find a better name since its decorators don't wrap very well
+    if view_name == "tastypie.resources.wrapper":
+        tastypie_components = _get_tastypie_components(request, view_func)
+        if tastypie_components is not None:
+            view_name = "{}.{}.{}".format(
+                tastypie_components.module,
+                tastypie_components.controller,
+                tastypie_components.action,
+            )
+
+    return "Controller/{}".format(view_name)
+
+
+def get_request_components(request):
+    if not request.resolver_match:
+        return None
+    view_func = request.resolver_match.func
+    view_name = request.resolver_match._func_path
+    if hasattr(view_func, "view_class"):
+        view_func = view_func.view_class
+    request_components = RequestComponents(
+        module=view_func.__module__,
+        controller=view_func.__name__,
+        action=request.method,
+    )
+
+    django_admin_components = _get_django_admin_components(view_func)
+    if django_admin_components:
+        request_components = django_admin_components
+
+    django_rest_framework_components = _get_django_rest_framework_components(
+        request, view_func
+    )
+    if django_rest_framework_components is not None:
+        request_components = django_rest_framework_components
+
+    # Seems to be a Tastypie Resource. Need to resort to some stack inspection
+    # to find a better name since its decorators don't wrap very well
+    if view_name == "tastypie.resources.wrapper":
+        tastypie_components = _get_tastypie_components(request, view_func)
+        if tastypie_components is not None:
+            request_components = tastypie_components
+    return request_components
+
+
+def _get_django_admin_components(view_func):
+    if hasattr(view_func, "model_admin"):
+        # Seems to comes from Django admin (attribute only set on Django 1.9+)
+        admin_class = view_func.model_admin.__class__
+        return RequestComponents(
+            module=admin_class.__module__,
+            controller=admin_class.__name__,
+            action=view_func.__name__,
+        )
+    return None
+
+
+def _get_django_rest_framework_components(request, view_func):
+    try:
+        from rest_framework.viewsets import ViewSetMixin
+    except ImportError:
+        return None
+
+    kls = getattr(view_func, "cls", None)
+    if isinstance(kls, type) and not issubclass(kls, ViewSetMixin):
+        return None
+
+    # Get 'actions' set in ViewSetMixin.as_view
+    actions = getattr(view_func, "actions", None)
+    if not actions or not isinstance(actions, dict):
+        return None
+
+    method_lower = request.method.lower()
+    if method_lower not in actions:
+        return None
+
+    return RequestComponents(
+        module=view_func.__module__,
+        controller=view_func.__name__,
+        action=actions[method_lower],
+    )
+
+
+def _get_tastypie_components(request, view_func):
+    try:
+        from tastypie.resources import Resource
+    except ImportError:
+        return None
+
+    try:
+        wrapper = view_func.__wrapped__
+    except AttributeError:
+        return None
+
+    if not hasattr(wrapper, "__closure__") or len(wrapper.__closure__) != 2:
+        return None
+
+    instance = wrapper.__closure__[0].cell_contents
+    if not isinstance(instance, Resource):  # pragma: no cover
+        return None
+
+    method_name = wrapper.__closure__[1].cell_contents
+    if not isinstance(method_name, str):  # pragma: no cover
+        return None
+
+    if method_name.startswith("dispatch_"):  # pragma: no cover
+        method_name = request.method.lower() + method_name.split("dispatch", 1)[1]
+
+    return RequestComponents(
+        module=instance.__module__,
+        controller=instance.__class__.__name__,
+        action=method_name,
+    )