perf(reminders): drop reminders that are not due soon - #10259

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:852

• CalculateNextTickTime assumes entry.StartAt.Kind is Utc via Debug.Assert and also returns entry.StartAt directly when now <= entry.StartAt. Some reminder storage providers can round-trip StartAt as DateTimeKind.Unspecified (the code below already treats reminder timestamps as UTC even if the kind is lost), which makes the assert incorrect in Debug builds and can propagate Unspecified into computed tick times (breaking the later previousTickTime.Kind == Utc assert). Normalize StartAt to UTC ticks before using/returning it.

        internal static DateTime CalculateNextTickTime(ReminderEntry entry, DateTime now)
        {
            ArgumentNullException.ThrowIfNull(entry);
            Debug.Assert(entry.StartAt.Kind == DateTimeKind.Utc);
            Debug.Assert(now.Kind == DateTimeKind.Utc);
            if (entry.Period <= TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException(nameof(entry), entry.Period, "Reminder period must be greater than zero.");
            }

            if (now <= entry.StartAt)
            {
                return entry.StartAt;
            }

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:843

• CalculateNextTickTime asserts that entry.StartAt.Kind == DateTimeKind.Utc, but reminder storage providers can legitimately round-trip DateTime values as Unspecified (while still representing UTC). This makes the invariant too strict (and contradicts the later comment which says timestamps represent UTC even if kind is lost), causing debug builds/tests to fail unexpectedly.

        internal static DateTime CalculateNextTickTime(ReminderEntry entry, DateTime now)
        {
            ArgumentNullException.ThrowIfNull(entry);
            Debug.Assert(entry.StartAt.Kind == DateTimeKind.Utc);
            Debug.Assert(now.Kind == DateTimeKind.Utc);

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:2

• using Microsoft.CodeAnalysis; appears to be unused in this file and will trigger CS8019 (unused using directive) under warnings-as-errors. Remove it to keep the build clean.

using Microsoft.CodeAnalysis;

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:5

• using Microsoft.CodeAnalysis; is unused in this file and will trigger an unnecessary-using warning (and likely fail the build if warnings are treated as errors). Please remove it.

using System.Diagnostics;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:845

• ReminderEntry.StartAt is documented/handled elsewhere as “UTC even if a storage provider loses DateTimeKind”, but CalculateNextTickTime currently assumes DateTimeKind.Utc (Debug.Assert) and uses now <= entry.StartAt, which can perform kind conversions and miscompute comparisons if StartAt.Kind is Unspecified/Local. Normalize StartAt (and now) via DateTime.SpecifyKind(..., Utc) and compare using ticks to avoid unintended kind conversions.

            ArgumentNullException.ThrowIfNull(entry);
            Debug.Assert(entry.StartAt.Kind == DateTimeKind.Utc);
            Debug.Assert(now.Kind == DateTimeKind.Utc);
            if (entry.Period <= TimeSpan.Zero)
            {

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:5

• using Microsoft.CodeAnalysis; is unused in this file (it’s the only occurrence), which will trigger CS8019 under warnings-as-errors. Please remove it to keep the build clean.

using System.Diagnostics;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:1122

• TryStopOutsideLoadingWindow cancels _scheduleChangedCancellation but does not dispose it. Since evictions can happen frequently with a small loading window, disposing here helps avoid CTS resource buildup.

                _shared.LogDebugStoppingReminder(entry, ReminderEvents.LocalReminderStopReason.OutsideLoadingWindow);
                _stopCancellation.Cancel();
                scheduleChangedCancellation.Cancel();
                return true;

src/Orleans.Reminders/ReminderService/LocalReminderService.cs:1099

• StopAsync cancels the current _scheduleChangedCancellation but never disposes it. Since this CTS is replaced/disposed on Update, leaving it undisposed on stop can accumulate unmanaged resources (eg, registrations) across many reminders.

Dispose the captured CTS after cancelling it, similar to Update.

This issue also appears on line 1119 of the same file.

                if (entry is not null)
                {
                    _shared.LogDebugStoppingReminder(entry, reason);
                }
                _stopCancellation.Cancel();
                scheduleChangedCancellation.Cancel();
                return runTask ?? Task.CompletedTask;