feat(quartz): Add an option to monitor all scheduled jobs

src/Sentry.Quartz/Core/JobMonitor.cs

@@ -5,13 +5,14 @@
 
 namespace Sentry.Quartz;
 
-// Captures the check-ins of jobs with SentryMonitorSlugAttribute
+// Captures the check-ins of jobs with SentryMonitorSlugAttribute, or of every scheduled job with MonitorAllJobs
 internal sealed class JobMonitor
 {
     // How long the schedules of all monitored triggers are reused before they're read from the scheduler again
     internal static readonly TimeSpan TriggerSchedulesTtl = TimeSpan.FromMinutes(1);
 
     private static readonly ConcurrentDictionary<Type, SentryMonitorSlugAttribute?> Attributes = new();
+    private static readonly SentryMonitorSlugAttribute DefaultAttribute = new();
 
     private readonly SentryQuartzOptions _options;
     private readonly IHub _hub;
@@ -38,7 +39,8 @@ public JobMonitor(SentryQuartzOptions options, IHub hub, IDiagnosticLogger? logg
         try
         {
             var jobType = QuartzApi.GetJobType(context.JobDetail);
-            var attribute = GetAttribute(jobType);
+            var attribute = GetAttribute(jobType)
+                            ?? (IsMonitoredByDefault(context) ? DefaultAttribute : null);
             if (attribute is null)
             {
                 return null;
@@ -52,9 +54,27 @@ public JobMonitor(SentryQuartzOptions options, IHub hub, IDiagnosticLogger? logg
                 return null;
             }
 
-            configureMonitorOptions = _options.SendMonitorConfig && attribute.SendMonitorConfig
-                ? await GetMonitorConfigAsync(context, monitorSlug, cancellationToken).ConfigureAwait(false)
-                : null;
+            var monitoredByDefault = ReferenceEquals(attribute, DefaultAttribute);
+            bool hasNoSchedule;
+            if (_options.SendMonitorConfig && attribute.SendMonitorConfig)
+            {
+                configureMonitorOptions = await GetMonitorConfigAsync(context, monitorSlug, cancellationToken)
+                    .ConfigureAwait(false);
+                hasNoSchedule = configureMonitorOptions is null;
+            }
+            else
+            {
+                configureMonitorOptions = null;
+                hasNoSchedule = monitoredByDefault
+                    && await GetTriggerScheduleAsync(context, monitorSlug, cancellationToken).ConfigureAwait(false) is null;
+            }
+
+            if (monitoredByDefault && hasNoSchedule)
+            {
+                Logger?.LogDebug("Skipping the check-in for job '{0}'. MonitorAllJobs only monitors jobs whose " +
+                                 "schedule Sentry supports.", context.JobDetail.Key);
+                return null;
+            }
         }
         catch (Exception e)
         {
@@ -153,6 +173,52 @@ public void Finish(JobCheckIn checkIn, bool failed, TimeSpan duration)
         }
     }
 
+    private bool IsMonitoredByDefault(IJobExecutionContext context)
+    {
+        if (!_options.MonitorAllJobs)
+        {
+            return false;
+        }
+
+        // Only jobs on a schedule Sentry can represent, and whose key stays the same across restarts
+        var key = context.JobDetail.Key;
+        if (!HasSentrySchedule(context.Trigger) || !HasIdentity(key))
+        {
+            return false;
+        }
+
+        if (IsExcluded(key))
+        {
+            Logger?.LogDebug("Skipping the check-in for job '{0}'. It matches ExcludedJobs.", key);
+            return false;
+        }
+
+        return true;
+    }
+
+    // Whether MonitorAllJobs covers the job's scheduled runs
+    private bool IsMonitoredByDefault(IJobDetail job) =>
+        _options.MonitorAllJobs && HasIdentity(job.Key) && !IsExcluded(job.Key);
+
+    private static bool HasSentrySchedule(ITrigger trigger) =>
+        TriggerSchedule.ToSchedule(trigger) is not null;
+
+    private bool IsExcluded(JobKey key)
+    {
+        var fullKey = key.ToString();
+        foreach (var pattern in _options.ExcludedJobs)
+        {
+            if (pattern._regex is { } regex
+                    ? regex.IsMatch(fullKey) || regex.IsMatch(key.Name)
+                    : pattern._string == fullKey || pattern._string == key.Name)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     // Reading every trigger takes several scheduler queries, so the result is reused for a minute.
     private async Task<TriggerSchedules> GetTriggerSchedulesAsync(
         IScheduler scheduler,
@@ -166,7 +232,7 @@ private async Task<TriggerSchedules> GetTriggerSchedulesAsync(
             if (_triggerSchedules is not { } schedules || schedules.ReadAt + TriggerSchedulesTtl <= now
                 || schedules.Scheduler != scheduler || !schedules.Contains(triggerKey))
             {
-                schedules = await TriggerSchedules.ReadAsync(scheduler, now, cancellationToken).ConfigureAwait(false);
+                schedules = await TriggerSchedules.ReadAsync(this, scheduler, now, cancellationToken).ConfigureAwait(false);
                 _triggerSchedules = schedules;
             }
 
@@ -196,19 +262,20 @@ private TriggerSchedules(IScheduler scheduler, DateTimeOffset readAt,
             _keys = keys;
         }
 
-        public static async Task<TriggerSchedules> ReadAsync(IScheduler scheduler, DateTimeOffset readAt,
-            CancellationToken cancellationToken)
+        public static async Task<TriggerSchedules> ReadAsync(JobMonitor monitor, IScheduler scheduler,
+            DateTimeOffset readAt, CancellationToken cancellationToken)
         {
             var triggersBySlug = new Dictionary<string, List<(TriggerKey Key, MonitorSchedule Schedule)>>();
             var keys = new HashSet<TriggerKey>();
-            var triggers = await QuartzApi.GetTriggersAsync(scheduler, IsMonitored, cancellationToken).ConfigureAwait(false);
+            var triggers = await QuartzApi.GetTriggersAsync(scheduler, monitor.IsMonitored, cancellationToken)
+                .ConfigureAwait(false);
             foreach (var (job, trigger) in triggers)
             {
                 keys.Add(trigger.Key);
 
-                // Triggers whose schedule isn't sent don't change the monitor
-                var attribute = GetAttribute(QuartzApi.GetJobType(job))!;
-                if (!attribute.SendMonitorConfig
+                // Triggers whose runs aren't monitored, or whose schedule isn't sent, don't change the monitor
+                var attribute = GetAttribute(QuartzApi.GetJobType(job)) ?? DefaultAttribute;
+                if (attribute is not { SendMonitorConfig: true }
                     || TriggerSchedule.ToSchedule(trigger) is not { } schedule
                     || GetMonitorSlug(job, trigger, attribute) is not { } slug)
                 {
@@ -240,18 +307,18 @@ public List<TriggerKey> WithDifferentSchedule(string monitorSlug, TriggerKey tri
                 .Select(trigger => trigger.Key)
                 .ToList();
         }
+    }
 
-        // Jobs whose type can't be resolved, such as a deleted job class still in a persistent store, are skipped
-        private static bool IsMonitored(IJobDetail job)
+    // Jobs whose type can't be resolved, such as a deleted job class still in a persistent store, are skipped
+    private bool IsMonitored(IJobDetail job)
+    {
+        try
         {
-            try
-            {
-                return GetAttribute(QuartzApi.GetJobType(job)) is not null;
-            }
-            catch (Exception)
-            {
-                return false;
-            }
+            return GetAttribute(QuartzApi.GetJobType(job)) is not null || IsMonitoredByDefault(job);
+        }
+        catch (Exception)
+        {
+            return false;
         }
     }
 

src/Sentry.Quartz/Core/SentryMonitorSlugAttribute.cs

@@ -5,7 +5,7 @@ namespace Sentry.Quartz;
 /// </summary>
 /// <remarks>
 /// <para>
-/// Jobs without this attribute are not monitored.
+/// Jobs without this attribute are not monitored, unless <see cref="SentryQuartzOptions.MonitorAllJobs"/> is enabled.
 /// </para>
 /// <para>
 /// When no monitor slug is given, the slug is the job's group and name joined by a hyphen, normalized the way Sentry

src/Sentry.Quartz/Core/SentryQuartzOptions.cs

@@ -7,6 +7,34 @@ namespace Sentry.Quartz;
 /// </summary>
 public class SentryQuartzOptions
 {
+    /// <summary>
+    /// When enabled, every job fired by a trigger whose schedule Sentry can represent sends check-ins, as if it had
+    /// <see cref="SentryMonitorSlugAttribute"/> without a monitor slug. Defaults to <c>false</c>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The monitor slug is the slug of the job's key, as described on <see cref="SentryMonitorSlugAttribute"/>. Jobs
+    /// built without an identity are skipped, and so are runs fired by other triggers, such as a job triggered once by
+    /// hand or a trigger with a calendar. <see cref="SendMonitorConfig"/> lists the schedules Sentry can represent.
+    /// Jobs with several triggers on different schedules are skipped, and so are jobs that share a monitor slug with
+    /// another job on a different schedule. Jobs with <see cref="SentryMonitorSlugAttribute"/> keep its settings and
+    /// still send check-ins.
+    /// </para>
+    /// <para>
+    /// To skip some jobs, add them to <see cref="ExcludedJobs"/>.
+    /// </para>
+    /// </remarks>
+    public bool MonitorAllJobs { get; set; }
+
+    /// <summary>
+    /// Jobs that <see cref="MonitorAllJobs"/> doesn't monitor. A string matches a job whose name or full key
+    /// (<c>group.name</c>) is equal to it, and a regular expression a job whose name or full key it matches.
+    /// </summary>
+    /// <remarks>
+    /// Jobs with <see cref="SentryMonitorSlugAttribute"/> are monitored even when they match.
+    /// </remarks>
+    public IList<StringOrRegex> ExcludedJobs { get; set; } = new List<StringOrRegex>();
+
     /// <summary>
     /// When enabled, the in-progress check-in of each job with <see cref="SentryMonitorSlugAttribute"/> includes
     /// the schedule of the trigger that fired the job as the monitor config, so Sentry creates the monitor or updates

src/Sentry.Quartz/SentryQuartzBuilderExtensions.cs

@@ -25,7 +25,8 @@ public static class SentryQuartzBuilderExtensions
         /// <para>
         /// Jobs with <see cref="SentryMonitorSlugAttribute"/> also send a check-in each time they run, with the
         /// schedule of the trigger that fired them as the monitor config. A job that throws or is cancelled sends an
-        /// error check-in. See <see cref="SentryQuartzOptions.SendMonitorConfig"/>.
+        /// error check-in. See <see cref="SentryQuartzOptions.SendMonitorConfig"/>. To monitor every scheduled job,
+        /// enable <see cref="SentryQuartzOptions.MonitorAllJobs"/>.
         /// </para>
         /// </remarks>
         /// <param name="configure">Configures the options.</param>

test/Sentry.Quartz.Tests/ApiApprovalTests.Run.DotNet10_0.verified.txt

@@ -19,6 +19,8 @@
     {
         public SentryQuartzOptions() { }
         public System.Action<Quartz.IJobExecutionContext, Sentry.SentryMonitorOptions>? ConfigureMonitorOptions { get; set; }
+        public System.Collections.Generic.IList<Sentry.StringOrRegex> ExcludedJobs { get; set; }
+        public bool MonitorAllJobs { get; set; }
         public bool SendMonitorConfig { get; set; }
     }
 }