How to Add Labels to Prometheus Metrics from .NET Application Sending OpenTelemetry to a Collector

Are you tired of looking at a sea of unlabeled metrics in your Prometheus dashboard, wondering which ones belong to which .NET application? Do you want to take your observability game to the next level by adding meaningful labels to your metrics? Look no further! In this article, we’ll guide you through the process of adding labels to Prometheus metrics from a .NET application sending OpenTelemetry to a collector.

What are Labels and Why Do They Matter?

Labels are key-value pairs attached to metrics that provide additional context about the data. They help you filter, group, and aggregate metrics in Prometheus, making it easier to identify trends, troubleshoot issues, and optimize performance. Think of labels as metadata that enriches your metrics, allowing you to ask more nuanced questions about your application’s behavior.

For example, you might want to label your metrics with the application version, environment, or deployment region. This way, you can compare performance across different versions, environments, or regions, and make data-driven decisions to improve your application.

Prerequisites

To follow along, you’ll need:

• A .NET application (we’ll use .NET 6.0 as an example)
• OpenTelemetry .NET SDK (installed via NuGet)
• A Prometheus collector (we’ll use the OpenTelemetry Collector as an example)
• A Prometheus instance (local or remote)

Step 1: Configure OpenTelemetry .NET SDK

First, you need to configure the OpenTelemetry .NET SDK to send metrics to your collector. Add the following code to your .NET application:

using OpenTelemetry;
using OpenTelemetry.Trace;

// Create a new OpenTelemetry instance
var otel = Sdk.CreateTracerProviderBuilder()
    .AddSource("MyApp")
    .AddHttpClientInstrumentation()
    .AddOtlpExporter(o =>
    {
        o.Endpoint = new Uri("https://your-collector-url.com:55678");
        o.Protocol = OtlpExportProtocol.HttpProto);
    })
    .Build();

// Set the global tracer provider
GlobalTracer.SetTracerProvider(otel);

This code sets up an OpenTelemetry instance with HTTP client instrumentation and configures the OTLP exporter to send metrics to your collector.

Step 2: Add Labels to Metrics

To add labels to your metrics, you’ll need to create a custom metric and attach labels to it. Let’s create a simple counter metric to track the number of requests:

using OpenTelemetry.Metrics;

// Create a new counter metric
var counter = otel.GetMeter("MyApp").CreateCounter("requests_total", "Requests processed by the application");

// Create a custom metric with labels
var requestCounter = counter.BindTo(new[] { new KeyValuePair("environment", "dev"), new KeyValuePair("app_version", "1.0.0") });

// Increment the counter
requestCounter.Add(1);

In this example, we create a counter metric called “requests_total” and attach two labels: “environment” with value “dev” and “app_version” with value “1.0.0”. When you increment the counter, the labels will be sent along with the metric to the collector.

Step 3: Configure the Collector

Next, you need to configure the collector to forward metrics to your Prometheus instance. Add the following configuration to your collector:

receivers:
  otlp:
    protocols:
      http:
        endpoint: ":55678"

exporters:
  prometheus:
    endpoint: "http://your-prometheus-url.com:9090"

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: []
      exporters: [prometheus]

This configuration sets up an OTLP receiver to receive metrics from your .NET application and forwards them to your Prometheus instance using the Prometheus exporter.

Step 4: Verify Labels in Prometheus

Finally, head over to your Prometheus dashboard and verify that the labels are being sent correctly. You should see the “requests_total” metric with the attached labels:

Metric	Value	Labels
requests_total	1	environment=”dev”, app_version=”1.0.0″

Voilà! You’ve successfully added labels to your Prometheus metrics from your .NET application sending OpenTelemetry to a collector.

Tips and Variations

Here are some additional tips and variations to help you get the most out of labeling your metrics:

• Dynamic labels**: Use dynamic labels that are generated at runtime, such as user IDs or request IDs, to add more context to your metrics.
• Label cardinality**: Be mindful of label cardinality, which refers to the number of unique label combinations. High cardinality can lead to performance issues and increased storage requirements.
• Label naming conventions**: Establish a consistent naming convention for your labels to make them easy to understand and maintain.
• Metrics correlation**: Use labels to correlate metrics across different services or applications, enabling more comprehensive insights into your system.

Conclusion

Adding labels to Prometheus metrics from your .NET application sending OpenTelemetry to a collector is a powerful way to enrich your metrics and gain deeper insights into your application’s behavior. By following these steps and tips, you’ll be well on your way to creating a more observable and optimized system.

Remember to experiment with different label combinations and explore the various ways you can use labels to segment, filter, and analyze your metrics. Happy observability adventuring!

Frequently Asked Question

Get the inside scoop on how to add labels to Prometheus metrics from a .NET application sending OpenTelemetry to a collector!