Serilog 嵌套日志延迟基准深度解析:ForContext 的 4 倍开销从何而来
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))则是:
_nested.Write(_event):同样是IsEnabled+PostLevelCheckEmit,但它的_enricher是FixedPropertyEnricher,_sink是父 Logger;FixedPropertyEnricher.Enrich()执行logEvent.AddPropertyIfAbsent(_eventProperty)(FixedPropertyEnricher.cs),尝试把SourceContext属性写入事件;- 调用父 Logger 的
ILogEventSink.Emit()接口(Logger.cs)。该接口特意绕过级别检查(注释明确说明"Bypasses the level check so that child loggers using this one as a sink can increase verbosity"),使子 Logger 可以比父 Logger 更宽松地放开日志级别; - 父 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 字符不缓存)发挥最大作用,把"解析模板"这类比嵌套开销更大的成本排除在热点路径之外。对于日志量极大的场景,这些微秒级以下的优化叠加起来仍能显著影响整体吞吐。