Harden DI and STJ release compatibility

Author: niemyjski

.github/workflows/build-linux.yml

@@ -27,9 +27,13 @@ jobs:
       run: dotnet build --configuration Release Exceptionless.Net.NonWindows.slnx
     - name: Run Tests
       run: dotnet test --configuration Release --no-build Exceptionless.Net.NonWindows.slnx
+    - 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
       run: |
         for framework in net8.0 net10.0; do
-          dotnet publish --configuration Release --framework "$framework" --output "artifacts/aot-smoke/$framework" test/Exceptionless.AotSmoke/Exceptionless.AotSmoke.csproj
-          "./artifacts/aot-smoke/$framework/Exceptionless.AotSmoke"
+          dotnet publish --configuration Release --framework "$framework" --output "artifacts/aot-smoke/$framework" -p:ExceptionlessPackageVersion="$MINVERVERSIONOVERRIDE" -p:ExceptionlessPackageSource="$GITHUB_WORKSPACE/artifacts/aot-package" test/Exceptionless.PackageAotSmoke/Exceptionless.PackageAotSmoke.csproj
+          "./artifacts/aot-smoke/$framework/Exceptionless.PackageAotSmoke"
+          dotnet publish --configuration Release --framework "$framework" --output "artifacts/hosting-aot-smoke/$framework" test/Exceptionless.HostingAotSmoke/Exceptionless.HostingAotSmoke.csproj
+          "./artifacts/hosting-aot-smoke/$framework/Exceptionless.HostingAotSmoke"
         done

README.md

@@ -22,24 +22,30 @@ using Exceptionless;
 using Exceptionless.Serializer;
 using Microsoft.Extensions.DependencyInjection;
 
-[JsonSourceGenerationOptions(
-    GenerationMode = JsonSourceGenerationMode.Metadata,
-    PropertyNamingPolicy = JsonKnownNamingPolicy.SnakeCaseLower,
-    UseStringEnumConverter = true)]
-[JsonSerializable(typeof(MyPayload))]
-internal partial class AppJsonSerializerContext : JsonSerializerContext { }
-
 var serializer = new DefaultJsonSerializer(AppJsonSerializerContext.Default);
 var services = new ServiceCollection();
 services.AddSingleton<IJsonSerializer>(serializer);
 services.AddSingleton<IStorageSerializer>(serializer);
 
 using var client = new ExceptionlessClient(services, configuration => {
     configuration.ApiKey = "YOUR_API_KEY";
+    configuration.IncludePrivateInformation = false;
 });
+
+[JsonSourceGenerationOptions(
+    GenerationMode = JsonSourceGenerationMode.Metadata,
+    PropertyNamingPolicy = JsonKnownNamingPolicy.SnakeCaseLower,
+    IncludeFields = true,
+    UseStringEnumConverter = true)]
+[JsonSerializable(typeof(MyPayload))]
+internal partial class AppJsonSerializerContext : JsonSerializerContext { }
+
+internal sealed class MyPayload {
+    public int Id { get; set; }
+}
 ```
 
-NativeAOT applications must also register custom services and plugins explicitly. Runtime type names from configuration and unregistered concrete-type activation are intentionally unsupported because trimming cannot preserve those types reliably. Error events still contain normal runtime stack traces, but the optional IL/PDB demystification used by legacy targets is disabled.
+NativeAOT applications must also register custom services and plugins explicitly. Runtime type names from configuration and unregistered concrete-type activation are intentionally unsupported because trimming cannot preserve those types reliably. Error events still contain normal runtime stack traces. The `net8.0` and later assets do not include the optional IL/PDB demystification used by the legacy target. CI publishes and executes NativeAOT smoke applications on `net8.0` and `net10.0`.
 
 ## Getting Started (Development)
 

build/common.props

@@ -11,7 +11,7 @@
     <Copyright>Copyright © $([System.DateTime]::Now.ToString(yyyy)) Exceptionless.  All rights reserved.</Copyright>
     <Authors>Exceptionless</Authors>
     <NoWarn>$(NoWarn);CS1591;NU1701</NoWarn>
-    <WarningsAsErrors>true</WarningsAsErrors>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <LangVersion>9.0</LangVersion>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageOutputPath>$(SolutionDir)artifacts</PackageOutputPath>

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

@@ -40,12 +40,29 @@
 ## Execution results
 
 - Baseline: 300 core tests and 10 MessagePack tests passed; 18 existing tests were skipped.
-- Final non-Windows suite: 313 core tests and 10 MessagePack tests passed; 0 failed; the same 18 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, depth limits, `DataDictionary` structured/raw values, settings coercion, and MessagePack marker round-trips.
+- 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.
 - `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 default Microsoft DI/default serialization, source-generated custom payloads, storage round-trips, queued submission, and nested exception capture on both target frameworks; Linux CI publishes and runs them 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, 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.
+- 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.
+
+## Release impact
+
+- 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.
+- 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.
+- 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.
 
 ## Historical NativeAOT comparison
 

src/Exceptionless/Compatibility/ExceptionlessIgnoreAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Exceptionless.Json {
+    /// <summary>
+    /// Instructs the Exceptionless serializer not to serialize a public field or property.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]
+    public sealed class ExceptionlessIgnoreAttribute : Attribute { }
+}

src/Exceptionless/Compatibility/JsonSerializationDelegates.cs

@@ -0,0 +1,7 @@
+using System.Collections.Generic;
+
+namespace Exceptionless.Json.Serialization {
+    public delegate IEnumerable<KeyValuePair<object, object>> ExtensionDataGetter(object o);
+
+    public delegate object ObjectConstructor<T>(params object[] args);
+}

src/Exceptionless/Extensions/ToErrorModelExtensions.cs

@@ -216,7 +216,11 @@ private static void PopulateStackTrace(this Error error, Error root, Exception e
                 return;
             }
 
-            foreach (StackFrame frame in frames) {
+            string[] rawStackFrames = (exception.StackTrace ?? String.Empty)
+                .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+
+            for (int frameIndex = 0; frameIndex < frames.Length; frameIndex++) {
+                StackFrame frame = frames[frameIndex];
                 var stackFrame = new Models.Data.StackFrame {
                     LineNumber = frame.GetFileLineNumber(),
                     Column = frame.GetFileColumnNumber(),
@@ -234,17 +238,71 @@ private static void PopulateStackTrace(this Error error, Error root, Exception e
 
                 try {
 #if NET8_0_OR_GREATER
+                    MethodBase method = frame.GetMethod();
                     if (RuntimeFeature.IsDynamicCodeSupported)
-#endif
+                        stackFrame.PopulateMethod(root, method);
+                    else
+                        stackFrame.PopulateMethodIdentity(method);
+#else
                     stackFrame.PopulateMethod(root, frame.GetMethod());
+#endif
                 } catch (Exception ex) {
                     log.Error(typeof(ExceptionlessClient), ex, "Error populating StackFrame method info: " + ex.Message);
                 }
 
+                if (String.IsNullOrEmpty(stackFrame.Name) && frameIndex < rawStackFrames.Length)
+                    stackFrame.PopulateMethodIdentity(rawStackFrames[frameIndex]);
+
                 error.StackTrace.Add(stackFrame);
             }
         }
 
+        private static void PopulateMethodIdentity(this Method method, string stackTraceLine) {
+            string identity = stackTraceLine?.Trim();
+            if (String.IsNullOrEmpty(identity))
+                return;
+
+            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 methodSeparator = identity.LastIndexOf('.');
+            if (methodSeparator < 0) {
+                method.Name = identity;
+                return;
+            }
+
+            method.Name = identity.Substring(methodSeparator + 1);
+            string declaringType = identity.Substring(0, methodSeparator);
+            int namespaceSeparator = declaringType.LastIndexOf('.');
+            if (namespaceSeparator < 0) {
+                method.DeclaringType = declaringType;
+                return;
+            }
+
+            method.DeclaringNamespace = declaringType.Substring(0, namespaceSeparator);
+            method.DeclaringType = declaringType.Substring(namespaceSeparator + 1);
+        }
+
+        private static void PopulateMethodIdentity(this Method method, MethodBase methodBase) {
+            if (methodBase == null)
+                return;
+
+            method.Name = methodBase.Name;
+            if (methodBase.DeclaringType == null)
+                return;
+
+            method.DeclaringNamespace = methodBase.DeclaringType.Namespace;
+            method.DeclaringType = methodBase.DeclaringType.Name;
+        }
+
         private static void PopulateMethod(this Method method, Error root, MethodBase methodBase) {
             if (methodBase == null)
                 return;

src/Exceptionless/Models/Collections/DataDictionary.cs

@@ -1,9 +1,10 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 namespace Exceptionless.Models {
-    public class DataDictionary : Dictionary<string, object> {
-        private readonly HashSet<string> _rawJsonKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    public class DataDictionary : Dictionary<string, object>, IDictionary<string, object>, IDictionary {
+        private readonly Dictionary<string, string> _rawJsonValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
         public DataDictionary() : base(StringComparer.OrdinalIgnoreCase) {}
 
@@ -31,7 +32,7 @@ public DataDictionary(IEnumerable<KeyValuePair<string, object>> values) : base(S
         }
 
         public new void Clear() {
-            _rawJsonKeys.Clear();
+            _rawJsonValues.Clear();
             base.Clear();
         }
 
@@ -61,20 +62,109 @@ public string GetString(string name, string @default) {
             return String.Empty;
         }
 
-        internal bool IsRawJson(string key) {
-            return !String.IsNullOrEmpty(key) && _rawJsonKeys.Contains(key);
+        internal bool IsRawJson(string key, object value) {
+            return !String.IsNullOrEmpty(key)
+                && value is string stringValue
+                && _rawJsonValues.TryGetValue(key, out string rawJson)
+                && ReferenceEquals(stringValue, rawJson);
         }
 
         internal void SetRawJson(string key, string value) {
             base[key] = value;
 
             if (!String.IsNullOrEmpty(key))
-                _rawJsonKeys.Add(key);
+                _rawJsonValues[key] = value;
         }
 
         private void ClearRawJson(string key) {
             if (!String.IsNullOrEmpty(key))
-                _rawJsonKeys.Remove(key);
+                _rawJsonValues.Remove(key);
+        }
+
+        object IDictionary<string, object>.this[string key] {
+            get => this[key];
+            set => this[key] = value;
+        }
+
+        ICollection<string> IDictionary<string, object>.Keys => base.Keys;
+        ICollection<object> IDictionary<string, object>.Values => base.Values;
+        int ICollection<KeyValuePair<string, object>>.Count => base.Count;
+        bool ICollection<KeyValuePair<string, object>>.IsReadOnly => false;
+
+        void IDictionary<string, object>.Add(string key, object value) => Add(key, value);
+        bool IDictionary<string, object>.ContainsKey(string key) => base.ContainsKey(key);
+        bool IDictionary<string, object>.Remove(string key) => Remove(key);
+        bool IDictionary<string, object>.TryGetValue(string key, out object value) => base.TryGetValue(key, out value);
+
+        void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> item) => Add(item.Key, item.Value);
+        void ICollection<KeyValuePair<string, object>>.Clear() => Clear();
+        bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> item) {
+            return base.TryGetValue(item.Key, out object value)
+                && EqualityComparer<object>.Default.Equals(value, item.Value);
+        }
+        void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int arrayIndex) {
+            foreach (var item in this)
+                array[arrayIndex++] = item;
+        }
+        bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> item) {
+            if (!((ICollection<KeyValuePair<string, object>>)this).Contains(item))
+                return false;
+
+            return Remove(item.Key);
+        }
+
+        IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator() => base.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => base.GetEnumerator();
+
+        object IDictionary.this[object key] {
+            get => key is string stringKey && base.TryGetValue(stringKey, out object value) ? value : null;
+            set {
+                if (!(key is string stringKey))
+                    throw new ArgumentException("DataDictionary keys must be strings.", nameof(key));
+
+                this[stringKey] = value;
+            }
+        }
+
+        ICollection IDictionary.Keys => base.Keys;
+        ICollection IDictionary.Values => base.Values;
+        bool IDictionary.IsReadOnly => false;
+        bool IDictionary.IsFixedSize => false;
+        int ICollection.Count => base.Count;
+        bool ICollection.IsSynchronized => false;
+        object ICollection.SyncRoot => this;
+
+        void IDictionary.Add(object key, object value) {
+            if (!(key is string stringKey))
+                throw new ArgumentException("DataDictionary keys must be strings.", nameof(key));
+
+            Add(stringKey, value);
+        }
+        void IDictionary.Clear() => Clear();
+        bool IDictionary.Contains(object key) => key is string stringKey && base.ContainsKey(stringKey);
+        IDictionaryEnumerator IDictionary.GetEnumerator() => new DataDictionaryEnumerator(base.GetEnumerator());
+        void IDictionary.Remove(object key) {
+            if (key is string stringKey)
+                Remove(stringKey);
+        }
+        void ICollection.CopyTo(Array array, int index) {
+            foreach (var item in this)
+                array.SetValue(new DictionaryEntry(item.Key, item.Value), index++);
+        }
+
+        private sealed class DataDictionaryEnumerator : IDictionaryEnumerator {
+            private readonly IEnumerator<KeyValuePair<string, object>> _inner;
+
+            public DataDictionaryEnumerator(IEnumerator<KeyValuePair<string, object>> inner) {
+                _inner = inner;
+            }
+
+            public DictionaryEntry Entry => new DictionaryEntry(Key, Value);
+            public object Key => _inner.Current.Key;
+            public object Value => _inner.Current.Value;
+            public object Current => Entry;
+            public bool MoveNext() => _inner.MoveNext();
+            public void Reset() => _inner.Reset();
         }
     }
-}
+}