LangChain

LangChain

LangChain is a framework for building applications powered by large language models (LLMs). It enables developers to create sophisticated AI applications by chaining together LLM calls, tools, and data sources. Monitoring LangChain applications is essential for understanding LLM performance, tracking token usage, identifying bottlenecks in chain executions, and troubleshooting errors in production.

Use Cases

• Monitor LLM call performance and latency across different models and providers
• Track token usage and costs including cache hits to optimize spending and performance
• Analyze chain execution flows to understand multi-step reasoning and identify bottlenecks
• Troubleshoot production issues with full conversation context, prompts, and completions
• Understand model behavior through detailed request parameters and response metadata

Overview

LangChain applications can be instrumented with OpenTelemetry to automatically capture traces, metrics, and logs. This provides visibility into LLM calls, chain executions, token usage, latency, and errors. OpenTelemetry's auto-instrumentation approach (recommended) requires zero code changes, while manual instrumentation offers full control for custom spans and attributes.

For a complete working example, see the LangChain observability example in the dash0-examples repository.

Prerequisites

Before setting up LangChain monitoring, ensure:

• You have access to an LLM provider (e.g., Anthropic, OpenAI)

You'll need an OpenTelemetry Collector deployed to receive telemetry from your LangChain application. Consider using:

• Dash0 operator for Kubernetes
• OpenTelemetry Operator for Kubernetes

• Helm Chart for The OpenTelemetry Collector

For local development, see the LangChain observability example for a complete setup with docker-compose.

Approach 1: Auto-Instrumentation (Recommended)

Auto-instrumentation automatically captures telemetry from LangChain with zero code changes.

Install Dependencies

Install the OpenTelemetry distribution and LangChain instrumentation:

pip install opentelemetry-distro \
  opentelemetry-exporter-otlp \
  opentelemetry-instrumentation-langchain

Bootstrap Auto-Instrumentation

Run the bootstrap command to install instrumentation packages for your installed libraries:

opentelemetry-bootstrap -a install

Configure Environment Variables

Set the following environment variables to send telemetry to an OpenTelemetry Collector:

export OTEL_SERVICE_NAME="my-langchain-app"
export OTEL_SERVICE_VERSION="1.0.0"
export OTEL_DEPLOYMENT_ENVIRONMENT="production"
export OTEL_EXPORTER_OTLP_ENDPOINT="http://localhost:4317"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"

Run Your Application

Execute your application with the opentelemetry-instrument wrapper:

opentelemetry-instrument python your_app.py

For frameworks like Flask or FastAPI:

opentelemetry-instrument flask --app myapp run
opentelemetry-instrument uvicorn main:app --reload

Your LangChain application now exports telemetry automatically with no code changes required. Auto-instrumentation does not prevent you from adding custom spans - you can always reference the global tracer using trace.get_tracer(__name__) to add business-specific context.

Approach 2: Manual Instrumentation

Manual instrumentation provides full control and allows custom spans and attributes.

Install Dependencies

pip install opentelemetry-api \
  opentelemetry-sdk \
  opentelemetry-exporter-otlp \
  opentelemetry-instrumentation-langchain

Configure OpenTelemetry

Add the following setup code to your application:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.semconv.resource import ResourceAttributes
from opentelemetry.instrumentation.langchain import LangchainInstrumentor

def setup_telemetry():
    """Configure OpenTelemetry for LangChain."""

    # Define service resource
    resource = Resource(attributes={
        ResourceAttributes.SERVICE_NAME: "my-langchain-app",
        ResourceAttributes.SERVICE_VERSION: "1.0.0",
        ResourceAttributes.DEPLOYMENT_ENVIRONMENT: "production",
    })

    # Create tracer provider
    provider = TracerProvider(resource=resource)

    # Configure OTLP exporter to send to collector
    otlp_exporter = OTLPSpanExporter(
        endpoint="http://localhost:4317",
        insecure=True,
    )

    # Add span processor
    provider.add_span_processor(BatchSpanProcessor(otlp_exporter))

    # Set global tracer provider
    trace.set_tracer_provider(provider)

    # Instrument LangChain
    LangchainInstrumentor().instrument()

# Call once at application startup
setup_telemetry()

Add Custom Spans (Optional)

You can add custom spans to capture business logic:

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("process_user_query") as span:
    span.set_attribute("user.id", "user123")
    span.set_attribute("query.type", "qa")

    # Your LangChain code here
    response = chain.invoke({"question": "What is OpenTelemetry?"})

What Gets Captured

The LangChain instrumentation automatically captures comprehensive telemetry following the OpenTelemetry Semantic Conventions for GenAI, including full conversation context, token usage metrics, and chain execution flows.

Example captured attributes include gen_ai.usage.input_tokens and gen_ai.usage.output_tokens for cost tracking, gen_ai.prompt.0.content and gen_ai.completion.0.content for debugging conversations, and gen_ai.request.model for tracking which models are being used.

Verification

After running your instrumented application:

1. Navigate to Traces in Dash0
2. Filter by your service name (e.g., my-langchain-app)
3. Look for traces with operation names like:
   • ChatAnthropic.invoke
   • RunnableSequence.invoke
   • ChatPromptTemplate.invoke
   • StrOutputParser.parse

References

• OpenTelemetry Python Auto-Instrumentation
• OpenTelemetry LangChain Instrumentation
• LangChain Documentation
• OpenTelemetry Semantic Conventions for GenAI