ddtrace 4.14.2__tar.gz → 4.15.2__tar.gz

ddtrace-4.15.2/MANIFEST.in

@@ -0,0 +1,11 @@
+graft cmake
+graft ddtrace
+graft src
+
+recursive-exclude ddtrace *.manifest.yaml
+recursive-exclude * **/__pycache__/*
+prune .riot/
+prune benchmarks/
+prune releasenotes/
+prune src/native/target*
+prune src/native_heap_gotter/target*

ddtrace-4.15.2/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: ddtrace
+Version: 4.15.2
+Summary: Datadog APM client library
+Author-email: "Datadog, Inc." <dev@datadoghq.com>
+License: LICENSE.BSD3
+Project-URL: Bug Tracker, https://github.com/DataDog/dd-trace-py/issues
+Project-URL: Changelog, https://github.com/DataDog/dd-trace-py/releases
+Project-URL: Documentation, https://ddtrace.readthedocs.io/en/stable/
+Project-URL: Homepage, https://github.com/DataDog/dd-trace-py
+Project-URL: Source Code, https://github.com/DataDog/dd-trace-py/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE.Apache
+License-File: LICENSE.BSD3
+License-File: NOTICE
+Requires-Dist: bytecode<1,>=0.19.0; python_version >= "3.15.0"
+Requires-Dist: bytecode<1,>=0.17.0; python_version >= "3.14.0"
+Requires-Dist: bytecode<1,>=0.16.0; python_version >= "3.13.0"
+Requires-Dist: bytecode<1,>=0.15.1; python_version ~= "3.12.0"
+Requires-Dist: bytecode<1,>=0.14.0; python_version ~= "3.11.0"
+Requires-Dist: bytecode<1,>=0.13.0; python_version < "3.11"
+Requires-Dist: ddtrace-internal==0.1.0
+Requires-Dist: envier~=0.6.1
+Requires-Dist: opentelemetry-api<2,>=1
+Requires-Dist: wrapt!=2.2.0,<3,>=1
+Provides-Extra: opentracing
+Requires-Dist: opentracing<3,>=2; extra == "opentracing"
+Provides-Extra: opentelemetry
+Requires-Dist: opentelemetry-exporter-otlp<2,>=1; extra == "opentelemetry"
+Provides-Extra: openfeature
+Requires-Dist: openfeature-sdk<1,>=0.8; extra == "openfeature"
+Dynamic: license-file
+
+# `ddtrace`
+
+[![CircleCI](https://circleci.com/gh/DataDog/dd-trace-py/tree/main.svg?style=svg)](https://circleci.com/gh/DataDog/dd-trace-py/tree/main)
+[![PypiVersions](https://img.shields.io/pypi/v/ddtrace.svg)](https://pypi.org/project/ddtrace/)
+[![Pyversions](https://img.shields.io/pypi/pyversions/ddtrace.svg?style=flat)](https://pypi.org/project/ddtrace/)
+
+<img align="right" src="https://user-images.githubusercontent.com/6321485/167082083-53f6e48f-1843-4708-9b98-587c94f7ddb3.png" alt="bits python" width="200px"/>
+
+This library powers [Distributed Tracing](https://docs.datadoghq.com/tracing/),
+ [Continuous Profiling](https://docs.datadoghq.com/tracing/profiler/),
+ [Error Tracking](https://docs.datadoghq.com/tracing/error_tracking/),
+ [Test Optimization](https://docs.datadoghq.com/tests/),
+ [Deployment Tracking](https://docs.datadoghq.com/tracing/deployment_tracking/),
+ [Code Hotspots](https://docs.datadoghq.com/tracing/profiler/connect_traces_and_profiles/),
+ [Dynamic Instrumentation](https://docs.datadoghq.com/dynamic_instrumentation/),
+ and more.
+
+To get started with tracing, check out the [product documentation][setup docs] or the [glossary][visualization docs].
+
+For advanced usage and configuration information, check out the [library documentation][api docs].
+
+To get started as a contributor, see [the contributing docs](https://ddtrace.readthedocs.io/en/stable/contributing.html) first.
+
+For information about the bug/security fix and maintenance policy, see the [versioning docs][versioning docs].
+
+[setup docs]: https://docs.datadoghq.com/tracing/setup/python/
+[api docs]: https://ddtrace.readthedocs.io/
+[visualization docs]: https://docs.datadoghq.com/tracing/visualization/
+[versioning docs]: https://github.com/DataDog/dd-trace-py/blob/main/docs/versioning.rst#release-support

ddtrace-4.15.2/ddtrace/__init__.py

@@ -0,0 +1,57 @@
+import sys
+
+
+LOADED_MODULES = frozenset(sys.modules.keys())
+
+
+# Ensure we capture references to unpatched modules as early as possible
+import ddtrace.internal._unpatched  # noqa
+from ._logger import configure_ddtrace_logger  # noqa: E402
+
+# configure ddtrace logger before other modules log
+configure_ddtrace_logger()  # noqa: E402
+
+# Enable telemetry writer and excepthook as early as possible to ensure we capture any exceptions from initialization
+import ddtrace.internal.telemetry  # noqa: E402, F401
+
+from ._monkey import patch  # noqa: E402
+from ._monkey import patch_all  # noqa: E402
+from .internal.compat import PYTHON_VERSION_INFO  # noqa: E402
+from .internal.settings import env  # noqa: E402
+from .internal.settings._config import config  # noqa: E402
+from .internal.utils.deprecations import DDTraceDeprecationWarning  # noqa: E402
+from .internal.utils.deprecations import deprecate  # noqa: E402
+from .version import __version__  # noqa: E402
+
+
+# TODO: Deprecate accessing tracer from ddtrace.__init__ module in v4.0
+if env.get("_DD_GLOBAL_TRACER_INIT", "true").lower() in ("1", "true"):
+    from ddtrace.trace import tracer  # noqa: F401
+
+# Initialize DSM support and register DSM handlers (if enabled)
+import ddtrace.internal.datastreams as _  # noqa: E402, F401
+
+
+__all__ = [
+    "__version__",
+    "patch",
+    "patch_all",
+    "config",
+    "DDTraceDeprecationWarning",
+]
+
+
+def check_supported_python_version():
+    if PYTHON_VERSION_INFO < (3, 10):
+        deprecation_message = (
+            "Support for ddtrace with Python version %d.%d is deprecated and will be removed in 5.0.0."
+        )
+        if PYTHON_VERSION_INFO < (3, 9):
+            deprecation_message = "Support for ddtrace with Python version %d.%d was removed in 4.0.0."
+        deprecate(
+            (deprecation_message % (PYTHON_VERSION_INFO[0], PYTHON_VERSION_INFO[1])),
+            category=DDTraceDeprecationWarning,
+        )
+
+
+check_supported_python_version()

ddtrace-4.15.2/ddtrace/_monkey.py

@@ -0,0 +1,414 @@
+from collections.abc import Callable
+import importlib
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+from typing import Union
+
+from wrapt.importer import when_imported
+
+from ddtrace.internal.settings import env
+from ddtrace.internal.settings._config import config
+from ddtrace.internal.settings.integration import _integration_env_var_id
+from ddtrace.internal.telemetry.constants import TELEMETRY_NAMESPACE
+from ddtrace.internal.utils.deprecations import deprecate
+from ddtrace.vendor.packaging.specifiers import SpecifierSet
+from ddtrace.vendor.packaging.version import Version
+
+from .internal import telemetry
+from .internal.logger import get_logger
+from .internal.utils import formats
+from .internal.utils.deprecations import DDTraceDeprecationWarning  # noqa: E402
+
+
+log = get_logger(__name__)
+
+# Default set of modules to automatically patch or not
+PATCH_MODULES = {
+    "aiokafka": True,
+    "aiomysql": True,
+    "anyio": True,
+    "aredis": True,
+    "asyncio": True,
+    "avro": True,
+    "boto": True,
+    "botocore": True,
+    "bottle": True,
+    "celery": True,
+    "consul": True,
+    "ddtrace_api": True,
+    "django": True,
+    "dramatiq": True,
+    "elasticsearch": True,
+    "algoliasearch": True,
+    "futures": True,
+    "google_adk": True,
+    "google_cloud_pubsub": True,
+    "google_genai": True,
+    "gevent": True,
+    "graphql": True,
+    "grpc": True,
+    "httpx2": True,
+    "httpx": True,
+    "kafka": True,
+    "langgraph": True,
+    "llama_index": True,
+    "litellm": True,
+    "mysql": True,
+    "mysqldb": True,
+    "pymysql": True,
+    "mariadb": True,
+    "mcp": True,
+    "mistralai": True,
+    "psycopg": True,
+    "pylibmc": True,
+    "pymemcache": True,
+    "pymongo": True,
+    "redis": True,
+    "rediscluster": True,
+    "requests": True,
+    "rq": True,
+    "sanic": True,
+    "snowflake": False,
+    "sqlalchemy": False,  # Prefer DB client instrumentation
+    "sqlite3": True,
+    "aiohttp": True,  # requires asyncio (Python 3.4+)
+    "aiohttp_jinja2": True,
+    "aiopg": True,
+    "aiobotocore": False,
+    "httplib": False,
+    "urllib3": False,
+    "vertexai": True,
+    "vertica": True,
+    "molten": True,
+    "jinja2": True,
+    "mako": True,
+    "flask": True,
+    "kombu": False,
+    "starlette": True,
+    # Ignore some web framework integrations that might be configured explicitly in code
+    "falcon": True,
+    "pyramid": True,
+    "logbook": True,
+    "logging": True,
+    "loguru": True,
+    "structlog": True,
+    "pynamodb": True,
+    "pyodbc": True,
+    "fastapi": True,
+    "dogpile_cache": True,
+    "yaaredis": True,
+    "asyncpg": True,
+    "aws_durable_execution_sdk_python": True,
+    "aws_lambda": True,  # patch only in AWS Lambda environments
+    "azure_cosmos": True,
+    "azure_eventhubs": True,
+    "azure_functions": True,
+    "azure_durable_functions": True,
+    "azure_servicebus": True,
+    "tornado": False,
+    "openai": True,
+    "langchain": True,
+    "anthropic": True,
+    "crewai": True,
+    "pydantic_ai": True,
+    "pytorch": False,
+    "vllm": True,
+    "mlflow": config._model_lab_enabled,
+    "subprocess": True,
+    "unittest": True,
+    "coverage": False,
+    "selenium": True,
+    "valkey": True,
+    "openai_agents": True,
+    "ray": False,
+    "protobuf": config._data_streams_enabled,
+    "claude_agent_sdk": True,
+}
+
+# this information would make sense to live in the contrib modules,
+# but that would mean getting it would require importing those modules,
+# which we need to avoid until as late as possible.
+CONTRIB_DEPENDENCIES = {
+    "tornado": ("futures",),
+}
+
+_PATCHED_MODULES = set()
+
+# Module names that need to be patched for a given integration. If the module
+# name coincides with the integration name, then there is no need to add an
+# entry here.
+_MODULES_FOR_CONTRIB = {
+    "elasticsearch": (
+        "elasticsearch",
+        "elasticsearch1",
+        "elasticsearch2",
+        "elasticsearch5",
+        "elasticsearch6",
+        "elasticsearch7",
+        # Starting with version 8, the default transport which is what we
+        # actually patch is found in the separate elastic_transport package
+        "elastic_transport",
+        "opensearchpy",
+    ),
+    "psycopg": (
+        "psycopg",
+        "psycopg2",
+    ),
+    "snowflake": ("snowflake.connector",),
+    "dogpile_cache": ("dogpile.cache",),
+    "mysqldb": ("MySQLdb",),
+    "futures": ("concurrent.futures.thread",),
+    "vertica": ("vertica_python",),
+    "aws_lambda": ("datadog_lambda",),
+    "azure_cosmos": ("azure.cosmos",),
+    "azure_eventhubs": ("azure.eventhub",),
+    "azure_durable_functions": ("azure.durable_functions",),
+    "azure_functions": ("azure.functions",),
+    "azure_servicebus": ("azure.servicebus",),
+    "httplib": ("http.client",),
+    "kafka": ("confluent_kafka",),
+    "google_adk": ("google.adk",),
+    "google_cloud_pubsub": ("google.cloud.pubsub_v1",),
+    "google_genai": ("google.genai",),
+    "langchain": ("langchain_core",),
+    "llama_index": ("llama_index.core",),
+    "langgraph": (
+        "langgraph",
+        "langgraph.graph",
+        "langgraph.prebuilt",
+    ),
+    "mistralai": ("mistralai.client",),
+    "openai_agents": ("agents",),
+    "pytorch": ("torch",),
+}
+
+_NOT_PATCHABLE_VIA_ENVVAR = {"ddtrace_api"}
+
+
+class PatchException(Exception):
+    """Wraps regular `Exception` class when patching modules"""
+
+    pass
+
+
+class ModuleNotFoundException(PatchException):
+    pass
+
+
+class IncompatibleModuleException(PatchException):
+    def __init__(self, message: str, installed_version: Union[str, None] = None):
+        super().__init__(message)
+        self.installed_version = installed_version
+
+
+def is_version_compatible(version: str, supported_versions_spec: str) -> bool:
+    "Returns whether a given package version is compatible with the integration's supported version range."
+
+    if not supported_versions_spec:
+        return False
+
+    if supported_versions_spec == "*":
+        return True
+
+    try:
+        specifier_set = SpecifierSet(supported_versions_spec)
+        return Version(version) in specifier_set
+    except Exception:
+        return False
+
+
+def _get_installed_module_version(imported_module: ModuleType, hooked_module_name: str) -> Union[str, None]:
+    "Returns the installed version of a module."
+
+    if hasattr(imported_module, "get_versions"):
+        return imported_module.get_versions().get(hooked_module_name)
+    elif hasattr(imported_module, "get_version"):
+        return imported_module.get_version()
+    return None
+
+
+def _get_integration_supported_versions(
+    integration_patch_module: ModuleType, integration_name: str, hooked_module_name: str
+) -> Union[str, None]:
+    "Returns the supported version range for an integration."
+    if not hasattr(integration_patch_module, "_supported_versions"):
+        return None
+
+    supported_versions = integration_patch_module._supported_versions()
+    if hooked_module_name in supported_versions:
+        return supported_versions[hooked_module_name]
+    elif integration_name in supported_versions:
+        return supported_versions[integration_name]
+    return None
+
+
+def check_module_compatibility(
+    integration_patch_module: ModuleType, integration_name: str, hooked_module_name: str
+) -> None:
+    "Determines if a module should be patched based on installed version and the integration's supported version range."
+
+    # stdlib modules will not have an associated version and should always be patched
+    installed_version = _get_installed_module_version(integration_patch_module, hooked_module_name)
+    if not installed_version:
+        return
+
+    supported_version_spec = _get_integration_supported_versions(
+        integration_patch_module, integration_name, hooked_module_name
+    )
+    if not supported_version_spec:
+        # TODO: once all integrations have a supported version spec, we should raise an error here
+        return
+
+    if not is_version_compatible(installed_version, supported_version_spec):
+        message = (
+            f"Skipped patching '{integration_name}' integration, installed version: {installed_version} "
+            f"is not compatible with integration support spec: {supported_version_spec}."
+        )
+        raise IncompatibleModuleException(message, installed_version=installed_version)
+    return
+
+
+def _on_import_factory(
+    module: str, path_f: str, raise_errors: bool = True, patch_indicator: Union[bool, list[str]] = True
+) -> Callable[[Any], None]:
+    """Factory to create an import hook for the provided module name"""
+
+    def on_import(hook):
+        # Import and patch module
+        try:
+            imported_module = importlib.import_module(path_f % (module,))
+
+            # if safe instrumentation is enabled, we check if the module's version
+            # is compatible with the integration's supported version range, and throw an error if it is not
+            if config._trace_safe_instrumentation_enabled:
+                check_module_compatibility(imported_module, module, hook.__name__)
+
+            imported_module.patch()
+            if hasattr(imported_module, "patch_submodules"):
+                imported_module.patch_submodules(patch_indicator)
+
+        except IncompatibleModuleException as e:
+            log.error(
+                "failed to enable ddtrace support for %s: %s",
+                module,
+                str(e),
+                extra={"send_to_telemetry": False},
+            )
+            telemetry.telemetry_writer.add_integration(
+                module, False, PATCH_MODULES.get(module) is True, str(e), version=e.installed_version
+            )
+        except Exception as e:
+            if raise_errors:
+                raise
+            log.error(
+                "failed to enable ddtrace support for %s: %s",
+                module,
+                str(e),
+                exc_info=True,
+                extra={"send_to_telemetry": False},
+            )
+            telemetry.telemetry_writer.add_integration(module, False, PATCH_MODULES.get(module) is True, str(e))
+            telemetry.telemetry_writer.add_count_metric(
+                TELEMETRY_NAMESPACE.TRACERS,
+                "integration_errors",
+                1,
+                (("integration_name", module), ("error_type", type(e).__name__)),
+            )
+        else:
+            if hasattr(imported_module, "get_versions"):
+                versions = imported_module.get_versions()
+                for name, v in versions.items():
+                    telemetry.telemetry_writer.add_integration(
+                        name, True, PATCH_MODULES.get(module) is True, "", version=v
+                    )
+            elif hasattr(imported_module, "get_version"):
+                # Some integrations/iast patchers do not define get_version
+                version = imported_module.get_version()
+                telemetry.telemetry_writer.add_integration(
+                    module, True, PATCH_MODULES.get(module) is True, "", version=version
+                )
+
+    return on_import
+
+
+def patch_all(**patch_modules: bool) -> None:
+    """Enables ddtrace library instrumentation.
+
+    In addition to ``patch_modules``, an override can be specified via an
+    environment variable, ``DD_TRACE_<module>_ENABLED`` for each module.
+
+    ``patch_modules`` have the highest precedence for overriding.
+
+    :param dict patch_modules: Override whether particular modules are patched or not.
+
+        >>> _patch_all(redis=False)
+    """
+    deprecate(
+        "patch_all is deprecated and will be removed in a future version of the tracer.",
+        message="""patch_all is deprecated in favor of ``import ddtrace.auto`` and ``DD_PATCH_MODULES``
+        environment variable if needed.""",
+        category=DDTraceDeprecationWarning,
+    )
+    _patch_all(**patch_modules)
+
+
+def _patch_all(**patch_modules: bool) -> None:
+    modules = PATCH_MODULES.copy()
+
+    # The enabled setting can be overridden by environment variables
+    for module, _enabled in modules.items():
+        env_var = "DD_TRACE_%s_ENABLED" % _integration_env_var_id(module)
+        if module not in _NOT_PATCHABLE_VIA_ENVVAR and env_var in env:
+            modules[module] = formats.asbool(env[env_var])
+
+        # Enable all dependencies for the module
+        if modules[module]:
+            for dep in CONTRIB_DEPENDENCIES.get(module, ()):
+                modules[dep] = True
+
+    # Arguments take precedence over the environment and the defaults.
+    modules.update(patch_modules)
+
+    patch(raise_errors=False, **modules)
+
+
+def patch(raise_errors: bool = True, **patch_modules: Union[list[str], bool]) -> None:
+    """Patch only a set of given modules.
+
+    :param bool raise_errors: Raise error if one patch fail.
+    :param dict patch_modules: List of modules to patch.
+
+        >>> patch(psycopg=True, elasticsearch=True)
+    """
+    contribs = {c: patch_indicator for c, patch_indicator in patch_modules.items() if patch_indicator}
+    for contrib, patch_indicator in contribs.items():
+        # Check if we have the requested contrib.
+        base_path = Path(__file__).parent / "contrib" / "internal" / contrib
+        if raise_errors and not (base_path / "patch.py").exists() and not (base_path / "patch.pyc").exists():
+            raise ModuleNotFoundException(f"{contrib} does not have automatic instrumentation")
+        modules_to_patch = _MODULES_FOR_CONTRIB.get(contrib, (contrib,))
+        for module in modules_to_patch:
+            # Use factory to create handler to close over `module` and `raise_errors` values from this loop
+            when_imported(module)(
+                _on_import_factory(
+                    contrib,
+                    "ddtrace.contrib.internal.%s.patch",
+                    raise_errors=raise_errors,
+                    patch_indicator=patch_indicator,
+                )
+            )
+
+        # manually add module to patched modules
+        _PATCHED_MODULES.add(contrib)
+
+    log.info(
+        "Configured ddtrace instrumentation for %s integration(s). The following modules have been patched: %s",
+        len(contribs),
+        ",".join(contribs),
+    )
+
+
+def _get_patched_modules() -> set[str]:
+    """Get the list of patched modules"""
+    return _PATCHED_MODULES

ddtrace-4.15.2/ddtrace/_trace/context.py

@@ -0,0 +1,4 @@
+from ddtrace.internal.native._native import Context
+
+
+__all__ = ["Context"]