Using instrumentation libraries

When you develop an app, you might use third-party libraries and frameworks to accelerate your work. If you then instrument your app using OpenTelemetry, you might want to avoid spending additional time to manually add traces, logs, and metrics to the third-party libraries and frameworks you use.

Many libraries and frameworks already support OpenTelemetry or are supported through OpenTelemetry instrumentation, so that they can generate telemetry you can export to an observability back end.

If you are instrumenting an app or service that use third-party libraries or frameworks, follow these instructions to learn how to use natively instrumented libraries and instrumentation libraries for your dependencies.

Use natively instrumented libraries

If a library comes with OpenTelemetry support by default, you can get traces, metrics, and logs emitted from that library by adding and setting up the OpenTelemetry SDK with your app.

The library might require some additional configuration for the instrumentation. Go to the documentation for that library to learn more.

• Elasticsearch Java API Client
• Micrometer Tracing
• Quarkus

Use Instrumentation Libraries

If a library does not come with OpenTelemetry out of the box, you can use instrumentation libraries in order to generate telemetry data for a library or framework.

The Java agent for automatic instrumentation includes instrumentation libraries for many common Java frameworks. Most are turned on by default. If you need to turn off certain instrumentation libraries, you can suppress them.

If you use code-based instrumentation, you can leverage some instrumentation libraries for your dependencies standalone. To find out which standalone instrumentation libraries are available, take a look at this list. Follow the instructions of each instrumentation library to set them up.

Example app

The following example instruments an HTTP client application using library instrumentation which calls an HTTP server.

You can use the dice example app as HTTP server from Getting Started or you can create your own HTTP server.

Dependencies

Set up an environment in a new directory named java-simple-http-client. Inside the directory, create a file named build.gradle.kts with the following content:

• Gradle
• Maven

plugins {
  id("java")
  id("application")
}

application {
  mainClass.set("otel.SampleHttpClient")
}

sourceSets {
  main {
    java.setSrcDirs(setOf("."))
  }
}

repositories {
  mavenCentral()
}

dependencies {
    implementation("io.opentelemetry:opentelemetry-api:1.42.0");
    implementation("io.opentelemetry:opentelemetry-sdk:1.42.0");
    implementation("io.opentelemetry:opentelemetry-exporter-logging:1.42.0");
    implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.42.0");
    implementation("io.opentelemetry.instrumentation:opentelemetry-java-http-client:2.7.0-alpha");
}

<dependencies>
  <dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-java-http-client</artifactId>
    <version>2.7.0-alpha</version>
  </dependency>
</dependencies>

Setup

The following example shows how you can instrument external API calls using Java HTTP client library:

// SampleHttpClient.java
package otel;

import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
import io.opentelemetry.instrumentation.httpclient.JavaHttpClientTelemetry;
import java.net.http.HttpClient;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpHeaders;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public final class SampleHttpClient {
    //Init OpenTelemetry
    private static final OpenTelemetry openTelemetry = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk();

    //Use this HttpClient implementation for making standard http client calls.
    public HttpClient createTracedClient(OpenTelemetry openTelemetry) {
        return JavaHttpClientTelemetry.builder(openTelemetry).build().newHttpClient(createClient());
    }

    //your configuration of the Java HTTP Client goes here:
    private HttpClient createClient() {
        return HttpClient.newBuilder().build();
    }

    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .GET()
            .uri(URI.create(System.getenv().getOrDefault("EXTERNAL_API_ENDPOINT", "http://localhost:8080/rolldice")))
            //.setHeader("User-Agent", "Java 11 HttpClient Bot") // add request header
            .build();

        SampleHttpClient s = new SampleHttpClient();
        HttpResponse<String> response = s.createTracedClient(openTelemetry).send(request, HttpResponse.BodyHandlers.ofString());
        // print response headers
        HttpHeaders headers = response.headers();
        headers.map().forEach((k, v) -> System.out.println(k + ":" + v));
        // print status code
        System.out.println(response.statusCode());
        // print response body
        System.out.println(response.body());

    }
}

Run

Set the EXTERNAL_API_ENDPOINT environment variable to specify the external API endpoint. By default, it points to http://localhost:8080/rolldice, where example dice app is running.

To check your code, run the app:

env \
OTEL_SERVICE_NAME=http-client \
OTEL_TRACES_EXPORTER=logging \
OTEL_METRICS_EXPORTER=logging \
OTEL_LOGS_EXPORTER=logging \
gradle run

When you run the app, the instrumentation libraries do the following:

• Start a new trace.
• Generate a span that represents the request made to the external API endpoint.
• If you use an instrumented HTTP server, as in the dice app, more trace spans are generated with the same trace ID.

Available instrumentation libraries

For a full list of instrumentation libraries, see opentelemetry-java-instrumentation.

Next steps

After you’ve set up instrumentation libraries, you might want to add additional instrumentation to collect custom telemetry data.

You might also want to configure an appropriate exporter to export your telemetry data to one or more telemetry backends.

For existing library instrumentations, also see Java agent.

opentelemetry-java