Refactor IHttpError to use ProblemDetails for errors

- Move IHttpError to AspNetCore.Abstractions and update GetErrorModel to return ProblemDetails with optional traceId and path.
- Remove SetTraceIdentifier; trace ID is now handled in error model generation.
- Update WebApiException to generate ProblemDetails/ValidationProblemDetails with traceId, path, and extra context.
- Make AddTraceId public and document its usage in ControllerBaseExtensions.
- Update exception handler middleware to use new GetErrorModel signature and set content type to application/problem+json.
- Standardize on ProblemDetails for error responses throughout the codebase.

Author: Vadim Belov

Sources/EasyExtensions.AspNetCore/Abstractions/IHttpError.cs

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025–2026 Vadim Belov <https://belov.us>
+
+using Microsoft.AspNetCore.Mvc;
+using System.Net;
+
+namespace EasyExtensions.AspNetCore.Abstractions
+{
+    /// <summary>
+    /// Interface for HTTP error.
+    /// </summary>
+    public interface IHttpError
+    {
+        /// <summary>
+        /// Gets error model.
+        /// </summary>
+        /// <param name="traceId">Optional trace ID to include in the error model.</param>
+        /// <param name="path">Optional request path to include in the error model.</param>
+        /// <returns> Error model. </returns>
+        ProblemDetails GetErrorModel(string? traceId = null, string? path = null);
+
+        /// <summary>
+        /// Gets status code.
+        /// </summary>
+        HttpStatusCode StatusCode { get; }
+    }
+}

Sources/EasyExtensions.AspNetCore/Exceptions/WebApiException.cs

@@ -2,12 +2,18 @@
 // Copyright (c) 2025–2026 Vadim Belov <https://belov.us>
 
 using EasyExtensions.Abstractions;
+using EasyExtensions.AspNetCore.Abstractions;
+using EasyExtensions.AspNetCore.Extensions;
 using EasyExtensions.Models;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.WebUtilities;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Net;
+using System.Net.Mime;
+using System.Net.NetworkInformation;
 
 namespace EasyExtensions.AspNetCore.Exceptions
 {
@@ -44,37 +50,48 @@ public class WebApiException(
         /// <summary>
         /// Additional error details. This property can be used to provide extra 
         /// information about the error, such as validation errors, stack traces, or any
+        /// other relevant context that may help in understanding the error.
         /// </summary>
         public object? Extra { get; } = extra;
 
         /// <summary>
         /// Get error model.
         /// </summary>
         /// <returns> Error model. </returns>
-        public ErrorModel GetErrorModel()
+        public ProblemDetails GetErrorModel(string? traceId = null, string? path = null)
         {
-            int statusCode = (int)StatusCode;
-            return new()
+            if (!string.IsNullOrWhiteSpace(ObjectName))
             {
-                Status = statusCode,
-                Type = GetRfcType(StatusCode),
-                Title = ReasonPhrases.GetReasonPhrase(statusCode),
-                TraceId = Activity.Current?.Id ?? string.Empty,
-                Errors = new Dictionary<string, string>
+                var details = new ValidationProblemDetails
                 {
-                    { ObjectName, Message }
-                }
+                    Detail = this.Message,
+                    Instance = path ?? "/",
+                    Status = (int)StatusCode,
+                    Type = GetRfcType(StatusCode),
+                    Errors = new Dictionary<string, string[]>(),
+                    Extensions = new Dictionary<string, object?>(),
+                    Title = ReasonPhrases.GetReasonPhrase((int)StatusCode),
+                };
+                details.Extensions["traceId"] = traceId ?? Activity.Current?.Id ?? "-";
+                ControllerBaseExtensions.AddExtra(details, Extra);
+                details.Errors[ObjectName] = [Message];
+
+                return details;
+            }
+
+            var problemDetails = new ProblemDetails
+            {
+                Detail = this.Message,
+                Instance = path ?? "/",
+                Status = (int)StatusCode,
+                Type = GetRfcType(StatusCode),
+                Extensions = new Dictionary<string, object?>(),
+                Title = ReasonPhrases.GetReasonPhrase((int)StatusCode),
             };
-        }
+            problemDetails.Extensions["traceId"] = traceId ?? Activity.Current?.Id ?? "-";
+            ControllerBaseExtensions.AddExtra(problemDetails, Extra);
 
-        /// <summary>
-        /// Sets the trace identifier for the current context.
-        /// </summary>
-        /// <param name="traceId">The unique identifier to associate with the current trace. Cannot be null.</param>
-        /// <exception cref="NotImplementedException">Thrown when the method is called, as the implementation is not provided.</exception>
-        public void SetTraceIdentifier(string traceId)
-        {
-            throw new NotImplementedException();
+            return problemDetails;
         }
 
         private static string GetRfcType(HttpStatusCode statusCode)

Sources/EasyExtensions.AspNetCore/Extensions/ControllerBaseExtensions.cs

@@ -186,7 +186,16 @@ private static ObjectResult BuildApiError(this ControllerBase controller, HttpSt
             };
         }
 
-        private static void AddTraceId(ControllerBase controller, ProblemDetails details)
+        /// <summary>
+        /// Adds the current HTTP request's trace identifier to the specified ProblemDetails instance as an extension
+        /// for enhanced request tracking.
+        /// </summary>
+        /// <remarks>If the HTTP context does not contain a trace identifier or if it is empty or
+        /// whitespace, no extension is added to the ProblemDetails instance. This method is useful for correlating
+        /// problem responses with server logs during troubleshooting.</remarks>
+        /// <param name="controller">The controller instance from which to obtain the HTTP context and its trace identifier. Cannot be null.</param>
+        /// <param name="details">The ProblemDetails object to which the trace identifier extension will be added. Cannot be null.</param>
+        public static void AddTraceId(ControllerBase controller, ProblemDetails details)
         {
             var traceId = controller.HttpContext.TraceIdentifier;
             if (!string.IsNullOrWhiteSpace(traceId))

Sources/EasyExtensions.AspNetCore/Extensions/ServiceCollectionExtensions.cs

@@ -2,18 +2,22 @@
 // Copyright (c) 2025–2026 Vadim Belov <https://belov.us>
 
 using EasyExtensions.Abstractions;
+using EasyExtensions.AspNetCore.Abstractions;
+using EasyExtensions.AspNetCore.Exceptions;
 using EasyExtensions.AspNetCore.Formatters;
 using EasyExtensions.AspNetCore.HealthChecks;
 using EasyExtensions.Helpers;
 using EasyExtensions.Services;
 using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Console;
 using System;
 using System.Linq;
+using System.Net.Mime;
 using System.Threading.Tasks;
 
 namespace EasyExtensions.AspNetCore.Extensions
@@ -199,13 +203,9 @@ private static async Task HandleException(HttpContext context)
             var exception = exceptionHandlerPathFeature.Error;
             if (exception is IHttpError httpError)
             {
-                var traceId = context.TraceIdentifier;
-                if (!string.IsNullOrEmpty(traceId))
-                {
-                    httpError.SetTraceIdentifier(traceId);
-                }
                 context.Response.StatusCode = (int)httpError.StatusCode;
-                await context.Response.WriteAsJsonAsync(httpError.GetErrorModel());
+                context.Response.ContentType = MediaTypeNames.Application.ProblemJson;
+                await context.Response.WriteAsJsonAsync(httpError.GetErrorModel(context.TraceIdentifier, context.Request.Path));
             }
         }
     }