Operational Monitoring

By Optimizely Education
Published: Mar 13, 2026
Rating 1 star 2 stars 3 stars 4 stars 5 stars

Average rating: 0 No reviews

Outline

At a glance

Health-Aware Monitoring: Move beyond "did it run" to detecting data drift, API timeouts, and partial failures.
Telemetry Strategy: Use structured Application Insights events like SyncActivityCompleted for real-time KQL querying.
Automated Health Checks: Implement native .NET IHealthCheck to expose machine-readable sync status endpoints.
Defensive Operations: Configure circuit breakers and threshold alerts to prevent resource exhaustion during failures.

In federated digital architectures, the reliability of the system depends on the health of the background processes that bridge external data into the CMS. For Optimizely CMS 13, monitoring synchronization workflows is a critical operational requirement. Simple oversight of whether a scheduled job "ran" is insufficient; architects must implement "Health-Aware" monitoring that detects data drift, API timeouts, and partial synchronization failures.

This module outlines strategies for establishing a robust monitoring framework for synchronized content providers.

1. Monitoring Scheduled Job Health

Optimizely CMS identifies background synchronization tasks through scheduled jobs. While these jobs provide a native UI for tracking execution, programmatic monitoring is required for enterprise-grade alerting.

1. Key Performance Indicators (KPIs)

To determine if a sync process is healthy, the following metrics should be tracked:

Execution Latency: Significant deviations from the average completion time can indicate external API bottlenecks or unexpected increases in data volume.
Failed Item Density: Monitoring for scenarios where a job reports success despite a significant percentage of individual item failures due to schema errors.
Heartbeat Frequency: Verifying that jobs are running at the configured intervals. Stalled heartbeats often signal underlying environment issues.

2. Programmatic Access to Logs

In .NET 8, developers can query the IScheduledJobLogRepository to analyze historical execution data. This programmatic access is essential for building custom operational dashboards and automated cleanup routines.

2. Telemetry Integration with Application Insights

Optimizely DXP utilizes Azure Application Insights as the standard for Application Performance Management (APM). Synchronization workflows should emit custom telemetry to facilitate real-time alerting.

Custom Event Tracking

Instead of simple trace logs, synchronization jobs should emit structured events. This allows operations teams to build Kusto Query Language (KQL) queries to identify performance trends:

SyncActivityStarted: Emitted at the initiation of the ingestion phase.
SyncActivityCompleted: Includes contextual properties such as ItemsProcessed, ItemsSucceeded, and ItemsFailed.
ExternalApiLatency: Tracks the duration of individual external requests to identify system-wide service degradation.

3. Technical Implementation: Custom Sync Health Check

Utilizing the native ASP.NET Core Health Checks middleware allows the CMS to expose a machine-readable endpoint (e.g., /health/sync) that external monitoring tools can poll effectively.

using Microsoft.Extensions.Diagnostics.HealthChecks;
using EPiServer.DataAbstraction;

public class ContentSyncHealthCheck : IHealthCheck
{
    private readonly IScheduledJobLogRepository _logRepository;
    private readonly IScheduledJobRepository _jobRepository;

    public ContentSyncHealthCheck(IScheduledJobLogRepository logRepository, IScheduledJobRepository jobRepository)
    {
        _logRepository = logRepository;
        _jobRepository = jobRepository;
    }

    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken token = default)
    {
        // Identify the specific sync job by its GUID
        var jobId = new Guid("8a0e3b0b-2a0d-4b88-f6dc-af8d6acccb7a");
        var job = _jobRepository.Get(jobId);

        if (job == null)
        {
            return Task.FromResult(HealthCheckResult.Unhealthy("Sync job not found."));
        }

        // Retrieve the most recent log entry
        var latestLog = _logRepository.GetLogEntries(jobId, 0, 1).FirstOrDefault();

        if (latestLog == null)
        {
            return Task.FromResult(HealthCheckResult.Degraded("No sync history available."));
        }

        // Verify if the job ran within the last 2 hours and was successful
        var isStale = latestLog.CompletedUtc < DateTime.UtcNow.AddHours(-2);
        var isFailed = latestLog.Status == ScheduledJobReportStatus.Failed;

        if (isFailed || isStale)
        {
            return Task.FromResult(HealthCheckResult.Unhealthy($"Sync is broken. Last success: {latestLog.CompletedUtc}"));
        }

        return Task.FromResult(HealthCheckResult.Healthy("Content synchronization is operational."));
    }
}

4. Alerting and Defensive Failover

Effective monitoring must lead to proactive outcomes to ensure site stability:

Threshold-Based Alerts: Configure Azure Alerts to trigger when ExternalApiLatency exceeds critical thresholds for more than 5 minutes.
Missing Heartbeat Alerts: Utilize "Smart Detection" in Application Insights to notify teams if its expected sync event telemetry has ceased.
Automatic Circuit Tripping: If monitoring detects a 100% failure rate, the synchronization job should be programmatically disabled to prevent log flooding and wasteful resource consumption.

Conclusion

Operational monitoring in Optimizely CMS 13 transforms synchronization from an opaque background process into a transparent architectural layer. By implementing a combination of heartbeat monitoring, structured Application Insights telemetry, and native .NET Health Checks, architects ensure that broken integrations are identified and resolved before they impact the user experience. Shifting to a health-aware monitoring strategy is the final step in securing a robust federated content hub.