The Aspire Dashboard: Your Distributed Application at a Glance

One of the most immediately impressive features of .NET Aspire is the dashboard that launches when you run your AppHost. It gives you a unified view of every resource, their logs, traces, and metrics — without installing Jaeger, Grafana, or any other external tooling.

What You See on Launch

When you run your AppHost project, the dashboard opens in your browser automatically. The landing page shows the Resources view: a table listing every project, container, and executable in your application. Each row displays the resource name, type, state, and any endpoints.

At a glance you can see whether your PostgreSQL container is running, whether your API has started, and which ports everything is listening on. Resources that fail to start are highlighted immediately.

Structured Logs

The Structured Logs page aggregates log output from every service in real time. Unlike tailing raw console output, these logs are structured — you can filter by severity, resource, or search for specific text.

Because Aspire configures OpenTelemetry logging by default through the ServiceDefaults project, your logs arrive with full context: trace IDs, span IDs, and resource attributes. This means you can click a log entry and jump directly to the trace that produced it.

Filtering is powerful. You can narrow down to a single service, show only warnings and errors, or search for a specific correlation ID:

Filter: resource.name = "catalog-api" AND severity >= Warning

Distributed Traces

The Traces page is where the dashboard truly shines. Every HTTP request, database call, and message broker interaction is captured as a distributed trace. You see a waterfall diagram showing exactly how a request flows through your services.

For example, a request to your frontend might show:

  1. Frontend receives HTTP GET /products
  2. Frontend calls catalog-api via HTTP
  3. Catalog API queries PostgreSQL
  4. Catalog API checks Redis cache
  5. Response returns through the chain

Each span shows its duration, status, and attributes. Slow database queries or failed HTTP calls stand out immediately.

You do not need to add any tracing code to see this. The ServiceDefaults project configures ASP.NET Core and HttpClient instrumentation automatically. If you want to add custom spans, you use the standard ActivitySource API:

Example.cs 
private static readonly ActivitySource ActivitySource = new("MyApp.Catalog");

public async Task<Product?> GetProductAsync(int id)
{
    using var activity = ActivitySource.StartActivity("GetProduct");
    activity?.SetTag("product.id", id);

    // ... your logic here
}

Register the source in your ServiceDefaults configuration:

Example.cs 
builder.Services.AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing.AddSource("MyApp.Catalog");
    });

The custom span will appear in the dashboard traces alongside the automatic instrumentation.

Metrics

The Metrics page displays counters, histograms, and gauges from your services. Out of the box you get ASP.NET Core metrics like request duration, active connections, and response status code counts. You also get .NET runtime metrics: GC collections, thread pool usage, and memory consumption.

The dashboard renders these as simple line charts. Whilst it is not a replacement for Grafana in production, it is more than sufficient for development. You can quickly spot whether a service is leaking memory or whether request latencies are climbing.

Using the Dashboard Standalone

The Aspire dashboard is available as a standalone Docker container, which means you can use it outside of Aspire entirely. Any application that exports OTLP telemetry can send data to it:

terminal 
docker run --rm -it -p 18888:18888 -p 4317:18889 \
    mcr.microsoft.com/dotnet/aspire-dashboard:9.0

Then point your application's OTLP exporter to http://localhost:4317 and open http://localhost:18888 in your browser. This is particularly useful if you want dashboard-style observability for a non-Aspire application.

Console Logs

The Console Logs page shows raw stdout and stderr from each resource. This is useful for containers that do not emit structured logs — you see exactly what they print to the console, just as if you were running docker logs.

Practical Tips

Trace filtering: Use the search box on the Traces page to filter by span name or attribute. If you are debugging a specific endpoint, search for its route template.

Resource restart: You can stop and restart individual resources directly from the dashboard without restarting the entire AppHost.

Log levels: Adjust log levels at runtime by modifying your appsettings.Development.json. The dashboard picks up structured log entries immediately — no restart needed.

The Aspire dashboard transforms local development from guesswork into evidence-based debugging. You see exactly what your application is doing, where time is being spent, and where errors originate — all without leaving your browser.