scout-apm 3.3.0__cp38-cp38-musllinux_1_2_i686.whl

scout_apm/core/__init__.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+
+import atexit
+import logging
+import os
+import sys
+
+from scout_apm import instruments
+from scout_apm.compat import kwargs_only
+from scout_apm.core import objtrace
+from scout_apm.core.agent.manager import CoreAgentManager
+from scout_apm.core.agent.socket import CoreAgentSocketThread
+from scout_apm.core.config import scout_config
+from scout_apm.core.error_service import ErrorServiceThread
+from scout_apm.core.metadata import report_app_metadata
+
+logger = logging.getLogger(__name__)
+
+
+@kwargs_only
+def install(config=None):
+    global shutdown_registered
+    if config is not None:
+        scout_config.set(**config)
+    scout_config.log()
+
+    if os.name == "nt":
+        logger.info(
+            "APM Not Launching on PID: %s - Windows is not supported", os.getpid()
+        )
+        return False
+
+    if not scout_config.value("monitor"):
+        logger.info(
+            "APM Not Launching on PID: %s - Configuration 'monitor' is not true",
+            os.getpid(),
+        )
+        return False
+
+    instruments.ensure_all_installed()
+    objtrace.enable()
+
+    logger.debug("APM Launching on PID: %s", os.getpid())
+    launched = CoreAgentManager().launch()
+
+    report_app_metadata()
+    if launched:
+        # Stop the thread to avoid running threads pre-fork
+        CoreAgentSocketThread.ensure_stopped()
+
+    if scout_config.value("shutdown_timeout_seconds") > 0.0 and not shutdown_registered:
+        atexit.register(shutdown)
+        shutdown_registered = True
+
+    return True
+
+
+shutdown_registered = False
+
+
+def shutdown():
+    timeout_seconds = scout_config.value("shutdown_timeout_seconds")
+
+    def apm_callback(queue_size):
+        if scout_config.value("shutdown_message_enabled"):
+            print(  # noqa: T001,T201
+                (
+                    "Scout draining {queue_size} event{s} for up to"
+                    + " {timeout_seconds} seconds"
+                ).format(
+                    queue_size=queue_size,
+                    s=("" if queue_size == 1 else "s"),
+                    timeout_seconds=timeout_seconds,
+                ),
+                file=sys.stderr,
+            )
+
+    def error_callback(queue_size):
+        if scout_config.value("shutdown_message_enabled"):
+            print(  # noqa: T001,T201
+                (
+                    "Scout draining {queue_size} error{s} for up to"
+                    + " {timeout_seconds} seconds"
+                ).format(
+                    queue_size=queue_size,
+                    s=("" if queue_size == 1 else "s"),
+                    timeout_seconds=timeout_seconds,
+                ),
+                file=sys.stderr,
+            )
+
+    CoreAgentSocketThread.wait_until_drained(
+        timeout_seconds=timeout_seconds, callback=apm_callback
+    )
+
+    if scout_config.value("errors_enabled"):
+        ErrorServiceThread.wait_until_drained(
+            timeout_seconds=timeout_seconds, callback=error_callback
+        )

scout_apm/core/agent/commands.py

@@ -0,0 +1,250 @@
+# coding=utf-8
+
+import datetime as dt
+import logging
+import re
+
+from scout_apm.compat import iteritems
+
+logger = logging.getLogger(__name__)
+
+key_regex = re.compile(r"^[a-zA-Z0-9]{20}$")
+
+
+def format_dt_for_core_agent(event_time: dt.datetime) -> str:
+    """
+    Returns expected format for Core Agent compatibility.
+    Coerce any tz-aware datetime to UTC just in case.
+    """
+    # if we somehow got a naive datetime, convert it to UTC
+    if event_time.tzinfo is None:
+        logger.warning("Naive datetime passed to format_dt_for_core_agent")
+        event_time = event_time.astimezone(dt.timezone.utc)
+    return event_time.isoformat()
+
+
+class Register(object):
+    __slots__ = ("app", "key", "hostname")
+
+    def __init__(self, app, key, hostname):
+        self.app = app
+        self.key = key
+        self.hostname = hostname
+
+    def message(self):
+        key_prefix = self.key[:3]
+        key_matches_regex = bool(key_regex.match(self.key))
+        logger.info(
+            "Registering with app=%s key_prefix=%s key_format_validated=%s host=%s"
+            % (self.app, key_prefix, key_matches_regex, self.hostname)
+        )
+        return {
+            "Register": {
+                "app": self.app,
+                "key": self.key,
+                "host": self.hostname,
+                "language": "python",
+                "api_version": "1.0",
+            }
+        }
+
+
+class StartSpan(object):
+    __slots__ = ("timestamp", "request_id", "span_id", "parent", "operation")
+
+    def __init__(self, timestamp, request_id, span_id, parent, operation):
+        self.timestamp = timestamp
+        self.request_id = request_id
+        self.span_id = span_id
+        self.parent = parent
+        self.operation = operation
+
+    def message(self):
+        return {
+            "StartSpan": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+                "span_id": self.span_id,
+                "parent_id": self.parent,
+                "operation": self.operation,
+            }
+        }
+
+
+class StopSpan(object):
+    __slots__ = ("timestamp", "request_id", "span_id")
+
+    def __init__(self, timestamp, request_id, span_id):
+        self.timestamp = timestamp
+        self.request_id = request_id
+        self.span_id = span_id
+
+    def message(self):
+        return {
+            "StopSpan": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+                "span_id": self.span_id,
+            }
+        }
+
+
+class StartRequest(object):
+    __slots__ = ("timestamp", "request_id")
+
+    def __init__(self, timestamp, request_id):
+        self.timestamp = timestamp
+        self.request_id = request_id
+
+    def message(self):
+        return {
+            "StartRequest": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+            }
+        }
+
+
+class FinishRequest(object):
+    __slots__ = ("timestamp", "request_id")
+
+    def __init__(self, timestamp, request_id):
+        self.timestamp = timestamp
+        self.request_id = request_id
+
+    def message(self):
+        return {
+            "FinishRequest": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+            }
+        }
+
+
+class TagSpan(object):
+    __slots__ = ("timestamp", "request_id", "span_id", "tag", "value")
+
+    def __init__(self, timestamp, request_id, span_id, tag, value):
+        self.timestamp = timestamp
+        self.request_id = request_id
+        self.span_id = span_id
+        self.tag = tag
+        self.value = value
+
+    def message(self):
+        return {
+            "TagSpan": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+                "span_id": self.span_id,
+                "tag": self.tag,
+                "value": self.value,
+            }
+        }
+
+
+class TagRequest(object):
+    __slots__ = ("timestamp", "request_id", "tag", "value")
+
+    def __init__(self, timestamp, request_id, tag, value):
+        self.timestamp = timestamp
+        self.request_id = request_id
+        self.tag = tag
+        self.value = value
+
+    def message(self):
+        return {
+            "TagRequest": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "request_id": self.request_id,
+                "tag": self.tag,
+                "value": self.value,
+            }
+        }
+
+
+class ApplicationEvent(object):
+    __slots__ = ("event_type", "event_value", "source", "timestamp")
+
+    def __init__(self, event_type, event_value, source, timestamp):
+        self.event_type = event_type
+        self.event_value = event_value
+        self.source = source
+        self.timestamp = timestamp
+
+    def message(self):
+        return {
+            "ApplicationEvent": {
+                "timestamp": format_dt_for_core_agent(self.timestamp),
+                "event_type": self.event_type,
+                "event_value": self.event_value,
+                "source": self.source,
+            }
+        }
+
+
+class BatchCommand(object):
+    __slots__ = ("commands",)
+
+    def __init__(self, commands):
+        self.commands = commands
+
+    def message(self):
+        return {
+            "BatchCommand": {
+                "commands": [command.message() for command in self.commands]
+            }
+        }
+
+    @classmethod
+    def from_tracked_request(cls, request):
+        # The TrackedRequest must be finished
+        commands = []
+        commands.append(
+            StartRequest(timestamp=request.start_time, request_id=request.request_id)
+        )
+        for key, value in iteritems(request.tags):
+            commands.append(
+                TagRequest(
+                    timestamp=request.start_time,
+                    request_id=request.request_id,
+                    tag=key,
+                    value=value,
+                )
+            )
+
+        for span in request.complete_spans:
+            commands.append(
+                StartSpan(
+                    timestamp=span.start_time,
+                    request_id=span.request_id,
+                    span_id=span.span_id,
+                    parent=span.parent,
+                    operation=span.operation,
+                )
+            )
+
+            for key, value in iteritems(span.tags):
+                commands.append(
+                    TagSpan(
+                        timestamp=span.start_time,
+                        request_id=request.request_id,
+                        span_id=span.span_id,
+                        tag=key,
+                        value=value,
+                    )
+                )
+
+            commands.append(
+                StopSpan(
+                    timestamp=span.end_time,
+                    request_id=span.request_id,
+                    span_id=span.span_id,
+                )
+            )
+
+        commands.append(
+            FinishRequest(timestamp=request.end_time, request_id=request.request_id)
+        )
+
+        return cls(commands)

scout_apm/core/agent/manager.py

@@ -0,0 +1,319 @@
+# coding=utf-8
+
+import errno
+import hashlib
+import json
+import logging
+import os
+import subprocess
+import tarfile
+import time
+
+from urllib3.exceptions import HTTPError
+
+from scout_apm.compat import urllib3_cert_pool_manager
+from scout_apm.core.config import scout_config
+
+logger = logging.getLogger(__name__)
+
+CA_ALREADY_RUNNING_EXIT_CODE = 3
+
+
+class CoreAgentManager(object):
+    def __init__(self):
+        self.core_agent_bin_path = None
+        self.core_agent_bin_version = None
+        self.core_agent_dir = "{}/{}".format(
+            scout_config.value("core_agent_dir"),
+            scout_config.value("core_agent_full_name"),
+        )
+        self.downloader = CoreAgentDownloader(
+            self.core_agent_dir, scout_config.value("core_agent_full_name")
+        )
+
+    def launch(self):
+        if not scout_config.value("core_agent_launch"):
+            logger.debug(
+                "Not attempting to launch Core Agent "
+                "due to 'core_agent_launch' setting."
+            )
+            return False
+
+        if not self.verify():
+            if not scout_config.value("core_agent_download"):
+                logger.debug(
+                    "Not attempting to download Core Agent due "
+                    "to 'core_agent_download' setting."
+                )
+                return False
+
+            self.download()
+
+            if not self.verify():
+                logger.debug("Failed to verify Core Agent. Not launching Core Agent.")
+                return False
+
+        return self.run()
+
+    def download(self):
+        self.downloader.download()
+
+    def run(self):
+        try:
+            with open(os.devnull) as devnull:
+                subprocess.check_call(
+                    (
+                        self.agent_binary()
+                        + self.daemonize_flag()
+                        + self.log_level()
+                        + self.log_file()
+                        + self.config_file()
+                        + self.socket_path()
+                    ),
+                    close_fds=True,
+                    stdout=devnull,
+                )
+        except subprocess.CalledProcessError as err:
+            if err.returncode == CA_ALREADY_RUNNING_EXIT_CODE:
+                # Other processes may have already started the core agent.
+                logger.debug("Core agent already running.")
+                return True
+            else:
+                logger.exception("CalledProcessError running Core Agent")
+            return False
+        except Exception:
+            # TODO detect failure of launch properly
+            logger.exception("Error running Core Agent")
+            return False
+        return True
+
+    def agent_binary(self):
+        return [self.core_agent_bin_path, "start"]
+
+    def daemonize_flag(self):
+        return ["--daemonize", "true"]
+
+    def socket_path(self):
+        path = get_socket_path()
+        if path.is_tcp:
+            return ["--tcp", path.tcp_address]
+        else:
+            return ["--socket", path]
+
+    def log_level(self):
+        # Old deprecated name "log_level"
+        log_level = scout_config.value("log_level")
+        if log_level is None:
+            log_level = scout_config.value("core_agent_log_level")
+        return ["--log-level", log_level]
+
+    def log_file(self):
+        # Old deprecated name "log_file"
+        path = scout_config.value("log_file")
+        if path is None:
+            path = scout_config.value("core_agent_log_file")
+
+        if path is not None:
+            return ["--log-file", path]
+        else:
+            return []
+
+    def config_file(self):
+        # Old deprecated name "config_file"
+        path = scout_config.value("config_file")
+        if path is None:
+            path = scout_config.value("core_agent_config_file")
+
+        if path is not None:
+            return ["--config-file", path]
+        else:
+            return []
+
+    def verify(self):
+        manifest = parse_manifest(self.core_agent_dir + "/manifest.json")
+        if manifest is None:
+            logger.debug(
+                "Core Agent verification failed: CoreAgentManifest is not valid."
+            )
+            self.core_agent_bin_path = None
+            self.core_agent_bin_version = None
+            return False
+
+        bin_path = os.path.join(self.core_agent_dir, manifest.bin_name)
+        if sha256_digest(bin_path) == manifest.sha256:
+            self.core_agent_bin_path = bin_path
+            self.core_agent_bin_version = manifest.bin_version
+            return True
+        else:
+            logger.debug("Core Agent verification failed: SHA mismatch.")
+            self.core_agent_bin_path = None
+            self.core_agent_bin_version = None
+            return False
+
+
+class CoreAgentDownloader(object):
+    def __init__(self, download_destination, core_agent_full_name):
+        self.stale_download_secs = 120
+        self.destination = download_destination
+        self.core_agent_full_name = core_agent_full_name
+        self.package_location = self.destination + "/{}.tgz".format(
+            self.core_agent_full_name
+        )
+        self.download_lock_path = self.destination + "/download.lock"
+        self.download_lock_fd = None
+
+    def download(self):
+        self.create_core_agent_dir()
+        self.obtain_download_lock()
+        if self.download_lock_fd is not None:
+            try:
+                downloaded = self.download_package()
+                if downloaded:
+                    self.untar()
+                else:
+                    logger.debug("Core Agent download failed: bad http response.")
+            except (OSError, HTTPError):
+                logger.exception("Exception raised while downloading Core Agent")
+            finally:
+                self.release_download_lock()
+
+    def create_core_agent_dir(self):
+        try:
+            os.makedirs(self.destination, scout_config.core_agent_permissions())
+        except OSError:
+            pass
+
+    def obtain_download_lock(self):
+        self.clean_stale_download_lock()
+        try:
+            self.download_lock_fd = os.open(
+                self.download_lock_path,
+                os.O_RDWR | os.O_CREAT | os.O_EXCL | os.O_NONBLOCK,
+            )
+        except OSError as exc:
+            logger.debug(
+                "Could not obtain download lock on %s",
+                self.download_lock_path,
+                exc_info=exc,
+            )
+            self.download_lock_fd = None
+
+    def clean_stale_download_lock(self):
+        try:
+            delta = time.time() - os.stat(self.download_lock_path).st_ctime
+            if delta > self.stale_download_secs:
+                logger.debug("Clearing stale download lock file.")
+                os.unlink(self.download_lock_path)
+        except OSError:
+            pass
+
+    def release_download_lock(self):
+        if self.download_lock_fd is not None:
+            os.unlink(self.download_lock_path)
+            os.close(self.download_lock_fd)
+
+    def download_package(self):
+        full_url = self.full_url()
+        logger.debug("Downloading: %s to %s", full_url, self.package_location)
+        http = urllib3_cert_pool_manager()
+        response = http.request(
+            "GET", full_url, preload_content=False, timeout=10.0, retries=3
+        )
+        try:
+            if response.status != 200:
+                return False
+            with open(self.package_location, "wb") as fp:
+                for chunk in response.stream():
+                    fp.write(chunk)
+        finally:
+            response.release_conn()
+            http.clear()
+        return True
+
+    def untar(self):
+        t = tarfile.open(self.package_location, "r")
+        t.extractall(self.destination)
+
+    def full_url(self):
+        return "{root_url}/{core_agent_full_name}.tgz".format(
+            root_url=self.root_url(), core_agent_full_name=self.core_agent_full_name
+        )
+
+    def root_url(self):
+        return scout_config.value("download_url")
+
+
+def parse_manifest(path):
+    try:
+        manifest_file = open(path)
+    except OSError as exc:
+        if exc.errno == errno.ENOENT:
+            logger.debug("Core Agent Manifest does not exist at %s", path)
+        else:
+            logger.debug("Error opening Core Agent Manifest at %s", path, exc_info=exc)
+        return None
+
+    try:
+        with manifest_file:
+            data = json.load(manifest_file)
+            logger.debug("Core Agent manifest json: %s", data)
+
+            bin_name = data["core_agent_binary"]
+            if not isinstance(bin_name, str):
+                raise TypeError("core_agent_binary should be a string.")
+            bin_version = data["core_agent_version"]
+            if not isinstance(bin_version, str):
+                raise TypeError("core_agent_version should be a string.")
+            sha256 = data["core_agent_binary_sha256"]
+            if not isinstance(sha256, str):
+                raise TypeError("core_agent_binary_sha256 should be a string.")
+
+            return CoreAgentManifest(
+                bin_name=bin_name,
+                bin_version=bin_version,
+                sha256=sha256,
+            )
+
+    # IOError => OSError on Python 3
+    except (KeyError, ValueError, TypeError, OSError, IOError) as exc:  # noqa: B014
+        logger.debug("Error parsing Core Agent Manifest", exc_info=exc)
+        return None
+
+
+class CoreAgentManifest(object):
+    __slots__ = ("bin_name", "bin_version", "sha256")
+
+    def __init__(self, bin_name, bin_version, sha256):
+        self.bin_name = bin_name
+        self.bin_version = bin_version
+        self.sha256 = sha256
+
+
+def sha256_digest(filename, block_size=65536):
+    try:
+        sha256 = hashlib.sha256()
+        with open(filename, "rb") as f:
+            for block in iter(lambda: f.read(block_size), b""):
+                sha256.update(block)
+        return sha256.hexdigest()
+    except OSError as exc:
+        logger.debug("Error on digest", exc_info=exc)
+        return None
+
+
+class SocketPath(str):
+    @property
+    def is_tcp(self):
+        return self.startswith("tcp://")
+
+    @property
+    def tcp_address(self):
+        return self[len("tcp://") :]
+
+
+def get_socket_path():
+    # Old deprecated name "socket_path"
+    socket_path = scout_config.value("socket_path")
+    if socket_path is None:
+        socket_path = scout_config.value("core_agent_socket_path")
+    return SocketPath(socket_path)