Add TZ Diagnostic Event (#9662)

* Fix typo in HostIdCollisionErrorCode

* Add diagnostic event for when the function app has 10 non-decryptable secrets backups

* Add a test case for a diagnostic event when the function app has 10 non-decryptable secrets backups

* Log a diagnostic event if the read operation failed because the blob access tier is set to archived

* Add BlobRepository_TierSetToArchive_ReadAsync_Logs_DiagnosticEvent

* Update help links

* Add diagnostic event for when there is a problem with the app package

* Update Moq version to 4.20.69

* Add ZipPackageFailure_Logs_DiagnosticEvent test case

* Add ApplyRunFromPackageContext_Throws_Logs_DiagnosticEvent test case

* Add helper method to validate that the expected diagnostic event is present

* Add a diagnostic event for parsing errors in the host configuration file

* Add InvalidHostJsonLogsDiagnosticEvent test case

* Fix build

* Update logic to create a format exception with the inner exception, log it and throw

* Update logic to catch the RequestFailedException directly

* changes

* adding unit tests

* changes

* trying to get diff to match

* revert

* comments

* adding potential null case

* addressing comments

* fixing unit test

---------

Co-authored-by: Francisco-Gamino <[email protected]>

Author: aishwaryabh

src/WebJobs.Script.WebHost/Health/TokenExpirationService.cs

@@ -43,19 +43,26 @@ public TokenExpirationService(IEnvironment environment, ILogger<TokenExpirationS
 
         protected override async Task ExecuteAsync(CancellationToken cancellationToken)
         {
-            await Task.Yield(); // force a yield, so our synchronous code does not slowdown startup
-            await _standby.Task.WaitAsync(cancellationToken);
-
-            if (_environment.IsCoreTools())
+            try
             {
-                return;
-            }
+                await Task.Yield(); // force a yield, so our synchronous code does not slowdown startup
+                await _standby.Task.WaitAsync(cancellationToken);
 
-            while (!cancellationToken.IsCancellationRequested)
+                if (_environment.IsCoreTools())
+                {
+                    return;
+                }
+
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    // check at every hour
+                    AnalyzeSasTokenInUri();
+                    await Task.Delay(TimeSpan.FromHours(1), cancellationToken);
+                }
+            }
+            catch (Exception ex) when (ex is not OperationCanceledException)
             {
-                // check at every hour
-                AnalyzeSasTokenInUri();
-                await Task.Delay(TimeSpan.FromHours(1), cancellationToken);
+                _logger.LogWarning(ex.ToString());
             }
         }
 

src/WebJobs.Script.WebHost/WebJobsScriptHostService.cs

@@ -224,7 +224,7 @@ private void CheckFileSystem()
             }
         }
 
-        private void ValidateLinuxSKUConfiguration()
+        private void ValidateLinuxSKUConfiguration(ILogger logger)
         {
             var websiteRunFromPackageValue = _environment.GetEnvironmentVariable(AzureWebsiteRunFromPackage);
             var scmRunFromPackageValue = _environment.GetEnvironmentVariable(ScmRunFromPackage);
@@ -234,7 +234,24 @@ private void ValidateLinuxSKUConfiguration()
                 _environment.IsLinuxConsumptionOnAtlas() &&
                 !_environment.IsManagedAppEnvironment())
             {
-                _logger.LogError($"Unable to load the functions payload since the app was not provisioned with valid {AzureWebJobsSecretStorage} connection string.");
+                logger?.LogError($"Unable to load the functions payload since the app was not provisioned with valid {AzureWebJobsSecretStorage} connection string.");
+            }
+
+            var functionsTimeZone = _environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionsTimeZone);
+            var functionsWebsiteTimeZone = _environment.GetEnvironmentVariable(EnvironmentSettingNames.FunctionsWebsiteTimeZone);
+
+            // If we have a linux consumption app and the time zone env variable is set, log a warning and diagnostic event
+            if (_environment.IsLinuxConsumptionOnAtlas() &&
+                (!string.IsNullOrEmpty(functionsTimeZone) ||
+                !string.IsNullOrEmpty(functionsWebsiteTimeZone)))
+            {
+                string message = Script.Properties.Resources.LinuxConsumptionRemoveTimeZone;
+
+                // Log diagnostic event
+                logger?.LogDiagnosticEventError(DiagnosticEventConstants.LinuxConsumptionTimeZoneErrorCode, message, DiagnosticEventConstants.LinuxConsumptionTimeZoneErrorHelpLink, new InvalidOperationException(message));
+
+                // Log warning so this message goes to App insights
+                logger?.LogWarning(message);
             }
         }
 
@@ -326,7 +343,7 @@ private async Task UnsynchronizedStartHostAsync(ScriptHostStartupOperation activ
 
                 LogInitialization(localHost, isOffline, attemptCount, ++_hostStartCount, activeOperation.Id);
 
-                ValidateLinuxSKUConfiguration();
+                ValidateLinuxSKUConfiguration(GetHostLogger(localHost));
 
                 if (!_scriptWebHostEnvironment.InStandbyMode)
                 {

src/WebJobs.Script/Diagnostics/DiagnosticEventConstants.cs

@@ -22,5 +22,8 @@ internal static class DiagnosticEventConstants
 
         public const string UnableToParseHostConfigurationFileErrorCode = "AZFD0009";
         public const string UnableToParseHostConfigurationFileHelpLink = "https://go.microsoft.com/fwlink/?linkid=2248917";
+
+        public const string LinuxConsumptionTimeZoneErrorCode = "AZFD0010";
+        public const string LinuxConsumptionTimeZoneErrorHelpLink = "https://go.microsoft.com/fwlink/?linkid=2250165";
     }
 }

src/WebJobs.Script/Environment/EnvironmentSettingNames.cs

@@ -74,6 +74,8 @@ public static class EnvironmentSettingNames
         public const string WebsiteNodeDefaultVersion = "WEBSITE_NODE_DEFAULT_VERSION";
         public const string FunctionsMetricsPublishPath = "FUNCTIONS_METRICS_PUBLISH_PATH";
         public const string FunctionsAlwaysReadyInstance = "FUNCTIONS_ALWAYSREADY_INSTANCE";
+        public const string FunctionsTimeZone = "TZ";
+        public const string FunctionsWebsiteTimeZone = "WEBSITE_TIME_ZONE";
 
         //Function in Kubernetes
         public const string PodNamespace = "POD_NAMESPACE";

src/WebJobs.Script/Properties/Resources.Designer.cs

@@ -176,4 +176,7 @@
   <data name="SasTokenExpiringInfoFormat" xml:space="preserve">
     <value>SAS token within '{1}' setting is set to expire in {0} days.</value>
   </data>
+  <data name="LinuxConsumptionRemoveTimeZone" xml:space="preserve">
+    <value>The environment variables 'WEBSITE_TIME_ZONE' and 'TZ' are not supported on this platform. For more information, see https://go.microsoft.com/fwlink/?linkid=2250165.</value>
+  </data>
 </root>

src/WebJobs.Script/Properties/Resources.resx

@@ -7,8 +7,11 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Reactive.Joins;
 using System.Text;
 using System.Threading.Tasks;
+using DryIoc;
+using Microsoft.Azure.WebJobs.Script.Tests.Integration.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.Authentication;
 using Microsoft.Azure.WebJobs.Script.WebHost.Models;
@@ -17,6 +20,8 @@
 using Microsoft.Azure.WebJobs.Script.Workers.Rpc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Microsoft.WebJobs.Script.Tests;
 using Newtonsoft.Json;
@@ -153,6 +158,52 @@ public async Task StandbyModeE2E_LinuxContainer()
             Assert.NotSame(GetCachedTimeZoneInfo(), _originalTimeZoneInfoCache);
         }
 
+        [Fact]
+        public async Task LinuxContainer_TimeZoneEnvVariableE2E()
+        {
+            byte[] bytes = TestHelpers.GenerateKeyBytes();
+            var encryptionKey = Convert.ToBase64String(bytes);
+            var containerName = "testContainer";
+
+            var vars = new Dictionary<string, string>
+            {
+                { EnvironmentSettingNames.AzureWebsitePlaceholderMode, "1" },
+                { EnvironmentSettingNames.ContainerName, containerName },
+                { EnvironmentSettingNames.AzureWebsiteHostName, "testapp.azurewebsites.net" },
+                { EnvironmentSettingNames.AzureWebsiteName, "TestApp" },
+                { EnvironmentSettingNames.ContainerEncryptionKey, encryptionKey },
+                { EnvironmentSettingNames.AzureWebsiteContainerReady, null },
+                { EnvironmentSettingNames.AzureWebsiteSku, "Dynamic" },
+                { EnvironmentSettingNames.AzureWebsiteZipDeployment, null },
+                { EnvironmentSettingNames.AzureWebJobsFeatureFlags, ScriptConstants.FeatureFlagEnableProxies },
+                { "AzureWebEncryptionKey", "0F75CA46E7EBDD39E4CA6B074D1F9A5972B849A55F91A248" },
+                { EnvironmentSettingNames.FunctionsTimeZone, "Europe/Berlin" }
+            };
+
+            var environment = new TestEnvironment(vars);
+
+            Assert.True(environment.IsLinuxConsumptionOnAtlas());
+            Assert.False(environment.IsFlexConsumptionSku());
+            Assert.True(environment.IsAnyLinuxConsumption());
+
+            await InitializeTestHostAsync("Linux", environment);
+
+            var expectedTraceMessage = "The environment variables 'WEBSITE_TIME_ZONE' and 'TZ' are not supported on this platform. For more information, see https://go.microsoft.com/fwlink/?linkid=2250165.";
+
+            // verify the expected logs
+            var logLines = _loggerProvider.GetAllLogMessages().Where(p => p.FormattedMessage != null).Select(p => p.FormattedMessage).ToArray();
+            Assert.Equal(2, logLines.Count(p => p.Contains(expectedTraceMessage)));
+
+            DiagnosticEventTestUtils.ValidateThatTheExpectedDiagnosticEventIsPresent(
+            _loggerProvider,
+                expectedTraceMessage,
+                LogLevel.Error,
+                DiagnosticEventConstants.LinuxConsumptionTimeZoneErrorHelpLink,
+                DiagnosticEventConstants.LinuxConsumptionTimeZoneErrorCode
+            );
+
+        }
+
         private async Task Assign(string encryptionKey)
         {
             // create a zip package