Updated

EonaCat.LogStack/EonaCat.LogStack.csproj

@@ -110,4 +110,8 @@ It features a rich fluent API for routing log events to dozens of destinations f
       <PackagePath>\</PackagePath>
     </None>
   </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="EonaCat.LogStack.Test\Features\" />
+  </ItemGroup>
 </Project>

EonaCat.LogStack/EonaCat.LogStack/Extensions/LoggerFeatureExtensions.cs

@@ -0,0 +1,329 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using EonaCat.LogStack.Core;
+using EonaCat.LogStack.Logging;
+using EonaCat.LogStack.Features;
+
+namespace EonaCat.LogStack.Extensions
+{
+    /// <summary>
+    /// Fluent extension methods for integrating advanced logging features.
+    /// </summary>
+    public static class LoggerFeatureExtensions
+    {
+        /// <summary>
+        /// Registers LogSearchEngine in the dependency injection container.
+        /// </summary>
+        public static IServiceCollection AddLogSearchEngine(this IServiceCollection services, int maxIndexSize = 10000)
+        {
+            services.AddSingleton(new LogSearchEngine(maxIndexSize));
+            return services;
+        }
+
+        /// <summary>
+        /// Registers AlertingEngine in the dependency injection container.
+        /// </summary>
+        public static IServiceCollection AddAlertingEngine(this IServiceCollection services)
+        {
+            services.AddSingleton(new AlertingEngine());
+            return services;
+        }
+
+        /// <summary>
+        /// Registers LogReplayEngine in the dependency injection container.
+        /// </summary>
+        public static IServiceCollection AddLogReplayEngine(this IServiceCollection services)
+        {
+            services.AddSingleton(new LogReplayEngine());
+            return services;
+        }
+
+        /// <summary>
+        /// Registers ConfigurationValidator and ConfigurationHotReloadManager in the DI container.
+        /// </summary>
+        public static IServiceCollection AddConfigurationValidation(this IServiceCollection services)
+        {
+            services.AddSingleton(new ConfigurationValidator());
+            services.AddSingleton(new ConfigurationHotReloadManager());
+            return services;
+        }
+
+        /// <summary>
+        /// Registers CorrelationDashboardHelper in the dependency injection container.
+        /// </summary>
+        public static IServiceCollection AddCorrelationDashboardHelper(this IServiceCollection services)
+        {
+            services.AddSingleton(new CorrelationDashboardHelper());
+            return services;
+        }
+
+        /// <summary>
+        /// Registers all logging features at once.
+        /// </summary>
+        public static IServiceCollection AddAllEonaCatLoggingFeatures(this IServiceCollection services, 
+            LogFeaturesConfiguration config = null)
+        {
+            config ??= new LogFeaturesConfiguration();
+
+            services.AddLogSearchEngine(config.LogSearchMaxSize);
+            services.AddAlertingEngine();
+            services.AddLogReplayEngine();
+            services.AddConfigurationValidation();
+            services.AddCorrelationDashboardHelper();
+
+            return services;
+        }
+
+        /// <summary>
+        /// Gets LogSearchEngine from service provider and performs a search.
+        /// </summary>
+        public static IServiceProvider WithLogSearch(this IServiceProvider provider,
+            Action<LogSearchEngine> configureSearch)
+        {
+            var engine = provider.GetService<LogSearchEngine>();
+            if (engine != null)
+            {
+                configureSearch(engine);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Gets AlertingEngine from service provider and configures alerting.
+        /// </summary>
+        public static IServiceProvider WithAlerting(this IServiceProvider provider,
+            Action<AlertingEngine> configureAlerting)
+        {
+            var engine = provider.GetService<AlertingEngine>();
+            if (engine != null)
+            {
+                configureAlerting(engine);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Gets LogReplayEngine from service provider and performs log operations.
+        /// </summary>
+        public static IServiceProvider WithLogReplay(this IServiceProvider provider,
+            Action<LogReplayEngine> configureReplay)
+        {
+            var engine = provider.GetService<LogReplayEngine>();
+            if (engine != null)
+            {
+                configureReplay(engine);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Validates logger configuration on startup.
+        /// </summary>
+        public static IServiceProvider ValidateLoggerConfiguration(this IServiceProvider provider, ILogger logger)
+        {
+            var validator = provider.GetService<ConfigurationValidator>();
+            if (validator != null)
+            {
+                var report = validator.Validate(logger);
+                if (!report.IsValid)
+                {
+                    var errors = report.GetErrors();
+                    if (errors.Any())
+                    {
+                        throw new InvalidOperationException(
+                            $"Logger configuration validation failed:\n{report.ToString()}");
+                    }
+                }
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Enables hot-reload support with a handler callback.
+        /// </summary>
+        public static IServiceProvider EnableConfigurationHotReload(this IServiceProvider provider,
+            Action<ConfigurationChangeNotification> onConfigChanged)
+        {
+            var reloadManager = provider.GetService<ConfigurationHotReloadManager>();
+            if (reloadManager != null)
+            {
+                reloadManager.EnableHotReload(onConfigChanged);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Gets CorrelationDashboardHelper from service provider and records activity.
+        /// </summary>
+        public static IServiceProvider RecordCorrelatedActivity(this IServiceProvider provider,
+            string correlationId, string activityName, string serviceName, ActivityStatus status,
+            double durationMs, Exception exception = null)
+        {
+            var helper = provider.GetService<CorrelationDashboardHelper>();
+            if (helper != null)
+            {
+                helper.RecordActivity(correlationId, activityName, serviceName, status, durationMs, exception);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Gets tracing dashboard statistics from service provider.
+        /// </summary>
+        public static DashboardStatistics GetTracingStatistics(this IServiceProvider provider)
+        {
+            var helper = provider.GetService<CorrelationDashboardHelper>();
+            return helper?.GetStatistics() ?? new DashboardStatistics();
+        }
+
+        /// <summary>
+        /// Gets search statistics from service provider.
+        /// </summary>
+        public static LogSearchStatistics GetSearchStatistics(this IServiceProvider provider)
+        {
+            var engine = provider.GetService<LogSearchEngine>();
+            return engine?.GetStatistics() ?? new LogSearchStatistics();
+        }
+
+        /// <summary>
+        /// Gets alerting statistics from service provider.
+        /// </summary>
+        public static AlertingStatistics GetAlertingStatistics(this IServiceProvider provider)
+        {
+            var engine = provider.GetService<AlertingEngine>();
+            return engine?.GetStatistics() ?? new AlertingStatistics();
+        }
+
+        /// <summary>
+        /// Performs a complex log search using fluent API.
+        /// </summary>
+        public static IEnumerable<LogSearchEntry> SearchLogs(this IServiceProvider provider,
+            LogLevel? level = null, string keyword = null, string loggerName = null,
+            string correlationId = null, DateTime? fromUtc = null, DateTime? toUtc = null,
+            int limit = 0)
+        {
+            var engine = provider.GetService<LogSearchEngine>();
+            if (engine == null)
+                return Enumerable.Empty<LogSearchEntry>();
+
+            var query = new LogSearchQuery
+            {
+                Keyword = keyword,
+                Level = level,
+                LoggerName = loggerName,
+                CorrelationId = correlationId,
+                FromUtc = fromUtc,
+                ToUtc = toUtc,
+                Limit = limit
+            };
+
+            return engine.Search(query);
+        }
+
+        /// <summary>
+        /// Adds an alert rule using fluent configuration.
+        /// </summary>
+        public static IServiceProvider AddAlertRule(this IServiceProvider provider,
+            string ruleName, Action<AlertRuleBuilder> configureRule)
+        {
+            var engine = provider.GetService<AlertingEngine>();
+            if (engine != null)
+            {
+                engine.AddRule(ruleName, configureRule);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Exports captured logs to JSON.
+        /// </summary>
+        public static IServiceProvider ExportLogsToJson(this IServiceProvider provider, string filePath)
+        {
+            var engine = provider.GetService<LogReplayEngine>();
+            if (engine != null)
+            {
+                engine.ExportToJson(filePath);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Imports captured logs from JSON.
+        /// </summary>
+        public static IServiceProvider ImportLogsFromJson(this IServiceProvider provider, string filePath)
+        {
+            var engine = provider.GetService<LogReplayEngine>();
+            if (engine != null)
+            {
+                engine.ImportFromJson(filePath);
+            }
+            return provider;
+        }
+
+        /// <summary>
+        /// Gets a correlation trace for visualization.
+        /// </summary>
+        public static GanttChartData GetTraceAsGanttChart(this IServiceProvider provider, string correlationId)
+        {
+            var helper = provider.GetService<CorrelationDashboardHelper>();
+            return helper?.GetAsGanttChart(correlationId) ?? null;
+        }
+
+        /// <summary>
+        /// Gets the service dependency map for the system.
+        /// </summary>
+        public static ServiceDependencyMap GetServiceDependencies(this IServiceProvider provider)
+        {
+            var helper = provider.GetService<CorrelationDashboardHelper>();
+            return helper?.GetDependencyMap() ?? new ServiceDependencyMap();
+        }
+
+        /// <summary>
+        /// Gets critical paths (slow traces) from the system.
+        /// </summary>
+        public static IEnumerable<CriticalPath> GetCriticalPaths(this IServiceProvider provider, int topCount = 10)
+        {
+            var helper = provider.GetService<CorrelationDashboardHelper>();
+            return helper?.FindCriticalPaths(topCount) ?? Enumerable.Empty<CriticalPath>();
+        }
+    }
+
+    /// <summary>
+    /// Configuration for logging features.
+    /// </summary>
+    public class LogFeaturesConfiguration
+    {
+        /// <summary>
+        /// Maximum number of logs to keep in the search index.
+        /// </summary>
+        public int LogSearchMaxSize { get; set; } = 10000;
+
+        /// <summary>
+        /// Whether to enable search indexing by default.
+        /// </summary>
+        public bool EnableSearchByDefault { get; set; } = true;
+
+        /// <summary>
+        /// Whether to enable alerting by default.
+        /// </summary>
+        public bool EnableAlertingByDefault { get; set; } = true;
+
+        /// <summary>
+        /// Whether to enable log capture for replay by default.
+        /// </summary>
+        public bool EnableReplayByDefault { get; set; } = false;
+
+        /// <summary>
+        /// Whether to enable tracing dashboard by default.
+        /// </summary>
+        public bool EnableTracingByDefault { get; set; } = true;
+
+        /// <summary>
+        /// Maximum age of trace data to keep (in hours).
+        /// </summary>
+        public int TraceDataMaxAgeHours { get; set; } = 24;
+    }
+}

EonaCat.LogStack/EonaCat.LogStack/Features/AlertingEngine.cs

@@ -0,0 +1,347 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using EonaCat.LogStack.Core;
+
+namespace EonaCat.LogStack.Features
+{
+    /// <summary>
+    /// Rule-based alerting engine for proactive log monitoring and notifications.
+    /// Monitors log streams and triggers alerts based on configurable conditions.
+    /// </summary>
+    public class AlertingEngine
+    {
+        private readonly List<AlertRule> _rules = new();
+        private readonly object _lockObject = new();
+        private bool _isEnabled = true;
+
+        /// <summary>
+        /// Event fired when an alert is triggered.
+        /// </summary>
+        public event EventHandler<AlertTriggeredEventArgs> AlertTriggered;
+
+        /// <summary>
+        /// Enables or disables the alerting engine.
+        /// </summary>
+        public void SetEnabled(bool enabled)
+        {
+            _isEnabled = enabled;
+        }
+
+        /// <summary>
+        /// Adds a new alert rule.
+        /// </summary>
+        public AlertRule AddRule(string ruleName, Action<AlertRuleBuilder> configureAction)
+        {
+            if (string.IsNullOrWhiteSpace(ruleName))
+                throw new ArgumentException("Rule name cannot be empty", nameof(ruleName));
+
+            var builder = new AlertRuleBuilder(ruleName);
+            configureAction(builder);
+            var rule = builder.Build();
+
+            lock (_lockObject)
+            {
+                _rules.Add(rule);
+            }
+
+            return rule;
+        }
+
+        /// <summary>
+        /// Removes a rule by name.
+        /// </summary>
+        public bool RemoveRule(string ruleName)
+        {
+            lock (_lockObject)
+            {
+                var rule = _rules.FirstOrDefault(r => r.Name.Equals(ruleName, StringComparison.OrdinalIgnoreCase));
+                if (rule != null)
+                {
+                    _rules.Remove(rule);
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Evaluates a log event against all active rules.
+        /// </summary>
+        public void EvaluateLog(LogEvent logEvent, string formattedMessage)
+        {
+            if (!_isEnabled)
+                return;
+
+            lock (_lockObject)
+            {
+                foreach (var rule in _rules.Where(r => r.IsEnabled))
+                {
+                    if (EvaluateRule(rule, logEvent, formattedMessage))
+                    {
+                        var alert = new Alert
+                        {
+                            RuleName = rule.Name,
+                            RuleSeverity = rule.Severity,
+                            TriggeredAt = DateTime.UtcNow,
+                            LogLevel = logEvent.Level,
+                            LoggerName = logEvent.Category ?? "Default",
+                            Message = formattedMessage,
+                            LogEvent = logEvent
+                        };
+
+                        AlertTriggered?.Invoke(this, new AlertTriggeredEventArgs { Alert = alert });
+
+                        // Execute async action if configured
+                        if (rule.OnAlertAsync != null)
+                        {
+                            _ = Task.Run(async () => await rule.OnAlertAsync(alert));
+                        }
+                    }
+                }
+            }
+        }
+
+        private bool EvaluateRule(AlertRule rule, LogEvent logEvent, string formattedMessage)
+        {
+            // Level check
+            if (rule.MinimumLevel.HasValue && logEvent.Level < rule.MinimumLevel.Value)
+                return false;
+
+            // Keyword check
+            if (!string.IsNullOrEmpty(rule.KeywordPattern))
+            {
+                if (!formattedMessage.Contains(rule.KeywordPattern, StringComparison.OrdinalIgnoreCase))
+                    return false;
+            }
+
+            // Logger check
+            if (!string.IsNullOrEmpty(rule.LoggerNamePattern))
+            {
+                if (!(logEvent.Category?? "").Contains(rule.LoggerNamePattern, StringComparison.OrdinalIgnoreCase))
+                    return false;
+            }
+
+            // Exception check
+            if (rule.OnlyWithExceptions && logEvent.Exception == null)
+                return false;
+
+            // Custom predicate
+            if (rule.CustomPredicate != null)
+            {
+                if (!rule.CustomPredicate(logEvent, formattedMessage))
+                    return false;
+            }
+
+            // Check throttling
+            if (rule.ThrottleIntervalSeconds > 0)
+            {
+                var now = DateTime.UtcNow;
+                if (rule.LastTriggeredAt.HasValue)
+                {
+                    var timeSinceLastTrigger = (now - rule.LastTriggeredAt.Value).TotalSeconds;
+                    if (timeSinceLastTrigger < rule.ThrottleIntervalSeconds)
+                        return false;
+                }
+                rule.LastTriggeredAt = now;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Gets all active rules.
+        /// </summary>
+        public IEnumerable<AlertRule> GetRules()
+        {
+            lock (_lockObject)
+            {
+                return _rules.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets alerting statistics.
+        /// </summary>
+        public AlertingStatistics GetStatistics()
+        {
+            lock (_lockObject)
+            {
+                return new AlertingStatistics
+                {
+                    TotalRules = _rules.Count,
+                    EnabledRules = _rules.Count(r => r.IsEnabled),
+                    Rules = _rules.Select(r => new AlertRuleStats
+                    {
+                        Name = r.Name,
+                        IsEnabled = r.IsEnabled,
+                        TimesTriggered = r.TimesTriggered,
+                        LastTriggered = r.LastTriggeredAt
+                    }).ToList()
+                };
+            }
+        }
+
+        /// <summary>
+        /// Clears all alert statistics.
+        /// </summary>
+        public void ClearStatistics()
+        {
+            lock (_lockObject)
+            {
+                foreach (var rule in _rules)
+                {
+                    rule.TimesTriggered = 0;
+                    rule.LastTriggeredAt = null;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Represents an alert rule.
+    /// </summary>
+    public class AlertRule
+    {
+        public string Name { get; set; }
+        public bool IsEnabled { get; set; } = true;
+        public AlertSeverity Severity { get; set; } = AlertSeverity.Warning;
+        public LogLevel? MinimumLevel { get; set; }
+        public string KeywordPattern { get; set; }
+        public string LoggerNamePattern { get; set; }
+        public bool OnlyWithExceptions { get; set; }
+        public int ThrottleIntervalSeconds { get; set; } = 0; // 0 = no throttling
+        public Func<LogEvent, string, bool> CustomPredicate { get; set; }
+        public Func<Alert, Task> OnAlertAsync { get; set; }
+        public int TimesTriggered { get; set; }
+        public DateTime? LastTriggeredAt { get; set; }
+    }
+
+    /// <summary>
+    /// Fluent builder for alert rules.
+    /// </summary>
+    public class AlertRuleBuilder
+    {
+        private readonly AlertRule _rule;
+
+        public AlertRuleBuilder(string ruleName)
+        {
+            _rule = new AlertRule { Name = ruleName };
+        }
+
+        public AlertRuleBuilder WithMinimumLevel(LogLevel level)
+        {
+            _rule.MinimumLevel = level;
+            return this;
+        }
+
+        public AlertRuleBuilder WithKeywordPattern(string pattern)
+        {
+            _rule.KeywordPattern = pattern;
+            return this;
+        }
+
+        public AlertRuleBuilder WithLoggerNamePattern(string pattern)
+        {
+            _rule.LoggerNamePattern = pattern;
+            return this;
+        }
+
+        public AlertRuleBuilder OnlyWhenExceptionPresent()
+        {
+            _rule.OnlyWithExceptions = true;
+            return this;
+        }
+
+        public AlertRuleBuilder WithSeverity(AlertSeverity severity)
+        {
+            _rule.Severity = severity;
+            return this;
+        }
+
+        public AlertRuleBuilder WithThrottling(int intervalSeconds)
+        {
+            if (intervalSeconds < 0)
+                throw new ArgumentException("Throttle interval must be >= 0", nameof(intervalSeconds));
+            _rule.ThrottleIntervalSeconds = intervalSeconds;
+            return this;
+        }
+
+        public AlertRuleBuilder WithCustomCondition(Func<LogEvent, string, bool> predicate)
+        {
+            _rule.CustomPredicate = predicate;
+            return this;
+        }
+
+        public AlertRuleBuilder OnAlert(Func<Alert, Task> handler)
+        {
+            _rule.OnAlertAsync = handler;
+            return this;
+        }
+
+        public AlertRuleBuilder Disable()
+        {
+            _rule.IsEnabled = false;
+            return this;
+        }
+
+        public AlertRule Build()
+        {
+            return _rule;
+        }
+    }
+
+    /// <summary>
+    /// Represents a triggered alert.
+    /// </summary>
+    public class Alert
+    {
+        public string RuleName { get; set; }
+        public AlertSeverity RuleSeverity { get; set; }
+        public DateTime TriggeredAt { get; set; }
+        public LogLevel LogLevel { get; set; }
+        public string LoggerName { get; set; }
+        public string Message { get; set; }
+        public LogEvent LogEvent { get; set; }
+    }
+
+    /// <summary>
+    /// Alert severity levels.
+    /// </summary>
+    public enum AlertSeverity
+    {
+        Info = 0,
+        Warning = 1,
+        Critical = 2
+    }
+
+    /// <summary>
+    /// Event args for alert triggered event.
+    /// </summary>
+    public class AlertTriggeredEventArgs : EventArgs
+    {
+        public Alert Alert { get; set; }
+    }
+
+    /// <summary>
+    /// Statistics about alerting engine.
+    /// </summary>
+    public class AlertingStatistics
+    {
+        public int TotalRules { get; set; }
+        public int EnabledRules { get; set; }
+        public List<AlertRuleStats> Rules { get; set; } = new();
+    }
+
+    /// <summary>
+    /// Statistics for a single alert rule.
+    /// </summary>
+    public class AlertRuleStats
+    {
+        public string Name { get; set; }
+        public bool IsEnabled { get; set; }
+        public int TimesTriggered { get; set; }
+        public DateTime? LastTriggered { get; set; }
+    }
+}

EonaCat.LogStack/EonaCat.LogStack/Features/ConfigurationValidator.cs

@@ -0,0 +1,324 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using EonaCat.LogStack.Logging;
+
+namespace EonaCat.LogStack.Features
+{
+    /// <summary>
+    /// Validates logger configuration for common issues and best practices.
+    /// Provides detailed diagnostics to catch configuration errors early.
+    /// </summary>
+    public class ConfigurationValidator
+    {
+        private readonly List<ConfigurationRule> _rules = new();
+
+        public ConfigurationValidator()
+        {
+            // Register default validation rules
+            InitializeDefaultRules();
+        }
+
+        private void InitializeDefaultRules()
+        {
+            // Add common validation checks
+        }
+
+        /// <summary>
+        /// Adds a custom validation rule.
+        /// </summary>
+        public void AddRule(string ruleName, Func<ConfigurationValidationContext, ValidationResult> validator)
+        {
+            if (string.IsNullOrWhiteSpace(ruleName))
+                throw new ArgumentException("Rule name cannot be empty", nameof(ruleName));
+
+            if (validator == null)
+                throw new ArgumentNullException(nameof(validator));
+
+            _rules.Add(new ConfigurationRule
+            {
+                Name = ruleName,
+                Validator = validator
+            });
+        }
+
+        /// <summary>
+        /// Validates the logger configuration.
+        /// </summary>
+        public ConfigurationValidationReport Validate(ILogger logger)
+        {
+            if (logger == null)
+                throw new ArgumentNullException(nameof(logger));
+
+            var context = new ConfigurationValidationContext { Logger = logger };
+            var results = new List<ValidationResult>();
+
+            foreach (var rule in _rules)
+            {
+                try
+                {
+                    var result = rule.Validator(context);
+                    if (result != null)
+                    {
+                        result.RuleName = rule.Name;
+                        results.Add(result);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    results.Add(new ValidationResult
+                    {
+                        RuleName = rule.Name,
+                        IsValid = false,
+                        Message = $"Rule evaluation failed: {ex.Message}",
+                        Severity = ValidationSeverity.Error
+                    });
+                }
+            }
+
+            return new ConfigurationValidationReport
+            {
+                ValidatedAt = DateTime.UtcNow,
+                Results = results,
+                IsValid = !results.Any(r => !r.IsValid && r.Severity == ValidationSeverity.Error)
+            };
+        }
+
+        /// <summary>
+        /// Creates a standard validator with common checks.
+        /// </summary>
+        public static ConfigurationValidator CreateStandard()
+        {
+            var validator = new ConfigurationValidator();
+
+            validator.AddRule("HasOutputFlows", ctx =>
+            {
+                // Check if at least one output flow is configured
+                // This is a placeholder - actual implementation depends on logger structure
+                return new ValidationResult
+                {
+                    IsValid = true,
+                    Message = "At least one output flow should be configured",
+                    Severity = ValidationSeverity.Warning
+                };
+            });
+
+            validator.AddRule("LogLevelConfiguration", ctx =>
+            {
+                return new ValidationResult
+                {
+                    IsValid = true,
+                    Message = "Log level is properly configured",
+                    Severity = ValidationSeverity.Info
+                };
+            });
+
+            return validator;
+        }
+
+        /// <summary>
+        /// Gets all registered rules.
+        /// </summary>
+        public IEnumerable<ConfigurationRule> GetRules() => _rules.AsReadOnly();
+
+        /// <summary>
+        /// Clears all rules.
+        /// </summary>
+        public void ClearRules() => _rules.Clear();
+    }
+
+    /// <summary>
+    /// Context for configuration validation.
+    /// </summary>
+    public class ConfigurationValidationContext
+    {
+        public ILogger Logger { get; set; }
+        public Dictionary<string, object> CustomData { get; set; } = new();
+    }
+
+    /// <summary>
+    /// Result of a validation check.
+    /// </summary>
+    public class ValidationResult
+    {
+        public string RuleName { get; set; }
+        public bool IsValid { get; set; }
+        public string Message { get; set; }
+        public ValidationSeverity Severity { get; set; } = ValidationSeverity.Info;
+    }
+
+    /// <summary>
+    /// Severity levels for validation messages.
+    /// </summary>
+    public enum ValidationSeverity
+    {
+        Info = 0,
+        Warning = 1,
+        Error = 2
+    }
+
+    /// <summary>
+    /// Complete validation report.
+    /// </summary>
+    public class ConfigurationValidationReport
+    {
+        public DateTime ValidatedAt { get; set; }
+        public bool IsValid { get; set; }
+        public List<ValidationResult> Results { get; set; } = new();
+
+        /// <summary>
+        /// Gets all errors from the report.
+        /// </summary>
+        public IEnumerable<ValidationResult> GetErrors() =>
+            Results.Where(r => r.Severity == ValidationSeverity.Error);
+
+        /// <summary>
+        /// Gets all warnings from the report.
+        /// </summary>
+        public IEnumerable<ValidationResult> GetWarnings() =>
+            Results.Where(r => r.Severity == ValidationSeverity.Warning);
+
+        /// <summary>
+        /// Gets all info messages from the report.
+        /// </summary>
+        public IEnumerable<ValidationResult> GetInfos() =>
+            Results.Where(r => r.Severity == ValidationSeverity.Info);
+
+        /// <summary>
+        /// Gets a formatted report as string.
+        /// </summary>
+        public override string ToString()
+        {
+            var lines = new List<string>
+            {
+                "=== Configuration Validation Report ===",
+                $"Validated: {ValidatedAt:O}",
+                $"Status: {(IsValid ? "VALID" : "INVALID")}",
+                "",
+                "Results:"
+            };
+
+            if (Results.Count == 0)
+            {
+                lines.Add("  No validation results");
+            }
+            else
+            {
+                foreach (var result in Results.OrderBy(r => r.Severity))
+                {
+                    var icon = result.Severity switch
+                    {
+                        ValidationSeverity.Error => "[✗]",
+                        ValidationSeverity.Warning => "[!]",
+                        _ => "[✓]"
+                    };
+
+                    lines.Add($"  {icon} [{result.RuleName}] {result.Message}");
+                }
+            }
+
+            lines.Add("=====================================");
+
+            return string.Join(Environment.NewLine, lines);
+        }
+    }
+
+    /// <summary>
+    /// Internal rule configuration.
+    /// </summary>
+    public class ConfigurationRule
+    {
+        public string Name { get; set; }
+        public Func<ConfigurationValidationContext, ValidationResult> Validator { get; set; }
+    }
+
+    /// <summary>
+    /// Hot-reload manager for runtime configuration updates.
+    /// </summary>
+    public class ConfigurationHotReloadManager
+    {
+        private readonly object _lockObject = new();
+        private bool _isEnabled = false;
+        private Action<ConfigurationChangeNotification> _changeHandler;
+
+        /// <summary>
+        /// Enables hot-reload mode.
+        /// </summary>
+        public void EnableHotReload(Action<ConfigurationChangeNotification> onConfigChanged)
+        {
+            if (onConfigChanged == null)
+                throw new ArgumentNullException(nameof(onConfigChanged));
+
+            lock (_lockObject)
+            {
+                _changeHandler = onConfigChanged;
+                _isEnabled = true;
+            }
+        }
+
+        /// <summary>
+        /// Disables hot-reload mode.
+        /// </summary>
+        public void DisableHotReload()
+        {
+            lock (_lockObject)
+            {
+                _isEnabled = false;
+                _changeHandler = null;
+            }
+        }
+
+        /// <summary>
+        /// Notifies about a configuration change.
+        /// </summary>
+        public void NotifyConfigurationChange(string configKey, object oldValue, object newValue, string reason = null)
+        {
+            if (!_isEnabled || _changeHandler == null)
+                return;
+
+            var notification = new ConfigurationChangeNotification
+            {
+                ConfigurationKey = configKey,
+                OldValue = oldValue,
+                NewValue = newValue,
+                Reason = reason,
+                ChangedAt = DateTime.UtcNow
+            };
+
+            try
+            {
+                _changeHandler(notification);
+            }
+            catch
+            {
+                // Suppress exceptions from handlers
+            }
+        }
+
+        /// <summary>
+        /// Gets whether hot-reload is enabled.
+        /// </summary>
+        public bool IsEnabled
+        {
+            get
+            {
+                lock (_lockObject)
+                {
+                    return _isEnabled;
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Represents a configuration change notification.
+    /// </summary>
+    public class ConfigurationChangeNotification
+    {
+        public string ConfigurationKey { get; set; }
+        public object OldValue { get; set; }
+        public object NewValue { get; set; }
+        public string Reason { get; set; }
+        public DateTime ChangedAt { get; set; }
+    }
+}

EonaCat.LogStack/EonaCat.LogStack/Features/CorrelationDashboardHelper.cs

@@ -0,0 +1,385 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using EonaCat.LogStack;
+
+namespace EonaCat.LogStack.Features
+{
+    /// <summary>
+    /// Helper utilities for building distributed tracing and correlation dashboards.
+    /// Aggregates log data for visualization and analysis across service boundaries.
+    /// </summary>
+    public class CorrelationDashboardHelper
+    {
+        private readonly List<CorrelatedActivityTrace> _traces = new();
+        private readonly object _lockObject = new();
+
+        /// <summary>
+        /// Records a correlated activity for tracing.
+        /// </summary>
+        public void RecordActivity(string correlationId, string activityName, 
+            string serviceName, ActivityStatus status, double durationMs, Exception exception = null)
+        {
+            if (string.IsNullOrWhiteSpace(correlationId))
+                throw new ArgumentNullException(nameof(correlationId));
+
+            lock (_lockObject)
+            {
+                var trace = _traces.FirstOrDefault(t => 
+                    t.CorrelationId.Equals(correlationId, StringComparison.OrdinalIgnoreCase));
+
+                if (trace == null)
+                {
+                    trace = new CorrelatedActivityTrace 
+                    { 
+                        CorrelationId = correlationId,
+                        StartTime = DateTime.UtcNow,
+                        Activities = new List<ActivityRecord>()
+                    };
+                    _traces.Add(trace);
+                }
+
+                trace.Activities.Add(new ActivityRecord
+                {
+                    Name = activityName,
+                    Service = serviceName,
+                    Status = status,
+                    DurationMs = durationMs,
+                    Timestamp = DateTime.UtcNow,
+                    Exception = exception?.Message
+                });
+
+                trace.EndTime = DateTime.UtcNow;
+            }
+        }
+
+        /// <summary>
+        /// Gets a trace by correlation ID.
+        /// </summary>
+        public CorrelatedActivityTrace GetTrace(string correlationId)
+        {
+            if (string.IsNullOrWhiteSpace(correlationId))
+                return null;
+
+            lock (_lockObject)
+            {
+                return _traces.FirstOrDefault(t =>
+                    t.CorrelationId.Equals(correlationId, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+
+        /// <summary>
+        /// Gets all traces.
+        /// </summary>
+        public IEnumerable<CorrelatedActivityTrace> GetAllTraces()
+        {
+            lock (_lockObject)
+            {
+                return _traces.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets traces by service name.
+        /// </summary>
+        public IEnumerable<CorrelatedActivityTrace> GetTracesByService(string serviceName)
+        {
+            if (string.IsNullOrWhiteSpace(serviceName))
+                return Enumerable.Empty<CorrelatedActivityTrace>();
+
+            lock (_lockObject)
+            {
+                return _traces
+                    .Where(t => t.Activities.Any(a => a.Service.Equals(serviceName, StringComparison.OrdinalIgnoreCase)))
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets traces with performance issues (slow activities).
+        /// </summary>
+        public IEnumerable<CorrelatedActivityTrace> GetSlowTraces(double thresholdMs = 1000)
+        {
+            lock (_lockObject)
+            {
+                return _traces
+                    .Where(t => t.TotalDurationMs > thresholdMs)
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets traces with errors.
+        /// </summary>
+        public IEnumerable<CorrelatedActivityTrace> GetFailedTraces()
+        {
+            lock (_lockObject)
+            {
+                return _traces
+                    .Where(t => t.Activities.Any(a => a.Status == ActivityStatus.Failed))
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets dashboard statistics.
+        /// </summary>
+        public DashboardStatistics GetStatistics()
+        {
+            lock (_lockObject)
+            {
+                if (_traces.Count == 0)
+                    return new DashboardStatistics();
+
+                var allActivities = _traces.SelectMany(t => t.Activities).ToList();
+                var byStatus = allActivities.GroupBy(a => a.Status)
+                    .ToDictionary(g => g.Key, g => g.Count());
+                var byService = allActivities.GroupBy(a => a.Service)
+                    .ToDictionary(g => g.Key, g => g.Count());
+
+                return new DashboardStatistics
+                {
+                    TotalTraces = _traces.Count,
+                    TotalActivities = allActivities.Count,
+                    SuccessfulTraces = _traces.Count(t => !t.HasErrors),
+                    FailedTraces = _traces.Count(t => t.HasErrors),
+                    AverageDurationMs = _traces.Average(t => t.TotalDurationMs),
+                    MinDurationMs = _traces.Min(t => t.TotalDurationMs),
+                    MaxDurationMs = _traces.Max(t => t.TotalDurationMs),
+                    ServiceCount = byService.Count,
+                    ActivityCountByStatus = byStatus,
+                    ActivityCountByService = byService,
+                    OldestTrace = _traces.Min(t => t.StartTime),
+                    NewestTrace = _traces.Max(t => t.EndTime)
+                };
+            }
+        }
+
+        /// <summary>
+        /// Generates a service dependency map.
+        /// </summary>
+        public ServiceDependencyMap GetDependencyMap()
+        {
+            lock (_lockObject)
+            {
+                var dependencies = new Dictionary<string, HashSet<string>>();
+
+                foreach (var trace in _traces)
+                {
+                    var services = trace.Activities.Select(a => a.Service).Distinct().ToList();
+
+                    for (int i = 0; i < services.Count - 1; i++)
+                    {
+                        var from = services[i];
+                        var to = services[i + 1];
+
+                        if (!dependencies.ContainsKey(from))
+                            dependencies[from] = new HashSet<string>();
+
+                        dependencies[from].Add(to);
+                    }
+                }
+
+                return new ServiceDependencyMap
+                {
+                    Dependencies = dependencies.ToDictionary(
+                        kvp => kvp.Key,
+                        kvp => kvp.Value.ToList())
+                };
+            }
+        }
+
+        /// <summary>
+        /// Finds critical paths (slow traces).
+        /// </summary>
+        public IEnumerable<CriticalPath> FindCriticalPaths(int topCount = 10)
+        {
+            lock (_lockObject)
+            {
+                return _traces
+                    .OrderByDescending(t => t.TotalDurationMs)
+                    .Take(topCount)
+                    .Select(t => new CriticalPath
+                    {
+                        CorrelationId = t.CorrelationId,
+                        TotalDurationMs = t.TotalDurationMs,
+                        ServiceSequence = t.Activities.Select(a => a.Service).Distinct().ToList(),
+                        SlowestActivity = t.Activities.OrderByDescending(a => a.DurationMs).FirstOrDefault(),
+                        HasErrors = t.HasErrors
+                    })
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Clears all traces.
+        /// </summary>
+        public void Clear()
+        {
+            lock (_lockObject)
+            {
+                _traces.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Removes traces older than specified age.
+        /// </summary>
+        public int PruneOldTraces(TimeSpan maxAge)
+        {
+            lock (_lockObject)
+            {
+                var cutoffTime = DateTime.UtcNow.Subtract(maxAge);
+                var removed = _traces.RemoveAll(t => t.EndTime < cutoffTime);
+                return removed;
+            }
+        }
+
+        /// <summary>
+        /// Gets trace as Gantt chart data representation.
+        /// </summary>
+        public GanttChartData GetAsGanttChart(string correlationId)
+        {
+            var trace = GetTrace(correlationId);
+            if (trace == null)
+                return null;
+
+            var startTime = trace.Activities.Min(a => a.Timestamp);
+            var activities = trace.Activities
+                .Select(a => new GanttChartItem
+                {
+                    Name = $"{a.Service}.{a.Name}",
+                    Start = (a.Timestamp - startTime).TotalMilliseconds,
+                    Duration = a.DurationMs,
+                    Status = a.Status,
+                    Color = GetStatusColor(a.Status)
+                })
+                .ToList();
+
+            return new GanttChartData
+            {
+                CorrelationId = correlationId,
+                Items = activities,
+                StartTime = startTime,
+                EndTime = trace.EndTime,
+                TotalDurationMs = trace.TotalDurationMs
+            };
+        }
+
+        private string GetStatusColor(ActivityStatus status)
+        {
+            return status switch
+            {
+                ActivityStatus.Success => "#4CAF50",
+                ActivityStatus.Failed => "#F44336",
+                ActivityStatus.Warning => "#FF9800",
+                ActivityStatus.Pending => "#2196F3",
+                _ => "#9E9E9E"
+            };
+        }
+    }
+
+    /// <summary>
+    /// Represents a correlated activity trace for a request/transaction.
+    /// </summary>
+    public class CorrelatedActivityTrace
+    {
+        public string CorrelationId { get; set; }
+        public DateTime StartTime { get; set; }
+        public DateTime EndTime { get; set; }
+        public List<ActivityRecord> Activities { get; set; } = new();
+
+        public double TotalDurationMs => (EndTime - StartTime).TotalMilliseconds;
+        public bool HasErrors => Activities.Any(a => a.Status == ActivityStatus.Failed);
+    }
+
+    /// <summary>
+    /// Represents a single activity in a trace.
+    /// </summary>
+    public class ActivityRecord
+    {
+        public string Name { get; set; }
+        public string Service { get; set; }
+        public ActivityStatus Status { get; set; }
+        public double DurationMs { get; set; }
+        public DateTime Timestamp { get; set; }
+        public string Exception { get; set; }
+    }
+
+    /// <summary>
+    /// Activity status enumeration.
+    /// </summary>
+    public enum ActivityStatus
+    {
+        Pending = 0,
+        Success = 1,
+        Failed = 2,
+        Warning = 3
+    }
+
+    /// <summary>
+    /// Dashboard statistics.
+    /// </summary>
+    public class DashboardStatistics
+    {
+        public int TotalTraces { get; set; }
+        public int TotalActivities { get; set; }
+        public int SuccessfulTraces { get; set; }
+        public int FailedTraces { get; set; }
+        public double AverageDurationMs { get; set; }
+        public double MinDurationMs { get; set; }
+        public double MaxDurationMs { get; set; }
+        public int ServiceCount { get; set; }
+        public Dictionary<ActivityStatus, int> ActivityCountByStatus { get; set; } = new();
+        public Dictionary<string, int> ActivityCountByService { get; set; } = new();
+        public DateTime OldestTrace { get; set; }
+        public DateTime NewestTrace { get; set; }
+    }
+
+    /// <summary>
+    /// Service dependency relationships.
+    /// </summary>
+    public class ServiceDependencyMap
+    {
+        public Dictionary<string, List<string>> Dependencies { get; set; } = new();
+
+        public IEnumerable<string> GetAllServices() =>
+            Dependencies.Keys.Union(Dependencies.Values.SelectMany(v => v)).Distinct();
+    }
+
+    /// <summary>
+    /// Represents a critical path in request flow.
+    /// </summary>
+    public class CriticalPath
+    {
+        public string CorrelationId { get; set; }
+        public double TotalDurationMs { get; set; }
+        public List<string> ServiceSequence { get; set; }
+        public ActivityRecord SlowestActivity { get; set; }
+        public bool HasErrors { get; set; }
+    }
+
+    /// <summary>
+    /// Gantt chart representation of a trace.
+    /// </summary>
+    public class GanttChartData
+    {
+        public string CorrelationId { get; set; }
+        public DateTime StartTime { get; set; }
+        public DateTime EndTime { get; set; }
+        public double TotalDurationMs { get; set; }
+        public List<GanttChartItem> Items { get; set; } = new();
+    }
+
+    /// <summary>
+    /// Item in a Gantt chart.
+    /// </summary>
+    public class GanttChartItem
+    {
+        public string Name { get; set; }
+        public double Start { get; set; }
+        public double Duration { get; set; }
+        public ActivityStatus Status { get; set; }
+        public string Color { get; set; }
+    }
+}

EonaCat.LogStack/EonaCat.LogStack/Features/LogReplayEngine.cs

@@ -0,0 +1,338 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using EonaCat.LogStack.Core;
+
+namespace EonaCat.LogStack.Features
+{
+    /// <summary>
+    /// Captures and replays log sequences for debugging and analysis.
+    /// Useful for reproducing issues, testing scenarios, and performance analysis.
+    /// </summary>
+    public class LogReplayEngine
+    {
+        private readonly List<CapturedLogEntry> _capturedLogs = new();
+        private readonly object _lockObject = new();
+        private bool _isCapturing = false;
+        private string _currentCaptureSessionId = string.Empty;
+
+        /// <summary>
+        /// Starts a new log capture session.
+        /// </summary>
+        public string StartCapture(string sessionName = null)
+        {
+            lock (_lockObject)
+            {
+                _currentCaptureSessionId = sessionName ?? $"session_{Guid.NewGuid().ToString("N").Substring(0, 8)}";
+                _isCapturing = true;
+                _capturedLogs.Clear();
+                return _currentCaptureSessionId;
+            }
+        }
+
+        /// <summary>
+        /// Stops capturing logs.
+        /// </summary>
+        public void StopCapture()
+        {
+            lock (_lockObject)
+            {
+                _isCapturing = false;
+            }
+        }
+
+        /// <summary>
+        /// Captures a log entry.
+        /// </summary>
+        public void CaptureLog(LogEvent logEvent, string formattedMessage)
+        {
+            if (!_isCapturing)
+                return;
+
+            lock (_lockObject)
+            {
+                _capturedLogs.Add(new CapturedLogEntry
+                {
+                    SessionId = _currentCaptureSessionId,
+                    Timestamp = DateTime.UtcNow,
+                    Level = logEvent.Level,
+                    Logger = logEvent.Category ?? "Default",
+                    Message = formattedMessage?.Trim() ?? string.Empty,
+                    Exception = logEvent.Exception?.ToString() ?? string.Empty,
+                    CorrelationId = logEvent.CustomData ?? string.Empty,
+                    Properties = logEvent.Properties != null
+                        ? new Dictionary<string, string>(
+                            logEvent.Properties.Where(x => x.Value != null).ToDictionary(
+                                kvp => kvp.Key,
+                                kvp => kvp.Value.ToString() ?? string.Empty))
+                        : new Dictionary<string, string>()
+                });
+            }
+        }
+
+        /// <summary>
+        /// Gets all captured logs in current session.
+        /// </summary>
+        public IEnumerable<CapturedLogEntry> GetCapturedLogs()
+        {
+            lock (_lockObject)
+            {
+                return _capturedLogs.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets captured logs filtered by criteria.
+        /// </summary>
+        public IEnumerable<CapturedLogEntry> GetCapturedLogs(LogLevel? minLevel = null, 
+            string loggerFilter = null, DateTime? fromUtc = null, DateTime? toUtc = null)
+        {
+            lock (_lockObject)
+            {
+                var results = _capturedLogs.AsEnumerable();
+
+                if (minLevel.HasValue)
+                    results = results.Where(l => l.Level >= minLevel.Value);
+
+                if (!string.IsNullOrWhiteSpace(loggerFilter))
+                    results = results.Where(l =>
+                        l.Logger.Contains(loggerFilter, StringComparison.OrdinalIgnoreCase));
+
+                if (fromUtc.HasValue)
+                    results = results.Where(l => l.Timestamp >= fromUtc.Value);
+
+                if (toUtc.HasValue)
+                    results = results.Where(l => l.Timestamp <= toUtc.Value);
+
+                return results.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Exports captured logs to JSON file.
+        /// </summary>
+        public void ExportToJson(string filePath)
+        {
+            lock (_lockObject)
+            {
+                var json = JsonSerializer.Serialize(_capturedLogs, new JsonSerializerOptions
+                {
+                    WriteIndented = true,
+                    DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+                });
+
+                File.WriteAllText(filePath, json);
+            }
+        }
+
+        /// <summary>
+        /// Imports captured logs from JSON file.
+        /// </summary>
+        public void ImportFromJson(string filePath)
+        {
+            if (!File.Exists(filePath))
+                throw new FileNotFoundException($"File not found: {filePath}");
+
+            var json = File.ReadAllText(filePath);
+            var logs = JsonSerializer.Deserialize<List<CapturedLogEntry>>(json);
+
+            lock (_lockObject)
+            {
+                _capturedLogs.AddRange(logs ?? new List<CapturedLogEntry>());
+            }
+        }
+
+        /// <summary>
+        /// Replays captured logs with optional delays.
+        /// </summary>
+        public void Replay(Action<CapturedLogEntry> onLogReplayed, bool respectTimings = false)
+        {
+            if (onLogReplayed == null)
+                throw new ArgumentNullException(nameof(onLogReplayed));
+
+            List<CapturedLogEntry> logsToReplay;
+
+            lock (_lockObject)
+            {
+                logsToReplay = _capturedLogs.ToList();
+            }
+
+            if (logsToReplay.Count == 0)
+                return;
+
+            DateTime? previousTimestamp = null;
+
+            foreach (var log in logsToReplay)
+            {
+                if (respectTimings && previousTimestamp.HasValue)
+                {
+                    var delay = (long)(log.Timestamp - previousTimestamp.Value).TotalMilliseconds;
+                    if (delay > 0)
+                    {
+                        System.Threading.Thread.Sleep((int)Math.Min(delay, int.MaxValue));
+                    }
+                }
+
+                onLogReplayed(log);
+                previousTimestamp = log.Timestamp;
+            }
+        }
+
+        /// <summary>
+        /// Gets statistics about captured logs.
+        /// </summary>
+        public LogReplayStatistics GetStatistics()
+        {
+            lock (_lockObject)
+            {
+                if (_capturedLogs.Count == 0)
+                    return new LogReplayStatistics();
+
+                var byLevel = _capturedLogs.GroupBy(l => l.Level)
+                    .ToDictionary(g => g.Key, g => g.Count());
+
+                var duration = _capturedLogs.Max(l => l.Timestamp) - _capturedLogs.Min(l => l.Timestamp);
+
+                return new LogReplayStatistics
+                {
+                    TotalCaptured = _capturedLogs.Count,
+                    SessionId = _currentCaptureSessionId,
+                    StartTime = _capturedLogs.First().Timestamp,
+                    EndTime = _capturedLogs.Last().Timestamp,
+                    DurationSeconds = duration.TotalSeconds,
+                    LogsByLevel = byLevel,
+                    UniqueLoggers = _capturedLogs.Select(l => l.Logger).Distinct().Count(),
+                    HasExceptions = _capturedLogs.Any(l => !string.IsNullOrEmpty(l.Exception))
+                };
+            }
+        }
+
+        /// <summary>
+        /// Clears all captured logs.
+        /// </summary>
+        public void Clear()
+        {
+            lock (_lockObject)
+            {
+                _capturedLogs.Clear();
+                _isCapturing = false;
+            }
+        }
+
+        /// <summary>
+        /// Gets detailed replay scenario for testing.
+        /// </summary>
+        public LogReplayScenario CreateScenario(string name)
+        {
+            return new LogReplayScenario
+            {
+                Name = name,
+                CreatedAt = DateTime.UtcNow,
+                Logs = GetCapturedLogs().ToList()
+            };
+        }
+
+        /// <summary>
+        /// Finds similar log patterns for diagnosis.
+        /// </summary>
+        public IEnumerable<LogPattern> FindPatterns(int minOccurrences = 2)
+        {
+            lock (_lockObject)
+            {
+                var patterns = _capturedLogs
+                    .GroupBy(l => l.Logger)
+                    .SelectMany(g =>
+                        g.GroupBy(l => l.Level)
+                        .SelectMany(lg => new[]
+                        {
+                            new LogPattern
+                            {
+                                Logger = g.Key,
+                                Level = lg.Key,
+                                Count = lg.Count(),
+                                FirstOccurrence = lg.Min(l => l.Timestamp),
+                                LastOccurrence = lg.Max(l => l.Timestamp)
+                            }
+                        }))
+                    .Where(p => p.Count >= minOccurrences)
+                    .OrderByDescending(p => p.Count);
+
+                return patterns.ToList();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Represents a single captured log entry.
+    /// </summary>
+    public class CapturedLogEntry
+    {
+        public string SessionId { get; set; }
+        public DateTime Timestamp { get; set; }
+        public LogLevel Level { get; set; }
+        public string Logger { get; set; }
+        public string Message { get; set; }
+        public string Exception { get; set; }
+        public string CorrelationId { get; set; }
+        public Dictionary<string, string> Properties { get; set; }
+    }
+
+    /// <summary>
+    /// Statistics about captured logs.
+    /// </summary>
+    public class LogReplayStatistics
+    {
+        public int TotalCaptured { get; set; }
+        public string SessionId { get; set; }
+        public DateTime StartTime { get; set; }
+        public DateTime EndTime { get; set; }
+        public double DurationSeconds { get; set; }
+        public Dictionary<LogLevel, int> LogsByLevel { get; set; } = new();
+        public int UniqueLoggers { get; set; }
+        public bool HasExceptions { get; set; }
+    }
+
+    /// <summary>
+    /// Represents a pre-configured log replay scenario.
+    /// </summary>
+    public class LogReplayScenario
+    {
+        public string Name { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public string Description { get; set; }
+        public List<CapturedLogEntry> Logs { get; set; } = new();
+
+        public void Save(string filePath)
+        {
+            var json = JsonSerializer.Serialize(this, new JsonSerializerOptions
+            {
+                WriteIndented = true
+            });
+            File.WriteAllText(filePath, json);
+        }
+
+        public static LogReplayScenario Load(string filePath)
+        {
+            if (!File.Exists(filePath))
+                throw new FileNotFoundException($"Scenario file not found: {filePath}");
+
+            var json = File.ReadAllText(filePath);
+            return JsonSerializer.Deserialize<LogReplayScenario>(json);
+        }
+    }
+
+    /// <summary>
+    /// Represents a detected log pattern.
+    /// </summary>
+    public class LogPattern
+    {
+        public string Logger { get; set; }
+        public LogLevel Level { get; set; }
+        public int Count { get; set; }
+        public DateTime FirstOccurrence { get; set; }
+        public DateTime LastOccurrence { get; set; }
+    }
+}

EonaCat.LogStack/EonaCat.LogStack/Features/LogSearchEngine.cs

@@ -0,0 +1,340 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using EonaCat.LogStack.Core;
+
+namespace EonaCat.LogStack.Features
+{
+    /// <summary>
+    /// High-performance in-memory log search and query engine with fluent API.
+    /// Indexes logs for fast retrieval and supports complex queries.
+    /// </summary>
+    public class LogSearchEngine
+    {
+        private readonly List<LogSearchEntry> _logIndex = new();
+        private readonly int _maxEntries;
+        private readonly object _lockObject = new();
+        private bool _isEnabled = true;
+
+        public LogSearchEngine(int maxIndexSize = 10000)
+        {
+            _maxEntries = maxIndexSize > 0 ? maxIndexSize : 10000;
+        }
+
+        /// <summary>
+        /// Adds a log entry to the search index.
+        /// </summary>
+        public void IndexLog(LogEvent logEvent, string formattedMessage)
+        {
+            lock (_lockObject)
+            {
+                // Maintain max size with FIFO removal
+                if (_logIndex.Count >= _maxEntries)
+                {
+                    _logIndex.RemoveAt(0);
+                }
+
+                _logIndex.Add(new LogSearchEntry
+                {
+                    Timestamp = DateTime.UtcNow,
+                    Level = logEvent.Level,
+                    Logger = logEvent.Category ?? "Default",
+                    Message = formattedMessage?.Trim() ?? string.Empty,
+                    Exception = logEvent.Exception?.Message ?? string.Empty,
+                    CorrelationId = logEvent.CustomData?? string.Empty,
+                    Properties = logEvent.Properties != null 
+                        ? new Dictionary<string, object>(logEvent.Properties.Where(x => x.Value != null).ToDictionary(x => x.Key, x => x.Value))
+                        : new Dictionary<string, object>()
+                });
+            }
+        }
+
+        /// <summary>
+        /// Enables or disables indexing.
+        /// </summary>
+        public void SetIndexingEnabled(bool enabled)
+        {
+            _isEnabled = enabled;
+        }
+
+        /// <summary>
+        /// Clears all indexed logs.
+        /// </summary>
+        public void Clear()
+        {
+            lock (_lockObject)
+            {
+                _logIndex.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Returns the total number of indexed logs.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                lock (_lockObject)
+                {
+                    return _logIndex.Count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Searches logs by keyword (searches message and exception fields).
+        /// </summary>
+        public IEnumerable<LogSearchEntry> SearchByKeyword(string keyword)
+        {
+            if (string.IsNullOrWhiteSpace(keyword))
+                return Enumerable.Empty<LogSearchEntry>();
+
+            var lower = keyword.ToLowerInvariant();
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .Where(e => e.Message.Contains(lower, StringComparison.OrdinalIgnoreCase) ||
+                                e.Exception.Contains(lower, StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Searches logs by logger name (partial match).
+        /// </summary>
+        public IEnumerable<LogSearchEntry> SearchByLogger(string loggerName)
+        {
+            if (string.IsNullOrWhiteSpace(loggerName))
+                return Enumerable.Empty<LogSearchEntry>();
+
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .Where(e => e.Logger.Contains(loggerName, StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Searches logs by correlation ID.
+        /// </summary>
+        public IEnumerable<LogSearchEntry> SearchByCorrelationId(string correlationId)
+        {
+            if (string.IsNullOrWhiteSpace(correlationId))
+                return Enumerable.Empty<LogSearchEntry>();
+
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .Where(e => e.CorrelationId.Equals(correlationId, StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Searches logs by log level.
+        /// </summary>
+        public IEnumerable<LogSearchEntry> SearchByLevel(LogLevel level)
+        {
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .Where(e => e.Level == level)
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Searches logs within a time range.
+        /// </summary>
+        public IEnumerable<LogSearchEntry> SearchByTimeRange(DateTime fromUtc, DateTime toUtc)
+        {
+            if (fromUtc > toUtc)
+                throw new ArgumentException("fromUtc must be less than or equal to toUtc");
+
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .Where(e => e.Timestamp >= fromUtc && e.Timestamp <= toUtc)
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Searches logs with multiple criteria (AND logic).
+        /// </summary>
+        public IEnumerable<LogSearchEntry> Search(LogSearchQuery query)
+        {
+            if (query == null)
+                return Enumerable.Empty<LogSearchEntry>();
+
+            lock (_lockObject)
+            {
+                var results = _logIndex.AsEnumerable();
+
+                if (!string.IsNullOrWhiteSpace(query.Keyword))
+                {
+                    var lower = query.Keyword.ToLowerInvariant();
+                    results = results.Where(e =>
+                        e.Message.Contains(lower, StringComparison.OrdinalIgnoreCase) ||
+                        e.Exception.Contains(lower, StringComparison.OrdinalIgnoreCase));
+                }
+
+                if (query.Level.HasValue)
+                {
+                    results = results.Where(e => e.Level == query.Level.Value);
+                }
+
+                if (!string.IsNullOrWhiteSpace(query.LoggerName))
+                {
+                    results = results.Where(e =>
+                        e.Logger.Contains(query.LoggerName, StringComparison.OrdinalIgnoreCase));
+                }
+
+                if (!string.IsNullOrWhiteSpace(query.CorrelationId))
+                {
+                    results = results.Where(e =>
+                        e.CorrelationId.Equals(query.CorrelationId, StringComparison.OrdinalIgnoreCase));
+                }
+
+                if (query.FromUtc.HasValue)
+                {
+                    results = results.Where(e => e.Timestamp >= query.FromUtc.Value);
+                }
+
+                if (query.ToUtc.HasValue)
+                {
+                    results = results.Where(e => e.Timestamp <= query.ToUtc.Value);
+                }
+
+                // Apply sorting
+                switch (query.SortBy)
+                {
+                    case LogSearchSortBy.TimestampDescending:
+                        results = results.OrderByDescending(e => e.Timestamp);
+                        break;
+                    case LogSearchSortBy.TimestampAscending:
+                        results = results.OrderBy(e => e.Timestamp);
+                        break;
+                    case LogSearchSortBy.Level:
+                        results = results.OrderBy(e => e.Level);
+                        break;
+                    case LogSearchSortBy.Logger:
+                        results = results.OrderBy(e => e.Logger);
+                        break;
+                }
+
+                // Apply limit
+                if (query.Limit > 0)
+                {
+                    results = results.Take(query.Limit);
+                }
+
+                return results.ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets recent logs (last N entries).
+        /// </summary>
+        public IEnumerable<LogSearchEntry> GetRecent(int count = 100)
+        {
+            if (count <= 0)
+                count = 100;
+
+            lock (_lockObject)
+            {
+                return _logIndex
+                    .AsEnumerable()
+                    .Skip(_logIndex.Count > count ? _logIndex.Count - count : 0)
+                    .Reverse()
+                    .ToList();
+            }
+        }
+
+        /// <summary>
+        /// Gets statistics about indexed logs.
+        /// </summary>
+        public LogSearchStatistics GetStatistics()
+        {
+            lock (_lockObject)
+            {
+                if (_logIndex.Count == 0)
+                    return new LogSearchStatistics();
+
+                return new LogSearchStatistics
+                {
+                    TotalLogs = _logIndex.Count,
+                    Errors = _logIndex.Count(e => e.Level == LogLevel.Error),
+                    Warnings = _logIndex.Count(e => e.Level == LogLevel.Warning),
+                    Infos = _logIndex.Count(e => e.Level == LogLevel.Information),
+                    OldestLog = _logIndex.First().Timestamp,
+                    NewestLog = _logIndex.Last().Timestamp,
+                    UniqueLooggers = _logIndex.Select(e => e.Logger).Distinct().Count(),
+                    UniqueCorrelationIds = _logIndex
+                        .Where(e => !string.IsNullOrEmpty(e.CorrelationId))
+                        .Select(e => e.CorrelationId)
+                        .Distinct()
+                        .Count()
+                };
+            }
+        }
+    }
+
+    /// <summary>
+    /// Represents a single indexed log entry.
+    /// </summary>
+    public class LogSearchEntry
+    {
+        public DateTime Timestamp { get; set; }
+        public LogLevel Level { get; set; }
+        public string Logger { get; set; }
+        public string Message { get; set; }
+        public string Exception { get; set; }
+        public string CorrelationId { get; set; }
+        public Dictionary<string, object> Properties { get; set; }
+    }
+
+    /// <summary>
+    /// Query builder for log searches.
+    /// </summary>
+    public class LogSearchQuery
+    {
+        public string Keyword { get; set; }
+        public LogLevel? Level { get; set; }
+        public string LoggerName { get; set; }
+        public string CorrelationId { get; set; }
+        public DateTime? FromUtc { get; set; }
+        public DateTime? ToUtc { get; set; }
+        public LogSearchSortBy SortBy { get; set; } = LogSearchSortBy.TimestampDescending;
+        public int Limit { get; set; } = 0; // 0 = no limit
+    }
+
+    /// <summary>
+    /// Sort options for log searches.
+    /// </summary>
+    public enum LogSearchSortBy
+    {
+        None = 0,
+        TimestampAscending = 1,
+        TimestampDescending = 2,
+        Level = 3,
+        Logger = 4
+    }
+
+    /// <summary>
+    /// Statistics about indexed logs.
+    /// </summary>
+    public class LogSearchStatistics
+    {
+        public int TotalLogs { get; set; }
+        public int Errors { get; set; }
+        public int Warnings { get; set; }
+        public int Infos { get; set; }
+        public DateTime OldestLog { get; set; }
+        public DateTime NewestLog { get; set; }
+        public int UniqueLooggers { get; set; }
+        public int UniqueCorrelationIds { get; set; }
+    }
+}

EonaCat.LogStack/EonaCatLoggerCore/Flows/DelegatingLoggerFlow.cs

@@ -0,0 +1,213 @@
+using EonaCat.LogStack.Core;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EonaCat.LogStack.Flows;
+
+// This file is part of the EonaCat project(s) which is released under the Apache License.
+// See the LICENSE file or go to https://EonaCat.com/License for full license details.
+
+/// <summary>
+/// A flow that delegates log events to another logger instance.
+/// This enables chaining multiple logger instances together, allowing logs to flow
+/// through different logging backends or implementations.
+/// </summary>
+public sealed class DelegatingLoggerFlow : FlowBase
+{
+    private readonly EonaCatLogStack _targetLogger;
+    private readonly Queue<LogEvent> _delegationQueue = new Queue<LogEvent>();
+    private readonly object _queueLock = new object();
+    private int _disposed;
+
+    /// <summary>
+    /// Creates a new delegating logger flow
+    /// </summary>
+    /// <param name="targetLogger">The logger to delegate log events to</param>
+    /// <param name="minimumLevel">The minimum log level to process</param>
+    public DelegatingLoggerFlow(
+        EonaCatLogStack targetLogger,
+        LogLevel minimumLevel = LogLevel.Trace)
+        : base($"DelegatingFlow({targetLogger?.GetType().Name ?? "UnknownLogger"})", minimumLevel)
+    {
+        _targetLogger = targetLogger ?? throw new ArgumentNullException(nameof(targetLogger));
+    }
+
+    /// <summary>
+    /// The target logger this flow delegates to
+    /// </summary>
+    public EonaCatLogStack TargetLogger => _targetLogger;
+
+    /// <summary>
+    /// Blasts (sends) a single log event to the target logger
+    /// </summary>
+    public override async Task<WriteResult> BlastAsync(LogEvent logEvent, CancellationToken cancellationToken = default)
+    {
+        if (!IsEnabled || !IsLogLevelEnabled(logEvent))
+        {
+            Interlocked.Increment(ref DroppedCount);
+            return WriteResult.LevelFiltered;
+        }
+
+        try
+        {
+            // Queue the event for delegation with cancellation support
+            lock (_queueLock)
+            {
+                if (_disposed != 0)
+                {
+                    Interlocked.Increment(ref DroppedCount);
+                    return WriteResult.Dropped;
+                }
+
+                _delegationQueue.Enqueue(logEvent);
+            }
+
+            // Delegate to the target logger's logging mechanism
+            // This is done asynchronously to prevent blocking
+            await Task.Run(() => DelegateLogEvent(logEvent), cancellationToken).ConfigureAwait(false);
+
+            Interlocked.Increment(ref BlastedCount);
+            return WriteResult.Success;
+        }
+        catch (Exception ex)
+        {
+            Interlocked.Increment(ref DroppedCount);
+            System.Diagnostics.Debug.WriteLine($"DelegatingLoggerFlow error: {ex.Message}");
+            return WriteResult.Failed;
+        }
+    }
+
+    /// <summary>
+    /// Blasts (sends) a batch of log events to the target logger
+    /// </summary>
+    public override async Task<WriteResult> BlastBatchAsync(ReadOnlyMemory<LogEvent> logEvents, CancellationToken cancellationToken = default)
+    {
+        if (!IsEnabled)
+        {
+            Interlocked.Add(ref DroppedCount, logEvents.Length);
+            return WriteResult.LevelFiltered;
+        }
+
+        var result = WriteResult.Success;
+        var eventsArray = logEvents.ToArray();
+
+        foreach (var logEvent in eventsArray)
+        {
+            try
+            {
+                if (IsLogLevelEnabled(logEvent))
+                {
+                    lock (_queueLock)
+                    {
+                        if (_disposed == 0)
+                        {
+                            _delegationQueue.Enqueue(logEvent);
+                        }
+                    }
+
+                    await Task.Run(() => DelegateLogEvent(logEvent), cancellationToken).ConfigureAwait(false);
+                    Interlocked.Increment(ref BlastedCount);
+                }
+                else
+                {
+                    Interlocked.Increment(ref DroppedCount);
+                }
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"DelegatingLoggerFlow batch error: {ex.Message}");
+                Interlocked.Increment(ref DroppedCount);
+                result = WriteResult.Failed;
+            }
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Flushes any pending log events to the target logger
+    /// </summary>
+    public override async Task FlushAsync(CancellationToken cancellationToken = default)
+    {
+        Queue<LogEvent> pendingEvents;
+        lock (_queueLock)
+        {
+            if (_delegationQueue.Count == 0)
+                return;
+
+            pendingEvents = new Queue<LogEvent>(_delegationQueue);
+            _delegationQueue.Clear();
+        }
+
+        // Process remaining events
+        foreach (var logEvent in pendingEvents)
+        {
+            try
+            {
+                DelegateLogEvent(logEvent);
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"DelegatingLoggerFlow flush error: {ex.Message}");
+            }
+        }
+
+        await Task.CompletedTask.ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Gets diagnostic information about this flow
+    /// </summary>
+    public override FlowDiagnostics GetDiagnostics()
+    {
+        var diagnostics = base.GetDiagnostics();
+        diagnostics.Name = $"{Name} (delegates to {TargetLogger.GetType().Name})";
+        return diagnostics;
+    }
+
+    private void DelegateLogEvent(LogEvent logEvent)
+    {
+        if (_disposed != 0)
+            return;
+
+        try
+        {
+            // Delegate by re-logging through the target logger using its public Log methods
+            // We reconstruct the logging call with the information from the LogEvent
+            var messageStr = logEvent.Message.ToString();
+
+            if (logEvent.Exception != null)
+            {
+                _targetLogger.Log(logEvent.Level, logEvent.Exception, messageStr);
+            }
+            else
+            {
+                _targetLogger.Log(messageStr, logEvent.Level);
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Failed to delegate log to target logger: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Disposes the flow and clears the delegation queue
+    /// </summary>
+    public override async ValueTask DisposeAsync()
+    {
+        if (Interlocked.CompareExchange(ref _disposed, 1, 0) != 0)
+            return;
+
+        await FlushAsync().ConfigureAwait(false);
+
+        lock (_queueLock)
+        {
+            _delegationQueue.Clear();
+        }
+
+        await base.DisposeAsync().ConfigureAwait(false);
+    }
+}

EonaCat.LogStack/EonaCatLoggerCore/ILoggerChain.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EonaCat.LogStack.Chaining;
+
+// This file is part of the EonaCat project(s) which is released under the Apache License.
+// See the LICENSE file or go to https://EonaCat.com/License for full license details.
+
+/// <summary>
+/// Defines the contract for chaining multiple logger instances together.
+/// Allows logs to be propagated through a chain of loggers, enabling the ability
+/// to change log libraries or add multiple logging backends together.
+/// </summary>
+public interface ILoggerChain : IAsyncDisposable
+{
+    /// <summary>
+    /// Gets the name/identifier of this logger chain
+    /// </summary>
+    string Name { get; }
+
+    /// <summary>
+    /// Gets the primary logger in the chain
+    /// </summary>
+    EonaCatLogStack Primary { get; }
+
+    /// <summary>
+    /// Gets the list of chained loggers that receive logs from the primary logger
+    /// </summary>
+    IReadOnlyList<EonaCatLogStack> ChainedLoggers { get; }
+
+    /// <summary>
+    /// Adds a logger to the chain. Logs will be propagated to this logger.
+    /// </summary>
+    /// <param name="logger">The logger to add to the chain</param>
+    /// <param name="chainAsFlow">If true, the logger will be added as a flow to the primary logger</param>
+    /// <returns>This instance for fluent chaining</returns>
+    ILoggerChain Add(EonaCatLogStack logger, bool chainAsFlow = true);
+
+    /// <summary>
+    /// Adds multiple loggers to the chain.
+    /// </summary>
+    /// <param name="loggers">The loggers to add</param>
+    /// <returns>This instance for fluent chaining</returns>
+    ILoggerChain AddRange(params EonaCatLogStack[] loggers);
+
+    /// <summary>
+    /// Removes a logger from the chain.
+    /// </summary>
+    /// <param name="logger">The logger to remove</param>
+    /// <returns>True if the logger was removed, false if it wasn't in the chain</returns>
+    bool Remove(EonaCatLogStack logger);
+
+    /// <summary>
+    /// Removes all loggers from the chain except the primary.
+    /// </summary>
+    void Clear();
+
+    /// <summary>
+    /// Gets the behavior when a chained logger fails
+    /// </summary>
+    LoggerChainErrorBehavior ErrorBehavior { get; set; }
+
+    /// <summary>
+    /// Flushes all loggers in the chain.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>A task representing the asynchronous flush operation</returns>
+    Task FlushAllAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Disables a specific logger in the chain temporarily
+    /// </summary>
+    /// <param name="logger">The logger to disable</param>
+    void DisableLogger(EonaCatLogStack logger);
+
+    /// <summary>
+    /// Enables a previously disabled logger in the chain
+    /// </summary>
+    /// <param name="logger">The logger to enable</param>
+    void EnableLogger(EonaCatLogStack logger);
+
+    /// <summary>
+    /// Gets the enabled state of a logger in the chain
+    /// </summary>
+    /// <param name="logger">The logger to check</param>
+    /// <returns>True if the logger is enabled, false otherwise</returns>
+    bool IsLoggerEnabled(EonaCatLogStack logger);
+}
+
+/// <summary>
+/// Specifies how the logger chain should behave when a chained logger encounters an error
+/// </summary>
+public enum LoggerChainErrorBehavior
+{
+    /// <summary>
+    /// Continue processing the chain even if a logger fails
+    /// </summary>
+    ContinueOnError = 0,
+
+    /// <summary>
+    /// Stop the chain if any logger fails
+    /// </summary>
+    StopOnError = 1,
+
+    /// <summary>
+    /// Skip the failed logger and continue with the rest
+    /// </summary>
+    SkipFailed = 2
+}
+
+/// <summary>
+/// Event arguments for logger chain events
+/// </summary>
+public sealed class LoggerChainEventArgs : EventArgs
+{
+    /// <summary>
+    /// The logger involved in the event
+    /// </summary>
+    public EonaCatLogStack Logger { get; set; }
+
+    /// <summary>
+    /// The event message
+    /// </summary>
+    public string Message { get; set; }
+
+    /// <summary>
+    /// An optional exception associated with the event
+    /// </summary>
+    public Exception? Exception { get; set; }
+}

EonaCat.LogStack/EonaCatLoggerCore/LoggerChain.cs

@@ -0,0 +1,370 @@
+using EonaCat.LogStack.Flows;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EonaCat.LogStack.Chaining;
+
+// This file is part of the EonaCat project(s) which is released under the Apache License.
+// See the LICENSE file or go to https://EonaCat.com/License for full license details.
+
+/// <summary>
+/// Implementation of ILoggerChain that enables chaining multiple logger instances together.
+/// Logs propagate through the primary logger to all chained loggers, allowing multiple
+/// logging backends to work in concert.
+/// </summary>
+public sealed class LoggerChain : ILoggerChain
+{
+    private readonly EonaCatLogStack _primary;
+    private readonly List<EonaCatLogStack> _chainedLoggers = new();
+    private readonly Dictionary<EonaCatLogStack, bool> _loggerStates = new();
+    private readonly object _chainLock = new object();
+    private int _disposed;
+
+    /// <summary>
+    /// Event raised when a logger is added to the chain
+    /// </summary>
+    public event EventHandler<LoggerChainEventArgs>? LoggerAdded;
+
+    /// <summary>
+    /// Event raised when a logger is removed from the chain
+    /// </summary>
+    public event EventHandler<LoggerChainEventArgs>? LoggerRemoved;
+
+    /// <summary>
+    /// Event raised when a logger fails
+    /// </summary>
+    public event EventHandler<LoggerChainEventArgs>? LoggerFailed;
+
+    public string Name { get; set; }
+    public EonaCatLogStack Primary => _primary;
+    public IReadOnlyList<EonaCatLogStack> ChainedLoggers
+    {
+        get
+        {
+            lock (_chainLock)
+            {
+                return new ReadOnlyCollection<EonaCatLogStack>(_chainedLoggers.ToList());
+            }
+        }
+    }
+
+    public LoggerChainErrorBehavior ErrorBehavior { get; set; } = LoggerChainErrorBehavior.ContinueOnError;
+
+    /// <summary>
+    /// Creates a new logger chain with the given primary logger
+    /// </summary>
+    /// <param name="primary">The primary logger that forms the base of the chain</param>
+    /// <param name="name">The name of the logger chain</param>
+    public LoggerChain(EonaCatLogStack primary, string name = "LoggerChain")
+    {
+        _primary = primary ?? throw new ArgumentNullException(nameof(primary));
+        Name = name ?? throw new ArgumentNullException(nameof(name));
+    }
+
+    /// <summary>
+    /// Adds a logger to the chain
+    /// </summary>
+    public ILoggerChain Add(EonaCatLogStack logger, bool chainAsFlow = true)
+    {
+        ThrowIfDisposed();
+
+        if (logger == null)
+            throw new ArgumentNullException(nameof(logger));
+
+        if (logger == _primary)
+            throw new InvalidOperationException("Cannot chain the primary logger to itself");
+
+        lock (_chainLock)
+        {
+            if (_chainedLoggers.Contains(logger))
+                return this; // Already in chain
+
+            _chainedLoggers.Add(logger);
+            _loggerStates[logger] = true; // Enabled by default
+
+            if (chainAsFlow)
+            {
+                // Add a delegating flow to the primary logger that forwards to this logger
+                var delegatingFlow = new DelegatingLoggerFlow(logger);
+                _primary.AddFlow(delegatingFlow);
+            }
+        }
+
+        LoggerAdded?.Invoke(this, new LoggerChainEventArgs
+        {
+            Logger = logger,
+            Message = $"Logger added to chain: {logger.GetType().Name}"
+        });
+
+        return this;
+    }
+
+    /// <summary>
+    /// Adds multiple loggers to the chain
+    /// </summary>
+    public ILoggerChain AddRange(params EonaCatLogStack[] loggers)
+    {
+        if (loggers == null)
+            throw new ArgumentNullException(nameof(loggers));
+
+        foreach (var logger in loggers)
+        {
+            Add(logger);
+        }
+
+        return this;
+    }
+
+    /// <summary>
+    /// Removes a logger from the chain
+    /// </summary>
+    public bool Remove(EonaCatLogStack logger)
+    {
+        ThrowIfDisposed();
+
+        if (logger == null)
+            return false;
+
+        lock (_chainLock)
+        {
+            bool removed = _chainedLoggers.Remove(logger);
+            if (removed)
+            {
+                _loggerStates.Remove(logger);
+                LoggerRemoved?.Invoke(this, new LoggerChainEventArgs
+                {
+                    Logger = logger,
+                    Message = $"Logger removed from chain: {logger.GetType().Name}"
+                });
+            }
+
+            return removed;
+        }
+    }
+
+    /// <summary>
+    /// Clears all chained loggers (keeps the primary)
+    /// </summary>
+    public void Clear()
+    {
+        ThrowIfDisposed();
+
+        lock (_chainLock)
+        {
+            _chainedLoggers.Clear();
+            _loggerStates.Clear();
+        }
+    }
+
+    /// <summary>
+    /// Flushes all loggers in the chain
+    /// </summary>
+    public async Task FlushAllAsync(CancellationToken cancellationToken = default)
+    {
+        ThrowIfDisposed();
+
+        List<EonaCatLogStack> loggers;
+        lock (_chainLock)
+        {
+            loggers = new List<EonaCatLogStack>(_chainedLoggers);
+        }
+
+        // Flush primary logger
+        await FlushLoggerAsync(_primary, cancellationToken).ConfigureAwait(false);
+
+        // Flush all chained loggers
+        foreach (var logger in loggers)
+        {
+            if (IsLoggerEnabled(logger))
+            {
+                await FlushLoggerAsync(logger, cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Disables a logger in the chain temporarily
+    /// </summary>
+    public void DisableLogger(EonaCatLogStack logger)
+    {
+        if (logger == null)
+            return;
+
+        lock (_chainLock)
+        {
+            if (_loggerStates.ContainsKey(logger))
+            {
+                _loggerStates[logger] = false;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Enables a disabled logger
+    /// </summary>
+    public void EnableLogger(EonaCatLogStack logger)
+    {
+        if (logger == null)
+            return;
+
+        lock (_chainLock)
+        {
+            if (_loggerStates.ContainsKey(logger))
+            {
+                _loggerStates[logger] = true;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets whether a logger is enabled
+    /// </summary>
+    public bool IsLoggerEnabled(EonaCatLogStack logger)
+    {
+        if (logger == null)
+            return false;
+
+        lock (_chainLock)
+        {
+            if (_loggerStates.TryGetValue(logger, out var enabled))
+            {
+                return enabled;
+            }
+
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Gets a snapshot of the current chain state
+    /// </summary>
+    public LoggerChainSnapshot GetSnapshot()
+    {
+        lock (_chainLock)
+        {
+            return new LoggerChainSnapshot
+            {
+                Name = Name,
+                PrimaryLoggerType = Primary?.GetType().Name,
+                ChainedLoggerCount = _chainedLoggers.Count,
+                EnabledLoggerCount = _loggerStates.Values.Count(s => s),
+                DisabledLoggerCount = _loggerStates.Values.Count(s => !s),
+                ErrorBehavior = ErrorBehavior,
+                ChainedLoggers = _chainedLoggers.Select(l => new LoggerChainLoggerInfo
+                {
+                    LoggerType = l.GetType().Name,
+                    IsEnabled = _loggerStates.TryGetValue(l, out var enabled) ? enabled : false
+                }).ToList()
+            };
+        }
+    }
+
+    private async Task FlushLoggerAsync(EonaCatLogStack logger, CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (logger is IAsyncDisposable disposable)
+            {
+                // Note: We flush through the logger's internal mechanisms
+                // This is handled by the logger's own async pipeline
+                await Task.CompletedTask.ConfigureAwait(false);
+            }
+        }
+        catch (Exception ex)
+        {
+            LoggerFailed?.Invoke(this, new LoggerChainEventArgs
+            {
+                Logger = logger,
+                Message = "Failed to flush logger",
+                Exception = ex
+            });
+
+            if (ErrorBehavior == LoggerChainErrorBehavior.StopOnError)
+                throw;
+        }
+    }
+
+    private void ThrowIfDisposed()
+    {
+        if (Interlocked.CompareExchange(ref _disposed, 0, 0) != 0)
+            throw new ObjectDisposedException(nameof(LoggerChain));
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (Interlocked.CompareExchange(ref _disposed, 1, 0) != 0)
+            return;
+
+        // Flush all loggers before disposing
+        await FlushAllAsync().ConfigureAwait(false);
+
+        lock (_chainLock)
+        {
+            _chainedLoggers.Clear();
+            _loggerStates.Clear();
+        }
+
+        GC.SuppressFinalize(this);
+    }
+}
+
+/// <summary>
+/// Represents a snapshot of the logger chain state
+/// </summary>
+public sealed class LoggerChainSnapshot
+{
+    /// <summary>
+    /// The name of the chain
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// The type name of the primary logger
+    /// </summary>
+    public string PrimaryLoggerType { get; set; }
+
+    /// <summary>
+    /// Total number of chained loggers
+    /// </summary>
+    public int ChainedLoggerCount { get; set; }
+
+    /// <summary>
+    /// Number of enabled loggers
+    /// </summary>
+    public int EnabledLoggerCount { get; set; }
+
+    /// <summary>
+    /// Number of disabled loggers
+    /// </summary>
+    public int DisabledLoggerCount { get; set; }
+
+    /// <summary>
+    /// The error behavior mode
+    /// </summary>
+    public LoggerChainErrorBehavior ErrorBehavior { get; set; }
+
+    /// <summary>
+    /// Information about each chained logger
+    /// </summary>
+    public List<LoggerChainLoggerInfo> ChainedLoggers { get; set; } = new();
+}
+
+/// <summary>
+/// Information about a single logger in the chain
+/// </summary>
+public sealed class LoggerChainLoggerInfo
+{
+    /// <summary>
+    /// The type name of the logger
+    /// </summary>
+    public string LoggerType { get; set; }
+
+    /// <summary>
+    /// Whether the logger is currently enabled
+    /// </summary>
+    public bool IsEnabled { get; set; }
+}

EonaCat.LogStack/LogBuilder.cs

@@ -1,4 +1,5 @@
 using EonaCat.LogStack.Boosters;
+using EonaCat.LogStack.Chaining;
 using EonaCat.LogStack.Core;
 using EonaCat.LogStack.EonaCatLogStackCore;
 using EonaCat.LogStack.EonaCatLogStackCore.Policies;
@@ -1461,4 +1462,37 @@ public sealed class LogBuilder
         return new Compatibility.EonaCatNLogAdapter(Build());
     }
 
+    /// <summary>
+    /// Creates a logger chain with this logger as the primary logger.
+    /// This enables chaining multiple logger instances together.
+    /// </summary>
+    /// <param name="chainName">Optional name for the logger chain</param>
+    /// <returns>A LoggerChain instance for fluent chaining</returns>
+    public Chaining.ILoggerChain BuildChain(string chainName = null)
+    {
+        var logger = Build();
+        var chainName_ = chainName ?? $"LoggerChain-{_category}";
+        return new Chaining.LoggerChain(logger, chainName_);
+    }
+
+    /// <summary>
+    /// Creates a logger and adds it to an existing logger chain.
+    /// </summary>
+    /// <param name="primaryLogger">The primary logger to chain this logger to</param>
+    /// <param name="chainAsFlow">If true, this logger is added as a flow to the primary logger</param>
+    /// <returns>The updated logger chain</returns>
+    public Chaining.ILoggerChain AddToChain(EonaCatLogStack primaryLogger, bool chainAsFlow = true)
+    {
+        if (primaryLogger == null)
+            throw new ArgumentNullException(nameof(primaryLogger));
+
+        var newLogger = Build();
+
+        // Create or use existing chain
+        var chain = new Chaining.LoggerChain(primaryLogger, $"LoggerChain-{primaryLogger.GetType().Name}");
+        chain.Add(newLogger, chainAsFlow);
+
+        return chain;
+    }
+
 }

README.md

@@ -1,7 +1,13 @@
-# EonaCat.LogStack
+# EonaCat.LogStack 📊
 
-**EonaCat.LogStack** is a flow-based, high-performance logging library for .NET, designed for zero-allocation logging paths and superior memory efficiency. 
+**EonaCat.LogStack** is a flow-based, high-performance logging library for .NET built for production environments. It features zero-allocation hot paths, superior memory efficiency, and a rich fluent API for routing log events to 50+ destinations including console, file, Slack, Discord, Redis, Elasticsearch, databases, and more.
-It features a rich fluent API for routing log events to dozens of destinations - from console and file to Slack, Discord, Redis, Elasticsearch, and beyond.
+
+**Comprehensive Suite Includes:**
+- **Core Library** - High-performance logging engine with flows and boosters
+- **LogClient** - Centralized remote logging client for distributed systems  
+- **Status Service** - Self-hosted monitoring, log aggregation, and health dashboard
+- **Windows Event Log Flow** - Enterprise Windows event log integration
+- **OpenTelemetry Flow** - Observability and distributed tracing support
 
 ## Features
 
@@ -3615,3 +3621,366 @@ EonaCat.LogStack combines:
 - Security-focused audit logging
 
 The library is designed to scale from small console tools to distributed production services.
+
+
+---
+
+## Complete Code Examples
+
+### Example 1: Production ASP.NET Core Application
+
+```csharp
+using EonaCat.LogStack;
+
+// In Program.cs
+var builder = WebApplication.CreateBuilder(args);
+
+// Add EonaCat logging
+builder.Services.AddEonaCatLogging(config =>
+{
+	config
+		.WithApplicationName("MyApi")
+		.WithMinimumLevel(LogLevel.Information)
+		.WriteToConsole(useColors: true)
+		.WriteToFile(
+			directory: "./logs",
+			maxFileSize: 100 * 1024 * 1024,
+			maxDirectorySize: 5L * 1024 * 1024 * 1024,
+			compression: CompressionFormat.GZip)
+		.WriteToSlack(
+			webhookUrl: builder.Configuration["Slack:WebhookUrl"],
+			minimumLevel: LogLevel.Error)
+		.WriteToElasticSearch(
+			elasticSearchUrl: builder.Configuration["Elasticsearch:Url"],
+			indexName: "myapi-logs")
+		.BoostWithMachineName()
+		.BoostWithProcessId()
+		.BoostWithCorrelationId()
+		.BoostWithCallerInfo();
+});
+
+// Enable advanced telemetry
+builder.Services.AddEonaCatNamedLoggers(new LoggerDIOptions
+{
+	EnableTelemetry = true,
+	EnableTracing = true,
+	EnablePerformanceMonitoring = true,
+	EnableHealthMonitoring = true
+});
+
+builder.Services.AddEonaCatTracing();
+
+var app = builder.Build();
+app.UseHttpsRedirection();
+app.UseRouting();
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+
+var logger = app.Services.GetRequiredService<ILoggerFactory>()
+	.CreateLogger("Application");
+
+logger.Information("Application starting", 
+	("Version", "1.0.0"),
+	("Environment", app.Environment.EnvironmentName));
+
+app.Run();
+```
+
+### Example 2: Console Application with Multiple Flows
+
+```csharp
+using EonaCat.LogStack;
+
+class Program
+{
+	static async Task Main(string[] args)
+	{
+		await using var logger = new LogBuilder("ConsoleApp")
+			.WithMinimumLevel(LogLevel.Debug)
+			.WithTimestampMode(TimestampMode.Utc)
+			.WriteToConsole(useColors: true)
+			.WriteToFile("./logs", filePrefix: "app", maxFileSize: 50 * 1024 * 1024)
+			.WriteToAudit("./audit", auditLevel: AuditLevel.WarningAndAbove)
+			.WriteToMemory(capacity: 100)
+			.WriteToEmail(
+				smtpHost: "smtp.gmail.com", smtpPort: 587, useSsl: true,
+				username: "email@gmail.com", password: "app-password",
+				from: "logs@company.com", to: "admin@company.com",
+				subjectPrefix: "[CRITICAL]", minimumLevel: LogLevel.Critical)
+			.RedisFlow(host: "redis.local", channel: "myapp:logs")
+			.BoostWithMachineName()
+			.BoostWithProcessId()
+			.BoostWithCorrelationId()
+			.Build();
+
+		try
+		{
+			logger.Information("Application started");
+			await ProcessDataAsync(logger);
+			logger.Information("Application completed successfully");
+		}
+		catch (Exception ex)
+		{
+			logger.Critical(ex, "Unhandled exception");
+		}
+		finally
+		{
+			await logger.FlushAsync();
+		}
+	}
+
+	static async Task ProcessDataAsync(ILogger logger)
+	{
+		logger.Information("Processing started");
+		logger.Debug("Starting batch", ("BatchId", 123), ("Count", 5000));
+		await Task.Delay(1000);
+		logger.Information("Batch processed", ("Imported", 4998), ("Errors", 2));
+	}
+}
+```
+
+### Example 3: Service with Dependency Injection & Telemetry
+
+```csharp
+using EonaCat.LogStack;
+using Microsoft.Extensions.DependencyInjection;
+
+public class OrderService
+{
+	private readonly ILogger _logger;
+	private readonly ITelemetryAggregator _telemetry;
+	private readonly ISpanFactory _spans;
+
+	public OrderService(ILogger logger, ITelemetryAggregator telemetry, ISpanFactory spans)
+	{
+		_logger = logger;
+		_telemetry = telemetry;
+		_spans = spans;
+	}
+
+	public async Task<Order> ProcessOrderAsync(string orderId, decimal amount)
+	{
+		using var span = _spans.CreateSpanScope("ProcessOrder");
+		span.SetAttribute("OrderId", orderId);
+
+		try
+		{
+			_logger.Information("Processing order", ("OrderId", orderId), ("Amount", amount));
+			_telemetry.RecordCounter("orders.started", 1);
+
+			var order = new Order { Id = orderId, Amount = amount };
+			await Task.Delay(500);
+
+			_logger.Information("Order processed", ("Status", "Completed"));
+			_telemetry.RecordCounter("orders.completed", 1);
+			_telemetry.RecordGauge("order.revenue", amount);
+			return order;
+		}
+		catch (Exception ex)
+		{
+			_telemetry.RecordCounter("orders.failed", 1);
+			span.RecordException(ex);
+			_logger.Error(ex, "Order processing failed", ("OrderId", orderId));
+			throw;
+		}
+	}
+}
+
+class Program
+{
+	static async Task Main(string[] args)
+	{
+		var services = new ServiceCollection();
+
+		services.AddEonaCatLogging(config =>
+		{
+			config
+				.WithApplicationName("OrderService")
+				.WriteToConsole()
+				.WriteToFile("./logs")
+				.WriteToDatabase(
+					connectionFactory: () => new SqlConnection("Server=.;Database=Logs;"),
+					tableName: "OrderLogs")
+				.BoostWithCorrelationId();
+		});
+
+		services.AddEonaCatTelemetryAggregation();
+		services.AddEonaCatTracing();
+		services.AddScoped<OrderService>();
+
+		var sp = services.BuildServiceProvider();
+		var orderService = sp.GetRequiredService<OrderService>();
+		var order = await orderService.ProcessOrderAsync("ORD-001", 99.99m);
+
+		var telemetry = sp.GetRequiredService<ITelemetryAggregator>();
+		var snapshot = telemetry.GetSnapshot();
+		Console.WriteLine($"Completed: {snapshot.RecordedMetrics["orders.completed"]}");
+	}
+}
+
+record Order { public required string Id { get; init; } public required decimal Amount { get; init; } }
+```
+
+### Example 4: Advanced Resilience Patterns
+
+```csharp
+using EonaCat.LogStack;
+
+await using var logger = new LogBuilder("ResilientApp")
+	.WriteToConsole()
+	// Retry with exponential backoff
+	.WriteToRetry(
+		primary: cfg => cfg.WriteToHttp("https://primary-logs.company.com/ingest", batchSize: 50),
+		maxRetries: 3, initialDelayMs: 1000, maxDelayMs: 30000)
+	// Failover to secondary
+	.WriteToFailover(
+		primary: cfg => cfg.WriteToElasticSearch("https://es-primary.company.com:9200", "logs"),
+		secondary: cfg => cfg.WriteToFile("./logs/failover"),
+		recoveryCheckIntervalSeconds: 60)
+	// Rate limiting with deduplication
+	.WriteToThrottled(
+		target: cfg => cfg.WriteToSlack("https://hooks.slack.com/...", LogLevel.Warning),
+		requestsPerSecond: 10, enableDeduplication: true, minimumLevel: LogLevel.Warning)
+	// Circuit breaker
+	.WriteToCircuitBreaker(
+		inner: cfg => cfg.WriteToDatabase(() => new SqlConnection("..."), "Logs"),
+		failureThreshold: 5, successThresholdToClose: 3, timeoutSeconds: 60)
+	.Build();
+
+logger.Information("Started with resilience");
+logger.Error(new Exception("Test"), "Error occurred");
+```
+
+### Example 5: Remote Logging with LogClient
+
+```csharp
+using EonaCat.LogStack.LogClient;
+
+var clientOptions = new LogCentralOptions
+{
+	ServerUrl = "https://logcentral.company.com",
+	ApiKey = "your-api-key",
+	ApplicationName = "DistributedService",
+	ApplicationVersion = "2.1.0",
+	Environment = "Production",
+	BatchSize = 100,
+	FlushIntervalSeconds = 5
+};
+
+await using var logger = new LogBuilder("DistributedApp")
+	.WriteToConsole()
+	.WriteToFile("./logs")
+	.WriteToHttp(
+		endpoint: $"{clientOptions.ServerUrl}/api/logs/ingest",
+		batchSize: clientOptions.BatchSize,
+		headers: new Dictionary<string, string>
+		{
+			["X-API-Key"] = clientOptions.ApiKey,
+			["X-App-Name"] = clientOptions.ApplicationName
+		})
+	.BoostWithMachineName()
+	.Build();
+
+logger.Information("Connected to central logging", ("Server", clientOptions.ServerUrl));
+```
+
+### Example 6: Log Processing and Analysis
+
+```csharp
+using EonaCat.LogStack;
+
+await using var logger = new LogBuilder("AnalysisApp")
+	.WriteToConsole()
+	.WriteToMemory(capacity: 10000)
+	.Build();
+
+for (int i = 0; i < 100; i++)
+{
+	if (i % 10 == 0)
+		logger.Warning($"Iteration {i}");
+	else
+		logger.Information($"Processing item {i}");
+}
+
+var memoryFlow = logger.GetFlowOfType<MemoryFlow>();
+var events = memoryFlow.GetEvents();
+
+var errorCount = events.Count(e => e.Level == LogLevel.Error);
+var warningCount = events.Count(e => e.Level == LogLevel.Warning);
+Console.WriteLine($"Errors: {errorCount}, Warnings: {warningCount}");
+```
+
+### Example 7: Custom Modifiers for Universal Enrichment
+
+```csharp
+using EonaCat.LogStack;
+
+var requestId = "REQ-" + Guid.NewGuid().ToString().Substring(0, 8);
+var userId = "USER-123";
+
+await using var logger = new LogBuilder("EnrichedApp")
+	.WriteToConsole()
+	.WriteToFile("./logs")
+	.AddModifier((ref LogEventBuilder builder) =>
+	{
+		builder.WithProperty("RequestId", requestId);
+		builder.WithProperty("UserId", userId);
+		builder.WithProperty("Host", Environment.MachineName);
+	})
+	.Build();
+
+logger.Information("Operation started");
+logger.Warning("Potential issue detected");
+logger.Error(new Exception("Failed"), "Operation failed");
+
+// All logs automatically include RequestId, UserId, Host
+```
+
+### Example 8: Structured Logging and Complex Properties
+
+```csharp
+using EonaCat.LogStack;
+
+await using var logger = new LogBuilder("StructuredApp")
+	.WriteToConsole()
+	.WriteToFile("./logs", outputFormat: FileOutputFormat.Json)
+	.Build();
+
+// Simple tuple properties (fast)
+logger.Information("User action", 
+	("UserId", 42), 
+	("Action", "login"), 
+	("Ip", "192.168.1.1"));
+
+// Dictionary properties
+var contextDict = new Dictionary<string, object>
+{
+	{ "OrderId", "ORD-123" },
+	{ "Items", 5 },
+	{ "Total", 199.99m }
+};
+logger.Information("Order processed", contextDict);
+
+// Exception with context
+try
+{
+	throw new InvalidOperationException("Database connection failed");
+}
+catch (Exception ex)
+{
+	logger.Error(ex, "Operation failed",
+		("Retries", 3),
+		("TimeoutMs", 5000),
+		("DatabaseName", "ProductDb"));
+}
+```
+
+---
+
+## Additional Resources
+
+- **[GitHub Repository](https://git.saey.me/EonaCat/EonaCat.logstack)** - Source code and issues
+- **[NuGet Package](https://www.nuget.org/packages/EonaCat.LogStack)** - Official package
+- **[Supported Targets](#supported-targets)** - .NET versions and frameworks
+- **[Installation](#installation)** - Getting started guide