Harden core client for NativeAOT

Author: niemyjski

.github/workflows/build-linux.yml

@@ -27,3 +27,7 @@ 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: NativeAOT Smoke Test
+      run: |
+        dotnet publish --configuration Release --output artifacts/aot-smoke test/Exceptionless.AotSmoke/Exceptionless.AotSmoke.csproj
+        ./artifacts/aot-smoke/Exceptionless.AotSmoke

README.md

@@ -12,6 +12,35 @@ The definition of the word exceptionless is: to be without exception. [Exception
 
 Refer to the Exceptionless documentation here: [Exceptionless Docs](https://exceptionless.com/docs/).
 
+### NativeAOT
+
+The core `Exceptionless` package supports NativeAOT on `net8.0` and later. Exceptionless provides source-generated metadata for its wire models. Applications must provide a `JsonSerializerContext` for custom objects stored in event data and register the resulting serializer before creating the client:
+
+```csharp
+using System.Text.Json.Serialization;
+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";
+});
+```
+
+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.
+
 ## Getting Started (Development)
 
 All of our [.NET clients can be installed](https://www.nuget.org/profiles/exceptionless?showAllPackages=True) via the [NuGet package manager](https://docs.nuget.org/consume/Package-Manager-Dialog).

docs/brainstorms/2026-07-12-modern-di-stj-brainstorm.md

@@ -23,12 +23,12 @@ The STJ migration already exists as four focused commits on `niemyjski/drop-json
 - Allow explicit `IServiceCollection` customization before the resolver is used.
 - Keep Exceptionless' internally owned provider isolated from an application's root provider; hosted apps continue resolving `ExceptionlessClient` from application DI.
 - Treat serialized JSON as a compatibility contract, not merely valid JSON.
-- Keep STJ converters reflection-based for `netstandard2.0` and `net462` compatibility; source generation can be a later optimization.
+- Keep reflection fallback for `netstandard2.0` and `net462`, but use built-in source-generated metadata for the modern `net8.0` and `net10.0` assets. NativeAOT consumers register an additional `JsonSerializerContext` for their own payload types.
 
 ## Open Questions
 
 - Removing `IDependencyResolver` and making every internal service directly application-DI-owned is deferred to a future major version.
-- A separate performance benchmark can decide whether STJ source generation is worth the additional model metadata surface.
+- NativeAOT deliberately uses ordinary runtime stack traces instead of the bundled IL/PDB demystifier because the latter depends on metadata that trimming removes.
 
 ## Next Steps
 

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

@@ -29,6 +29,14 @@
 4. Inspect the final diff for accidental API breaks and remaining Newtonsoft/TinyIoC references.
 5. Document Windows-only validation that still needs CI when it cannot be run on macOS.
 
+## NativeAOT hardening
+
+1. Multi-target the core package for `net8.0` and `net10.0` and enable the built-in AOT, trimming, and single-file analyzers.
+2. Use an Exceptionless-owned `JsonSerializerContext` for the wire model and accept a consumer resolver/context for arbitrary event data.
+3. Require NativeAOT consumers to register services and custom payload metadata explicitly; retain reflection and unregistered concrete activation only for dynamic-code runtimes.
+4. Use regular runtime stack traces on modern targets instead of the IL/PDB demystifier, while keeping exception capture and serialization functional with reduced metadata.
+5. Publish and execute a warning-as-error NativeAOT smoke application covering Microsoft DI, custom STJ metadata, storage, queues, submission, and nested exception capture in Linux CI.
+
 ## Execution results
 
 - Baseline: 300 core tests and 10 MessagePack tests passed; 18 existing tests were skipped.
@@ -37,3 +45,4 @@
 - 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.
 - `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. A real NativeAOT executable now covers Microsoft DI, source-generated custom payloads, storage round-trips, queued submission, and nested exception capture; Linux CI publishes and runs that executable with linker warnings treated as errors.

src/Exceptionless/Configuration/ExceptionlessConfiguration.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Net;
 using System.Reflection;
@@ -412,7 +413,7 @@ public void AddPlugin<T>(T plugin) where T : IEventPlugin {
         /// Register an plugin to be used in this configuration.
         /// </summary>
         /// <typeparam name="T">The plugin type to be added.</typeparam>
-        public void AddPlugin<T>() where T : IEventPlugin {
+        public void AddPlugin<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>() where T : IEventPlugin {
             AddPlugin(typeof(T).FullName, typeof(T));
         }
 
@@ -421,7 +422,7 @@ public void AddPlugin<T>() where T : IEventPlugin {
         /// </summary>
         /// <param name="key">The key used to identify the plugin.</param>
         /// <param name="pluginType">The plugin type to be added.</param>
-        public void AddPlugin(string key, Type pluginType) {
+        public void AddPlugin(string key, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type pluginType) {
             RemovePlugin(key);
 
             var plugin = new PluginRegistration(key, GetPriority(pluginType), new Lazy<IEventPlugin>(() => Resolver.Resolve(pluginType) as IEventPlugin));

src/Exceptionless/Demystifier/TypeNameHelper.cs

@@ -101,7 +101,7 @@ private static void ProcessType(StringBuilder builder, Type type, DisplayNameOpt
             {
                 builder.Append(type.Name);
             }
-            else if (type.Assembly.ManifestModule.Name == "FSharp.Core.dll" 
+            else if (type.Assembly.GetName().Name == "FSharp.Core"
                      && FSharpTypeNames.TryGetValue(type.Name, out builtInName))
             {
                 builder.Append(builtInName);
@@ -174,7 +174,7 @@ private static void ProcessGenericType(StringBuilder builder, Type type, Type[]
                 return;
             }
 
-            if (type.Assembly.ManifestModule.Name == "FSharp.Core.dll" 
+            if (type.Assembly.GetName().Name == "FSharp.Core"
                      && FSharpTypeNames.TryGetValue(type.Name, out var builtInName))
             {
                 builder.Append(builtInName);

src/Exceptionless/Dependency/DefaultDependencyResolver.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Exceptionless.Dependency {
@@ -28,7 +30,7 @@ public DefaultDependencyResolver(IServiceCollection services) {
             AddServices(services);
         }
 
-        public object Resolve(Type serviceType) {
+        public object Resolve([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type serviceType) {
             if (serviceType == null)
                 throw new ArgumentNullException(nameof(serviceType));
 
@@ -44,7 +46,7 @@ public object Resolve(Type serviceType) {
             }
         }
 
-        public void Register(Type serviceType, Type concreteType) {
+        public void Register(Type serviceType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)] Type concreteType) {
             if (serviceType == null)
                 throw new ArgumentNullException(nameof(serviceType));
             if (concreteType == null)
@@ -151,7 +153,7 @@ private ServiceProvider GetProvider() {
             return _provider;
         }
 
-        private object CreateInstance(IServiceProvider provider, Type concreteType) {
+        private object CreateInstance(IServiceProvider provider, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type concreteType) {
             return ActivatorUtilities.CreateInstance(new FallbackServiceProvider(this, provider), concreteType);
         }
 
@@ -175,7 +177,7 @@ private static bool CanActivate(Type type) {
             return !type.IsAbstract && !type.IsInterface && !type.ContainsGenericParameters;
         }
 
-        private static bool CanAssign(Type serviceType, Type concreteType) {
+        private static bool CanAssign(Type serviceType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type concreteType) {
             if (!serviceType.IsGenericTypeDefinition)
                 return serviceType.IsAssignableFrom(concreteType);
 
@@ -202,6 +204,7 @@ public FallbackServiceProvider(DefaultDependencyResolver resolver, IServiceProvi
                 _provider = provider;
             }
 
+            [UnconditionalSuppressMessage("Trimming", "IL2067", Justification = "The unannotated IServiceProvider contract cannot express constructor requirements. NativeAOT rejects this dynamic fallback before activation; AOT callers must register the service.")]
             public object GetService(Type serviceType) {
                 if (serviceType == typeof(IServiceProvider))
                     return this;
@@ -210,7 +213,15 @@ public object GetService(Type serviceType) {
                 if (service != null)
                     return service;
 
-                return CanActivate(serviceType) ? _resolver.CreateInstance(_provider, serviceType) : null;
+                if (!CanActivate(serviceType))
+                    return null;
+
+#if NET8_0_OR_GREATER
+                if (!RuntimeFeature.IsDynamicCodeSupported)
+                    throw new NotSupportedException($"Type '{serviceType.FullName}' must be registered before it can be resolved in a NativeAOT application.");
+#endif
+
+                return _resolver.CreateInstance(_provider, serviceType);
             }
         }
     }

src/Exceptionless/Dependency/DependencyResolverExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Exceptionless.Logging;
 using Exceptionless.Queue;
 using Exceptionless.Serializer;
@@ -8,22 +9,22 @@
 
 namespace Exceptionless.Dependency {
     public static class DependencyResolverExtensions {
-        public static bool HasRegistration<TService>(this IDependencyResolver resolver) where TService : class {
+        public static bool HasRegistration<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TService>(this IDependencyResolver resolver) where TService : class {
             if (resolver == null)
                 return false;
 
             return resolver.Resolve(typeof(TService)) != null;
         }
 
-        public static bool HasDefaultRegistration<TService, TDefaultImplementation>(this IDependencyResolver resolver) where TService : class where TDefaultImplementation : TService {
+        public static bool HasDefaultRegistration<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TService, TDefaultImplementation>(this IDependencyResolver resolver) where TService : class where TDefaultImplementation : TService {
             if (resolver == null)
                 return false;
 
             var instance = resolver.Resolve(typeof(TService));
             return instance is TDefaultImplementation;
         }
 
-        public static object Resolve(this IDependencyResolver resolver, Type type) {
+        public static object Resolve(this IDependencyResolver resolver, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type) {
             if (resolver == null)
                 throw new ArgumentNullException(nameof(resolver));
 
@@ -33,7 +34,7 @@ public static object Resolve(this IDependencyResolver resolver, Type type) {
             return resolver.Resolve(type);
         }
 
-        public static TService Resolve<TService>(this IDependencyResolver resolver, TService defaultImplementation = null) where TService : class {
+        public static TService Resolve<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] TService>(this IDependencyResolver resolver, TService defaultImplementation = null) where TService : class {
             if (resolver == null)
                 throw new ArgumentNullException(nameof(resolver));
 
@@ -53,14 +54,14 @@ public static void Register<TService>(this IDependencyResolver resolver, TServic
             resolver.Register(typeof(TService), () => implementation);
         }
 
-        public static void Register<TService>(this IDependencyResolver resolver) {
+        public static void Register<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)] TService>(this IDependencyResolver resolver) {
             if (resolver == null)
                 throw new ArgumentNullException(nameof(resolver));
 
             resolver.Register(typeof(TService), typeof(TService));
         }
 
-        public static void Register<TService, TImplementation>(this IDependencyResolver resolver) where TImplementation : TService {
+        public static void Register<TService, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)] TImplementation>(this IDependencyResolver resolver) where TImplementation : TService {
             if (resolver == null)
                 throw new ArgumentNullException(nameof(resolver));
 

src/Exceptionless/Dependency/IDependencyResolver.cs

@@ -1,9 +1,10 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Exceptionless.Dependency {
     public interface IDependencyResolver : IDisposable {
-        object Resolve(Type serviceType);
-        void Register(Type serviceType, Type concreteType);
+        object Resolve([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type serviceType);
+        void Register(Type serviceType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.Interfaces)] Type concreteType);
         void Register(Type serviceType, Func<object> activator);
     }
 }

src/Exceptionless/Exceptionless.csproj

@@ -2,10 +2,14 @@
   <Import Project="..\..\build\common.props" />
 
   <PropertyGroup Condition=" '$(OS)' != 'Windows_NT' ">
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFrameworks>netstandard2.0;net8.0;net10.0</TargetFrameworks>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(OS)' == 'Windows_NT' ">
-    <TargetFrameworks>netstandard2.0;net462</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net462;net8.0;net10.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))" Label="AOT">
+    <IsAotCompatible>true</IsAotCompatible>
   </PropertyGroup>
 
   <PropertyGroup Label="Package">
@@ -23,11 +27,19 @@
     <None Include="readme.txt" pack="true" PackagePath="." />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'" Label="Package References">
+  <ItemGroup Condition="'$(TargetFramework)' != 'net462'" Label="Package References">
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'" Label="Package References">
     <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
   </ItemGroup>
 
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))" Label="AOT">
+    <Compile Remove="Demystifier\**\*.cs" />
+    <Compile Include="Demystifier\TypeNameHelper.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
     <PackageReference Include="System.Reflection.Metadata" Version="8.0.1" />
@@ -52,4 +64,8 @@
   <PropertyGroup Condition="'$(TargetFramework)' == 'net462'" Label="Build">
     <DefineConstants>$(DefineConstants);NET45</DefineConstants>
   </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' != 'net462'" Label="Build">
+    <DefineConstants>$(DefineConstants);NETSTANDARD</DefineConstants>
+  </PropertyGroup>
 </Project>