Loggning och diagnostik i ASP.NET Core SignalR

Av Andrew Stanton-Nurse

Den här artikeln innehåller vägledning för att samla in diagnostik från din ASP.NET Core-app SignalR för att felsöka problem.

Server-side logging

Eftersom SignalR är en del av ASP.NET Core använder den ASP.NET Core-loggningssystemet. I standardkonfigurationen SignalR loggar minimal information, men loggningsnivån kan konfigureras. Mer information om hur du konfigurerar ASP.NET Core-loggning finns i dokumentationen om ASP.NET Core-loggning .

SignalR använder två loggningskategorier:

• Microsoft.AspNetCore.SignalR: För loggar relaterade till hubbprotokoll, aktivering av hubbar, anropa metoder och andra hubbrelaterade aktiviteter.
• Microsoft.AspNetCore.Http.Connections: För loggar som rör transporter, till exempel WebSockets, Long Polling, Server-Sent Events och lågnivåinfrastruktur SignalR .

Om du vill aktivera detaljerade loggar från SignalRkonfigurerar du båda föregående prefix till Debug nivån i appsettings.json filen genom att lägga till följande objekt i underavsnittet LogLevel i Logging:

{
    "Logging": {
        "LogLevel": {
            "Default": "Debug",
            "System": "Information",
            "Microsoft": "Information",
            "Microsoft.AspNetCore.SignalR": "Debug",
            "Microsoft.AspNetCore.Http.Connections": "Debug"
        }
    }
}

Loggningsnivåerna för SignalR loggningskategorierna kan också konfigureras i kod i CreateWebHostBuilder metoden:

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .ConfigureLogging(logging =>
        {
            logging.AddFilter("Microsoft.AspNetCore.SignalR", LogLevel.Debug);
            logging.AddFilter("Microsoft.AspNetCore.Http.Connections", LogLevel.Debug);
        })
        .UseStartup<Startup>();

Om du inte använder JSON-baserad konfiguration anger du följande konfigurationsvärden i konfigurationssystemet:

• Logging:LogLevel:Microsoft.AspNetCore.SignalR = Debug
• Logging:LogLevel:Microsoft.AspNetCore.Http.Connections = Debug

Kontrollera dokumentationen för konfigurationssystemet för att avgöra hur du anger kapslade konfigurationsvärden. När du till exempel använder miljövariabler används två _ tecken i stället för : (till exempel Logging__LogLevel__Microsoft.AspNetCore.SignalR).

Vi rekommenderar att du använder Debug nivån när du samlar in mer detaljerad diagnostik för din app. Nivån Trace genererar diagnostik på låg nivå och behövs sällan för att diagnostisera problem i din app.

Komma åt loggar på serversidan

Hur loggar på serversidan används beror på vilken miljö appen körs i.

Som en konsolapp utanför IIS

Om du kör i en konsolapp bör konsolloggaren vara aktiverad som standard. SignalR loggar visas i konsolen.

I IIS Express från Visual Studio

Visual Studio visar loggutdata i utdatafönstret . Välj alternativet ASP.NET Core Web Server från rullgardinsmenyn.

Azure App Service

Aktivera alternativet Programloggning (Filsystem) i avsnittet Diagnostikloggar i Azure App Service-portalen och konfigurera nivån till Verbose. Loggar ska vara tillgängliga från loggströmningstjänsten och i loggar i apptjänstens filsystem. Mer information finns i Azure-loggströmning.

Other environments

Mer information om hur du konfigurerar loggningsproviders som är lämpliga för olika distributionsmiljöer, till exempel Docker, Kubernetes eller Windows Service, finns i Loggning i .NET och ASP.NET Core.

Loggning för JavaScript-klient

När du använder JavaScript-klienten kan du konfigurera loggningsalternativ med hjälp av configureLogging metoden på HubConnectionBuilder:

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/my/hub/url")
    .configureLogging(signalR.LogLevel.Debug)
    .build();

Inaktivera ramverksloggning genom att signalR.LogLevel.None ange i configureLogging -metoden. Observera att viss loggning genereras direkt av webbläsaren och inte kan inaktiveras via inställning av loggnivå.

I följande tabell visas loggnivåer som är tillgängliga för JavaScript-klienten. Om du ställer in loggnivån på ett av dessa värden kan du logga på den nivån och alla nivåer ovanför den i tabellen.

När du har konfigurerat verbositeten skrivs loggarna till webbläsarkonsolen (eller Standardutdata i en NodeJS-app).

Om du vill skicka loggar till ett anpassat loggningssystem kan du ange ett JavaScript-objekt som implementerar ILogger gränssnittet. Den enda metod som behöver implementeras är log, som tar händelsens nivå och meddelandet som är associerat med händelsen. For example:

import { ILogger, LogLevel, HubConnectionBuilder } from "@microsoft/signalr";

export class MyLogger implements ILogger {
    log(logLevel: LogLevel, message: string) {
        // Use `message` and `logLevel` to record the log message to your own system
    }
}

// later on, when configuring your connection...

let connection = new HubConnectionBuilder()
    .withUrl("/my/hub/url")
    .configureLogging(new MyLogger())
    .build();

import { ILogger, LogLevel, HubConnectionBuilder } from "@aspnet/signalr";

export class MyLogger implements ILogger {
    log(logLevel: LogLevel, message: string) {
        // Use `message` and `logLevel` to record the log message to your own system
    }
}

// later on, when configuring your connection...

let connection = new HubConnectionBuilder()
    .withUrl("/my/hub/url")
    .configureLogging(new MyLogger())
    .build();

loggning för .NET-klienter

Om du vill hämta loggar från .NET-klienten kan du använda ConfigureLogging -metoden på HubConnectionBuilder. Detta fungerar på samma sätt som metoden på ConfigureLoggingWebHostBuilder och HostBuilder. Du kan konfigurera samma loggningsproviders som du använder i ASP.NET Core. Du måste dock installera och aktivera NuGet-paketen manuellt för de enskilda loggningsprovidrar.

Information om hur du lägger till .NET-klientloggning i en Blazor WebAssembly app finns i ASP.NET Core-loggningBlazor.

Console logging

För att aktivera konsolloggning lägger du till paketet Microsoft.Extensions.Logging.Console . AddConsole Använd sedan metoden för att konfigurera konsolloggaren:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/my/hub/url")
    .ConfigureLogging(logging =>
    {
        // Log to the Console
        logging.AddConsole();

        // This will set ALL logging to Debug level
        logging.SetMinimumLevel(LogLevel.Debug);
    })
    .Build();

Felsöka utdatafönsterloggning

Loggar kan konfigureras för att gå till utdatafönstret i Visual Studio. Installera paketet Microsoft.Extensions.Logging.Debug och använd AddDebug metoden:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/my/hub/url")
    .ConfigureLogging(logging =>
    {
        // Log to the Output Window
        logging.AddDebug();

        // This will set ALL logging to Debug level
        logging.SetMinimumLevel(LogLevel.Debug)
    })
    .Build();

Andra loggningsleverantörer

SignalR stöder andra loggningsleverantörer som Serilog, Seq, NLog eller andra loggningssystem som integreras med Microsoft.Extensions.Logging. Om loggningssystemet innehåller en ILoggerProviderkan du registrera den med AddProvider:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/my/hub/url")
    .ConfigureLogging(logging =>
    {
        // Log to your custom provider
        logging.AddProvider(new MyCustomLoggingProvider());

        // This will set ALL logging to Debug level
        logging.SetMinimumLevel(LogLevel.Debug)
    })
    .Build();

Control verbosity

När du loggar från andra platser i appen kan det vara för utförligt att ändra standardnivån till Debug . Ett filter kan användas för att konfigurera loggningsnivån för SignalR loggar. Detta kan göras i kod på ungefär samma sätt som på servern:

var connection = new HubConnectionBuilder()
    .WithUrl("https://example.com/my/hub/url")
    .ConfigureLogging(logging =>
    {
        // Register your providers

        // Set the default log level to Information, but to Debug for SignalR-related loggers.
        logging.SetMinimumLevel(LogLevel.Information);
        logging.AddFilter("Microsoft.AspNetCore.SignalR", LogLevel.Debug);
        logging.AddFilter("Microsoft.AspNetCore.Http.Connections", LogLevel.Debug);
    })
    .Build();

Spårning i SignalR

SignalR hubbservern SignalR och klienten ger information om SignalR anslutningar och meddelanden med hjälp av DiagnosticSource och Activity. SignalR har en ActivitySource för både hubbservern och klienten, som börjar med .NET 9.

En ActivitySource är en komponent som används i distribuerad spårning för att skapa och hantera aktiviteter (eller intervall) som representerar åtgärder i ditt program. Dessa aktiviteter kan användas för att:

• Spåra flödet av begäranden och åtgärder mellan olika komponenter och tjänster.
• Ge värdefulla insikter om programmets prestanda och beteende.

.NET SignalR-servern ActivitySource

SignalR ActivitySource med namnet Microsoft.AspNetCore.SignalR.Server genererar händelser för hubbmetodanrop:

• Varje metod är en egen aktivitet, så allt som emitterar en aktivitet under ett hubbmetodanrop är under hubbmetodaktiviteten.
• Hubbmetodaktiviteter har ingen överordnade. Det innebär att de inte samlas under den långvariga SignalR-anslutningen.

I följande exempel används .NET Aspire instrumentpanel och OpenTelemetry--paket:

<PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.9.0" />
<PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.9.0" />
<PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.9.0" />

Lägg till följande startkod i filen Program.cs:

using OpenTelemetry.Trace;
using SignalRChat.Hubs;

// Set OTEL_EXPORTER_OTLP_ENDPOINT environment variable depending on where your OTEL endpoint is.
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddSignalR();

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        if (builder.Environment.IsDevelopment())
        {
            // View all traces only in development environment.
            tracing.SetSampler(new AlwaysOnSampler());
        }

        tracing.AddAspNetCoreInstrumentation();
        tracing.AddSource("Microsoft.AspNetCore.SignalR.Server");
    });

builder.Services.ConfigureOpenTelemetryTracerProvider(tracing => tracing.AddOtlpExporter());

var app = builder.Build();

Följande exempelutdata kommer från Aspire-instrumentpanelen:

ASP.NET Core tillhandahåller också egna mått för Microsoft.AspNetCore.Hosting händelsekällan.

.NET SignalR-klient för ActivitySource

Det SignalRActivitySource namngivna Microsoft.AspNetCore.SignalR.Client genererar händelser för en SignalR klient:

• Hubbanrop skapar ett klientintervall. Andra SignalR klienter, till exempel JavaScript-klienten, stöder inte spårning. Den här funktionen kommer att läggas till i fler klienter i framtida versioner.
• Anrop till hubben både på klienten och servern stöder kontextspridning. Spridning av spårningskontexten möjliggör sann distribuerad spårning. Nu är det möjligt att se anropsflödet från klienten till servern och tillbaka.

Så här ser de här nya aktiviteterna ut på .NET Aspire instrumentpanelen:

Network traces

Om du stöter på ett problem kan en nätverksspårning ibland ge värdefull information. Detta är särskilt användbart när du skickar in ett problem i vår problemspårare.

Samla in en nätverksspårning med Fiddler (önskat alternativ)

Den här metoden fungerar för alla appar.

Fiddler är ett kraftfullt verktyg för att samla in HTTP-spårningar. Installera den från telerik.com/fiddler, starta den och kör sedan appen och återskapa problemet. Fiddler är tillgängligt för Windows och det finns betaversioner för macOS och Linux.

Om du ansluter med HTTPS finns det några extra steg för att se till att Fiddler kan dekryptera HTTPS-trafiken. Mer information finns i Fiddler-dokumentationen.

När du har samlat in spårningen exporterar du den genom att välja Spara>>alla sessioner i menyraden

Samla in en nätverksspårning med tcpdump (endast macOS och Linux)

Den här metoden fungerar för alla appar.

Råa TCP-spårningar kan samlas in med tcpdump genom att köra följande kommando från ett kommandogränssnitt. Du kan behöva vara root eller prefixa kommandot med sudo om du får ett behörighetsfel:

tcpdump -i [interface] -w trace.pcap

Ersätt [interface] med det nätverksgränssnitt som du vill avbilda på. Detta är vanligtvis något i stil /dev/eth0 med (för ett Standard Ethernet-gränssnitt) eller /dev/lo0 (för localhost-trafik). Mer information finns på den tcpdump manuella sidan i värdsystemet.

Samla in en nätverksspårning i webbläsaren

Den här metoden fungerar bara för webbläsarbaserade appar.

De flesta konsoler för webbläsarutvecklare har fliken Nätverk som gör att nätverksaktivitet kan samlas in mellan webbläsaren och servern. Dessa spårningar innehåller dock inte WebSocket- och Server-Sent-händelsemeddelanden. När du använder dessa transporter är det bättre att använda ett verktyg som Fiddler eller TcpDump, enligt beskrivningen senare i den här artikeln.

Microsoft Edge och Internet Explorer

(Anvisningarna är desamma för både Microsoft Edge och Internet Explorer)

1. Öppna Dev Tools genom att trycka på F12
2. Välj fliken Nätverk
3. Uppdatera sidan (om det behövs) och återskapa problemet
4. Välj ikonen Spara i verktygsfältet för att exportera spårningen som en "HAR"-fil:

Google Chrome

1. Öppna Dev Tools genom att trycka på F12
2. Välj fliken Nätverk
3. Uppdatera sidan (om det behövs) och återskapa problemet
4. Högerklicka var som helst i listan med begäranden och välj "Spara som HAR med innehåll":

Mozilla Firefox

1. Öppna Dev Tools genom att trycka på F12
2. Välj fliken Nätverk
3. Uppdatera sidan (om det behövs) och återskapa problemet
4. Högerklicka var som helst i listan med begäranden och välj "Spara alla som HAR"

Bifoga diagnostikfiler till GitHub-problem

Diagnostikfiler kan kopplas till GitHub-problem genom att byta namn på dem så att de har ett .txt tillägg och sedan dra och släppa dem till problemet.

Metrics

Mått är en representation av datamått över tidsintervall. Till exempel begäranden per sekund. Måttdata gör det möjligt att övervaka tillståndet för en app på en hög nivå. .NET gRPC-metrik genereras med EventCounter.

SignalR servermetrik

SignalR serverstatistik rapporteras via Microsoft.AspNetCore.Http.Connections händelsekällan.

Observe metrics

dotnet-counters är ett prestandaövervakningsverktyg för ad hoc-hälsoövervakning och prestandaundersökning på första nivån. Övervaka en .NET-app med Microsoft.AspNetCore.Http.Connections som providernamn. For example:

> dotnet-counters monitor --process-id 37016 --counters Microsoft.AspNetCore.Http.Connections

Press p to pause, r to resume, q to quit.
    Status: Running
[Microsoft.AspNetCore.Http.Connections]
    Average Connection Duration (ms)       16,040.56
    Current Connections                         1
    Total Connections Started                   8
    Total Connections Stopped                   7
    Total Connections Timed Out                 0

Additional resources

• ASP.NET Core SignalR konfiguration
• ASP.NET Core SignalR JavaScript-klient
• ASP.NET Core SignalR .NET-klient