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.
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:
Note
The example is built using Gradle. You might need to amend the directory structure andpom.xml
to run using 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.1");
implementation("io.opentelemetry:opentelemetry-sdk:1.42.1");
implementation("io.opentelemetry:opentelemetry-exporter-logging:1.42.1");
implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.42.1");
implementation("io.opentelemetry.instrumentation:opentelemetry-java-http-client:2.8.0-alpha");
}
<dependencies>
<dependency>
<groupId>io.opentelemetry.instrumentation</groupId>
<artifactId>opentelemetry-java-http-client</artifactId>
<version>2.8.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 the SDK to export to one or more telemetry backends.
For existing library instrumentations, also see Java agent.
Feedback
Was this page helpful?
Thank you. Your feedback is appreciated!
Please let us know how we can improve this page. Your feedback is appreciated!