Diagnostics & Performance

dotnet tool install -g dotnet-trace
dotnet-trace collect --process-id 1234 --duration 00:00:30
# Produces a .nettrace file, viewable in PerfView or Visual Studio

Common follow-ups: How do you view a .nettrace file's contents?;What's the performance overhead of running dotnet-trace against a live process?

dotnet-counters monitor --process-id 1234

# Live output includes:
# cpu-usage, gc-heap-size, gen-0-gc-count, threadpool-thread-count, request-rate...

Common follow-ups: How do you add custom application-specific counters using EventCounter or Meter?;How does this compare to a full APM solution like Application Insights?

dotnet tool install -g dotnet-gcdump
dotnet-gcdump collect --process-id 1234
# Analyze the resulting .gcdump in Visual Studio: Debug > Windows > Show Diagnostic Tools > Memory Usage

Common follow-ups: What's the difference between a gcdump and a full process memory dump?;How do you identify a reference path keeping an object alive in the dump viewer?

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSqlClientInstrumentation()
        .AddOtlpExporter());

Common follow-ups: How does distributed tracing correlate spans across service boundaries?;What's the difference between Application Insights and the vendor-neutral OpenTelemetry approach?

private static readonly Meter _meter = new("MyApp.Orders");
private static readonly Counter<long> _ordersProcessed = _meter.CreateCounter<long>("orders.processed");
private static readonly Histogram<double> _processingDuration = _meter.CreateHistogram<double>("orders.duration");

public void ProcessOrder() {
    var sw = Stopwatch.StartNew();
    // ... processing logic ...
    _ordersProcessed.Add(1);
    _processingDuration.Record(sw.Elapsed.TotalMilliseconds);
}

Common follow-ups: What's the difference between a Counter, Gauge, and Histogram instrument type?;How does dotnet-counters automatically discover custom Meters?

[MemoryDiagnoser]
public class StringConcatBenchmarks {
    [Benchmark]
    public string StringConcat() => "a" + "b" + "c";

    [Benchmark]
    public string StringBuilder() => new StringBuilder().Append("a").Append("b").Append("c").ToString();
}

// Run via: BenchmarkRunner.Run<StringConcatBenchmarks>();

Common follow-ups: How does BenchmarkDotNet handle JIT warm-up automatically?;What does the MemoryDiagnoser attribute add to the benchmark output?

// Common cause of starvation: blocking on async code
public IActionResult GetData() {
    var result = _service.GetDataAsync().Result;  // BLOCKS a thread pool thread
    return Ok(result);
}

// Fix: async all the way through
public async Task<IActionResult> GetData() {
    var result = await _service.GetDataAsync();
    return Ok(result);
}

Common follow-ups: Why does the thread pool grow new threads slowly rather than immediately?;How does MinThreads configuration provide a (usually inadvisable) quick mitigation?

# Running as a sidecar in Kubernetes, collecting a trace via its HTTP API:
curl -X POST "http://localhost:52323/trace?pid=1&durationSeconds=30" -o trace.nettrace

# Or configured to auto-collect a dump when CPU exceeds a threshold for 30 seconds
{ "CollectionRuleDefaults": { "Triggers": { "CPUUsage": { "GreaterThan": 90, "SlidingWindowDuration": "00:00:30" } } } }

Common follow-ups: How do collection rules automate diagnostics without human intervention?;What security considerations apply to exposing dotnet-monitor's API?

// Async state machine overhead is real but usually negligible relative to the I/O wait time
public async Task<Order> GetOrderAsync(int id) {
    return await _db.Orders.FindAsync(id);  // thread NOT blocked during the DB roundtrip
}

// vs blocking equivalent (bad under load):
public Order GetOrder(int id) {
    return _db.Orders.Find(id);  // blocks a thread pool thread for the entire DB roundtrip
}

Common follow-ups: When does the state machine's overhead actually matter (very hot, tight loops with no real I/O)?;How does ValueTask reduce allocation overhead for frequently-synchronously-completing async methods?

dotnet tool install -g dotnet-dump
dotnet-dump collect --process-id 1234
dotnet-dump analyze core_20240115.dmp

# Inside the analyze REPL:
> dumpheap -stat
# Shows object counts and total size by type, sorted by total size

Common follow-ups: How do you configure automatic dump collection on unhandled exceptions or crashes?;What SOS commands help trace why a specific object is still referenced?