Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

fix(dify-agent): handle non-recording tracing parents (#44701)

zyssyz12365e5e61a8ae3
diff --git a/dify-agent/src/dify_agent/runtime/observability.py b/dify-agent/src/dify_agent/runtime/observability.py
index 58de42b4ee8..93d7523b799 100644
--- a/dify-agent/src/dify_agent/runtime/observability.py
+++ b/dify-agent/src/dify_agent/runtime/observability.py
@@ -103,9 +103,12 @@ class _IsolatedTracer(Tracer):
parent = get_current_span(context)
if not parent.get_span_context().is_valid:
return context
- if isinstance(parent, ReadableSpan):
+ # Logfire's ReadableSpan wrapper can delegate to a NonRecordingSpan,
+ # which propagates a valid context but has no SDK resource.
+ resource = getattr(parent, "resource", None) if isinstance(parent, ReadableSpan) else None
+ if resource is not None:
instance_id = self.client.resource_attributes.get("service.instance.id")
- if instance_id is not None and parent.resource.attributes.get("service.instance.id") == instance_id:
+ if instance_id is not None and resource.attributes.get("service.instance.id") == instance_id:
return context
elif self.preserve_external_parent:
return context
diff --git a/dify-agent/tests/local/dify_agent/runtime/test_agent_observability.py b/dify-agent/tests/local/dify_agent/runtime/test_agent_observability.py
index 751005137b7..ce0728da0fd 100644
--- a/dify-agent/tests/local/dify_agent/runtime/test_agent_observability.py
+++ b/dify-agent/tests/local/dify_agent/runtime/test_agent_observability.py
@@ -11,7 +11,7 @@ import httpx
import logfire
import pytest
from opentelemetry import context as otel_context
-from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags, get_current_span, set_span_in_context
@@ -425,6 +425,50 @@ def test_isolated_tracer_remote_and_same_instance_parent_policy(method: str, sam
platform_client.shutdown(timeout_millis=5000)
[email protected]("method", ["start_span", "start_as_current_span"])
[email protected]("preserve_external_parent", [True, False])
+def test_isolated_tracer_handles_logfire_wrapped_nonrecording_parent(
+ method: str, preserve_external_parent: bool
+) -> None:
+ exporter = InMemorySpanExporter()
+ client = _local_client(exporter)
+ remote = NonRecordingSpan(SpanContext(trace_id=0xABCD, span_id=0x1234, is_remote=True, trace_flags=TraceFlags(0)))
+ parent = (
+ client.config.get_tracer_provider()
+ .get_tracer("sampled-out")
+ .start_span("sampled-out-parent", context=set_span_in_context(remote))
+ )
+ token = otel_context.attach(set_span_in_context(parent))
+ try:
+ # Logfire's real wrapper is a ReadableSpan even when its underlying OTel
+ # span was not sampled and therefore has no SDK resource.
+ assert isinstance(parent, ReadableSpan)
+ assert isinstance(parent.span, NonRecordingSpan)
+ assert parent.get_span_context().is_valid
+ tracer = IsolatedTracerProvider(client, preserve_external_parent=preserve_external_parent).get_tracer("child")
+ if method == "start_span":
+ child = tracer.start_span("child")
+ child.end()
+ else:
+ with tracer.start_as_current_span("child") as child:
+ assert get_current_span().get_span_context() == child.get_span_context()
+ assert get_current_span() is parent
+ assert client.force_flush(timeout_millis=10000)
+
+ if preserve_external_parent:
+ assert child.get_span_context().trace_id == remote.get_span_context().trace_id
+ assert not child.get_span_context().trace_flags.sampled
+ assert not exporter.get_finished_spans()
+ else:
+ span = _spans_by_name(exporter, "child")[0]
+ assert span.parent is None
+ assert span.context.trace_id != remote.get_span_context().trace_id
+ finally:
+ otel_context.detach(token)
+ parent.end()
+ client.shutdown(timeout_millis=5000)
+
+
def test_concurrent_agent_runs_have_independent_business_roots() -> None:
platform_exporter = InMemorySpanExporter()
platform_client = _local_client(platform_exporter)
diff --git a/dify-agent/tests/local/dify_agent/server/test_observability_isolation.py b/dify-agent/tests/local/dify_agent/server/test_observability_isolation.py
index 28f493c45bb..7e196180652 100644
--- a/dify-agent/tests/local/dify_agent/server/test_observability_isolation.py
+++ b/dify-agent/tests/local/dify_agent/server/test_observability_isolation.py
@@ -293,3 +293,38 @@ def test_platform_fastapi_instrumentation_omits_parsed_argument_payloads() -> No
assert "fastapi.arguments.errors" not in serialized
finally:
client.shutdown(timeout_millis=5000)
+
+
+def test_platform_fastapi_instrumentation_accepts_unsampled_request_bodies() -> None:
+ exporter = InMemorySpanExporter()
+ client = logfire.configure(
+ local=True,
+ send_to_logfire=False,
+ console=False,
+ metrics=False,
+ inspect_arguments=False,
+ additional_span_processors=[SimpleSpanProcessor(exporter)],
+ )
+ app = FastAPI()
+
+ @app.post("/echo")
+ def echo(payload: _SmokePayload) -> dict[str, str]:
+ return {"text": payload.text}
+
+ try:
+ with client.instrument_fastapi(
+ app,
+ request_attributes_mapper=observability._platform_request_attributes,
+ capture_headers=False,
+ tracer_provider=IsolatedTracerProvider(client, preserve_external_parent=True),
+ ):
+ with TestClient(app) as http:
+ headers = {"traceparent": "00-0000000000000000000000000000abcd-0000000000001234-00"}
+ response = http.post("/echo", json={"text": "unsampled-body", "count": 1}, headers=headers)
+ assert response.status_code == 200
+ assert response.json() == {"text": "unsampled-body"}
+ assert http.post("/echo", json={"text": "invalid", "count": "x"}, headers=headers).status_code == 422
+ assert client.force_flush(timeout_millis=10000)
+ assert not exporter.get_finished_spans()
+ finally:
+ client.shutdown(timeout_millis=5000)