OpenTelemetry Integration Guide

OpenTelemetry is a standard protocol for tracing, and LangWatch is fully compatible with OpenTelemetry, you can use any OpenTelemetry compatible library to capture your LLM traces and send them to LangWatch.

This guide demonstrates the OpenTelemetry integration using Python, but the same principles apply to integration with OpenTelemetry instrumentation in other languages.

Protip: wanna to get started even faster? Copy our llms.txt and ask an AI to do this integration

Prerequisites

Obtain your LANGWATCH_API_KEY from the LangWatch dashboard.

Installation

pip install opentelemetry

Configuration

Set up LangWatch as the OpenTelemetry exporter endpoint:

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

# Set up OpenTelemetry trace provider with LangWatch as the endpoint
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(
    SimpleSpanProcessor(
        OTLPSpanExporter(
            endpoint="https://app.langwatch.ai/api/otel/v1/traces",
            headers={"Authorization": "Bearer " + os.environ["LANGWATCH_API_KEY"]},
        )
    )
)
# Optionally, you can also print the spans to the console.
tracer_provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))

Capturing LLM Traces

Currently, there are different open initiatives for LLM instrumentation libraries, here we show some examples on how to capture LLM traces with a couple of them.

Installation:

pip install openinference-instrumentation-openai

Then, instrument your OpenAI calls:

from openinference.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-openai

Then, instrument your OpenAI calls:

from openinference.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-bedrock

Then, instrument your AWS calls:

from openinference.instrumentation.bedrock import BedrockInstrumentor

BedrockInstrumentor().instrument()

That’s it! You can now see the traces for your AWS Bedrock calls in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-dspy

Then, instrument your DSPy calls:

from openinference.instrumentation.dspy import DSPyInstrumentor

DSPyInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your DSPy calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-haystack

Then, instrument your Haystack calls:

from openinference.instrumentation.haystack import HaystackInstrumentor

HaystackInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your Haystack calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-langchain

Then, instrument your LangChain calls:

from openinference.instrumentation.langchain import LangChainInstrumentor

LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your LangChain calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-crewai openinference-instrumentation-langchain

Then, instrument your LangChain calls. CrewAI uses LangChain under the hood, so we instrument both:

from openinference.instrumentation.crewai import CrewAIInstrumentor
from openinference.instrumentation.langchain import LangChainInstrumentor

CrewAIInstrumentor().instrument(tracer_provider=tracer_provider)
LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your CrewAI calls in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-autogen

Note: The Autogen integration is currently experimental and may have limitations or unexpected behavior.

Then, instrument Autogen:

from openinference.instrumentation.autogen import AutogenInstrumentor

AutogenInstrumentor().instrument()

That’s it! You can now see the traces from inside Autogen in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-openai

Then, instrument your OpenAI calls:

from openinference.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-openai

Then, instrument your OpenAI calls:

from openinference.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-bedrock

Then, instrument your AWS calls:

from openinference.instrumentation.bedrock import BedrockInstrumentor

BedrockInstrumentor().instrument()

That’s it! You can now see the traces for your AWS Bedrock calls in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-dspy

Then, instrument your DSPy calls:

from openinference.instrumentation.dspy import DSPyInstrumentor

DSPyInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your DSPy calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-haystack

Then, instrument your Haystack calls:

from openinference.instrumentation.haystack import HaystackInstrumentor

HaystackInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your Haystack calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-langchain

Then, instrument your LangChain calls:

from openinference.instrumentation.langchain import LangChainInstrumentor

LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your LangChain calls in the LangWatch dashboard:

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-crewai openinference-instrumentation-langchain

Then, instrument your LangChain calls. CrewAI uses LangChain under the hood, so we instrument both:

from openinference.instrumentation.crewai import CrewAIInstrumentor
from openinference.instrumentation.langchain import LangChainInstrumentor

CrewAIInstrumentor().instrument(tracer_provider=tracer_provider)
LangChainInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your CrewAI calls in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install openinference-instrumentation-autogen

Note: The Autogen integration is currently experimental and may have limitations or unexpected behavior.

Then, instrument Autogen:

from openinference.instrumentation.autogen import AutogenInstrumentor

AutogenInstrumentor().instrument()

That’s it! You can now see the traces from inside Autogen in the LangWatch dashboard.

Capturing Metadata

You can use OpenInference’s using_attributes context manager to capture additional information for your LLM calls, such as the user_id, session_id (equivalent to thread id), tags and metadata:

from openinference.instrumentation import using_attributes

def main():
  with using_attributes(
      session_id="my-test-session",
      user_id="my-test-user",
      tags=["tag-1", "tag-2"],
      metadata={"foo": "bar"},
  ):
      # Your LLM call

Installation:

pip install opentelemetry-instrumentation-openai

Then, instrument your OpenAI calls:

from opentelemetry.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Installation:

pip install opentelemetry-instrumentation-openai

Then, instrument your OpenAI calls:

from opentelemetry.instrumentation.openai import OpenAIInstrumentor

OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your OpenAI calls in the LangWatch dashboard:

Installation:

pip install opentelemetry-instrumentation-anthropic

Then, instrument your Anthropic calls:

from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor

AnthropicInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your Anthropic calls in the LangWatch dashboard:

Installation:

pip install opentelemetry-instrumentation-langchain

Then, instrument your LangChain calls:

from opentelemetry.instrumentation.langchain import LangchainInstrumentor

LangchainInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your LangChain calls in the LangWatch dashboard:

Installation:

pip install opentelemetry-instrumentation-llamaindex

Then, instrument your LlamaIndex calls:

from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor

LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)

That’s it! You can now see the traces for your LlamaIndex calls in the LangWatch dashboard.

LLM Observability

LLM Evaluation

LLM Development

API Endpoints

Support

OpenTelemetry Integration Guide

Prerequisites

Installation

Configuration

Capturing LLM Traces

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

LLM Observability

LLM Evaluation

LLM Development

API Endpoints

Support

​Prerequisites

​Installation

​Configuration

​Capturing LLM Traces

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

​Capturing Metadata

Prerequisites

Installation

Configuration

Capturing LLM Traces

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata

Capturing Metadata