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.

• Azure SDK Instrumentation
• MassTransit .NET client
• ThrottlingTroll

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.

For example, the instrumentation library for ASP.NET Core will automatically create spans and metrics based on the inbound HTTP requests.

Setup

Each instrumentation library is a NuGet package, and installing them is typically done like so:

dotnet add package OpenTelemetry.Instrumentation.{library-name-or-type}

It is typically then registered at application startup time, such as when creating a TracerProvider.

Note on Versioning

The Semantic Conventions (Standards) for attribute names are not currently stable therefore the instrumentation library is currently not in a released state. That doesn’t mean that the functionality itself is not stable, only that the names of some of the attributes may change in the future, some may be added, some may be removed. This means that you need to use the --prerelease flag, or install a specific version of the package

Example with ASP.NET Core and HttpClient

As an example, here’s how you can instrument inbound and output requests from an ASP.NET Core app.

First, get the appropriate packages of OpenTelemetry Core:

dotnet add package OpenTelemetry
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Exporter.Console

Then you can install the instrumentation libraries:

dotnet add package OpenTelemetry.Instrumentation.AspNetCore --prerelease
dotnet add package OpenTelemetry.Instrumentation.Http --prerelease

Next, configure each instrumentation library at startup and use them!

using OpenTelemetry.Resources;
using OpenTelemetry.Trace;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOpenTelemetry()
  .WithTracing(b =>
  {
      b
      .AddHttpClientInstrumentation()
      .AddAspNetCoreInstrumentation();
  });

var app = builder.Build();

var httpClient = new HttpClient();

app.MapGet("/hello", async () =>
{
    var html = await httpClient.GetStringAsync("https://example.com/");
    if (string.IsNullOrWhiteSpace(html))
    {
        return "Hello, World!";
    }
    else
    {
        return "Hello, World!";
    }
});

app.Run();

When you run this code and access the /hello endpoint, the instrumentation libraries will:

• Start a new trace
• Generate a span representing the request made to the endpoint
• Generate a child span representing the HTTP GET made to https://example.com/

If you add more instrumentation libraries, then you get more spans for each of those.

Available instrumentation libraries

A full list of instrumentation libraries produced by OpenTelemetry is available from the opentelemetry-dotnet repository.

You can also find more instrumentations available in the registry.

Next steps

After you have set up instrumentation libraries, you may want to add your own instrumentation to your code, to collect custom telemetry data.

If you are using .NET Framework 4.x instead of modern .NET, refer to the .NET Framework docs to configure OpenTelemetry and instrumentation libraries on .NET Framework.

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

You can also check the automatic instrumentation for .NET, which is currently in beta.