scout-apm 3.3.0__cp310-cp310-musllinux_1_2_i686.whl

scout_apm/core/samplers/memory.py

@@ -0,0 +1,23 @@
+# coding=utf-8
+
+import logging
+
+import psutil
+
+logger = logging.getLogger(__name__)
+
+
+def get_rss_in_mb():
+    rss_in_bytes = psutil.Process().memory_info().rss
+    return rss_in_bytes / (1024 * 1024)
+
+
+class Memory(object):
+    metric_type = "Memory"
+    metric_name = "Physical"
+    human_name = "Process Memory"
+
+    def run(self):
+        value = get_rss_in_mb()
+        logger.debug("%s: #%s", self.human_name, value)
+        return value

scout_apm/core/samplers/thread.py

@@ -0,0 +1,41 @@
+# coding=utf-8
+
+import datetime as dt
+import logging
+import os
+import threading
+
+from scout_apm.core.agent.commands import ApplicationEvent
+from scout_apm.core.agent.socket import CoreAgentSocketThread
+from scout_apm.core.samplers.cpu import Cpu
+from scout_apm.core.samplers.memory import Memory
+from scout_apm.core.threading import SingletonThread
+
+logger = logging.getLogger(__name__)
+
+
+class SamplersThread(SingletonThread):
+    _instance_lock = threading.Lock()
+    _stop_event = threading.Event()
+
+    def run(self):
+        logger.debug("Starting Samplers.")
+        instances = [Cpu(), Memory()]
+
+        while True:
+            for instance in instances:
+                event_value = instance.run()
+                if event_value is not None:
+                    event_type = instance.metric_type + "/" + instance.metric_name
+                    event = ApplicationEvent(
+                        event_value=event_value,
+                        event_type=event_type,
+                        timestamp=dt.datetime.now(dt.timezone.utc),
+                        source="Pid: " + str(os.getpid()),
+                    )
+                    CoreAgentSocketThread.send(event)
+
+            should_stop = self._stop_event.wait(timeout=60)
+            if should_stop:
+                logger.debug("Stopping Samplers.")
+                break

scout_apm/core/stacktracer.py

@@ -0,0 +1,30 @@
+# coding=utf-8
+
+import wrapt
+
+from scout_apm.core.tracked_request import TrackedRequest
+
+
+def trace_method(cls, method_name=None):
+    def decorator(info_func):
+        method_to_patch = method_name or info_func.__name__
+
+        @wrapt.decorator
+        def wrapper(wrapped, instance, args, kwargs):
+            entry_type, detail = info_func(instance, *args, **kwargs)
+            operation = entry_type
+            if detail["name"] is not None:
+                operation = operation + "/" + detail["name"]
+
+            tracked_request = TrackedRequest.instance()
+            with tracked_request.span(operation=operation) as span:
+                for key, value in detail.items():
+                    span.tag(key, value)
+
+                return wrapped(*args, **kwargs)
+
+        setattr(cls, method_to_patch, wrapper(getattr(cls, method_to_patch)))
+
+        return wrapper
+
+    return decorator

scout_apm/core/threading.py

@@ -0,0 +1,56 @@
+# coding=utf-8
+
+import threading
+
+
+class SingletonThread(threading.Thread):
+    _instance = None
+    # Copy these variables into subclasses to avoid sharing:
+    # (Would use __init_subclass__() but Python 2 doesn't support it and using
+    # metaclasses to achieve the same is a lot of faff.)
+    # _instance_lock = threading.Lock()
+    # _stop_event = threading.Event()
+
+    @classmethod
+    def ensure_started(cls):
+        instance = cls._instance
+        if instance is not None and instance.is_alive():
+            # No need to grab the lock
+            return
+        with cls._instance_lock:
+            if cls._instance is None or not cls._instance.is_alive():
+                cls._instance = cls()
+                cls._instance.start()
+
+    @classmethod
+    def ensure_stopped(cls):
+        if cls._instance is None:
+            # No need to grab the lock
+            return
+        with cls._instance_lock:
+            if cls._instance is None:
+                # Nothing to stop
+                return
+            elif not cls._instance.is_alive():
+                # Thread died
+                cls._instance = None
+                return
+
+            # Signal stopping
+            cls._stop_event.set()
+            cls._on_stop()
+            cls._instance.join()
+
+            cls._instance = None
+            cls._stop_event.clear()
+
+    @classmethod
+    def _on_stop(cls):
+        """
+        Hook to allow subclasses to add extra behaviour to stopping.
+        """
+        pass
+
+    def __init__(self, *args, **kwargs):
+        super(SingletonThread, self).__init__(*args, **kwargs)
+        self.daemon = True

scout_apm/core/tracked_request.py

@@ -0,0 +1,328 @@
+# coding=utf-8
+
+import datetime as dt
+import logging
+from contextlib import contextmanager
+from uuid import uuid4
+
+from scout_apm.core import backtrace, objtrace
+from scout_apm.core.agent.commands import BatchCommand
+from scout_apm.core.agent.socket import CoreAgentSocketThread
+from scout_apm.core.config import scout_config
+from scout_apm.core.n_plus_one_tracker import NPlusOneTracker
+from scout_apm.core.sampler import Sampler
+from scout_apm.core.samplers.memory import get_rss_in_mb
+from scout_apm.core.samplers.thread import SamplersThread
+
+logger = logging.getLogger(__name__)
+
+
+class TrackedRequest(object):
+    """
+    This is a container which keeps track of all module instances for a single
+    request. For convenience they are made available as attributes based on
+    their keyname
+    """
+
+    _sampler = None
+
+    @classmethod
+    def get_sampler(cls):
+        if cls._sampler is None:
+            cls._sampler = Sampler(scout_config)
+        return cls._sampler
+
+    __slots__ = (
+        "sampler",
+        "request_id",
+        "start_time",
+        "end_time",
+        "active_spans",
+        "complete_spans",
+        "tags",
+        "is_real_request",
+        "_memory_start",
+        "n_plus_one_tracker",
+        "hit_max",
+        "sent",
+        "operation",
+    )
+
+    # Stop adding new spans at this point, to avoid exhausting memory
+    MAX_COMPLETE_SPANS = 1500
+
+    @classmethod
+    def instance(cls):
+        from scout_apm.core.context import context
+
+        return context.get_tracked_request()
+
+    def __init__(self):
+        self.request_id = "req-" + str(uuid4())
+        self.start_time = dt.datetime.now(dt.timezone.utc)
+        self.end_time = None
+        self.active_spans = []
+        self.complete_spans = []
+        self.tags = {}
+        self.is_real_request = False
+        self._memory_start = get_rss_in_mb()
+        self.n_plus_one_tracker = NPlusOneTracker()
+        self.hit_max = False
+        self.sent = False
+        self.operation = None
+        logger.debug("Starting request: %s", self.request_id)
+
+    def __repr__(self):
+        # Incomplete to avoid TMI
+        return "<TrackedRequest(request_id={}, tags={})>".format(
+            repr(self.request_id), repr(self.tags)
+        )
+
+    def tag(self, key, value):
+        if key in self.tags:
+            logger.debug(
+                "Overwriting previously set tag for request %s: %s",
+                self.request_id,
+                key,
+            )
+        self.tags[key] = value
+
+    def start_span(
+        self,
+        operation,
+        ignore=False,
+        ignore_children=False,
+        should_capture_backtrace=True,
+    ):
+        parent = self.current_span()
+        if parent is not None:
+            parent_id = parent.span_id
+            if parent.ignore_children:
+                ignore = True
+                ignore_children = True
+        else:
+            parent_id = None
+
+        if len(self.complete_spans) >= self.MAX_COMPLETE_SPANS:
+            if not self.hit_max:
+                logger.debug(
+                    "Hit the maximum number of spans, this trace will be incomplete."
+                )
+                self.hit_max = True
+            ignore = True
+            ignore_children = True
+
+        new_span = Span(
+            request_id=self.request_id,
+            operation=operation,
+            ignore=ignore,
+            ignore_children=ignore_children,
+            parent=parent_id,
+            should_capture_backtrace=should_capture_backtrace,
+        )
+        self.active_spans.append(new_span)
+        return new_span
+
+    def stop_span(self):
+        try:
+            stopping_span = self.active_spans.pop()
+        except IndexError as exc:
+            logger.debug("Exception when stopping span", exc_info=exc)
+        else:
+            stopping_span.stop()
+            if not stopping_span.ignore:
+                stopping_span.annotate()
+                self.complete_spans.append(stopping_span)
+
+        if len(self.active_spans) == 0:
+            self.finish()
+
+    @contextmanager
+    def span(self, *args, **kwargs):
+        span = self.start_span(*args, **kwargs)
+        try:
+            yield span
+        finally:
+            self.stop_span()
+
+    def current_span(self):
+        if self.active_spans:
+            return self.active_spans[-1]
+        else:
+            return None
+
+    # Request is done, release any info we have about it.
+    def finish(self):
+        from scout_apm.core.context import context
+
+        logger.debug("Stopping request: %s", self.request_id)
+        if self.end_time is None:
+            self.end_time = dt.datetime.now(dt.timezone.utc)
+
+        if self.is_real_request:
+            if not self.sent and self.get_sampler().should_sample(
+                self.operation, self.is_ignored()
+            ):
+                self.tag("mem_delta", self._get_mem_delta())
+                self.sent = True
+                batch_command = BatchCommand.from_tracked_request(self)
+                if scout_config.value("log_payload_content"):
+                    logger.debug(
+                        "Sending request: %s. Payload: %s",
+                        self.request_id,
+                        batch_command.message(),
+                    )
+                else:
+                    logger.debug("Sending request: %s.", self.request_id)
+                CoreAgentSocketThread.send(batch_command)
+            SamplersThread.ensure_started()
+
+        details = " ".join(
+            "{}={}".format(key, value)
+            for key, value in [
+                ("start_time", self.start_time),
+                ("end_time", self.end_time),
+                ("duration", (self.end_time - self.start_time).total_seconds()),
+                ("active_spans", len(self.active_spans)),
+                ("complete_spans", len(self.complete_spans)),
+                ("tags", len(self.tags)),
+                ("hit_max", self.hit_max),
+                ("is_real_request", self.is_real_request),
+                ("sent", self.sent),
+            ]
+        )
+        logger.debug("Request %s %s", self.request_id, details)
+        context.clear_tracked_request(self)
+
+    def _get_mem_delta(self):
+        current_mem = get_rss_in_mb()
+        if current_mem > self._memory_start:
+            return current_mem - self._memory_start
+        return 0.0
+
+    # A request is ignored if the tag "ignore_transaction" is set to True
+    def is_ignored(self):
+        return self.tags.get("ignore_transaction", False)
+
+
+class Span(object):
+    __slots__ = (
+        "span_id",
+        "start_time",
+        "end_time",
+        "request_id",
+        "operation",
+        "ignore",
+        "ignore_children",
+        "parent",
+        "tags",
+        "start_objtrace_counts",
+        "end_objtrace_counts",
+        "should_capture_backtrace",
+    )
+
+    def __init__(
+        self,
+        request_id=None,
+        operation=None,
+        ignore=False,
+        ignore_children=False,
+        parent=None,
+        should_capture_backtrace=True,
+    ):
+        self.span_id = "span-" + str(uuid4())
+        self.start_time = dt.datetime.now(dt.timezone.utc)
+        self.end_time = None
+        self.request_id = request_id
+        self.operation = operation
+        self.ignore = ignore
+        self.ignore_children = ignore_children
+        self.parent = parent
+        self.tags = {}
+        self.start_objtrace_counts = objtrace.get_counts()
+        self.end_objtrace_counts = (0, 0, 0, 0)
+        self.should_capture_backtrace = should_capture_backtrace
+
+    def __repr__(self):
+        # Incomplete to avoid TMI
+        return "<Span(span_id={}, operation={}, ignore={}, tags={})>".format(
+            repr(self.span_id), repr(self.operation), repr(self.ignore), repr(self.tags)
+        )
+
+    def stop(self):
+        self.end_time = dt.datetime.now(dt.timezone.utc)
+        self.end_objtrace_counts = objtrace.get_counts()
+
+    def tag(self, key, value):
+        if key in self.tags:
+            logger.debug(
+                "Overwriting previously set tag for span %s: %s", self.span_id, key
+            )
+        self.tags[key] = value
+
+    # In seconds
+    def duration(self):
+        if self.end_time is not None:
+            return (self.end_time - self.start_time).total_seconds()
+        else:
+            # Current, running duration
+            return (
+                dt.datetime.now(tz=dt.timezone.utc) - self.start_time
+            ).total_seconds()
+
+    # Add any interesting annotations to the span. Assumes that we are in the
+    # process of stopping this span.
+    def annotate(self):
+        self.add_allocation_tags()
+        if not self.should_capture_backtrace:
+            return
+        slow_threshold = 0.5
+        if self.duration() > slow_threshold:
+            self.capture_backtrace()
+
+    def add_allocation_tags(self):
+        if not objtrace.is_extension:
+            logger.debug("Not adding allocation tags: extension not loaded")
+            return
+
+        start_allocs = (
+            self.start_objtrace_counts[0]
+            + self.start_objtrace_counts[1]
+            + self.start_objtrace_counts[2]
+        )
+        end_allocs = (
+            self.end_objtrace_counts[0]
+            + self.end_objtrace_counts[1]
+            + self.end_objtrace_counts[2]
+        )
+
+        # If even one of the counters rolled over, we're pretty much
+        # guaranteed to have end_allocs be less than start_allocs.
+        # This should rarely happen. Max Unsigned Long Long is a big number
+        if end_allocs - start_allocs < 0:
+            logger.debug(
+                "End allocation count smaller than start allocation "
+                "count for span %s: start = %d, end = %d",
+                self.span_id,
+                start_allocs,
+                end_allocs,
+            )
+            return
+
+        self.tag("allocations", end_allocs - start_allocs)
+        self.tag("start_allocations", start_allocs)
+        self.tag("stop_allocations", end_allocs)
+
+    def capture_backtrace(self):
+        # The core-agent will trim the full_path as necessary.
+        self.tag(
+            "stack",
+            [
+                {
+                    "file": frame["full_path"],
+                    "line": frame["line"],
+                    "function": frame["function"],
+                }
+                for frame in backtrace.capture_backtrace()
+            ],
+        )

scout_apm/core/web_requests.py

@@ -0,0 +1,167 @@
+# coding=utf-8
+
+from scout_apm.compat import parse_qsl, urlencode
+from scout_apm.core.config import scout_config
+from scout_apm.core.queue_time import track_request_queue_time
+
+# Originally derived from:
+# 1. Rails:
+#   https://github.com/rails/rails/blob/0196551e6039ca864d1eee1e01819fcae12c1dc9/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt  # noqa
+# 2. Sentry server side scrubbing:
+#   https://docs.sentry.io/data-management/sensitive-data/#server-side-scrubbing
+FILTER_PARAMETERS = frozenset(
+    [
+        "access",
+        "access_token",
+        "api_key",
+        "apikey",
+        "auth",
+        "auth_token",
+        "card[number]",
+        "certificate",
+        "credentials",
+        "crypt",
+        "key",
+        "mysql_pwd",
+        "otp",
+        "passwd",
+        "password",
+        "private",
+        "protected",
+        "salt",
+        "secret",
+        "secret_key",
+        "ssn",
+        "stripetoken",
+        "token",
+    ]
+)
+
+
+def create_filtered_path(path, query_params):
+    if scout_config.value("uri_reporting") == "path":
+        return path
+    filtered_params = sorted(
+        [
+            (
+                str(key).encode("utf-8"),
+                # Apply str again to cover the None case.
+                str(filter_element(key, value)).encode("utf-8"),
+            )
+            for key, value in query_params
+        ]
+    )
+    if not filtered_params:
+        return path
+    return path + "?" + urlencode(filtered_params)
+
+
+def filter_element(key, value):
+    """
+    Filter an individual key/value element of sensitive content. If the
+    value is a dictionary, recursively filter the keys in that dictionary.
+
+    Can be used recursively on a dict with:
+
+        filter_element('', {"foo": "bar"})
+    """
+    is_sensitive = str(key).lower() in FILTER_PARAMETERS
+
+    if is_sensitive:
+        filtered = "[FILTERED]"
+    elif isinstance(value, dict):
+        # Python 2 unicode compatibility: force all keys and values to bytes
+        #
+        # We expect query_params to have keys and values both of strings, because
+        # that's how frameworks build it. However sometimes application code
+        # mutates this structure to use incorrect types, or we are filtering a
+        # different collection, so we have to cautiously make everything a string
+        # again. Ignoring the possibilities of bytes or objects with bad __str__
+        # methods because they seem very unlikely.
+        filtered = {str(k): filter_element(k, v) for k, v in value.items()}
+    elif isinstance(value, list):
+        filtered = [filter_element("", v) for v in value]
+    elif isinstance(value, set):
+        filtered = {filter_element("", v) for v in value}
+    elif isinstance(value, tuple):
+        filtered = tuple([filter_element("", v) for v in value])
+    elif value is None:
+        filtered = value
+    else:
+        filtered = str(value)
+
+    return filtered
+
+
+def ignore_path(path):
+    ignored_paths = scout_config.value("ignore")
+    for ignored in ignored_paths:
+        if path.lstrip(" /").startswith(ignored):
+            return True
+    return False
+
+
+def asgi_track_request_data(scope, tracked_request):
+    """
+    Track request data from an ASGI HTTP or Websocket scope.
+    """
+    path = scope.get("root_path", "") + scope["path"]
+    query_params = parse_qsl(scope.get("query_string", b"").decode("utf-8"))
+    tracked_request.tag("path", create_filtered_path(path, query_params))
+    if ignore_path(path):
+        tracked_request.tag("ignore_transaction", True)
+
+    # We only care about the last values of headers so don't care that we use
+    # a plain dict rather than a multi-value dict
+    headers = {k.lower(): v for k, v in scope.get("headers", ())}
+
+    if scout_config.value("collect_remote_ip"):
+        user_ip = (
+            headers.get(b"x-forwarded-for", b"").decode("latin1").split(",")[0]
+            or headers.get(b"client-ip", b"").decode("latin1").split(",")[0]
+            or scope.get("client", ("",))[0]
+        )
+        tracked_request.tag("user_ip", user_ip)
+
+    queue_time = headers.get(b"x-queue-start", b"") or headers.get(
+        b"x-request-start", b""
+    )
+    track_request_queue_time(queue_time.decode("latin1"), tracked_request)
+
+
+def werkzeug_track_request_data(werkzeug_request, tracked_request):
+    """
+    Several integrations use Werkzeug requests, so share the code for
+    extracting common data here.
+    """
+    path = werkzeug_request.path
+    tracked_request.tag(
+        "path", create_filtered_path(path, werkzeug_request.args.items(multi=True))
+    )
+    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 = (
+            werkzeug_request.headers.get("x-forwarded-for", default="").split(",")[0]
+            or werkzeug_request.headers.get("client-ip", default="").split(",")[0]
+            or werkzeug_request.remote_addr
+        )
+        tracked_request.tag("user_ip", user_ip)
+
+    queue_time = werkzeug_request.headers.get(
+        "x-queue-start", default=""
+    ) or werkzeug_request.headers.get("x-request-start", default="")
+    track_request_queue_time(queue_time, tracked_request)
+
+
+class RequestComponents(object):
+    __slots__ = ("module", "controller", "action")
+
+    def __init__(self, module, controller, action):
+        self.module = module
+        self.controller = controller
+        self.action = action

scout_apm/django/__init__.py

@@ -0,0 +1,7 @@
+# coding=utf-8
+
+import django
+
+if django.VERSION < (3, 2, 0):
+    # Only define default_app_config when using a version earlier than 3.2
+    default_app_config = "scout_apm.django.apps.ScoutApmDjangoConfig"