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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: tp_trace
-Version: 0.1.6
+Version: 0.2.0
 Summary: tp_trace: High-performance Python Observability SDK for OpenTelemetry
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
@@ -12,9 +12,12 @@ Requires-Dist: opentelemetry-instrumentation-psycopg2>=0.44b0
 Requires-Dist: opentelemetry-instrumentation-redis>=0.44b0
 Requires-Dist: opentelemetry-instrumentation-botocore>=0.44b0
 Requires-Dist: opentelemetry-instrumentation-celery>=0.54b1
+Requires-Dist: opentelemetry-instrumentation-django>=0.44b0
 Requires-Dist: wrapt>=1.14.0
+Requires-Dist: urllib3<2,>=1.26.0; python_version < "3.9"
 Provides-Extra: django
 Requires-Dist: django>=4.2; extra == "django"
+Requires-Dist: opentelemetry-instrumentation-django>=0.44b0; extra == "django"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: botocore>=1.37.38; extra == "dev"

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tp_trace"
-version = "0.1.6"
+version = "0.2.0"
 description = "tp_trace: High-performance Python Observability SDK for OpenTelemetry"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -17,12 +17,15 @@ dependencies = [
     "opentelemetry-instrumentation-redis>=0.44b0",
     "opentelemetry-instrumentation-botocore>=0.44b0",
     "opentelemetry-instrumentation-celery>=0.54b1",
+    "opentelemetry-instrumentation-django>=0.44b0",
     "wrapt>=1.14.0",
+    "urllib3>=1.26.0,<2; python_version < '3.9'",
 ]
 
 [project.optional-dependencies]
 django = [
     "django>=4.2",
+    "opentelemetry-instrumentation-django>=0.44b0",
 ]
 dev = [
     "pytest>=7.0.0",

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

@@ -18,11 +18,11 @@ from opentelemetry.sdk.trace.sampling import ALWAYS_OFF, Sampler
 from opentelemetry.trace import get_current_span, get_tracer
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 from opentelemetry.baggage.propagation import W3CBaggagePropagator
-from opentelemetry.propagators.composite import CompositePropagator
 from opentelemetry.propagate import set_global_textmap
 
 from tp_trace.config import SDKConfig
 from tp_trace.exporter import SafeSpanExporter
+from tp_trace.red import RedSpanProcessor, SampledOnlySpanProcessor
 from tp_trace.route_context import RouteEnrichingSpanProcessor
 from tp_trace.integrations import BaseIntegration, get_integration_manager
 from tp_trace.sanitize import sanitize_query_string, sanitize_sql, sanitize_url
@@ -42,6 +42,8 @@ __all__ = [
     "BaseIntegration",
     "get_integration_manager",
     "RouteEnrichingSpanProcessor",
+    "RedSpanProcessor",
+    "SampledOnlySpanProcessor",
     "SafeSpanExporter",
 ]
 
@@ -198,6 +200,12 @@ def init(
         except Exception as exc:
             logger.debug("tp_trace: Failed to register RouteEnrichingSpanProcessor: %s", exc)
 
+        # Register RED metrics aggregator: computes 100% RED metrics for all dependencies
+        try:
+            provider.add_span_processor(RedSpanProcessor())
+        except Exception as exc:
+            logger.debug("tp_trace: Failed to register RedSpanProcessor: %s", exc)
+
         # Configure Exporter and Processor if not disabled
         if not config.disabled:
             if exporter is None:
@@ -234,18 +242,21 @@ def init(
                     else:
                         span_processor = SimpleSpanProcessor(safe_exporter)
 
-                provider.add_span_processor(span_processor)
+                # Gate exports: only spans with trace_flags.sampled=True are serialized/transmitted
+                provider.add_span_processor(SampledOnlySpanProcessor(span_processor))
 
         # Set as global tracer provider
         trace.set_tracer_provider(provider)
         _ACTIVE_PROVIDER = provider
         _INITIALIZED = True
 
-        # Setup W3C Trace Context and Baggage composite propagator
+        # Setup W3C Trace Context and Baggage composite propagator wrapped with TpTrace filtering
+        from tp_trace.propagator import TpTraceFilteringPropagator
+
         try:
-            set_global_textmap(CompositePropagator([TraceContextTextMapPropagator(), W3CBaggagePropagator()]))
+            set_global_textmap(TpTraceFilteringPropagator([TraceContextTextMapPropagator(), W3CBaggagePropagator()]))
         except Exception:
-            set_global_textmap(TraceContextTextMapPropagator())
+            set_global_textmap(TpTraceFilteringPropagator([TraceContextTextMapPropagator()]))
 
         # Auto-patch installed integrations if requested
         if config.auto_patch and not config.disabled:
@@ -335,8 +346,11 @@ def _reset_for_testing() -> None:
             except Exception:
                 pass
         try:
-            from tp_trace.metrics import set_metrics_recorder
+            from tp_trace.metrics import get_metrics_recorder, set_metrics_recorder
 
+            rec = get_metrics_recorder()
+            if rec is not None:
+                rec.shutdown()
             set_metrics_recorder(None)
         except Exception:
             pass
@@ -366,9 +380,28 @@ def set_attribute(key: str, value: Any) -> None:
     set_tag(key, value)
 
 
+def set_view(view_name: Optional[str]) -> Optional[Any]:
+    """Set the active view name on the in-flight context and propagate to child spans / Celery tasks.
+
+    Returns a token that can be passed to reset_view if manual scope management is needed.
+    """
+    from tp_trace.route_context import set_request_view
+
+    return set_request_view(view_name)
+
+
+def reset_view(token: Optional[Any] = None) -> None:
+    """Reset the active view name on the in-flight context."""
+    from tp_trace.route_context import reset_request_view
+
+    reset_request_view(token)
+
+
 __all__ = [
     "set_tag",
     "set_attribute",
+    "set_view",
+    "reset_view",
     "init",
     "patch_all",
     "get_config",

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

@@ -76,6 +76,38 @@ def _parse_cmd_max_length(val: Any) -> int:
     return n
 
 
+def _parse_positive_int_default(val: Any, default: int, min_val: int = 1, field_name: str = "") -> int:
+    """Non-throwing positive integer parser.
+
+    Catches type, format, and range errors, emits debug log, and returns default.
+    """
+    if val is None:
+        return default
+    try:
+        n = int(val)
+        if n >= min_val:
+            return n
+        logger.debug("tp_trace: %s=%r below minimum %d, falling back to %d", field_name, val, min_val, default)
+        return default
+    except (TypeError, ValueError) as exc:
+        logger.debug("tp_trace: %s=%r invalid integer (%s), falling back to %d", field_name, val, exc, default)
+        return default
+
+
+def _parse_nonnegative_float_default(val: Any, default: float, field_name: str = "") -> float:
+    """Parse a finite non-negative float, falling back safely on invalid input."""
+    if val is None:
+        return default
+    try:
+        number = float(val)
+        if math.isfinite(number) and number >= 0:
+            return number
+    except (TypeError, ValueError):
+        pass
+    logger.debug("tp_trace: %s=%r invalid duration, falling back to %s", field_name, val, default)
+    return default
+
+
 def _parse_endpoint_sample_rules(val: Any) -> Dict[str, float]:
     """Parse and validate endpoint-specific sampling rules.
 
@@ -214,10 +246,13 @@ class SDKConfig:
     trusted_proxies: List[str] = field(default_factory=list)
     db_role_map: Dict[str, str] = field(default_factory=dict)
     auto_patch: bool = True
+    # Governs incoming HTTP request propagation (e.g. Django). Internal messaging (Celery) always extracts.
     extract_trace_context: Any = True
     metrics_endpoint: Optional[str] = None
     metrics_enabled: bool = True
     metrics_export_interval_millis: int = 60000
+    metric_cardinality_limit: int = 5000
+    service_instance_id: Optional[str] = None
     # Masking -> exposure toggles. Defaults expose infrastructure details
     # (Redis endpoint, Redis command contents, URL query strings), matching
     # dd-trace. Deployments that do NOT own the infra can restore masking.
@@ -225,6 +260,8 @@ class SDKConfig:
     redis_mask_command: bool = False
     redis_cmd_max_length: int = 1000
     query_mode: str = "expose"
+    n_plus_one_duplicate_threshold: int = 15
+    n_plus_one_max_fingerprints: int = 256
 
     @classmethod
     def from_env_and_kwargs(
@@ -250,10 +287,14 @@ class SDKConfig:
         metrics_endpoint: Optional[str] = None,
         metrics_enabled: Optional[bool] = None,
         metrics_export_interval_millis: Optional[int] = None,
+        metric_cardinality_limit: Optional[int] = None,
+        service_instance_id: Optional[str] = None,
         redis_mask_endpoint: Optional[bool] = None,
         redis_mask_command: Optional[bool] = None,
         redis_cmd_max_length: Optional[int] = None,
         query_mode: Optional[str] = None,
+        n_plus_one_duplicate_threshold: Optional[int] = None,
+        n_plus_one_max_fingerprints: Optional[int] = None,
         **extra: Any,
     ) -> "SDKConfig":
         """Build SDKConfig by prioritizing explicit kwargs over environment variables."""
@@ -368,6 +409,25 @@ class SDKConfig:
         except Exception:
             resolved_metrics_interval = 60000
 
+        try:
+            raw_cardinality_limit = (
+                metric_cardinality_limit
+                if metric_cardinality_limit is not None
+                else extra.get("metric_cardinality_limit")
+                or os.getenv("TP_TRACE_METRIC_CARDINALITY_LIMIT")
+            )
+            resolved_metric_cardinality_limit = max(1, int(raw_cardinality_limit)) if raw_cardinality_limit is not None else 5000
+        except Exception:
+            resolved_metric_cardinality_limit = 5000
+
+        resolved_service_instance_id = (
+            service_instance_id
+            or extra.get("service_instance_id")
+            or os.getenv("TP_TRACE_SERVICE_INSTANCE_ID")
+            or os.getenv("OTEL_SERVICE_INSTANCE_ID")
+            or None
+        )
+
         env_headers = _parse_headers(os.getenv("TP_TRACE_HEADERS") or os.getenv("OTEL_EXPORTER_OTLP_HEADERS"))
         merged_headers = dict(env_headers)
         if headers:
@@ -484,6 +544,13 @@ class SDKConfig:
             "AUTO_PATCH",
             "extract_trace_context",
             "EXTRACT_TRACE_CONTEXT",
+            "n_plus_one_duplicate_threshold",
+            "N_PLUS_ONE_DUPLICATE_THRESHOLD",
+            # Deprecated timing knobs are ignored rather than becoming resource tags.
+            "n_plus_one_min_cumulative_duration_ms",
+            "N_PLUS_ONE_MIN_CUMULATIVE_DURATION_MS",
+            "n_plus_one_max_fingerprints",
+            "N_PLUS_ONE_MAX_FINGERPRINTS",
         }
         for k, v in extra.items():
             if k not in KNOWN_EXTRA_KEYS and not k.startswith("_"):
@@ -633,6 +700,29 @@ class SDKConfig:
         raw_query_mode = query_mode if query_mode is not None else os.getenv("TP_TRACE_QUERY_MODE")
         resolved_query_mode = _parse_query_mode(raw_query_mode)
 
+        raw_n_plus_one_dup = (
+            n_plus_one_duplicate_threshold
+            if n_plus_one_duplicate_threshold is not None
+            else extra.get("n_plus_one_duplicate_threshold")
+            if extra.get("n_plus_one_duplicate_threshold") is not None
+            else os.getenv("TP_TRACE_N_PLUS_ONE_DUPLICATE_THRESHOLD")
+            or os.getenv("TP_DOG_N_PLUS_ONE_DUPLICATE_THRESHOLD")
+        )
+        resolved_n_plus_one_dup = _parse_positive_int_default(
+            raw_n_plus_one_dup, default=15, min_val=2, field_name="n_plus_one_duplicate_threshold"
+        )
+
+        raw_n_plus_one_max_fp = (
+            n_plus_one_max_fingerprints
+            if n_plus_one_max_fingerprints is not None
+            else extra.get("n_plus_one_max_fingerprints")
+            if extra.get("n_plus_one_max_fingerprints") is not None
+            else os.getenv("TP_TRACE_N_PLUS_ONE_MAX_FINGERPRINTS") or os.getenv("TP_DOG_N_PLUS_ONE_MAX_FINGERPRINTS")
+        )
+        resolved_n_plus_one_max_fp = _parse_positive_int_default(
+            raw_n_plus_one_max_fp, default=256, min_val=1, field_name="n_plus_one_max_fingerprints"
+        )
+
         return cls(
             project_name=resolved_project,
             cluster_name=resolved_cluster,
@@ -661,8 +751,12 @@ class SDKConfig:
             metrics_endpoint=resolved_metrics_endpoint,
             metrics_enabled=resolved_metrics_enabled,
             metrics_export_interval_millis=resolved_metrics_interval,
+            metric_cardinality_limit=resolved_metric_cardinality_limit,
+            service_instance_id=resolved_service_instance_id,
             redis_mask_endpoint=resolved_redis_mask_endpoint,
             redis_mask_command=resolved_redis_mask_command,
             redis_cmd_max_length=resolved_cmd_max_length,
             query_mode=resolved_query_mode,
+            n_plus_one_duplicate_threshold=resolved_n_plus_one_dup,
+            n_plus_one_max_fingerprints=resolved_n_plus_one_max_fp,
         )

{tp_trace-0.1.6 → tp_trace-0.2.0}/src/tp_trace/integrations/base.py

@@ -29,6 +29,14 @@ class BaseIntegration(abc.ABC):
         self._wrapped_keys: set = set()
         self._when_imported_hooks: List[Tuple[str, Callable]] = []
 
+    @property
+    def config(self) -> Optional[SDKConfig]:
+        return self._config
+
+    @config.setter
+    def config(self, value: Optional[SDKConfig]) -> None:
+        self._config = value
+
     @abc.abstractmethod
     def is_installed(self) -> bool:
         """Check if target library or framework is installed in the current environment."""
@@ -94,8 +102,10 @@ class BaseIntegration(abc.ABC):
 
     def unwrap_all(self) -> None:
         """Restores all wrapped targets to their original unwrapped states in reverse order."""
+        failed_targets = []
         while self._wrapped_targets:
             target_obj, attr_name, original = self._wrapped_targets.pop()
+            key = (id(target_obj), attr_name)
             try:
                 current = getattr(target_obj, attr_name, None)
                 if current is not None and hasattr(current, "__wrapped__"):
@@ -104,6 +114,7 @@ class BaseIntegration(abc.ABC):
                     setattr(target_obj, attr_name, original)
                 elif hasattr(target_obj, attr_name):
                     delattr(target_obj, attr_name)
+                self._wrapped_keys.discard(key)
             except Exception as exc:
                 logger.debug(
                     "Error unwrapping %s on %s in %s integration: %s",
@@ -112,7 +123,10 @@ class BaseIntegration(abc.ABC):
                     self.name,
                     exc,
                 )
-        self._wrapped_keys.clear()
+                failed_targets.append((target_obj, attr_name, original))
+
+        if failed_targets:
+            self._wrapped_targets.extend(failed_targets)
 
     def when_imported(self, module_name: str, callback: Callable[..., Any]) -> None:
         """
@@ -166,6 +180,13 @@ class BaseIntegration(abc.ABC):
             return True
         try:
             self._remove_patch()
+            if self._wrapped_targets:
+                logger.debug(
+                    "Failed to completely uninstrument %s; %d targets remained wrapped",
+                    self.name,
+                    len(self._wrapped_targets),
+                )
+                return False
             self._instrumented = False
             logger.debug("Successfully uninstrumented integration: %s", self.name)
             return True

{tp_trace-0.1.6 → tp_trace-0.2.0}/src/tp_trace/integrations/celery/context.py

@@ -12,7 +12,7 @@ from typing import FrozenSet, Iterable, NamedTuple, Optional
 class CeleryCreationMeta(NamedTuple):
     action: str  # "apply_async" or "run"
     bounded_operation: str  # "celery.apply_async.<admitted_name or unknown>"
-    span_name: str  # "🟣 celery.apply_async" or "🟣 celery.run"
+    span_name: str  # "🟣 <task_name>.apply_async" or "🟣 <task_name>.run" (fallback generic)
 
 
 _CURRENT_CELERY_CREATION_META: contextvars.ContextVar[Optional[CeleryCreationMeta]] = contextvars.ContextVar(

{tp_trace-0.1.6 → tp_trace-0.2.0}/src/tp_trace/integrations/celery/instrumentor.py

@@ -64,10 +64,11 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
         task_name = getattr(task, "name", None)
 
         bounded_op = compute_bounded_operation("run", task_name, registered=task is not None)
+        span_name = f"🟣 {task_name}.run" if task_name and task_name != "unknown" else "🟣 celery.run"
         meta = CeleryCreationMeta(
             action="run",
             bounded_operation=bounded_op,
-            span_name="🟣 celery.run",
+            span_name=span_name,
         )
 
         if task is None or task_id is None:
@@ -76,6 +77,26 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
         # creation. Keep our own restoration token for failures before that point.
         restore_token = context_api.attach(context_api.get_current())
         token = set_celery_creation_meta(meta)
+
+        # Defensive propagation support: Celery stores incoming message headers in task.request.headers.
+        # Upstream CeleryGetter does getattr(task.request, key). Ensure W3C propagation attributes
+        # on task.request are populated from task.request.headers if missing.
+        try:
+            req = getattr(task, "request", None)
+            if req is not None:
+                req_headers = getattr(req, "headers", None)
+                if req_headers is None and isinstance(req, dict):
+                    req_headers = req.get("headers")
+                if isinstance(req_headers, dict):
+                    for k in ("traceparent", "tracestate", "baggage"):
+                        if k in req_headers and not hasattr(req, k):
+                            try:
+                                setattr(req, k, req_headers[k])
+                            except Exception:
+                                pass
+        except Exception:
+            pass
+
         try:
             try:
                 super()._trace_prerun(*args, **kwargs)
@@ -109,7 +130,7 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
                 if ctx is not None:
                     span, _, _ = ctx
                     if span is not None and getattr(span, "is_recording", lambda: True)():
-                        safe_update_name(span, "🟣 celery.run")
+                        safe_update_name(span, span_name)
                         safe_set_attribute(span, "celery.task_id", task_id)
                         if task_name:
                             safe_set_attribute(span, "celery.task_name", task_name)
@@ -126,6 +147,24 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
                                 rk = delivery_info.get("routing_key")
                                 if rk:
                                     safe_set_attribute(span, "celery.queue", str(rk))
+                            req_headers = getattr(req, "headers", None)
+                            if req_headers is None and isinstance(req, dict):
+                                req_headers = req.get("headers")
+                            trigger_view = None
+                            if isinstance(req_headers, dict):
+                                trigger_view = req_headers.get("tp_trigger_view")
+                            if not trigger_view:
+                                # Fallback for tasks executed eagerly in-process within the same thread
+                                # (e.g. task_always_eager=True in tests or synchronous workflows),
+                                # where task request headers may not have traversed amqp serialization.
+                                try:
+                                    from tp_trace.route_context import get_current_view
+
+                                    trigger_view = get_current_view()
+                                except Exception:
+                                    pass
+                            if trigger_view:
+                                safe_set_attribute(span, "celery.trigger.view", str(trigger_view))
         except Exception:
             logger.debug("Error during _trace_prerun enrichment", exc_info=True)
 
@@ -141,15 +180,32 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
             elif hasattr(sender, "name"):
                 task_name = getattr(sender, "name")
             else:
-                task_name = "unknown"
+                headers = kwargs.get("headers")
+                if isinstance(headers, dict) and headers.get("task"):
+                    task_name = str(headers.get("task"))
+                else:
+                    task_name = "unknown"
 
         bounded_op = compute_bounded_operation("apply_async", task_name, registered=task is not None)
+        span_name = f"🟣 {task_name}.apply_async" if task_name and task_name != "unknown" else "🟣 celery.apply_async"
         meta = CeleryCreationMeta(
             action="apply_async",
             bounded_operation=bounded_op,
-            span_name="🟣 celery.apply_async",
+            span_name=span_name,
         )
 
+        trigger_view = None
+        try:
+            from tp_trace.route_context import get_current_view
+
+            trigger_view = get_current_view()
+        except Exception:
+            pass
+
+        headers = kwargs.get("headers")
+        if isinstance(headers, dict) and trigger_view:
+            headers["tp_trigger_view"] = trigger_view
+
         token = set_celery_creation_meta(meta)
         try:
             try:
@@ -160,6 +216,16 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
             logger.debug("Upstream _trace_before_publish failed", exc_info=True)
             return
 
+        # Defensive propagation injection: ensure trace context is injected even if headers dict
+        # was initially empty (upstream checks `if headers: inject(headers)`, skipping empty dicts).
+        try:
+            if isinstance(headers, dict) and "traceparent" not in headers:
+                from opentelemetry.propagate import inject
+
+                inject(headers)
+        except Exception:
+            pass
+
         # Only enrich a verified producer from upstream's context store.
         # Unknown-task producers can already have ended; the ambient span then
         # belongs to the application and must never be enriched or ended here.
@@ -168,9 +234,11 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
                 ctx = utils.retrieve_context(task, task_id, is_publish=True)
                 span = ctx[0] if ctx is not None else None
                 if span is not None and getattr(span, "is_recording", lambda: True)():
-                    safe_update_name(span, "🟣 celery.apply_async")
+                    safe_update_name(span, span_name)
                     safe_set_attribute(span, "celery.task_id", task_id)
                     safe_set_attribute(span, "celery.task_name", task_name)
+                    if trigger_view:
+                        safe_set_attribute(span, "celery.trigger.view", trigger_view)
 
                     # Extract producer queue
                     queue_name = None
@@ -191,13 +259,19 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
             logger.debug("Error during _trace_before_publish enrichment", exc_info=True)
 
     def _trace_after_publish(self, *args: Any, **kwargs: Any) -> None:  # type: ignore[override]
-        task = utils.retrieve_task_from_sender(kwargs)
-        task_id = utils.retrieve_task_id_from_message(kwargs)
+        try:
+            task = utils.retrieve_task_from_sender(kwargs)
+            task_id = utils.retrieve_task_id_from_message(kwargs)
+            ctx = utils.retrieve_context(task, task_id, is_publish=True) if (task and task_id) else None
+        except Exception:
+            task = None
+            task_id = None
+            ctx = None
 
-        ctx = utils.retrieve_context(task, task_id, is_publish=True) if (task and task_id) else None
         try:
             super()._trace_after_publish(*args, **kwargs)
-        except Exception:
+        except Exception as exc:
+            logger.debug("Upstream _trace_after_publish failed: %s", exc, exc_info=True)
             if ctx is not None:
                 _, activation, _ = ctx
                 try:
@@ -206,7 +280,6 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
                     pass
                 if task and task_id:
                     utils.detach_context(task, task_id, is_publish=True)
-            raise
 
     def _trace_failure(self, *args: Any, **kwargs: Any) -> None:  # type: ignore[override]
         upstream_failed = False
@@ -325,7 +398,8 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
         try:
             try:
                 super()._trace_postrun(*args, **kwargs)
-            except Exception:
+            except Exception as exc:
+                logger.debug("Upstream _trace_postrun failed: %s", exc, exc_info=True)
                 # Upstream finalization failed: best-effort cleanup
                 if ctx is not None:
                     span, activation, token = ctx
@@ -345,11 +419,13 @@ class TpTraceCeleryInstrumentor(CeleryInstrumentor):
                             context_api.detach(token)  # type: ignore[arg-type]
                         except Exception:
                             pass
-                raise
         finally:
             restore_token = self._prerun_context_tokens.pop(task_id, None) if task_id else None
             if restore_token is not None:
-                context_api.detach(restore_token)
+                try:
+                    context_api.detach(restore_token)
+                except Exception:
+                    pass
             # Defensive timing map cleanup against leaks across all upstream versions
             if hasattr(self, "task_id_to_start_time") and isinstance(self.task_id_to_start_time, dict):
                 if task_id:

tp_trace-0.2.0/src/tp_trace/integrations/django/__init__.py

@@ -0,0 +1,15 @@
+"""Django integration package — re-exports DjangoIntegration.
+
+Layout follows:
+integrations/django/
+  __init__.py      — re-export
+  integration.py   — DjangoIntegration orchestration
+  request.py       — SERVER request hooks and OTel middleware enhancement
+  middleware.py    — load_middleware wrapper
+  view.py          — view span
+  template.py      — template span
+"""
+
+from .integration import DjangoIntegration
+
+__all__ = ["DjangoIntegration"]

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

@@ -145,10 +145,13 @@ def make_traced_cache_op(op_name: str):
                 pass
 
         if key is not None:
-            if 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)
+            try:
+                if 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)
+            except Exception:
+                pass
 
         token = _in_cache_span.set(True)
         try: