tp-trace 0.2.0__tar.gz → 0.3.0__tar.gz

{tp_trace-0.2.0 → tp_trace-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: tp_trace
-Version: 0.2.0
+Version: 0.3.0
 Summary: tp_trace: High-performance Python Observability SDK for OpenTelemetry
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -38,7 +38,7 @@ The SDK exports OTLP traces to the team's telemetry endpoint. Tempo stores the t
 
 ## Start here
 
-- [Run the local development stack](dev/README.md)
+- [Run the local development stack](dev/README.md) (`make rebuild` for the first start, `make up` thereafter)
 - [Tutorial: see your first trace](docs/tutorials/first-trace.md)
 - [How-to: configure tp_trace](docs/how-to/configure-tp-trace.md)
 - [How-to: investigate a slow or failing request](docs/how-to/investigate-a-request.md)

{tp_trace-0.2.0 → tp_trace-0.3.0}/README.md

@@ -6,7 +6,7 @@ The SDK exports OTLP traces to the team's telemetry endpoint. Tempo stores the t
 
 ## Start here
 
-- [Run the local development stack](dev/README.md)
+- [Run the local development stack](dev/README.md) (`make rebuild` for the first start, `make up` thereafter)
 - [Tutorial: see your first trace](docs/tutorials/first-trace.md)
 - [How-to: configure tp_trace](docs/how-to/configure-tp-trace.md)
 - [How-to: investigate a slow or failing request](docs/how-to/investigate-a-request.md)

{tp_trace-0.2.0 → tp_trace-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tp_trace"
-version = "0.2.0"
+version = "0.3.0"
 description = "tp_trace: High-performance Python Observability SDK for OpenTelemetry"
 readme = "README.md"
 requires-python = ">=3.8"

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/__init__.py

@@ -202,7 +202,13 @@ def init(
 
         # Register RED metrics aggregator: computes 100% RED metrics for all dependencies
         try:
-            provider.add_span_processor(RedSpanProcessor())
+            provider.add_span_processor(
+                RedSpanProcessor(
+                    cardinality_limit_per_service=config.operation_cardinality_limit,
+                    route_limit=config.route_cardinality_limit,
+                    service_limit=config.service_cardinality_limit,
+                )
+            )
         except Exception as exc:
             logger.debug("tp_trace: Failed to register RedSpanProcessor: %s", exc)
 

tp_trace-0.3.0/src/tp_trace/compat/__init__.py

@@ -0,0 +1 @@
+"""Compatibility shims for OpenTelemetry internals."""

tp_trace-0.3.0/src/tp_trace/compat/attributes.py

@@ -0,0 +1,191 @@
+"""Compatibility layer for mutating span attributes across OTel SDK versions.
+
+OpenTelemetry Python SDK exposes no public API to mutate attributes on an ended
+ReadableSpan. tp_trace only does this as a last resort for third-party
+instrumentors that add attributes after our control points. All access to
+private internals goes through this module with version checks and a kill-switch.
+"""
+
+import logging
+import os
+from typing import Any, Dict, MutableMapping, Optional, Tuple
+
+logger = logging.getLogger("tp_trace.compat.attributes")
+
+try:
+    from importlib import metadata
+
+    _OTEL_SDK_VERSION = metadata.version("opentelemetry-sdk")
+except Exception:
+    _OTEL_SDK_VERSION = "unknown"
+
+
+def _parse_version(v: str) -> Optional[Tuple[int, int, int]]:
+    if not v or v == "unknown":
+        return None
+    # Strip common suffixes like b0, rc1
+    try:
+        # Take only digits and dots
+        parts = []
+        for token in v.replace("-", ".").replace("_", ".").split("."):
+            # Extract leading digits
+            num = ""
+            for ch in token:
+                if ch.isdigit():
+                    num += ch
+                else:
+                    break
+            if num:
+                parts.append(int(num))
+            if len(parts) >= 3:
+                break
+        if len(parts) >= 2:
+            while len(parts) < 3:
+                parts.append(0)
+            return (parts[0], parts[1], parts[2])
+    except Exception:
+        pass
+    return None
+
+
+_OTEL_SDK_VER_TUPLE = _parse_version(_OTEL_SDK_VERSION)
+
+_ATTR_MUTATION_DISABLED = os.environ.get("TP_TRACE_DISABLE_ATTR_MUTATION", "").strip().lower() in (
+    "1",
+    "true",
+    "yes",
+    "on",
+)
+_WARNED_DISABLED = False
+
+
+def _sdk_version_ok() -> bool:
+    global _WARNED_DISABLED
+    if _ATTR_MUTATION_DISABLED:
+        if not _WARNED_DISABLED:
+            logger.debug("tp_trace: attribute mutation disabled via TP_TRACE_DISABLE_ATTR_MUTATION")
+            _WARNED_DISABLED = True
+        return False
+    if _OTEL_SDK_VER_TUPLE is None:
+        if not _WARNED_DISABLED:
+            logger.debug("tp_trace: could not parse opentelemetry-sdk version; disabling ended-span attribute mutation")
+            _WARNED_DISABLED = True
+        return False
+    try:
+        major, minor, _ = _OTEL_SDK_VER_TUPLE
+        if (major, minor) < (1, 20):
+            if not _WARNED_DISABLED:
+                logger.debug("tp_trace: opentelemetry-sdk %s too old for ended-span mutation", _OTEL_SDK_VERSION)
+                _WARNED_DISABLED = True
+            return False
+        # Don't fail closed on newer versions - rely on structure checks
+        return True
+    except Exception:
+        if not _WARNED_DISABLED:
+            logger.debug("tp_trace: attribute mutation disabled due to version check failure")
+            _WARNED_DISABLED = True
+        return False
+
+
+def _is_recording_span(span: Any) -> bool:
+    try:
+        if hasattr(span, "is_recording") and span.is_recording():
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def _get_attrs_obj(span: Any) -> Any:
+    attrs = getattr(span, "_attributes", None)
+    if attrs is not None:
+        return attrs
+    attrs = getattr(span, "attributes", None)
+    return attrs
+
+
+def _find_mutable_dict(attrs_obj: Any) -> Optional[MutableMapping]:
+    if attrs_obj is None:
+        return None
+    if isinstance(attrs_obj, dict):
+        return attrs_obj
+    # Prefer known internal names for BoundedAttributes
+    for name in ("_dict",):
+        try:
+            cand = getattr(attrs_obj, name, None)
+            if isinstance(cand, dict):
+                return cand
+            if isinstance(cand, MutableMapping):
+                return cand
+        except Exception:
+            continue
+    return None
+
+
+def get_mutable_attributes(span: Any) -> Optional[MutableMapping]:
+    """Get a mutable attribute mapping if possible."""
+    if not _sdk_version_ok():
+        return None
+    attrs_obj = _get_attrs_obj(span)
+    target = _find_mutable_dict(attrs_obj)
+    if target is not None:
+        return target
+    return None
+
+
+def set_attribute_safe(span: Any, key: str, value: Any) -> bool:
+    # For recording spans, use public API. For ended spans, write via compat first.
+    try:
+        if _is_recording_span(span):
+            try:
+                if hasattr(span, "set_attribute"):
+                    span.set_attribute(key, value)
+                    return True
+            except Exception:
+                pass
+            return False
+    except Exception:
+        pass
+    target = get_mutable_attributes(span)
+    if target is not None:
+        try:
+            target[key] = value
+            return True
+        except Exception:
+            pass
+    return False
+
+
+def delete_attribute_safe(span: Any, key: str) -> bool:
+    target = get_mutable_attributes(span)
+    if target is None:
+        return False
+    try:
+        if key in target:
+            del target[key]
+            return True
+    except Exception:
+        pass
+    return False
+
+
+def get_attributes_view(span: Any) -> Dict[str, Any]:
+    try:
+        attrs = getattr(span, "attributes", None)
+        if attrs is not None:
+            try:
+                return dict(attrs)
+            except Exception:
+                pass
+    except Exception:
+        pass
+    try:
+        attrs_obj = _get_attrs_obj(span)
+        if attrs_obj is not None:
+            try:
+                return dict(attrs_obj)
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return {}

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/config.py

@@ -10,6 +10,10 @@ from tp_trace.version import __version__
 
 logger = logging.getLogger("tp_trace.config")
 
+DEFAULT_OPERATION_CARDINALITY_LIMIT = 1000
+DEFAULT_ROUTE_CARDINALITY_LIMIT = 5000
+DEFAULT_SERVICE_CARDINALITY_LIMIT = 16
+
 # Deprecated inputs that name the *project* after a *service*. Warned once each so
 # operators learn the canonical name without log spam.
 _warned_project_aliases: set = set()
@@ -262,6 +266,9 @@ class SDKConfig:
     query_mode: str = "expose"
     n_plus_one_duplicate_threshold: int = 15
     n_plus_one_max_fingerprints: int = 256
+    operation_cardinality_limit: int = DEFAULT_OPERATION_CARDINALITY_LIMIT
+    route_cardinality_limit: int = DEFAULT_ROUTE_CARDINALITY_LIMIT
+    service_cardinality_limit: int = DEFAULT_SERVICE_CARDINALITY_LIMIT
 
     @classmethod
     def from_env_and_kwargs(
@@ -295,6 +302,9 @@ class SDKConfig:
         query_mode: Optional[str] = None,
         n_plus_one_duplicate_threshold: Optional[int] = None,
         n_plus_one_max_fingerprints: Optional[int] = None,
+        operation_cardinality_limit: Optional[int] = None,
+        route_cardinality_limit: Optional[int] = None,
+        service_cardinality_limit: Optional[int] = None,
         **extra: Any,
     ) -> "SDKConfig":
         """Build SDKConfig by prioritizing explicit kwargs over environment variables."""
@@ -420,6 +430,24 @@ class SDKConfig:
         except Exception:
             resolved_metric_cardinality_limit = 5000
 
+        resolved_operation_cardinality_limit = _parse_positive_int_default(
+            operation_cardinality_limit if operation_cardinality_limit is not None else os.getenv("TP_TRACE_OPERATION_CARDINALITY_LIMIT"),
+            default=DEFAULT_OPERATION_CARDINALITY_LIMIT,
+            field_name="operation_cardinality_limit",
+        )
+
+        resolved_route_cardinality_limit = _parse_positive_int_default(
+            route_cardinality_limit if route_cardinality_limit is not None else os.getenv("TP_TRACE_ROUTE_CARDINALITY_LIMIT"),
+            default=DEFAULT_ROUTE_CARDINALITY_LIMIT,
+            field_name="route_cardinality_limit",
+        )
+
+        resolved_service_cardinality_limit = _parse_positive_int_default(
+            service_cardinality_limit if service_cardinality_limit is not None else os.getenv("TP_TRACE_SERVICE_CARDINALITY_LIMIT"),
+            default=DEFAULT_SERVICE_CARDINALITY_LIMIT,
+            field_name="service_cardinality_limit",
+        )
+
         resolved_service_instance_id = (
             service_instance_id
             or extra.get("service_instance_id")
@@ -752,6 +780,9 @@ class SDKConfig:
             metrics_enabled=resolved_metrics_enabled,
             metrics_export_interval_millis=resolved_metrics_interval,
             metric_cardinality_limit=resolved_metric_cardinality_limit,
+            operation_cardinality_limit=resolved_operation_cardinality_limit,
+            route_cardinality_limit=resolved_route_cardinality_limit,
+            service_cardinality_limit=resolved_service_cardinality_limit,
             service_instance_id=resolved_service_instance_id,
             redis_mask_endpoint=resolved_redis_mask_endpoint,
             redis_mask_command=resolved_redis_mask_command,

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/exporter.py

@@ -9,98 +9,14 @@ import time
 from typing import Any, Optional
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
+from tp_trace.normalize import normalize_span_attributes
+
 logger = logging.getLogger("tp_trace.exporter")
 
 
 def _ensure_normalized_attributes(span: Any) -> None:
     try:
-        attrs = getattr(span, "_attributes", None)
-        if attrs is None:
-            attrs = getattr(span, "attributes", None)
-        target_dict = getattr(attrs, "_dict", None)
-        if target_dict is None and hasattr(attrs, "__setitem__"):
-            target_dict = attrs
-
-        if target_dict is not None:
-            is_owned_celery = bool(
-                target_dict.get("tp_trace.celery.owned") or (attrs and attrs.get("tp_trace.celery.owned"))
-            )
-            if is_owned_celery:
-                for bad_key in (
-                    "http.method",
-                    "http.request.method",
-                    "http.route",
-                    "http.route_template",
-                    "django.route",
-                ):
-                    if bad_key in target_dict:
-                        try:
-                            del target_dict[bad_key]
-                        except Exception:
-                            pass
-                if not target_dict.get("normalized.service"):
-                    target_dict["normalized.service"] = "celery"
-                if not target_dict.get("normalized.operation"):
-                    from opentelemetry.trace import SpanKind
-
-                    action = "apply_async" if getattr(span, "kind", None) == SpanKind.PRODUCER else "run"
-                    target_dict["normalized.operation"] = f"celery.{action}.unknown"
-                return
-
-            if not target_dict.get("normalized.service"):
-                svc = (
-                    target_dict.get("peer.service")
-                    or target_dict.get("db.system")
-                    or target_dict.get("rpc.system")
-                    or target_dict.get("component")
-                )
-                if svc == "postgresql":
-                    svc = "postgres"
-                elif svc == "aws-api":
-                    svc = "aws-s3"
-                target_dict["normalized.service"] = str(svc or "django")
-
-            svc = target_dict.get("normalized.service")
-            if not target_dict.get("normalized.operation"):
-                op = None
-                if svc == "redis" or target_dict.get("db.system") == "redis":
-                    if "db.redis.pipeline_length" in target_dict:
-                        op = "redis.pipeline"
-                    elif target_dict.get("db.operation"):
-                        op = f"redis.{str(target_dict.get('db.operation')).lower()}"
-                    elif getattr(span, "name", ""):
-                        raw = (
-                            getattr(span, "name", "")
-                            .replace("🔸", "")
-                            .replace("REDIS:", "")
-                            .replace("redis:", "")
-                            .strip()
-                            .lower()
-                        )
-                        op = f"redis.{raw}" if raw else "redis.command"
-                    else:
-                        op = "redis.command"
-                elif svc in ("postgres", "pgbouncer") or target_dict.get("db.system") in ("postgres", "postgresql"):
-                    op = target_dict.get("db.statement") or "postgres.query"
-                elif svc == "django":
-                    route_val = target_dict.get("http.route_template") or target_dict.get("http.route")
-                    if target_dict.get("http.method") and route_val:
-                        op = f"{target_dict.get('http.method')} {route_val}"
-                    else:
-                        op = getattr(span, "name", "")
-                elif target_dict.get("rpc.service") and target_dict.get("rpc.method"):
-                    op = f"{target_dict.get('rpc.service')}.{target_dict.get('rpc.method')}"
-                elif target_dict.get("db.statement"):
-                    op = target_dict.get("db.statement")
-                elif target_dict.get("http.method") and (
-                    target_dict.get("http.route_template") or target_dict.get("http.route")
-                ):
-                    route_val = target_dict.get("http.route_template") or target_dict.get("http.route")
-                    op = f"{target_dict.get('http.method')} {route_val}"
-                else:
-                    op = getattr(span, "name", "")
-                if op:
-                    target_dict["normalized.operation"] = str(op)
+        normalize_span_attributes(span)
     except Exception:
         pass
 

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/integrations/django/cache.py

@@ -81,6 +81,8 @@ def make_traced_cache_op(op_name: str):
             key = kwargs["key"]
         elif "keys" in kwargs:
             key = kwargs["keys"]
+        elif op_name == "set_many":
+            key = kwargs.get("data")
 
         span_attrs = {
             "django.cache.operation": op_name,
@@ -146,7 +148,9 @@ def make_traced_cache_op(op_name: str):
 
         if key is not None:
             try:
-                if isinstance(key, (list, tuple, set)):
+                if isinstance(key, dict):
+                    span_attrs["django.cache.key"] = ", ".join(str(k) for k in key)
+                elif isinstance(key, (list, tuple, set)):
                     span_attrs["django.cache.key"] = ", ".join(str(k) for k in key)
                 else:
                     span_attrs["django.cache.key"] = str(key)

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/integrations/django/request.py

@@ -474,7 +474,11 @@ def _evaluate_repeated_queries(span, cfg, final_route, method, duration_ms):
             safe_set_attribute(span, "n_plus_one.severity", severity)
             safe_set_attribute(span, "n_plus_one.severity_reason", severity_reason)
             safe_set_attribute(span, "n_plus_one.tracker_overflowed", stats.tracker_overflowed)
-            if final_route and final_route != "__unmatched__" and not str(final_route).isdigit():
+            # The request-finalization hook can run more than once for a span when
+            # Django and the OTel middleware both finalize it. Keep the anomaly
+            # metric request-scoped even if evaluation is repeated.
+            already_recorded = bool(getattr(span, "_tp_trace_affected_metric_recorded", False))
+            if final_route and final_route != "__unmatched__" and not str(final_route).isdigit() and not already_recorded:
                 from tp_trace.metrics import record_repeated_query_affected_request
 
                 record_repeated_query_affected_request(
@@ -483,6 +487,10 @@ def _evaluate_repeated_queries(span, cfg, final_route, method, duration_ms):
                     service="django",
                     extra_attributes=get_current_tags(),
                 )
+                try:
+                    setattr(span, "_tp_trace_affected_metric_recorded", True)
+                except Exception:
+                    pass
     except Exception as n_plus_one_exc:
         logger.debug("Failed to evaluate/record repeated query anomaly: %s", n_plus_one_exc)
 
@@ -581,9 +589,26 @@ def _tp_trace_django_request_hook(span: Any, request: Any) -> None:
             safe_set_attribute(span, "http.user_agent", ua)
 
         if query_mode == "strip" or not url_query:
-            safe_set_attribute(span, "url.query", "")
-            if hasattr(span, "_attributes") and hasattr(span._attributes, "pop"):
-                span._attributes.pop("url.query", None)
+            try:
+                from tp_trace.compat.attributes import get_mutable_attributes
+
+                target = get_mutable_attributes(span)
+                if target is not None:
+                    try:
+                        target.pop("url.query", None)
+                    except Exception:
+                        try:
+                            del target["url.query"]
+                        except Exception:
+                            pass
+                elif hasattr(span, "is_recording") and span.is_recording():
+                    if hasattr(span, "set_attribute"):
+                        try:
+                            span.set_attribute("url.query", "")
+                        except Exception:
+                            pass
+            except Exception:
+                pass
         else:
             safe_set_attribute(span, "url.query", url_query)
 
@@ -630,6 +655,12 @@ def _tp_trace_django_request_hook(span: Any, request: Any) -> None:
         logger.debug("Error in django request hook", exc_info=True)
 
 
+def _request_method(request: Any) -> str:
+    """Normalize telemetry metadata without changing the request object."""
+    method = getattr(request, "method", "GET")
+    return method.upper() if isinstance(method, str) and method else "GET"
+
+
 def _tp_trace_django_response_hook(span: Any, request: Any, response: Any) -> None:
     """Official OTel DjangoInstrumentor response hook.
 
@@ -637,25 +668,27 @@ def _tp_trace_django_response_hook(span: Any, request: Any, response: Any) -> No
     (X-Trace-ID, X-Span-ID, traceparent), user attribution, repeated query
     anomaly detection, request metrics, and resets context tokens.
     """
-    ctx = getattr(request, "_tp_request_context", None)
-    tracker_token = ctx[0] if ctx else None
-    route_token = ctx[1] if ctx else None
-    view_token = ctx[2] if ctx else None
-    start_time = ctx[3] if ctx else None
-    preresolved_route = ctx[4] if ctx else None
-
+    tracker_token = route_token = view_token = None
     try:
+        ctx = getattr(request, "_tp_request_context", None)
+        tracker_token = ctx[0] if ctx else None
+        route_token = ctx[1] if ctx else None
+        view_token = ctx[2] if ctx else None
+        start_time = ctx[3] if ctx else None
+        preresolved_route = ctx[4] if ctx else None
+
         if span is None:
             return
 
         cfg = attempt(_get_config, default=None, _label="request_config")
-        method = getattr(request, "method", "GET").upper()
+        method = attempt(_request_method, request, default="GET", _label="request.method")
         path = getattr(request, "path", "/")
 
         duration_ms = ((time.monotonic() - start_time) * 1000.0) if start_time else 0.0
         safe_set_attribute(span, "http.request.duration_ms", duration_ms)
 
         status_code = attempt(getattr, response, "status_code", default=200, _label="response.status_code")
+        status_code = attempt(int, status_code, default=200, _label="response.status_code.int")
         error = status_code >= 500
 
         norm_route = attempt(_normalize_route, request, path, default="__unmatched__", _label="normalize_route")
@@ -697,9 +730,26 @@ def _tp_trace_django_response_hook(span: Any, request: Any, response: Any) -> No
         safe_set_attribute(span, "url.path", url_path)
         safe_set_attribute(span, "http.target", target_url)
         if query_mode == "strip" or not url_query:
-            safe_set_attribute(span, "url.query", "")
-            if hasattr(span, "_attributes") and hasattr(span._attributes, "pop"):
-                span._attributes.pop("url.query", None)
+            try:
+                from tp_trace.compat.attributes import get_mutable_attributes
+
+                target = get_mutable_attributes(span)
+                if target is not None:
+                    try:
+                        target.pop("url.query", None)
+                    except Exception:
+                        try:
+                            del target["url.query"]
+                        except Exception:
+                            pass
+                elif hasattr(span, "is_recording") and span.is_recording():
+                    if hasattr(span, "set_attribute"):
+                        try:
+                            span.set_attribute("url.query", "")
+                        except Exception:
+                            pass
+            except Exception:
+                pass
         else:
             safe_set_attribute(span, "url.query", url_query)
 
@@ -776,7 +826,16 @@ def _tp_trace_django_response_hook(span: Any, request: Any, response: Any) -> No
 
             attempt(_set_headers, _label="trace_headers")
 
-        _evaluate_repeated_queries(span, cfg, final_route, method, duration_ms)
+        # OTel/Django integrations may invoke the response hook twice for one
+        # request. Evaluate and emit request-scoped anomaly metrics once.
+        if not getattr(request, "_tp_trace_n_plus_one_evaluated", False):
+            try:
+                setattr(request, "_tp_trace_n_plus_one_evaluated", True)
+            except Exception:
+                pass
+            _evaluate_repeated_queries(span, cfg, final_route, method, duration_ms)
+    except Exception:
+        logger.debug("Error in django response hook", exc_info=True)
     finally:
         if span is not None:
             try:
@@ -786,14 +845,13 @@ def _tp_trace_django_response_hook(span: Any, request: Any, response: Any) -> No
             except Exception:
                 pass
         if tracker_token is not None:
-            reset_request_db_tracker(tracker_token)
+            attempt(reset_request_db_tracker, tracker_token, _label="reset_db_tracker")
         if view_token is not None:
-            reset_request_view(view_token)
+            attempt(reset_request_view, view_token, _label="reset_view")
         if route_token is not None:
-            reset_request_route(route_token)
-        reset_request_tags()
-        if hasattr(request, "_tp_request_context"):
-            try:
-                delattr(request, "_tp_request_context")
-            except Exception:
-                pass
+            attempt(reset_request_route, route_token, _label="reset_route")
+        attempt(reset_request_tags, _label="reset_tags")
+        try:
+            delattr(request, "_tp_request_context")
+        except Exception:
+            pass

{tp_trace-0.2.0 → tp_trace-0.3.0}/src/tp_trace/integrations/django/view.py

@@ -14,7 +14,7 @@ from tp_trace.safety import UNTRACED, attempt, safe_enrich, safe_set_attribute,
 from tp_trace.tracing import traced_span
 from tp_trace.config_access import get_config as _get_config, set_config as set_config
 
-from .request import _format_view_from_match, _normalize_route, _resolve_view_name
+from .request import _format_view_from_match, _normalize_route, _request_method, _resolve_view_name
 
 _in_view_dispatch: ContextVar[bool] = ContextVar("in_view_dispatch", default=False)
 
@@ -64,12 +64,12 @@ def traced_get_response(wrapped: Callable, instance: Any, args: Any, kwargs: Any
         tracer_name="tp_trace.django",
     ) as span:
         _apply_tags(span)
-        method = attempt(getattr, request, "method", default="GET", _label="request.method")
+        method = attempt(_request_method, request, default="GET", _label="request.method")
         pre_route = attempt(_normalize_route, request, initial_route, default=initial_route, _label="normalize_route")
         route_token = None
         if pre_route and pre_route != "__unmatched__":
             route_token = set_request_route(pre_route, method)
-        match = getattr(request, "resolver_match", None)
+        match = attempt(getattr, request, "resolver_match", default=None, _label="resolver_match")
         resolved_view = (
             attempt(_format_view_from_match, match, method, default=None, _label="view_format") if match else None
         )
@@ -165,7 +165,7 @@ def _build_dispatch_plan(instance: Any, wrapped: Callable, args: Any, kwargs: An
     )
 
     request = args[0] if args else kwargs.get("request")
-    method = attempt(getattr, request, "method", default="GET", _label="request.method")
+    method = attempt(_request_method, request, default="GET", _label="request.method")
     method = method.lower() if isinstance(method, str) else "get"
 
     dispatch_cls = attempt(
@@ -249,7 +249,7 @@ def traced_view_dispatch(wrapped: Callable, instance: Any, args: Any, kwargs: An
                         _label="normalize_route",
                     )
                     if norm_route and norm_route != "__unmatched__":
-                        req_method = attempt(getattr, request, "method", default="GET", _label="request.method")
+                        req_method = attempt(_request_method, request, default="GET", _label="request.method")
                         route_token = set_request_route(norm_route, req_method)
                         safe_set_attribute(dispatch_span, "http.route", norm_route)