Add changes for log analytics / azure monitoring for Linux Dedicated (#5212)

ankitkumarr · web-flow · commit c6f6ecbd0b20 · 2019-12-11T17:49:46.000-08:00
diff --git a/src/WebJobs.Script.WebHost/Diagnostics/LinuxAppServiceEventGenerator.cs b/src/WebJobs.Script.WebHost/Diagnostics/LinuxAppServiceEventGenerator.cs
@@ -9,13 +9,15 @@ namespace Microsoft.Azure.WebJobs.Script.WebHost.Diagnostics
     internal class LinuxAppServiceEventGenerator : LinuxEventGenerator
     {
         private readonly LinuxAppServiceFileLoggerFactory _loggerFactory;
+        private readonly HostNameProvider _hostNameProvider;
 
-        public LinuxAppServiceEventGenerator(LinuxAppServiceFileLoggerFactory loggerFactory)
+        public LinuxAppServiceEventGenerator(LinuxAppServiceFileLoggerFactory loggerFactory, HostNameProvider hostNameProvider)
         {
             _loggerFactory = loggerFactory;
+            _hostNameProvider = hostNameProvider ?? throw new ArgumentNullException(nameof(hostNameProvider));
         }
 
-        public static string TraceEventRegex { get; } = $"(?<Level>[0-6]),(?<SubscriptionId>[^,]*),(?<AppName>[^,]*),(?<FunctionName>[^,]*),(?<EventName>[^,]*),(?<Source>[^,]*),\"(?<Details>.*)\",\"(?<Summary>.*)\",(?<HostVersion>[^,]*),(?<EventTimestamp>[^,]+),(?<ExceptionType>[^,]*),\"(?<ExceptionMessage>.*)\",(?<FunctionInvocationId>[^,]*),(?<HostInstanceId>[^,]*),(?<ActivityId>[^,\"]*)";
+        public static string TraceEventRegex { get; } = $"(?<Level>[0-6]),(?<SubscriptionId>[^,]*),(?<HostName>[^,]*),(?<AppName>[^,]*),(?<FunctionName>[^,]*),(?<EventName>[^,]*),(?<Source>[^,]*),\"(?<Details>.*)\",\"(?<Summary>.*)\",(?<HostVersion>[^,]*),(?<EventTimestamp>[^,]+),(?<ExceptionType>[^,]*),\"(?<ExceptionMessage>.*)\",(?<FunctionInvocationId>[^,]*),(?<HostInstanceId>[^,]*),(?<ActivityId>[^,\"]*)";
 
         public static string MetricEventRegex { get; } = $"(?<SubscriptionId>[^,]*),(?<AppName>[^,]*),(?<FunctionName>[^,]*),(?<EventName>[^,]*),(?<Average>\\d*),(?<Min>\\d*),(?<Max>\\d*),(?<Count>\\d*),(?<HostVersion>[^,]*),(?<EventTimestamp>[^,]+),(?<Details>[^,\"]*)";
 
@@ -27,10 +29,11 @@ public override void LogFunctionTraceEvent(LogLevel level, string subscriptionId
         {
             var eventTimestamp = DateTime.UtcNow.ToString(EventTimestampFormat);
             var hostVersion = ScriptHost.Version;
+            var hostName = _hostNameProvider.Value;
             FunctionsSystemLogsEventSource.Instance.SetActivityId(activityId);
 
             var logger = _loggerFactory.GetOrCreate(FunctionsLogsCategory);
-            WriteEvent(logger, $"{(int)ToEventLevel(level)},{subscriptionId},{appName},{functionName},{eventName},{source},{NormalizeString(details)},{NormalizeString(summary)},{hostVersion},{eventTimestamp},{exceptionType},{NormalizeString(exceptionMessage)},{functionInvocationId},{hostInstanceId},{activityId}");
+            WriteEvent(logger, $"{(int)ToEventLevel(level)},{subscriptionId},{hostName},{appName},{functionName},{eventName},{source},{NormalizeString(details)},{NormalizeString(summary)},{hostVersion},{eventTimestamp},{exceptionType},{NormalizeString(exceptionMessage)},{functionInvocationId},{hostInstanceId},{activityId}");
         }
 
         public override void LogFunctionMetricEvent(string subscriptionId, string appName, string functionName, string eventName, long average,
diff --git a/src/WebJobs.Script.WebHost/Diagnostics/LinuxEventGenerator.cs b/src/WebJobs.Script.WebHost/Diagnostics/LinuxEventGenerator.cs
@@ -12,16 +12,23 @@ public abstract class LinuxEventGenerator : IEventGenerator
         public static readonly string EventTimestampFormat = "MM/dd/yyyy hh:mm:ss.fff tt";
 
         // These names should match the source file names for fluentd
-        public static readonly string FunctionsLogsCategory = "functionslogs";
+        public static readonly string FunctionsLogsCategory = "functionslogsv2";
         public static readonly string FunctionsMetricsCategory = "functionsmetrics";
         public static readonly string FunctionsDetailsCategory = "functionsdetails";
         public static readonly string FunctionsExecutionEventsCategory = "functionexecutionevents";
 
         internal static string NormalizeString(string value)
         {
-            // need to remove newlines for csv output
+            // Need to remove newlines for csv output
             value = value.Replace(Environment.NewLine, " ");
 
+            // Need to replace double quotes with single quotes as
+            // our regex query looks at double quotes as delimeter for
+            // individual column
+            // TODO: Once the regex takes into account for quotes, we can
+            // safely remove this
+            value = value.Replace("\"", "'");
+
             // Wrap string literals in enclosing quotes
             // For string columns that may contain quotes and/or
             // our delimiter ',', before writing the value we
diff --git a/src/WebJobs.Script.WebHost/HostNameProvider.cs b/src/WebJobs.Script.WebHost/HostNameProvider.cs
@@ -21,13 +21,11 @@ namespace Microsoft.Azure.WebJobs.Script.WebHost
     public class HostNameProvider
     {
         private readonly IEnvironment _environment;
-        private readonly ILogger _logger;
         private string _hostName;
 
-        public HostNameProvider(IEnvironment environment, ILogger<HostNameProvider> logger)
+        public HostNameProvider(IEnvironment environment)
         {
             _environment = environment ?? throw new ArgumentNullException(nameof(environment));
-            _logger = logger;
         }
 
         public virtual string Value
@@ -52,17 +50,17 @@ public virtual string Value
             }
         }
 
-        public virtual void Synchronize(HttpRequest request)
+        public virtual void Synchronize(HttpRequest request, ILogger logger)
         {
             string hostNameHeaderValue = request.Headers[ScriptConstants.AntaresDefaultHostNameHeader];
             if (!string.IsNullOrEmpty(hostNameHeaderValue) &&
                 string.Compare(Value, hostNameHeaderValue) != 0)
             {
-                    if (string.Compare(Value, hostNameHeaderValue) != 0)
-                    {
-                        _logger.LogInformation("HostName updated from '{0}' to '{1}'", Value, hostNameHeaderValue);
-                        _hostName = hostNameHeaderValue;
-                    }
+                if (string.Compare(Value, hostNameHeaderValue) != 0)
+                {
+                    logger.LogInformation("HostName updated from '{0}' to '{1}'", Value, hostNameHeaderValue);
+                    _hostName = hostNameHeaderValue;
+                }
             }
         }
 
diff --git a/src/WebJobs.Script.WebHost/Middleware/HostnameFixupMiddleware.cs b/src/WebJobs.Script.WebHost/Middleware/HostnameFixupMiddleware.cs
@@ -3,24 +3,26 @@
 
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
 
 namespace Microsoft.Azure.WebJobs.Script.WebHost.Middleware
 {
     public class HostnameFixupMiddleware
     {
         private readonly RequestDelegate _next;
         private readonly HostNameProvider _hostNameProvider;
+        private readonly ILogger _logger;
 
-        public HostnameFixupMiddleware(RequestDelegate next, HostNameProvider hostNameProvider)
+        public HostnameFixupMiddleware(RequestDelegate next, HostNameProvider hostNameProvider, ILogger<HostnameFixupMiddleware> logger)
         {
             _next = next;
             _hostNameProvider = hostNameProvider;
+            _logger = logger;
         }
 
         public async Task Invoke(HttpContext context)
         {
-            _hostNameProvider.Synchronize(context.Request);
-
+            _hostNameProvider.Synchronize(context.Request, _logger);
             await _next.Invoke(context);
         }
     }
diff --git a/src/WebJobs.Script.WebHost/WebHostServiceCollectionExtensions.cs b/src/WebJobs.Script.WebHost/WebHostServiceCollectionExtensions.cs
@@ -91,7 +91,8 @@ public static void AddWebJobsScriptHost(this IServiceCollection services, IConfi
                 }
                 else if (SystemEnvironment.Instance.IsLinuxAppService())
                 {
-                    return new LinuxAppServiceEventGenerator(new LinuxAppServiceFileLoggerFactory());
+                    var hostNameProvider = p.GetService<HostNameProvider>();
+                    return new LinuxAppServiceEventGenerator(new LinuxAppServiceFileLoggerFactory(), hostNameProvider);
                 }
                 else
                 {
diff --git a/test/WebJobs.Script.Tests.Integration/Management/FunctionsSyncManagerTests.cs b/test/WebJobs.Script.Tests.Integration/Management/FunctionsSyncManagerTests.cs
@@ -115,7 +115,7 @@ public FunctionsSyncManagerTests()
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHostName)).Returns(testHostName);
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.SkipSslValidation)).Returns((string)null);
             _mockEnvironment.Setup(p => p.GetEnvironmentVariable(EnvironmentSettingNames.AzureWebJobsSecretStorageType)).Returns("blob");
-            _hostNameProvider = new HostNameProvider(_mockEnvironment.Object, loggerFactory.CreateLogger<HostNameProvider>());
+            _hostNameProvider = new HostNameProvider(_mockEnvironment.Object);
 
             var functionMetadataProvider = new FunctionMetadataProvider(optionsMonitor, new OptionsWrapper<LanguageWorkerOptions>(CreateLanguageWorkerConfigSettings()), NullLogger<FunctionMetadataProvider>.Instance, new TestMetricsLogger());
             _functionsSyncManager = new FunctionsSyncManager(configuration, hostIdProviderMock.Object, optionsMonitor, loggerFactory.CreateLogger<FunctionsSyncManager>(), httpClient, secretManagerProviderMock.Object, _mockWebHostEnvironment.Object, _mockEnvironment.Object, _hostNameProvider, functionMetadataProvider);
diff --git a/test/WebJobs.Script.Tests.Integration/Security/SecretManagerProviderTests.cs b/test/WebJobs.Script.Tests.Integration/Security/SecretManagerProviderTests.cs
@@ -42,7 +42,7 @@ public SecretManagerProviderTests()
             var loggerProvider = new TestLoggerProvider();
             var loggerFactory = new LoggerFactory();
             loggerFactory.AddProvider(loggerProvider);
-            var hostNameProvider = new HostNameProvider(environment, loggerFactory.CreateLogger<HostNameProvider>());
+            var hostNameProvider = new HostNameProvider(environment);
 
             _provider = new DefaultSecretManagerProvider(optionsMonitor, mockIdProvider.Object, config,
                 new TestEnvironment(), NullLoggerFactory.Instance, new TestMetricsLogger(), hostNameProvider);
diff --git a/test/WebJobs.Script.Tests/DefaultScriptWebHookProviderTests.cs b/test/WebJobs.Script.Tests/DefaultScriptWebHookProviderTests.cs
@@ -35,7 +35,7 @@ public DefaultScriptWebHookProviderTests()
             loggerFactory.AddProvider(loggerProvider);
             var testEnvironment = new TestEnvironment();
             testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHostName, TestHostName);
-            var hostNameProvider = new HostNameProvider(testEnvironment, loggerFactory.CreateLogger<HostNameProvider>());
+            var hostNameProvider = new HostNameProvider(testEnvironment);
             _webHookProvider = new DefaultScriptWebHookProvider(mockSecretManagerProvider.Object, hostNameProvider);
         }
 
diff --git a/test/WebJobs.Script.Tests/Diagnostics/LinuxAppServiceEventGeneratorTests.cs b/test/WebJobs.Script.Tests/Diagnostics/LinuxAppServiceEventGeneratorTests.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
+using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.Diagnostics;
 using Microsoft.Extensions.Logging;
 using Moq;
@@ -14,6 +15,8 @@ namespace Microsoft.Azure.WebJobs.Script.Tests.Diagnostics
 {
     public class LinuxAppServiceEventGeneratorTests
     {
+        private const string _hostNameDefault = "SimpleApp";
+
         private readonly LinuxAppServiceEventGenerator _generator;
         private readonly Dictionary<string, MockLinuxAppServiceFileLogger> _loggers;
 
@@ -32,7 +35,12 @@ public LinuxAppServiceEventGeneratorTests()
             var loggerFactoryMock = new Mock<LinuxAppServiceFileLoggerFactory>(MockBehavior.Strict);
             loggerFactoryMock.Setup(f => f.GetOrCreate(It.IsAny<string>())).Returns<string>(s => _loggers[s]);
 
-            _generator = new LinuxAppServiceEventGenerator(loggerFactoryMock.Object);
+            var environmentMock = new Mock<IEnvironment>();
+            environmentMock.Setup(f => f.GetEnvironmentVariable(It.Is<string>(v => v == "WEBSITE_HOSTNAME")))
+                .Returns<string>(s => _hostNameDefault);
+
+            var hostNameProvider = new HostNameProvider(environmentMock.Object);
+            _generator = new LinuxAppServiceEventGenerator(loggerFactoryMock.Object, hostNameProvider);
         }
 
         [Theory]
@@ -47,23 +55,24 @@ public void ParseLogEvents(LogLevel level, string subscriptionId, string appName
             var match = regex.Match(evt);
 
             Assert.True(match.Success);
-            Assert.Equal(16, match.Groups.Count);
+            Assert.Equal(17, match.Groups.Count);
 
             DateTime dt;
             var groupMatches = match.Groups.Select(p => p.Value).Skip(1).ToArray();
             Assert.Collection(groupMatches,
                 p => Assert.Equal((int)LinuxEventGenerator.ToEventLevel(level), int.Parse(p)),
                 p => Assert.Equal(subscriptionId, p),
+                p => Assert.Equal(_hostNameDefault, p),
                 p => Assert.Equal(appName, p),
                 p => Assert.Equal(functionName, p),
                 p => Assert.Equal(eventName, p),
                 p => Assert.Equal(source, p),
-                p => Assert.Equal(details, p),
-                p => Assert.Equal(summary, p),
+                p => Assert.Equal(details, LinuxContainerEventGeneratorTests.UnNormalize(p)),
+                p => Assert.Equal(summary, LinuxContainerEventGeneratorTests.UnNormalize(p)),
                 p => Assert.Equal(ScriptHost.Version, p),
                 p => Assert.True(DateTime.TryParse(p, out dt)),
                 p => Assert.Equal(exceptionType, p),
-                p => Assert.Equal(exceptionMessage, p),
+                p => Assert.Equal(exceptionMessage, LinuxContainerEventGeneratorTests.UnNormalize(p)),
                 p => Assert.Equal(functionInvocationId, p),
                 p => Assert.Equal(hostInstanceId, p),
                 p => Assert.Equal(activityId, p));
@@ -117,8 +126,8 @@ public void ParseDetailsEvents(string siteName, string functionName, string inpu
             Assert.Collection(groupMatches,
                 p => Assert.Equal(siteName, p),
                 p => Assert.Equal(functionName, p),
-                p => Assert.Equal(inputBindings, p),
-                p => Assert.Equal(outputBindings, p),
+                p => Assert.Equal(inputBindings, LinuxContainerEventGeneratorTests.UnNormalize(p)),
+                p => Assert.Equal(outputBindings, LinuxContainerEventGeneratorTests.UnNormalize(p)),
                 p => Assert.Equal(scriptType, p),
                 p => Assert.Equal(isDisabled ? "1" : "0", p));
         }
diff --git a/test/WebJobs.Script.Tests/Diagnostics/LinuxContainerEventGeneratorTests.cs b/test/WebJobs.Script.Tests/Diagnostics/LinuxContainerEventGeneratorTests.cs
@@ -72,12 +72,12 @@ public void ParseLogEvents(LogLevel level, string subscriptionId, string appName
                 p => Assert.Equal(functionName, p),
                 p => Assert.Equal(eventName, p),
                 p => Assert.Equal(source, p),
-                p => Assert.Equal(details, JsonUnescape(p)),
-                p => Assert.Equal(summary, JsonUnescape(p)),
+                p => Assert.Equal(details, UnNormalize(JsonUnescape(p))),
+                p => Assert.Equal(summary, UnNormalize(JsonUnescape(p))),
                 p => Assert.Equal(ScriptHost.Version, p),
                 p => Assert.True(DateTime.TryParse(p, out dt)),
                 p => Assert.Equal(exceptionType, p),
-                p => Assert.Equal(exceptionMessage, JsonUnescape(p)),
+                p => Assert.Equal(exceptionMessage, UnNormalize(JsonUnescape(p))),
                 p => Assert.Equal(functionInvocationId, p),
                 p => Assert.Equal(hostInstanceId, p),
                 p => Assert.Equal(activityId, p),
@@ -93,6 +93,14 @@ private static string JsonUnescape(string value)
             return value.Replace("\\", string.Empty);
         }
 
+        public static string UnNormalize(string normalized)
+        {
+            // We replace all double quotes to single before the writing the logs
+            // to avoid our logging agents parsing break
+            // TODO: we can remove this once platform is able to handle quotes in logs
+            return normalized.Replace("'", "\"");
+        }
+
         private static string JsonSerializeEvent(string evt)
         {
             // the logging pipeline currently wraps our raw log data with JSON
@@ -166,8 +174,8 @@ public void ParseDetailsEvents(string siteName, string functionName, string inpu
             Assert.Collection(groupMatches,
                 p => Assert.Equal(siteName, p),
                 p => Assert.Equal(functionName, p),
-                p => Assert.Equal(inputBindings, JsonUnescape(p)),
-                p => Assert.Equal(outputBindings, JsonUnescape(p)),
+                p => Assert.Equal(inputBindings, UnNormalize(JsonUnescape(p))),
+                p => Assert.Equal(outputBindings, UnNormalize(JsonUnescape(p))),
                 p => Assert.Equal(scriptType, p),
                 p => Assert.Equal(isDisabled ? "1" : "0", p));
         }
diff --git a/test/WebJobs.Script.Tests/Eventing/DiagnosticLoggerTests.cs b/test/WebJobs.Script.Tests/Eventing/DiagnosticLoggerTests.cs
@@ -40,7 +40,7 @@ public DiagnosticLoggerTests()
             var loggerProvider = new TestLoggerProvider();
             var loggerFactory = new LoggerFactory();
             loggerFactory.AddProvider(loggerProvider);
-            _hostNameProvider = new HostNameProvider(_environment, loggerFactory.CreateLogger<HostNameProvider>());
+            _hostNameProvider = new HostNameProvider(_environment);
             _logger = new AzureMonitorDiagnosticLogger(_category, _hostInstanceId, _mockEventGenerator.Object, _environment, new LoggerExternalScopeProvider(), _hostNameProvider);
         }
 
diff --git a/test/WebJobs.Script.Tests/HostNameProviderTests.cs b/test/WebJobs.Script.Tests/HostNameProviderTests.cs
@@ -18,6 +18,7 @@ public class HostNameProviderTests
         private readonly Mock<IEnvironment> _mockEnvironment;
         private readonly HostNameProvider _hostNameProvider;
         private readonly TestLoggerProvider _loggerProvider;
+        private readonly ILogger _logger;
 
         public HostNameProviderTests()
         {
@@ -26,7 +27,8 @@ public HostNameProviderTests()
             _loggerProvider = new TestLoggerProvider();
             var loggerFactory = new LoggerFactory();
             loggerFactory.AddProvider(_loggerProvider);
-            _hostNameProvider = new HostNameProvider(_mockEnvironment.Object, loggerFactory.CreateLogger<HostNameProvider>());
+            _logger = loggerFactory.CreateLogger<HostNameProvider>();
+            _hostNameProvider = new HostNameProvider(_mockEnvironment.Object);
         }
 
         [Theory]
@@ -53,35 +55,36 @@ public void Synchronize_UpdatesValue()
 
             // no header present
             HttpRequest request = new DefaultHttpContext().Request;
-            _hostNameProvider.Synchronize(request);
+            _hostNameProvider.Synchronize(request, _logger);
             Assert.Equal(null, _hostNameProvider.Value);
 
             // empty header value
             request = new DefaultHttpContext().Request;
             request.Headers.Add(ScriptConstants.AntaresDefaultHostNameHeader, string.Empty);
-            _hostNameProvider.Synchronize(request);
+            _hostNameProvider.Synchronize(request, _logger);
             Assert.Equal(null, _hostNameProvider.Value);
 
             // host provided via header - expect update
             request = new DefaultHttpContext().Request;
             request.Headers.Add(ScriptConstants.AntaresDefaultHostNameHeader, "test.azurewebsites.net");
-            _hostNameProvider.Synchronize(request);
+            _hostNameProvider.Synchronize(request, _logger);
             Assert.Equal("test.azurewebsites.net", _hostNameProvider.Value);
             var logs = _loggerProvider.GetAllLogMessages();
             Assert.Equal(1, logs.Count);
             Assert.Equal("HostName updated from '(null)' to 'test.azurewebsites.net'", logs[0].FormattedMessage);
 
             // no change in header value - no update expected
             _loggerProvider.ClearAllLogMessages();
-            _hostNameProvider.Synchronize(request);
+            _hostNameProvider.Synchronize(request, _logger);
+            Assert.Equal("test.azurewebsites.net", _hostNameProvider.Value);
             Assert.Equal("test.azurewebsites.net", _hostNameProvider.Value);
             logs = _loggerProvider.GetAllLogMessages();
             Assert.Equal(0, logs.Count);
 
             // another change - expect update
             request = new DefaultHttpContext().Request;
             request.Headers.Add(ScriptConstants.AntaresDefaultHostNameHeader, "test2.azurewebsites.net");
-            _hostNameProvider.Synchronize(request);
+            _hostNameProvider.Synchronize(request, _logger);
             Assert.Equal("test2.azurewebsites.net", _hostNameProvider.Value);
             logs = _loggerProvider.GetAllLogMessages();
             Assert.Equal(1, logs.Count);
diff --git a/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs b/test/WebJobs.Script.Tests/Managment/WebFunctionsManagerTests.cs
diff --git a/test/WebJobs.Script.Tests/Metrics/LinuxContainerMetricsPublisherTests.cs b/test/WebJobs.Script.Tests/Metrics/LinuxContainerMetricsPublisherTests.cs
diff --git a/test/WebJobs.Script.Tests/Middleware/HostnameFixupMiddlewareTests.cs b/test/WebJobs.Script.Tests/Middleware/HostnameFixupMiddlewareTests.cs
diff --git a/test/WebJobs.Script.Tests/Security/SecretManagerTests.cs b/test/WebJobs.Script.Tests/Security/SecretManagerTests.cs
diff --git a/test/WebJobs.Script.Tests/StandbyManagerTests.cs b/test/WebJobs.Script.Tests/StandbyManagerTests.cs
diff --git a/test/WebJobs.Script.Tests/WebJobsScriptHostServiceTests.cs b/test/WebJobs.Script.Tests/WebJobsScriptHostServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,15 @@ namespace Microsoft.Azure.WebJobs.Script.WebHost.Diagnostics`
`9`	`9`	`internal class LinuxAppServiceEventGenerator : LinuxEventGenerator`
`10`	`10`	`{`
`11`	`11`	`private readonly LinuxAppServiceFileLoggerFactory _loggerFactory;`
	`12`	`+ private readonly HostNameProvider _hostNameProvider;`
`12`	`13`
`13`		`- public LinuxAppServiceEventGenerator(LinuxAppServiceFileLoggerFactory loggerFactory)`
	`14`	`+ public LinuxAppServiceEventGenerator(LinuxAppServiceFileLoggerFactory loggerFactory, HostNameProvider hostNameProvider)`
`14`	`15`	`{`
`15`	`16`	`_loggerFactory = loggerFactory;`
	`17`	`+ _hostNameProvider = hostNameProvider ?? throw new ArgumentNullException(nameof(hostNameProvider));`
`16`	`18`	`}`
`17`	`19`
`18`		`- public static string TraceEventRegex { get; } = $"(?<Level>[0-6]),(?<SubscriptionId>[^,]),(?<AppName>[^,]),(?<FunctionName>[^,]),(?<EventName>[^,]),(?<Source>[^,]),\"(?<Details>.)\",\"(?<Summary>.)\",(?<HostVersion>[^,]),(?<EventTimestamp>[^,]+),(?<ExceptionType>[^,]),\"(?<ExceptionMessage>.)\",(?<FunctionInvocationId>[^,]),(?<HostInstanceId>[^,]),(?<ActivityId>[^,\"]*)";`
	`20`	`+ public static string TraceEventRegex { get; } = $"(?<Level>[0-6]),(?<SubscriptionId>[^,]),(?<HostName>[^,]),(?<AppName>[^,]),(?<FunctionName>[^,]),(?<EventName>[^,]),(?<Source>[^,]),\"(?<Details>.)\",\"(?<Summary>.)\",(?<HostVersion>[^,]),(?<EventTimestamp>[^,]+),(?<ExceptionType>[^,]),\"(?<ExceptionMessage>.)\",(?<FunctionInvocationId>[^,]),(?<HostInstanceId>[^,]),(?<ActivityId>[^,\"])";`
`19`	`21`
`20`	`22`	`public static string MetricEventRegex { get; } = $"(?<SubscriptionId>[^,]),(?<AppName>[^,]),(?<FunctionName>[^,]),(?<EventName>[^,]),(?<Average>\\d),(?<Min>\\d),(?<Max>\\d),(?<Count>\\d),(?<HostVersion>[^,]),(?<EventTimestamp>[^,]+),(?<Details>[^,\"])";`
`21`	`23`
`@@ -27,10 +29,11 @@ public override void LogFunctionTraceEvent(LogLevel level, string subscriptionId`
`27`	`29`	`{`
`28`	`30`	`var eventTimestamp = DateTime.UtcNow.ToString(EventTimestampFormat);`
`29`	`31`	`var hostVersion = ScriptHost.Version;`
	`32`	`+ var hostName = _hostNameProvider.Value;`
`30`	`33`	`FunctionsSystemLogsEventSource.Instance.SetActivityId(activityId);`
`31`	`34`
`32`	`35`	`var logger = _loggerFactory.GetOrCreate(FunctionsLogsCategory);`
`33`		`- WriteEvent(logger, $"{(int)ToEventLevel(level)},{subscriptionId},{appName},{functionName},{eventName},{source},{NormalizeString(details)},{NormalizeString(summary)},{hostVersion},{eventTimestamp},{exceptionType},{NormalizeString(exceptionMessage)},{functionInvocationId},{hostInstanceId},{activityId}");`
	`36`	`+ WriteEvent(logger, $"{(int)ToEventLevel(level)},{subscriptionId},{hostName},{appName},{functionName},{eventName},{source},{NormalizeString(details)},{NormalizeString(summary)},{hostVersion},{eventTimestamp},{exceptionType},{NormalizeString(exceptionMessage)},{functionInvocationId},{hostInstanceId},{activityId}");`
`34`	`37`	`}`
`35`	`38`
`36`	`39`	`public override void LogFunctionMetricEvent(string subscriptionId, string appName, string functionName, string eventName, long average,`
Original file line number	Diff line number	Diff line change
`@@ -21,13 +21,11 @@ namespace Microsoft.Azure.WebJobs.Script.WebHost`
`21`	`21`	`public class HostNameProvider`
`22`	`22`	`{`
`23`	`23`	`private readonly IEnvironment _environment;`
`24`		`- private readonly ILogger _logger;`
`25`	`24`	`private string _hostName;`
`26`	`25`
`27`		`- public HostNameProvider(IEnvironment environment, ILogger<HostNameProvider> logger)`
	`26`	`+ public HostNameProvider(IEnvironment environment)`
`28`	`27`	`{`
`29`	`28`	`_environment = environment ?? throw new ArgumentNullException(nameof(environment));`
`30`		`- _logger = logger;`
`31`	`29`	`}`
`32`	`30`
`33`	`31`	`public virtual string Value`
`@@ -52,17 +50,17 @@ public virtual string Value`
`52`	`50`	`}`
`53`	`51`	`}`
`54`	`52`
`55`		`- public virtual void Synchronize(HttpRequest request)`
	`53`	`+ public virtual void Synchronize(HttpRequest request, ILogger logger)`
`56`	`54`	`{`
`57`	`55`	`string hostNameHeaderValue = request.Headers[ScriptConstants.AntaresDefaultHostNameHeader];`
`58`	`56`	`if (!string.IsNullOrEmpty(hostNameHeaderValue) &&`
`59`	`57`	`string.Compare(Value, hostNameHeaderValue) != 0)`
`60`	`58`	`{`
`61`		`- if (string.Compare(Value, hostNameHeaderValue) != 0)`
`62`		`- {`
`63`		`- _logger.LogInformation("HostName updated from '{0}' to '{1}'", Value, hostNameHeaderValue);`
`64`		`- _hostName = hostNameHeaderValue;`
`65`		`- }`
	`59`	`+ if (string.Compare(Value, hostNameHeaderValue) != 0)`
	`60`	`+ {`
	`61`	`+ logger.LogInformation("HostName updated from '{0}' to '{1}'", Value, hostNameHeaderValue);`
	`62`	`+ _hostName = hostNameHeaderValue;`
	`63`	`+ }`
`66`	`64`	`}`
`67`	`65`	`}`
`68`	`66`
Original file line number	Diff line number	Diff line change
`@@ -3,24 +3,26 @@`
`3`	`3`
`4`	`4`	`using System.Threading.Tasks;`
`5`	`5`	`using Microsoft.AspNetCore.Http;`
	`6`	`+using Microsoft.Extensions.Logging;`
`6`	`7`
`7`	`8`	`namespace Microsoft.Azure.WebJobs.Script.WebHost.Middleware`
`8`	`9`	`{`
`9`	`10`	`public class HostnameFixupMiddleware`
`10`	`11`	`{`
`11`	`12`	`private readonly RequestDelegate _next;`
`12`	`13`	`private readonly HostNameProvider _hostNameProvider;`
	`14`	`+ private readonly ILogger _logger;`
`13`	`15`
`14`		`- public HostnameFixupMiddleware(RequestDelegate next, HostNameProvider hostNameProvider)`
	`16`	`+ public HostnameFixupMiddleware(RequestDelegate next, HostNameProvider hostNameProvider, ILogger<HostnameFixupMiddleware> logger)`
`15`	`17`	`{`
`16`	`18`	`_next = next;`
`17`	`19`	`_hostNameProvider = hostNameProvider;`
	`20`	`+ _logger = logger;`
`18`	`21`	`}`
`19`	`22`
`20`	`23`	`public async Task Invoke(HttpContext context)`
`21`	`24`	`{`
`22`		`- _hostNameProvider.Synchronize(context.Request);`
`23`		`-`
	`25`	`+ _hostNameProvider.Synchronize(context.Request, _logger);`
`24`	`26`	`await _next.Invoke(context);`
`25`	`27`	`}`
`26`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,8 @@ public static void AddWebJobsScriptHost(this IServiceCollection services, IConfi`
`91`	`91`	`}`
`92`	`92`	`else if (SystemEnvironment.Instance.IsLinuxAppService())`
`93`	`93`	`{`
`94`		`- return new LinuxAppServiceEventGenerator(new LinuxAppServiceFileLoggerFactory());`
	`94`	`+ var hostNameProvider = p.GetService<HostNameProvider>();`
	`95`	`+ return new LinuxAppServiceEventGenerator(new LinuxAppServiceFileLoggerFactory(), hostNameProvider);`
`95`	`96`	`}`
`96`	`97`	`else`
`97`	`98`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public DefaultScriptWebHookProviderTests()`
`35`	`35`	`loggerFactory.AddProvider(loggerProvider);`
`36`	`36`	`var testEnvironment = new TestEnvironment();`
`37`	`37`	`testEnvironment.SetEnvironmentVariable(EnvironmentSettingNames.AzureWebsiteHostName, TestHostName);`
`38`		`- var hostNameProvider = new HostNameProvider(testEnvironment, loggerFactory.CreateLogger<HostNameProvider>());`
	`38`	`+ var hostNameProvider = new HostNameProvider(testEnvironment);`
`39`	`39`	`_webHookProvider = new DefaultScriptWebHookProvider(mockSecretManagerProvider.Object, hostNameProvider);`
`40`	`40`	`}`
`41`	`41`