Merge pull request #720 from Azure/zhiyuanliang/merge-main-to-preview

Merge main to preview

Author: zhiyuanliang-ms

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationHealthCheck.cs

@@ -37,17 +37,27 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
                 return HealthCheckResult.Unhealthy(HealthCheckConstants.NoProviderFoundMessage);
             }
 
+            HealthCheckResult worstResult = HealthCheckResult.Healthy();
+
             foreach (IHealthCheck healthCheck in _healthChecks)
             {
                 var result = await healthCheck.CheckHealthAsync(context, cancellationToken).ConfigureAwait(false);
 
+                // Keep track of the worst health status found
+                // HealthStatus enum is ordered: Unhealthy(0) < Degraded(1) < Healthy(2)
+                if (result.Status < worstResult.Status)
+                {
+                    worstResult = result;
+                }
+
+                // If an Unhealthy status is found, short-circuit since that's the worst possible
                 if (result.Status == HealthStatus.Unhealthy)
                 {
                     return result;
                 }
             }
 
-            return HealthCheckResult.Healthy();
+            return worstResult;
         }
 
         private void FindHealthChecks(IConfigurationRoot configurationRoot, List<IHealthCheck> healthChecks)

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationProvider.cs

@@ -576,15 +576,17 @@ public void ProcessPushNotification(PushNotification pushNotification, TimeSpan?
 
         public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
         {
+            HealthStatus failureStatus = context.Registration?.FailureStatus ?? HealthStatus.Unhealthy;
+
             if (!_lastSuccessfulAttempt.HasValue)
             {
-                return HealthCheckResult.Unhealthy(HealthCheckConstants.LoadNotCompletedMessage);
+                return new HealthCheckResult(status: failureStatus, description: HealthCheckConstants.LoadNotCompletedMessage);
             }
 
             if (_lastFailedAttempt.HasValue &&
                 _lastSuccessfulAttempt.Value < _lastFailedAttempt.Value)
             {
-                return HealthCheckResult.Unhealthy(HealthCheckConstants.RefreshFailedMessage);
+                return new HealthCheckResult(status: failureStatus, description: HealthCheckConstants.RefreshFailedMessage);
             }
 
             return HealthCheckResult.Healthy();

src/Microsoft.Extensions.Configuration.AzureAppConfiguration/AzureAppConfigurationRefresherProvider.cs

@@ -63,10 +63,14 @@ private void FindRefreshers(IConfigurationRoot configurationRoot, ILoggerFactory
             {
                 foreach (IConfigurationProvider provider in configurationRoot.Providers)
                 {
-                    if (provider is AzureAppConfigurationProvider appConfigurationProvider)
+                    if (provider is IConfigurationRefresher configurationRefresher)
                     {
-                        appConfigurationProvider.LoggerFactory = loggerFactory;
-                        refreshers.Add(appConfigurationProvider);
+                        refreshers.Add(configurationRefresher);
+
+                        if (configurationRefresher is AzureAppConfigurationProvider azureAppConfigurationProvider)
+                        {
+                            azureAppConfigurationProvider.LoggerFactory = loggerFactory;
+                        }
                     }
                     else if (provider is ChainedConfigurationProvider chainedProvider)
                     {

tests/Tests.AzureAppConfiguration/Unit/HealthCheckTest.cs

@@ -136,5 +136,54 @@ public async Task HealthCheckTests_RegisterAzureAppConfigurationHealthCheck()
             Assert.Contains(HealthCheckConstants.HealthCheckRegistrationName, result.Entries.Keys);
             Assert.Equal(HealthStatus.Healthy, result.Entries[HealthCheckConstants.HealthCheckRegistrationName].Status);
         }
+
+        [Fact]
+        public async Task HealthCheckTests_ShouldRespectHealthCheckRegistration()
+        {
+            IConfigurationRefresher refresher = null;
+            var mockResponse = new Mock<Response>();
+            var mockClient = new Mock<ConfigurationClient>(MockBehavior.Strict);
+
+            mockClient.SetupSequence(c => c.GetConfigurationSettingsAsync(It.IsAny<SettingSelector>(), It.IsAny<CancellationToken>()))
+                       .Returns(new MockAsyncPageable(kvCollection))
+                       .Throws(new RequestFailedException(503, "Request failed."));
+
+            var config = new ConfigurationBuilder()
+                .AddAzureAppConfiguration(options =>
+                {
+                    options.ClientManager = TestHelpers.CreateMockedConfigurationClientManager(mockClient.Object);
+                    options.MinBackoffDuration = TimeSpan.FromSeconds(2);
+                    options.ConfigurationSettingPageIterator = new MockConfigurationSettingPageIterator();
+                    options.ConfigureRefresh(refreshOptions =>
+                    {
+                        refreshOptions.RegisterAll()
+                            .SetRefreshInterval(TimeSpan.FromSeconds(1));
+                    });
+                    refresher = options.GetRefresher();
+                })
+                .Build();
+
+            var services = new ServiceCollection();
+            services.AddSingleton<IConfiguration>(config);
+            services.AddLogging(); // add logging for health check service
+            services.AddHealthChecks()
+                .AddAzureAppConfiguration(
+                    name: "TestName",
+                    failureStatus: HealthStatus.Degraded);
+            var provider = services.BuildServiceProvider();
+            var healthCheckService = provider.GetRequiredService<HealthCheckService>();
+
+            var result = await healthCheckService.CheckHealthAsync();
+            Assert.Equal(HealthStatus.Healthy, result.Status);
+
+            // Wait for the refresh interval to expire
+            Thread.Sleep(2000);
+
+            await refresher.TryRefreshAsync();
+            result = await healthCheckService.CheckHealthAsync();
+            Assert.Equal(HealthStatus.Degraded, result.Status);
+            Assert.Contains("TestName", result.Entries.Keys);
+            Assert.Equal(HealthStatus.Degraded, result.Entries["TestName"].Status);
+        }
     }
 }