scout-apm 3.3.0__cp38-cp38-musllinux_1_2_i686.whl

scout_apm/instruments/elasticsearch.py

@@ -0,0 +1,263 @@
+# coding=utf-8
+
+import logging
+from collections import namedtuple
+
+import wrapt
+
+from scout_apm.compat import get_pos_args, unwrap_decorators
+from scout_apm.core.tracked_request import TrackedRequest
+
+try:
+    from elasticsearch import VERSION as ELASTICSEARCH_VERSION
+    from elasticsearch import Elasticsearch
+except ImportError:  # pragma: no cover
+    Elasticsearch = None
+    ELASTICSEARCH_VERSION = (0, 0, 0)
+
+try:
+    # Transport was moved to elastic_transport as of v8.0.0
+    from elastic_transport import Transport
+except ImportError:  # pragma: no cover
+    try:
+        from elasticsearch import Transport
+    except ImportError:  # pragma: no cover
+        Transport = None
+
+logger = logging.getLogger(__name__)
+
+
+def ensure_installed():
+    logger.debug("Instrumenting elasticsearch.")
+
+    if Elasticsearch is None or Transport is None:
+        if Elasticsearch is None:
+            logger.debug(
+                "Couldn't import elasticsearch.Elasticsearch "
+                "- probably not installed."
+            )
+        if Transport is None:
+            logger.debug(
+                "Couldn't import elasticsearch.Transport or "
+                "elastic_transport.Transport - probably not installed."
+            )
+    else:
+        ensure_client_instrumented()
+        ensure_transport_instrumented()
+
+
+ClientMethod = namedtuple("ClientMethod", ["name", "takes_index_argument"])
+
+VERSIONED_CLIENT_METHODS = {
+    "v7": [
+        ClientMethod("bulk", True),
+        ClientMethod("clear_scroll", False),
+        ClientMethod("close", False),
+        ClientMethod("close_point_in_time", False),
+        ClientMethod("count", True),
+        ClientMethod("create", True),
+        ClientMethod("delete", True),
+        ClientMethod("delete_by_query", True),
+        ClientMethod("delete_by_query_rethrottle", False),
+        ClientMethod("delete_script", False),
+        ClientMethod("exists", True),
+        ClientMethod("exists_source", True),
+        ClientMethod("explain", True),
+        ClientMethod("field_caps", True),
+        ClientMethod("get", True),
+        ClientMethod("get_script", False),
+        ClientMethod("get_script_context", False),
+        ClientMethod("get_script_languages", False),
+        ClientMethod("get_source", True),
+        ClientMethod("index", True),
+        ClientMethod("info", False),
+        ClientMethod("mget", True),
+        ClientMethod("msearch", True),
+        ClientMethod("msearch_template", True),
+        ClientMethod("mtermvectors", True),
+        ClientMethod("open_point_in_time", True),
+        ClientMethod("ping", False),
+        ClientMethod("put_script", False),
+        ClientMethod("rank_eval", True),
+        ClientMethod("reindex", False),
+        ClientMethod("reindex_rethrottle", False),
+        ClientMethod("render_search_template", False),
+        ClientMethod("scripts_painless_execute", False),
+        ClientMethod("scroll", False),
+        ClientMethod("search", True),
+        ClientMethod("search_mvt", True),
+        ClientMethod("search_shards", True),
+        ClientMethod("search_template", True),
+        ClientMethod("termvectors", True),
+        ClientMethod("terms_enum", True),
+        ClientMethod("update", True),
+        ClientMethod("update_by_query", True),
+        ClientMethod("update_by_query_rethrottle", False),
+    ],
+    "v8": [
+        ClientMethod("knn_search", True),
+        ClientMethod("health_report", False),
+    ],
+}
+
+CLIENT_METHODS = VERSIONED_CLIENT_METHODS["v7"][:]
+if ELASTICSEARCH_VERSION > (8, 0, 0):
+    CLIENT_METHODS += VERSIONED_CLIENT_METHODS["v8"]
+
+
+have_patched_client = False
+
+
+def ensure_client_instrumented():
+    global have_patched_client
+
+    if not have_patched_client:
+        instrumented_count = 0
+        for name, takes_index_argument in CLIENT_METHODS:
+            try:
+                method = getattr(Elasticsearch, name)
+                if takes_index_argument:
+                    wrapped = wrap_client_index_method(method)
+                else:
+                    wrapped = wrap_client_method(method)
+                setattr(Elasticsearch, name, wrapped)
+                instrumented_count += 1
+            except Exception as exc:
+                logger.debug(
+                    "Failed to instrument elasticsearch.Elasticsearch.%s: %r",
+                    name,
+                    exc,
+                    exc_info=exc,
+                )
+        if instrumented_count == 0:
+            logger.warning(
+                "Failed to instrument any elasticsearch.Elasticsearch methods."
+                " Enable debug logs to view root causes."
+            )
+
+        have_patched_client = True
+
+
+@wrapt.decorator
+def wrap_client_index_method(wrapped, instance, args, kwargs):
+    # elasticsearch-py 7.5.1 changed the order of arguments for client methods,
+    # so to be safe we need to inspect the wrapped method's positional
+    # arguments to see if we should pull it from there
+    if "index" in kwargs:
+        index = kwargs["index"]
+    else:
+        unwrapped = unwrap_decorators(wrapped)
+        pos_args = get_pos_args(unwrapped)
+        try:
+            index_index = pos_args.index("index")
+        except ValueError:  # pragma: no cover
+            # This guards against the method not accepting an 'index' argument
+            # but they all do - for now
+            index = ""
+        else:
+            try:
+                index = args[index_index - 1]  # subtract 'self'
+            except IndexError:
+                index = ""
+
+    if isinstance(index, (list, tuple)):
+        index = ",".join(index)
+    if index == "":
+        index = "Unknown"
+    index = index.title()
+
+    camel_name = "".join(c.title() for c in wrapped.__name__.split("_"))
+    operation = "Elasticsearch/{}/{}".format(index, camel_name)
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation=operation, ignore_children=True):
+        return wrapped(*args, **kwargs)
+
+
+@wrapt.decorator
+def wrap_client_method(wrapped, instance, args, kwargs):
+    camel_name = "".join(c.title() for c in wrapped.__name__.split("_"))
+    operation = "Elasticsearch/{}".format(camel_name)
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation=operation, ignore_children=True):
+        return wrapped(*args, **kwargs)
+
+
+have_patched_transport = False
+
+
+def ensure_transport_instrumented():
+    global have_patched_transport
+
+    if not have_patched_transport:
+        try:
+            Transport.perform_request = wrapped_perform_request(
+                Transport.perform_request
+            )
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument elasticsearch.Transport.perform_request: %r",
+                exc,
+                exc_info=exc,
+            )
+
+    have_patched_transport = True
+
+
+def _sanitize_name(name):
+    try:
+        op = name.split("/")[-1]
+        op = op[1:]  # chop leading '_' from op
+        known_names = (
+            "bench",
+            "bulk",
+            "count",
+            "delete_by_query",
+            "execute",
+            "exists",
+            "explain",
+            "field_caps",
+            "field_stats",
+            "health",
+            "mget",
+            "mlt",
+            "mpercolate",
+            "msearch",
+            "mtermvectors",
+            "percolate",
+            "pit",
+            "query",
+            "rank_eval",
+            "reindex",
+            "script_context",
+            "script_language",
+            "scroll",
+            "search_shards",
+            "source",
+            "suggest",
+            "template",
+            "termvectors",
+            "terms_enum",
+            "update",
+            "update_by_query",
+            "search",
+        )
+        if op in known_names:
+            return op.title()
+        return "Unknown"
+    except Exception:
+        return "Unknown"
+
+
+@wrapt.decorator
+def wrapped_perform_request(wrapped, instance, args, kwargs):
+    try:
+        op = _sanitize_name(args[1])
+    except IndexError:
+        op = "Unknown"
+
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(
+        operation="Elasticsearch/{}".format(op),
+        ignore_children=True,
+    ):
+        return wrapped(*args, **kwargs)

scout_apm/instruments/jinja2.py

@@ -0,0 +1,127 @@
+# coding=utf-8
+
+import logging
+import sys
+
+import wrapt
+
+from scout_apm.core.tracked_request import TrackedRequest
+
+try:
+    from jinja2 import Environment
+except ImportError:  # pragma: no cover
+    Environment = None
+
+try:
+    from jinja2 import Template
+except ImportError:  # pragma: no cover
+    Template = None
+
+# The async_ module can only be shipped on Python 3.6+
+try:
+    from scout_apm.async_.instruments.jinja2 import wrapped_render_async
+except ImportError:
+    wrapped_render_async = None
+
+
+logger = logging.getLogger(__name__)
+
+
+have_patched_environment_init = False
+have_patched_template_render = False
+have_patched_template_render_async = False
+
+
+def ensure_installed():
+    global have_patched_template_render
+
+    logger.debug("Instrumenting Jinja2.")
+
+    if Template is None:
+        logger.debug("Couldn't import jinja2.Template - probably not installed.")
+        return
+
+    instrument_render_async()
+
+    if not have_patched_template_render:
+        try:
+            Template.render = wrapped_render(Template.render)
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument jinja2.Template.render: %r", exc, exc_info=exc
+            )
+        else:
+            have_patched_template_render = True
+
+
+def instrument_render_async():
+    global have_patched_environment_init
+    global have_patched_template_render_async
+
+    if wrapped_render_async is None:
+        return
+
+    if not have_patched_environment_init and not hasattr(Template, "render_async"):
+        try:
+            Environment.__init__ = wrapped_environment_init_jinja_v2(
+                Environment.__init__
+            )
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument jinja2.Environment.__init__: %r",
+                exc,
+                exc_info=exc,
+            )
+        else:
+            have_patched_environment_init = True
+    elif hasattr(Template, "render_async") and not have_patched_template_render_async:
+        try:
+            Template.render_async = wrapped_render_async(Template.render_async)
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument jinja2.Template.render_async: %r",
+                exc,
+                exc_info=exc,
+            )
+        else:
+            have_patched_template_render_async = True
+
+
+@wrapt.decorator
+def wrapped_render(wrapped, instance, args, kwargs):
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation="Template/Render") as span:
+        span.tag("name", instance.name)
+        return wrapped(*args, **kwargs)
+
+
+@wrapt.decorator
+def wrapped_environment_init_jinja_v2(wrapped, instance, args, kwargs):
+    """
+    Delayed wrapping of render_async(), since Template won't have this method
+    until after jinja2.asyncsupport is imported, which since Jinja2 2.11.0 is
+    done conditionally in Environment.__init__:
+    https://github.com/pallets/jinja/issues/765
+
+    This is no longer needed since Jinja2 v3.0.0
+    """
+    global have_patched_template_render_async
+    result = wrapped(*args, **kwargs)
+
+    if (
+        wrapped_render_async is not None
+        and not have_patched_template_render_async
+        and "jinja2.asyncsupport" in sys.modules
+    ):
+        try:
+            Template.render_async = wrapped_render_async(Template.render_async)
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument jinja2.Template.render_async: %r",
+                exc,
+                exc_info=exc,
+            )
+        else:
+            have_patched_template_render_async = True
+
+    return result

scout_apm/instruments/pymongo.py

@@ -0,0 +1,105 @@
+# coding=utf-8
+
+import logging
+
+import wrapt
+
+from scout_apm.core.tracked_request import TrackedRequest
+
+try:
+    import pymongo
+    from pymongo.collection import Collection
+except ImportError:
+    pymongo = None
+    Collection = None
+
+logger = logging.getLogger(__name__)
+
+have_patched_collection = False
+
+
+def ensure_installed():
+    global have_patched_collection
+
+    logger.debug("Instrumenting pymongo.")
+
+    if Collection is None:
+        logger.debug("Couldn't import pymongo.Collection - probably not installed.")
+    elif not have_patched_collection:
+        methods = COLLECTION_METHODS
+        if pymongo.version_tuple < (4, 0):
+            methods = COLLECTION_METHODS_V3
+        for name in methods:
+            try:
+                setattr(
+                    Collection, name, wrap_collection_method(getattr(Collection, name))
+                )
+            except Exception as exc:
+                logger.warning(
+                    "Failed to instrument pymongo.Collection.%s: %r",
+                    name,
+                    exc,
+                    exc_info=exc,
+                )
+        have_patched_collection = True
+
+
+COLLECTION_METHODS = [
+    "aggregate",
+    "aggregate_raw_batches",
+    "bulk_write",
+    "count_documents",
+    "create_index",
+    "create_indexes",
+    "delete_many",
+    "delete_one",
+    "distinct",
+    "drop",
+    "drop_index",
+    "drop_indexes",
+    "estimated_document_count",
+    "find",
+    "find_one",
+    "find_one_and_delete",
+    "find_one_and_replace",
+    "find_one_and_update",
+    "find_raw_batches",
+    "index_information",
+    "insert_many",
+    "insert_one",
+    "list_indexes",
+    "rename",
+    "replace_one",
+    "update_many",
+    "update_one",
+    "drop_search_index",
+    "create_search_indexes",
+    "create_search_index",
+    "list_search_indexes",
+    "update_search_index",
+]
+
+COLLECTION_METHODS_V3 = COLLECTION_METHODS + [
+    "count",
+    "ensure_index",
+    "find_and_modify",
+    "group",
+    "inline_map_reduce",
+    "insert",
+    "map_reduce",
+    "parallel_scan",
+    "reindex",
+    "remove",
+    "save",
+    "update",
+]
+
+
+@wrapt.decorator
+def wrap_collection_method(wrapped, instance, args, kwargs):
+    tracked_request = TrackedRequest.instance()
+    camel_name = "".join(c.title() for c in wrapped.__name__.split("_"))
+    operation = "MongoDB/{}.{}".format(instance.name, camel_name)
+    with tracked_request.span(operation=operation, ignore_children=True) as span:
+        span.tag("name", instance.name)
+        return wrapped(*args, **kwargs)

scout_apm/instruments/redis.py

@@ -0,0 +1,77 @@
+# coding=utf-8
+
+import logging
+
+import wrapt
+
+from scout_apm.core.tracked_request import TrackedRequest
+
+try:
+    import redis
+except ImportError:  # pragma: no cover
+    redis = None
+else:
+    if redis.VERSION[0] >= 3:
+        from redis import Redis
+        from redis.client import Pipeline
+    else:  # pragma: no cover
+        from redis import StrictRedis as Redis
+        from redis.client import BasePipeline as Pipeline
+
+logger = logging.getLogger(__name__)
+
+
+have_patched_redis_execute_command = False
+have_patched_pipeline_execute = False
+
+
+def ensure_installed():
+    global have_patched_redis_execute_command, have_patched_pipeline_execute
+
+    logger.debug("Instrumenting redis.")
+
+    if redis is None:
+        logger.debug("Couldn't import redis - probably not installed.")
+    else:
+        if not have_patched_redis_execute_command:
+            try:
+                Redis.execute_command = wrapped_execute_command(Redis.execute_command)
+            except Exception as exc:
+                logger.warning(
+                    "Failed to instrument redis.Redis.execute_command: %r",
+                    exc,
+                    exc_info=exc,
+                )
+            else:
+                have_patched_redis_execute_command = True
+
+        if not have_patched_pipeline_execute:
+            try:
+                Pipeline.execute = wrapped_execute(Pipeline.execute)
+            except Exception as exc:
+                logger.warning(
+                    "Failed to instrument redis.Pipeline.execute: %r", exc, exc_info=exc
+                )
+            else:
+                have_patched_pipeline_execute = True
+
+    return True
+
+
+@wrapt.decorator
+def wrapped_execute_command(wrapped, instance, args, kwargs):
+    try:
+        op = args[0]
+    except (IndexError, TypeError):
+        op = "Unknown"
+
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation="Redis/{}".format(op)):
+        return wrapped(*args, **kwargs)
+
+
+@wrapt.decorator
+def wrapped_execute(wrapped, instance, args, kwargs):
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation="Redis/MULTI"):
+        return wrapped(*args, **kwargs)

scout_apm/instruments/urllib3.py

@@ -0,0 +1,80 @@
+# coding=utf-8
+
+import logging
+
+import urllib3
+import wrapt
+
+from scout_apm.core.config import scout_config
+from scout_apm.core.tracked_request import TrackedRequest
+
+try:
+    from urllib3 import HTTPConnectionPool
+except ImportError:  # pragma: no cover
+    HTTPConnectionPool = None
+
+# Try except separately because _url_from_pool is explicitly imported for urllib3 >= 2.
+# HTTPConnectionPool is always required.
+try:
+    from urllib3.connectionpool import _url_from_pool
+except ImportError:  # pragma: no cover
+
+    def _url_from_pool(pool, path):
+        pass
+
+
+logger = logging.getLogger(__name__)
+
+have_patched_pool_urlopen = False
+
+
+def ensure_installed():
+    global have_patched_pool_urlopen
+
+    logger.debug("Instrumenting urllib3.")
+
+    if HTTPConnectionPool is None:
+        logger.debug(
+            "Couldn't import urllib3.HTTPConnectionPool - probably not installed."
+        )
+        return False
+    elif not have_patched_pool_urlopen:
+        try:
+            HTTPConnectionPool.urlopen = wrapped_urlopen(HTTPConnectionPool.urlopen)
+        except Exception as exc:
+            logger.warning(
+                "Failed to instrument for Urllib3 HTTPConnectionPool.urlopen: %r",
+                exc,
+                exc_info=exc,
+            )
+        else:
+            have_patched_pool_urlopen = True
+
+
+@wrapt.decorator
+def wrapped_urlopen(wrapped, instance, args, kwargs):
+    def _extract_method(method, *args, **kwargs):
+        return method
+
+    try:
+        method = _extract_method(*args, **kwargs)
+    except TypeError:
+        method = "Unknown"
+
+    try:
+        if int(urllib3.__version__.split(".")[0]) < 2:
+            url = str(instance._absolute_url("/"))
+        else:
+            url = str(_url_from_pool(instance, "/"))
+    except Exception:
+        logger.exception("Could not get URL for HTTPConnectionPool")
+        url = "Unknown"
+
+    # Don't instrument ErrorMonitor calls
+    if str(url).startswith(scout_config.value("errors_host")):
+        return wrapped(*args, **kwargs)
+
+    tracked_request = TrackedRequest.instance()
+    with tracked_request.span(operation="HTTP/{}".format(method)) as span:
+        span.tag("url", str(url))
+        return wrapped(*args, **kwargs)