# Using instrumentation libraries

LLMS index: [llms.txt](/llms.txt)

---


アプリを開発する際、作業を加速するためにサードパーティのライブラリやフレームワークを使用することがあるでしょう。
OpenTelemetryを使用してアプリを計装する場合、使用するサードパーティのライブラリやフレームワークにトレース、ログ、メトリクスを手動で追加するために時間を費やすことを避けたいことがあります。

多くのライブラリやフレームワークはすでにOpenTelemetryをサポートしているか、OpenTelemetryの[計装](/docs/concepts/instrumentation/libraries/)を介してサポートされているため、テレメトリーを生成してオブザーバビリティバックエンドにエクスポートできます。

サードパーティのライブラリやフレームワークを使用しているアプリやサービスを計装する場合は、このページの手順に従って、ネイティブに計装されたライブラリと依存関係の計装ライブラリの使用方法を学んでください。

## ネイティブに計装されたライブラリを使用する {#use-natively-instrumented-libraries}

デフォルトでOpenTelemetryサポートが付属しているライブラリの場合、アプリにOpenTelemetry SDKを追加して設定することで、そのライブラリから発行されるトレース、メトリクス、ログを取得できます。

ライブラリによっては、計装のために追加の構成が必要な場合があります。
詳細はライブラリごとのドキュメントをご覧ください。
{{__hugo_ctx/}}


- [Azure SDK Instrumentation](https://learn.microsoft.com/en-us/azure/azure-monitor/app/opentelemetry-enable)
- [FusionCache .NET caching library](https://github.com/ZiggyCreatures/FusionCache/blob/main/docs/OpenTelemetry.md)
- [MassTransit .NET client](https://masstransit.io/documentation/configuration/observability)
- [nservicebus OpenTelemetry Integration](https://docs.particular.net/nservicebus/operations/opentelemetry)
- [ThrottlingTroll](https://github.com/ThrottlingTroll/ThrottlingTroll/wiki#telemetry)






<div class="alert alert-info" role="alert">



OpenTelemetryがネイティブに統合された.NETライブラリをご存知でしたら、[お知らせください][let us know]。

</div>




[let us know]: https://github.com/open-telemetry/opentelemetry.io/issues/new/choose
{{__hugo_ctx/}}



## Use Instrumentation Libraries

If a library does not come with OpenTelemetry out of the box, you can use
[instrumentation libraries](/docs/specs/otel/glossary/#instrumentation-library)
in order to generate telemetry data for a library or framework.

For example,
[the instrumentation library for ASP.NET Core](https://www.nuget.org/packages/OpenTelemetry.Instrumentation.AspNetCore)
will automatically create [spans](/docs/concepts/signals/traces/#spans) and
[metrics](/docs/concepts/signals/metrics) based on the inbound HTTP requests.

## Setup

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

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

It is typically then registered at application startup time, such as when
creating a [TracerProvider](/docs/concepts/signals/traces/#tracer-provider).

## 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:

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

Then you can install the instrumentation libraries:

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

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

```csharp
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](/ecosystem/registry/?language=dotnet&component=instrumentation).

## Next steps

After you have set up instrumentation libraries, you may want to add your own
[instrumentation](/docs/languages/dotnet/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](/docs/languages/dotnet/netframework) to configure
OpenTelemetry and instrumentation libraries on .NET Framework.

You'll also want to configure an appropriate exporter to
[export your telemetry data](/docs/languages/dotnet/exporters) to one or more
telemetry backends.

You can also check the
[automatic instrumentation for .NET](/docs/zero-code/dotnet), which is currently
in beta.

[opentelemetry-dotnet]: https://github.com/open-telemetry/opentelemetry-dotnet