Harden DI and STJ edge cases and coverage

Author: niemyjski

.github/workflows/build-linux.yml

@@ -25,8 +25,15 @@ jobs:
         echo "MINVERVERSIONOVERRIDE=$version" >> $GITHUB_ENV
     - name: Build
       run: dotnet build --configuration Release Exceptionless.Net.NonWindows.slnx
-    - name: Run Tests
-      run: dotnet test --configuration Release --no-build Exceptionless.Net.NonWindows.slnx
+    - name: Run Tests with Coverage
+      run: dotnet test --configuration Release --no-build --collect:"XPlat Code Coverage" --results-directory artifacts/test-results Exceptionless.Net.NonWindows.slnx
+    - name: Upload Coverage
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: coverage-linux
+        path: artifacts/test-results/**/coverage.cobertura.xml
+        if-no-files-found: error
     - name: Pack Core for NativeAOT Test
       run: dotnet pack --configuration Release --no-build --output artifacts/aot-package -p:SolutionDir="$GITHUB_WORKSPACE/" src/Exceptionless/Exceptionless.csproj
     - name: NativeAOT Smoke Test

docs/plans/2026-07-12-modern-di-stj-plan.md

@@ -40,12 +40,13 @@
 ## Execution results
 
 - Baseline: 300 core tests and 10 MessagePack tests passed; 18 existing tests were skipped.
-- Final non-Windows suite: 324 core tests and 11 MessagePack tests passed; 0 failed; 18 tests were skipped.
-- Focused DI coverage now includes singleton and transient compatibility, constructor injection, isolated containers, late replacement, `IServiceCollection` overrides, open generics, container disposal, external instance ownership, and host-provider disposal of the default client.
-- Serializer coverage retains exact wire-format assertions and adds regressions for exclusions inside collections and settings, depth limits, reference loops in string and stream paths, public fields, the legacy ignore attribute, `DataDictionary` interface mutation, structured/raw values, settings coercion, and MessagePack round-trips.
+- Final non-Windows suite: 370 core tests and 12 MessagePack tests passed; 0 failed; 18 existing tests were skipped.
+- Focused DI coverage now includes singleton and transient compatibility, constructor injection, isolated containers, coherent provider snapshots after late replacement, `IServiceCollection` overrides and enumeration, open generics, exact disposal of every provider snapshot, external instance ownership, per-host client isolation, and host-versus-caller disposal ownership.
+- Serializer coverage retains exact wire-format assertions and adds regressions for exclusions inside collections and settings, named floating-point values, declared-type depth limits, cycles, malformed getters, predicates, converters, and iterators, STJ custom converters/number handling/extension data, stream/string parity, public fields, the legacy ignore attribute, every `DataDictionary` interface path, structured/raw values, settings and POST-data coercion, and MessagePack raw-object round-trips.
+- Linux CI now collects and uploads Cobertura coverage for both test assemblies. The final core report is 74% line / 50% branch overall and 88.1% of executable production lines changed by the PR are covered; the migration-critical components are substantially higher: `JsonValueWriter` 97% line / 93% branch, `DataDictionaryConverter` 93% / 81%, `JsonElementValueConverter` 96% / 96%, `SettingsDictionaryConverter` 89% / 83%, `DataDictionary` 99% / 92%, and the Microsoft DI resolver 84% / 61%.
 - `net462` core and `net472` test assemblies build with 0 warnings and 0 errors when Windows targeting is forced on macOS. Runtime execution of the .NET Framework tests still belongs in Windows CI.
 - The non-Windows solution packs successfully. A Windows-shaped core package containing both `net462` and `netstandard2.0` assets also packs successfully with explicit `SolutionDir`.
-- `net8.0` and `net10.0` core builds pass with 0 AOT/trim/single-file warnings. Real NativeAOT executables now cover the packed NuGet assets, default Microsoft DI/default serialization, source-generated custom properties and fields, storage round-trips, queued submission, identifiable exception frames, and Generic Host startup/shutdown on both target frameworks. Linux CI publishes and executes the package and hosting smoke applications with linker warnings treated as errors.
+- `net8.0` and `net10.0` core builds pass with 0 AOT/trim/single-file warnings. Real NativeAOT executables now cover the packed NuGet assets, default Microsoft DI/default serialization, source-generated custom properties and fields, event-batch serialization, storage round-trips, queued submission, identifiable exception frames across rethrow boundaries, and Generic Host startup/shutdown on both target frameworks. The `net10.0` smoke found and fixed an offset-only runtime frame with no usable identity; those empty frames are now omitted. Linux CI publishes and executes the package and hosting smoke applications with linker warnings treated as errors.
 - SDK ApiCompat is clean from the previous `netstandard2.0` asset to both the new `netstandard2.0` and `net8.0` assets. Compatibility shims retain the legacy ignore attribute, serializer delegates, and `AssemblyHelper.GetTypes` API.
 - Release builds now actually treat warnings as errors; the previous `WarningsAsErrors=true` property was a warning-code list rather than the boolean build gate.
 
@@ -54,15 +55,17 @@
 - The non-Windows core package grows from 596,508 bytes to 686,321 bytes (about 15%) because it contains `netstandard2.0`, `net8.0`, and `net10.0` assets instead of one asset. Its uncompressed contents shrink from 2,261,763 bytes to 1,792,690 bytes (about 21%), and the `netstandard2.0` assembly shrinks from 998,912 bytes to 348,160 bytes (about 65%).
 - Every package inherits `Microsoft.Extensions.DependencyInjection` 8 through the core package. The `netstandard2.0`, `net462`, and `net8.0` dependency groups also carry System.Text.Json 10, which is the largest deployment and binding-risk change for .NET Framework applications.
 - The existing `IDependencyResolver` and public setup APIs remain compatible. Microsoft DI backs the client-owned resolver and exposes an `IServiceCollection` customization seam; registrations from an application's root Generic Host provider are not automatically imported into the client's isolated provider.
+- Configuration-based hosting overloads now create one client owned by each host provider instead of mutating the process-wide `ExceptionlessClient.Default`. Explicit client overloads remain caller-owned. Configuration-based logging providers likewise own an isolated client, while providers given an existing client only flush it and do not dispose it. This removes cross-host configuration/disposal interference but changes code that intentionally depended on those overloads mutating the global default.
 - Custom payloads now follow System.Text.Json contracts. Public fields and `ExceptionlessIgnoreAttribute` remain supported, but consumers relying on Newtonsoft-specific contracts such as `DataContract`/`DataMember` behavior should migrate to STJ attributes and source-generated metadata.
+- Filtered event serialization remains streaming for normal objects, dictionaries, and collections. Converter-backed leaf values are preflighted before their property name is written so a failing converter cannot corrupt the containing event; this adds a small per-leaf allocation only for custom converter-backed values.
 - The `net8.0` and later core assets use normal runtime stack traces instead of the legacy IL/PDB demystifier. NativeAOT frames retain parsed method identity, but modern JIT consumers also lose enhanced demystification.
 - Although ApiCompat is clean, the serializer behavior, transitive dependency graph, target assets, and modern-stack-trace change are substantial enough to recommend a 7.0 release rather than shipping the work as 6.2.1.
 
 ## Remaining release gates
 
 - Run the net462/net472 tests and package-load checks on a real Windows runner; macOS cross-compilation passes but cannot prove .NET Framework runtime binding behavior.
 - Require the Linux, macOS, and Windows build jobs in branch protection. The repository currently requires only `license/cla`, so the new regression gates are not merge-enforced yet.
-- Push/open the branch only with awareness that non-PR Windows pushes publish prerelease packages to GitHub Packages and Feedz.
+- Keep draft PR #368 open until the real Windows runtime checks are green. Be aware that additional non-PR Windows pushes publish prerelease packages to GitHub Packages and Feedz.
 
 ## Historical NativeAOT comparison
 

src/Exceptionless/Dependency/DefaultDependencyResolver.cs

@@ -9,7 +9,10 @@ namespace Exceptionless.Dependency {
     public sealed class DefaultDependencyResolver : IDependencyResolver {
         private readonly object _lock = new object();
         private readonly IServiceCollection _services;
-        private readonly List<ServiceProvider> _providers = new List<ServiceProvider>();
+        // Microsoft DI providers are immutable. Registrations made after resolution create a
+        // new coherent provider snapshot; older snapshots stay alive so services already
+        // returned to callers are not disposed underneath them.
+        private readonly List<ServiceProvider> _providerSnapshots = new List<ServiceProvider>();
         private ServiceProvider _provider;
         private bool _disposed;
 
@@ -136,10 +139,10 @@ public void Dispose() {
                     return;
 
                 _disposed = true;
-                foreach (var provider in _providers)
+                foreach (var provider in _providerSnapshots)
                     provider.Dispose();
 
-                _providers.Clear();
+                _providerSnapshots.Clear();
                 _provider = null;
             }
         }
@@ -149,7 +152,7 @@ private ServiceProvider GetProvider() {
                 return _provider;
 
             _provider = _services.BuildServiceProvider();
-            _providers.Add(_provider);
+            _providerSnapshots.Add(_provider);
             return _provider;
         }
 

src/Exceptionless/ExceptionlessClient.cs

@@ -294,11 +294,6 @@ protected internal void OnSubmittedEvent(EventSubmittedEventArgs e) {
         }
 
         void IDisposable.Dispose() {
-            // The process-wide client can be registered as an externally owned singleton in a host.
-            // A host service provider must not make ExceptionlessClient.Default unusable for the rest of the process.
-            if (_defaultClient.IsValueCreated && ReferenceEquals(_defaultClient.Value, this))
-                return;
-
             Configuration.Changed -= OnConfigurationChanged;
             if (_queue.IsValueCreated)
                 _queue.Value.EventsPosted -= OnQueueEventsPosted;

src/Exceptionless/Extensions/ExceptionlessConfigurationExtensions.cs

@@ -439,24 +439,25 @@ public static void ReadFromConfiguration(this ExceptionlessConfiguration config,
             if (!String.IsNullOrEmpty(storageSerializer)) {
                 try {
                     Type serializerType = null;
+                    bool canResolveSerializerType = true;
 #if NET8_0_OR_GREATER
                     if (!RuntimeFeature.IsDynamicCodeSupported) {
                         config.Resolver.GetLog().Error(typeof(ExceptionlessConfigurationExtensions), "StorageSerializer cannot be activated from a type name in NativeAOT. Register IStorageSerializer with IServiceCollection instead.");
+                        canResolveSerializerType = false;
                     }
-                    else
-                        serializerType = ResolveConfiguredType(storageSerializer);
-#else
-                    serializerType = ResolveConfiguredType(storageSerializer);
 #endif
-                    if (serializerType != null) {
-                        if (!typeof(IStorageSerializer).GetTypeInfo().IsAssignableFrom(serializerType))
+                    if (canResolveSerializerType) {
+                        serializerType = ResolveConfiguredType(storageSerializer);
+                        if (serializerType == null)
+                            config.Resolver.GetLog().Error(typeof(ExceptionlessConfigurationExtensions), $"The storage serializer {storageSerializer} type could not be resolved.");
+                        else if (!typeof(IStorageSerializer).GetTypeInfo().IsAssignableFrom(serializerType))
                             config.Resolver.GetLog().Error(typeof(ExceptionlessConfigurationExtensions), $"The storage serializer {storageSerializer} does not implement interface {typeof(IStorageSerializer)}.");
                         else
                             config.Resolver.Register(typeof(IStorageSerializer), serializerType);
                     }
                 }
                 catch (Exception ex) {
-                    config.Resolver.GetLog().Error(typeof(ExceptionlessConfigurationExtensions), ex, $"The storage serializer {storageSerializer} type could not be resolved: ${ex.Message}");
+                    config.Resolver.GetLog().Error(typeof(ExceptionlessConfigurationExtensions), ex, $"The storage serializer {storageSerializer} type could not be resolved: {ex.Message}");
                 }
             }
 

src/Exceptionless/Extensions/ToErrorModelExtensions.cs

@@ -218,6 +218,10 @@ private static void PopulateStackTrace(this Error error, Error root, Exception e
 
             string[] rawStackFrames = (exception.StackTrace ?? String.Empty)
                 .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+            rawStackFrames = rawStackFrames
+                .Select(line => line.Trim())
+                .Where(line => line.StartsWith("at ", StringComparison.Ordinal))
+                .ToArray();
 
             for (int frameIndex = 0; frameIndex < frames.Length; frameIndex++) {
                 StackFrame frame = frames[frameIndex];
@@ -253,6 +257,16 @@ private static void PopulateStackTrace(this Error error, Error root, Exception e
                 if (String.IsNullOrEmpty(stackFrame.Name) && frameIndex < rawStackFrames.Length)
                     stackFrame.PopulateMethodIdentity(rawStackFrames[frameIndex]);
 
+                // NativeAOT can expose runtime frames that have no method, source, or line
+                // metadata and do not appear in Exception.StackTrace. An offset-only frame
+                // cannot be displayed or grouped meaningfully, so omit it instead of
+                // emitting an empty stack frame.
+                if (String.IsNullOrEmpty(stackFrame.Name)
+                    && String.IsNullOrEmpty(stackFrame.DeclaringType)
+                    && String.IsNullOrEmpty(stackFrame.FileName)
+                    && stackFrame.LineNumber == 0)
+                    continue;
+
                 error.StackTrace.Add(stackFrame);
             }
         }
@@ -265,14 +279,14 @@ private static void PopulateMethodIdentity(this Method method, string stackTrace
             if (identity.StartsWith("at ", StringComparison.Ordinal))
                 identity = identity.Substring(3);
 
-            int argumentsStart = identity.IndexOf('(');
-            if (argumentsStart >= 0)
-                identity = identity.Substring(0, argumentsStart);
-
             int locationStart = identity.IndexOf(" in ", StringComparison.Ordinal);
             if (locationStart >= 0)
                 identity = identity.Substring(0, locationStart);
 
+            int argumentsStart = identity.IndexOf('(');
+            if (argumentsStart >= 0)
+                identity = identity.Substring(0, argumentsStart);
+
             int methodSeparator = identity.LastIndexOf('.');
             if (methodSeparator < 0) {
                 method.Name = identity;

src/Exceptionless/Models/Collections/DataDictionary.cs

@@ -9,8 +9,20 @@ public class DataDictionary : Dictionary<string, object>, IDictionary<string, ob
         public DataDictionary() : base(StringComparer.OrdinalIgnoreCase) {}
 
         public DataDictionary(IEnumerable<KeyValuePair<string, object>> values) : base(StringComparer.OrdinalIgnoreCase) {
-            foreach (var kvp in values)
-                Add(kvp.Key, kvp.Value);
+            if (values == null)
+                throw new ArgumentNullException(nameof(values));
+
+            if (values is DataDictionary dataDictionary) {
+                foreach (var entry in dataDictionary) {
+                    if (dataDictionary.IsRawJson(entry.Key, entry.Value))
+                        SetRawJson(entry.Key, (string)entry.Value);
+                    else
+                        Add(entry.Key, entry.Value);
+                }
+            } else {
+                foreach (var entry in values)
+                    Add(entry.Key, entry.Value);
+            }
         }
 
         public new object this[string key] {
@@ -63,7 +75,7 @@ public string GetString(string name, string @default) {
         }
 
         internal bool IsRawJson(string key, object value) {
-            return !String.IsNullOrEmpty(key)
+            return key != null
                 && value is string stringValue
                 && _rawJsonValues.TryGetValue(key, out string rawJson)
                 && ReferenceEquals(stringValue, rawJson);
@@ -72,12 +84,12 @@ internal bool IsRawJson(string key, object value) {
         internal void SetRawJson(string key, string value) {
             base[key] = value;
 
-            if (!String.IsNullOrEmpty(key))
+            if (key != null)
                 _rawJsonValues[key] = value;
         }
 
         private void ClearRawJson(string key) {
-            if (!String.IsNullOrEmpty(key))
+            if (key != null)
                 _rawJsonValues.Remove(key);
         }
 

src/Exceptionless/Serializer/DataDictionaryConverter.cs

@@ -65,7 +65,7 @@ public override DataDictionary Read(ref Utf8JsonReader reader, Type typeToConver
                 }
             }
 
-            return dictionary;
+            throw new JsonException("Unexpected end of JSON while reading a data dictionary.");
         }
 
         public override void Write(Utf8JsonWriter writer, DataDictionary value, JsonSerializerOptions options) {