Opentelemetry

// Program.csvar builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()    .ConfigureResource(resource => resource        .AddService(            serviceName: builder.Environment.ApplicationName,            serviceVersion: "1.0.0"))    .WithTracing(tracing => tracing        .AddAspNetCoreInstrumentation()        .AddHttpClientInstrumentation()        .AddEntityFrameworkCoreInstrumentation()        .AddSource("MyApp.Orders"))    .WithMetrics(metrics => metrics        .AddAspNetCoreInstrumentation()        .AddHttpClientInstrumentation()        .AddRuntimeInstrumentation()        .AddMeter("MyApp.Orders"))    .WithLogging()             // no per-signal exporter here —    .UseOtlpExporter();        // UseOtlpExporter covers all three signals
// UseOtlpExporter replaces per-signal AddOtlpExporter calls. Never combine// the two — mixing them throws NotSupportedException (see Anti-patterns).

public sealed class OrderMetrics{    private readonly Counter<int> _ordersCreated;    private readonly Histogram<double> _orderDuration;    private readonly UpDownCounter<int> _activeOrders;    private readonly Gauge<double> _queueDepth;
    public OrderMetrics(IMeterFactory meterFactory)    {        var meter = meterFactory.Create("MyApp.Orders");
        _ordersCreated = meter.CreateCounter<int>(            "myapp.orders.created", "{orders}", "Number of orders created");
        _orderDuration = meter.CreateHistogram<double>(            "myapp.orders.duration", "s", "Order processing duration",            advice: new InstrumentAdvice<double>            {                HistogramBucketBoundaries = [0.01, 0.05, 0.1, 0.5, 1, 5, 10]            });
        _activeOrders = meter.CreateUpDownCounter<int>(            "myapp.orders.active", "{orders}", "Currently active orders");
        _queueDepth = meter.CreateGauge<double>(            "myapp.orders.queue_depth", "{items}", "Current queue depth");    }
    public void OrderCreated() => _ordersCreated.Add(1);    public void RecordDuration(double seconds) => _orderDuration.Record(seconds);    public void OrderStarted() => _activeOrders.Add(1);    public void OrderCompleted() => _activeOrders.Add(-1);    public void SetQueueDepth(double depth) => _queueDepth.Record(depth);}
// Registrationbuilder.Services.AddSingleton<OrderMetrics>();

// Allocation-free (3 or fewer tags)_ordersCreated.Add(1,    new KeyValuePair<string, object?>("order.type", "standard"),    new KeyValuePair<string, object?>("payment.method", "credit_card"));
// 4+ tags — use TagList to avoid allocationsvar tags = new TagList{    { "order.type", "standard" },    { "payment.method", "credit_card" },    { "region", "us-east" },    { "priority", "high" }};_ordersCreated.Add(1, tags);

public sealed class OrderService(ILogger<OrderService> logger){    private static readonly ActivitySource Source = new("MyApp.Orders");
    public async Task<Order> ProcessOrderAsync(CreateOrderRequest request, CancellationToken ct)    {        using var activity = Source.StartActivity("ProcessOrder", ActivityKind.Internal);        activity?.SetTag("order.customer_id", request.CustomerId);
        try        {            await ValidateOrder(request, ct);            activity?.AddEvent(new ActivityEvent("OrderValidated"));
            var order = await SaveOrder(request, ct);            activity?.SetTag("order.id", order.Id.ToString());            activity?.SetStatus(ActivityStatusCode.Ok);            return order;        }        catch (Exception ex)        {            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);            activity?.RecordException(ex);            throw;        }    }}

public partial class OrderService(ILogger<OrderService> logger){    [LoggerMessage(Level = LogLevel.Information,        Message = "Processing order {OrderId} for customer {CustomerId}")]    partial void LogOrderProcessing(Guid orderId, Guid customerId);}

// BAD — new Meter per request causes memory leakspublic void HandleRequest(){    var meter = new Meter("MyApp");    meter.CreateCounter<int>("requests").Add(1);}
// GOOD — singleton via IMeterFactorypublic class MyMetrics(IMeterFactory meterFactory){    private readonly Counter<int> _requests =        meterFactory.Create("MyApp").CreateCounter<int>("myapp.requests");    public void RequestHandled() => _requests.Add(1);}

// BAD — NullReferenceException when no listener is attachedusing var activity = source.StartActivity("Work");activity.SetTag("key", "value");
// GOOD — null-safeactivity?.SetTag("key", "value");

// BAD — unbounded cardinality causes memory explosion in collectors_counter.Add(1, new("request.id", Guid.NewGuid().ToString()));_counter.Add(1, new("user.id", userId));
// GOOD — low-cardinality dimensions only_counter.Add(1, new("http.method", "GET"), new("http.status_code", 200));

// BAD — throws NotSupportedException at runtimebuilder.Services.AddOpenTelemetry()    .UseOtlpExporter()    .WithTracing(t => t.AddOtlpExporter());
// GOOD — use one approachbuilder.Services.AddOpenTelemetry().UseOtlpExporter();

// BAD — activities silently dropped (no listener registered)var source = new ActivitySource("MyApp.Custom");using var activity = source.StartActivity("Work"); // null!
// GOOD — register in the tracing builderotel.WithTracing(t => t.AddSource("MyApp.Custom"));otel.WithMetrics(m => m.AddMeter("MyApp.Custom"));