OpenTelemetry Integration Guide

OpenTelemetry is a vendor-neutral standard for observability that provides a unified way to capture traces, metrics, and logs. LangWatch is fully compatible with OpenTelemetry, allowing you to use any OpenTelemetry-compatible library in any programming language to capture your LLM traces and send them to LangWatch. This guide shows you how to set up OpenTelemetry instrumentation in any language and configure it to export traces to LangWatch’s OTEL API endpoint.

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
If using a service API key, also obtain your LANGWATCH_PROJECT_ID from your project settings
Install the OpenTelemetry SDK for your programming language

LangWatch OTEL API Endpoint

LangWatch provides a standard OpenTelemetry Protocol (OTLP) endpoint for receiving traces:

https://app.langwatch.ai/api/otel/v1/traces

This endpoint accepts OTLP over HTTP and gRPC protocols, making it compatible with all OpenTelemetry SDKs.

General Setup Pattern

The setup follows this general pattern across all languages:

Install OpenTelemetry SDK for your language
Configure the OTLP exporter to point to LangWatch’s endpoint
Set up authentication using your API key
Initialize the trace provider with the exporter
Instrument your LLM calls using available instrumentation libraries

Language-Specific Examples

Java
C#/.NET

Install OpenTelemetry

Add to your pom.xml:

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-sdk</artifactId>
    <version>1.32.0</version>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-otlp</artifactId>
    <version>1.32.0</version>
</dependency>

Configure the exporter

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
import io.opentelemetry.sdk.trace.export.OtlpHttpSpanExporter;
import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;

public class OpenTelemetryConfig {
    public static OpenTelemetry initOpenTelemetry() {
        OtlpHttpSpanExporter spanExporter = OtlpHttpSpanExporter.builder()
            .setEndpoint("https://app.langwatch.ai/api/otel/v1/traces")
            .addHeader("Authorization", "Bearer " + System.getenv("LANGWATCH_API_KEY"))
            .build();

        SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
            .addSpanProcessor(BatchSpanProcessor.builder(spanExporter).build())
            .setResource(Resource.getDefault().toBuilder()
                .put(ResourceAttributes.SERVICE_NAME, "my-service")
                .build())
            .build();

        return OpenTelemetrySdk.builder()
            .setTracerProvider(sdkTracerProvider)
            .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance()))
            .buildAndRegisterGlobal();
    }
}

Instrument your LLM calls

import io.opentelemetry.api.trace.Tracer;

public class LLMService {
    private final Tracer tracer = OpenTelemetry.getGlobalTracer("my-service");

    public void callLLM() {
        var span = tracer.spanBuilder("llm-call").startSpan();
        try (var scope = span.makeCurrent()) {
            // Your LLM call here
        } finally {
            span.end();
        }
    }
}

Install OpenTelemetry

dotnet add package OpenTelemetry
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol

Configure the exporter

using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

public class Program
{
    public static void Main(string[] args)
    {
        var builder = Sdk.CreateTracerProviderBuilder()
            .SetResourceBuilder(ResourceBuilder.CreateDefault()
                .AddService(serviceName: "my-service"))
            .AddOtlpExporter(opts => opts
                .Endpoint = new Uri("https://app.langwatch.ai/api/otel/v1/traces")
                .Headers = "Authorization=Bearer " + Environment.GetEnvironmentVariable("LANGWATCH_API_KEY"))
            .Build();
    }
}

Instrument your LLM calls

using OpenTelemetry.Trace;

public class LLMService
{
    private readonly Tracer _tracer = TracerProvider.Default.GetTracer("my-service");

    public async Task<string> CallLLMAsync()
    {
        using var span = _tracer.StartActiveSpan("llm-call");
        // Your LLM call here
        return "response";
    }
}

Available Instrumentation Libraries

LangWatch works with any OpenTelemetry-compatible instrumentation library. Here are some popular options:

Java Libraries

Spring AI: Spring AI provides built-in observability support for AI applications, including OpenTelemetry integration for tracing LLM calls and AI operations
OpenTelemetry Java SDK: Use OpenTelemetry Java SDK with custom spans

.NET Libraries

Azure Monitor OpenTelemetry: Azure Monitor OpenTelemetry provides comprehensive OpenTelemetry support for .NET applications, including automatic instrumentation and Azure-specific features
OpenTelemetry .NET SDK: Use OpenTelemetry .NET SDK with custom instrumentation

Manual Instrumentation

If no automatic instrumentation is available for your LLM provider, you can manually create spans:

import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.context.Context;

public class LLMService {
    private final Tracer tracer = OpenTelemetry.getGlobalTracer("my-service");

    public String callLLM(String prompt) {
        Span span = tracer.spanBuilder("llm-call").startSpan();
        
        try (var scope = span.makeCurrent()) {
            // Add relevant attributes
            span.setAttribute("llm.provider", "custom-provider");
            span.setAttribute("llm.model", "gpt-5-mini");
            span.setAttribute("llm.prompt", prompt);
            
            // Your LLM call here
            String response = yourLLMClient.generate(prompt);
            
            return response;
        } finally {
            span.end();
        }
    }
}

Environment Variables

Set these environment variables for authentication:

export LANGWATCH_API_KEY="your-api-key-here"
export LANGWATCH_PROJECT_ID="your-project-id-here"  # Required for service API keys

LANGWATCH_PROJECT_ID is required when using a service API key (e.g. for CI/CD or multi-project setups). Project API keys obtained from the project settings page already have the project context built in.

Verification

After setting up your instrumentation, you can verify that traces are being sent to LangWatch by:

Making a few LLM calls in your application
Checking the LangWatch dashboard for incoming traces
Looking for spans with your service name and LLM call details

Troubleshooting

Traces not appearing in LangWatch

Verify your API key is correct and has proper permissions
Check that the endpoint URL is correct: https://app.langwatch.ai/api/otel/v1/traces
Ensure your application is making LLM calls after instrumentation is set up
Check network connectivity to the LangWatch endpoint

Authentication errors

Verify the Authorization header format: Bearer YOUR_API_KEY
Ensure the API key is valid and not expired
Check that the API key has the necessary permissions for trace ingestion

Performance issues

Consider using batch span processors for high-volume applications
Implement sampling to reduce the number of traces sent
Use async span processors to avoid blocking your application

Next Steps

Explore the LangWatch dashboard to view your traces
Set up custom evaluations for your LLM calls

​Prerequisites

​LangWatch OTEL API Endpoint

​General Setup Pattern

​Language-Specific Examples

​Available Instrumentation Libraries

​Java Libraries

​.NET Libraries

​Manual Instrumentation

​Environment Variables

​Verification

​Troubleshooting

​Next Steps

Prerequisites

LangWatch OTEL API Endpoint

General Setup Pattern

Language-Specific Examples

Available Instrumentation Libraries

Java Libraries

.NET Libraries

Manual Instrumentation

Environment Variables

Verification

Troubleshooting

Next Steps