The most significant changes in the code include the update of the Kentico.Xperience.Libraries package from version 13.0.70 to 13.0.74, the addition of new files IObjectQueryExtensions.cs and BaseKenticoHealthCheck.cs, and the refactoring of several health check classes.

1. The `Kentico.Xperience.Libraries` package was updated to version `13.0.74` from `13.0.70`, which is reflected in the `packages.lock.json` file.
2. The `StagingTaskHealthCheck` was commented out in the `DependencyInjection.cs` file.
3. A new file `IObjectQueryExtensions.cs` was added, providing extension methods for `IObjectQuery`.
4. The `AzureSearchTaskHealthCheck` class was refactored to inherit from `BaseKenticoHealthCheck<SearchTaskAzureInfo>`, which involved refactoring the `CheckHealthAsync` method and adding new methods for data retrieval and error data.
5. A new file `BaseKenticoHealthCheck.cs` was added, which provides a base class for Kentico health checks.
6. Several health check classes, including `EventLogHealthCheck`, `LocalSearchTaskHealthCheck`, `SiteConfigurationHealthCheck`, `SitePresentationHealthCheck`, and `WebFarmTaskHealthCheck`, were refactored in a similar way to `AzureSearchTaskHealthCheck`.
7. The `StagingTaskHealthCheck` class was refactored to use the `ToList` method instead of `GetEnumerableTypedResultAsync`.
8. The `WebFarmHealthCheck` class was refactored to check if `webFarmServers` is null or empty before proceeding.

Author: bluemodus-brandon

Directory.Packages.props

@@ -3,7 +3,7 @@
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="Kentico.Xperience.Libraries" Version="[13.0.70, 13.1.0)" />
+    <PackageVersion Include="Kentico.Xperience.Libraries" Version="[13.0.74, 13.1.0)" />
     <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="8.0.0.0" />
     <PackageVersion Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.2.0" />
     <PackageVersion Include="CSharpFunctionalExtensions" Version="2.41.0" />

src/XperienceCommunity.AspNetCore.HealthChecks/DependencyInjection.cs

@@ -36,7 +36,7 @@ public static IHealthChecksBuilder AddKenticoHealthChecks(this IServiceCollectio
                 .AddHealthChecks()
                 .AddCheck<SiteConfigurationHealthCheck>("Site Configuration Health Check", tags: s_tags)
                 .AddCheck<SitePresentationHealthCheck>("Site Presentation Url Health Check", tags: s_tags)
-                .AddCheck<StagingTaskHealthCheck>("Staging Task Health Check", tags: s_tags)
+                //.AddCheck<StagingTaskHealthCheck>("Staging Task Health Check", tags: s_tags)
                 .AddCheck<EventLogHealthCheck>("Search Task Health Check", tags: s_tags)
                 .AddCheck<WebFarmHealthCheck>("Web Farm Health Check", tags: s_tags)
                 .AddCheck<AzureSearchTaskHealthCheck>("Azure Search Task Health Checks", tags: s_tags)

src/XperienceCommunity.AspNetCore.HealthChecks/Extensions/IObjectQueryExtensions.cs

@@ -0,0 +1,35 @@
+using System.Data;
+using CMS.DataEngine;
+
+namespace XperienceCommunity.AspNetCore.HealthChecks.Extensions
+{
+    public static class IObjectQueryExtensions
+    {
+        /// <summary>
+        /// Return an IEnumerable of objects from the query.
+        /// </summary>
+        /// <typeparam name="TQuery"></typeparam>
+        /// <typeparam name="TObject"></typeparam>
+        /// <param name="query"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        public static async Task<IEnumerable<TObject>> ToListAsync<TQuery, TObject>(this IObjectQuery<TQuery, TObject> query, CancellationToken cancellationToken = default)
+        where TQuery : IObjectQuery<TQuery, TObject>
+        where TObject : BaseInfo
+        {
+            ArgumentNullException.ThrowIfNull(query);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            
+            var results = await query.GetTypedQuery()
+                //.GetEnumerableResultAsync(CommandBehavior.Default, false, cancellationToken)
+                .GetEnumerableTypedResultAsync(cancellationToken: cancellationToken)
+                //.GetEnumerableTypedResultAsync(commandBehavior: CommandBehavior.CloseConnection, true, cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+
+            
+            return results.ToList() ?? Enumerable.Empty<TObject>();
+        }
+    }
+}

src/XperienceCommunity.AspNetCore.HealthChecks/HealthChecks/AzureSearchTaskHealthCheck.cs

@@ -4,14 +4,15 @@
 using CMS.Search;
 using CMS.Search.Azure;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
+using XperienceCommunity.AspNetCore.HealthChecks.Extensions;
 
 namespace XperienceCommunity.AspNetCore.HealthChecks.HealthChecks
 {
     /// <summary>
     /// Azure Search Task Health Check
     /// </summary>
     /// <remarks>Checks the Azure Search Task for any errors.</remarks>
-    public sealed class AzureSearchTaskHealthCheck : IHealthCheck
+    public sealed class AzureSearchTaskHealthCheck : BaseKenticoHealthCheck<SearchTaskAzureInfo>, IHealthCheck
     {
         private readonly ISearchTaskAzureInfoProvider _searchTaskAzureInfoProvider;
         private readonly IProgressiveCache _cache;
@@ -27,25 +28,7 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
         {
             try
             {
-                // Asynchronously loads data and ensures caching
-                var data = await _cache.LoadAsync(async cacheSettings =>
-                        {
-                            // Calls an async method that loads the required data
-                            var result = await _searchTaskAzureInfoProvider
-                                .Get()
-                                .GetEnumerableTypedResultAsync(CommandBehavior.CloseConnection, true, cancellationToken)
-                                .ConfigureAwait(false);
-
-                            cacheSettings.CacheDependency =
-                                CacheHelper.GetCacheDependency($"{SearchTaskAzureInfo.OBJECT_TYPE}|all");
-
-                            return result;
-                        },
-                        new CacheSettings(TimeSpan.FromMinutes(10).TotalMinutes,
-                            $"apphealth|{SearchTaskAzureInfo.OBJECT_TYPE}"))
-                    .ConfigureAwait(false);
-
-                var searchTasks = data.ToList();
+                var searchTasks = (await GetDataForTypeAsync(cancellationToken)).ToList();
 
                 if (searchTasks.Count == 0)
                 {
@@ -60,13 +43,11 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
                     return HealthCheckResult.Healthy();
                 }
 
-                var healthResultData = GetData(errorTasks);
-
-                return HealthCheckResult.Degraded("Azure Search Tasks Contain Errors.", data: healthResultData);
+                return HealthCheckResult.Degraded("Azure Search Tasks Contain Errors.", data: GetErrorData(errorTasks));
             }
             catch (InvalidOperationException ex)
             {
-                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase))
+                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase) || ex.Message.Contains("current state", StringComparison.OrdinalIgnoreCase))
                 {
                     return HealthCheckResult.Healthy();
                 }
@@ -79,7 +60,24 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
             }
         }
 
-        private static IReadOnlyDictionary<string, object> GetData(IEnumerable<SearchTaskAzureInfo> objects)
+        protected override IEnumerable<SearchTaskAzureInfo> GetDataForType()
+        {
+            var result = _searchTaskAzureInfoProvider.Get()
+                .WhereNotEmpty(nameof(SearchTaskAzureInfo.SearchTaskAzureErrorMessage));
+
+            return result.ToList();
+        }
+
+        protected override async Task<IEnumerable<SearchTaskAzureInfo>> GetDataForTypeAsync(
+            CancellationToken cancellationToken = default)
+        {
+            var query = _searchTaskAzureInfoProvider.Get()
+                .WhereNotEmpty(nameof(SearchTaskAzureInfo.SearchTaskAzureErrorMessage));
+
+            return await query.ToListAsync(cancellationToken: cancellationToken);
+        }
+
+        protected override IReadOnlyDictionary<string, object> GetErrorData(IEnumerable<SearchTaskAzureInfo> objects)
         {
             var dictionary = objects.ToDictionary<SearchTaskAzureInfo, string, object>(searchTask => searchTask.SearchTaskAzureID.ToString(), searchTask => searchTask.SearchTaskAzureErrorMessage);
 

src/XperienceCommunity.AspNetCore.HealthChecks/HealthChecks/BaseKenticoHealthCheck.cs

@@ -0,0 +1,31 @@
+using CMS.DataEngine;
+
+namespace XperienceCommunity.AspNetCore.HealthChecks.HealthChecks
+{
+    /// <summary>
+    /// Represents a base class for Kentico health checks.
+    /// </summary>
+    /// <typeparam name="T">The type of the Kentico object.</typeparam>
+    public abstract class BaseKenticoHealthCheck<T> where T : BaseInfo
+    {
+        /// <summary>
+        /// Gets the data for the specified Kentico object type.
+        /// </summary>
+        /// <returns>An enumerable collection of Kentico objects.</returns>
+        protected abstract IEnumerable<T> GetDataForType();
+
+        /// <summary>
+        /// Gets the data for the specified Kentico object type asynchronously.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>A task that represents the asynchronous operation and contains an enumerable collection of Kentico objects.</returns>
+        protected abstract Task<IEnumerable<T>> GetDataForTypeAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Gets the error data for the specified Kentico objects.
+        /// </summary>
+        /// <param name="objects">The Kentico objects.</param>
+        /// <returns>A read-only dictionary containing the error data.</returns>
+        protected abstract IReadOnlyDictionary<string, object> GetErrorData(IEnumerable<T> objects);
+    }
+}

src/XperienceCommunity.AspNetCore.HealthChecks/HealthChecks/EventLogHealthCheck.cs

@@ -2,15 +2,18 @@
 using System.Data;
 using CMS.EventLog;
 using CMS.Helpers;
+using CMS.Search.Azure;
+using CMS.SiteProvider;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
+using XperienceCommunity.AspNetCore.HealthChecks.Extensions;
 
 namespace XperienceCommunity.AspNetCore.HealthChecks.HealthChecks
 {
     /// <summary>
     /// Event Log Health Check
     /// </summary>
     /// <remarks>Investigates the Last 100 Event Log Entries for Errors.</remarks>
-    public sealed class EventLogHealthCheck : IHealthCheck
+    public sealed class EventLogHealthCheck : BaseKenticoHealthCheck<EventLogInfo>, IHealthCheck
     {
         private readonly IEventLogInfoProvider _eventLogInfoProvider;
         private readonly IProgressiveCache _cache;
@@ -26,38 +29,25 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
         {
             try
             {
-                var data = await _cache.LoadAsync(async cs =>
-                {
-                    var results = await _eventLogInfoProvider
-                        .Get()
-                        .GetEnumerableTypedResultAsync(CommandBehavior.CloseConnection, true, cancellationToken)
-                        .ConfigureAwait(false);
-
-                    cs.CacheDependency = CacheHelper.GetCacheDependency($"{EventLogInfo.OBJECT_TYPE}|all");
-
-                    return results;
-                }, new CacheSettings(TimeSpan.FromMinutes(10).TotalMinutes, $"apphealth|{EventLogInfo.OBJECT_TYPE}"))
-                    .ConfigureAwait(false);
-
-                var eventList = data.ToList();
+                var eventList = (await GetDataForTypeAsync(cancellationToken)).ToList();
 
                 var exceptionEvents = eventList
-                    .Where(e => e.EventType == "E" 
-                                && e.EventTime >= DateTime.UtcNow.AddHours(-24) 
+                    .Where(e => e.EventType == "E"
+                                && e.EventTime >= DateTime.UtcNow.AddHours(-24)
                                 && !e.Source.Equals(nameof(HealthReport), StringComparison.OrdinalIgnoreCase))
                     .OrderByDescending(x => x.EventID)
                     .ToList();
 
                 if (exceptionEvents.Count >= 25)
                 {
-                    return HealthCheckResult.Degraded($"There are {exceptionEvents.Count} errors in the event log.", null, GetData(exceptionEvents));
+                    return HealthCheckResult.Degraded($"There are {exceptionEvents.Count} errors in the event log.", null, GetErrorData(exceptionEvents));
                 }
 
                 return HealthCheckResult.Healthy();
             }
             catch (InvalidOperationException ex)
             {
-                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase))
+                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase) || ex.Message.Contains("current state", StringComparison.OrdinalIgnoreCase))
                 {
                     return HealthCheckResult.Healthy();
                 }
@@ -70,7 +60,25 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
             }
         }
 
-        private static IReadOnlyDictionary<string, object> GetData(IEnumerable<EventLogInfo> objects)
+        protected override IEnumerable<EventLogInfo> GetDataForType()
+        {
+            var query = _eventLogInfoProvider.Get()
+                .WhereEquals(nameof(EventLogInfo.EventType), "E")
+                .WhereNotEquals(nameof(EventLogInfo.Source), nameof(HealthReport));
+
+            return query.ToList();
+        }
+
+        protected override async Task<IEnumerable<EventLogInfo>> GetDataForTypeAsync(CancellationToken cancellationToken = default)
+        {
+            var query = _eventLogInfoProvider.Get()
+                .WhereEquals(nameof(EventLogInfo.EventType), "E")
+                .WhereNotEquals(nameof(EventLogInfo.Source), nameof(HealthReport));
+
+            return await query.ToListAsync(cancellationToken: cancellationToken);
+        }
+
+        protected override IReadOnlyDictionary<string, object> GetErrorData(IEnumerable<EventLogInfo> objects)
         {
             var dictionary = objects.ToDictionary<EventLogInfo, string, object>(e => e.EventID.ToString(), ev => ev.Exception);
 

src/XperienceCommunity.AspNetCore.HealthChecks/HealthChecks/LocalSearchTaskHealthCheck.cs

@@ -3,14 +3,15 @@
 using CMS.Helpers;
 using CMS.Search;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
+using XperienceCommunity.AspNetCore.HealthChecks.Extensions;
 
 namespace XperienceCommunity.AspNetCore.HealthChecks.HealthChecks
 {
     /// <summary>
     /// Local Search Task Health Check
     /// </summary>
     /// <remarks>Checks the Local Search Tasks to determine if any errors are present.</remarks>
-    public sealed class LocalSearchTaskHealthCheck : IHealthCheck
+    public sealed class LocalSearchTaskHealthCheck : BaseKenticoHealthCheck<SearchTaskInfo>, IHealthCheck
     {
         private readonly ISearchTaskInfoProvider _searchTaskInfoProvider;
         private readonly IProgressiveCache _cache;
@@ -25,42 +26,18 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
         {
             try
             {
-                // Asynchronously loads data and ensures caching
-                var data = await _cache.LoadAsync(async cacheSettings =>
-                    {
-                        // Calls an async method that loads the required data
-                        var result = await _searchTaskInfoProvider
-                            .Get()
-                            .GetEnumerableTypedResultAsync(CommandBehavior.CloseConnection, true, cancellationToken)
-                            .ConfigureAwait(false);
-
-                        cacheSettings.CacheDependency = CacheHelper.GetCacheDependency($"{SearchTaskInfo.OBJECT_TYPE}|all");
-
-                        return result;
-                    }, new CacheSettings(TimeSpan.FromMinutes(10).TotalMinutes, $"apphealth|{SearchTaskInfo.OBJECT_TYPE}"))
-                    .ConfigureAwait(false);
-
-                var searchTasks = data.ToList();
+                var searchTasks = (await GetDataForTypeAsync(cancellationToken)).ToList();
 
                 if (searchTasks.Count == 0)
                 {
                     return HealthCheckResult.Healthy();
                 }
 
-                var errorTasks = searchTasks.Where(searchTask => !string.IsNullOrEmpty(searchTask.SearchTaskErrorMessage)).ToList();
-
-                if (errorTasks.Count == 0)
-                {
-                    return HealthCheckResult.Healthy();
-                }
-
-                var resultData = GetData(errorTasks);
-
-                return HealthCheckResult.Degraded("Local Search Tasks Contain Errors.", data: resultData);
+                return HealthCheckResult.Degraded("Local Search Tasks Contain Errors.", data: GetErrorData(searchTasks));
             }
             catch (InvalidOperationException ex)
             {
-                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase))
+                if (ex.Message.Contains("open DataReader", StringComparison.OrdinalIgnoreCase) || ex.Message.Contains("current state", StringComparison.OrdinalIgnoreCase))
                 {
                     return HealthCheckResult.Healthy();
                 }
@@ -73,7 +50,24 @@ public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context
             }
         }
 
-        private static IReadOnlyDictionary<string, object> GetData(IEnumerable<SearchTaskInfo> objects)
+        protected override IEnumerable<SearchTaskInfo> GetDataForType()
+        {
+            var query = _searchTaskInfoProvider.Get()
+                .WhereNotEmpty(nameof(SearchTaskInfo.SearchTaskErrorMessage));
+            
+            return query.ToList();
+        }
+
+        protected override async Task<IEnumerable<SearchTaskInfo>> GetDataForTypeAsync(CancellationToken cancellationToken = default)
+        {
+            
+            var query = _searchTaskInfoProvider.Get()
+                .WhereNotEmpty(nameof(SearchTaskInfo.SearchTaskErrorMessage));
+
+            return await query.ToListAsync(cancellationToken: cancellationToken);
+        }
+
+        protected override IReadOnlyDictionary<string, object> GetErrorData(IEnumerable<SearchTaskInfo> objects)
         {
             var dictionary = objects.ToDictionary<SearchTaskInfo, string, object>(searchTask => searchTask.SearchTaskID.ToString(), searchTask => searchTask.SearchTaskErrorMessage);