Fix Foundatio NRT nullable reference type errors by niemyjski · Pull Request #2202 · exceptionless/Exceptionless

niemyjski · 2026-04-13T14:04:37Z

Summary

Adapts all consuming code to Foundatio new NRT annotations. No functional changes — only null-safety adaptations.

What Changed and Why

Insulation (2 files)

Bootstrapper.cs: Updated GetAWSCredentials/GetAWSRegionEndpoint parameter types to use nullable dictionary values
MaxMindGeoIpService.cs: Added null check on stream from GetFileStreamAsync

Web (4 files)

EventController.cs / StackController.cs: Null-conditional on aggregation results, guarded SearchBeforeToken/AfterToken/AggregationsExpression
MessageBusBroker.cs: Added null guard for entityChanged.Id, made userId nullable
OverageMiddleware.cs: Fail-closed when org not found (was NRE, now returns 402)

Tests (17 files)

Adapted assertions for nullable returns from repository and aggregation APIs

Test Plan

dotnet build — 0 errors, 0 warnings
dotnet test — CI

- Update Foundatio libraries to the latest beta versions across the Core, Insulation, and Test projects.

…iles (batch 1/3) Foundatio packages upgraded to versions with nullable reference types enabled, causing 135 build errors. This batch fixes 102 errors across 30 files by: - Updating Dictionary<string, string> to Dictionary<string, string?> for connection string data - Changing ILock return types to ILock? for lock acquisition methods - Adding null guards for QueueEntry.Value and WorkItemContext.GetData<T>() which are now nullable - Adding diagnostic logging for null defensive guards to improve observability Remaining 33 errors in Repositories, Services, Billing, and Migrations will be addressed in subsequent batches.

Copilot

Pull request overview

Aligns Exceptionless with Foundatio’s updated nullable-reference-type (NRT) APIs, addressing build breaks caused by nullable connection-string parsing, nullable queue/work-item payloads, and nullable lock acquisition.

Changes:

Updated Foundatio package references and adjusted affected project dependencies.
Updated configuration option models to use Dictionary<string, string?> for parsed connection-string data and added null-safe parsing.
Updated jobs and work item handlers for nullable queue/work-item payloads and nullable lock acquisition (ILock?), adding defensive guards and logging.

Reviewed changes

Copilot reviewed 36 out of 36 changed files in this pull request and generated 11 comments.

Show a summary per file

File	Description
tests/Exceptionless.Tests/Exceptionless.Tests.csproj	Bumps Foundatio Xunit package to a newer beta compatible with NRT changes.
src/Exceptionless.Insulation/Exceptionless.Insulation.csproj	Updates Foundatio provider packages to newer betas.
src/Exceptionless.Core/Exceptionless.Core.csproj	Updates Foundatio hosting/JsonNet packages and Elasticsearch repo package version.
src/Exceptionless.Core/Extensions/DictionaryExtensions.cs	Updates connection-string dictionary extension helpers to accept nullable values.
src/Exceptionless.Core/Configuration/StorageOptions.cs	Switches connection-string parsed `Data` to `Dictionary<string, string?>`.
src/Exceptionless.Core/Configuration/QueueOptions.cs	Switches connection-string parsed `Data` to `Dictionary<string, string?>`.
src/Exceptionless.Core/Configuration/CacheOptions.cs	Uses nullable-valued connection-string parsing and merges provider options safely.
src/Exceptionless.Core/Configuration/MessageBusOptions.cs	Uses nullable-valued connection-string parsing and merges provider options safely.
src/Exceptionless.Core/Configuration/MetricOptions.cs	Uses null-safe parsing for potentially-missing metrics connection string.
src/Exceptionless.Core/Configuration/ElasticsearchOptions.cs	Uses null-safe parsing for potentially-missing Elasticsearch connection string.
src/Exceptionless.Core/Configuration/AuthOptions.cs	Uses null-safe parsing for OAuth connection-string data.
src/Exceptionless.Core/Configuration/SlackOptions.cs	Uses null-safe parsing for OAuth connection-string data.
src/Exceptionless.Core/Configuration/IntercomOptions.cs	Uses null-safe parsing for OAuth connection-string data.
src/Exceptionless.Core/Jobs/WebHooksJob.cs	Adds null guards for queue payload and for nullable WebHook id handling.
src/Exceptionless.Core/Jobs/MailMessageJob.cs	Adds null guard for queue payload and avoids re-reading nullable entry value.
src/Exceptionless.Core/Jobs/EventUserDescriptionsJob.cs	Adds null guard for queue payload; initializes `ev.Data` before `AddRange`.
src/Exceptionless.Core/Jobs/EventNotificationsJob.cs	Adds null guard for queue payload.
src/Exceptionless.Core/Jobs/EventPostsJob.cs	Adds null guard for queue payload; avoids re-reading entry value after completion; improves logging around nullability.
src/Exceptionless.Core/Jobs/StackStatusJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/StackEventCountJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/EventUsageJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/DownloadGeoIPDatabaseJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/DailySummaryJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/CloseInactiveSessionsJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/CleanupOrphanedDataJob.cs	Updates lock acquisition signature to `Task<ILock?>`.
src/Exceptionless.Core/Jobs/CleanupDataJob.cs	Updates lock acquisition signature to `Task<ILock?>`; filters null hits elements before accessing ids.
src/Exceptionless.Core/Jobs/WorkItemHandlers/UserMaintenanceWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/UpdateProjectNotificationSettingsWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/SetProjectIsConfiguredWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/SetLocationFromGeoWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data and `Geo` string.
src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveStacksWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveBotEventsWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectMaintenanceWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationNotificationWorkItemHandler.cs	Adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationMaintenanceWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.
src/Exceptionless.Core/Jobs/WorkItemHandlers/FixStackStatsWorkItemHandler.cs	Updates lock acquisition signature to `Task<ILock?>`; adds null guard for work item data.

Comments suppressed due to low confidence (3)

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetLocationFromGeoWorkItemHandler.cs:31

AcquireAsync(..., new CancellationToken(true)) passes a canceled token, which can prevent acquiring the lock for this work item. Pass through the cancellationToken parameter instead.
src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveStacksWorkItemHandler.cs:27
new CancellationToken(true) is an already-canceled token; using it with _lockProvider.AcquireAsync can cause immediate cancellation and prevent lock acquisition. Use the method's cancellationToken parameter instead.

    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        string cacheKey = $"{nameof(RemoveStacksWorkItem)}:{((RemoveStacksWorkItem)workItem).ProjectId}";
        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), new CancellationToken(true));
    }

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetProjectIsConfiguredWorkItemHandler.cs:28

This passes new CancellationToken(true) (already canceled) to _lockProvider.AcquireAsync, which can cancel lock acquisition immediately and keep this handler from running under lock. Use the provided cancellationToken instead.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

src/Exceptionless.Core/Jobs/StackStatusJob.cs

src/Exceptionless.Core/Jobs/StackEventCountJob.cs

src/Exceptionless.Core/Jobs/EventUsageJob.cs

src/Exceptionless.Core/Jobs/DailySummaryJob.cs

src/Exceptionless.Core/Jobs/DownloadGeoIPDatabaseJob.cs

src/Exceptionless.Core/Jobs/CleanupOrphanedDataJob.cs

src/Exceptionless.Core/Jobs/CleanupDataJob.cs

Copilot · 2026-04-13T14:10:19Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/ProjectMaintenanceWorkItemHandler.cs

-    public override Task<ILock> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        return _lockProvider.AcquireAsync(nameof(ProjectMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), new CancellationToken(true));


new CancellationToken(true) is pre-canceled; if _lockProvider.AcquireAsync observes it, this handler won't acquire its work-item lock. Pass the cancellationToken parameter (or CancellationToken.None) instead.

Suggested change

return _lockProvider.AcquireAsync(nameof(ProjectMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), new CancellationToken(true));

return _lockProvider.AcquireAsync(nameof(ProjectMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), cancellationToken);

Copilot · 2026-04-13T14:10:19Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/UserMaintenanceWorkItemHandler.cs

+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        return _lockProvider.AcquireAsync(nameof(UserMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), new CancellationToken(true));
    }


This uses new CancellationToken(true) (already canceled) for lock acquisition, which can cause acquisition to immediately cancel and the handler to run unlocked / not run at all (depending on base behavior). Use the provided cancellationToken instead.

Copilot · 2026-04-13T14:10:20Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationNotificationWorkItemHandler.cs

+
        string cacheKey = $"{nameof(OrganizationNotificationWorkItemHandler)}:{wi.OrganizationId}";

        return _lockProvider.TryUsingAsync(cacheKey, async () =>


In this TryUsingAsync call, the CancellationToken argument passed later is new CancellationToken(true), which is already canceled and can cause the lock usage to be canceled immediately (skipping the work). Pass through the caller's cancellation token (or CancellationToken.None) instead.

Foundatio 11.x introduces nullable reference types across infrastructure APIs (ILockProvider, ICacheClient, FindResults, QueueEntry, etc.). Batch 2 adapts Repositories, Services, Extensions, Models, Plugins, Mail, Migrations, Billing, and Utility files to handle nullable returns and stricter nullability contracts. Key changes: - Add null guards after GetByIdAsync (returns T? now) - Use .OfType<T>() to filter null collection elements - Guard nullable keys before ICacheClient.GetAsync - Handle DateRange init-only properties via Remove/re-add pattern - Add logging when operations silently skip missing entities - Change return types where Foundatio APIs now return nullable Brings Exceptionless.Core to 0 build errors. Tests blocked by 8 pre-existing Insulation errors (batch 3).

Copilot review identified 11 instances where \ ew CancellationToken(true)\ (already canceled) was passed to lock acquisition methods. This caused locks to be immediately canceled, preventing jobs/handlers from running. Changed all lock acquisition calls to pass through the method's \cancellationToken\ parameter instead, allowing proper lock acquisition and job execution.

Copilot

Pull request overview

Copilot reviewed 56 out of 56 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (2)

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetLocationFromGeoWorkItemHandler.cs:31

GetWorkItemLockAsync passes new CancellationToken(true) (already canceled) into _lockProvider.AcquireAsync, which can prevent the lock from ever being acquired. Use the cancellationToken parameter passed into the method (or context.CancellationToken) so lock acquisition can proceed and be canceled correctly.
src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveStacksWorkItemHandler.cs:27
GetWorkItemLockAsync uses new CancellationToken(true) when acquiring the lock, which is an already-canceled token and can cause AcquireAsync to immediately cancel and return no lock. Pass through the cancellationToken argument instead.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-13T16:56:09Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetProjectIsConfiguredWorkItemHandler.cs

+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        string cacheKey = $"{nameof(SetProjectIsConfiguredWorkItemHandler)}:{((SetProjectIsConfiguredWorkItem)workItem).ProjectId}";
        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), new CancellationToken(true));


GetWorkItemLockAsync ignores the provided cancellationToken and passes new CancellationToken(true) (already-canceled) to AcquireAsync, which can cause lock acquisition to be immediately canceled and the handler to run without a lock (or not run as intended). Pass through the cancellationToken parameter (or context.CancellationToken) instead of creating an always-canceled token.

Foundatio now exposes NRT annotations. This commit adapts all consuming code: - Insulation: update GetAWSCredentials/GetAWSRegionEndpoint parameter types from IDictionary<string,string> to IDictionary<string,string?>, add null check on GeoIP database stream - Web controllers: use null-conditional on aggregation results (Min/Max/Sum/Cardinality/Terms), guard SearchBeforeToken/AfterToken and AggregationsExpression against null, fix OverageMiddleware null dereference, add null guard in MessageBusBroker - Tests: adapt all test assertions to handle nullable returns from repository and aggregation APIs

Copilot

Pull request overview

Copilot reviewed 79 out of 79 changed files in this pull request and generated 3 comments.

Comments suppressed due to low confidence (2)

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetLocationFromGeoWorkItemHandler.cs:31

GetWorkItemLockAsync currently passes new CancellationToken(true) to AcquireAsync instead of the provided cancellationToken. Because the token is already canceled, lock acquisition can be skipped/canceled immediately, defeating the purpose of the work-item lock. Use the cancellationToken parameter (or CancellationToken.None) here.
src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveStacksWorkItemHandler.cs:27
GetWorkItemLockAsync passes a pre-canceled CancellationToken (new CancellationToken(true)) to AcquireAsync, which can prevent the lock from being acquired and allow concurrent executions. Use the provided cancellationToken (or CancellationToken.None) instead.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-13T19:46:49Z

src/Exceptionless.Web/Controllers/EventController.cs

+                FirstOccurrence = term.Aggregations.Min<DateTime>("min_date")?.Value ?? DateTime.MinValue,
+                LastOccurrence = term.Aggregations.Max<DateTime>("max_date")?.Value ?? DateTime.MinValue,
+                Total = (long)(term.Aggregations.Sum("sum_count")?.Value ?? term.Total.GetValueOrDefault()),


Falling back to DateTime.MinValue when the min/max aggregations are missing can leak a year-0001 timestamp to API consumers. Since you already have the Stack model, prefer a meaningful fallback (e.g., stack.FirstOccurrence / stack.LastOccurrence) or handle the missing aggregation case explicitly (return 0 results / error).

Copilot · 2026-04-13T19:46:49Z

src/Exceptionless.Web/Controllers/StackController.cs

+                FirstOccurrence = term.Aggregations.Min<DateTime>("min_date")?.Value ?? DateTime.MinValue,
+                LastOccurrence = term.Aggregations.Max<DateTime>("max_date")?.Value ?? DateTime.MinValue,
+                Total = (long)(term.Aggregations.Sum("sum_count")?.Value ?? term.Total.GetValueOrDefault()),


Using DateTime.MinValue as a fallback for missing min/max aggregations can return an invalid/meaningless timestamp to clients. Consider falling back to the stack entity’s FirstOccurrence/LastOccurrence (or explicitly handling the missing aggregation case) rather than emitting 0001-01-01.

Copilot · 2026-04-13T19:46:50Z

src/Exceptionless.Core/Repositories/Queries/EventStackFilterQuery.cs

+            var dateRanges = systemFilterQuery.GetDateRanges();
+            var rangesToReplace = dateRanges
+                .Where(range => range.Field == _inferredEventDateField || range.Field == "date")
+                .ToList();
+
+            // TODO: Verify remove+add ordering change is functionally equivalent via EventStackFilterQueryTests
+            // after Insulation blocker is resolved (was previously in-place mutation).
+            foreach (var range in rangesToReplace)
            {
-                if (range.Field == _inferredEventDateField || range.Field == "date")
-                {
-                    range.Field = _inferredStackLastOccurrenceField;
-                    if (isStackIdsNegated) // don't apply retention date filter on inverted stack queries
-                        range.StartDate = null;
-                    range.EndDate = null;
-                }
+                dateRanges.Remove(range);
+                systemFilterQuery.DateRange(
+                    isStackIdsNegated ? null : range.StartDate, // don't apply retention date filter on inverted stack queries
+                    null,
+                    _inferredStackLastOccurrenceField,
+                    range.TimeZone);
            }


This hunk changes how date ranges are rewritten (remove+add) and includes a TODO noting the ordering/behavior hasn’t been verified. Given the PR description says “no functional changes”, please either add a focused test (e.g., covering date range rewriting and inverted stack queries) or adjust the implementation to preserve the previous behavior without leaving an unverified TODO in production code.

- Add .keyword sub-field to ip copy-to field in EventIndex so FieldEquals validation passes (Foundatio now rejects TermQuery on analyzed text fields without a keyword sub-field) - Regenerate OpenAPI baseline to reflect updated CountResult schema

- Fix 3 work item handlers that still passed new CancellationToken(true) to AcquireAsync, which would immediately cancel lock acquisition - Replace unverified TODO with descriptive comment (tests pass)

Address Copilot review: fall back to stack.FirstOccurrence and stack.LastOccurrence when aggregation metrics are null, instead of leaking year-0001 timestamps to API consumers.

Copilot

Pull request overview

Copilot reviewed 81 out of 81 changed files in this pull request and generated 11 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-04-14T02:17:01Z

src/Exceptionless.Core/Services/UsageService.cs

                context.Organization = await _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());

+            if (context.Organization is null)
+                throw new InvalidOperationException($"Organization '{organizationId}' not found.");
+


GetEventsLeftAsync now throws when the organization cannot be loaded from the repository. This method is called from request-path middleware (e.g., OverageMiddleware) and background jobs; throwing here will surface as a 500 instead of failing closed (block/402) or safely skipping usage checks. Consider returning 0 (or another fail-closed value) when the org is missing (and optionally logging), or ensure all callers translate this into an appropriate HTTP response/result.

Copilot · 2026-04-14T02:17:01Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetProjectIsConfiguredWorkItemHandler.cs

+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        string cacheKey = $"{nameof(SetProjectIsConfiguredWorkItemHandler)}:{((SetProjectIsConfiguredWorkItem)workItem).ProjectId}";
-        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), new CancellationToken(true));
+        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), cancellationToken);
    }


AcquireAsync(..., new CancellationToken(true)) passes an already-cancelled token, so lock acquisition will be cancelled immediately (often returning null/throwing) and the handler may run without the intended lock protection. Use the provided cancellationToken (or CancellationToken.None) instead of creating a cancelled token.

Copilot · 2026-04-14T02:17:01Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/SetLocationFromGeoWorkItemHandler.cs

+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        string cacheKey = $"{nameof(SetLocationFromGeoWorkItemHandler)}:{((SetLocationFromGeoWorkItem)workItem).EventId}";
-        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), new CancellationToken(true));
+        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), cancellationToken);
    }


AcquireAsync(..., new CancellationToken(true)) uses an already-cancelled token, which can prevent the lock from being acquired and lead to concurrent handlers for the same event. Use the cancellationToken parameter (or CancellationToken.None) instead so the lock reliably protects this work item.

Copilot · 2026-04-14T02:17:02Z

src/Exceptionless.Core/Jobs/WorkItemHandlers/RemoveStacksWorkItemHandler.cs

+    public override Task<ILock?> GetWorkItemLockAsync(object workItem, CancellationToken cancellationToken = new())
    {
        string cacheKey = $"{nameof(RemoveStacksWorkItem)}:{((RemoveStacksWorkItem)workItem).ProjectId}";
-        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), new CancellationToken(true));
+        return _lockProvider.AcquireAsync(cacheKey, TimeSpan.FromMinutes(15), cancellationToken);
    }


AcquireAsync(..., new CancellationToken(true)) passes a cancelled token, so the lock is likely never acquired and this handler may run concurrently (which is risky for bulk stack deletion + cache invalidation). Use the supplied cancellationToken (or CancellationToken.None) instead of a pre-cancelled token.

Copilot · 2026-04-14T02:17:02Z

tests/Exceptionless.Tests/Stats/AggregationTests.cs

+        Assert.Equal(eventCount, (result.Aggregations.DateHistogram("date_date")?.Buckets ?? []).Sum(t => t.Total));
+        Assert.Single((result.Aggregations.DateHistogram("date_date")?.Buckets ?? []).First().Aggregations);
+        Assert.Equal(eventCount, result.Aggregations.Cardinality("cardinality_id")?.Value.GetValueOrDefault() ?? 0);
+        Assert.Equal(eventCount, (result.Aggregations.DateHistogram("date_date")?.Buckets ?? []).Sum(t => t.Aggregations.Cardinality("cardinality_id")?.Value.GetValueOrDefault() ?? 0));


The null-coalescing to [] followed by .First() can still throw when the date histogram aggregation/buckets are missing or empty, but the exception will be less informative than an assertion failure. Consider asserting the histogram and bucket collection is not null/empty before accessing First(), or use Single()/FirstOrDefault() with an explicit assert message.

Copilot · 2026-04-14T02:17:02Z

tests/Exceptionless.Tests/Serializer/SerializerTests.cs

        Assert.Equal(8, ev.Data.Count);
        Assert.Equal("Hi", ev.Data.GetString("SomeString"));
-        Assert.False(ev.Data.GetBoolean("SomeBool"));
+        Assert.Equal(false, ev.Data["SomeBool"]);
        Assert.Equal(1L, ev.Data["SomeNum"]);


Assert.Equal(false, ev.Data["SomeBool"]) depends on the deserializer storing a boxed bool. If the converter ever yields a string/JValue/JsonElement, this will fail even though the logical value is false. Consider using a typed accessor/conversion (e.g., retrieving a bool via the same conversion path used in production) so the test validates behavior rather than the internal representation.

Copilot · 2026-04-14T02:17:03Z

src/Exceptionless.Core/Services/UsageService.cs

            var organization = await _organizationRepository.GetByIdAsync(organizationId, o => o.Cache());
+            if (organization is null)
+                throw new InvalidOperationException($"Organization '{organizationId}' not found.");


Throwing InvalidOperationException when the organization/project is missing changes the behavior of GetUsageAsync from a query-style method into an exception-throwing method, which can bubble up as a 500 in controller mapping paths. Consider returning a zeroed UsageInfoResponse (or a null/Try* result) and letting API layers decide whether to return 404 vs. default usage.

Copilot · 2026-04-14T02:17:03Z

src/Exceptionless.Core/Services/UsageService.cs

            var project = await _projectRepository.GetByIdAsync(projectId, o => o.Cache());
+            if (project is null)
+                throw new InvalidOperationException($"Project '{projectId}' not found.");


Same concern as the organization branch: throwing when the project is missing can cause unhandled exceptions in callers that expect a best-effort usage calculation. Prefer returning a default/empty usage response (or a nullable/Try* result) so API layers can decide how to handle missing projects.

Copilot · 2026-04-14T02:17:03Z

tests/Exceptionless.Tests/Stats/AggregationTests.cs

        var termsAggregation = result.Aggregations.Terms<string>("terms_stack_id");
-        var largestStackBucket = termsAggregation.Buckets.First();
+        var largestStackBucket = (termsAggregation?.Buckets ?? []).First();



(termsAggregation?.Buckets ?? []).First() will throw if the aggregation is missing or returns no buckets, but the ?? [] makes it harder to tell whether the failure was due to missing aggregations vs. missing test data. Consider asserting termsAggregation and Buckets are present/non-empty before calling First() so failures are clearer.

Copilot · 2026-04-14T02:17:03Z

src/Exceptionless.Core/Repositories/Configuration/Indexes/EventIndex.cs

        return descriptor
-            .Text(f => f.Name(EventIndex.Alias.IpAddress).Analyzer(EventIndex.COMMA_WHITESPACE_ANALYZER))
+            .Text(f => f.Name(EventIndex.Alias.IpAddress).Analyzer(EventIndex.COMMA_WHITESPACE_ANALYZER).AddKeywordField())
            .Text(f => f.Name(EventIndex.Alias.OperatingSystem).Analyzer(EventIndex.WHITESPACE_LOWERCASE_ANALYZER).AddKeywordField())


Adding .AddKeywordField() to the IpAddress alias mapping changes the Elasticsearch index mapping (introduces a new multi-field) and may require an index version bump/reindex depending on how indexes are managed. This appears to be a functional change, so it should be called out in the PR description and verified for rollout impact.

github-actions · 2026-04-14T02:21:07Z

Package	Line Rate	Branch Rate	Complexity	Health
Exceptionless.Core	66%	60%	7630	➖
Exceptionless.Insulation	24%	22%	210	❌
Exceptionless.Web	57%	43%	3646	➖
Exceptionless.AppHost	26%	14%	55	❌
Summary	61% (11932 / 19520)	54% (5960 / 11106)	11541	➖

niemyjski added 2 commits April 12, 2026 22:15

Update dependencies

ae3ddb2

- Update Foundatio libraries to the latest beta versions across the Core, Insulation, and Test projects.

Copilot AI review requested due to automatic review settings April 13, 2026 14:04

Copilot started reviewing on behalf of niemyjski April 13, 2026 14:05 View session

Copilot AI reviewed Apr 13, 2026

View reviewed changes

niemyjski added 2 commits April 13, 2026 09:51

Copilot AI review requested due to automatic review settings April 13, 2026 16:51

Copilot started reviewing on behalf of niemyjski April 13, 2026 16:52 View session

Copilot AI reviewed Apr 13, 2026

View reviewed changes

niemyjski changed the title ~~Fix Foundatio NRT errors (batch 1/3: Configuration, Jobs, WorkItemHandlers)~~ Fix Foundatio NRT nullable reference type errors Apr 13, 2026

niemyjski requested a review from Copilot April 13, 2026 19:40

Copilot started reviewing on behalf of niemyjski April 13, 2026 19:40 View session

Copilot AI reviewed Apr 13, 2026

View reviewed changes

Fix Foundatio upgrade test failures

8806739

- Add .keyword sub-field to ip copy-to field in EventIndex so FieldEquals validation passes (Foundatio now rejects TermQuery on analyzed text fields without a keyword sub-field) - Regenerate OpenAPI baseline to reflect updated CountResult schema

niemyjski requested a review from Copilot April 14, 2026 02:09

Copilot started reviewing on behalf of niemyjski April 14, 2026 02:09 View session

niemyjski added 2 commits April 13, 2026 21:11

Address Copilot review: fix remaining pre-canceled CancellationTokens

ba15079

- Fix 3 work item handlers that still passed new CancellationToken(true) to AcquireAsync, which would immediately cancel lock acquisition - Replace unverified TODO with descriptive comment (tests pass)

Use stack entity dates as fallback instead of DateTime.MinValue

6df2f37

Address Copilot review: fall back to stack.FirstOccurrence and stack.LastOccurrence when aggregation metrics are null, instead of leaking year-0001 timestamps to API consumers.

Copilot AI reviewed Apr 14, 2026

View reviewed changes

	return _lockProvider.AcquireAsync(nameof(ProjectMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), new CancellationToken(true));
	return _lockProvider.AcquireAsync(nameof(ProjectMaintenanceWorkItemHandler), TimeSpan.FromMinutes(15), cancellationToken);


		string cacheKey = $"{nameof(OrganizationNotificationWorkItemHandler)}:{wi.OrganizationId}";

		return _lockProvider.TryUsingAsync(cacheKey, async () =>

Uh oh!

Conversation

niemyjski commented Apr 13, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

What Changed and Why

Insulation (2 files)

Web (4 files)

Tests (17 files)

Test Plan

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

niemyjski commented Apr 13, 2026 •

edited

Loading