Quando si sviluppano applicazioni distribuite, l’osservabilità è fondamentale. Non basta che il codice funzioni: dobbiamo essere in grado di capire cosa accade dentro il sistema, diagnosticare errori e misurare le performance.

In un ambiente cloud native, con API, frontend, worker e risorse esterne che interagiscono tra loro, la complessità cresce rapidamente. Senza strumenti adeguati, diventa difficile anche solo capire dove sia avvenuto un errore.

Con .NET Aspire, l’osservabilità non è un’aggiunta opzionale, ma una feature integrata: log, metriche e tracing vengono raccolti automaticamente e resi disponibili in un’unica dashboard.

Cosa intendiamo per osservabilità

Il termine osservabilità indica la capacità di un sistema di fornire informazioni interne utili al monitoraggio e alla diagnosi dei problemi. I tre pilastri principali sono:

• Log – registrazioni testuali di eventi e operazioni.
• Metriche – valori numerici che descrivono lo stato del sistema (CPU, richieste al secondo, errori).
• Tracing distribuito – tracciamento delle richieste che attraversano più servizi.

Tradizionalmente, ognuno di questi aspetti richiede configurazioni manuali e strumenti separati. Aspire li integra in un unico flusso.

Logging centralizzato

Per impostazione predefinita, ogni progetto Aspire eredita le configurazioni di logging definite in ServiceDefaults.

Esempio di setup in ServiceDefaults/Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Aggiunge logging console + OpenTelemetry
builder.Logging.AddConsole()
    .AddOpenTelemetry(options =>
    {
        options.IncludeFormattedMessage = true;
        options.IncludeScopes = true;
    });

var app = builder.Build();
app.MapGet("/", () => "Hello Aspire!");
app.Run();

Tutti i log dei vari progetti vengono centralizzati nella dashboard Aspire, così puoi vedere in un unico posto cosa succede in API, frontend e worker.

Metriche

Aspire supporta nativamente OpenTelemetry Metrics, che consente di raccogliere informazioni numeriche sull’andamento dell’applicazione.

Ad esempio, nel tuo progetto API puoi aggiungere un contatore di richieste:

using System.Diagnostics.Metrics;

var meter = new Meter("MyApi", "1.0");
var requestCounter = meter.CreateCounter<int>("api_requests_total");

var app = WebApplication.CreateBuilder(args).Build();

app.MapGet("/products", () =>
{
    requestCounter.Add(1);
    return new[] { "Laptop", "Smartphone", "Tablet" };
});

app.Run();

Questi dati vengono raccolti da Aspire e resi disponibili nella dashboard, oppure esportati verso strumenti esterni come Prometheus o Grafana.

Tracing distribuito

Uno dei vantaggi più forti di Aspire è l’integrazione con OpenTelemetry Tracing. Questo permette di seguire una richiesta che passa attraverso diversi servizi.

Esempio: se il tuo frontend chiama l’API, e l’API a sua volta interroga un database, Aspire può mostrare un trace completo con tempi di esecuzione e dettagli di ogni passaggio.

Nel progetto API, basta attivare il middleware OpenTelemetry:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing.AddAspNetCoreInstrumentation();
        tracing.AddHttpClientInstrumentation();
        tracing.AddEntityFrameworkCoreInstrumentation();
    });

var app = builder.Build();

app.MapGet("/orders", () => new[] { "Order1", "Order2" });

app.Run();

Grazie a questa configurazione, ogni richiesta che passa per l’API verrà tracciata automaticamente.

La dashboard Aspire

Il cuore dell’osservabilità in Aspire è la sua dashboard web, avviata insieme all’AppHost. Da qui puoi:

• vedere i log centralizzati di tutti i progetti;
• monitorare endpoint e risorse collegate;
• ispezionare metriche in tempo reale;
• visualizzare i trace distribuiti delle richieste.

Questo significa che, anche con una soluzione multi-progetto complessa, hai una singola finestra di controllo.

Cosa fa Aspire dietro le quinte

L’integrazione dell’osservabilità è uno dei punti in cui Aspire semplifica di più la vita dello sviluppatore:

• Configura automaticamente OpenTelemetry per log, metriche e tracing, senza bisogno di setup manuali complessi.
• Centralizza i log provenienti da più progetti, così non devi aprire terminali separati o container logs.
• Raccoglie le metriche e le espone in un formato standard (es. Prometheus), pronto per l’integrazione con strumenti esterni.
• Gestisce il tracing distribuito tra progetti diversi, assegnando ID univoci alle richieste.
• Offre una dashboard integrata che ti evita di installare subito strumenti terzi (anche se puoi aggiungerli in seguito).

In sostanza, Aspire trasforma l’osservabilità da attività secondaria (e spesso trascurata) a feature di default, disponibile fin da subito.

Conclusioni

Con .NET Aspire, l’osservabilità diventa parte integrante del ciclo di sviluppo: log, metriche e trace sono raccolti automaticamente, senza configurazioni complesse. Questo riduce drasticamente il tempo necessario a diagnosticare problemi e rende l’applicazione più robusta e pronta per il cloud.

Nel prossimo articolo vedremo come Aspire gestisce l’integrazione con risorse esterne, come database, code di messaggi e API di terze parti.