Exporting OpenTelemetry Data to Azure Monitor with Java

OpenTelemetry provides vendor-neutral instrumentation for distributed tracing, and Azure Monitor offers powerful analytics for telemetry data. The Azure Monitor OpenTelemetry Exporter for Java bridges these systems, enabling Java applications instrumented with OpenTelemetry to send telemetry to Application Insights. However, this package is deprecated in favor of the autoconfigure package, which provides simplified setup and automatic instrumentation. This article covers both the legacy exporter and migration guidance.

What This Skill Does

The azure-monitor-opentelemetry-exporter-java skill provided manual configuration for exporting OpenTelemetry telemetry to Azure Monitor, but has been deprecated. The recommended replacement is azure-monitor-opentelemetry-autoconfigure, which provides automatic configuration, built-in instrumentation for popular Java libraries, simplified setup with minimal code, better integration with OpenTelemetry SDK, and continuous updates with new features and improvements.

This skill enabled manual span creation with custom attributes, nested span hierarchies for complex operations, exception recording on spans, custom span processors for telemetry enrichment, and metrics export through OpenTelemetry's meter API. However, all these capabilities are better supported in the autoconfigure package.

Getting Started

For new projects, use the autoconfigure package:

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-monitor-opentelemetry-autoconfigure</artifactId>
    <version>LATEST</version>
</dependency>

Set your Application Insights connection string:

export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=xxx;IngestionEndpoint=https://xxx.in.applicationinsights.azure.com/"

Initialize with a single call:

import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
import io.opentelemetry.api.OpenTelemetry;
import com.azure.monitor.opentelemetry.exporter.AzureMonitorExporter;

AutoConfiguredOpenTelemetrySdkBuilder sdkBuilder = AutoConfiguredOpenTelemetrySdk.builder();
AzureMonitorExporter.customize(sdkBuilder);
OpenTelemetry openTelemetry = sdkBuilder.build().getOpenTelemetrySdk();

Key Features

Automatic Instrumentation: The autoconfigure package automatically instruments popular Java libraries including HTTP clients, database drivers, messaging systems, and web frameworks. This eliminates manual instrumentation for common scenarios.

Simplified Configuration: Connection strings from environment variables automatically configure the exporter. No manual exporter creation or SDK builder configuration required for basic scenarios.

Span Creation: Create spans representing units of work with timing information, custom attributes for context, exception recording for error tracking, and automatic parent-child relationships through context propagation.

Custom Span Processors: Implement span processors that intercept span lifecycle events for adding attributes to all spans, filtering spans before export, sampling decisions, or enriching telemetry with environment data.

Metrics Support: Export metrics through OpenTelemetry's meter API with counters for cumulative values, histograms for distributions, and automatic integration with Azure Monitor's customMetrics table.

Usage Examples

Creating spans with custom attributes (works with both legacy and autoconfigure):

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

Tracer tracer = openTelemetry.getTracer("com.example.myapp");

Span span = tracer.spanBuilder("processOrder")
    .setAttribute("order.id", "12345")
    .setAttribute("customer.tier", "premium")
    .startSpan();

try (Scope scope = span.makeCurrent()) {
    span.setAttribute("items.count", 3);
    processOrder();
} catch (Exception e) {
    span.recordException(e);
    throw e;
} finally {
    span.end();
}

Implementing custom span processor for telemetry enrichment:

import io.opentelemetry.sdk.trace.SpanProcessor;
import io.opentelemetry.sdk.trace.ReadWriteSpan;
import io.opentelemetry.api.common.AttributeKey;

SpanProcessor enrichmentProcessor = new SpanProcessor() {
    @Override
    public void onStart(Context context, ReadWriteSpan span) {
        span.setAttribute("environment", System.getenv("ENV"));
        span.setAttribute("version", "1.0.0");
    }
    // ... other methods
};

sdkBuilder.addTracerProviderCustomizer(
    (sdkTracerProviderBuilder, configProperties) -> 
        sdkTracerProviderBuilder.addSpanProcessor(enrichmentProcessor)
);

Recording metrics for business KPIs:

import io.opentelemetry.api.metrics.Meter;
import io.opentelemetry.api.metrics.LongCounter;

Meter meter = openTelemetry.getMeter("com.example.myapp");

LongCounter orderCounter = meter.counterBuilder("orders.processed")
    .setDescription("Total orders processed")
    .build();

orderCounter.add(1, Attributes.of(
    AttributeKey.stringKey("status"), "completed"
));

Best Practices

Migrate to azure-monitor-opentelemetry-autoconfigure for new projects. The legacy exporter package receives minimal updates and lacks automatic instrumentation capabilities. The autoconfigure package provides better developer experience and ongoing improvements.

Set meaningful span names that describe operations clearly. Use descriptive names like "processPayment" or "fetchUserProfile" rather than generic names like "operation1". Clear names improve troubleshooting in Application Insights.

Add relevant attributes to spans for contextual debugging. Include identifiers, status codes, and business-relevant data. These attributes enable filtering and grouping in Azure Monitor queries.

Always end spans in finally blocks to ensure telemetry completeness even when exceptions occur. Unclosed spans don't export properly and leave gaps in distributed traces.

Record exceptions on spans when errors occur. Exception information appears in Application Insights' exceptions view with full stack traces and span context for debugging.

Use try-with-resources for scope management to automatically restore context. This pattern prevents context leaks that cause incorrect parent-child relationships in distributed traces.

Follow OpenTelemetry semantic conventions for standard attributes. Use conventional attribute names for HTTP requests, database queries, and messaging operations to ensure compatibility with Azure Monitor's analysis features.

When to Use This Skill

Use this skill (specifically the autoconfigure package) when building Java applications requiring distributed tracing across microservices. OpenTelemetry provides vendor-neutral instrumentation that works with Azure Monitor and other observability backends.

It's ideal for teams adopting OpenTelemetry standards who want flexibility to switch observability vendors. OpenTelemetry instrumentation decouples application code from specific monitoring backends.

The skill is valuable for complex distributed systems where request flows span multiple services. Distributed tracing visualizes request paths, identifies bottlenecks, and measures latency across service boundaries.

Use it when automatic instrumentation reduces manual telemetry code maintenance. The autoconfigure package instruments popular libraries without code changes, enabling faster onboarding of new services.

When Not to Use This Skill

Don't use the legacy exporter package for new projects. It's deprecated with minimal updates. Use azure-monitor-opentelemetry-autoconfigure instead for better functionality and ongoing support.

If you're building simple single-service applications without distributed tracing needs, Application Insights SDK provides simpler integration without OpenTelemetry overhead.

Avoid it when your team hasn't adopted OpenTelemetry standards. OpenTelemetry requires understanding of spans, traces, and context propagation. For teams unfamiliar with these concepts, Application Insights SDK offers gentler learning curve.

Don't use it for non-Java applications. OpenTelemetry has language-specific implementations for Python, .NET, JavaScript, and others, each with their own Azure Monitor exporters optimized for the platform.

Related Skills

• azure-monitor-opentelemetry-exporter-py - Export OpenTelemetry data from Python applications
• azure-mgmt-applicationinsights-dotnet - Manage Application Insights resources
• azure-monitor-query-java - Query exported telemetry data

Source

This skill is provided by Microsoft as part of the Azure SDK for Java. The package is deprecated in favor of azure-monitor-opentelemetry-autoconfigure. Learn more at the Maven Central page, review the migration guide, and explore the autoconfigure package for current best practices.