.NET Monitoring Guide: ASP.NET Core, OpenTelemetry & Application Observability (2026)

// Program.cs — Health check configuration
builder.Services.AddHealthChecks()
    // Database connectivity
    .AddSqlServer(
        connectionString: builder.Configuration.GetConnectionString("DefaultConnection"),
        name: "sql-server",
        tags: ["ready", "db"]
    )
    // Redis cache
    .AddRedis(
        redisConnectionString: builder.Configuration["Redis:ConnectionString"],
        name: "redis",
        tags: ["ready", "cache"]
    )
    // External dependency
    .AddUrlGroup(
        uri: new Uri("https://api.payment-provider.com/health"),
        name: "payment-api",
        tags: ["ready", "external"]
    )
    // Custom check
    .AddCheck<QueueDepthHealthCheck>("message-queue", tags: ["ready"]);

// Separate endpoints for K8s probes
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    // Liveness: only process health (no dependency checks)
    Predicate = _ => false,
    ResponseWriter = HealthCheckResponseWriter.WriteResponse
});

app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    // Readiness: all checks with "ready" tag
    Predicate = c => c.Tags.Contains("ready"),
    ResponseWriter = HealthCheckResponseWriter.WriteResponse
});

// Kubernetes deployment.yaml
// livenessProbe:
//   httpGet:
//     path: /health/live
//     port: 8080
//   initialDelaySeconds: 10
//   periodSeconds: 30
// readinessProbe:
//   httpGet:
//     path: /health/ready
//     port: 8080
//   initialDelaySeconds: 5
//   periodSeconds: 10

// Custom health check for queue depth
public class QueueDepthHealthCheck : IHealthCheck
{
    private readonly IMessageQueue _queue;

    public QueueDepthHealthCheck(IMessageQueue queue) => _queue = queue;

    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        var depth = await _queue.GetDepthAsync();

        return depth switch
        {
            < 1000 => HealthCheckResult.Healthy(
                $"Queue depth: {depth}",
                data: new Dictionary<string, object> { ["depth"] = depth }
            ),
            < 5000 => HealthCheckResult.Degraded(
                $"Queue depth elevated: {depth}",
                data: new Dictionary<string, object> { ["depth"] = depth }
            ),
            _ => HealthCheckResult.Unhealthy(
                $"Queue depth critical: {depth}",
                data: new Dictionary<string, object> { ["depth"] = depth }
            )
        };
    }
}

// Install NuGet packages:
// dotnet add package OpenTelemetry.Extensions.Hosting
// dotnet add package OpenTelemetry.Instrumentation.AspNetCore
// dotnet add package OpenTelemetry.Instrumentation.Http
// dotnet add package OpenTelemetry.Instrumentation.SqlClient
// dotnet add package OpenTelemetry.Instrumentation.EntityFrameworkCore
// dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
// dotnet add package OpenTelemetry.Instrumentation.Runtime

// Program.cs
builder.Services.AddOpenTelemetry()
    .ConfigureResource(r => r.AddService(
        serviceName: "my-aspnetcore-api",
        serviceVersion: "2.1.0"
    ))
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation(o => {
            o.RecordException = true;
            o.Filter = ctx => !ctx.Request.Path.StartsWithSegments("/health");
        })
        .AddHttpClientInstrumentation()
        .AddSqlClientInstrumentation(o => o.SetDbStatementForText = true)
        .AddEntityFrameworkCoreInstrumentation()
        .AddOtlpExporter(o => o.Endpoint = new Uri("http://localhost:4317"))
    )
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddRuntimeInstrumentation()  // CLR GC, thread pool, heap
        .AddPrometheusExporter()      // /metrics endpoint
    );

// Custom trace spans in business logic
public class OrderService
{
    private static readonly ActivitySource Source =
        new("MyApp.OrderService", "1.0.0");

    public async Task<Order> ProcessOrderAsync(OrderRequest request)
    {
        using var activity = Source.StartActivity("ProcessOrder");
        activity?.SetTag("order.value", request.TotalAmount);
        activity?.SetTag("customer.tier", request.CustomerTier);

        try
        {
            var result = await _paymentService.ChargeAsync(request);
            activity?.SetTag("payment.method", result.Method);
            return result;
        }
        catch (PaymentDeclinedException ex)
        {
            activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
            activity?.RecordException(ex);
            throw;
        }
    }
}

// dotnet add package prometheus-net.AspNetCore

// Program.cs
builder.Services.AddHealthChecks(); // Required for health check metrics

app.UseRouting();
app.UseHttpMetrics(options => {
    // Reduce cardinality — don't create metric per URL
    options.ReduceStatusCodeCardinality();
    options.AddCustomLabel("version", ctx =>
        ctx.GetRouteValue("version")?.ToString() ?? "");
});

app.MapMetrics("/metrics"); // Prometheus scrape endpoint
app.MapHealthChecks("/health");

// Custom business metrics
public class OrderMetrics
{
    private static readonly Counter OrdersTotal = Metrics.CreateCounter(
        "orders_total",
        "Total orders processed",
        new CounterConfiguration
        {
            LabelNames = ["status", "payment_method"]
        }
    );

    private static readonly Histogram OrderAmountDollars = Metrics.CreateHistogram(
        "order_amount_dollars",
        "Order value in dollars",
        new HistogramConfiguration
        {
            Buckets = [10, 50, 100, 500, 1000, 5000]
        }
    );

    private static readonly Gauge ActiveCheckouts = Metrics.CreateGauge(
        "active_checkouts",
        "Number of checkouts in progress"
    );

    public void RecordOrder(string status, string paymentMethod, double amount)
    {
        OrdersTotal.WithLabels(status, paymentMethod).Inc();
        OrderAmountDollars.Observe(amount);
    }
}

// Key alert rules (Prometheus/Grafana)
// alert: HighDotNetGcPauseRatio
//   expr: dotnet_gc_pause_ratio > 0.1  # >10% of time in GC
// alert: ThreadPoolStarvation
//   expr: dotnet_threadpool_queue_length > 100
// alert: LargeObjectHeapGrowth
//   expr: rate(dotnet_gc_heap_size_bytes{generation="loh"}[5m]) > 0

# Live CLR counters (attach to running process)
dotnet-counters monitor --process-id 12345 \
  --counters System.Runtime

# Key counters to watch:
# gc-heap-size         — managed heap total (MB)
# gen-0-size / gen-1-size / gen-2-size — per-generation
# loh-size             — Large Object Heap size
# gen-0-gc-count / gen-1-gc-count / gen-2-gc-count
# gc-fragmentation     — heap fragmentation %
# threadpool-queue-length
# active-timer-count
# working-set          — total process memory (MB)

# Capture GC heap dump (analyze with PerfView or VS)
dotnet-gcdump collect --process-id 12345 --output heap.gcdump

# Common memory leak patterns in .NET:
# 1. Event handler leaks — += without -= on long-lived publishers
# 2. Static dictionary growth — add keys, never remove
# 3. IDisposable not disposed — HttpClient, DbContext, streams
# 4. Closures capturing large objects
# 5. String.Intern abuse — unique strings fill intern pool forever

# Suppress LOH pressure with ArrayPool
// Instead of:
byte[] buffer = new byte[1_000_000];

// Use:
var pool = ArrayPool<byte>.Shared;
byte[] buffer = pool.Rent(1_000_000);
try { /* use buffer */ }
finally { pool.Return(buffer); }