Merge feature/di-support: DI support for aspect handlers and Log emitter

Author: MistyKuu

README.md

@@ -66,8 +66,9 @@ Built-in aspects (no extra dependencies):
 public async Task<Order> GetOrderAsync(int id) { ... }
 // → Jaeger/Zipkin/OTLP see: OrderService.GetOrderAsync with params as tags
 
-// Timing — lightweight metrics via event:
-TimingHandler.OnTimingRecorded += (cls, method, ms) => metrics.Record(method, ms);
+// Timing — lightweight metrics (DI or static event):
+// DI: builder.Services.AddSingleton<ITimingRecorder, MyRecorder>();
+// Static: TimingHandler.OnTimingRecorded += (cls, method, ms) => ...;
 [Timing]
 public Order PlaceOrder(int id) { ... }
 

packages/ZibStack.NET.Aop/README.md

@@ -35,25 +35,31 @@ Parameters are added as span tags. Exceptions set error status + add exception e
 
 ### [Timing] — lightweight metrics
 
-Records method execution time via a static event. No external dependencies.
+Records method execution time. Supports DI with `ITimingRecorder` or static event fallback.
 
 ```csharp
-// Subscribe to timing events:
+// Option 1 — DI (recommended):
+builder.Services.AddSingleton<ITimingRecorder, MyMetricsRecorder>();
+builder.Services.AddTransient<TimingHandler>();
+
+// Option 2 — static event (no DI needed):
 TimingHandler.OnTimingRecorded += (className, methodName, elapsedMs) =>
-{
     Console.WriteLine($"{className}.{methodName}: {elapsedMs}ms");
-    // or: myMetrics.RecordHistogram("method_duration", elapsedMs, methodName);
-};
 
 [Timing]
 public Order GetOrder(int id) { ... }
 ```
 
 ### [SuppressException] — exception observability
 
-Fires an event when a method throws. Useful for recording exceptions without changing control flow.
+Fires when a method throws. Supports DI with `IExceptionObserver` or static event fallback.
 
 ```csharp
+// Option 1 — DI:
+builder.Services.AddSingleton<IExceptionObserver, MyExceptionLogger>();
+builder.Services.AddTransient<SuppressExceptionHandler>();
+
+// Option 2 — static event:
 SuppressExceptionHandler.OnExceptionSuppressed += (ctx, ex) =>
     logger.LogWarning(ex, "Exception in {Method}", ctx.MethodName);
 
@@ -72,23 +78,34 @@ public Order GetOrder(int id) { ... }
 public async Task<Order> GetOrderAsync(int id) { ... }
 ```
 
-### [Cache] — in-memory caching
+### [Cache] — caching
+
+Supports DI with `IAspectCache` (Redis, IMemoryCache, etc.) or built-in in-memory fallback.
 
 ```csharp
+// Option 1 — DI with custom cache:
+builder.Services.AddSingleton<IAspectCache, RedisAspectCache>();
+builder.Services.AddTransient<CacheHandler>();
+
+// Option 2 — built-in in-memory (no DI needed):
 [Cache(DurationSeconds = 60)]
 public Order GetOrder(int id) { ... }
-// First call: executes, caches result
-// Same params again: returns cached (no execution)
 
-// Invalidate:
+// Invalidate (fallback cache only):
 CacheHandler.Invalidate("GetOrder");
 CacheHandler.ClearAll();
 ```
 
 ### [Authorize] — authorization check
 
+Supports DI with `IAuthorizationChecker` or static delegate fallback.
+
 ```csharp
-// Setup once at startup:
+// Option 1 — DI (recommended):
+builder.Services.AddScoped<IAuthorizationChecker, MyAuthChecker>();
+builder.Services.AddTransient<AuthorizeHandler>();
+
+// Option 2 — static delegate:
 AuthorizeHandler.AuthorizationCheck = (ctx, policy) =>
     currentUser.HasPermission(policy ?? ctx.MethodName);
 
@@ -99,6 +116,53 @@ public void DeleteOrder(int id) { ... }  // checks "DeleteOrder" permission
 public void PurgeAllData() { ... }  // checks "Admin" permission
 ```
 
+## Dependency Injection
+
+All aspect handlers support DI. Register handlers and their dependencies in your DI container, then wire up `AspectServiceProvider`:
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Register handler dependencies
+builder.Services.AddSingleton<ITimingRecorder, PrometheusTimingRecorder>();
+builder.Services.AddScoped<IAuthorizationChecker, JwtAuthChecker>();
+builder.Services.AddSingleton<IAspectCache, RedisAspectCache>();
+
+// Register handlers themselves
+builder.Services.AddTransient<TimingHandler>();
+builder.Services.AddTransient<AuthorizeHandler>();
+builder.Services.AddTransient<CacheHandler>();
+
+var app = builder.Build();
+
+// Enable DI for all aspect handlers (one line):
+AspectServiceProvider.ServiceProvider = app.Services;
+```
+
+When `AspectServiceProvider.ServiceProvider` is set, generated code resolves handlers from DI. If DI is not configured or a handler is not registered, it falls back to `new` (backward compatible).
+
+Custom handlers also benefit — just add constructor parameters:
+
+```csharp
+public class MetricsHandler : IAspectHandler
+{
+    private readonly ILogger<MetricsHandler> _logger;
+    private readonly IMetrics _metrics;
+
+    public MetricsHandler(ILogger<MetricsHandler> logger, IMetrics metrics)
+    {
+        _logger = logger;
+        _metrics = metrics;
+    }
+
+    public void OnBefore(AspectContext ctx) { }
+    public void OnAfter(AspectContext ctx)
+        => _metrics.RecordHistogram("method_duration", ctx.ElapsedMilliseconds, ctx.MethodName);
+    public void OnException(AspectContext ctx, Exception ex)
+        => _logger.LogError(ex, "Failed {Method}", ctx.MethodName);
+}
+```
+
 ## Custom Aspects
 
 ### Sync handler (works on sync + async methods)

packages/ZibStack.NET.Aop/sample/SampleApi/Aspects/TimingAttribute.cs

@@ -1,29 +1,21 @@
 using ZibStack.NET.Aop;
+using ZibStack.NET.Aop.Aspects;
 
 namespace ZibStack.NET.Aop.Sample.Aspects;
 
 /// <summary>
-/// Simple timing aspect — logs elapsed time via IAspectHandler.
+/// Custom timing recorder that uses ILogger via DI.
+/// No more static events needed!
 /// </summary>
-[AspectHandler(typeof(TimingHandler))]
-public class TimingAttribute : AspectAttribute
+public class LoggingTimingRecorder : ITimingRecorder
 {
-}
+    private readonly ILogger<LoggingTimingRecorder> _logger;
 
-public class TimingHandler : IAspectHandler
-{
-    public void OnBefore(AspectContext context)
-    {
-        Console.WriteLine($"[Timing] Starting {context.ClassName}.{context.MethodName}({context.FormatParameters()})");
-    }
-
-    public void OnAfter(AspectContext context)
-    {
-        Console.WriteLine($"[Timing] Completed {context.ClassName}.{context.MethodName} in {context.ElapsedMilliseconds}ms");
-    }
+    public LoggingTimingRecorder(ILogger<LoggingTimingRecorder> logger) => _logger = logger;
 
-    public void OnException(AspectContext context, Exception exception)
+    public void Record(string className, string methodName, long elapsedMilliseconds)
     {
-        Console.WriteLine($"[Timing] Failed {context.ClassName}.{context.MethodName} after {context.ElapsedMilliseconds}ms: {exception.Message}");
+        _logger.LogInformation("[Timing] {Class}.{Method} completed in {Ms}ms",
+            className, methodName, elapsedMilliseconds);
     }
 }

packages/ZibStack.NET.Aop/sample/SampleApi/Program.cs

@@ -1,9 +1,22 @@
+using ZibStack.NET.Aop;
+using ZibStack.NET.Aop.Aspects;
+using ZibStack.NET.Aop.Sample.Aspects;
 using ZibStack.NET.Aop.Sample.Services;
 
 var builder = WebApplication.CreateBuilder(args);
+
+// Register services
 builder.Services.AddSingleton<OrderService>();
+
+// Register aspect handlers with DI — handlers now get constructor-injected dependencies
+builder.Services.AddSingleton<ITimingRecorder, LoggingTimingRecorder>();
+builder.Services.AddTransient<TimingHandler>();
+
 var app = builder.Build();
 
+// Wire up DI for all aspect handlers
+AspectServiceProvider.ServiceProvider = app.Services;
+
 app.MapGet("/order/{id:int}", (int id, OrderService service) =>
 {
     var order = service.GetOrder(id);

packages/ZibStack.NET.Aop/sample/SampleApi/Services/OrderService.cs

@@ -1,4 +1,4 @@
-using ZibStack.NET.Aop.Sample.Aspects;
+using ZibStack.NET.Aop.Aspects;
 
 namespace ZibStack.NET.Aop.Sample.Services;
 

packages/ZibStack.NET.Aop/src/ZibStack.NET.Aop.Abstractions/AspectServiceProvider.cs

@@ -0,0 +1,35 @@
+using System;
+
+namespace ZibStack.NET.Aop;
+
+/// <summary>
+/// Static service locator for resolving aspect handlers from DI.
+/// When configured, handlers are resolved from <see cref="ServiceProvider"/> instead of
+/// being instantiated with <c>new</c>. This allows handlers to receive constructor-injected
+/// dependencies (ILogger, IMemoryCache, IHttpContextAccessor, etc.).
+/// </summary>
+/// <example>
+/// <code>
+/// // Program.cs — register your handlers and wire up the provider:
+/// builder.Services.AddTransient&lt;TimingHandler&gt;();
+/// var app = builder.Build();
+/// AspectServiceProvider.ServiceProvider = app.Services;
+/// </code>
+/// </example>
+public static class AspectServiceProvider
+{
+    /// <summary>
+    /// The application's service provider. Set this at startup to enable DI for aspect handlers.
+    /// When null (default), handlers are created with parameterless constructors (backward compatible).
+    /// </summary>
+    public static IServiceProvider? ServiceProvider { get; set; }
+
+    /// <summary>
+    /// Resolves a handler from <see cref="ServiceProvider"/>, or returns null if DI is not configured
+    /// or the type is not registered.
+    /// </summary>
+    public static T? Resolve<T>() where T : class
+    {
+        return ServiceProvider?.GetService(typeof(T)) as T;
+    }
+}

packages/ZibStack.NET.Aop/src/ZibStack.NET.Aop.Abstractions/Aspects/AuthorizeAttribute.cs

@@ -2,12 +2,17 @@ namespace ZibStack.NET.Aop.Aspects;
 
 /// <summary>
 /// Checks authorization before method execution. Throws <see cref="UnauthorizedAccessException"/>
-/// if the check fails. Configure the authorization logic via <see cref="AuthorizeHandler.AuthorizationCheck"/>.
+/// if the check fails. Configure via DI (<see cref="IAuthorizationChecker"/>) or
+/// static <see cref="AuthorizeHandler.AuthorizationCheck"/>.
 /// </summary>
 /// <example>
 /// <code>
-/// // Setup (once, at startup):
-/// AuthorizeHandler.AuthorizationCheck = (ctx, policy) =>
+/// // Option 1 — DI (recommended):
+/// builder.Services.AddScoped&lt;IAuthorizationChecker, MyAuthChecker&gt;();
+/// builder.Services.AddTransient&lt;AuthorizeHandler&gt;();
+///
+/// // Option 2 — static delegate:
+/// AuthorizeHandler.AuthorizationCheck = (ctx, policy) =&gt;
 /// {
 ///     var user = GetCurrentUser();
 ///     return user.HasPermission(policy ?? ctx.MethodName);
@@ -28,20 +33,37 @@ public sealed class AuthorizeAttribute : AspectAttribute
     public string? Policy { get; set; }
 }
 
+/// <summary>
+/// Authorization checker interface. Register in DI to provide authorization logic.
+/// </summary>
+public interface IAuthorizationChecker
+{
+    /// <summary>Return true to allow, false to deny.</summary>
+    bool IsAuthorized(AspectContext context, string? policy);
+}
+
 public sealed class AuthorizeHandler : IAroundAspectHandler
 {
-    /// <summary>
-    /// Set this at startup. Parameters: AspectContext, policy string (nullable).
-    /// Return true to allow, false to deny.
-    /// </summary>
+    private readonly IAuthorizationChecker? _checker;
+
+    /// <summary>Static delegate fallback. Used when DI is not configured.</summary>
     public static Func<AspectContext, string?, bool>? AuthorizationCheck { get; set; }
 
+    public AuthorizeHandler() { }
+
+    public AuthorizeHandler(IAuthorizationChecker checker) => _checker = checker;
+
     public object? Around(AspectContext context, Func<object?> proceed)
     {
         var policy = context.Properties.TryGetValue("Policy", out var p) && p is string s ? s : null;
 
-        var check = AuthorizationCheck;
-        if (check != null && !check(context, policy))
+        bool authorized;
+        if (_checker != null)
+            authorized = _checker.IsAuthorized(context, policy);
+        else
+            authorized = AuthorizationCheck?.Invoke(context, policy) ?? true;
+
+        if (!authorized)
             throw new UnauthorizedAccessException(
                 $"Access denied to {context.ClassName}.{context.MethodName}" +
                 (policy != null ? $" (policy: {policy})" : ""));