Serilog 嵌套日志延迟基准深度解析:ForContext 的 4 倍开销从何而来

原创2026-10-14 14:01:081,380 阅读
文章标签:可观测性后端

Serilog 嵌套日志延迟基准深度解析:ForContext 的 4 倍开销从何而来

本篇技术指南以 Serilog 仓库中 results/netcoreapp1.0/NestedLoggerLatencyBenchmark-report-github.md 基准报告为核心,结合 NestedLoggerLatencyBenchmark.cs 与 Logger.cs 源码,逐项解读报告中的环境参数与吞吐数据,并还原嵌套 Logger 内部实现机制。读完本文,你将能准确看懂 BenchmarkDotNet 报告中的每一列指标,理解 ForContext() 产生额外延迟的底层原因,并掌握如何在仓库中复现这套基准实验。

报告全景:一次 BenchmarkDotNet 吞吐量测试记录

该报告是 BenchmarkDotNet 在 .NET Core (CoreCLR) 运行时上、以 Throughput(吞吐)模式运行 NestedLoggerLatencyBenchmark 的原始输出,格式为 GitHub Markdown 报告。报告开头是 ini 代码块包裹的主机环境信息,紧接着是基准结果表格。这份文件既是一份可复现的实验记录,也是理解嵌套 Logger 性能成本的直接证据。

主机环境信息逐项解读

报告顶部的环境区块记录了本次实验的运行条件:

Host Process Environment Information:
BenchmarkDotNet.Core=v0.9.9.0
OS=Windows
Processor=?, ProcessorCount=8
Frequency=2533306 ticks, Resolution=394.7411 ns, Timer=TSC
CLR=CORE, Arch=64-bit ? [RyuJIT]
GC=Concurrent Workstation
dotnet cli version: 1.0.0-preview2-003121
字段 值 含义
BenchmarkDotNet.Core v0.9.9.0 基准框架版本,属 BenchmarkDotNet 早期 0.9 系列
OS Windows 测试运行的操作系统
ProcessorCount 8 逻辑处理器数量(报告中 CPU 型号字段缺失,显示为 ?)
Frequency 2533306 ticks 高精度计时器每秒 tick 数
Resolution 394.7411 ns 计时器分辨率约 394.7 纳秒
Timer TSC 基于 x86 TSC(时间戳计数器)的高精度计时
CLR CORE, Arch=64-bit ? [RyuJIT] 64 位 CoreCLR 运行时,采用 RyuJIT 即时编译器
GC Concurrent Workstation 并发工作站垃圾回收模式
dotnet cli version 1.0.0-preview2-003121 构建与运行所用的 .NET CLI 预览版

Type=NestedLoggerLatencyBenchmark Mode=Throughput 这一行明确了被测类型与基准模式:Mode=Throughput 表示 BenchmarkDotNet 会不断重复调用被测方法,以测量单位时间内能完成的操作次数(或单次操作的耗时),这正是评估日志写入延迟的合适模式。作为对照,仓库中其他基准如 NestedLoggerCreationBenchmark.cs 使用 [MemoryDiagnoser] 侧重测量分配,而本基准只关注单次 Write 的吞吐成本。

结果表格:RootLogger 与 NestedLogger 的吞吐对比

       Method |     Median |    StdDev | Scaled | Scaled-SD |
------------- |----------- |---------- |------- |---------- |
   RootLogger | 14.0131 ns | 0.2212 ns |   1.00 |      0.00 |
 NestedLogger | 59.4502 ns | 1.3198 ns |   4.23 |      0.11 |

结果中的四个指标需要逐一理解:

  • Median(中位数):单次操作耗时的中位数。基准会运行多轮并多次测量,中位数比平均值更能抵抗偶发抖动。RootLogger 写一次事件的中位耗时约 14.01 ns,NestedLogger 约 59.45 ns。
  • StdDev(标准差):测量结果的离散程度。RootLogger 为 0.22 ns、NestedLogger 为 1.32 ns,说明两组测量都相当稳定,NestedLogger 的抖动略大。
  • Scaled(相对缩放):以基准方法(Baseline)为 1.00,其余方法的耗时倍数。RootLogger 是 Baseline(1.00),NestedLogger 为 4.23 倍。
  • Scaled-SD:缩放倍数的标准差(0.11),表明 4.23 倍这一结论在测量误差范围内是可靠的。

将 net4.5.2 版报告(52.61 ns / 14.53 ns,约 3.60 倍)与 netcoreapp2.0 版报告(41.70 ns / 11.78 ns,约 3.54 倍)对比可以看出:在不同运行时与硬件上,嵌套 Logger 的写延迟始终约为根 Logger 的 3.5~4 倍,这一量级的额外成本稳定存在。但必须强调,这些数字高度依赖当时的硬件(本报告 CPU 型号缺失,netcoreapp2.0 报告为 Intel Core i7-7567U)、运行时版本与 BenchmarkDotNet 版本,只能作为量级参考,不能直接迁移到当前硬件上作为绝对性能指标。

基准方法剖析:被测对象到底做了什么

要理解 4 倍差距,先要看清基准代码在测什么。完整源码位于 test/Serilog.PerformanceTests/NestedLoggerLatencyBenchmark.cs:

public class NestedLoggerLatencyBenchmark
{
    ILogger _log = null!, _nested = null!;
    readonly LogEvent _event = Some.InformationEvent();

    [GlobalSetup]
    public void Setup()
    {
        _log = new LoggerConfiguration()
            .WriteTo.Sink(new NullSink())
            .CreateLogger();

        _nested = _log.ForContext<NestedLoggerLatencyBenchmark>();
    }

    [Benchmark(Baseline = true)]
    public void RootLogger()
    {
        _log.Write(_event);
    }

    [Benchmark]
    public void NestedLogger()
    {
        _nested.Write(_event);
    }
}

几个关键设计点:

  • <a href="https://link.gitcode.com/i/9276eb1cfcc1e279f1eaca9ead45ccbf" target="_blank">GlobalSetup]:基准运行前只执行一次的环境准备——创建根 Logger,并通过 ForContext<NestedLoggerLatencyBenchmark>() 派生嵌套 Logger。基准本身不测量 ForContext 的创建成本(那是 [NestedLoggerCreationBenchmark 的职责),只测量通过嵌套 Logger 写一条已绑定事件的延迟。
  • _event 是预先绑定好的 LogEvent:由 Support/Some.cs 中的 Some.InformationEvent() 通过 BindMessageTemplate 提前构造。这意味着基准刻意排除了消息模板解析、属性绑定等开销,聚焦于日志管线的最小写路径——更贴近高热点路径的实测。
  • NullSink:实现于 Support/NullSink.cs,Emit 为空操作。它排除了真实输出设备(控制台、文件等)的 IO 干扰,让基准只反映 Logger 自身的管线成本。配置使用 new LoggerConfiguration().WriteTo.Sink(...),该 API 定义于 LoggerSinkConfiguration.cs。
  • [Benchmark(Baseline = true)]:标记 RootLogger 为基准基线,对应结果表中 Scaled = 1.00 的一行。

源码级归因:嵌套 Logger 的延迟到底花在哪里

NestedLogger 多出的约 45 ns 并非凭空产生,而是 Serilog 嵌套 Logger 实现结构的直接结果。

1. ForContext 创建了一条独立的 Logger 链

ForContext<T>() 的调用链在 Logger.cs 中清晰可见:泛型重载转发到 ForContext(Type),后者再转发到 ForContext(Constants.SourceContextPropertyName, source.FullName)——也就是说,ForContext<NestedLoggerLatencyBenchmark>() 实际是给每条日志事件添加一个名为 SourceContext、值为类型全名的属性。

真正关键的实现在 ForContext(string, object, bool)(Logger.cs):它构造一个 FixedPropertyEnricher(定义于 src/Serilog/Core/Enrichers/FixedPropertyEnricher.cs),然后返回一个新的 Logger 实例,该实例的 _sink 指向父 Logger(this),_enricher 指向新建的 enricher:

return new Logger(
    _messageTemplateProcessor,
    minimumLevel,
    levelSwitch,
    this,      // 嵌套 Logger 的 sink 就是父 Logger
    enricher,  // FixedPropertyEnricher
    null,
    _overrideMap);

于是形成了"嵌套 Logger → 父 Logger → NullSink"的链式结构。写一条事件时,事件要穿过整条链。

2. 写入路径比根 Logger 多出两次调用

根 Logger 的写路径(_log.Write(_event))走 Logger.cs 的 Write(LogEvent) → IsEnabled → PostLevelCheckEmit:一次 enricher 处理、一次 sink 分发。

嵌套 Logger 的写路径(_nested.Write(_event))则是:

  1. _nested.Write(_event):同样是 IsEnabled + PostLevelCheckEmit,但它的 _enricher 是 FixedPropertyEnricher,_sink 是父 Logger;
  2. FixedPropertyEnricher.Enrich() 执行 logEvent.AddPropertyIfAbsent(_eventProperty)(FixedPropertyEnricher.cs),尝试把 SourceContext 属性写入事件;
  3. 调用父 Logger 的 ILogEventSink.Emit() 接口(Logger.cs)。该接口特意绕过级别检查(注释明确说明"Bypasses the level check so that child loggers using this one as a sink can increase verbosity"),使子 Logger 可以比父 Logger 更宽松地放开日志级别;
  4. 父 Logger 内部再走一次 PostLevelCheckEmit:这一次 _enricher 是空的(根 Logger 无 enricher),然后 _sink.Emit 落到 NullSink。

对照 PostLevelCheckEmit 的实现可以看出,嵌套路径比根路径额外多出:一次 enricher 属性注入、一次 ILogEventSink.Emit 接口间接调用、再一次 PostLevelCheckEmit 的异常包装与分发。接口虚调用、属性注入的对象操作与多一层分发,正是多出的 ~45 ns 的主要来源。

3. 级别检查的设计值得注意

Logger.IsEnabled(Logger.cs)是刻意做得很轻的:先读字段 _minimumLevel,仅当存在 LoggingLevelSwitch 时才做二次检查。源码注释强调"checking minimum level is a very quick (CPU-cacheable) read in the simple case",这也是 RootLogger 单次写入能压到十几纳秒量级的原因之一。嵌套 Logger 复用父级的最小级别字段,因此级别过滤本身不会带来额外负担——开销集中在事件穿过整条链的过程。

4. 极端情况:SilentLogger 零成本

仓库还提供了一个结构上的极端对照:ForContext 在参数为 null 时直接返回 this(Logger.cs),而 SilentLogger.cs 是级别永不启用的空实现(IsEnabled 恒为 false,所有 Write 为空)。这说明 Serilog 在"没有内容要写"的路径上把成本压到了最低;本基准测量的是"确定要写"的路径,SilentLogger 不参与其中。

复现基准:如何在自己的环境跑出这份报告

Serilog 的基准由独立的性能测试项目承载(Serilog.PerformanceTests.csproj,引用 BenchmarkDotNet 与 xUnit),并封装为 xUnit 测试,方便通过 dotnet test 一键运行。入口是 Harness.cs 中的 NestedLoggerLatency 测试:

[Fact]
public void NestedLoggerLatency()
{
    BenchmarkRunner.Run<NestedLoggerLatencyBenchmark>();
}

复现方式有两种:

方式一:只跑本基准(推荐),通过 --filter 精确匹配:

dotnet test -c Release -f netcoreapp3.1 --filter "FullyQualifiedName=Serilog.PerformanceTests.Harness.NestedLoggerLatency"

(Harness.cs 注释中给出了同构的 Allocations 示例;当前 csproj 的目标框架为 net10.0;net9.0;net8.0,运行时应替换为实际可用框架。)

方式二:跑全部基准,仓库根目录的 RunPerfTests.ps1 会先执行 Build.ps1 构建,再对所有 test/*.PerformanceTests 项目逐个执行 dotnet test -c Release。

几点实操注意事项:

  • 基准必须用 Release 配置运行,否则 JIT 优化缺失会完全扭曲数据;
  • 跑基准前关闭其他占用 CPU 的进程,并优先使用性能模式电源计划;本报告的 GC=Concurrent Workstation 与 8 核环境是当时的默认条件,并非需要手动指定的开关;
  • 结果中的 Median/StdDev 是 BenchmarkDotNet 自动多轮采样后的统计量,不要用单次计时器读数替代;
  • results/ 目录下的各报告(如 netcoreapp1.0、net4.5.2、netcoreapp2.0)是不同年代、不同运行时下的历史快照,直接对比时应注意到 BenchmarkDotNet 版本与硬件差异。

结论与工程启示

综合 results/netcoreapp1.0/NestedLoggerLatencyBenchmark-report-github.md 的测量数据与 Logger.cs 的实现:

  • 数值结论:在该报告环境中,通过嵌套 Logger 写一条事件的中位耗时约 59.45 ns,是根 Logger(约 14.01 ns)的 4.23 倍;历史上其他运行时上约为 3.5~3.6 倍。绝对数值仅代表当时环境,但"嵌套引入数倍恒定开销"的结论在多个报告间一致。
  • 结构结论:开销主要来自 ForContext 构造的"新 Logger 作为门面、父 Logger 作为 sink"的链式结构——事件每次写入都要多经历一次属性注入、一次 ILogEventSink.Emit 虚调用和一次额外的 PostLevelCheckEmit 分发。
  • 工程启示:每个 ForContext 调用都会产生一个新的 Logger 实例,因此应尽量复用派生好的嵌套 Logger(比如在每个类中只创建一次并缓存),避免在每条日志上重复调用 ForContext;同时把消息模板作为常量而非每次拼接字符串,可以让 MessageTemplateCache(上限 1000 条、长度超过 1024 字符不缓存)发挥最大作用,把"解析模板"这类比嵌套开销更大的成本排除在热点路径之外。对于日志量极大的场景,这些微秒级以下的优化叠加起来仍能显著影响整体吞吐。
登录后查看全文
serilog