Log enrichment with entry assembly metadata (#10283)

* log enrichment

* If no metadata, no property added.

* Wiring Assembly through from the top call.
Flag to disable metadata logging.
TelemetryInitializer with similar functionality, so we can use it both in Serilog and ApplicationInsights context.

Author: agr

src/NuGet.Services.Logging/Extensions/NuGetAssemblyMetadataEnricherExtensions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Reflection;
+using Serilog;
+using Serilog.Configuration;
+using Serilog.Enrichers;
+
+namespace NuGet.Services.Logging
+{
+    public static class NuGetAssemblyMetadataEnricherExtensions
+    {
+        public static LoggerConfiguration WithNuGetAssemblyMetadata(
+            this LoggerEnrichmentConfiguration enrichmentConfiguration,
+            Assembly metadataSourceAssembly)
+        {
+            if (enrichmentConfiguration == null)
+            {
+                throw new ArgumentNullException(nameof(enrichmentConfiguration));
+            }
+
+            if (metadataSourceAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(metadataSourceAssembly));
+            }
+
+            return enrichmentConfiguration.With(new NuGetAssemblyMetadataEnricher(metadataSourceAssembly));
+        }
+    }
+}

src/NuGet.Services.Logging/LoggingSetup.cs

@@ -1,8 +1,9 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Diagnostics;
 using System.Linq;
+using System.Reflection;
 using Microsoft.ApplicationInsights.Extensibility;
 using Microsoft.Extensions.Logging;
 using Serilog;
@@ -12,14 +13,25 @@ namespace NuGet.Services.Logging
 {
     public static class LoggingSetup
     {
-        public static LoggerConfiguration CreateDefaultLoggerConfiguration(bool withConsoleLogger = false)
+        public static LoggerConfiguration CreateDefaultLoggerConfiguration(
+            bool withConsoleLogger = false,
+            bool withAssemblyMetadata = true,
+            Assembly metadataSourceAssembly = null)
         {
             var loggerConfiguration = new LoggerConfiguration()
                 .MinimumLevel.Verbose();
 
             loggerConfiguration.Enrich.WithMachineName();
             loggerConfiguration.Enrich.WithProcessId();
             loggerConfiguration.Enrich.FromLogContext();
+            if (withAssemblyMetadata)
+            {
+                metadataSourceAssembly ??= Assembly.GetEntryAssembly();
+                if (metadataSourceAssembly != null)
+                {
+                    loggerConfiguration.Enrich.WithNuGetAssemblyMetadata(metadataSourceAssembly);
+                }
+            }
 
             if (withConsoleLogger)
             {
@@ -64,4 +76,4 @@ public static ILoggerFactory CreateLoggerFactory(
             return loggerFactory;
         }
     }
-}
+}

src/NuGet.Services.Logging/NuGetAssemblyMetadata.cs

@@ -0,0 +1,52 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Reflection;
+
+#nullable enable
+
+namespace NuGet.Services.Logging
+{
+    public class NuGetAssemblyMetadata
+    {
+        private const string BranchMetadataKey = "Branch";
+        private const string CommitIdMetadataKey = "CommitId";
+        private const string BuildDateUtcMetadataKey = "BuildDateUtc";
+
+        public string? AssemblyInformationalVersion { get; set; } = null;
+        public string? Branch { get; set; } = null;
+        public string? CommitId { get; set; } = null;
+        public string? BuildDateUtc { get; set; } = null;
+
+        public NuGetAssemblyMetadata(Assembly metadataSourceAssembly)
+        {
+            var attributes = metadataSourceAssembly?.GetCustomAttributes();
+            if (attributes is null)
+            {
+                return;
+            }
+            foreach (var attribute in attributes)
+            {
+                if (attribute is AssemblyInformationalVersionAttribute informationalVersion)
+                {
+                    AssemblyInformationalVersion = informationalVersion.InformationalVersion;
+                }
+                if (attribute is AssemblyMetadataAttribute metadataAttribute)
+                {
+                    switch (metadataAttribute.Key)
+                    {
+                        case BranchMetadataKey:
+                            Branch = metadataAttribute.Value;
+                            break;
+                        case CommitIdMetadataKey:
+                            CommitId = metadataAttribute.Value;
+                            break;
+                        case BuildDateUtcMetadataKey:
+                            BuildDateUtc = metadataAttribute.Value;
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}

src/NuGet.Services.Logging/NuGetAssemblyMetadataEnricher.cs

@@ -0,0 +1,56 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Reflection;
+using Serilog.Core;
+using Serilog.Events;
+
+#nullable enable
+
+namespace NuGet.Services.Logging
+{
+    /// <summary>
+    /// Enriches logs with entry assembly NuGet metadata:
+    /// AssemblyInformationalVersion
+    /// Branch
+    /// CommitId
+    /// BuildDateUtc
+    /// See PowerShell script that adds it: https://github.com/NuGet/NuGetGallery/blob/27bc6a62ead3110c1d8d2d2794fc8b8b646b1f1d/build/common.ps1#L884-L889
+    /// </summary>
+    public class NuGetAssemblyMetadataEnricher : ILogEventEnricher
+    {
+        public const string PropertyName = "NuGetStartingAssemblyMetadata";
+
+        private LogEventProperty? _cachedProperty = null;
+        private readonly bool _hasAssemblyMetadata = false;
+        private readonly NuGetAssemblyMetadata _assemblyMetadata;
+
+        public NuGetAssemblyMetadataEnricher(Assembly metadataSourceAssembly)
+        {
+            if (metadataSourceAssembly == null)
+            {
+                throw new ArgumentNullException(nameof(metadataSourceAssembly));
+            }
+
+            _assemblyMetadata = new NuGetAssemblyMetadata(metadataSourceAssembly);
+            _hasAssemblyMetadata =
+                _assemblyMetadata.AssemblyInformationalVersion != null
+                || _assemblyMetadata.Branch != null
+                || _assemblyMetadata.CommitId != null
+                || _assemblyMetadata.BuildDateUtc != null;
+        }
+
+        public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+        {
+            if (!_hasAssemblyMetadata)
+            {
+                return;
+            }
+
+            _cachedProperty ??= propertyFactory.CreateProperty(PropertyName, _assemblyMetadata, destructureObjects: true);
+
+            logEvent.AddPropertyIfAbsent(_cachedProperty);
+        }
+    }
+}

src/NuGet.Services.Logging/TelemetryInitializers/NuGetAssemblyMetadataTelemetryInitializer.cs

@@ -0,0 +1,59 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Microsoft.ApplicationInsights.Channel;
+using Microsoft.ApplicationInsights.DataContracts;
+using Microsoft.ApplicationInsights.Extensibility;
+
+#nullable enable
+
+namespace NuGet.Services.Logging
+{
+    public class NuGetAssemblyMetadataTelemetryInitializer : ITelemetryInitializer
+    {
+        private readonly NuGetAssemblyMetadata _assemblyMetadata;
+
+        public NuGetAssemblyMetadataTelemetryInitializer(Assembly metadataSourceAssembly)
+        {
+            if (metadataSourceAssembly is null)
+            {
+                throw new ArgumentNullException(nameof(metadataSourceAssembly));
+            }
+
+            _assemblyMetadata = new NuGetAssemblyMetadata(metadataSourceAssembly);
+        }
+
+        public void Initialize(ITelemetry telemetry)
+        {
+            if (telemetry is not ISupportProperties itemTelemetry)
+            {
+                return;
+            }
+
+            itemTelemetry.Properties
+                .AddPropertyIfAbsent(nameof(_assemblyMetadata.AssemblyInformationalVersion), _assemblyMetadata.AssemblyInformationalVersion)
+                .AddPropertyIfAbsent(nameof(_assemblyMetadata.Branch), _assemblyMetadata.Branch)
+                .AddPropertyIfAbsent(nameof(_assemblyMetadata.CommitId), _assemblyMetadata.CommitId)
+                .AddPropertyIfAbsent(nameof(_assemblyMetadata.BuildDateUtc), _assemblyMetadata.BuildDateUtc);
+        }
+    }
+
+    internal static class DictionaryExtensions
+    {
+        public static IDictionary<string, string> AddPropertyIfAbsent(
+            this IDictionary<string, string> dictionary,
+            string propertyName,
+            string? propertyValue)
+        {
+            if (!dictionary.ContainsKey(propertyName) && propertyValue is not null)
+            {
+                dictionary.Add(propertyName, propertyValue);
+            }
+
+            return dictionary;
+        }
+    }
+}

src/NuGetGallery/App_Start/DefaultDependenciesModule.cs

@@ -108,7 +108,7 @@ protected override void Load(ContainerBuilder builder)
                 configuration.Current,
                 out ITelemetryClient telemetryClient);
 
-            var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(withConsoleLogger: false);
+            var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(withConsoleLogger: false, withAssemblyMetadata: false);
             var loggerFactory = LoggingSetup.CreateLoggerFactory(
                 loggerConfiguration,
                 telemetryConfiguration: applicationInsightsConfiguration.TelemetryConfiguration);