// How many items are in the index ?
IIndexDiagnostics indexDiagnostics = _indexDiagnosticsFactory.Create(externalIndex);

// Why is this returning various different results (0, 5, 7)
_healthCheck.NumberOfItemsInIndex = indexDiagnostics.GetDocumentCount();

using Microsoft.Extensions.Diagnostics.HealthChecks;

namespace Gibe.HealthChecks.ExamineIndex.HealthChecks
{
    public class UmbracoExternalIndexReadyHealthCheck : IHealthCheck
    {
        public bool ExternalIndexReady { get; set; }
        public long NumberOfItemsInIndex { get; set; }
        public TimeSpan DurationToBuildIndex { get; set; }

        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context,
            CancellationToken cancellationToken = default)
        {
            // The property ExternalIndexReady is set in ExamineHealthCheckContentIndexPopulator
            // Once it has finished creating the external index
            if (ExternalIndexReady)
            {
                return Task.FromResult(HealthCheckResult.Healthy("The external index is ready.",
                    new Dictionary<string, object>
                    {
                        // Provide some extra info about the index for information purposes
                        // That can be displayed as part of the health check response if users use a custom response writer
                        { "numberOfItemsInIndex", NumberOfItemsInIndex },
                        { "durationToBuildIndex", DurationToBuildIndex }
                    }));
            }

            return Task.FromResult(HealthCheckResult.Unhealthy("The external index is still creating its index"));
        }
    }
}

using System.Diagnostics;
using Examine;
using Gibe.HealthChecks.ExamineIndex.HealthChecks;
using Microsoft.Extensions.Logging;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Infrastructure.Examine;
using Umbraco.Cms.Infrastructure.Persistence;

namespace Gibe.HealthChecks.ExamineIndex.Examine;

public class IndexReadyContentIndexPopulator : PublishedContentIndexPopulator
{
    private readonly UmbracoExternalIndexReadyHealthCheck _healthCheck;
    private readonly IProfilingLogger _profilingLogger;
    private readonly IIndexDiagnosticsFactory _indexDiagnosticsFactory;

    public IndexReadyContentIndexPopulator(
        ILogger<PublishedContentIndexPopulator> logger, 
        IContentService contentService, 
        IUmbracoDatabaseFactory umbracoDatabaseFactory, 
        IPublishedContentValueSetBuilder contentValueSetBuilder, 
        UmbracoExternalIndexReadyHealthCheck healthCheck,
        IIndexDiagnosticsFactory indexDiagnosticsFactory) 
        : base(logger, contentService, umbracoDatabaseFactory, contentValueSetBuilder)
    {
        _healthCheck = healthCheck;
        _indexDiagnosticsFactory = indexDiagnosticsFactory;
    }

    protected override void PopulateIndexes(IReadOnlyList<IIndex> indexes)
    {
        // Lets time how long it takes to do the indexing work
        var stopWatch = new Stopwatch();
        stopWatch.Start();
        
        // Do the usual work from Umbraco CMS
        // Of creating the index and populating it
        base.PopulateIndexes(indexes);

        stopWatch.Stop();
        
        // Ensure we have the external index assigned to this Populator
        // It should be - but good to check
        var externalIndex = indexes.SingleOrDefault(x => x.Name.Equals(Constants.UmbracoIndexes.ExternalIndexName));

        if (externalIndex != null)
        {
            // Update Health Check property with duration
            _healthCheck.DurationToBuildIndex = stopWatch.Elapsed;
             
            // How many items are in the index ?
            IIndexDiagnostics indexDiagnostics = _indexDiagnosticsFactory.Create(externalIndex);
            _healthCheck.NumberOfItemsInIndex = indexDiagnostics.GetDocumentCount();
            
            // Mark the healthcheck as ready
            _healthCheck.ExternalIndexReady = true;
        }
    }
}

using Gibe.HealthChecks.ExamineIndex.Examine;
using Gibe.HealthChecks.ExamineIndex.HealthChecks;
using Microsoft.Extensions.DependencyInjection;
using Umbraco.Cms.Infrastructure.Examine;

namespace Gibe.HealthChecks.ExamineIndex.Extensions
{
    public static class HealthCheckBuilderExtensions
    {
        public static IHealthChecksBuilder AddUmbracoExternalIndexReady(this IHealthChecksBuilder healthChecksBuilder)
        {
            // Because we use it in ExamineHealthCheckContentIndexPopulator
            // We need to explicitly add it into the DI container
            healthChecksBuilder.Services.AddSingleton<UmbracoExternalIndexReadyHealthCheck>();

            // Replace the singleton of PublishedContentIndexPopulator from Umbraco CMS with our own
            // We need this so we can add mark a property on our health check once it's all done its work of indexing

            // There are more than one type of IIndexPopulator hence looking for the specific one we want to replace
            var publishedContentIndexPopulator =
                healthChecksBuilder.Services.SingleOrDefault(x =>
                    x.ImplementationType == typeof(PublishedContentIndexPopulator));
            if (publishedContentIndexPopulator != null)
            {
                healthChecksBuilder.Services.Remove(publishedContentIndexPopulator);
                healthChecksBuilder.Services.AddSingleton<IIndexPopulator, IndexReadyContentIndexPopulator>();
            }

            // Add our health check
            return healthChecksBuilder.AddCheck<UmbracoExternalIndexReadyHealthCheck>("UmbracoExternalIndexReady");
        }
    }
}

using System.Text;
using System.Text.Json;
using Gibe.HealthChecks.ExamineIndex.Extensions;
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.Extensions.Diagnostics.HealthChecks;
using Umbraco.Cms.Core.Composing;
using Umbraco.Cms.Web.Common.ApplicationBuilder;

namespace Gibe.HealthChecks.TestSite.Composing
{
    public class HealthChecksComposer : IComposer
    {
        public void Compose(IUmbracoBuilder builder)
        {
            // Add Health Checks
            // Users could choose other packages from https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecks
            // and chain other checks
            builder.Services.AddHealthChecks()
                .AddUmbracoExternalIndexReady();


            builder.Services.Configure<UmbracoPipelineOptions>(options =>
            {
                options.AddFilter(new UmbracoPipelineFilter("AspNetHealthChecks")
                {
                    Endpoints = app => app.UseEndpoints(endpoints =>
                    {
                        endpoints.MapHealthChecks("/health", new HealthCheckOptions()
                        {
                            // Use a custom response writer to give us some JSON and more info about the health check/s
                            // https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks?view=aspnetcore-8.0#customize-output
                            ResponseWriter = WriteResponse
                        });
                    })
                });
            });
        }

        // Output custom JSON for the health check/s
        // https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks?view=aspnetcore-8.0#customize-output
        private static Task WriteResponse(HttpContext context, HealthReport healthReport)
        {
            context.Response.ContentType = "application/json; charset=utf-8";

            var options = new JsonWriterOptions { Indented = true };

            using var memoryStream = new MemoryStream();
            using (var jsonWriter = new Utf8JsonWriter(memoryStream, options))
            {
                jsonWriter.WriteStartObject();
                jsonWriter.WriteString("status", healthReport.Status.ToString());
                jsonWriter.WriteStartObject("results");

                foreach (var healthReportEntry in healthReport.Entries)
                {
                    jsonWriter.WriteStartObject(healthReportEntry.Key);
                    jsonWriter.WriteString("status", healthReportEntry.Value.Status.ToString());
                    jsonWriter.WriteString("description", healthReportEntry.Value.Description);
                    jsonWriter.WriteStartObject("data");

                    foreach (var item in healthReportEntry.Value.Data)
                    {
                        jsonWriter.WritePropertyName(item.Key);

                        JsonSerializer.Serialize(jsonWriter, item.Value, item.Value?.GetType() ?? typeof(object));
                    }

                    jsonWriter.WriteEndObject();
                    jsonWriter.WriteEndObject();
                }

                jsonWriter.WriteEndObject();
                jsonWriter.WriteEndObject();
            }

            return context.Response.WriteAsync(Encoding.UTF8.GetString(memoryStream.ToArray()));
        }
    }
}