OpenTelemetry looks promising for .NET application monitoring

If you follow cloud-native .NET development, OpenTelemetry is a project worth keeping an eye on.

OpenTelemetry is an observability framework focused on collecting traces, metrics, and logs from distributed applications. The project combines earlier efforts such as OpenTracing and OpenCensus into a single standard approach for telemetry collection.

From a .NET developer perspective, the interesting part is standardized instrumentation.

Instead of every monitoring vendor requiring its own SDK and APIs, applications can emit telemetry through OpenTelemetry compatible libraries and export the data to different backends.

A simple ASP.NET Core setup already starts looking fairly straightforward:

public void ConfigureServices(IServiceCollection services)
{
    services.AddOpenTelemetryTracing(builder =>
    {
        builder
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation();
    });
}

This automatically captures incoming ASP.NET Core requests and outgoing HTTP calls.

One practical benefit is distributed tracing. In a microservices environment, a single request may pass through several APIs, queues, databases, and external services before completing.

With distributed tracing enabled, it becomes easier to follow the entire request flow across service boundaries.

For example:

• frontend API receives request
• backend service processes data
• SQL Server query executes
• external REST API is called.

Instead of debugging isolated logs from each service separately, the trace can connect the operations together.

OpenTelemetry is still evolving at this stage, and many libraries are early preview quality. However, the direction looks promising because the effort is vendor-neutral and supported by multiple cloud and monitoring providers.

It's also worth remembering that OpenTelemetry itself is not a monitoring backend. It collects and exports telemetry data, while separate systems such as Jaeger, Zipkin, Prometheus, or cloud monitoring platforms visualize the results.

For ASP.NET Core applications moving toward containers and microservices, having a common telemetry model could simplify monitoring significantly compared to maintaining multiple vendor-specific SDKs. This might eventually replace Application Insights.