Getting Started with OpenTelemetry: Observability Made Easy

What is OpenTelemetry?

OpenTelemetry is an open-source observability framework that provides a unified way to collect, process, and export telemetry data such as traces, metrics, and logs. It is designed to help developers monitor and debug distributed systems by providing insights into application performance and behavior.

With OpenTelemetry, you can instrument your applications to gain visibility into how requests flow through your system, identify bottlenecks, and troubleshoot issues effectively.

Why Use OpenTelemetry?

Here are some key benefits of using OpenTelemetry:

1. Unified Observability: Collect traces, metrics, and logs using a single framework.
2. Vendor-Neutral: Export telemetry data to any backend, such as Azure Monitor, Grafana, or Prometheus.
3. Standardized APIs: Use consistent APIs and SDKs across multiple programming languages.
4. Extensibility: Easily extend OpenTelemetry to meet your specific observability needs.
5. Community-Driven: Backed by a large and active open-source community.

Key Components of OpenTelemetry

OpenTelemetry consists of the following core components:

1. Traces: Capture the lifecycle of a request as it flows through your system. Traces help you understand dependencies and latency.
2. Metrics: Collect numerical data, such as request counts, CPU usage, and memory consumption, to monitor system health.
3. Logs: Record discrete events, such as errors or state changes, to provide additional context for debugging.

Setting Up OpenTelemetry in .NET

Here’s how you can get started with OpenTelemetry in a .NET application:

Step 1: Install the Required NuGet Packages

Run the following commands to install the OpenTelemetry libraries:

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

Step 2: Configure OpenTelemetry in Your Application

Add the following code to your Program.cs or Startup.cs file:

using OpenTelemetry;
using OpenTelemetry.Trace;
using OpenTelemetry.Metrics;

var builder = WebApplication.CreateBuilder(args);

// Add OpenTelemetry tracing and metrics
builder.Services.AddOpenTelemetry()
    .WithTracing(tracerProviderBuilder =>
    {
        tracerProviderBuilder
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddConsoleExporter(); // Export traces to the console
    })
    .WithMetrics(metricsProviderBuilder =>
    {
        metricsProviderBuilder
            .AddAspNetCoreInstrumentation()
            .AddRuntimeInstrumentation()
            .AddConsoleExporter(); // Export metrics to the console
    });

var app = builder.Build();

app.MapGet("/", () => "Hello, OpenTelemetry!");

app.Run();

Step 3: Run Your Application

Start your application and observe the telemetry data in the console. You’ll see traces and metrics being logged as requests are processed.

Aspire and how to view Telemetry

If your .NET code is .Net 8 or higher you can use Aspire which configures OpenTelemetry for free! Check out Getting started with .Net Aspire . Once Aspire is setup, you will be able to see Logs, Traces and Metrics in the Aspire Dashboard.

Another popular way to view your data is Grafana, where you can create custom dashboards. I have talked about adding Logs to Grafana recently.

There are lots of other ways to view your data, like Application Insights, DataDog, Jaeger, New Relic and many more.

But you are not tied to one solution, you can send your data to more than one of these if you wish.

Conclusion

OpenTelemetry simplifies observability by providing a unified framework for collecting traces, metrics, and logs. Whether you’re building microservices, monitoring distributed systems, or debugging performance issues, OpenTelemetry is a powerful tool to have in your arsenal.

Start using OpenTelemetry today and gain deeper insights into your applications!

Have you tried OpenTelemetry? Share your experiences and tips in the comments below!