mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
[SLG-0004]: metadata value attributes implementation (#453)
Proposal discussion thread: https://forums.swift.org/t/proposal-slg-0004-metadata-value-attributes-revision-2/86488 Add an extensible per-value attribute mechanism for metadata. ### Motivation: Metadata values in `swift-log` are opaque strings by the time the `LogHandler` receives them. The call site often knows things about a value that the handler cannot infer — for example, whether the value should be redacted in different environments. ### Modifications: - SLG-0004 proposal is updated based on the feedback. - Added `AttributedStringCarrier: CustomStringConvertible`-based mechanism to `Logging`. - Added benchmarks and benchmark thresholds for the new attributed metadata. ### Result: `swift-log` provides an optional extensible mechanism for attaching attributes to metadata values. --------- Co-authored-by: Franz Busch <privat@franz-busch.de>
This commit is contained in:
1 parent
a012e0ad8a
commit
7dc6101ae4
33 files changed
+1346
-101
No files matched your search
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 970,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 970,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 5851,
|
||||
"objectAllocCount" : 2
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 7055,
|
||||
"objectAllocCount" : 3
|
||||
}
|
||||
+10
@@ -30,4 +30,14 @@ public let benchmarks: @Sendable () -> Void = {
|
||||
makeBenchmark(loggerLevel: .warning, logLevel: .warning, "_generic") { logger in
|
||||
logger.log(level: .warning, "hello, benchmarking world")
|
||||
}
|
||||
makeBenchmark(loggerLevel: .notice, logLevel: .notice, "_attributed_generic") { logger in
|
||||
logger.log(
|
||||
level: .notice,
|
||||
"hello, benchmarking world",
|
||||
metadata: [
|
||||
"public-key": "\("public-value", sensitivity: .public)",
|
||||
"private-key": "\("private-value", sensitivity: .sensitive)",
|
||||
]
|
||||
)
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
{
|
||||
"instructions" : 658,
|
||||
"instructions" : 662,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 662,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
{
|
||||
"instructions" : 1874,
|
||||
"instructions" : 1892,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
{
|
||||
"instructions" : 1874,
|
||||
"instructions" : 1892,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
@@ -24,4 +24,40 @@ public let benchmarks: @Sendable () -> Void = {
|
||||
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_generic") { logger in
|
||||
logger.log(level: .debug, "hello, benchmarking world")
|
||||
}
|
||||
makeBenchmark(loggerLevel: .error, logLevel: .error, "_1_attribute") { logger in
|
||||
logger.log(
|
||||
level: .error,
|
||||
"hello, benchmarking world",
|
||||
metadata: [
|
||||
"public-key": "\("public-value", sensitivity: .public)"
|
||||
]
|
||||
)
|
||||
}
|
||||
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_1_attribute") { logger in
|
||||
logger.log(
|
||||
level: .debug,
|
||||
"hello, benchmarking world",
|
||||
metadata: [
|
||||
"public-key": "\("public-value", sensitivity: .public)"
|
||||
]
|
||||
)
|
||||
}
|
||||
makeBenchmark(loggerLevel: .error, logLevel: .error, "_2_attributes") { logger in
|
||||
logger.log(
|
||||
level: .error,
|
||||
"hello, benchmarking world",
|
||||
metadata: [
|
||||
"public-key": "\("public-value", attributes: [BenchmarkSensitivity.public, BenchmarkColor.red])"
|
||||
]
|
||||
)
|
||||
}
|
||||
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_2_attributes") { logger in
|
||||
logger.log(
|
||||
level: .debug,
|
||||
"hello, benchmarking world",
|
||||
metadata: [
|
||||
"public-key": "\("public-value", attributes: [BenchmarkSensitivity.public, BenchmarkColor.red])"
|
||||
]
|
||||
)
|
||||
}
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 985,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 985,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 5855,
|
||||
"objectAllocCount" : 2
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"instructions" : 7075,
|
||||
"objectAllocCount" : 3
|
||||
}
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
{
|
||||
"instructions" : 1872,
|
||||
"instructions" : 1890,
|
||||
"objectAllocCount" : 0
|
||||
}
|
||||
@@ -14,6 +14,40 @@
|
||||
|
||||
import Logging
|
||||
|
||||
// MARK: - Benchmark attributes
|
||||
|
||||
public enum BenchmarkSensitivity: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
|
||||
case sensitive = 1
|
||||
case `public` = 2
|
||||
}
|
||||
|
||||
extension Logger.MetadataValue.StringInterpolation {
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
|
||||
_ value: T,
|
||||
sensitivity: BenchmarkSensitivity
|
||||
) {
|
||||
self.appendInterpolation(value, attributes: { $0[BenchmarkSensitivity.self] = sensitivity })
|
||||
}
|
||||
}
|
||||
|
||||
public enum BenchmarkColor: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
|
||||
case red = 1
|
||||
case blue = 2
|
||||
}
|
||||
|
||||
extension Logger.MetadataValue.StringInterpolation {
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
|
||||
_ value: T,
|
||||
color: BenchmarkColor
|
||||
) {
|
||||
self.appendInterpolation(value, attributes: { $0[BenchmarkColor.self] = color })
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - NoOpLogHandler
|
||||
|
||||
struct NoOpLogHandler: LogHandler {
|
||||
let label: String
|
||||
public var metadataProvider: Logger.MetadataProvider?
|
||||
@@ -31,6 +65,13 @@ struct NoOpLogHandler: LogHandler {
|
||||
func log(
|
||||
event: LogEvent
|
||||
) {
|
||||
// Access metadata attributes
|
||||
if let metadata = event.metadata {
|
||||
for (_, value) in metadata {
|
||||
let _ = value.attributes
|
||||
}
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
@@ -43,6 +84,13 @@ struct NoOpLogHandler: LogHandler {
|
||||
function: String,
|
||||
line: UInt
|
||||
) {
|
||||
// Access metadata attributes
|
||||
if let metadata = explicitMetadata {
|
||||
for (_, value) in metadata {
|
||||
let _ = value.attributes
|
||||
}
|
||||
}
|
||||
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
|
||||
@@ -57,18 +57,23 @@ public struct InMemoryLogHandler: LogHandler {
|
||||
self.metadata = metadata
|
||||
}
|
||||
|
||||
public init(level: Logger.Level, message: Logger.Message, error: (any Error)?, metadata: Logger.Metadata) {
|
||||
public init(
|
||||
level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
error: (any Error)?,
|
||||
metadata: Logger.Metadata
|
||||
) {
|
||||
self.level = level
|
||||
self.message = message
|
||||
self.error = error
|
||||
self.metadata = metadata
|
||||
}
|
||||
|
||||
public static func == (lhs: InMemoryLogHandler.Entry, rhs: InMemoryLogHandler.Entry) -> Bool {
|
||||
public static func == (lhs: Entry, rhs: Entry) -> Bool {
|
||||
lhs.level == rhs.level
|
||||
&& lhs.message == rhs.message
|
||||
&& errorsEqual(lhs.error, rhs.error)
|
||||
&& lhs.metadata == rhs.metadata
|
||||
&& errorsEqual(lhs.error, rhs.error)
|
||||
}
|
||||
|
||||
private static func errorsEqual(_ lhs: (any Error)?, _ rhs: (any Error)?) -> Bool {
|
||||
@@ -126,14 +131,23 @@ public struct InMemoryLogHandler: LogHandler {
|
||||
}
|
||||
|
||||
public func log(event: LogEvent) {
|
||||
// Start with the metadata provider..
|
||||
var mergedMetadata: Logger.Metadata = self.metadataProvider?.get() ?? [:]
|
||||
// ..merge in self.metadata, overwriting existing keys
|
||||
mergedMetadata = mergedMetadata.merging(self.metadata) { $1 }
|
||||
// ..merge in metadata from this log call, overwriting existing keys
|
||||
mergedMetadata = mergedMetadata.merging(event.metadata ?? [:]) { $1 }
|
||||
var merged = self.metadata
|
||||
|
||||
self.logStore.append(level: event.level, message: event.message, error: event.error, metadata: mergedMetadata)
|
||||
if let provider = self.metadataProvider {
|
||||
let provided = provider.get()
|
||||
merged.merge(provided, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
|
||||
if let eventMetadata = event.metadata {
|
||||
merged.merge(eventMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
|
||||
self.logStore.append(
|
||||
level: event.level,
|
||||
message: event.message,
|
||||
error: event.error,
|
||||
metadata: merged
|
||||
)
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "log(event:)")
|
||||
|
||||
@@ -3,7 +3,9 @@
|
||||
SwiftLog provides compile-time traits to eliminate less severe log levels from
|
||||
your binary reducing the runtime overhead.
|
||||
|
||||
## Motivation
|
||||
## Overview
|
||||
|
||||
### Motivation
|
||||
|
||||
When deploying applications to production, you often know in advance which log
|
||||
levels will never be needed. For example, a production service might only need
|
||||
@@ -11,7 +13,7 @@ warning and above, while trace and debug levels are only useful during
|
||||
development. By using traits, you can completely remove these unnecessary log
|
||||
levels at compile time, achieving zero runtime overhead.
|
||||
|
||||
## Available traits
|
||||
### Available traits
|
||||
|
||||
SwiftLog defines seven maximum log level traits, ordered from most permissive
|
||||
to most restrictive:
|
||||
@@ -39,7 +41,7 @@ are specified, the most restrictive one takes effect.
|
||||
> Note: Traits should only be set by the applications and not libraries as
|
||||
> any traits defined in a transitive dependency will affect the whole resolution tree.
|
||||
|
||||
## Example
|
||||
### Example
|
||||
|
||||
To enable a trait, specify it when declaring your package dependency:
|
||||
|
||||
|
||||
@@ -129,9 +129,6 @@ public struct PrintLogHandler: LogHandler {
|
||||
let timestamp = ISO8601DateFormatter().string(from: Date())
|
||||
let levelString = event.level.rawValue.uppercased()
|
||||
|
||||
// Get provider metadata
|
||||
let providerMetadata = metadataProvider?.get() ?? [:]
|
||||
|
||||
// Merge handler metadata with message metadata
|
||||
let combinedMetadata = Self.prepareMetadata(
|
||||
base: self.metadata,
|
||||
@@ -183,6 +180,49 @@ public struct PrintLogHandler: LogHandler {
|
||||
}
|
||||
```
|
||||
|
||||
#### Reading metadata attributes in LogHandlers
|
||||
|
||||
Metadata values can carry attributes alongside their string representation. Attributes are embedded inside
|
||||
`MetadataValue` via the `.stringConvertible` case and are accessible through the `value.attributes` property. This
|
||||
enables features like sensitivity annotations without any changes to your handler's protocol conformance.
|
||||
|
||||
To read attributes in your log handler:
|
||||
|
||||
```swift
|
||||
public func log(event: LogEvent) {
|
||||
// Merge handler metadata, provider metadata, and event metadata as usual
|
||||
var merged = self.metadata
|
||||
|
||||
if let provider = self.metadataProvider {
|
||||
merged.merge(provider.get(), uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
|
||||
if let eventMetadata = event.metadata {
|
||||
merged.merge(eventMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
|
||||
// Read attributes from individual values:
|
||||
for (key, value) in merged {
|
||||
let attributes = value.attributes // Empty if the value carries no attributes
|
||||
|
||||
// Process based on your handler's needs
|
||||
// For example, check for a custom attribute:
|
||||
// if attributes[MyAttribute.self] == .flagged { ... }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Key considerations:**
|
||||
|
||||
- **Opt-in inspection**: Attributes are invisible unless you call `value.attributes`. Handlers that do not care about
|
||||
attributes work without any changes.
|
||||
|
||||
- **No new protocol requirements**: Reading attributes does not require implementing any new `LogHandler` properties
|
||||
or subscripts. The `metadata` property and `metadataKey` subscript work exactly as before.
|
||||
|
||||
- **Attributes flow through metadata**: Attributed values flow naturally through metadata merging, `MetadataProvider`,
|
||||
and `MultiplexLogHandler` — no special handling needed.
|
||||
|
||||
### Performance considerations
|
||||
|
||||
1. **Avoid blocking**: Don't block the calling thread for I/O operations.
|
||||
|
||||
@@ -125,13 +125,11 @@ extension Logger.MetadataValueAttributes {
|
||||
/// ``MetadataValueAttributes``. Each conforming type acts as both the key (identified
|
||||
/// by its metatype) and the value.
|
||||
///
|
||||
/// This protocol is designed for **small, fixed-vocabulary attributes** represented as
|
||||
/// enums. Each attribute value is stored as an `Int64` raw value, so attributes occupy minimal
|
||||
/// This protocol is designed for **small, fixed-vocabulary attributes**.
|
||||
/// Each attribute value is stored as an `Int64` raw value, so attributes occupy minimal
|
||||
/// space (one inline slot without heap allocation for the common single-attribute case).
|
||||
/// Attributes that need to carry associated data, strings, or richer payloads are outside
|
||||
/// the scope of this protocol.
|
||||
///
|
||||
/// ## Example
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```swift
|
||||
/// public enum Priority: Int64, Sendable, Logger.MetadataValueAttributes.Attribute {
|
||||
@@ -139,6 +137,17 @@ extension Logger.MetadataValueAttributes {
|
||||
/// case high = 2
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// ```swift
|
||||
/// public struct Priority: Sendable, Hashable, Logger.MetadataValueAttributes.Attribute {
|
||||
/// public let rawValue: Int64
|
||||
/// public init(rawValue: Int64) {
|
||||
/// self.rawValue = rawValue
|
||||
/// }
|
||||
/// public static let low = Priority(rawValue: 1)
|
||||
/// public static let high = Priority(rawValue: 2)
|
||||
/// }
|
||||
/// ```
|
||||
public protocol Attribute: Sendable,
|
||||
RawRepresentable where RawValue == Int64 {}
|
||||
}
|
||||
@@ -152,10 +161,6 @@ the attribute at runtime — no coordination between packages is needed.
|
||||
```swift
|
||||
extension Logger {
|
||||
/// Attributes that can be associated with metadata values.
|
||||
///
|
||||
/// `MetadataValueAttributes` stores one attribute inline without heap allocation. When more than one attribute
|
||||
/// is needed, additional attributes spill over to a heap-allocated array.
|
||||
/// Use the generic subscript to get/set attributes by their ``Attribute`` type.
|
||||
public struct MetadataValueAttributes: Sendable, Equatable, ExpressibleByArrayLiteral {
|
||||
/// Nested ``Attribute`` protocol (see above).
|
||||
public protocol Attribute: Sendable, RawRepresentable where RawValue == Int64 {}
|
||||
|
||||
@@ -5,3 +5,15 @@
|
||||
### Creating a log event
|
||||
|
||||
- ``init(level:message:metadata:source:file:function:line:)``
|
||||
- ``init(level:message:error:metadata:source:file:function:line:)``
|
||||
|
||||
### Inspecting a log event
|
||||
|
||||
- ``level``
|
||||
- ``message``
|
||||
- ``error``
|
||||
- ``metadata``
|
||||
- ``source``
|
||||
- ``file``
|
||||
- ``function``
|
||||
- ``line``
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
### Creating a metadata provider
|
||||
|
||||
- ``init(_:)``
|
||||
- ``init(_:)-(()->Logger.Metadata)``
|
||||
|
||||
### Invoking the provider
|
||||
|
||||
|
||||
@@ -66,6 +66,10 @@
|
||||
- ``subscript(metadataKey:)``
|
||||
- ``MetadataValue``
|
||||
|
||||
### Metadata attribute types
|
||||
|
||||
- ``MetadataValueAttributes``
|
||||
|
||||
### Inspecting a logger
|
||||
|
||||
- ``label``
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
# ``Logging/SwiftLogNoOpLogHandler``
|
||||
|
||||
A log handler that silently discards all log messages.
|
||||
|
||||
## Topics
|
||||
|
||||
### Creating a Swift Log no-op log handler
|
||||
|
||||
@@ -17,7 +17,7 @@ This separation allows libraries to adopt the API while applications choose any
|
||||
compatible logging backend implementation without requiring changes from
|
||||
libraries.
|
||||
|
||||
## Getting Started
|
||||
### Getting Started
|
||||
|
||||
Use this package if you're writing a cross-platform application (for example, Linux and
|
||||
macOS) or library, and want to target this logging API.
|
||||
|
||||
@@ -30,12 +30,9 @@ public struct LogEvent: Sendable {
|
||||
public var error: (any Error)?
|
||||
|
||||
/// The metadata associated with this event, if any.
|
||||
public var metadata: Logger.Metadata? {
|
||||
get { self._metadata }
|
||||
set { self._metadata = newValue }
|
||||
}
|
||||
|
||||
private var _metadata: Logger.Metadata?
|
||||
///
|
||||
/// Metadata values may carry attributes accessible via ``Logger/MetadataValue/attributes``.
|
||||
public var metadata: Logger.Metadata?
|
||||
|
||||
/// The source where this log event originated, for example the logging module.
|
||||
///
|
||||
@@ -116,7 +113,7 @@ public struct LogEvent: Sendable {
|
||||
self.level = level
|
||||
self.message = message
|
||||
self.error = error
|
||||
self._metadata = metadata
|
||||
self.metadata = metadata
|
||||
self._source = source
|
||||
self.file = file
|
||||
self.function = function
|
||||
|
||||
@@ -0,0 +1,432 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// MARK: - MetadataValueAttributes storage
|
||||
|
||||
extension Logger {
|
||||
/// Attributes that can be associated with metadata values.
|
||||
public struct MetadataValueAttributes: Sendable {
|
||||
/// A protocol for defining custom metadata attributes.
|
||||
///
|
||||
/// Conform to this protocol to define a custom attribute that can be stored in
|
||||
/// ``MetadataValueAttributes``. Each conforming type acts as both the key (identified
|
||||
/// by its metatype) and the value.
|
||||
///
|
||||
/// This protocol is designed for **small, fixed-vocabulary attributes**.
|
||||
/// Each attribute value is stored as an `Int64` raw value, so attributes occupy minimal
|
||||
/// space (one inline slot without heap allocation for the common single-attribute case).
|
||||
///
|
||||
/// ## Examples
|
||||
///
|
||||
/// ```swift
|
||||
/// public enum Priority: Int64, Sendable, Logger.MetadataValueAttributes.Attribute {
|
||||
/// case low = 1
|
||||
/// case high = 2
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// ```swift
|
||||
/// public struct Priority: Sendable, Hashable, Logger.MetadataValueAttributes.Attribute {
|
||||
/// public let rawValue: Int64
|
||||
/// public init(rawValue: Int64) {
|
||||
/// self.rawValue = rawValue
|
||||
/// }
|
||||
/// public static let low = Priority(rawValue: 1)
|
||||
/// public static let high = Priority(rawValue: 2)
|
||||
/// }
|
||||
/// ```
|
||||
public protocol Attribute: Sendable, RawRepresentable where RawValue == Int64 {}
|
||||
|
||||
/// An entry in the metadata attributes storage.
|
||||
@usableFromInline
|
||||
internal struct Entry: Sendable, Equatable {
|
||||
@usableFromInline
|
||||
internal var key: ObjectIdentifier
|
||||
|
||||
@usableFromInline
|
||||
internal var value: Int64
|
||||
|
||||
@inlinable
|
||||
internal init(key: ObjectIdentifier, value: Int64) {
|
||||
self.key = key
|
||||
self.value = value
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var _inline: Entry?
|
||||
|
||||
@usableFromInline
|
||||
internal var _overflow: [Entry]?
|
||||
|
||||
/// Create empty metadata value attributes.
|
||||
@inlinable
|
||||
public init() {}
|
||||
|
||||
/// Get or set a custom attribute by its type.
|
||||
///
|
||||
/// - Parameter attribute: The metatype of the attribute to access.
|
||||
/// - Returns: The attribute value, or `nil` if not set.
|
||||
@inlinable
|
||||
public subscript<Attr: Attribute>(attribute: Attr.Type) -> Attr? {
|
||||
get {
|
||||
let id = ObjectIdentifier(Attr.self)
|
||||
if let inline = self._inline, inline.key == id { return Attr(rawValue: inline.value) }
|
||||
if let overflow = self._overflow {
|
||||
for entry in overflow {
|
||||
if entry.key == id { return Attr(rawValue: entry.value) }
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
set {
|
||||
let id = ObjectIdentifier(Attr.self)
|
||||
if let v = newValue {
|
||||
self._upsert(key: id, value: v.rawValue)
|
||||
} else {
|
||||
self._remove(key: id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _upsert(key id: ObjectIdentifier, value: Int64) {
|
||||
let entry = Entry(key: id, value: value)
|
||||
if let inline = self._inline, inline.key == id {
|
||||
self._inline = entry
|
||||
return
|
||||
}
|
||||
if let idx = self._overflow?.firstIndex(where: { $0.key == id }) {
|
||||
self._overflow?[idx] = entry
|
||||
return
|
||||
}
|
||||
if self._inline == nil {
|
||||
self._inline = entry
|
||||
} else {
|
||||
if self._overflow == nil {
|
||||
self._overflow = [entry]
|
||||
} else {
|
||||
self._overflow?.append(entry)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _remove(key id: ObjectIdentifier) {
|
||||
if let inline = self._inline, inline.key == id {
|
||||
if var overflow = self._overflow, !overflow.isEmpty {
|
||||
self._inline = overflow.removeLast()
|
||||
self._overflow = overflow.isEmpty ? nil : overflow
|
||||
} else {
|
||||
self._inline = nil
|
||||
}
|
||||
return
|
||||
}
|
||||
if let idx = self._overflow?.firstIndex(where: { $0.key == id }) {
|
||||
self._overflow?.remove(at: idx)
|
||||
if self._overflow?.isEmpty == true {
|
||||
self._overflow = nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func _merge(from other: Self) {
|
||||
if let inline = other._inline {
|
||||
self._upsert(key: inline.key, value: inline.value)
|
||||
}
|
||||
if let overflow = other._overflow {
|
||||
for entry in overflow {
|
||||
self._upsert(key: entry.key, value: entry.value)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Compare all entries as an unordered set.
|
||||
///
|
||||
/// The inline slot and overflow array may hold the same logical entries in different
|
||||
/// positions depending on insertion order. This method checks set equality by
|
||||
/// verifying that every entry on one side exists on the other. O(n²) but n is
|
||||
/// typically 1–2.
|
||||
@inlinable
|
||||
internal func _isEqual(to other: Self) -> Bool {
|
||||
let lhsOverflowCount = self._overflow?.count ?? 0
|
||||
let rhsOverflowCount = other._overflow?.count ?? 0
|
||||
let lhsCount = (self._inline != nil ? 1 : 0) + lhsOverflowCount
|
||||
let rhsCount = (other._inline != nil ? 1 : 0) + rhsOverflowCount
|
||||
guard lhsCount == rhsCount else { return false }
|
||||
guard lhsCount > 0 else { return true }
|
||||
|
||||
// Check that every lhs entry exists in rhs.
|
||||
// With matching counts, this is sufficient for set equality.
|
||||
if let inline = self._inline {
|
||||
if !other._contains(inline) { return false }
|
||||
}
|
||||
if let overflow = self._overflow {
|
||||
for entry in overflow {
|
||||
if !other._contains(entry) { return false }
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func _contains(_ entry: Entry) -> Bool {
|
||||
if self._inline == entry { return true }
|
||||
if let overflow = self._overflow {
|
||||
for e in overflow {
|
||||
if e == entry { return true }
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger.MetadataValueAttributes: Equatable {
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs._isEqual(to: rhs)
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger.MetadataValueAttributes: ExpressibleByArrayLiteral {
|
||||
/// Creates metadata value attributes from an array literal of attribute values.
|
||||
///
|
||||
/// Each element is any ``Attribute`` conforming value. The key is
|
||||
/// inferred from the concrete type of the value.
|
||||
///
|
||||
/// ```swift
|
||||
/// let attrs: Logger.MetadataValueAttributes = [Sensitivity.sensitive, ValueType.int64]
|
||||
/// ```
|
||||
/// Each element goes through existential boxing to extract `type(of:)` and `.rawValue`.
|
||||
/// This is acceptable for a literal initializer but should not be used in hot paths;
|
||||
/// prefer the type-safe subscript (`attrs[SomeAttribute.self] = value`) for performance-sensitive code.
|
||||
@inlinable
|
||||
public init(arrayLiteral elements: any Logger.MetadataValueAttributes.Attribute...) {
|
||||
self.init()
|
||||
for element in elements {
|
||||
self._upsert(key: ObjectIdentifier(type(of: element)), value: element.rawValue)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - AttributedStringCarrier
|
||||
|
||||
extension Logger {
|
||||
/// Internal carrier that wraps a string with metadata attributes.
|
||||
///
|
||||
/// Produced by `MetadataValue.StringInterpolation` when any interpolation
|
||||
/// segment specifies attributes, or by ``MetadataValue/attributed(_:attributes:)``.
|
||||
/// This is the only type that carries attributes; the `.attributes` property on
|
||||
/// `MetadataValue` checks for it with a concrete type comparison rather than a
|
||||
/// protocol conformance lookup.
|
||||
@usableFromInline
|
||||
internal struct AttributedStringCarrier: CustomStringConvertible, Sendable {
|
||||
@usableFromInline
|
||||
internal let string: String
|
||||
|
||||
@usableFromInline
|
||||
internal let metadataAttributes: Logger.MetadataValueAttributes
|
||||
|
||||
@usableFromInline
|
||||
internal init(string: String, metadataAttributes: Logger.MetadataValueAttributes) {
|
||||
self.string = string
|
||||
self.metadataAttributes = metadataAttributes
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var description: String { self.string }
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - MetadataValue attributes API
|
||||
|
||||
extension Logger.MetadataValue {
|
||||
/// The attributes associated with this metadata value, if any.
|
||||
///
|
||||
/// **Getting:** When the value is a ``stringConvertible(_:)`` wrapping an
|
||||
/// `AttributedStringCarrier`, returns that carrier's attributes.
|
||||
/// For all other cases returns empty attributes.
|
||||
///
|
||||
/// **Setting:** Replaces the value with `.stringConvertible(AttributedStringCarrier(...))`
|
||||
/// carrying the given attributes. For `.string` and `.stringConvertible` cases the string
|
||||
/// representation is preserved. For `.dictionary` and `.array` cases the setter is a no-op.
|
||||
///
|
||||
/// Only handlers that inspect attributes pay the cost of the getter check.
|
||||
@inlinable
|
||||
public var attributes: Logger.MetadataValueAttributes {
|
||||
get {
|
||||
if case .stringConvertible(let box) = self,
|
||||
let carrier = box as? Logger.AttributedStringCarrier
|
||||
{
|
||||
return carrier.metadataAttributes
|
||||
}
|
||||
return .init()
|
||||
}
|
||||
set {
|
||||
switch self {
|
||||
case .string(let s):
|
||||
self = .stringConvertible(
|
||||
Logger.AttributedStringCarrier(string: s, metadataAttributes: newValue)
|
||||
)
|
||||
case .stringConvertible(let box):
|
||||
self = .stringConvertible(
|
||||
Logger.AttributedStringCarrier(string: box.description, metadataAttributes: newValue)
|
||||
)
|
||||
case .dictionary, .array:
|
||||
assertionFailure("Cannot set attributes on .dictionary or .array metadata values")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates an attributed metadata value from a string-convertible value and attributes.
|
||||
///
|
||||
/// This is a convenience factory that behaves like an additional enum case, producing
|
||||
/// a `.stringConvertible(AttributedStringCarrier(...))` value without string interpolation:
|
||||
///
|
||||
/// ```swift
|
||||
/// let value: Logger.MetadataValue = .attributed(userId, attributes: [Sensitivity.sensitive])
|
||||
/// ```
|
||||
@inlinable
|
||||
public static func attributed(
|
||||
_ value: some CustomStringConvertible & Sendable,
|
||||
attributes: Logger.MetadataValueAttributes
|
||||
) -> Self {
|
||||
.stringConvertible(
|
||||
Logger.AttributedStringCarrier(
|
||||
string: String(describing: value),
|
||||
metadataAttributes: attributes
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Attributed string interpolation
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringInterpolation {
|
||||
/// Custom string interpolation that optionally captures metadata attributes.
|
||||
///
|
||||
/// When no attributes are specified, produces `.string(...)` — identical to the
|
||||
/// default `DefaultStringInterpolation` behavior. When any interpolation segment
|
||||
/// specifies attributes (via the `attributes:` parameter), the result is
|
||||
/// `.stringConvertible(AttributedStringCarrier(...))` carrying both the string
|
||||
/// and the accumulated attributes.
|
||||
///
|
||||
/// Attribute packages (like `LoggingAttributes`) can add overloads with
|
||||
/// domain-specific parameters (e.g. `sensitivity:`) that call through to
|
||||
/// `appendInterpolation(_:attributes:)`.
|
||||
public struct StringInterpolation: StringInterpolationProtocol, Sendable {
|
||||
@usableFromInline
|
||||
internal var output: String = ""
|
||||
|
||||
@usableFromInline
|
||||
internal var attributes: Logger.MetadataValueAttributes = .init()
|
||||
|
||||
@usableFromInline
|
||||
internal var hasAttributes: Bool = false
|
||||
|
||||
@inlinable
|
||||
public init(literalCapacity: Int, interpolationCount: Int) {
|
||||
self.output.reserveCapacity(literalCapacity + interpolationCount * 2)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func appendLiteral(_ literal: String) {
|
||||
self.output.append(literal)
|
||||
}
|
||||
|
||||
/// Interpolation with a custom attributes closure.
|
||||
///
|
||||
/// When called, the result will be `.stringConvertible(AttributedStringCarrier(...))`
|
||||
/// instead of `.string(...)`.
|
||||
///
|
||||
/// ```swift
|
||||
/// "\(userId, attributes: { $0[MyAttribute.self] = .flagged })"
|
||||
/// ```
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T>(
|
||||
_ value: T,
|
||||
attributes: @Sendable (inout Logger.MetadataValueAttributes) -> Void
|
||||
) where T: CustomStringConvertible & Sendable {
|
||||
self.output.append(value.description)
|
||||
attributes(&self.attributes)
|
||||
self.hasAttributes = true
|
||||
}
|
||||
|
||||
/// Interpolation with pre-built attributes.
|
||||
///
|
||||
/// ```swift
|
||||
/// "\(userId, attributes: [Sensitivity.sensitive])"
|
||||
/// ```
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T>(
|
||||
_ value: T,
|
||||
attributes: Logger.MetadataValueAttributes
|
||||
) where T: CustomStringConvertible & Sendable {
|
||||
self.output.append(value.description)
|
||||
if self.hasAttributes {
|
||||
self.attributes._merge(from: attributes)
|
||||
} else {
|
||||
self.attributes = attributes
|
||||
}
|
||||
self.hasAttributes = true
|
||||
}
|
||||
|
||||
/// Plain interpolation without attributes.
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T>(
|
||||
_ value: T
|
||||
) where T: CustomStringConvertible & Sendable {
|
||||
self.output.append(value.description)
|
||||
}
|
||||
|
||||
/// Fallback interpolation for types that are not `CustomStringConvertible`.
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T>(
|
||||
_ value: T
|
||||
) where T: Sendable {
|
||||
self.output.append(String(describing: value))
|
||||
}
|
||||
|
||||
/// Unconstrained fallback for non-`Sendable` types.
|
||||
@inlinable
|
||||
public mutating func appendInterpolation<T>(
|
||||
_ value: T
|
||||
) {
|
||||
self.output.append(String(describing: value))
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a metadata value from string interpolation.
|
||||
///
|
||||
/// If any interpolation segment specified attributes, the result is
|
||||
/// `.stringConvertible(AttributedStringCarrier(...))`. Otherwise, `.string(...)`.
|
||||
@inlinable
|
||||
public init(stringInterpolation: StringInterpolation) {
|
||||
if stringInterpolation.hasAttributes {
|
||||
self = .stringConvertible(
|
||||
Logger.AttributedStringCarrier(
|
||||
string: stringInterpolation.output,
|
||||
metadataAttributes: stringInterpolation.attributes
|
||||
)
|
||||
)
|
||||
} else {
|
||||
self = .string(stringInterpolation.output)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -251,6 +251,7 @@ extension Logger {
|
||||
/// - parameters:
|
||||
/// - level: The severity level of the `message`.
|
||||
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
|
||||
/// - error: An `Error` related to the event.
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log message originates from. The value defaults
|
||||
/// to the module that emits the log message.
|
||||
@@ -313,9 +314,23 @@ extension Logger {
|
||||
function: String = #function,
|
||||
line: UInt = #line
|
||||
) {
|
||||
self.log(level: level, message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
|
||||
self.log(
|
||||
level: level,
|
||||
message(),
|
||||
error: nil,
|
||||
metadata: metadata(),
|
||||
source: nil,
|
||||
file: file,
|
||||
function: function,
|
||||
line: line
|
||||
)
|
||||
}
|
||||
|
||||
/// Log a message using the log level and attributed metadata that you provide.
|
||||
///
|
||||
/// If the `logLevel` passed to this method is more severe than the `Logger`'s ``logLevel``, the library
|
||||
/// logs the message, otherwise nothing will happen.
|
||||
///
|
||||
/// Add, change, or remove a logging metadata item.
|
||||
///
|
||||
/// > Note: Changing the logging metadata only affects the instance of the `Logger` where you change it.
|
||||
@@ -1161,6 +1176,9 @@ extension Logger {
|
||||
/// `.array([.string("foo"), .string("bar \(buz)")])`, instead use the more natural `["foo", "bar \(buz)"]`.
|
||||
case array([Metadata.Value])
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger {
|
||||
|
||||
/// The log level.
|
||||
///
|
||||
@@ -1408,10 +1426,6 @@ extension Logger.MetadataValue: CustomStringConvertible {
|
||||
}
|
||||
}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringInterpolation {}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9686
|
||||
extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
|
||||
@@ -1443,6 +1457,7 @@ extension Logger.MetadataValue: ExpressibleByArrayLiteral {
|
||||
// MARK: - Sendable support helpers
|
||||
|
||||
extension Logger.MetadataValue: Sendable {}
|
||||
|
||||
extension Logger: Sendable {}
|
||||
extension Logger.Level: Sendable {}
|
||||
extension Logger.Message: Sendable {}
|
||||
@@ -53,12 +53,24 @@ extension Logger {
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// ### Metadata with Attributes
|
||||
///
|
||||
/// Metadata providers can return values that carry attributes via string interpolation:
|
||||
///
|
||||
/// ```swift
|
||||
/// let provider = Logger.MetadataProvider {
|
||||
/// [
|
||||
/// "trace-id": "\(Baggage.current?.traceID, sensitivity: .public)",
|
||||
/// "user-id": "\(RequestContext.current.userId, sensitivity: .sensitive)"
|
||||
/// ]
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// We recommend referring to [swift-distributed-tracing](https://github.com/apple/swift-distributed-tracing)
|
||||
/// for metadata providers which make use of its tracing and metadata propagation infrastructure. It is however
|
||||
/// possible to make use of metadata providers independently of tracing and instruments provided by that library,
|
||||
/// if necessary.
|
||||
public struct MetadataProvider: _SwiftLogSendable {
|
||||
/// Provide ``Logger.Metadata`` from the current context.
|
||||
@usableFromInline
|
||||
internal let _provideMetadata: @Sendable () -> Metadata
|
||||
|
||||
@@ -70,6 +82,8 @@ extension Logger {
|
||||
}
|
||||
|
||||
/// Invokes the metadata provider and returns the generated contextual metadata.
|
||||
///
|
||||
/// - Returns: Metadata dictionary, where values may carry attributes.
|
||||
public func get() -> Metadata {
|
||||
self._provideMetadata()
|
||||
}
|
||||
@@ -88,13 +102,12 @@ extension Logger.MetadataProvider {
|
||||
/// - Returns: A pseudo-`MetadataProvider` merging metadata from the given `MetadataProvider`s.
|
||||
public static func multiplex(_ providers: [Logger.MetadataProvider]) -> Logger.MetadataProvider? {
|
||||
assert(!providers.isEmpty, "providers MUST NOT be empty")
|
||||
|
||||
return Logger.MetadataProvider {
|
||||
providers.reduce(into: [:]) { metadata, provider in
|
||||
let providedMetadata = provider.get()
|
||||
guard !providedMetadata.isEmpty else {
|
||||
return
|
||||
}
|
||||
metadata.merge(providedMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
providers.reduce(into: Logger.Metadata()) { merged, provider in
|
||||
let provided = provider.get()
|
||||
guard !provided.isEmpty else { return }
|
||||
merged.merge(provided, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,15 +22,10 @@ struct InMemoryLogHandlerTests {
|
||||
let (logHandler, logger) = self.makeTestLogger()
|
||||
logger.info("hello", metadata: ["key1": "value1", "key2": ["a", "b", "c"]])
|
||||
|
||||
#expect(
|
||||
logHandler.entries == [
|
||||
InMemoryLogHandler.Entry(
|
||||
level: .info,
|
||||
message: "hello",
|
||||
metadata: ["key1": "value1", "key2": ["a", "b", "c"]]
|
||||
)
|
||||
]
|
||||
)
|
||||
#expect(logHandler.entries.count == 1)
|
||||
#expect(logHandler.entries[0].level == .info)
|
||||
#expect(logHandler.entries[0].message == "hello")
|
||||
#expect(logHandler.entries[0].metadata == ["key1": "value1", "key2": ["a", "b", "c"]])
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -39,16 +34,10 @@ struct InMemoryLogHandlerTests {
|
||||
logger[metadataKey: "test"] = "value"
|
||||
logger.info("hello", metadata: ["key1": "value1", "key2": ["a", "b", "c"]])
|
||||
|
||||
#expect(
|
||||
logHandler.entries == [
|
||||
InMemoryLogHandler.Entry(
|
||||
level: .info,
|
||||
message: "hello",
|
||||
metadata: ["key1": "value1", "key2": ["a", "b", "c"], "test": "value"]
|
||||
)
|
||||
]
|
||||
)
|
||||
// Metadata also sticks onto the logger
|
||||
#expect(logHandler.entries.count == 1)
|
||||
#expect(logHandler.entries[0].level == .info)
|
||||
#expect(logHandler.entries[0].message == "hello")
|
||||
#expect(logHandler.entries[0].metadata == ["key1": "value1", "key2": ["a", "b", "c"], "test": "value"])
|
||||
#expect(logger[metadataKey: "test"] == "value")
|
||||
}
|
||||
|
||||
@@ -62,11 +51,54 @@ struct InMemoryLogHandlerTests {
|
||||
logger[metadataKey: "c"] = "2"
|
||||
logger.info("hello", metadata: ["c": "3"])
|
||||
|
||||
#expect(
|
||||
logHandler.entries == [
|
||||
InMemoryLogHandler.Entry(level: .info, message: "hello", metadata: ["a": "1", "b": "2", "c": "3"])
|
||||
#expect(logHandler.entries.count == 1)
|
||||
#expect(logHandler.entries[0].level == .info)
|
||||
#expect(logHandler.entries[0].message == "hello")
|
||||
#expect(logHandler.entries[0].metadata == ["a": "1", "b": "1", "c": "3"])
|
||||
}
|
||||
|
||||
@Test
|
||||
func clear() {
|
||||
let (logHandler, logger) = self.makeTestLogger()
|
||||
logger.info("hello", metadata: ["key1": "value1", "key2": ["a", "b", "c"]])
|
||||
logHandler.clear()
|
||||
logger.info("hello2")
|
||||
|
||||
#expect(logHandler.entries.count == 1)
|
||||
#expect(logHandler.entries[0].level == .info)
|
||||
#expect(logHandler.entries[0].message == "hello2")
|
||||
#expect(logHandler.entries[0].metadata == [:])
|
||||
}
|
||||
|
||||
@Test
|
||||
func metadataWithAttributesIsPreservedInEntry() {
|
||||
var (logHandler, logger) = self.makeTestLogger()
|
||||
logger.logLevel = .trace
|
||||
logger[metadataKey: "global"] = "value"
|
||||
|
||||
logger.log(
|
||||
level: .info,
|
||||
"test",
|
||||
metadata: [
|
||||
"key": "\("value", attributes: { _ in })"
|
||||
]
|
||||
)
|
||||
|
||||
#expect(logHandler.entries.count == 1)
|
||||
#expect(logHandler.entries[0].metadata["key"]?.description == "value")
|
||||
#expect(logHandler.entries[0].metadata["global"]?.description == "value")
|
||||
}
|
||||
|
||||
private func makeTestLogger(metadataProvider: Logger.MetadataProvider? = nil) -> (InMemoryLogHandler, Logger) {
|
||||
var logHandler = InMemoryLogHandler()
|
||||
logHandler.metadataProvider = metadataProvider
|
||||
let logger = Logger(
|
||||
label: "MyApp",
|
||||
factory: { _ in
|
||||
logHandler
|
||||
}
|
||||
)
|
||||
return (logHandler, logger)
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -81,7 +113,7 @@ struct InMemoryLogHandlerTests {
|
||||
level: .info,
|
||||
message: "hello",
|
||||
error: TestError.first,
|
||||
metadata: [:],
|
||||
metadata: [:]
|
||||
)
|
||||
)
|
||||
|
||||
@@ -91,7 +123,7 @@ struct InMemoryLogHandlerTests {
|
||||
level: .info,
|
||||
message: "hello",
|
||||
error: nil,
|
||||
metadata: [:],
|
||||
metadata: [:]
|
||||
)
|
||||
)
|
||||
|
||||
@@ -116,33 +148,6 @@ struct InMemoryLogHandlerTests {
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
func clear() {
|
||||
let (logHandler, logger) = self.makeTestLogger()
|
||||
logger.info("hello", metadata: ["key1": "value1", "key2": ["a", "b", "c"]])
|
||||
logHandler.clear()
|
||||
logger.info("hello2")
|
||||
|
||||
// Only hello2 is here
|
||||
#expect(
|
||||
logHandler.entries == [
|
||||
InMemoryLogHandler.Entry(level: .info, message: "hello2", metadata: [:])
|
||||
]
|
||||
)
|
||||
}
|
||||
|
||||
private func makeTestLogger(metadataProvider: Logger.MetadataProvider? = nil) -> (InMemoryLogHandler, Logger) {
|
||||
var logHandler = InMemoryLogHandler()
|
||||
logHandler.metadataProvider = metadataProvider
|
||||
let logger = Logger(
|
||||
label: "MyApp",
|
||||
factory: { _ in
|
||||
logHandler
|
||||
}
|
||||
)
|
||||
return (logHandler, logger)
|
||||
}
|
||||
|
||||
enum TestError: Error {
|
||||
case first
|
||||
case second
|
||||
|
||||
@@ -98,6 +98,65 @@ struct LogEventTest {
|
||||
#expect(event.metadata == nil)
|
||||
}
|
||||
|
||||
// MARK: - Attributes on metadata values
|
||||
|
||||
@Test func metadataValueCarriesAttributesThroughStringInterpolation() {
|
||||
enum TestAttr: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case flagged = 1
|
||||
}
|
||||
|
||||
let value: Logger.MetadataValue = "\("secret", attributes: { $0[TestAttr.self] = .flagged })"
|
||||
#expect(value.attributes[TestAttr.self] == .flagged)
|
||||
#expect(value.description == "secret")
|
||||
}
|
||||
|
||||
@Test func metadataValueWithoutAttributesProducesString() {
|
||||
let value: Logger.MetadataValue = "\("plain")"
|
||||
#expect(value.attributes == Logger.MetadataValueAttributes())
|
||||
|
||||
if case .string(let s) = value {
|
||||
#expect(s == "plain")
|
||||
} else {
|
||||
Issue.record("Expected .string case for non-attributed interpolation")
|
||||
}
|
||||
}
|
||||
|
||||
@Test func metadataValueAttributesAreEmptyForPlainValues() {
|
||||
let values: [Logger.MetadataValue] = [
|
||||
.string("test"),
|
||||
.stringConvertible(42),
|
||||
.array(["a", "b"]),
|
||||
.dictionary(["k": "v"]),
|
||||
]
|
||||
for value in values {
|
||||
#expect(value.attributes == Logger.MetadataValueAttributes())
|
||||
}
|
||||
}
|
||||
|
||||
@Test func metadataValuesWithAttributesFlowThroughLogEvent() {
|
||||
enum TestAttr: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case flagged = 1
|
||||
}
|
||||
|
||||
let event = LogEvent(
|
||||
level: .info,
|
||||
message: "test",
|
||||
error: nil,
|
||||
metadata: [
|
||||
"secret": "\("value", attributes: { $0[TestAttr.self] = .flagged })",
|
||||
"plain": "no-attrs",
|
||||
],
|
||||
source: nil,
|
||||
file: "M/F.swift",
|
||||
function: "f()",
|
||||
line: 1
|
||||
)
|
||||
|
||||
#expect(event.metadata?["secret"]?.attributes[TestAttr.self] == .flagged)
|
||||
#expect(event.metadata?["secret"]?.description == "value")
|
||||
#expect(event.metadata?["plain"]?.attributes[TestAttr.self] == nil)
|
||||
}
|
||||
|
||||
@Test func loggerDerivedSourceMatchesModuleName() {
|
||||
let recorder = Recorder()
|
||||
let handler = LogEventHandler(recorder: recorder)
|
||||
|
||||
@@ -17,6 +17,11 @@ import Testing
|
||||
|
||||
@testable import Logging
|
||||
|
||||
private enum TestAttr: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case x = 1
|
||||
case y = 2
|
||||
}
|
||||
|
||||
extension LogHandler {
|
||||
fileprivate func with(logLevel: Logger.Level) -> any LogHandler {
|
||||
var result = self
|
||||
@@ -852,6 +857,73 @@ struct LoggingTest {
|
||||
logger1.error("hey")
|
||||
}
|
||||
|
||||
@Test func multiplexLogHandlerMetadataWithAttributes_settingAndReading() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
let logger1 = logging1.make(label: "1")
|
||||
let logger2 = logging2.make(label: "2")
|
||||
|
||||
var multiplexLogger = Logger(
|
||||
label: "test",
|
||||
factory: { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
)
|
||||
|
||||
// Set metadata with attributes via string interpolation
|
||||
multiplexLogger[metadataKey: "key1"] = "\("value1", attributes: { $0[TestAttr.self] = .x })"
|
||||
|
||||
// The value survives the round-trip
|
||||
let retrieved = multiplexLogger[metadataKey: "key1"]
|
||||
#expect(retrieved != nil)
|
||||
#expect(retrieved?.description == "value1")
|
||||
|
||||
// Attributes are preserved inside .stringConvertible
|
||||
#expect(retrieved?.attributes[TestAttr.self] == .x)
|
||||
}
|
||||
|
||||
@Test func multiplexLogHandlerMetadataWithAttributes_forwardsEventWithAttributes() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger = Logger(
|
||||
label: "test",
|
||||
factory: {
|
||||
MultiplexLogHandler([logging1.make(label: $0), logging2.make(label: $0)])
|
||||
}
|
||||
)
|
||||
logger.logLevel = .debug
|
||||
|
||||
// Log with metadata containing attributed values
|
||||
logger.info("hello", metadata: ["request-id": "\("abc123")"])
|
||||
|
||||
// Both handlers should receive the message
|
||||
logging1.history.assertExist(level: .info, message: "hello")
|
||||
logging2.history.assertExist(level: .info, message: "hello")
|
||||
}
|
||||
|
||||
@Test func metadataWithAttributes_flowsThroughHandler() {
|
||||
let logging = TestLogging()
|
||||
|
||||
var logger = Logger(
|
||||
label: "test",
|
||||
factory: { logging.make(label: $0) }
|
||||
)
|
||||
logger.logLevel = .debug
|
||||
|
||||
// Log with metadata values that carry attributes
|
||||
logger.info(
|
||||
"attributed event",
|
||||
metadata: [
|
||||
"user-id": "\("12345", attributes: { $0[TestAttr.self] = .x })"
|
||||
]
|
||||
)
|
||||
|
||||
// The handler should receive the message via LogEvent
|
||||
logging.history.assertExist(level: .info, message: "attributed event")
|
||||
}
|
||||
|
||||
/// Protects an object such that it can only be accessed while holding a lock.
|
||||
private final class LockedValueBox<Value: Sendable>: @unchecked Sendable {
|
||||
private let lock = Lock()
|
||||
|
||||
@@ -0,0 +1,443 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 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 Logging
|
||||
import Testing
|
||||
|
||||
// MARK: - Test Attribute Keys
|
||||
|
||||
enum AttrA: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case a1 = 1
|
||||
case a2 = 2
|
||||
}
|
||||
|
||||
enum AttrB: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case b1 = 1
|
||||
case b2 = 2
|
||||
}
|
||||
|
||||
enum AttrC: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case c1 = 1
|
||||
case c2 = 2
|
||||
}
|
||||
|
||||
enum AttrD: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case d1 = 1
|
||||
case d2 = 2
|
||||
}
|
||||
|
||||
enum AttrE: Int64, Logger.MetadataValueAttributes.Attribute {
|
||||
case e1 = 1
|
||||
case e2 = 2
|
||||
}
|
||||
|
||||
// MARK: - Tests
|
||||
|
||||
@Suite("MetadataValueAttributes Tests")
|
||||
struct MetadataAttributesTests {
|
||||
|
||||
@Test("Empty attributes")
|
||||
func testEmpty() {
|
||||
let attrs = Logger.MetadataValueAttributes()
|
||||
#expect(attrs[AttrA.self] == nil)
|
||||
#expect(attrs[AttrB.self] == nil)
|
||||
}
|
||||
|
||||
@Test("Set and get single attribute (inline)")
|
||||
func testSingleInline() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
}
|
||||
|
||||
@Test("Set and get multiple attributes")
|
||||
func testMultipleAttributes() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
attrs[AttrB.self] = .b2
|
||||
attrs[AttrC.self] = .c1
|
||||
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
#expect(attrs[AttrB.self] == .b2)
|
||||
#expect(attrs[AttrC.self] == .c1)
|
||||
}
|
||||
|
||||
@Test("Update existing attribute")
|
||||
func testUpdate() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
|
||||
attrs[AttrA.self] = .a2
|
||||
#expect(attrs[AttrA.self] == .a2)
|
||||
}
|
||||
|
||||
@Test("Remove inline attribute")
|
||||
func testRemoveInline() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
|
||||
attrs[AttrA.self] = nil
|
||||
#expect(attrs[AttrA.self] == nil)
|
||||
}
|
||||
|
||||
@Test("Remove overflow attribute")
|
||||
func testRemoveOverflow() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
attrs[AttrB.self] = .b1
|
||||
attrs[AttrC.self] = .c1
|
||||
|
||||
attrs[AttrB.self] = nil
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
#expect(attrs[AttrB.self] == nil)
|
||||
#expect(attrs[AttrC.self] == .c1)
|
||||
}
|
||||
|
||||
@Test("Remove inline promotes from overflow")
|
||||
func testRemoveInlinePromotesOverflow() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
attrs[AttrB.self] = .b1 // overflow
|
||||
|
||||
// Remove inline — overflow entry should be promoted
|
||||
attrs[AttrA.self] = nil
|
||||
|
||||
#expect(attrs[AttrA.self] == nil)
|
||||
#expect(attrs[AttrB.self] == .b1)
|
||||
}
|
||||
|
||||
@Test("Five attributes")
|
||||
func testFiveAttributes() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
attrs[AttrB.self] = .b1
|
||||
attrs[AttrC.self] = .c1
|
||||
attrs[AttrD.self] = .d1
|
||||
attrs[AttrE.self] = .e1
|
||||
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
#expect(attrs[AttrB.self] == .b1)
|
||||
#expect(attrs[AttrC.self] == .c1)
|
||||
#expect(attrs[AttrD.self] == .d1)
|
||||
#expect(attrs[AttrE.self] == .e1)
|
||||
}
|
||||
|
||||
@Test("Update overflow attribute")
|
||||
func testUpdateOverflow() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = .a1
|
||||
attrs[AttrB.self] = .b1
|
||||
|
||||
attrs[AttrB.self] = .b2
|
||||
#expect(attrs[AttrB.self] == .b2)
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
}
|
||||
|
||||
@Test("Equality with same content")
|
||||
func testEquality() {
|
||||
var attrs1 = Logger.MetadataValueAttributes()
|
||||
attrs1[AttrA.self] = .a1
|
||||
attrs1[AttrB.self] = .b1
|
||||
|
||||
var attrs2 = Logger.MetadataValueAttributes()
|
||||
attrs2[AttrA.self] = .a1
|
||||
attrs2[AttrB.self] = .b1
|
||||
|
||||
#expect(attrs1 == attrs2)
|
||||
|
||||
attrs2[AttrB.self] = .b2
|
||||
#expect(attrs1 != attrs2)
|
||||
}
|
||||
|
||||
@Test("Equality is order-independent")
|
||||
func testOrderIndependentEquality() {
|
||||
var attrs1 = Logger.MetadataValueAttributes()
|
||||
attrs1[AttrA.self] = .a1
|
||||
attrs1[AttrB.self] = .b1
|
||||
attrs1[AttrC.self] = .c1
|
||||
|
||||
var attrs2 = Logger.MetadataValueAttributes()
|
||||
attrs2[AttrC.self] = .c1
|
||||
attrs2[AttrA.self] = .a1
|
||||
attrs2[AttrB.self] = .b1
|
||||
|
||||
#expect(attrs1 == attrs2)
|
||||
}
|
||||
|
||||
@Test("Setting nil on non-existent attribute is no-op")
|
||||
func testSetNilNonExistent() {
|
||||
var attrs = Logger.MetadataValueAttributes()
|
||||
attrs[AttrA.self] = nil
|
||||
#expect(attrs[AttrA.self] == nil)
|
||||
|
||||
attrs[AttrB.self] = .b1
|
||||
attrs[AttrA.self] = nil
|
||||
#expect(attrs[AttrA.self] == nil)
|
||||
#expect(attrs[AttrB.self] == .b1)
|
||||
}
|
||||
|
||||
// MARK: - MetadataValue.attributed factory
|
||||
|
||||
@Test("Create attributed value with .attributed factory")
|
||||
func testAttributedFactory() {
|
||||
let value: Logger.MetadataValue = .attributed("hello", attributes: [AttrA.a1])
|
||||
#expect(value.description == "hello")
|
||||
#expect(value.attributes[AttrA.self] == .a1)
|
||||
}
|
||||
|
||||
@Test("Attributed factory with multiple attributes")
|
||||
func testAttributedFactoryMultipleAttributes() {
|
||||
let value: Logger.MetadataValue = .attributed("test", attributes: [AttrA.a1, AttrB.b2])
|
||||
#expect(value.description == "test")
|
||||
#expect(value.attributes[AttrA.self] == .a1)
|
||||
#expect(value.attributes[AttrB.self] == .b2)
|
||||
}
|
||||
|
||||
@Test("Attributed factory with empty attributes")
|
||||
func testAttributedFactoryEmptyAttributes() {
|
||||
let value: Logger.MetadataValue = .attributed("plain", attributes: .init())
|
||||
#expect(value.description == "plain")
|
||||
#expect(value.attributes[AttrA.self] == nil)
|
||||
}
|
||||
|
||||
@Test("Attributed factory produces same result as string interpolation")
|
||||
func testAttributedFactoryMatchesStringInterpolation() {
|
||||
let factory: Logger.MetadataValue = .attributed("42", attributes: [AttrA.a1])
|
||||
let interpolated: Logger.MetadataValue = "\(42, attributes: [AttrA.a1])"
|
||||
#expect(factory.description == interpolated.description)
|
||||
#expect(factory.attributes == interpolated.attributes)
|
||||
}
|
||||
|
||||
// MARK: - Array literal construction
|
||||
|
||||
@Test("Array literal with single attribute")
|
||||
func testArrayLiteralSingle() {
|
||||
let attrs: Logger.MetadataValueAttributes = [AttrA.a1]
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
}
|
||||
|
||||
@Test("Array literal with multiple attributes")
|
||||
func testArrayLiteralMultiple() {
|
||||
let attrs: Logger.MetadataValueAttributes = [AttrA.a1, AttrB.b2, AttrC.c1]
|
||||
#expect(attrs[AttrA.self] == .a1)
|
||||
#expect(attrs[AttrB.self] == .b2)
|
||||
#expect(attrs[AttrC.self] == .c1)
|
||||
}
|
||||
|
||||
@Test("Array literal with duplicate key uses last value")
|
||||
func testArrayLiteralDuplicateKey() {
|
||||
let attrs: Logger.MetadataValueAttributes = [AttrA.a1, AttrA.a2]
|
||||
#expect(attrs[AttrA.self] == .a2)
|
||||
}
|
||||
|
||||
// MARK: - MetadataValue.attributes setter
|
||||
|
||||
@Test("Set attributes on .string value")
|
||||
func testSetAttributesOnString() {
|
||||
var value: Logger.MetadataValue = "hello"
|
||||
#expect(value.attributes[AttrA.self] == nil)
|
||||
|
||||
value.attributes = [AttrA.a1]
|
||||
|
||||
#expect(value.description == "hello")
|
||||
#expect(value.attributes[AttrA.self] == .a1)
|
||||
}
|
||||
|
||||
@Test("Set attributes replaces existing attributes")
|
||||
func testSetAttributesReplacesExisting() {
|
||||
var value: Logger.MetadataValue = .attributed("test", attributes: [AttrA.a1])
|
||||
#expect(value.attributes[AttrA.self] == .a1)
|
||||
|
||||
let newAttrs: Logger.MetadataValueAttributes = [AttrB.b2]
|
||||
value.attributes = newAttrs
|
||||
|
||||
#expect(value.description == "test")
|
||||
#expect(value.attributes[AttrA.self] == nil)
|
||||
#expect(value.attributes[AttrB.self] == .b2)
|
||||
}
|
||||
|
||||
// MARK: - Intermediate handler modifies attributes
|
||||
|
||||
@Test("Intermediate handler adds attributes before forwarding")
|
||||
func testIntermediateHandlerAddsAttributes() {
|
||||
let recorder = AttributeRecorder()
|
||||
let inner = AttributeRecordingHandler(recorder: recorder)
|
||||
let enriching = AttributeEnrichingHandler(wrapping: inner)
|
||||
|
||||
var logger = Logger(label: "test") { _ in enriching }
|
||||
logger.logLevel = .trace
|
||||
|
||||
logger.info(
|
||||
"event",
|
||||
metadata: [
|
||||
"tagged": .attributed(42, attributes: [AttrA.a1]),
|
||||
"plain": "no-attrs",
|
||||
]
|
||||
)
|
||||
|
||||
#expect(recorder.messages.count == 1)
|
||||
let metadata = recorder.messages[0]
|
||||
|
||||
// The enriching handler should have added AttrB to all values
|
||||
#expect(metadata["tagged"]?.attributes[AttrA.self] == .a1)
|
||||
#expect(metadata["tagged"]?.attributes[AttrB.self] == .b1)
|
||||
#expect(metadata["plain"]?.attributes[AttrB.self] == .b1)
|
||||
}
|
||||
|
||||
@Test("Intermediate handler replaces attributes before forwarding")
|
||||
func testIntermediateHandlerReplacesAttributes() {
|
||||
let recorder = AttributeRecorder()
|
||||
let inner = AttributeRecordingHandler(recorder: recorder)
|
||||
let stripping = AttributeStrippingHandler(wrapping: inner)
|
||||
|
||||
var logger = Logger(label: "test") { _ in stripping }
|
||||
logger.logLevel = .trace
|
||||
|
||||
logger.info(
|
||||
"event",
|
||||
metadata: [
|
||||
"tagged": .attributed(42, attributes: [AttrA.a1])
|
||||
]
|
||||
)
|
||||
|
||||
#expect(recorder.messages.count == 1)
|
||||
let metadata = recorder.messages[0]
|
||||
|
||||
// The stripping handler should have removed all attributes
|
||||
#expect(metadata["tagged"]?.attributes[AttrA.self] == nil)
|
||||
#expect(metadata["tagged"]?.description == "42")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Test Helpers for intermediate handler tests
|
||||
|
||||
private final class AttributeRecorder: @unchecked Sendable {
|
||||
private let lock = Lock()
|
||||
private var _messages: [Logger.Metadata] = []
|
||||
|
||||
func record(metadata: Logger.Metadata) {
|
||||
self.lock.withLock { self._messages.append(metadata) }
|
||||
}
|
||||
|
||||
var messages: [Logger.Metadata] {
|
||||
self.lock.withLock { self._messages }
|
||||
}
|
||||
}
|
||||
|
||||
private struct AttributeRecordingHandler: LogHandler {
|
||||
var logLevel: Logger.Level = .trace
|
||||
var metadata = Logger.Metadata()
|
||||
var metadataProvider: Logger.MetadataProvider?
|
||||
private let recorder: AttributeRecorder
|
||||
|
||||
init(recorder: AttributeRecorder) {
|
||||
self.recorder = recorder
|
||||
}
|
||||
|
||||
subscript(metadataKey key: String) -> Logger.Metadata.Value? {
|
||||
get { self.metadata[key] }
|
||||
set { self.metadata[key] = newValue }
|
||||
}
|
||||
|
||||
func log(event: LogEvent) {
|
||||
var merged = self.metadata
|
||||
if let eventMetadata = event.metadata {
|
||||
merged.merge(eventMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
self.recorder.record(metadata: merged)
|
||||
}
|
||||
}
|
||||
|
||||
/// Intermediate handler that enriches all metadata values with AttrB before forwarding.
|
||||
private struct AttributeEnrichingHandler: LogHandler {
|
||||
var logLevel: Logger.Level {
|
||||
get { self.inner.logLevel }
|
||||
set { self.inner.logLevel = newValue }
|
||||
}
|
||||
|
||||
var metadata: Logger.Metadata {
|
||||
get { self.inner.metadata }
|
||||
set { self.inner.metadata = newValue }
|
||||
}
|
||||
|
||||
var metadataProvider: Logger.MetadataProvider? {
|
||||
get { self.inner.metadataProvider }
|
||||
set { self.inner.metadataProvider = newValue }
|
||||
}
|
||||
|
||||
private var inner: any LogHandler
|
||||
|
||||
init(wrapping inner: any LogHandler) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
subscript(metadataKey key: String) -> Logger.Metadata.Value? {
|
||||
get { self.inner[metadataKey: key] }
|
||||
set { self.inner[metadataKey: key] = newValue }
|
||||
}
|
||||
|
||||
func log(event: LogEvent) {
|
||||
var mutatedEvent = event
|
||||
if var eventMetadata = event.metadata {
|
||||
for (key, value) in eventMetadata {
|
||||
var attrs = value.attributes
|
||||
attrs[AttrB.self] = .b1
|
||||
eventMetadata[key]?.attributes = attrs
|
||||
}
|
||||
mutatedEvent.metadata = eventMetadata
|
||||
}
|
||||
self.inner.log(event: mutatedEvent)
|
||||
}
|
||||
}
|
||||
|
||||
/// Intermediate handler that strips all attributes before forwarding.
|
||||
private struct AttributeStrippingHandler: LogHandler {
|
||||
var logLevel: Logger.Level {
|
||||
get { self.inner.logLevel }
|
||||
set { self.inner.logLevel = newValue }
|
||||
}
|
||||
|
||||
var metadata: Logger.Metadata {
|
||||
get { self.inner.metadata }
|
||||
set { self.inner.metadata = newValue }
|
||||
}
|
||||
|
||||
var metadataProvider: Logger.MetadataProvider? {
|
||||
get { self.inner.metadataProvider }
|
||||
set { self.inner.metadataProvider = newValue }
|
||||
}
|
||||
|
||||
private var inner: any LogHandler
|
||||
|
||||
init(wrapping inner: any LogHandler) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
subscript(metadataKey key: String) -> Logger.Metadata.Value? {
|
||||
get { self.inner[metadataKey: key] }
|
||||
set { self.inner[metadataKey: key] = newValue }
|
||||
}
|
||||
|
||||
func log(event: LogEvent) {
|
||||
var mutatedEvent = event
|
||||
if var eventMetadata = event.metadata {
|
||||
for (key, _) in eventMetadata {
|
||||
eventMetadata[key]?.attributes = .init()
|
||||
}
|
||||
mutatedEvent.metadata = eventMetadata
|
||||
}
|
||||
self.inner.log(event: mutatedEvent)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user