Compare commits

..
3 Commits
8 changed files with 224 additions and 16 deletions

No files matched your search

+5 -1
View File
@@ -177,7 +177,11 @@ extension LogHandler {
nil
}
set {
self.log(level: .warning, message: "Attempted to set metadataProvider on \(Self.self) that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", metadata: nil, source: "Logging", file: #file, function: #function, line: #line)
#if DEBUG
if LoggingSystem.warnOnceLogHandlerNotSupportedMetadataProvider(Self.self) {
self.log(level: .warning, message: "Attempted to set metadataProvider on \(Self.self) that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", metadata: nil, source: "Logging", file: #file, function: #function, line: #line)
}
#endif
}
}
}
+98 -8
View File
@@ -663,6 +663,10 @@ public enum LoggingSystem {
private static let _factory = FactoryBox { label, _ in StreamLogHandler.standardOutput(label: label) }
private static let _metadataProviderFactory = MetadataProviderBox(nil)
#if DEBUG
private static var _warnOnceBox: WarnOnceBox = WarnOnceBox()
#endif
/// `bootstrap` is a one-time configuration function which globally selects the desired logging backend
/// implementation. `bootstrap` can be called at maximum once in any given program, calling it more than once will
/// lead to undefined behavior, most likely a crash.
@@ -708,9 +712,7 @@ public enum LoggingSystem {
fileprivate static var factory: (String, Logger.MetadataProvider?) -> LogHandler {
return { label, metadataProvider in
var handler = self._factory.underlying(label, metadataProvider)
handler.metadataProvider = metadataProvider
return handler
self._factory.underlying(label, metadataProvider)
}
}
@@ -727,6 +729,15 @@ public enum LoggingSystem {
return self._metadataProviderFactory.metadataProvider
}
#if DEBUG
/// Used to warn only once about a specific ``LogHandler`` type when it does not support ``Logger/MetadataProvider``,
/// but an attempt was made to set a metadata provider on such handler. In order to avoid flooding the system with
/// warnings such warning is only emitted in debug mode, and even then at-most once for a handler type.
internal static func warnOnceLogHandlerNotSupportedMetadataProvider<Handler: LogHandler>(_ type: Handler.Type) -> Bool {
self._warnOnceBox.warnOnceLogHandlerNotSupportedMetadataProvider(type: type)
}
#endif
private final class FactoryBox {
private let lock = ReadWriteLock()
fileprivate var _underlying: (_ label: String, _ provider: Logger.MetadataProvider?) -> LogHandler
@@ -911,7 +922,9 @@ extension Logger {
/// instead of the system wide bootstrapped one, when a log statement is about to be emitted.
public init(label: String, metadataProvider: MetadataProvider) {
self = Logger(label: label, factory: { label in
LoggingSystem.factory(label, metadataProvider)
var handler = LoggingSystem.factory(label, metadataProvider)
handler.metadataProvider = metadataProvider
return handler
})
}
}
@@ -1039,6 +1052,8 @@ extension Logger {
public struct MultiplexLogHandler: LogHandler {
private var handlers: [LogHandler]
private var effectiveLogLevel: Logger.Level
/// This metadata provider runs after all metadata providers of the multiplexed handlers.
private var _metadataProvider: Logger.MetadataProvider?
/// Create a `MultiplexLogHandler`.
///
@@ -1051,6 +1066,13 @@ public struct MultiplexLogHandler: LogHandler {
self.effectiveLogLevel = handlers.map { $0.logLevel }.min() ?? .trace
}
public init(_ handlers: [LogHandler], metadataProvider: Logger.MetadataProvider?) {
assert(!handlers.isEmpty, "MultiplexLogHandler.handlers MUST NOT be empty")
self.handlers = handlers
self.effectiveLogLevel = handlers.map { $0.logLevel }.min() ?? .trace
self._metadataProvider = metadataProvider
}
public var logLevel: Logger.Level {
get {
return self.effectiveLogLevel
@@ -1061,6 +1083,43 @@ public struct MultiplexLogHandler: LogHandler {
}
}
public var metadataProvider: Logger.MetadataProvider? {
get {
if self.handlers.count == 1 {
if let innerHandler = self.handlers.first?.metadataProvider {
if let multiplexHandlerProvider = self._metadataProvider {
return .multiplex([innerHandler, multiplexHandlerProvider])
} else {
return innerHandler
}
} else if let multiplexHandlerProvider = self._metadataProvider {
return multiplexHandlerProvider
} else {
return nil
}
} else {
var providers: [Logger.MetadataProvider] = []
let additionalMetadataProviderCount = (self._metadataProvider != nil ? 1 : 0)
providers.reserveCapacity(self.handlers.count + additionalMetadataProviderCount)
for handler in self.handlers {
if let provider = handler.metadataProvider {
providers.append(provider)
}
}
if let multiplexHandlerProvider = self._metadataProvider {
providers.append(multiplexHandlerProvider)
}
guard !providers.isEmpty else {
return nil
}
return .multiplex(providers)
}
}
set {
self.mutatingForEachHandler { $0.metadataProvider = newValue }
}
}
public func log(level: Logger.Level,
message: Logger.Message,
metadata: Logger.Metadata?,
@@ -1075,13 +1134,22 @@ public struct MultiplexLogHandler: LogHandler {
public var metadata: Logger.Metadata {
get {
var effectiveMetadata: Logger.Metadata = [:]
var effective: Logger.Metadata = [:]
// as a rough estimate we assume that the underlying handlers have a similar metadata count,
// and we use the first one's current count to estimate how big of a dictionary we need to allocate:
effectiveMetadata.reserveCapacity(self.handlers.first!.metadata.count) // !-safe, we always have at least one handler
return self.handlers.reduce(into: effectiveMetadata) { effectiveMetadata, handler in
effectiveMetadata.merge(handler.metadata, uniquingKeysWith: { l, _ in l })
effective.reserveCapacity(self.handlers.first!.metadata.count) // !-safe, we always have at least one handler
for handler in self.handlers {
effective.merge(handler.metadata, uniquingKeysWith: { _, handlerMetadata in handlerMetadata })
if let provider = handler.metadataProvider {
effective.merge(provider.get(), uniquingKeysWith: { _, provided in provided })
}
}
if let provider = self._metadataProvider {
effective.merge(provider.get(), uniquingKeysWith: { _, provided in provided })
}
return effective
}
set {
self.mutatingForEachHandler { $0.metadata = newValue }
@@ -1439,6 +1507,28 @@ extension Logger.MetadataValue: ExpressibleByArrayLiteral {
}
}
// MARK: - Debug only warnings
#if DEBUG
/// Contains state to manage all kinds of "warn only once" warnings which the logging system may want to issue.
private final class WarnOnceBox {
private let lock: Lock = Lock()
private var warnOnceLogHandlerNotSupportedMetadataProviderPerType: [ObjectIdentifier: Bool] = [:]
func warnOnceLogHandlerNotSupportedMetadataProvider<Handler: LogHandler>(type: Handler.Type) -> Bool {
self.lock.withLock {
let id = ObjectIdentifier(type)
if warnOnceLogHandlerNotSupportedMetadataProviderPerType[id] ?? false {
return false // don't warn, it was already warned about
} else {
warnOnceLogHandlerNotSupportedMetadataProviderPerType[id] = true
return true // warn about this handler type, it is the first time we encountered it
}
}
}
}
#endif
// MARK: - Sendable support helpers
#if compiler(>=5.7.0)
@@ -31,6 +31,8 @@ extension LoggingTest {
("testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes", testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes),
("testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers", testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers),
("testMultiplexLogHandlerMetadata_readingHandlerMetadata", testMultiplexLogHandlerMetadata_readingHandlerMetadata),
("testMultiplexMetadataProviderSet", testMultiplexMetadataProviderSet),
("testMultiplexMetadataProviderExtract", testMultiplexMetadataProviderExtract),
("testDictionaryMetadata", testDictionaryMetadata),
("testListMetadata", testListMetadata),
("testStringConvertibleMetadata", testStringConvertibleMetadata),
+82 -1
View File
@@ -220,7 +220,84 @@ class LoggingTest: XCTestCase {
XCTAssertEqual(multiplexLogger.handler.metadata, [
"one": "111",
"two": "222",
"in": "in-1",
"in": "in-2",
])
}
func testMultiplexMetadataProviderSet() {
let logging1 = TestLogging()
let logging2 = TestLogging()
var handler1 = logging1.make(label: "1")
handler1.metadata["one"] = "111"
handler1.metadata["in"] = "in-1"
handler1.metadataProvider = .constant([
"provider-1": "provided-111",
"provider-overlap": "provided-111",
])
var handler2 = logging2.make(label: "2")
handler2.metadata["two"] = "222"
handler2.metadata["in"] = "in-2"
handler2.metadataProvider = .constant([
"provider-2": "provided-222",
"provider-overlap": "provided-222",
])
LoggingSystem.bootstrapInternal { _ in
MultiplexLogHandler([handler1, handler2])
}
let multiplexLogger = Logger(label: "test")
XCTAssertEqual(multiplexLogger.handler.metadata, [
"one": "111",
"two": "222",
"in": "in-2",
"provider-1": "provided-111",
"provider-2": "provided-222",
"provider-overlap": "provided-222",
])
XCTAssertEqual(multiplexLogger.handler.metadataProvider?.get(), [
"provider-1": "provided-111",
"provider-2": "provided-222",
"provider-overlap": "provided-222",
])
}
func testMultiplexMetadataProviderExtract() {
let logging1 = TestLogging()
let logging2 = TestLogging()
var handler1 = logging1.make(label: "1")
handler1.metadataProvider = .constant([
"provider-1": "provided-111",
"provider-overlap": "provided-111",
])
var handler2 = logging2.make(label: "2")
handler2.metadata["two"] = "222"
handler2.metadata["in"] = "in-2"
handler2.metadataProvider = .constant([
"provider-2": "provided-222",
"provider-overlap": "provided-222",
])
LoggingSystem.bootstrapInternal({ _, metadataProvider in
MultiplexLogHandler(
[handler1, handler2],
metadataProvider: metadataProvider
)
}, metadataProvider: .constant([
"provider-overlap": "provided-outer",
]))
let multiplexLogger = Logger(label: "test")
let provider = multiplexLogger.metadataProvider!
XCTAssertEqual(provider.get(), [
"provider-1": "provided-111",
"provider-2": "provided-222",
"provider-overlap": "provided-outer",
])
}
@@ -999,6 +1076,10 @@ extension Logger.MetadataProvider {
static var exampleMetadataProvider: Self {
.init { ["example": .string("example-value")] }
}
static func constant(_ metadata: Logger.Metadata) -> Self {
.init { metadata }
}
}
// Sendable
+13 -1
View File
@@ -25,7 +25,9 @@ import Glibc
final class MetadataProviderTest: XCTestCase {
func testLoggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed() throws {
let logging = TestLogging()
LoggingSystem.bootstrapInternal(logging.make)
LoggingSystem.bootstrapInternal(logging.makeWithMetadataProvider,
metadataProvider: .init { ["common": "initial"]
})
let logger = Logger(label: #function, metadataProvider: .init {
[
@@ -42,21 +44,31 @@ final class MetadataProviderTest: XCTestCase {
}
func testLogHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt() {
#if DEBUG
// we only emit these warnings in debug mode
let logging = TestLogging()
var handler = LogHandlerThatDidNotImplementMetadataProviders(testLogging: logging)
handler.metadataProvider = .simpleTestProvider
logging.history.assertExist(level: .warning, message: "Attempted to set metadataProvider on LogHandlerThatDidNotImplementMetadataProviders that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", source: "Logging")
let countBefore = logging.history.entries.count
handler.metadataProvider = .simpleTestProvider
XCTAssertEqual(countBefore, logging.history.entries.count, "Should only log the warning once")
#endif
}
func testLogHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt() {
#if DEBUG
// we only emit these warnings in debug mode
let logging = TestLogging()
var handler = LogHandlerThatDidImplementMetadataProviders(testLogging: logging)
handler.metadataProvider = .simpleTestProvider
logging.history.assertNotExist(level: .warning, message: "Attempted to set metadataProvider on LogHandlerThatDidImplementMetadataProviders that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", source: "Logging")
#endif
}
}
+2 -1
View File
@@ -6,7 +6,8 @@ services:
image: swift-log:20.04-5.7
build:
args:
base_image: "swiftlang/swift:nightly-main-focal"
ubuntu_version: "focal"
swift_version: "5.7"
test:
image: swift-log:20.04-5.7
@@ -3,16 +3,16 @@ version: "3"
services:
runtime-setup:
image: swift-log:20.04-main
image: swift-log:20.04-5.8
build:
args:
base_image: "swiftlang/swift:nightly-main-focal"
base_image: "swiftlang/swift:nightly-5.8-focal"
test:
image: swift-log:20.04-main
image: swift-log:20.04-5.8
environment:
- FORCE_TEST_DISCOVERY=--enable-test-discovery
#- SANITIZER_ARG=--sanitize=thread
shell:
image: swift-log:20.04-main
image: swift-log:20.04-5.8
+18
View File
@@ -0,0 +1,18 @@
version: "3"
services:
runtime-setup:
image: swift-log:22.04-main
build:
args:
base_image: "swiftlang/swift:nightly-main-jammy"
test:
image: swift-log:22.04-main
environment:
- FORCE_TEST_DISCOVERY=--enable-test-discovery
#- SANITIZER_ARG=--sanitize=thread
shell:
image: swift-log:22.04-main