brute force migration to core api

chojomok · chojomok · commit 0fc505f8a632 · 2025-12-12T16:27:00.000-05:00
diff --git a/ddtrace/_trace/trace_handlers.py b/ddtrace/_trace/trace_handlers.py
@@ -595,6 +595,87 @@ def _on_django_cache(
         _finish_span(ctx, exc_info)
 
 
+def _on_requests_send_start(ctx: core.ExecutionContext) -> None:
+    span = _start_span(ctx)
+    if not span:
+        return
+
+    integration_config = ctx.get_item("integration_config")
+    hostname = ctx.get_item("hostname")
+
+    # integration_config can be either a dict (from pin._config) or ConfigNamespace (from config.requests)
+    split_by_domain = (
+        integration_config.get("split_by_domain")
+        if isinstance(integration_config, dict)
+        else integration_config.split_by_domain
+    )
+    distributed_tracing = (
+        integration_config.get("distributed_tracing", True)
+        if isinstance(integration_config, dict)
+        else integration_config.distributed_tracing
+    )
+
+    if split_by_domain and hostname:
+        span.service = hostname
+
+    if distributed_tracing:
+        request = ctx.get_item("request")
+        HTTPPropagator.inject(span.context, request.headers)
+
+
+def _on_requests_send_end(
+    ctx: core.ExecutionContext,
+    exc_info: Tuple[Optional[type], Optional[BaseException], Optional[TracebackType]],
+) -> None:
+    span = ctx.span
+    if not span:
+        _finish_span(ctx, exc_info)
+        return
+
+    (
+        request,
+        request_method,
+        request_url,
+        host_without_port,
+        response,
+    ) = ctx.get_items(["request", "request_method", "request_url", "host_without_port", "response"])
+
+    def _extract_query_string(uri):
+        start = uri.find("?") + 1
+        if start == 0:
+            return None
+        end = len(uri)
+        j = uri.rfind("#", 0, end)
+        if j != -1:
+            end = j
+        if end <= start:
+            return None
+        return uri[start:end]
+
+    status_code = None
+    response_headers = {}
+    if response is not None:
+        status_code = response.status_code
+        response_headers = dict(getattr(response, "headers", {}))
+
+    if request is not None:
+        # For set_http_meta, we need the global config.requests which has all the HTTP tagging settings
+        # The pin's integration_config dict may not have all attributes
+        trace_utils.set_http_meta(
+            span,
+            config.requests,
+            request_headers=request.headers,
+            response_headers=response_headers,
+            method=request_method,
+            url=request_url,
+            target_host=host_without_port,
+            status_code=status_code,
+            query=_extract_query_string(request_url) if request_url else None,
+        )
+
+    _finish_span(ctx, exc_info)
+
+
 def _on_django_func_wrapped(_unused1, _unused2, _unused3, ctx, ignored_excs):
     if ignored_excs:
         for exc in ignored_excs:
@@ -1524,5 +1605,9 @@ def listen():
     # Special/extra handling before calling _finish_span
     core.on("context.ended.django.cache", _on_django_cache)
 
+    # Requests handlers (also registered conditionally in patch.py)
+    core.on("context.started.requests.send", _on_requests_send_start)
+    core.on("context.ended.requests.send", _on_requests_send_end)
+
 
 listen()
diff --git a/ddtrace/contrib/internal/requests/connection.py b/ddtrace/contrib/internal/requests/connection.py
@@ -5,24 +5,20 @@
 
 import requests
 
-import ddtrace
 from ddtrace import config
-from ddtrace._trace.pin import Pin
-from ddtrace.constants import _SPAN_MEASURED_KEY
 from ddtrace.constants import SPAN_KIND
 from ddtrace.contrib import trace_utils
 from ddtrace.contrib.internal.trace_utils import _sanitized_url
 from ddtrace.ext import SpanKind
 from ddtrace.ext import SpanTypes
+from ddtrace.internal import core
 from ddtrace.internal.constants import COMPONENT
 from ddtrace.internal.constants import USER_AGENT_HEADER
 from ddtrace.internal.logger import get_logger
 from ddtrace.internal.opentelemetry.constants import OTLP_EXPORTER_HEADER_IDENTIFIER
 from ddtrace.internal.schema import schematize_url_operation
 from ddtrace.internal.schema.span_attribute_schema import SpanDirection
-from ddtrace.internal.settings.asm import config as asm_config
 from ddtrace.internal.utils import get_argument_value
-from ddtrace.propagation.http import HTTPPropagator
 
 
 log = get_logger(__name__)
@@ -69,18 +65,9 @@ def _extract_query_string(uri):
     return uri[start:end]
 
 
-def _wrap_send(func, instance, args, kwargs):
+@trace_utils.with_traced_module
+def _wrap_send(_requests_mod, pin, func, instance, args, kwargs):
     """Trace the `Session.send` instance method"""
-    # TODO[manu]: we already offer a way to provide the Global Tracer
-    # and is ddtrace.tracer; it's used only inside our tests and can
-    # be easily changed by providing a TracingTestCase that sets common
-    # tracing functionalities.
-    tracer = getattr(instance, "datadog_tracer", ddtrace.tracer)
-
-    # skip if tracing is not enabled
-    if not tracer.enabled and not asm_config._apm_opt_out:
-        return func(*args, **kwargs)
-
     request = get_argument_value(args, kwargs, 0, "request")
     if not request or is_otlp_export(request):
         return func(*args, **kwargs)
@@ -92,59 +79,55 @@ def _wrap_send(func, instance, args, kwargs):
     hostname, path = _extract_hostname_and_path(url)
     host_without_port = hostname.split(":")[0] if hostname is not None else None
 
-    cfg: Dict[str, Any] = {}
-    pin = Pin.get_from(instance)
-    if pin:
-        cfg = pin._config
+    parsed_uri = parse.urlparse(url)
 
-    service = None
-    if cfg["split_by_domain"] and hostname:
-        service = hostname
-    if service is None:
-        service = cfg.get("service", None)
-    if service is None:
-        service = cfg.get("service_name", None)
-    if service is None:
-        service = trace_utils.ext_service(None, config.requests)
+    # Support legacy datadog_tracer attribute for backwards compatibility (used in tests)
+    # If not set, use ddtrace.tracer to respect override_global_tracer
+    tracer = getattr(instance, "datadog_tracer", None)
+    if tracer is None:
+        import ddtrace
 
-    operation_name = schematize_url_operation("requests.request", protocol="http", direction=SpanDirection.OUTBOUND)
-    with tracer.trace(operation_name, service=service, resource=f"{method} {path}", span_type=SpanTypes.HTTP) as span:
-        span._set_tag_str(COMPONENT, config.requests.integration_name)
+        tracer = ddtrace.tracer
 
-        # set span.kind to the type of operation being performed
-        span._set_tag_str(SPAN_KIND, SpanKind.CLIENT)
+    # Check if tracing is disabled on the tracer (for APM opt-out tests)
+    from ddtrace.internal.settings.asm import config as asm_config
 
-        # PERF: avoid setting via Span.set_tag
-        span.set_metric(_SPAN_MEASURED_KEY, 1)
+    if not tracer.enabled and not asm_config._apm_opt_out:
+        return func(*args, **kwargs)
 
-        # propagate distributed tracing headers
-        if cfg.get("distributed_tracing"):
-            HTTPPropagator.inject(span.context, request.headers)
+    # Use pin's config if available, otherwise fall back to global config
+    integration_config = pin._config if pin else config.requests
 
-        response = response_headers = None
+    # Determine service name (check pin config for "service" or "service_name")
+    service = None
+    if integration_config and isinstance(integration_config, dict):
+        service = integration_config.get("service") or integration_config.get("service_name")
+    if service is None:
+        service = trace_utils.ext_service(pin, config.requests)
+
+    with core.context_with_data(
+        "requests.send",
+        span_name=schematize_url_operation("requests.request", protocol="http", direction=SpanDirection.OUTBOUND),
+        pin=pin,
+        tracer=tracer,
+        service=service,
+        resource=f"{method} {path}",
+        span_type=SpanTypes.HTTP,
+        integration_config=integration_config,
+        measured=True,
+        tags={COMPONENT: config.requests.integration_name, SPAN_KIND: SpanKind.CLIENT},
+        request=request,
+        request_url=url,
+        request_method=method,
+        request_headers=request.headers,
+        hostname=hostname,
+        path=path,
+        host_without_port=host_without_port,
+        parsed_uri=parsed_uri,
+    ) as ctx:
+        response = None
         try:
             response = func(*args, **kwargs)
             return response
         finally:
-            try:
-                status = None
-                if response is not None:
-                    status = response.status_code
-                    # Storing response headers in the span.
-                    # Note that response.headers is not a dict, but an iterable
-                    # requests custom structure, that we convert to a dict
-                    response_headers = dict(getattr(response, "headers", {}))
-
-                trace_utils.set_http_meta(
-                    span,
-                    config.requests,
-                    request_headers=request.headers,
-                    response_headers=response_headers,
-                    method=method,
-                    url=request.url,
-                    target_host=host_without_port,
-                    status_code=status,
-                    query=_extract_query_string(url),
-                )
-            except Exception:
-                log.debug("requests: error adding tags", exc_info=True)
+            ctx.set_item("response", response)
diff --git a/ddtrace/contrib/internal/requests/patch.py b/ddtrace/contrib/internal/requests/patch.py
@@ -19,6 +19,7 @@
 config._add(
     "requests",
     {
+        "tracing_enabled": asbool(os.getenv("DD_TRACE_REQUESTS_ENABLED", True)),
         "distributed_tracing": asbool(os.getenv("DD_REQUESTS_DISTRIBUTED_TRACING", default=True)),
         "split_by_domain": asbool(os.getenv("DD_REQUESTS_SPLIT_BY_DOMAIN", default=False)),
         "default_http_tag_query_string": config._http_client_tag_query_string,
@@ -27,7 +28,7 @@
 )
 
 # always patch our `TracedSession` when imported
-_w(TracedSession, "send", _wrap_send)
+_w(TracedSession, "send", _wrap_send(requests))
 Pin(_config=config.requests).onto(TracedSession)
 
 
@@ -45,7 +46,7 @@ def patch():
         return
     requests.__datadog_patch = True
 
-    _w("requests", "Session.send", _wrap_send)
+    _w("requests", "Session.send", _wrap_send(requests))
     # IAST needs to wrap this function because `Session.send` is too late
     if asm_config._load_modules:
         from ddtrace.appsec._common_module_patches import wrapped_request_D8CB81E472AF98A2 as _wrap_request
