Files
swift-log/Tests/InMemoryLoggingTests/MultiplexProviderRegressionTests.swift
0z5a c7413d967b Make MultiplexLogHandler.metadataProvider setter replace the initializer's provider (#537)
### Motivation:

`MultiplexLogHandler.metadataProvider`'s setter only forwards the new
provider to the underlying handlers. Since #522, `log(event:)` also
merges the provider passed to `init(_:metadataProvider:)` on top of the
underlying handlers' metadata, so after a set that old provider still
overrides the new one for conflicting keys, setting `nil` doesn't remove
it, and the getter keeps returning it.

This shows up through `Logger(label:metadataProvider:)`, which calls the
factory and then sets `handler.metadataProvider`. If the bootstrapped
factory returns a `MultiplexLogHandler` with its own provider, the
provider the library passed is silently overridden. With a plain handler
the same code uses the library's provider, which is what
`Logger(label:metadataProvider:)` documents ("the custom metadata
provider this logger should invoke, instead of the system wide
bootstrapped one").

### Modifications:

- In the setter, also replace the multiplex handler's own provider with
the new value. It is still forwarded to the underlying handlers as
before.
- Document the setter.
- Add regression tests: setting a provider replaces the initializer's
provider for one and two handlers, and setting `nil` clears it (both the
getter and emitted logs). Another test covers an underlying handler that
doesn't support metadata providers.

I kept forwarding to the underlying handlers and replace the multiplex
handler's own provider as well, rather than clearing it. Clearing it
would drop provider metadata for underlying handlers that use the
default `metadataProvider` implementation in the
`Logger(label:metadataProvider:)` case, which works today.

### Result:

After `handler.metadataProvider = p`, logs and the getter use `p`. After
`handler.metadataProvider = nil`, no provider metadata is added. In the
common setup where the factory passes its provider into the
`MultiplexLogHandler` initializer, the number of provider calls per log
stays the same. When the multiplex handler had no provider of its own, a
set now also applies the provider once at the multiplex level, so
underlying handlers without provider support get its metadata too.

The new tests fail on main and pass with this change. All tests pass
locally on macOS (Swift 6.3.3), and `swift format lint` is clean on the
changed files. I couldn't run the benchmarks locally.

This change was drafted with Claude Code (claude-opus-5-5); the test
results above are from the runs described.
2026-11-17 13:24:42 +00:00

97 lines
3.8 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2026 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import InMemoryLogging
import Logging
import Testing
struct MultiplexProviderRegressionTests {
@Test(arguments: [1, 2])
func constructorProviderReachesEverySink(handlerCount: Int) {
let sinks = (0..<handlerCount).map { _ in InMemoryLogHandler() }
let handler = MultiplexLogHandler(sinks, metadataProvider: .init { ["trace-id": "123"] })
let logger = Logger(label: "test", factory: { _ in handler })
#expect(logger.metadataProvider?.get()["trace-id"] == "123")
logger.info("hello")
for sink in sinks {
#expect(sink.entries.count == 1)
#expect(sink.entries.first?.metadata["trace-id"] == "123")
}
}
@Test func constructorProviderLayersBetweenChildAndExplicitMetadata() {
var sink = InMemoryLogHandler()
sink.metadataProvider = .init { ["child": "kept", "shared": "child"] }
let handler = MultiplexLogHandler(
[sink],
metadataProvider: .init {
["outer": "kept", "shared": "outer"]
}
)
let logger = Logger(label: "test", factory: { _ in handler })
logger.info("provided")
logger.info("explicit", metadata: ["shared": "explicit"])
#expect(sink.entries.first?.metadata == ["child": "kept", "outer": "kept", "shared": "outer"])
#expect(sink.entries.last?.metadata == ["child": "kept", "outer": "kept", "shared": "explicit"])
}
@Test(arguments: [1, 2])
func settingProviderReplacesConstructorProvider(handlerCount: Int) {
let sinks = (0..<handlerCount).map { _ in InMemoryLogHandler() }
let handler = MultiplexLogHandler(sinks, metadataProvider: .init { ["trace-id": "constructor"] })
var logger = Logger(label: "test", factory: { _ in handler })
logger.handler.metadataProvider = .init { ["trace-id": "replaced"] }
#expect(logger.metadataProvider?.get() == ["trace-id": "replaced"])
logger.info("replaced")
logger.handler.metadataProvider = nil
#expect(logger.metadataProvider == nil)
logger.info("cleared")
for sink in sinks {
#expect(sink.entries.map(\.metadata) == [["trace-id": "replaced"], [:]])
}
}
@Test func settingProviderReachesHandlersWithoutProviderSupport() {
let sink = InMemoryLogHandler()
var handler = MultiplexLogHandler(
[HandlerWithoutProviderSupport(sink: sink)],
metadataProvider: .init { ["trace-id": "constructor"] }
)
handler.metadataProvider = .init { ["trace-id": "replaced"] }
let logger = Logger(label: "test", factory: { _ in handler })
logger.info("hello")
// Debug builds may also record a one-time warning about the unsupported provider.
#expect(sink.entries.filter { $0.message == "hello" }.map(\.metadata) == [["trace-id": "replaced"]])
}
}
/// Uses the default `metadataProvider` implementation, so it ignores providers set on it.
private struct HandlerWithoutProviderSupport: LogHandler {
let sink: InMemoryLogHandler
var metadata: Logger.Metadata = [:]
var logLevel: Logger.Level = .info
subscript(metadataKey key: String) -> Logger.Metadata.Value? {
get { self.metadata[key] }
set { self.metadata[key] = newValue }
}
func log(event: LogEvent) {
self.sink.log(event: event)
}
}