Merge pull request #35185 from dotnet/main

Merge to Live

Author: Rick-Anderson

aspnetcore/fundamentals/http-logging/index.md

@@ -207,22 +207,22 @@ The following list shows the order of precedence for logging configuration:
 
 [!INCLUDE[](~/fundamentals/http-logging/includes/index-6-7.md)]
 
-:::moniker range=">= aspnetcore-10.0"
+:::moniker range=">= aspnetcore-9.0"
 
 ## Redacting sensitive data
 
 Http logging with redaction can be enabled by calling `AddHttpLoggingRedaction`<!-- Microsoft.Extensions.DependencyInjection.HttpLoggingServiceCollectionExtensions.AddHttpLoggingRedaction> -->:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet7&highlight=9)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet7&highlight=9)]
 
 For more information about .NET's data redaction library, see [Data redaction in .NET](/dotnet/core/extensions/data-redaction).
 
 ## Logging redaction options
 
 To configure options for logging with redaction, call `AddHttpLoggingRedaction`<!-- Microsoft.Extensions.DependencyInjection.HttpLoggingServiceCollectionExtensions.AddHttpLoggingRedaction>--> in `Program.cs`, using the lambda to configure <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions>--> `LoggingRedactionOptions`:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/MyTaxonomyClassifications.cs)]
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=6)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/MyTaxonomyClassifications.cs)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=6)]
 
 With the previous redaction configuration, the output is similar to the following:
 
@@ -254,53 +254,55 @@ info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.IncomingPathLoggingMode.Structured> -->
 * `Structured` logs the request path with parameters included.
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=9)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=9)]
 
 ### RequestPathParameterRedactionMode
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.RequestPathParameterRedactionMode> -->
-`RequestPathParameterRedactionMode` specifies how route parameters in the request path should be redacted, whether `Strict` or `None`.
+`RequestPathParameterRedactionMode` specifies how route parameters in the request path should be redacted, whether `Strict`, `Loose`, or `None`.
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.HttpRouteParameterRedactionMode.Strict>-->
-* `Strict`: request route parameters are considered as sensitive and are redacted by default.
+* `Strict`: Request route parameters are considered sensitive, require explicit annotation with a data classification, and are redacted by default.
+<!-- Microsoft.AspNetCore.Diagnostics.Logging.HttpRouteParameterRedactionMode.Loose>-->
+* `Loose`: All parameters are considered as non-sensitive and included as-is by default.
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.HttpRouteParameterRedactionMode.None>-->
-* `None`: request route parameters are considered as non-sensitive and logged as-is by default.
+* `None`: Route parameters aren't redacted regardless of the presence of data classification annotations.
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=8)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=8)]
 
 ### RequestHeadersDataClasses
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.RequestHeadersDataClasses>-->
 `RequestHeadersDataClasses` maps request headers to their data classification, which determines how they are redacted:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=10)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=10)]
 
 ### ResponseHeadersDataClasses
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.ResponseHeadersDataClasses>-->
 `ResponseHeadersDataClasses`, similar to <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.RequestHeadersDataClasses>--> `RequestHeadersDataClasses`, but for response headers:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=11)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=11)]
 
 ### RouteParameterDataClasses
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.RouteParameterDataClasses>-->
 `RouteParameterDataClasses` maps route parameters to their data classification:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=12,13,14,15)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=12,13,14,15)]
 
 ### ExcludePathStartsWith
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.ExcludePathStartsWith>-->
 `ExcludePathStartsWith` specifies paths that should be excluded from logging entirely:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=16,17)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=16,17)]
 
 ### IncludeUnmatchedRoutes
 
 <!-- Microsoft.AspNetCore.Diagnostics.Logging.LoggingRedactionOptions.IncludeUnmatchedRoutes>-->
 `IncludeUnmatchedRoutes` allows reporting unmatched routes. If set to `true`, logs whole path of routes not identified by [Routing](xref:fundamentals/routing) instead of logging `Unknown` value for path attribute:
 
-[!code-csharp[](~/fundamentals/http-logging/samples/8.x/Program.cs?name=snippet_redactionOptions&highlight=18)]
+[!code-csharp[](~/fundamentals/http-logging/samples/9.x/Program.cs?name=snippet_redactionOptions&highlight=18)]
 
 :::moniker-end

aspnetcore/fundamentals/http-logging/samples/8.x/HttpLoggingSample.csproj

@@ -5,10 +5,4 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.Middleware" Version="9.3.0" />
-    <PackageReference Include="Microsoft.Extensions.Compliance.Redaction" Version="9.3.0" />
-  </ItemGroup>
-
 </Project>

aspnetcore/fundamentals/http-logging/samples/8.x/Program.cs

@@ -1,4 +1,4 @@
-#define THIRD // FIRST SECOND THIRD FORTH
+#define THIRD // FIRST SECOND THIRD
 #if NEVER
 #elif FIRST
 // <snippet_Addservices>
@@ -60,54 +60,10 @@
 
 app.Run();
 // </snippet2>
-#elif FORTH
-using Microsoft.Extensions.Http.Diagnostics;
-using Microsoft.AspNetCore.Diagnostics.Logging;
-using Microsoft.Extensions.Compliance.Classification;
-using HttpLoggingSample;
-using Microsoft.Net.Http.Headers;
-
-// <snippet_redactionOptions>
-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();
-// </snippet_redactionOptions>
 #elif THIRD
 // <snippet3>
 using HttpLoggingSample;
 using Microsoft.AspNetCore.HttpLogging;
-// <snippet7>
 // <snippet4>
 var builder = WebApplication.CreateBuilder(args);
 
@@ -117,9 +73,6 @@
 });
 builder.Services.AddHttpLoggingInterceptor<SampleHttpLoggingInterceptor>();
 // </snippet4>
-builder.Services.AddRedaction();
-builder.Services.AddHttpLoggingRedaction(op => { });
-// </snippet7>
 var app = builder.Build();
 
 if (!app.Environment.IsDevelopment())

aspnetcore/fundamentals/http-logging/samples/9.x/HttpLoggingSample.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Diagnostics.Middleware" Version="9.4.0" />
+    <PackageReference Include="Microsoft.Extensions.Compliance.Redaction" Version="9.4.0" />
+  </ItemGroup>
+
+</Project>

aspnetcore/fundamentals/http-logging/samples/8.x/MyTaxonomyClassifications.cs renamed to aspnetcore/fundamentals/http-logging/samples/9.x/MyTaxonomyClassifications.cs

@@ -0,0 +1,43 @@
+using Microsoft.Extensions.Http.Diagnostics;
+using Microsoft.AspNetCore.Diagnostics.Logging;
+using Microsoft.Extensions.Compliance.Classification;
+using HttpLoggingSample;
+using Microsoft.Net.Http.Headers;
+
+// <snippet_redactionOptions>
+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();
+// </snippet_redactionOptions>
+

aspnetcore/fundamentals/http-logging/samples/9.x/Program.cs

@@ -0,0 +1,85 @@
+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");
+    }
+}
+

aspnetcore/fundamentals/http-logging/samples/9.x/SampleHttpLoggingInterceptor.cs

@@ -0,0 +1,11 @@
+{
+  "DetailedErrors": true,
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning",
+      "Microsoft.AspNetCore.Hosting": "Information",
+      "Microsoft.AspNetCore.HttpLogging.HttpLoggingMiddleware": "Information"
+    }
+  }
+}

aspnetcore/fundamentals/http-logging/samples/9.x/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}