Use the same naming rules for the names of logging dimensions

src/Generators/Microsoft.Gen.Logging/Emission/Emitter.Method.cs

@@ -316,7 +316,7 @@ void GenPropertyLoads(LoggingMethod lm, string stateName, out int numReservedUnc
                         {
                             if (!member.HasDataClassification)
                             {
-                                var propName = PropertyChainToString(propertyChain, member, "_", omitReferenceName: p.OmitReferenceName);
+                                var propName = PropertyChainToString(propertyChain, member, ".", omitReferenceName: p.OmitReferenceName);
                                 var accessExpression = PropertyChainToString(propertyChain, member, "?.", nonNullSeparator: ".");
 
                                 var ts = ShouldStringifyProperty(member)
@@ -367,7 +367,7 @@ void GenPropertyLoads(LoggingMethod lm, string stateName, out int numReservedUnc
                         {
                             if (member.HasDataClassification)
                             {
-                                var propName = PropertyChainToString(propertyChain, member, "_", omitReferenceName: p.OmitReferenceName);
+                                var propName = PropertyChainToString(propertyChain, member, ".", omitReferenceName: p.OmitReferenceName);
                                 var accessExpression = PropertyChainToString(propertyChain, member, "?.", nonNullSeparator: ".");
 
                                 var value = ShouldStringifyProperty(member)
@@ -391,7 +391,7 @@ void GenPropertyLoads(LoggingMethod lm, string stateName, out int numReservedUnc
                     {
                         if (member.HasDataClassification)
                         {
-                            var propName = PropertyChainToString(propertyChain, member, "_", omitReferenceName: p.OmitReferenceName);
+                            var propName = PropertyChainToString(propertyChain, member, ".", omitReferenceName: p.OmitReferenceName);
                             var accessExpression = PropertyChainToString(propertyChain, member, "?.", nonNullSeparator: ".");
 
                             var value = ShouldStringifyProperty(member)
@@ -418,7 +418,7 @@ void GenPropertyLoads(LoggingMethod lm, string stateName, out int numReservedUnc
                         }
                         else
                         {
-                            var propName = PropertyChainToString(propertyChain, member, "_", omitReferenceName: p.OmitReferenceName);
+                            var propName = PropertyChainToString(propertyChain, member, ".", omitReferenceName: p.OmitReferenceName);
                             var accessExpression = PropertyChainToString(propertyChain, member, "?.", nonNullSeparator: ".");
 
                             var ts = ShouldStringifyProperty(member)

src/Libraries/Microsoft.AspNetCore.Diagnostics.Middleware/Logging/HttpLoggingTagNames.cs

@@ -19,7 +19,7 @@ public static class HttpLoggingTagNames
     /// <summary>
     /// HTTP Host.
     /// </summary>
-    public const string Host = "Host";
+    public const string Host = "server.address";
 
     /// <summary>
     /// HTTP Method.
@@ -34,12 +34,12 @@ public static class HttpLoggingTagNames
     /// <summary>
     /// HTTP Request Headers prefix.
     /// </summary>
-    public const string RequestHeaderPrefix = "RequestHeader.";
+    public const string RequestHeaderPrefix = "http.request.header.";
 
     /// <summary>
     /// HTTP Response Headers prefix.
     /// </summary>
-    public const string ResponseHeaderPrefix = "ResponseHeader.";
+    public const string ResponseHeaderPrefix = "http.response.header.";
 
     /// <summary>
     /// HTTP Request Body.

src/Libraries/Microsoft.AspNetCore.HeaderParsing/HeaderParsingFeature.cs

@@ -198,12 +198,12 @@ private void CopyTo(Box<T> to)
         }
     }
 
-    [LoggerMessage(LogLevel.Debug, "Can't parse header '{headerName}' due to '{error}'.")]
+    [LoggerMessage(LogLevel.Debug, "Can't parse header '{HeaderName}' due to '{Error}'.")]
     private partial void LogParsingError(string headerName, string error);
 
-    [LoggerMessage(LogLevel.Debug, "Using a default value for header '{headerName}'.")]
+    [LoggerMessage(LogLevel.Debug, "Using a default value for header '{HeaderName}'.")]
     private partial void LogDefaultUsage(string headerName);
 
-    [LoggerMessage(LogLevel.Debug, "Header '{headerName}' not found.")]
+    [LoggerMessage(LogLevel.Debug, "Header '{HeaderName}' not found.")]
     private partial void LogNotFound(string headerName);
 }

src/Libraries/Microsoft.Extensions.Diagnostics.Extra/Enrichment/ApplicationEnricherTags.cs

@@ -14,22 +14,22 @@ public static class ApplicationEnricherTags
     /// <summary>
     /// Application name.
     /// </summary>
-    public const string ApplicationName = "AppName";
+    public const string ApplicationName = "service.name";
 
     /// <summary>
     /// Environment name.
     /// </summary>
-    public const string EnvironmentName = "CloudEnv";
+    public const string EnvironmentName = "deployment.environment";
 
     /// <summary>
     /// Deployment ring.
     /// </summary>
-    public const string DeploymentRing = "CloudDeploymentRing";
+    public const string DeploymentRing = "DeploymentRing";
 
     /// <summary>
     /// Build version.
     /// </summary>
-    public const string BuildVersion = "CloudRoleVer";
+    public const string BuildVersion = "service.version";
 
     /// <summary>
     /// Gets a list of all dimension names.

src/Libraries/Microsoft.Extensions.Diagnostics.Extra/Enrichment/ProcessEnricherTagNames.cs

@@ -14,12 +14,12 @@ public static class ProcessEnricherTagNames
     /// <summary>
     /// Process ID.
     /// </summary>
-    public const string ProcessId = "pid";
+    public const string ProcessId = "process.pid";
 
     /// <summary>
     /// Thread ID.
     /// </summary>
-    public const string ThreadId = "tid";
+    public const string ThreadId = "thread.id";
 
     /// <summary>
     /// Gets a list of all dimension names.

src/Libraries/Microsoft.Extensions.Diagnostics.ExtraAbstractions/Logging/LoggerMessageState.TagCollector.cs

@@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Logging;
 
 public partial class LoggerMessageState : ITagCollector
 {
-    private const char Separator = '_';
+    private const char Separator = '.';
 
     /// <inheritdoc />
     void ITagCollector.Add(string tagName, object? tagValue)

src/Libraries/Microsoft.Extensions.Diagnostics.HealthChecks.Common/Log.cs

@@ -8,13 +8,13 @@ namespace Microsoft.Extensions.Diagnostics.HealthChecks;
 
 internal static partial class Log
 {
-    [LoggerMessage(0, LogLevel.Warning, "Process reporting unhealthy: {status}. Health check entries are {entries}")]
+    [LoggerMessage(0, LogLevel.Warning, "Process reporting unhealthy: {Status}. Health check entries are {Entries}")]
     public static partial void Unhealthy(
         ILogger logger,
         HealthStatus status,
         StringBuilder entries);
 
-    [LoggerMessage(1, LogLevel.Debug, "Process reporting healthy: {status}.")]
+    [LoggerMessage(1, LogLevel.Debug, "Process reporting healthy: {Status}.")]
     public static partial void Healthy(
         ILogger logger,
         HealthStatus status);

src/Libraries/Microsoft.Extensions.Diagnostics.ResourceMonitoring/Log.cs

@@ -14,6 +14,6 @@ internal static partial class Log
     [LoggerMessage(1, LogLevel.Error, "Unable to gather utilization statistics.")]
     public static partial void HandledGatherStatisticsException(ILogger logger, Exception e);
 
-    [LoggerMessage(2, LogLevel.Error, "Publisher `{publisher}` was unable to publish utilization statistics.")]
+    [LoggerMessage(2, LogLevel.Error, "Publisher `{Publisher}` was unable to publish utilization statistics.")]
     public static partial void HandlePublishUtilizationException(ILogger logger, Exception e, string publisher);
 }

src/Libraries/Microsoft.Extensions.Hosting.Testing/HostTerminatorService.cs

@@ -60,7 +60,7 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         _host.Dispose();
     }
 
-    [LoggerMessage(0, LogLevel.Warning, "FakeHostOptions.TimeToLive set to {timeToLive} is up, disposing the host.")]
+    [LoggerMessage(0, LogLevel.Warning, "FakeHostOptions.TimeToLive set to {TimeToLive} is up, disposing the host.")]
     private partial void LogTimeToLiveUp(TimeSpan timeToLive);
 
     [LoggerMessage(1, LogLevel.Information, "Debugger is attached. The host won't be automatically disposed.")]

src/Libraries/Microsoft.Extensions.Http.Diagnostics/Latency/Internal/HttpClientLatencyLogEnricher.cs

@@ -50,7 +50,7 @@ public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request
                 AppendCheckpoints(lc, stringBuilder);
             }
 
-            collector.Add("latencyInfo", stringBuilder.ToString());
+            collector.Add("LatencyInfo", stringBuilder.ToString());
 
             _builderPool.Return(stringBuilder);
         }

src/Libraries/Microsoft.Extensions.Http.Diagnostics/Logging/HttpClientLoggingTagNames.cs

@@ -14,47 +14,47 @@ public static class HttpClientLoggingTagNames
     /// <summary>
     /// HTTP Request duration.
     /// </summary>
-    public const string Duration = "duration";
+    public const string Duration = "Duration";
 
     /// <summary>
     /// HTTP Host.
     /// </summary>
-    public const string Host = "httpHost";
+    public const string Host = "server.address";
 
     /// <summary>
     /// HTTP Method.
     /// </summary>
-    public const string Method = "httpMethod";
+    public const string Method = "http.request.method";
 
     /// <summary>
     /// HTTP Path.
     /// </summary>
-    public const string Path = "httpPath";
+    public const string Path = "url.path";
 
     /// <summary>
     /// HTTP Request Body.
     /// </summary>
-    public const string RequestBody = "httpRequestBody";
+    public const string RequestBody = "RequestBody";
 
     /// <summary>
     /// HTTP Response Body.
     /// </summary>
-    public const string ResponseBody = "httpResponseBody";
+    public const string ResponseBody = "ResponseBody";
 
     /// <summary>
     /// HTTP Request Headers prefix.
     /// </summary>
-    public const string RequestHeaderPrefix = "httpRequestHeader_";
+    public const string RequestHeaderPrefix = "http.request.header.";
 
     /// <summary>
     /// HTTP Response Headers prefix.
     /// </summary>
-    public const string ResponseHeaderPrefix = "httpResponseHeader_";
+    public const string ResponseHeaderPrefix = "http.response.header.";
 
     /// <summary>
     /// HTTP Status Code.
     /// </summary>
-    public const string StatusCode = "httpStatusCode";
+    public const string StatusCode = "http.response.status_code";
 
     /// <summary>
     /// Gets a list of all tag names.

src/Libraries/Microsoft.Extensions.Http.Diagnostics/Logging/Internal/Log.cs

@@ -12,10 +12,10 @@ namespace Microsoft.Extensions.Http.Logging.Internal;
 /// Logs <see cref="HttpRequestMessage"/>, <see cref="HttpResponseMessage"/> and the exceptions due to errors of request/response.
 /// </summary>
 [SuppressMessage("Major Code Smell", "S109:Magic numbers should not be used", Justification = "Event ID's.")]
-internal static partial class Log
+internal static class Log
 {
     internal const string OriginalFormat = "{OriginalFormat}";
-    internal const string OriginalFormatValue = "{httpMethod} {httpHost}/{httpPath}";
+    private const string NullString = "(null)";
 
     private const int MinimalPropertyCount = 4;
 
@@ -28,10 +28,10 @@ internal static partial class Log
         $"{{{HttpClientLoggingTagNames.Method}}} {{{HttpClientLoggingTagNames.Host}}}/{{{HttpClientLoggingTagNames.Path}}}";
 
     private const string LoggerContextMissingMessage =
-        $"The logger couldn't read its context for {{requestState}} request: {{{HttpClientLoggingTagNames.Method}}} {{{HttpClientLoggingTagNames.Host}}}";
+        $"The logger couldn't read its context for {{RequestState}} request: {{{HttpClientLoggingTagNames.Method}}} {{{HttpClientLoggingTagNames.Host}}}";
 
     private const string EnrichmentErrorMessage =
-        "An error occurred in enricher '{enricherType}' while enriching the logger context for request: " +
+        "An error occurred in enricher '{Enricher}' while enriching the logger context for request: " +
         $"{{{HttpClientLoggingTagNames.Method}}} {{{HttpClientLoggingTagNames.Host}}}/{{{HttpClientLoggingTagNames.Path}}}";
 
     private static readonly Func<LoggerMessageState, Exception?, string> _originalFormatValueFMTFunc = OriginalFormatValueFMT;
@@ -46,17 +46,114 @@ public static void OutgoingRequestError(ILogger logger, LogRecord record, Except
         OutgoingRequest(logger, LogLevel.Error, 2, nameof(OutgoingRequestError), record, exception);
     }
 
-    [LoggerMessage(LogLevel.Error, RequestReadErrorMessage)]
-    public static partial void RequestReadError(ILogger logger, Exception exception, HttpMethod httpMethod, string? httpHost, string? httpPath);
+    public static void RequestReadError(ILogger logger, Exception exception, HttpMethod method, string? host, string? path)
+    {
+        var state = LoggerMessageHelper.ThreadLocalState;
+
+        _ = state.ReserveTagSpace(4);
+        state.TagArray[3] = new(HttpClientLoggingTagNames.Method, method);
+        state.TagArray[2] = new(HttpClientLoggingTagNames.Host, host);
+        state.TagArray[1] = new(HttpClientLoggingTagNames.Path, path);
+        state.TagArray[0] = new(OriginalFormat, RequestReadErrorMessage);
+
+        logger.Log(
+            LogLevel.Error,
+            new(0, nameof(RequestReadError)),
+            state,
+            exception,
+            static (s, _) =>
+            {
+                var method = s.TagArray[3].Value ?? NullString;
+                var host = s.TagArray[2].Value ?? NullString;
+                var path = s.TagArray[1].Value ?? NullString;
+                return FormattableString.Invariant(
+                    $"An error occurred while reading the request data to fill the logger context for request: {method} {host}/{path}");
+            });
+
+        state.Clear();
+    }
 
-    [LoggerMessage(LogLevel.Error, ResponseReadErrorMessage)]
-    public static partial void ResponseReadError(ILogger logger, Exception exception, HttpMethod httpMethod, string httpHost, string httpPath);
+    public static void ResponseReadError(ILogger logger, Exception exception, HttpMethod method, string host, string path)
+    {
+        var state = LoggerMessageHelper.ThreadLocalState;
 
-    [LoggerMessage(LogLevel.Error, LoggerContextMissingMessage)]
-    public static partial void LoggerContextMissing(ILogger logger, Exception? exception, string requestState, HttpMethod httpMethod, string? httpHost);
+        _ = state.ReserveTagSpace(4);
+        state.TagArray[3] = new(HttpClientLoggingTagNames.Method, method);
+        state.TagArray[2] = new(HttpClientLoggingTagNames.Host, host);
+        state.TagArray[1] = new(HttpClientLoggingTagNames.Path, path);
+        state.TagArray[0] = new(OriginalFormat, ResponseReadErrorMessage);
+
+        logger.Log(
+            LogLevel.Error,
+            new(0, nameof(ResponseReadError)),
+            state,
+            exception,
+            static (s, _) =>
+            {
+                var method = s.TagArray[3].Value ?? NullString;
+                var host = s.TagArray[2].Value ?? NullString;
+                var path = s.TagArray[1].Value ?? NullString;
+                return FormattableString.Invariant(
+                    $"An error occurred while reading the response data to fill the logger context for request: {method} {host}/{path}");
+            });
+
+        state.Clear();
+    }
+
+    public static void LoggerContextMissing(ILogger logger, Exception? exception, string requestState, HttpMethod method, string? host)
+    {
+        var state = LoggerMessageHelper.ThreadLocalState;
 
-    [LoggerMessage(LogLevel.Error, EnrichmentErrorMessage)]
-    public static partial void EnrichmentError(ILogger logger, Exception exception, string? enricherType, HttpMethod httpMethod, string httpHost, string httpPath);
+        _ = state.ReserveTagSpace(4);
+        state.TagArray[3] = new("RequestState", requestState);
+        state.TagArray[2] = new(HttpClientLoggingTagNames.Method, method);
+        state.TagArray[1] = new(HttpClientLoggingTagNames.Host, host);
+        state.TagArray[0] = new(OriginalFormat, LoggerContextMissingMessage);
+
+        logger.Log(
+            LogLevel.Error,
+            new(0, nameof(LoggerContextMissing)),
+            state,
+            exception,
+            (s, _) =>
+            {
+                var requestState = s.TagArray[3].Value ?? NullString;
+                var method = s.TagArray[2].Value ?? NullString;
+                var host = s.TagArray[1].Value ?? NullString;
+                return FormattableString.Invariant($"The logger couldn't read its context for {requestState} request: {method} {host}");
+            });
+
+        state.Clear();
+    }
+
+    public static void EnrichmentError(ILogger logger, Exception exception, string? enricher, HttpMethod method, string host, string path)
+    {
+        var state = LoggerMessageHelper.ThreadLocalState;
+
+        _ = state.ReserveTagSpace(5);
+        state.TagArray[4] = new("Enricher", enricher);
+        state.TagArray[3] = new(HttpClientLoggingTagNames.Method, method);
+        state.TagArray[2] = new(HttpClientLoggingTagNames.Host, host);
+        state.TagArray[1] = new(HttpClientLoggingTagNames.Path, path);
+        state.TagArray[0] = new(OriginalFormat, EnrichmentErrorMessage);
+
+        logger.Log(
+            LogLevel.Error,
+            new(0, nameof(EnrichmentError)),
+            state,
+            exception,
+            (s, _) =>
+            {
+                var enricher = s.TagArray[4].Value ?? NullString;
+                var method = s.TagArray[3].Value ?? NullString;
+                var host = s.TagArray[2].Value ?? NullString;
+                var path = s.TagArray[1].Value ?? NullString;
+                return FormattableString.Invariant(
+                    $"An error occurred in enricher '{enricher}' while enriching the logger context for request: {method} {host}/{path}");
+            });
+
+        state.Clear();
+    }
 
     // Using the code below instead of generated logging method because we have a custom formatter and custom tag keys for headers.
     private static void OutgoingRequest(

test/Generators/Microsoft.Gen.Logging/Generated/LogMethodTests.cs

@@ -751,7 +751,7 @@ public void AtSymbolsTest()
 
         collector.Clear();
         AtSymbolsTestExtensions.M3(logger, LogLevel.Debug, o);
-        Assert.Equal("42", collector.LatestRecord.StructuredState!.GetValue("event_class"));
+        Assert.Equal("42", collector.LatestRecord.StructuredState!.GetValue("event.class"));
 
         collector.Clear();
         AtSymbolsTestExtensions.M5(logger, LogLevel.Debug, o);
@@ -892,7 +892,7 @@ public void FormattableTest()
         collector.Clear();
         FormattableTestExtensions.Method2(logger, new FormattableTestExtensions.ComplexObj());
         Assert.Equal(1, collector.Count);
-        Assert.Equal("Formatted!", collector.LatestRecord.StructuredState!.GetValue("p1_P1"));
+        Assert.Equal("Formatted!", collector.LatestRecord.StructuredState!.GetValue("p1.P1"));
 
         collector.Clear();
         FormattableTestExtensions.Method3(logger, default);