Serilog结构化日志：原理、实践与性能优化

1. 为什么需要结构化日志

第一次接触Serilog时，我正被传统文本日志折磨得够呛。那天凌晨3点，为了排查一个线上问题，我不得不逐行分析2GB的日志文件，用各种正则表达式匹配关键信息。这种经历让我深刻认识到：在分布式系统和微服务架构中，传统文本日志就像把数据扔进黑洞。

结构化日志与传统文本日志的本质区别在于数据组织形式。举个例子，传统日志可能是这样的：

code复制2023-08-15 14:30:22 [INFO] User login failed for user123 from 192.168.1.100

而结构化日志是这样的：

json复制{
  "Timestamp": "2023-08-15T14:30:22Z",
  "Level": "Information",
  "MessageTemplate": "User login failed for {Username} from {IpAddress}",
  "Properties": {
    "Username": "user123",
    "IpAddress": "192.168.1.100",
    "SourceContext": "AuthenticationService",
    "RequestId": "a1b2c3d4"
  }
}

关键认知：结构化日志不是简单的格式变化，而是将日志事件转化为可查询的数据结构。这就像把杂乱无章的纸质档案变成数据库记录。

2. Serilog核心架构解析

2.1 管道式日志处理模型

Serilog采用独特的管道处理模式，整个日志流程分为四个阶段：

1. 日志收集：通过Logger.Write()方法创建LogEvent
2. 属性增强：通过Enrichers添加上下文信息
3. 格式处理：通过Formatters决定输出结构
4. 持久化：通过Sinks写入目标存储

这种设计带来的最大优势是各环节解耦。比如我们可以在不修改业务代码的情况下，仅通过配置就实现：

• 为所有日志添加机器名环境变量
• 将开发环境的日志输出到控制台同时生产环境写入Elasticsearch
• 对敏感信息进行自动脱敏

2.2 关键组件选型指南

Sink选择矩阵：

Enricher实战案例：

csharp复制Log.Logger = new LoggerConfiguration()
    .Enrich.WithProperty("Application", "OrderService")
    .Enrich.WithMachineName()
    .Enrich.WithThreadId()
    .Enrich.WithCorrelationId() // 自定义扩展
    .CreateLogger();

3. 工程化落地实践

3.1 配置即代码的最佳实践

Serilog的强类型配置方式让日志策略变得可维护。这是我在电商项目中使用的分层配置：

csharp复制public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .UseSerilog((context, config) =>
        {
            var template = "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj} {NewLine}{Exception}";
            
            config.MinimumLevel.Debug()
                .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                .MinimumLevel.Override("System", LogEventLevel.Error)
                .Enrich.FromLogContext()
                .WriteTo.Console(outputTemplate: template)
                .WriteTo.File(
                    path: "logs/webapi-.log",
                    rollingInterval: RollingInterval.Day,
                    retainedFileCountLimit: 7,
                    outputTemplate: template);
                
            if (context.HostingEnvironment.IsProduction())
            {
                config.WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri("http://es-cluster:9200"))
                {
                    AutoRegisterTemplate = true,
                    IndexFormat = "webapi-{0:yyyy.MM}"
                });
            }
        });

3.2 性能优化关键参数

在高并发场景下，这几个参数直接影响系统吞吐量：

1. 批量提交配置（针对网络Sink）：

csharp复制.WriteTo.Elasticsearch(new ElasticsearchSinkOptions(...)
{
    BatchPostingLimit = 50,      // 每批日志条数
    Period = TimeSpan.FromSeconds(2), // 提交间隔
    QueueSizeLimit = 10000       // 内存队列容量
})

2. 异步写入模式：

csharp复制.WriteTo.Async(a => a.File("logs/app.log"))

3. 日志采样策略：

csharp复制.Configuration(c => c
    .MinimumLevel.Information()
    .WriteTo.Logger(lc => lc
        .Filter.ByIncludingOnly(e => e.Level == LogEventLevel.Information)
        .SampleEvery(5)  // 每5条采样1条
        .WriteTo.File("logs/info-sample.log"))
)

4. 诊断与问题排查

4.1 典型问题处理手册

问题1：日志丢失

• 检查点：异步队列是否溢出、Sink的异常处理、网络连通性
• 诊断命令：

  powershell复制# 查看Serilog自诊断日志
  Serilog.Debugging.SelfLog.Enable(msg => Console.Error.WriteLine(msg));
  

问题2：Elasticsearch写入慢

• 优化方案：
  • 调整BatchPostingLimit和Period参数平衡实时性与吞吐量
  • 启用Gzip压缩：ModifyConnectionSettings = c => c.EnableHttpCompression()
  • 使用指数退避重试策略

问题3：敏感信息泄露

• 解决方案：

  csharp复制.Destructure.ByTransforming<CreditCard>(cc => new { 
      cc.Last4Digits, 
      MaskedNumber = new string('*', cc.Number.Length - 4) + cc.Number.Substring(cc.Number.Length - 4) 
  })
  

4.2 监控指标设计

建议采集这些关键指标构建日志健康度仪表盘：

5. 进阶应用场景

5.1 分布式追踪集成

通过LogContext实现跨服务调用链追踪：

csharp复制using (LogContext.PushProperty("TraceId", Guid.NewGuid()))
{
    // 所有在此范围内的日志都会自动携带TraceId
    Log.Information("Processing order {OrderId}", order.Id);
}

配合OpenTelemetry实现全链路追踪：

csharp复制services.AddOpenTelemetryTracing(builder =>
    builder.AddSource("MyApp")
        .SetResourceBuilder(ResourceBuilder.CreateDefault()
            .AddService("OrderService"))
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSerilogInstrumentation()  // 关键集成点
        .AddJaegerExporter());

5.2 日志驱动开发

利用Serilog的断言功能实现契约检查：

csharp复制public class InventoryService
{
    public void DeductStock(string itemId, int quantity)
    {
        Log.ForContext("ItemId", itemId)
           .ForContext("Quantity", quantity)
           .Debug("Precondition check");
        
        if (quantity <= 0)
        {
            var ex = new ArgumentException("Quantity must be positive");
            Log.Error(ex, "Invalid quantity");
            throw ex;
        }
        
        // 业务逻辑...
    }
}

配合测试框架的日志验证：

csharp复制[Fact]
public void Should_log_warning_when_inventory_low()
{
    var logEvents = new List<LogEvent>();
    using (var logCapture = new LogCapture(logEvents))
    {
        // 执行测试操作
        _service.CheckInventory("item123");
        
        // 验证日志
        Assert.Contains(logEvents, 
            e => e.Level == LogEventLevel.Warning 
                && e.MessageTemplate.Text.Contains("Low stock"));
    }
}

6. 性能对比实测数据

在AWS c5.large实例上进行的基准测试（100万条日志）：

关键发现：

• 异步写入比同步模式快40%-60%
• 网络Sink的批量大小对性能影响显著（建议50-100条/批）
• 采样策略在高频日志场景下可提升5倍吞吐量

7. 容器化部署方案

7.1 Docker最佳实践

优化后的Dockerfile配置要点：

dockerfile复制FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
# 禁用控制台日志彩色输出（减少传输数据量）
ENV SERILOG__WRITETO__0__NAME=Console
ENV SERILOG__WRITETO__0__ARGS__OUTPUTTEMPLATE="[{Timestamp:o} {Level:u3}] {Message}{NewLine}{Exception}"
ENV SERILOG__WRITETO__0__ARGS__THEME=Plain

7.2 Kubernetes日志收集

使用Fluent Bit进行边车模式收集：

yaml复制apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: app
        volumeMounts:
        - name: logs
          mountPath: /app/logs
      - name: fluent-bit
        image: fluent/fluent-bit
        volumeMounts:
        - name: logs
          mountPath: /app/logs
        - name: config
          mountPath: /fluent-bit/etc
      volumes:
      - name: logs
        emptyDir: {}
      - name: config
        configMap:
          name: fluent-bit-config

对应的Fluent Bit配置：

ini复制[INPUT]
    Name              tail
    Path              /app/logs/*.log
    Tag               kube.app.*
    Mem_Buf_Limit     5MB
    Skip_Long_Lines   On

[OUTPUT]
    Name              es
    Match             *
    Host              elasticsearch
    Port              9200
    Logstash_Format   On
    Replace_Dots      On
    Retry_Limit       False

8. 安全合规实践

8.1 GDPR合规方案

实现自动数据脱敏的Enricher：

csharp复制public class GdprEnricher : ILogEventEnricher
{
    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
    {
        foreach (var prop in logEvent.Properties.Where(p => 
            p.Key.Contains("Email") || p.Key.Contains("Phone")))
        {
            var original = prop.Value.ToString();
            var masked = original.Length > 4 
                ? new string('*', original.Length - 4) + original.Substring(original.Length - 4)
                : "****";
                
            logEvent.AddOrUpdateProperty(propertyFactory
                .CreateProperty(prop.Key, masked));
        }
    }
}

8.2 审计日志特殊处理

审计日志需要独立配置：

csharp复制var auditLogger = new LoggerConfiguration()
    .WriteTo.File(
        path: "/secure/audit.log",
        restrictedToMinimumLevel: LogEventLevel.Information,
        fileSizeLimitBytes: 10_000_000,
        rollOnFileSizeLimit: true,
        shared: false)  // 禁止共享文件句柄
    .AuditTo.Sink(new AuditSink()) // 自定义审计Sink
    .CreateLogger();

关键安全措施：

• 使用单独的文件存储且禁用自动清理
• 设置严格的文件权限（600）
• 启用日志文件完整性校验
• 采用非对称加密签名重要审计事件

9. 团队协作规范

9.1 日志约定模板

制定团队统一的日志规范：

markdown复制# 日志消息编写指南

1. **消息模板**：
   - 动作现在时："Processing order {OrderId}"
   - 错误场景："Failed to process payment for {OrderId}"

2. **属性命名**：
   - 驼峰命名法：userId 而非 user_id
   - 类型后缀：durationMs, countItems

3. **级别标准**：
   - Debug: 开发调试信息
   - Info: 重要业务流程节点
   - Warning: 可自恢复的异常
   - Error: 需要干预的故障

9.2 Code Review检查清单

日志相关的CR要点：

• [ ] 是否所有异常都有Error级别日志？
• [ ] 敏感信息是否已脱敏？
• [ ] 日志消息是否可定位问题（包含足够上下文）？
• [ ] 高频日志是否添加了采样策略？
• [ ] 动态属性是否使用正确（@ vs $）？

10. 迁移策略指南

10.1 从NLog迁移

分阶段迁移方案：

1. 并行运行阶段：

   csharp复制var serilog = new LoggerConfiguration()
       .WriteTo.Console()
       .CreateLogger();
   
   var nlog = NLog.LogManager.GetCurrentClassLogger();
   
   // 适配器模式
   public class HybridLogger : ILogger
   {
       public void Log(string message)
       {
           serilog.Information(message);
           nlog.Info(message);
       }
   }
   

2. 逐步替换阶段：

   • 先替换业务代码中的日志调用
   • 再替换基础设施层的日志配置
   • 最后移除NLog包依赖

10.2 从log4net迁移

配置文件转换对照表：

特殊场景处理：

• 将log4net的NDC（嵌套诊断上下文）转换为Serilog的LogContext
• 自定义Enricher模拟log4net的GlobalContext特性

11. 成本优化实践

11.1 日志存储优化

Elasticsearch索引策略示例：

csharp复制.WriteTo.Elasticsearch(new ElasticsearchSinkOptions(...)
{
    IndexFormat = "logs-{0:yyyy.MM.dd}",
    TemplateName = "serilog-template",
    OverwriteTemplate = true,
    NumberOfShards = 2,  // 根据数据量调整
    NumberOfReplicas = 1 // 非生产环境可设为0
})

配套的ILM（索引生命周期管理）策略：

json复制PUT _ilm/policy/logs_policy
{
  "policy": {
    "phases": {
      "hot": {
        "actions": {
          "rollover": {
            "max_size": "50GB",
            "max_age": "7d"
          }
        }
      },
      "delete": {
        "min_age": "30d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

11.2 云服务成本控制

AWS CloudWatch日志组配置建议：

csharp复制.WriteTo.AmazonCloudWatch(
    logGroup: "/app/prod",
    logStreamNameProvider: new DefaultLogStreamProvider(),
    options: new CloudWatchSinkOptions
    {
        BatchSizeLimit = 100,
        Period = TimeSpan.FromSeconds(10),
        QueueSizeLimit = 10_000,
        RetryAttempts = 3
    })

成本优化技巧：

• 设置合理的日志保留期（开发环境7天，生产环境30天）
• 对DEBUG级别日志启用采样
• 使用日志过滤器减少不必要的数据上传
• 为不同级别的日志创建不同的日志组（便于设置差异化保留策略）

12. 异常处理最佳实践

12.1 结构化异常日志

正确记录异常的方式：

csharp复制try
{
    // 业务代码
}
catch (Exception ex)
{
    Log.Error(ex, "Failed to process order {OrderId} for user {UserId}", 
        order.Id, user.Id);
    
    // 附加上下文信息
    ex.Data["OrderId"] = order.Id;
    ex.Data["UserId"] = user.Id;
    throw;
}

12.2 全局异常过滤器

ASP.NET Core中的实现：

csharp复制public class LoggingExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        var log = Log.ForContext("RequestPath", context.HttpContext.Request.Path);
        
        log.Error(context.Exception, "Unhandled exception occurred");
        
        // 为客户端返回简化错误信息
        context.Result = new ObjectResult(new {
            Error = "An unexpected error occurred",
            Reference = Guid.NewGuid() // 用于关联日志
        }) {
            StatusCode = 500
        };
    }
}

注册过滤器：

csharp复制services.AddControllers(options => 
{
    options.Filters.Add<LoggingExceptionFilter>();
});

13. 性能关键路径日志

13.1 耗时监控实现

使用计时器记录关键操作：

csharp复制public async Task ProcessOrderAsync(Order order)
{
    var sw = Stopwatch.StartNew();
    try
    {
        using (LogContext.PushProperty("OrderProcessing", new { order.Id, order.Total }))
        {
            Log.Debug("Starting order processing");
            
            // 业务逻辑...
            
            Log.Information("Completed order processing in {ElapsedMs}ms", 
                sw.ElapsedMilliseconds);
        }
    }
    finally
    {
        Metrics.Default.Record("order.processing.time", sw.ElapsedMilliseconds);
    }
}

13.2 热路径优化

高频日志的优化技巧：

1. 使用预编译的消息模板：

   csharp复制private static readonly Action<ILogger, int, Exception> _orderProcessed = 
       LoggerMessage.Define<int>(
           LogLevel.Information,
           new EventId(1001, "OrderProcessed"),
           "Processed {OrderCount} orders");
   
   // 使用时
   _orderProcessed(logger, orders.Count, null);
   

2. 避免昂贵的属性计算：

   csharp复制// 错误方式（即使日志不输出也会执行ToString）
   Log.Debug($"Order details: {order.ToJson()}"); 
   
   // 正确方式
   Log.Debug("Order details: {@Order}", order); // 延迟计算
   

14. 多环境策略配置

14.1 环境差异化配置

通过appsettings.json实现：

json复制{
  "Serilog": {
    "Using": ["Serilog.Sinks.Console"],
    "MinimumLevel": {
      "Default": "Information",
      "Override": {
        "Microsoft": "Warning",
        "System": "Warning"
      }
    },
    "Enrich": ["FromLogContext"],
    "WriteTo": [
      {
        "Name": "Console",
        "Args": {
          "outputTemplate": "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"
        }
      },
      {
        "Name": "File",
        "Args": {
          "path": "logs/app.log",
          "rollingInterval": "Day"
        }
      }
    ]
  },
  "Serilog:Production": {
    "WriteTo": [
      {
        "Name": "Elasticsearch",
        "Args": {
          "nodeUris": "http://es-prod:9200"
        }
      }
    ]
  }
}

加载配置：

csharp复制var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var config = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddJsonFile($"appsettings.{env}.json", optional: true)
    .Build();

Log.Logger = new LoggerConfiguration()
    .ReadFrom.Configuration(config)
    .CreateLogger();

14.2 功能开关控制

动态调整日志级别：

csharp复制// 通过API动态修改日志级别
app.MapPost("/log-level", (LogLevel level) =>
{
    var levelSwitch = new LoggingLevelSwitch();
    levelSwitch.MinimumLevel = level;
    
    Log.Logger = new LoggerConfiguration()
        .MinimumLevel.ControlledBy(levelSwitch)
        .WriteTo.Console()
        .CreateLogger();
});

15. 客户端日志集成

15.1 浏览器日志收集

前端与后端日志关联方案：

javascript复制// 前端生成唯一追踪ID
const traceId = crypto.randomUUID();

// 发送到后端时携带header
fetch('/api/orders', {
    headers: {
        'X-Trace-Id': traceId
    }
});

// 前端日志记录
window.logger = {
    info: (message, data) => {
        console.log(JSON.stringify({
            timestamp: new Date().toISOString(),
            level: 'INFO',
            message,
            traceId,
            data
        }));
    }
};

后端关联处理：

csharp复制app.Use(async (context, next) =>
{
    var traceId = context.Request.Headers["X-Trace-Id"].FirstOrDefault() 
        ?? Guid.NewGuid().ToString();
    
    using (LogContext.PushProperty("TraceId", traceId))
    {
        await next();
    }
});

15.2 移动端日志策略

Xamarin/iOS/Android统一方案：

csharp复制// 共享日志配置
public static ILogger CreateMobileLogger()
{
    return new LoggerConfiguration()
        .Enrich.WithProperty("DeviceId", DeviceInfo.Id)
        .Enrich.WithProperty("Platform", DeviceInfo.Platform)
        .WriteTo.Sink(new MobileSink()) // 自定义Sink处理平台差异
        .CreateLogger();
}

// Android特定配置
#if ANDROID
Log.Logger = CreateMobileLogger()
    .WriteTo.AndroidLog()
    .CreateLogger();
#endif

// iOS特定配置
#if IOS
Log.Logger = CreateMobileLogger()
    .WriteTo.NSLog()
    .CreateLogger();
#endif

16. 日志分析进阶技巧

16.1 Elasticsearch查询示例

常见分析场景的KQL查询：

1. 错误趋势分析：

kibana复制level:Error AND service:Payment 
| timechart span=1h count() by exception_type

2. 性能瓶颈定位：

kibana复制message:"Completed * in *ms" 
| parse "Completed * in {duration:int}ms" 
| stats avg(duration), p95(duration) by operation_name
| sort avg(duration) desc

3. 业务指标提取：

kibana复制message:"Order created *" 
| parse "Order created {order_id} for {customer_id}" 
| stats dc(order_id) as daily_orders by customer_id
| sort daily_orders desc

16.2 Seq仪表盘配置

关键面板配置建议：

1. 服务健康度看板：

   • 错误日志实时流
   • 按服务分组的错误率趋势图
   • 最近10个关键错误列表

2. 性能监控看板：

   • 接口响应时间百分位图
   • 数据库查询耗时热力图
   • 消息队列处理延迟趋势

3. 业务分析看板：

   • 用户行为漏斗分析
   • 交易成功率地图分布
   • 营销活动转化率对比

17. 日志与监控系统集成

17.1 Prometheus指标暴露

通过日志生成自定义指标：

csharp复制public class MetricsEnricher : ILogEventEnricher
{
    private readonly Counter _errorCounter;
    
    public MetricsEnricher()
    {
        _errorCounter = Metrics.CreateCounter(
            "log_errors_total", 
            "Total error logs",
            new CounterConfiguration
            {
                LabelNames = new[] { "service" }
            });
    }
    
    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
    {
        if (logEvent.Level == LogEventLevel.Error)
        {
            var service = logEvent.Properties.TryGetValue("SourceContext", out var value) 
                ? value.ToString().Trim('"') 
                : "unknown";
                
            _errorCounter.WithLabels(service).Inc();
        }
    }
}

17.2 告警规则配置

Grafana告警规则示例：

yaml复制groups:
- name: logging-alerts
  rules:
  - alert: HighErrorRate
    expr: rate(log_errors_total{service="PaymentService"}[5m]) > 5
    for: 10m
    labels:
      severity: critical
    annotations:
      summary: "High error rate in {{ $labels.service }}"
      description: "Error rate is {{ $value }} errors/min"

18. 定制化扩展开发

18.1 自定义Sink开发

实现一个推送到Kafka的Sink：

csharp复制public class KafkaSink : ILogEventSink
{
    private readonly IProducer<Null, string> _producer;
    private readonly string _topic;
    
    public KafkaSink(string bootstrapServers, string topic)
    {
        var config = new ProducerConfig { BootstrapServers = bootstrapServers };
        _producer = new ProducerBuilder<Null, string>(config).Build();
        _topic = topic;
    }
    
    public void Emit(LogEvent logEvent)
    {
        var json = JsonConvert.SerializeObject(new {
            Timestamp = logEvent.Timestamp,
            Level = logEvent.Level.ToString(),
            Message = logEvent.RenderMessage(),
            Exception = logEvent.Exception?.ToString(),
            Properties = logEvent.Properties
        });
        
        _producer.ProduceAsync(_topic, new Message<Null, string> { Value = json });
    }
    
    public void Dispose() => _producer.Dispose();
}

注册Sink扩展方法：

csharp复制public static class KafkaSinkExtensions
{
    public static LoggerConfiguration Kafka(
        this LoggerSinkConfiguration sinkConfig,
        string bootstrapServers,
        string topic)
    {
        return sinkConfig.Sink(new KafkaSink(bootstrapServers, topic));
    }
}

18.2 自定义Enricher开发

实现一个HTTP请求上下文Enricher：

csharp复制public class HttpContextEnricher : ILogEventEnricher
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    
    public HttpContextEnricher(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }
    
    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
    {
        var context = _httpContextAccessor.HttpContext;
        if (context == null) return;
        
        logEvent.AddPropertyIfAbsent(propertyFactory
            .CreateProperty("RequestPath", context.Request.Path));
            
        logEvent.AddPropertyIfAbsent(propertyFactory
            .CreateProperty("ClientIP", context.Connection.RemoteIpAddress));
            
        if (context.User.Identity.IsAuthenticated)
        {
            logEvent.AddPropertyIfAbsent(propertyFactory
                .CreateProperty("UserId", context.User.FindFirstValue(ClaimTypes.NameIdentifier)));
        }
    }
}

19. 遗留系统改造策略

19.1 渐进式迁移方案

分阶段改造老旧系统：

阶段1：并行日志

csharp复制// 传统日志方式
ILogger _legacyLogger = LogManager.GetLogger("Legacy");

// Serilog适配器
ILogger _modernLogger = Log.ForContext<LegacyService>();

public void Process()
{
    // 同时记录两种日志
    _legacyLogger.Info("Processing started");
    _modernLogger.Information("Processing started");
    
    // 业务逻辑...
}

阶段2：抽象日志接口

csharp复制public interface IUnifiedLogger
{
    void Info(string message, object data = null);
    void Error(Exception ex, string message, object data = null);
}

public class SerilogAdapter : IUnifiedLogger
{
    public void Info(string message, object data = null)
    {
        if (data == null)
            Log.Information(message);
        else
            Log.Information("{Message} {@Data}", message, data);
    }
    
    // 其他方法实现...
}

阶段3：全面替换

• 逐步替换所有_legacyLogger调用
• 移除旧日志包依赖
• 统一日志配置中心

19.2 适配器模式实现

log4net到Serilog的适配器：

csharp复制public class Log4NetToSerilogAdapter : log4net.Core.ILogger
{
    private readonly ILogger _serilogLogger;
    
    public Log4NetToSerilogAdapter(ILogger serilogLogger)
    {
        _serilogLogger = serilogLogger;
    }
    
    public void Log(LoggingEvent logEvent)
    {
        var level = ConvertLevel(logEvent.Level);
        var message = logEvent.RenderedMessage;
        var exception = logEvent.ExceptionObject;
        
        _serilogLogger.Write(level, exception, message);
    }
    
    private LogEventLevel ConvertLevel(log4net.Core.Level log4netLevel)
    {
        if (log4netLevel == log4net.Core.Level.Debug) return LogEventLevel.Debug;
        if (log4netLevel == log4net.Core.Level.Info) return LogEventLevel.Information;
        if (log4netLevel == log4net.Core.Level.Warn) return LogEventLevel.Warning;
        if (log4netLevel == log4net.Core.Level.Error) return LogEventLevel.Error;
        if (log4netLevel == log4net.Core.Level.Fatal) return LogEventLevel.Fatal;
        return LogEventLevel.Verbose;
    }
}

20. 未来演进方向

20.1 机器学习日志分析

利用ML.NET实现日志自动分类：

csharp复制// 训练数据准备
var trainingData = logs
    .Where(l => l.Level == LogEventLevel.Error)
    .Select(l => new LogEntry
    {
        Message = l.RenderMessage(),
        Category = GetManualCategory(l) // 预先标注的类别
    });

// 构建管道
var pipeline = mlContext.Transforms.Text
    .FeaturizeText("Features", nameof(LogEntry.Message))
    .Append(mlContext.MulticlassClassification.Trainers
        .SdcaMaximumEntropy("Category", "Features"));

// 训练模型
var model = pipeline.Fit(trainingDataView);

// 使用模型预测
var predictionEngine = mlContext.Model
    .CreatePredictionEngine<LogEntry, LogPrediction>(model);

var prediction = predictionEngine.Predict(new LogEntry
{
    Message = "Database connection timeout"
});

20.2 日志压缩与加密

使用Brotli压缩日志：

csharp复制public class CompressedFileSink : ILogEventSink
{
    private readonly StreamWriter _writer;
    private readonly BrotliStream _compressor;
    
    public CompressedFileSink(string path)
    {
        var fileStream = new FileStream(path, FileMode.Append);
        _compressor = new BrotliStream(fileStream, CompressionLevel.Optimal);
        _writer = new StreamWriter(_compressor);
    }
    
    public void Emit(LogEvent logEvent)
    {
        var json = JsonConvert.SerializeObject(logEvent);
        _writer.WriteLine(json);
        _writer.Flush();
    }
    
    public void Dispose()
    {
        _writer.Dispose();
        _compressor.Dispose();
    }
}

AES日志加密实现：

csharp复制public class EncryptedSink : ILogEventSink
{
    private readonly Aes _aes;
    private readonly ICryptoTransform _encryptor;
    private readonly StreamWriter _writer;
    
    public EncryptedSink(string path, byte[] key, byte[] iv)
    {
        _aes = Aes.Create();
        _aes.Key = key;
        _aes.IV = iv;
        _encryptor = _aes.CreateEncryptor();
        
        var fileStream = new FileStream(path, FileMode.Append);
        var cryptoStream = new CryptoStream(fileStream, _encryptor, CryptoStreamMode.Write);
        _writer = new StreamWriter(cryptoStream);
    }
    
    public void Emit(LogEvent logEvent)
    {
        var json = JsonConvert.SerializeObject(logEvent);
        _writer.WriteLine(json);
        _writer.Flush();
    }
    
    public void Dispose()
    {
        _writer.Dispose();
        _encryptor.Dispose();
        _aes.Dispose();
    }
}