HTTP-loggning i ASP.NET Core

2025-04-30

Note

Det här är inte den senaste versionen av den här artikeln. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Warning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i supportpolicyn för .NET och .NET Core. För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

Important

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

För den nuvarande utgåvan, se .NET 9-versionen av den här artikeln .

HTTP-loggning är ett mellanprogram som loggar information om inkommande HTTP-begäranden och HTTP-svar. HTTP-loggning innehåller loggar med:

HTTP-begärandeinformation
Common properties
Headers
Body
HTTP-svarsinformation

HTTP-loggning kan:

Logga alla begäranden och svar eller endast begäranden och svar som uppfyller vissa kriterier.
Välj vilka delar av begäran och svar som loggas.
Gör att du kan redigera känslig information från loggarna.

HTTP-loggning kan minska prestandan för en app, särskilt när du loggar begärande- och svarsorganen. Överväg prestandapåverkan när du väljer fält att logga. Testa prestandapåverkan för de valda loggningsegenskaperna.

Warning

HTTP-loggning kan potentiellt logga personligt identifierbar information (PII). Överväg risken och undvik loggning av känslig information. Mer information om redigering finns i Redigera känsliga data

Aktivera HTTP-loggning

HTTP-loggning aktiveras genom att anropa AddHttpLogging och UseHttpLogging, enligt följande exempel:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Hello World!");

app.Run();

Den tomma lambda-funktionen i det föregående exemplet på att anropa AddHttpLogging lägger till mellanprogrammet med standardkonfigurationen. Som standard loggar HTTP-loggning vanliga egenskaper som sökväg, statuskod och rubriker för begäranden och svar.

Lägg till följande rad i appsettings.Development.json filen på nivån "LogLevel": { så att HTTP-loggarna visas:

"Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware": "Information"

Med standardkonfigurationen loggas en begäran och ett svar som ett par meddelanden som liknar följande exempel:

info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[1]
      Request:
      Protocol: HTTP/2
      Method: GET
      Scheme: https
      PathBase:
      Path: /
      Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
      Host: localhost:52941
      User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 Edg/118.0.2088.61
      Accept-Encoding: gzip, deflate, br
      Accept-Language: en-US,en;q=0.9
      Upgrade-Insecure-Requests: [Redacted]
      sec-ch-ua: [Redacted]
      sec-ch-ua-mobile: [Redacted]
      sec-ch-ua-platform: [Redacted]
      sec-fetch-site: [Redacted]
      sec-fetch-mode: [Redacted]
      sec-fetch-user: [Redacted]
      sec-fetch-dest: [Redacted]
info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[2]
      Response:
      StatusCode: 200
      Content-Type: text/plain; charset=utf-8
      Date: Tue, 24 Oct 2023 02:03:53 GMT
      Server: Kestrel

HTTP-loggningsalternativ

Om du vill konfigurera globala alternativ för mellanprogram för HTTP-loggning anropar du AddHttpLogging i Program.cs och använder lambdan för att konfigurera HttpLoggingOptions.

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;
    logging.CombineLogs = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging();

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Note

I föregående exempel och följande exempel UseHttpLogging anropas efter UseStaticFiles, så HTTP-loggning är inte aktiverat för statiska filer. Om du vill aktivera HTTP-loggning för statiska filer anropar du UseHttpLogging före UseStaticFiles.

`LoggingFields`

HttpLoggingOptions.LoggingFields är ett enumflagg som konfigurerar specifika delar av begäran och svaret för loggning. LoggingFields standardvärdet är RequestPropertiesAndHeaders | ResponsePropertiesAndHeaders.

`RequestHeaders` och `ResponseHeaders`

RequestHeaders och ResponseHeaders är uppsättningar med HTTP-huvuden som loggas. Rubrikvärden loggas endast för rubriknamn som finns i dessa samlingar. Följande kod lägger till sec-ch-ua till RequestHeaders, så värdet för sec-ch-ua-huvudet loggas. Och det lägger MyResponseHeader till ResponseHeaders, så att värdet för MyResponseHeader-headern loggas. Om dessa rader tas bort, är värdena för dessa rubriker [Redacted].

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;
    logging.CombineLogs = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging();

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

`MediaTypeOptions`

MediaTypeOptions tillhandahåller konfiguration för att välja vilken kodning som ska användas för en viss medietyp.

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;
    logging.CombineLogs = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging();

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Den här metoden kan också användas för att aktivera loggning för data som inte loggas som standard (till exempel formulärdata, som kan ha en medietyp som application/x-www-form-urlencoded eller multipart/form-data).

`MediaTypeOptions` metoder

`RequestBodyLogLimit` och `ResponseBodyLogLimit`

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;
    logging.CombineLogs = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging();

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

`CombineLogs`

Att ställa in CombineLogs till true konfigurerar mellanprogrammet för att konsolidera alla dess aktiverade loggar för en begäran och ett svar till en logg till slut. Detta inkluderar begäran, begärandetext, svar, svarstext och varaktighet.

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;
    logging.CombineLogs = true;
});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging();

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Endpoint-specific configuration

För slutpunktsspecifik konfiguration i minimala API-appar är en WithHttpLogging tilläggsmetod tillgänglig. I följande exempel visas hur du konfigurerar HTTP-loggning för en slutpunkt:

app.MapGet("/response", () => "Hello World! (logging response)")
    .WithHttpLogging(HttpLoggingFields.ResponsePropertiesAndHeaders);

För slutpunktsspecifik konfiguration i appar som använder styrenheter [HttpLogging] är attributet tillgängligt. Attributet kan också användas i minimala API-appar, som du ser i följande exempel:

app.MapGet("/duration", [HttpLogging(loggingFields: HttpLoggingFields.Duration)]
    () => "Hello World! (logging duration)");

`IHttpLoggingInterceptor`

IHttpLoggingInterceptor är gränssnittet för en tjänst som kan implementeras för att hantera återanrop för varje begäran och svar för att anpassa vilka detaljer som loggas. Alla slutpunktsspecifika logginställningar tillämpas först och kan sedan åsidosättas i dessa återanrop. En implementering kan:

Granska en begäran eller ett svar.
Aktivera eller inaktivera alla HttpLoggingFields.
Justera hur mycket av begärande- eller svarstexten som loggas.
Lägg till anpassade fält i loggarna.

Registrera en IHttpLoggingInterceptor implementering genom att anropa AddHttpLoggingInterceptor i Program.cs. Om flera IHttpLoggingInterceptor instanser registreras körs de i den registrerade ordningen.

I följande exempel visas hur du registrerar en IHttpLoggingInterceptor implementering:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.Duration;
});
builder.Services.AddHttpLoggingInterceptor<SampleHttpLoggingInterceptor>();

Följande exempel är en IHttpLoggingInterceptor implementering som:

Inspekterar begärandemetoden och inaktiverar loggning för POST-begäranden.
För icke-POST-begäranden:
- Redigerar begärandesökväg, begärandehuvuden och svarshuvuden.
- Lägger till anpassade fält och fältvärden i begärande- och svarsloggarna.

using Microsoft.AspNetCore.HttpLogging;

namespace HttpLoggingSample;

internal sealed class SampleHttpLoggingInterceptor : IHttpLoggingInterceptor
{
    public ValueTask OnRequestAsync(HttpLoggingInterceptorContext logContext)
    {
        if (logContext.HttpContext.Request.Method == "POST")
        {
            // Don't log anything if the request is a POST.
            logContext.LoggingFields = HttpLoggingFields.None;
        }

        // Don't enrich if we're not going to log any part of the request.
        if (!logContext.IsAnyEnabled(HttpLoggingFields.Request))
        {
            return default;
        }

        if (logContext.TryDisable(HttpLoggingFields.RequestPath))
        {
            RedactPath(logContext);
        }

        if (logContext.TryDisable(HttpLoggingFields.RequestHeaders))
        {
            RedactRequestHeaders(logContext);
        }

        EnrichRequest(logContext);

        return default;
    }

    public ValueTask OnResponseAsync(HttpLoggingInterceptorContext logContext)
    {
        // Don't enrich if we're not going to log any part of the response
        if (!logContext.IsAnyEnabled(HttpLoggingFields.Response))
        {
            return default;
        }

        if (logContext.TryDisable(HttpLoggingFields.ResponseHeaders))
        {
            RedactResponseHeaders(logContext);
        }

        EnrichResponse(logContext);

        return default;
    }

    private void RedactPath(HttpLoggingInterceptorContext logContext)
    {
        logContext.AddParameter(nameof(logContext.HttpContext.Request.Path), "RedactedPath");
    }

    private void RedactRequestHeaders(HttpLoggingInterceptorContext logContext)
    {
        foreach (var header in logContext.HttpContext.Request.Headers)
        {
            logContext.AddParameter(header.Key, "RedactedHeader");
        }
    }

    private void EnrichRequest(HttpLoggingInterceptorContext logContext)
    {
        logContext.AddParameter("RequestEnrichment", "Stuff");
    }

    private void RedactResponseHeaders(HttpLoggingInterceptorContext logContext)
    {
        foreach (var header in logContext.HttpContext.Response.Headers)
        {
            logContext.AddParameter(header.Key, "RedactedHeader");
        }
    }

    private void EnrichResponse(HttpLoggingInterceptorContext logContext)
    {
        logContext.AddParameter("ResponseEnrichment", "Stuff");
    }
}

Med den här interceptorn genererar en POST-begäran inga loggar även om HTTP-loggning har konfigurerats för att logga HttpLoggingFields.All. En GET-begäran genererar loggar som liknar följande exempel:

info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[1]
      Request:
      Path: RedactedPath
      Accept: RedactedHeader
      Host: RedactedHeader
      User-Agent: RedactedHeader
      Accept-Encoding: RedactedHeader
      Accept-Language: RedactedHeader
      Upgrade-Insecure-Requests: RedactedHeader
      sec-ch-ua: RedactedHeader
      sec-ch-ua-mobile: RedactedHeader
      sec-ch-ua-platform: RedactedHeader
      sec-fetch-site: RedactedHeader
      sec-fetch-mode: RedactedHeader
      sec-fetch-user: RedactedHeader
      sec-fetch-dest: RedactedHeader
      RequestEnrichment: Stuff
      Protocol: HTTP/2
      Method: GET
      Scheme: https
info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[2]
      Response:
      Content-Type: RedactedHeader
      MyResponseHeader: RedactedHeader
      ResponseEnrichment: Stuff
      StatusCode: 200
info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[4]
      ResponseBody: Hello World!
info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[8]
      Duration: 2.2778ms

Ordning för loggningskonfigurationers företräde

I följande lista visas prioritetsordningen för loggningskonfigurationen:

Global konfiguration från HttpLoggingOptions, som anges genom att anropa AddHttpLogging.
Slutpunktsspecifik konfiguration från [HttpLogging] attributet eller WithHttpLogging tilläggsmetoden åsidosätter global konfiguration.
IHttpLoggingInterceptor anropas med resultatet och kan ytterligare ändra konfigurationen per begäran.

HTTP-loggning är ett mellanprogram som loggar information om inkommande HTTP-begäranden och HTTP-svar. HTTP-loggning innehåller loggar med:

HTTP-begärandeinformation
Common properties
Headers
Body
HTTP-svarsinformation

HTTP-loggning är värdefull i flera scenarier för att:

Registrera information om inkommande begäranden och svar.
Filtrera vilka delar av begäran och svaret som loggas.
Filtrera vilka rubriker som ska loggas.

Warning

HTTP-loggning kan potentiellt logga personligt identifierbar information (PII). Överväg risken och undvik loggning av känslig information.

Aktivera HTTP-loggning

HTTP-loggning är aktiverad med UseHttpLogging, vilket lägger till HTTP-logging middleware.

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Hello World!");

app.Run();

Som standard loggar HTTP-loggning vanliga egenskaper som sökväg, statuskod och huvuden för begäranden och svar. Lägg till följande rad i appsettings.Development.json filen på nivån "LogLevel": { så att HTTP-loggarna visas:

 "Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware": "Information"

Utdata loggas som ett enda meddelande på LogLevel.Information.

Exempel på utdata för begäran

HTTP-loggningsalternativ

Om du vill konfigurera HTTP-loggningsmellanprogrammet anropar du AddHttpLogging i Program.cs.

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;

});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging(); 

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Note

I föregående exempel och följande exempel UseHttpLogging anropas efter UseStaticFiles, så HTTP-loggning är inte aktiverat för statisk fil. Om du vill aktivera HTTP-loggning för statiska filer anropar du UseHttpLogging före UseStaticFiles.

`LoggingFields`

HttpLoggingOptions.LoggingFields är ett enumflagg som konfigurerar specifika delar av begäran och svaret för loggning. HttpLoggingOptions.LoggingFields standardvärdet är RequestPropertiesAndHeaders | ResponsePropertiesAndHeaders.

`RequestHeaders`

Headers är en uppsättning HTTP-begärandehuvuden som tillåts loggas. Rubrikvärden loggas endast för rubriknamn som finns i den här samlingen. Följande kod loggar begärandehuvudet "sec-ch-ua". Om logging.RequestHeaders.Add("sec-ch-ua"); tas bort redigeras värdet för begärandehuvudet "sec-ch-ua" . Följande markerade kodanrop HttpLoggingOptions.RequestHeaders och HttpLoggingOptions.ResponseHeaders :

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;

});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging(); 

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

`MediaTypeOptions`

MediaTypeOptions tillhandahåller konfiguration för att välja vilken kodning som ska användas för en viss medietyp.

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;

});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging(); 

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Den här metoden kan också användas för att aktivera loggning för data som inte loggas som standard. Till exempel formulärdata, som kan ha en medietyp som application/x-www-form-urlencoded eller multipart/form-data.

`MediaTypeOptions` metoder

`RequestBodyLogLimit` och `ResponseBodyLogLimit`

using Microsoft.AspNetCore.HttpLogging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.All;
    logging.RequestHeaders.Add("sec-ch-ua");
    logging.ResponseHeaders.Add("MyResponseHeader");
    logging.MediaTypeOptions.AddText("application/javascript");
    logging.RequestBodyLogLimit = 4096;
    logging.ResponseBodyLogLimit = 4096;

});

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseStaticFiles();

app.UseHttpLogging(); 

app.Use(async (context, next) =>
{
    context.Response.Headers["MyResponseHeader"] =
        new string[] { "My Response Header Value" };

    await next();
});

app.MapGet("/", () => "Hello World!");

app.Run();

Redigera känsliga data

Http-loggning med redigering kan aktiveras genom att anropa AddHttpLoggingRedaction:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(logging =>
{
    logging.LoggingFields = HttpLoggingFields.Duration;
});

builder.Services.AddRedaction();
builder.Services.AddHttpLoggingRedaction(op => { });

Mer information om . NET:s dataredigeringsbibliotek finns i Dataredigering i .NET.

Redigeringsalternativ för loggning

Om du vill konfigurera alternativ för loggning med redigering anropar du AddHttpLoggingRedactionProgram.cs med hjälp av lambda för att konfigurera LoggingRedactionOptions:

using Microsoft.Extensions.Compliance.Classification;

namespace HttpLoggingSample
{
    public static class MyTaxonomyClassifications
    {
        public static string Name => "MyTaxonomy";

        public static DataClassification Private => new(Name, nameof(Private));
        public static DataClassification Public => new(Name, nameof(Public));
        public static DataClassification Personal => new(Name, nameof(Personal));
    }
}

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

Med den tidigare redigeringskonfigurationen liknar utdata följande:

info: Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware[9]
      Request and Response:
      server.address: localhost:61361
      Path: /
      http.request.header.accept:
      Protocol: HTTP/2
      Method: GET
      Scheme: https
      http.response.header.content-type:
      StatusCode: 200
      Duration: 8.4684
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
      Request finished HTTP/2 GET https://localhost:61361/ - 200 - text/plain;+charset=utf-8 105.5334ms

Note

Begärandesökvägen /home loggas inte eftersom den ingår i egenskapenExcludePathStartsWith. http.request.header.accept och http.response.header.content-type redigerades av Microsoft.Extensions.Compliance.Redaction.ErasingRedactor.

`RequestPathLoggingMode`

RequestPathLoggingMode bestämmer hur begärans sökväg loggas, beroende på om Formatted eller Structured, fastställs av IncomingPathLoggingMode:

Formatted: Loggar begärans sökväg utan parametrar.
Structured: Loggar sökvägen för begäran med parametrarna inkluderade.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`RequestPathParameterRedactionMode`

RequestPathParameterRedactionMode anger hur routningsparametrar i förfrågningsvägen ska redigeras, antingen Strict, Loose eller None, anges av HttpRouteParameterRedactionMode:

Strict: Parametrar för begärandeväg anses vara känsliga, kräver explicit anteckning med en dataklassificering och redigeras som standard.
Loose: Alla parametrar betraktas som icke-känsliga och ingår som standard as-is.
None: Routningsparametrarna redigeras inte oavsett förekomsten av dataklassificeringsanteckningar.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`RequestHeadersDataClasses`

RequestHeadersDataClasses mappar begäranderubriker till deras dataklassificering, vilket avgör hur de redigeras:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`ResponseHeadersDataClasses`

ResponseHeadersDataClasses, liknande RequestHeadersDataClasses", men för svarshuvuden:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`RouteParameterDataClasses`

RouteParameterDataClasses mappar vägparametrar till deras dataklassificering:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`ExcludePathStartsWith`

ExcludePathStartsWith anger sökvägar som ska undantas helt från loggning:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

`IncludeUnmatchedRoutes`

IncludeUnmatchedRoutes tillåter rapportering av omatchade rutter. Om värdet är inställt på trueloggar hela sökvägen för vägar som inte identifieras av Routning i stället för loggningsvärdet Unknown för sökvägsattributet:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddHttpLogging(o => { });
builder.Services.AddRedaction();

builder.Services.AddHttpLoggingRedaction(op =>
{
    op.RequestPathParameterRedactionMode = HttpRouteParameterRedactionMode.None;
    op.RequestPathLoggingMode = IncomingPathLoggingMode.Formatted;
    op.RequestHeadersDataClasses.Add(HeaderNames.Accept, MyTaxonomyClassifications.Public);
    op.ResponseHeadersDataClasses.Add(HeaderNames.ContentType, MyTaxonomyClassifications.Private);
    op.RouteParameterDataClasses = new Dictionary<string, DataClassification>
    {
        { "one", MyTaxonomyClassifications.Personal },
    };
    // Add the paths that should be filtered, with a leading '/'.
    op.ExcludePathStartsWith.Add("/home");
    op.IncludeUnmatchedRoutes = true;
});

var app = builder.Build();

app.UseHttpLogging();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}
app.UseStaticFiles();

app.MapGet("/", () => "Logged!");
app.MapGet("/home", () => "Not logged!");

app.Run();

Feedback

Var den här sidan till hjälp?

Dela via

HTTP-loggning i ASP.NET Core

Aktivera HTTP-loggning

HTTP-loggningsalternativ

LoggingFields

RequestHeaders och ResponseHeaders

MediaTypeOptions

MediaTypeOptions metoder

RequestBodyLogLimit och ResponseBodyLogLimit

CombineLogs

Endpoint-specific configuration

IHttpLoggingInterceptor

Ordning för loggningskonfigurationers företräde

Aktivera HTTP-loggning

HTTP-loggningsalternativ

LoggingFields

RequestHeaders

MediaTypeOptions

MediaTypeOptions metoder

RequestBodyLogLimit och ResponseBodyLogLimit

Redigera känsliga data

Redigeringsalternativ för loggning

RequestPathLoggingMode

RequestPathParameterRedactionMode

RequestHeadersDataClasses

ResponseHeadersDataClasses

RouteParameterDataClasses

ExcludePathStartsWith

IncludeUnmatchedRoutes

Feedback

Ytterligare resurser

`LoggingFields`

`RequestHeaders` och `ResponseHeaders`

`MediaTypeOptions`

`MediaTypeOptions` metoder

`RequestBodyLogLimit` och `ResponseBodyLogLimit`

`CombineLogs`

`IHttpLoggingInterceptor`

`LoggingFields`

`RequestHeaders`

`MediaTypeOptions`

`MediaTypeOptions` metoder

`RequestBodyLogLimit` och `ResponseBodyLogLimit`

`RequestPathLoggingMode`

`RequestPathParameterRedactionMode`

`RequestHeadersDataClasses`

`ResponseHeadersDataClasses`

`RouteParameterDataClasses`

`ExcludePathStartsWith`

`IncludeUnmatchedRoutes`