scout-apm 3.3.0__cp312-cp312-macosx_10_13_x86_64.whl

scout_apm/dramatiq.py

@@ -0,0 +1,42 @@
+# coding=utf-8
+
+import dramatiq
+
+import scout_apm.core
+from scout_apm.core.tracked_request import TrackedRequest
+
+
+class ScoutMiddleware(dramatiq.Middleware):
+    def __init__(self):
+        installed = scout_apm.core.install()
+        self._do_nothing = not installed
+
+    def before_process_message(self, broker, message):
+        if self._do_nothing:
+            return
+        tracked_request = TrackedRequest.instance()
+        tracked_request.tag("queue", message.queue_name)
+        tracked_request.tag("message_id", message.message_id)
+        operation = "Job/" + message.actor_name
+        tracked_request.start_span(operation=operation)
+        tracked_request.operation = operation
+
+    def after_process_message(self, broker, message, result=None, exception=None):
+        if self._do_nothing:
+            return
+        tracked_request = TrackedRequest.instance()
+        tracked_request.is_real_request = True
+        if exception:
+            tracked_request.tag("error", "true")
+        tracked_request.stop_span()
+
+    def after_skip_message(self, broker, message):
+        """
+        The message was skipped by another middleware raising SkipMessage.
+        Stop the span and thus the request, it won't have been marked as real
+        so that's alright.
+        """
+        if self._do_nothing:
+            return
+        tracked_request = TrackedRequest.instance()
+        tracked_request.stop_span()

scout_apm/falcon.py

@@ -0,0 +1,142 @@
+# coding=utf-8
+
+import logging
+import warnings
+
+import falcon
+
+from scout_apm.api import install
+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
+
+logger = logging.getLogger(__name__)
+
+# Falcon Middleware docs:
+# https://falcon.readthedocs.io/en/stable/api/middleware.html
+
+
+class ScoutMiddleware(object):
+    """
+    Falcon Middleware for integration with Scout APM.
+    """
+
+    def __init__(self, config, hug_http_interface=None):
+        self.api = None
+        self.hug_http_interface = hug_http_interface
+        installed = install(config=config)
+        self._do_nothing = not installed
+
+    def set_api(self, api):
+        if not isinstance(api, falcon.API):
+            raise ValueError("api should be an instance of falcon.API")
+        self.api = api
+
+    def process_request(self, req, resp):
+        if self._do_nothing:
+            return
+        if self.api is None and self.hug_http_interface is not None:
+            self.api = self.hug_http_interface.falcon
+        tracked_request = TrackedRequest.instance()
+        tracked_request.is_real_request = True
+        req.context.scout_tracked_request = tracked_request
+        tracked_request.start_span(
+            operation="Middleware", should_capture_backtrace=False
+        )
+
+        path = req.path
+        # Falcon URL parameter values are *either* single items or lists
+        url_params = [
+            (k, v)
+            for k, vs in req.params.items()
+            for v in (vs if isinstance(vs, list) else [vs])
+        ]
+        tracked_request.tag("path", create_filtered_path(path, url_params))
+        if ignore_path(path):
+            tracked_request.tag("ignore_transaction", True)
+
+        if scout_config.value("collect_remote_ip"):
+            # 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 = (
+                req.get_header("x-forwarded-for", default="").split(",")[0]
+                or req.get_header("client-ip", default="").split(",")[0]
+                or req.remote_addr
+            )
+            tracked_request.tag("user_ip", user_ip)
+
+        queue_time = req.get_header("x-queue-start", default="") or req.get_header(
+            "x-request-start", default=""
+        )
+        track_request_queue_time(queue_time, tracked_request)
+
+    def process_resource(self, req, resp, resource, params):
+        if self._do_nothing:
+            return
+
+        tracked_request = getattr(req.context, "scout_tracked_request", None)
+        if tracked_request is None:
+            # Somehow we didn't start a request - this might occur in
+            # combination with a pretty adversarial application, so guard
+            # against it, although if a request was started and the context was
+            # lost, other problems might occur.
+            return
+
+        if self.api is None:
+            warnings.warn(
+                (
+                    "{}.set_api() should be called before requests begin for"
+                    + " more detail."
+                ).format(self.__class__.__name__),
+                RuntimeWarning,
+                stacklevel=2,
+            )
+            operation = "Controller/{}.{}.{}".format(
+                resource.__module__, resource.__class__.__name__, req.method
+            )
+        else:
+            # Find the current responder's name. Falcon passes middleware the
+            # current resource but unfortunately not the method being called, hence
+            # we have to go through routing again.
+            responder, _params, _resource, _uri_template = self.api._get_responder(req)
+            operation = self._name_operation(req, responder, resource)
+
+        span = tracked_request.start_span(
+            operation=operation, should_capture_backtrace=False
+        )
+        tracked_request.operation = operation
+        req.context.scout_resource_span = span
+
+    def _name_operation(self, req, responder, resource):
+        try:
+            last_part = responder.__name__
+        except AttributeError:
+            last_part = req.method
+        return "Controller/{}.{}.{}".format(
+            resource.__module__, resource.__class__.__name__, last_part
+        )
+
+    def process_response(self, req, resp, resource, req_succeeded):
+        tracked_request = getattr(req.context, "scout_tracked_request", None)
+        if tracked_request is None:
+            # Somehow we didn't start a request
+            return
+
+        # Falcon only stores the response status line, we have to parse it
+        try:
+            status_code = int(resp.status.split(" ")[0])
+        except ValueError:
+            # Bad status line - force it to be tagged as an error because
+            # client will experience it as one
+            status_code = 500
+
+        if not req_succeeded or 500 <= status_code <= 599:
+            tracked_request.tag("error", "true")
+
+        span = getattr(req.context, "scout_resource_span", None)
+        if span is not None:
+            tracked_request.stop_span()
+        # Stop Middleware span
+        tracked_request.stop_span()

scout_apm/flask/__init__.py

@@ -0,0 +1,118 @@
+# coding=utf-8
+
+import logging
+import sys
+
+import wrapt
+from flask import current_app
+from flask.globals import request, session
+
+import scout_apm.core
+from scout_apm.core.config import scout_config
+from scout_apm.core.error import ErrorMonitor
+from scout_apm.core.tracked_request import TrackedRequest
+from scout_apm.core.web_requests import RequestComponents, werkzeug_track_request_data
+
+logger = logging.getLogger(__name__)
+
+
+class ScoutApm(object):
+    def __init__(self, app):
+        self.app = app
+        self._attempted_install = False
+        app.full_dispatch_request = self.wrapped_full_dispatch_request(
+            app.full_dispatch_request
+        )
+        app.preprocess_request = self.wrapped_preprocess_request(app.preprocess_request)
+
+    @wrapt.decorator
+    def wrapped_full_dispatch_request(self, wrapped, instance, args, kwargs):
+        if not self._attempted_install:
+            self.extract_flask_settings()
+            installed = scout_apm.core.install()
+            self._do_nothing = not installed
+            self._attempted_install = True
+
+        if self._do_nothing:
+            return wrapped(*args, **kwargs)
+
+        # Pass on routing exceptions (normally 404's)
+        if request.routing_exception is not None:
+            return wrapped(*args, **kwargs)
+
+        request_components = get_request_components(self.app, request)
+        operation = "Controller/{}.{}".format(
+            request_components.module, request_components.controller
+        )
+
+        tracked_request = TrackedRequest.instance()
+        tracked_request.is_real_request = True
+        tracked_request.operation = operation
+        request._scout_tracked_request = tracked_request
+
+        werkzeug_track_request_data(request, tracked_request)
+
+        with tracked_request.span(
+            operation=operation, should_capture_backtrace=False
+        ) as span:
+            request._scout_view_span = span
+
+            try:
+                response = wrapped(*args, **kwargs)
+            except Exception as exc:
+                tracked_request.tag("error", "true")
+                if scout_config.value("errors_enabled"):
+                    ErrorMonitor.send(
+                        sys.exc_info(),
+                        request_components=get_request_components(self.app, request),
+                        request_path=request.path,
+                        request_params=dict(request.args.lists()),
+                        session=dict(session.items()),
+                        environment=self.app.config,
+                    )
+                raise exc
+            else:
+                if 500 <= response.status_code <= 599:
+                    tracked_request.tag("error", "true")
+                return response
+
+    @wrapt.decorator
+    def wrapped_preprocess_request(self, wrapped, instance, args, kwargs):
+        tracked_request = getattr(request, "_scout_tracked_request", None)
+        if tracked_request is None:
+            return wrapped(*args, **kwargs)
+
+        # Unlike middleware in other frameworks, using request preprocessors is
+        # less common in Flask, so only add a span if there is any in use
+        have_before_request_funcs = (
+            None in instance.before_request_funcs
+            or request.blueprint in instance.before_request_funcs
+        )
+        if not have_before_request_funcs:
+            return wrapped(*args, **kwargs)
+
+        with tracked_request.span("PreprocessRequest", should_capture_backtrace=False):
+            return wrapped(*args, **kwargs)
+
+    def extract_flask_settings(self):
+        """
+        Copies SCOUT_* settings in the app into Scout's config lookup
+        """
+        configs = {}
+        configs["application_root"] = self.app.instance_path
+        for name in current_app.config:
+            if name.startswith("SCOUT_"):
+                value = current_app.config[name]
+                clean_name = name.replace("SCOUT_", "").lower()
+                configs[clean_name] = value
+        scout_config.set(**configs)
+
+
+def get_request_components(app, request):
+    view_func = app.view_functions[request.endpoint]
+    request_components = RequestComponents(
+        module=view_func.__module__,
+        controller=view_func.__name__,
+        action=request.method,
+    )
+    return request_components

scout_apm/flask/sqlalchemy.py

@@ -0,0 +1,28 @@
+# coding=utf-8
+
+import wrapt
+from flask_sqlalchemy import SQLAlchemy
+
+import scout_apm.sqlalchemy
+
+
+def instrument_sqlalchemy(db):
+    # Version 3 of flask_sqlalchemy changed how engines are created
+    if hasattr(db, "_make_engine"):
+        db._make_engine = wrapped_make_engine(db._make_engine)
+    else:
+        SQLAlchemy.get_engine = wrapped_get_engine(SQLAlchemy.get_engine)
+
+
+@wrapt.decorator
+def wrapped_get_engine(wrapped, instance, args, kwargs):
+    engine = wrapped(*args, **kwargs)
+    scout_apm.sqlalchemy.instrument_sqlalchemy(engine)
+    return engine
+
+
+@wrapt.decorator
+def wrapped_make_engine(wrapped, instance, args, kwargs):
+    engine = wrapped(*args, **kwargs)
+    scout_apm.sqlalchemy.instrument_sqlalchemy(engine)
+    return engine

scout_apm/huey.py

@@ -0,0 +1,54 @@
+# coding=utf-8
+
+from huey.exceptions import RetryTask, TaskLockedException
+from huey.signals import SIGNAL_CANCELED
+
+import scout_apm.core
+from scout_apm.core.tracked_request import TrackedRequest
+
+# Because neither hooks nor signals are called in *all* cases, we need to use
+# both in order to capture every case. See source:
+# https://github.com/coleifer/huey/blob/e6710bd6a9f581ebc728e24f5923d26eb0047750/huey/api.py#L331  # noqa
+
+
+def attach_scout(huey):
+    installed = scout_apm.core.install()
+    if installed:
+        attach_scout_handlers(huey)
+
+
+def attach_scout_handlers(huey):
+    huey.pre_execute()(scout_on_pre_execute)
+    huey.post_execute()(scout_on_post_execute)
+    huey.signal(SIGNAL_CANCELED)(scout_on_cancelled)
+
+
+def scout_on_pre_execute(task):
+    tracked_request = TrackedRequest.instance()
+
+    tracked_request.tag("task_id", task.id)
+
+    operation = "Job/{}.{}".format(task.__module__, task.__class__.__name__)
+    tracked_request.start_span(operation=operation)
+    tracked_request.operation = operation
+
+
+def scout_on_post_execute(task, task_value, exception):
+    tracked_request = TrackedRequest.instance()
+    if exception is None:
+        tracked_request.is_real_request = True
+    elif isinstance(exception, TaskLockedException):
+        pass
+    elif isinstance(exception, RetryTask):
+        tracked_request.is_real_request = True
+        tracked_request.tag("retrying", True)
+    else:
+        tracked_request.is_real_request = True
+        tracked_request.tag("error", "true")
+    tracked_request.stop_span()
+
+
+def scout_on_cancelled(signal, task, exc=None):
+    # In the case of a cancelled signal, Huey doesn't run the post_execute
+    # handler, so we need to tidy up
+    TrackedRequest.instance().stop_span()

scout_apm/hug.py

@@ -0,0 +1,40 @@
+# coding=utf-8
+
+import hug
+from hug.interface import HTTP
+
+from scout_apm.falcon import ScoutMiddleware as FalconMiddleware
+
+
+class ScoutMiddleware(FalconMiddleware):
+    """
+    Hug's HTTP interface is based on Falcon. Therefore we use a subclass of our
+    Falcon integration with Hug specific extras.
+    """
+
+    def __init__(self, config, hug_http_interface):
+        super(ScoutMiddleware, self).__init__(config)
+        self.hug_http_interface = hug_http_interface
+
+    def process_request(self, req, resp):
+        if not self._do_nothing and self.api is None:
+            self.api = self.hug_http_interface.falcon
+        return super(ScoutMiddleware, self).process_request(req, resp)
+
+    def _name_operation(self, req, responder, resource):
+        if isinstance(responder, HTTP):
+            # Hug doesn't use functions but its custom callable classes
+            return "Controller/{}.{}".format(
+                responder.interface._function.__module__,
+                responder.interface._function.__name__,
+            )
+        return super(ScoutMiddleware, self)._name_operation(req, responder, resource)
+
+
+def integrate_scout(hug_module_name, config):
+    http_interface = hug.API(hug_module_name).http
+    scout_middleware = ScoutMiddleware(
+        config=config,
+        hug_http_interface=http_interface,
+    )
+    http_interface.add_middleware(scout_middleware)

scout_apm/instruments/__init__.py

@@ -0,0 +1,21 @@
+# coding=utf-8
+
+import importlib
+import logging
+
+from scout_apm.core.config import scout_config
+
+logger = logging.getLogger(__name__)
+
+instrument_names = ["elasticsearch", "jinja2", "pymongo", "redis", "urllib3"]
+
+
+def ensure_all_installed():
+    disabled_instruments = scout_config.value("disabled_instruments")
+    for instrument_name in instrument_names:
+        if instrument_name in disabled_instruments:
+            logger.info("%s instrument is disabled. Skipping.", instrument_name)
+            continue
+
+        module = importlib.import_module("{}.{}".format(__name__, instrument_name))
+        module.ensure_installed()