How to capture the span_id in an instrumented LangChain app?

[omrihar]

I'm trying to follow the guide to capture the span id in order to allow the front-end application to capture human feedback (following the guide here: https://docs.arize.com/phoenix/tracing/how-to-tracing/capture-feedback).
The problem is that I'm using (for now) a simple LangChain chain which is automatically instrumented using:

    if project_name is None:
        project_name = PHOENIX_PROJECT
    tracer_provider = register(
        endpoint=f"{PHOENIX_URL}/v1/traces", project_name=project_name
    )

    LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

and when I try to get the span after the call, I always get a span id of '0000000000000000'.
I tried to add the span extraction into the chain in the following way:

def get_span() -> str:
    span = trace.get_current_span()
    span_id = span.get_span_context().span_id.to_bytes(8, "big").hex()
    return span_id

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | basic_rag_prompt
    | llm
    | {"output": StrOutputParser() }
    | RunnablePassthrough.assign(
        span_id=lambda x: get_span()
    )
)

but this ends up giving the same results. Is there a better / smarter way to get the current span_id?
In the final app I'll probably move to LangGraph, with a much more complex setup, but I'd like to already iron out all of these "prerequisits" at the very simple level.

Thanks!

[dosubot[bot]]

To capture the span_id in an instrumented LangChain app, you can use the get_span_id function provided in the helpers.py file from the OpenInference instrumentation. This function converts the span ID to a hexadecimal string. If you are getting a span ID of '0000000000000000', it might indicate that the span context is not being properly propagated or initialized.

Here is the relevant code snippet to capture the span_id:

from opentelemetry.trace import Span
from openinference.instrumentation.helpers import get_span_id

# Assuming `span` is an instance of `Span`
span_id = get_span_id(span)
print(span_id)

Make sure that the span object you are passing to get_span_id is correctly initialized and has a valid span context. If the span context is not properly set up, you will get a span ID of '0000000000000000'.

Additionally, you can refer to the following example from a manually instrumented LangChain application to ensure proper span initialization and attribute setting:

from opentelemetry import trace as trace_api
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# Set up the tracer provider and span processor
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(
    SimpleSpanProcessor(OTLPSpanExporter("http://localhost:6006/v1/traces"))
)
trace_api.set_tracer_provider(tracer_provider)
tracer = trace_api.get_tracer(__name__)

# Example of starting a span and setting attributes
with tracer.start_as_current_span("LangChain Span") as span:
    span.set_attribute("example.attribute", "value")
    span_id = span.get_span_context().span_id.to_bytes(8, "big").hex()
    print(span_id)

Ensure that your environment variables and tracer setup are correctly configured to avoid issues with span context propagation.

For additional verification, you can refer to the test case from OpenInference to ensure that the get_span_id function works as expected:

from opentelemetry.trace import NonRecordingSpan, SpanContext
from openinference.instrumentation.helpers import get_span_id, get_trace_id

def test_get_span_and_trace_ids() -> None:
    span = NonRecordingSpan(
        SpanContext(
            trace_id=83298525428589810613581548256892812612,
            span_id=8006530202346048876,
            is_remote=False,
        )
    )
    assert get_span_id(span) == "6f1ce8cc7245cd6c"
    assert get_trace_id(span) == "3eaab662c550df264f0fbd19bd8bfd44"

This test case demonstrates the correct usage of get_span_id and get_trace_id functions, ensuring that they return the expected hexadecimal string representations of the span and trace IDs.

For a complete setup, you can follow the instructions provided in the LangChain integration documentation to ensure that your LangChain application is properly instrumented and connected to the Phoenix server for observability and evaluation ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[omrihar]

I figured out the answer to that, after digging a bit deeper in the LangChain instrumentation code.
By using the get_current_span function from the instrumentor the code actually works.

So the solution is:

from openinference.instrumentation.langchain import get_current_span
...
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | basic_rag_prompt
    | llm
    | { "output": StrOutputParser() }
    | RunnablePassthrough.assign(
        span_id=lambda x: get_current_span().get_span_context().span_id.to_bytes(8, "big").hex()
    )
)

Perhaps it's worth adding this to the documentation?

[dosubot[bot]]

To get the root span for a given Span element, you can use the createSpanTree function defined in the utils.ts file. This function constructs a tree of spans and identifies root spans by checking if the parent span is not in the collection or if the parent span is null.

Here is the createSpanTree function:

import { ISpanItem } from "./types";

export type SpanTreeNode<TSpan> = {
  span: TSpan;
  children: SpanTreeNode<TSpan>[];
};

/**
 * Create a span tree from a list of spans
 * @param spans
 */
export function createSpanTree<TSpan extends ISpanItem>(
  spans: TSpan[]
): SpanTreeNode<TSpan>[] {
  // A map of spanId to span tree node
  const spanMap = spans.reduce((acc, span) => {
    acc.set(span.context.spanId, {
      span,
      children: [],
    });
    return acc;
  }, new Map<string, SpanTreeNode<TSpan>>());
  const rootSpans: SpanTreeNode<TSpan>[] = [];
  for (const span of spans) {
    const spanTreeItem = spanMap.get(span.context.spanId);
    if (span.parentId === null || !spanMap.has(span.parentId)) {
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      rootSpans.push(spanTreeItem!);
    } else {
      const parentSpanNode = spanMap.get(span.parentId);
      if (parentSpanNode) {
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        parentSpanNode.children.push(spanTreeItem!);
      }
    }
  }
  // We must sort the children of each span by their start time
  // So that the children are in the correct order
  for (const spanNode of spanMap.values()) {
    spanNode.children.sort(
      (a, b) =>
        new Date(a.span.startTime).valueOf() -
        new Date(b.span.startTime).valueOf()
    );
  }
  return rootSpans;
}

You can use this function by passing the list of spans to it, and it will return an array of root spans. Each root span will be the top-level node in the span tree ^[1].

To continue talking to Dosu, mention @dosu.

[omrihar]

@dosu this is not helpful, because I'm using the python sdk rather than the javascript one.

[dosubot[bot]]

To retrieve the root span in a Python setup using OpenTelemetry, you can follow a similar approach to the one used in the JavaScript example but adapted for Python. Unfortunately, there isn't a built-in function in the OpenTelemetry Python SDK to directly retrieve the root span. However, you can implement a utility function to traverse the span hierarchy and find the root span.

Here's an example of how you can achieve this:

1. Collect all spans: Ensure you have a way to collect all spans, typically using an in-memory span exporter during testing or debugging.

2. Identify the root span: Traverse the collected spans to find the one with no parent.

Here's a sample implementation:

from opentelemetry.sdk.trace import Span
from typing import List, Optional

def get_root_span(spans: List[Span], target_span: Span) -> Optional[Span]:
    current_span = target_span
    while current_span.parent:
        parent_span_id = current_span.parent.span_id
        parent_span = next((span for span in spans if span.context.span_id == parent_span_id), None)
        if parent_span is None:
            break
        current_span = parent_span
    return current_span

# Example usage
from opentelemetry.sdk.trace.export import InMemorySpanExporter, SimpleSpanProcessor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry import trace

# Set up in-memory span exporter
span_exporter = InMemorySpanExporter()
span_processor = SimpleSpanProcessor(span_exporter)
tracer_provider = TracerProvider()
tracer_provider.add_span_processor(span_processor)
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)

# Create some spans
with tracer.start_as_current_span("root") as root_span:
    with tracer.start_as_current_span("child") as child_span:
        with tracer.start_as_current_span("grandchild") as grandchild_span:
            pass

# Retrieve all finished spans
finished_spans = span_exporter.get_finished_spans()

# Find the root span for the grandchild span
root_span = get_root_span(finished_spans, grandchild_span)
print(f"Root span ID: {root_span.context.span_id.to_bytes(8, 'big').hex()}")

In this example, the get_root_span function traverses the span hierarchy to find the root span. The InMemorySpanExporter is used to collect spans for demonstration purposes. You can adapt this approach to your specific setup to ensure you correctly identify the root span in your LangChain application.

To continue talking to Dosu, mention @dosu.

[RogerHYang]

how do I get the root span for it?

Right now there isn't an easy way to get to the root span. Would you mind opening an enhancement request?

[omrihar]

Sure @RogerHYang , here it is: Arize-ai/openinference#1052