PR feedback

Author: niemyjski

README.md

@@ -1,8 +1,8 @@
 # Exceptionless .NET Clients
 
-[![Build Windows](https://github.com/exceptionless/Exceptionless.Net/workflows/Build%20Windows/badge.svg?branch=master)](https://github.com/Exceptionless/Exceptionless.Net/actions)
-[![Build OSX](https://github.com/exceptionless/Exceptionless.Net/workflows/Build%20OSX/badge.svg)](https://github.com/Exceptionless/Exceptionless.Net/actions)
-[![Build Linux](https://github.com/exceptionless/Exceptionless.Net/workflows/Build%20Linux/badge.svg)](https://github.com/Exceptionless/Exceptionless.Net/actions)
+[![Build Windows](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-windows.yml/badge.svg?branch=main)](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-windows.yml)
+[![Build OSX](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-osx.yml/badge.svg?branch=main)](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-osx.yml)
+[![Build Linux](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-linux.yml/badge.svg?branch=main)](https://github.com/Exceptionless/Exceptionless.Net/actions/workflows/build-linux.yml)
 [![NuGet Version](http://img.shields.io/nuget/v/Exceptionless.svg?style=flat)](https://www.nuget.org/packages/Exceptionless/)
 [![Discord](https://img.shields.io/discord/715744504891703319)](https://discord.gg/6HxgFCx)
 
@@ -29,8 +29,8 @@ editor design surfaces are available.
 
 1. You will need to install:
    1. [Visual Studio 2022](https://visualstudio.microsoft.com/vs/community/)
-   2. [.NET Core 6.x & 8.x SDK with VS Tooling](https://dotnet.microsoft.com/download)
-   3. [.NET Framework 4.6.2 Developer Pack](https://dotnet.microsoft.com/download/dotnet-framework/net462)
+   2. [.NET 10 SDK with Visual Studio tooling](https://dotnet.microsoft.com/download)
+   3. [.NET Framework 4.7.2 Developer Pack](https://dotnet.microsoft.com/download/dotnet-framework/net472)
 2. Open the `Exceptionless.Net.slnx` Visual Studio solution file.
 3. Select `Exceptionless.SampleConsole` as the startup project.
 4. Run the project by pressing `F5` to start the console.
@@ -43,7 +43,7 @@ build windows specific packages.
 
 1. You will need to install:
    1. [Visual Studio Code](https://code.visualstudio.com)
-   2. [.NET Core 6.x & 8.x SDK with VS Tooling](https://dotnet.microsoft.com/download)
+   2. [.NET 10 SDK](https://dotnet.microsoft.com/download)
 2. Open the cloned Exceptionless.Net folder.
 3. Run the `Exceptionless.SampleConsole` project by pressing `F5` to start the console.
 

samples/Exceptionless.SampleAspNetCore/Controllers/ValuesController.cs

@@ -10,7 +10,7 @@ public class ValuesController : Controller {
         private readonly ILogger _logger;
 
         public ValuesController(ExceptionlessClient exceptionlessClient, ILogger<ValuesController> logger) {
-            // ExceptionlessClient instance from DI that was registered with the AddExceptionless call in Startup.ConfigureServices
+            // ExceptionlessClient instance from DI that was registered with the builder.AddExceptionless call in Program.cs.
             _exceptionlessClient = exceptionlessClient;
             _logger = logger;
         }
@@ -21,7 +21,7 @@ public Dictionary<string, string> Get() {
             // Submit a feature usage event directly using the client instance that is injected from the DI container.
             _exceptionlessClient.SubmitFeatureUsage("ValuesController_Get");
 
-            // This log message will get sent to Exceptionless since Exceptionless has be added to the logging system in Program.cs.
+            // This log message will get sent to Exceptionless since Exceptionless has been added to the logging system in Program.cs.
             _logger.LogWarning("Test warning message");
 
             try {
@@ -42,7 +42,8 @@ public Dictionary<string, string> Get() {
                 handledException.ToExceptionless().Submit();
             }
 
-            // Unhandled exceptions will get reported since called UseExceptionless in the Startup.cs which registers a listener for unhandled exceptions.
+            // Unhandled exceptions will get reported because Program.cs enables the built-in exception handler pipeline
+            // and wires Exceptionless into both ASP.NET Core diagnostics and middleware hooks.
             throw new Exception($"Unhandled Exception: {Guid.NewGuid()}");
         }
     }

samples/Exceptionless.SampleAspNetCore/Program.cs

@@ -1,21 +1,37 @@
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Hosting;
-
-namespace Exceptionless.SampleAspNetCore {
-    public class Program {
-        public static void Main(string[] args) {
-            CreateHostBuilder(args).Build().Run();
-        }
-
-        public static IHostBuilder CreateHostBuilder(string[] args) =>
-            Host.CreateDefaultBuilder(args)
-                .ConfigureLogging(b => {
-                    // By default sends warning and error log messages to Exceptionless.
-                    // Log levels can be controlled remotely per log source from the Exceptionless app in near real-time.
-                    b.AddExceptionless();
-                })
-                .ConfigureWebHostDefaults(webBuilder => {
-                    webBuilder.UseStartup<Startup>();
-                });
-    }
-}
+using Exceptionless;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// By default sends warning and error log messages to Exceptionless.
+// Log levels can be controlled remotely per log source from the Exceptionless app in near real-time.
+builder.Logging.AddExceptionless();
+
+// Reads settings from IConfiguration then adds additional configuration from this lambda.
+// This also configures ExceptionlessClient.Default and host shutdown queue flushing.
+builder.AddExceptionless(c => c.DefaultData["Startup"] = "heyyy");
+// OR
+// builder.AddExceptionless();
+// OR
+// builder.AddExceptionless("API_KEY_HERE");
+
+// Adds ASP.NET Core request/unhandled exception hooks and standard exception handling services.
+builder.Services.AddExceptionless();
+builder.Services.AddProblemDetails();
+
+// This is normal ASP.NET Core code.
+builder.Services.AddControllers();
+
+var app = builder.Build();
+
+// Uses the built-in exception handler pipeline, with Exceptionless capturing via IExceptionHandler.
+app.UseExceptionHandler();
+
+// Adds Exceptionless middleware for diagnostics, 404 tracking, and queue processing.
+app.UseExceptionless();
+
+app.MapControllers();
+
+app.Run();

samples/Exceptionless.SampleAspNetCore/Startup.cs

@@ -64,7 +64,9 @@ public static IHostBuilder CreateHostBuilder(string[] args) =>
                                     handledException.ToExceptionless().Submit();
                                 }
 
-                                // Unhandled exceptions will get reported because host-level Exceptionless integration is enabled in Program.cs.
+                                // This simulates an unhandled exception. Host-level Exceptionless integration reports
+                                // host/AppDomain-level unhandled exceptions; ASP.NET Core request-pipeline exceptions
+                                // require the ASP.NET Core integration and UseExceptionHandler.
                                 throw new Exception($"Unhandled Exception: {Guid.NewGuid()}");
                             });
                         });

samples/Exceptionless.SampleHosting/Program.cs

@@ -9,6 +9,7 @@ public sealed class ExceptionlessDiagnosticListener : IObserver<KeyValuePair<str
         private const string HandledExceptionEvent = "Microsoft.AspNetCore.Diagnostics.HandledException";
         private const string DiagnosticsUnhandledExceptionEvent = "Microsoft.AspNetCore.Diagnostics.UnhandledException";
         private const string HostingUnhandledExceptionEvent = "Microsoft.AspNetCore.Hosting.UnhandledException";
+        private const string HostingDiagnosticsUnhandledExceptionEvent = "Microsoft.AspNetCore.Hosting.Diagnostics.UnhandledException";
         private const string MiddlewareExceptionEvent = "Microsoft.AspNetCore.MiddlewareAnalysis.MiddlewareException";
         private readonly ExceptionlessClient _client;
 
@@ -20,24 +21,36 @@ public void OnCompleted() { }
 
         public void OnError(Exception error) { }
 
+        internal static bool IsRelevantEvent(string eventName) {
+            return String.Equals(eventName, HandledExceptionEvent, StringComparison.Ordinal) ||
+                   String.Equals(eventName, DiagnosticsUnhandledExceptionEvent, StringComparison.Ordinal) ||
+                   String.Equals(eventName, HostingUnhandledExceptionEvent, StringComparison.Ordinal) ||
+                   String.Equals(eventName, HostingDiagnosticsUnhandledExceptionEvent, StringComparison.Ordinal) ||
+                   String.Equals(eventName, MiddlewareExceptionEvent, StringComparison.Ordinal);
+        }
+
         public void OnNext(KeyValuePair<string, object> diagnosticEvent) {
             switch (diagnosticEvent.Key) {
                 case HandledExceptionEvent:
                     SubmitException(diagnosticEvent.Value, diagnosticEvent.Key, false);
                     break;
                 case DiagnosticsUnhandledExceptionEvent:
                 case HostingUnhandledExceptionEvent:
+                case HostingDiagnosticsUnhandledExceptionEvent:
                     SubmitException(diagnosticEvent.Value, diagnosticEvent.Key, true);
                     break;
                 case MiddlewareExceptionEvent:
+                    if (diagnosticEvent.Value is null)
+                        break;
+
                     string middlewareName = GetPropertyValue(diagnosticEvent.Value, "name") as string;
                     SubmitException(diagnosticEvent.Value, middlewareName ?? diagnosticEvent.Key, true);
                     break;
             }
         }
 
         private void SubmitException(object payload, string submissionMethod, bool isUnhandledError) {
-            if (payload == null)
+            if (payload is null)
                 return;
 
             var httpContext = GetPropertyValue(payload, "httpContext") as HttpContext;
@@ -54,6 +67,9 @@ private void SubmitException(object payload, string submissionMethod, bool isUnh
         }
 
         private static object GetPropertyValue(object payload, string propertyName) {
+            if (payload is null)
+                return null;
+
             return payload.GetType()
                 .GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase)?
                 .GetValue(payload);

src/Platforms/Exceptionless.AspNetCore/ExceptionlessDiagnosticListener.cs

@@ -9,18 +9,17 @@
 using Exceptionless.Plugins.Default;
 using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 
 namespace Exceptionless {
     public static class ExceptionlessExtensions {
         /// <summary>
-        /// Registers the Exceptionless <see cref="IExceptionHandler"/> for capturing unhandled exceptions.
-        /// Call this in your service configuration alongside <c>app.UseExceptionHandler()</c>.
+        /// Registers the Exceptionless <see cref="IExceptionHandler"/> and required ASP.NET Core services
+        /// for capturing unhandled exceptions. Call this in your service configuration alongside <c>app.UseExceptionHandler()</c>.
         /// </summary>
-        public static IServiceCollection AddExceptionlessAspNetCore(this IServiceCollection services) {
+        public static IServiceCollection AddExceptionless(this IServiceCollection services) {
             services.AddHttpContextAccessor();
-            services.TryAddEnumerable(ServiceDescriptor.Singleton<IExceptionHandler, ExceptionlessExceptionHandler>());
+            services.AddExceptionHandler<ExceptionlessExceptionHandler>();
             return services;
         }
 
@@ -42,7 +41,9 @@ public static IApplicationBuilder UseExceptionless(this IApplicationBuilder app,
             //client.Configuration.Resolver.Register<ILastReferenceIdManager, WebLastReferenceIdManager>();
 
             var diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
-            diagnosticListener?.Subscribe(new ExceptionlessDiagnosticListener(client));
+            diagnosticListener?.Subscribe(
+                new ExceptionlessDiagnosticListener(client),
+                eventName => ExceptionlessDiagnosticListener.IsRelevantEvent(eventName));
 
             var lifetime = app.ApplicationServices.GetRequiredService<IHostApplicationLifetime>();
             lifetime.ApplicationStopping.Register(() => client.ProcessQueueAsync().ConfigureAwait(false).GetAwaiter().GetResult());

src/Platforms/Exceptionless.AspNetCore/ExceptionlessExtensions.cs

@@ -1,4 +1,4 @@
--------------------------------------
+-------------------------------------
         Exceptionless Readme
 -------------------------------------
 Exceptionless provides real-time error reporting for your apps. It organizes the
@@ -31,15 +31,18 @@ You must import the "Exceptionless" namespace and add the following code to regi
 using Exceptionless;
 
 var builder = WebApplication.CreateBuilder(args); 
-builder.Services.AddExceptionless("API_KEY_HERE");
+builder.AddExceptionless(c => c.ApiKey = "API_KEY_HERE");
+builder.Services.AddExceptionless();
+builder.Services.AddProblemDetails();
 
 In order to start gathering unhandled exceptions, you will need to register the Exceptionless middleware in your application 
 like this after building your application:
 
 var app = builder.Build(); 
+app.UseExceptionHandler();
 app.UseExceptionless();
 
-Alternatively, you can use different overloads of the AddExceptionless method for other configuration options.
+Alternatively, you can use different overloads of the host builder AddExceptionless method for other configuration options.
 Please visit the documentation at https://exceptionless.com/docs/clients/dotnet/sending-events/ for additional examples 
 and guidance on sending events to Exceptionless.
 

src/Platforms/Exceptionless.AspNetCore/readme.txt

@@ -24,20 +24,22 @@ Please visit the documentation https://exceptionless.com/docs/clients/dotnet/pri
 for detailed information on how to configure the client to meet your requirements.
 
 -------------------------------------
-Microsoft.Extensions.Logging Integration
+Microsoft.Extensions.Hosting Integration
 -------------------------------------
-You must import the "Exceptionless" namespace and call the following line
-of code to start reporting log messages.
+You must import the "Exceptionless" namespace and register Exceptionless on the
+host builder.
 
-loggerFactory.AddExceptionless("API_KEY_HERE");
+var builder = Host.CreateApplicationBuilder(args);
+builder.AddExceptionless(c => c.ApiKey = "API_KEY_HERE");
+builder.UseExceptionless();
 
-Alternatively, you can also use the different overloads of the AddExceptionless method
-for different configuration options.
+`AddExceptionless(...)` configures the client, and `UseExceptionless()` ensures
+the pending queue is flushed during host shutdown.
 
 Please visit the documentation https://exceptionless.com/docs/clients/dotnet/sending-events/
 for examples on sending events to Exceptionless.
 
 -------------------------------------
       Documentation and Support
 -------------------------------------
-Please visit http://exceptionless.io for documentation and support.
+Please visit http://exceptionless.io for documentation and support.

src/Platforms/Exceptionless.Extensions.Hosting/readme.txt

@@ -26,18 +26,21 @@ for detailed information on how to configure the client to meet your requirement
 -------------------------------------
 Microsoft.Extensions.Logging Integration
 -------------------------------------
-You must import the "Exceptionless" namespace and call the following line
-of code to start reporting log messages.
+You must import the "Exceptionless" namespace and add Exceptionless to the
+logging builder.
 
-loggerFactory.AddExceptionless("API_KEY_HERE");
+var builder = Host.CreateApplicationBuilder(args);
+builder.Logging.AddExceptionless();
 
-Alternatively, you can also use the different overloads of the AddExceptionless method
-for different configuration options.
+If you want to configure the client in the same app, pair this with one of the
+Exceptionless hosting registration overloads such as:
+
+builder.AddExceptionless(c => c.ApiKey = "API_KEY_HERE");
 
 Please visit the documentation https://exceptionless.com/docs/clients/dotnet/sending-events/
 for examples on sending events to Exceptionless.
 
 -------------------------------------
       Documentation and Support
 -------------------------------------
-Please visit http://exceptionless.io for documentation and support.
+Please visit http://exceptionless.io for documentation and support.