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.

8.6 KB
Raw Blame
"""Test support for provider packages: a recording egress and representative traces."""

import json
from collections import deque
from collections.abc import Iterable, Mapping
from dataclasses import dataclass
from datetime import UTC, datetime, timedelta

import grpc  # type: ignore[import-untyped]
from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import ExportTraceServiceRequest
from opentelemetry.proto.common.v1.common_pb2 import AnyValue
from opentelemetry.proto.trace.v1.trace_pb2 import Span as OtlpSpan

from dify_trace_sdk.egress import EgressResponse
from dify_trace_sdk.errors import EgressBlockedError
from dify_trace_sdk.ids import span_id_for, trace_id_for
from dify_trace_sdk.model import Cost, Span, SpanKind, SpanRef, SpanStatus, TokenUsage, Trace

MESSAGE_ID = "7b3c6c0e-38a1-4b52-9a7e-3ad8f3a1c001"
WORKFLOW_RUN_ID = "7b3c6c0e-38a1-4b52-9a7e-3ad8f3a1c002"
STARTED_AT = datetime(2026, 10, 1, 8, 0, 0, tzinfo=UTC)


@dataclass(frozen=True)
class RecordedRequest:
    method: str
    url: str
    headers: Mapping[str, str]
    content: bytes | None
    timeout: float
    sensitive_url: bool

    def json(self) -> object:
        return json.loads(self.content or b"null")


class RecordingEgress:
    """Answers requests from a script and records what a provider sent."""

    def __init__(self, responses: Iterable[EgressResponse | Exception], *, grpc_target: str | None) -> None:
        self._responses = deque(responses)
        self._grpc_target = grpc_target
        self.requests: list[RecordedRequest] = []
        self.grpc_endpoints: list[str] = []

    def request(
        self,
        method: str,
        url: str,
        *,
        headers: Mapping[str, str],
        content: bytes | None,
        timeout: float,
        sensitive_url: bool,
    ) -> EgressResponse:
        self.requests.append(
            RecordedRequest(
                method=method,
                url=url,
                headers=dict(headers),
                content=content,
                timeout=timeout,
                sensitive_url=sensitive_url,
            )
        )
        if not self._responses:
            raise AssertionError(f"unexpected request: {method} {url}")
        response = self._responses.popleft()
        if isinstance(response, Exception):
            raise response
        return response

    def grpc_channel(self, endpoint: str) -> grpc.Channel:
        self.grpc_endpoints.append(endpoint)
        if self._grpc_target is None:
            raise EgressBlockedError("gRPC is not available in this test")
        return grpc.insecure_channel(self._grpc_target)


def otlp_spans(egress: RecordingEgress) -> list[OtlpSpan]:
    """Every span ``egress`` recorded in OTLP requests, in send order."""
    return [
        span
        for request in egress.requests
        for resource_spans in ExportTraceServiceRequest.FromString(request.content or b"").resource_spans
        for scope_spans in resource_spans.scope_spans
        for span in scope_spans.spans
    ]


def _scalar(value: AnyValue) -> object:
    match value.WhichOneof("value"):
        case "string_value":
            return value.string_value
        case "int_value":
            return value.int_value
        case "double_value":
            return value.double_value
        case "bool_value":
            return value.bool_value
        case other:
            raise AssertionError(f"unexpected attribute value type {other}")


def otlp_attributes(span: OtlpSpan) -> dict[str, object]:
    return {item.key: _scalar(item.value) for item in span.attributes}


def response(status_code: int, body: object) -> EgressResponse:
    content = body if isinstance(body, bytes) else json.dumps(body).encode()
    content_type = "application/octet-stream" if isinstance(body, bytes) else "application/json"
    return EgressResponse(status_code=status_code, headers={"content-type": content_type}, content=content)


def message_trace() -> Trace:
    """A chat message: the message root and the LLM call that answered it."""
    message_span_id = span_id_for(MESSAGE_ID)
    return Trace(
        trace_id=trace_id_for(MESSAGE_ID),
        external_trace_id=None,
        session_id="conversation-1",
        user_id="end-user-1",
        parent=None,
        spans=(
            Span(
                span_id=message_span_id,
                parent_span_id=None,
                name="message",
                kind=SpanKind.CHAIN,
                start_time=STARTED_AT,
                end_time=STARTED_AT + timedelta(seconds=2),
                status=SpanStatus.OK,
                inputs={"query": "What is Dify?"},
                outputs="An LLM application platform.",
                attributes={"message_id": MESSAGE_ID, "app_id": "app-1", "tenant_id": "tenant-1"},
            ),
            Span(
                span_id=span_id_for(f"{MESSAGE_ID}:llm"),
                parent_span_id=message_span_id,
                name="llm",
                kind=SpanKind.LLM,
                start_time=STARTED_AT,
                end_time=STARTED_AT + timedelta(seconds=2),
                status=SpanStatus.OK,
                inputs=[{"role": "user", "content": "What is Dify?"}],
                outputs="An LLM application platform.",
                model_name="gpt-4o",
                model_provider="openai",
                usage=TokenUsage(prompt_tokens=12, completion_tokens=8, total_tokens=20),
                cost=Cost(amount=0.0004, currency="USD"),
                time_to_first_token=0.25,
                attributes={"message_id": MESSAGE_ID},
            ),
        ),
    )


def workflow_trace() -> Trace:
    """A workflow run with a failed tool node under a successful LLM node."""
    run_span_id = span_id_for(WORKFLOW_RUN_ID)
    llm_span_id = span_id_for("node-execution-llm")
    return Trace(
        trace_id=trace_id_for(WORKFLOW_RUN_ID),
        external_trace_id=None,
        session_id=WORKFLOW_RUN_ID,
        user_id="account-1",
        parent=None,
        spans=(
            Span(
                span_id=run_span_id,
                parent_span_id=None,
                name="workflow",
                kind=SpanKind.CHAIN,
                start_time=STARTED_AT,
                end_time=STARTED_AT + timedelta(seconds=5),
                status=SpanStatus.ERROR,
                error="Tool failed",
                inputs={"topic": "tracing"},
                outputs={},
                attributes={"workflow_run_id": WORKFLOW_RUN_ID, "app_id": "app-1"},
            ),
            Span(
                span_id=llm_span_id,
                parent_span_id=run_span_id,
                name="llm_Summarize",
                kind=SpanKind.LLM,
                start_time=STARTED_AT + timedelta(seconds=1),
                end_time=STARTED_AT + timedelta(seconds=3),
                status=SpanStatus.OK,
                inputs=[{"role": "user", "content": "Summarize tracing"}],
                outputs={"text": "Tracing records execution."},
                model_name="gpt-4o",
                model_provider="openai",
                usage=TokenUsage(prompt_tokens=30, completion_tokens=10, total_tokens=40),
                attributes={"node_execution_id": "node-execution-llm", "node_type": "llm"},
            ),
            Span(
                span_id=span_id_for("node-execution-tool"),
                parent_span_id=llm_span_id,
                name="tool_Search",
                kind=SpanKind.TOOL,
                start_time=STARTED_AT + timedelta(seconds=3),
                end_time=STARTED_AT + timedelta(seconds=5),
                status=SpanStatus.ERROR,
                error="Tool failed",
                inputs={"query": "tracing"},
                outputs={},
                attributes={"node_execution_id": "node-execution-tool", "node_type": "tool"},
            ),
        ),
    )


def tool_fragment() -> Trace:
    """A tool call sent separately and attached under the message of ``message_trace``."""
    return Trace(
        trace_id=trace_id_for(MESSAGE_ID),
        external_trace_id=None,
        session_id="conversation-1",
        user_id="end-user-1",
        parent=SpanRef(span_id=span_id_for(MESSAGE_ID), start_time=STARTED_AT),
        spans=(
            Span(
                span_id=span_id_for("tool-event-1"),
                parent_span_id=span_id_for(MESSAGE_ID),
                name="weather",
                kind=SpanKind.TOOL,
                start_time=STARTED_AT + timedelta(milliseconds=500),
                end_time=STARTED_AT + timedelta(seconds=1),
                status=SpanStatus.OK,
                inputs={"city": "Berlin"},
                outputs="Sunny",
                attributes={"message_id": MESSAGE_ID},
            ),
        ),
    )