mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
11
Commits
tomerd-patch-2
...
1.3.0
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
57c6bd0425 | ||
|
|
024f44d4d5 | ||
|
|
c37c434930 | ||
|
|
0c61f3610d | ||
|
|
237094d249 | ||
|
|
2caaa7fc10 | ||
|
|
afc50b29de | ||
|
|
ee8b3c5044 | ||
|
|
6d233ae476 | ||
|
|
a9784b00a6 | ||
|
|
4f87671873 |
No files matched your search
@@ -11,3 +11,5 @@
|
||||
--ifdef no-indent
|
||||
|
||||
# rules
|
||||
|
||||
--disable redundantParens # https://github.com/nicklockwood/SwiftFormat/issues/638
|
||||
@@ -71,6 +71,7 @@ As the API has just launched, not many implementations exist yet. If you are int
|
||||
| [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack) | a logging backend that sends critical log messages to Slack |
|
||||
| [NSHipster/swift-log-github-actions](https://github.com/NSHipster/swift-log-github-actions) | a logging backend that translates logging messages into [workflow commands for GitHub Actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions). |
|
||||
| [stevapple/swift-log-telegram](https://github.com/stevapple/swift-log-telegram) | a logging backend that sends log messages to any Telegram chat (Inspired by and forked from [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack)) |
|
||||
| [jagreenwood/swift-log-datadog](https://github.com/jagreenwood/swift-log-datadog) | a logging backend which sends log messages to the [Datadog](https://www.datadoghq.com/log-management/) log management service |
|
||||
| Your library? | [Get in touch!](https://forums.swift.org/c/server) |
|
||||
|
||||
## What is an API package?
|
||||
@@ -181,6 +182,16 @@ However, in special cases, it is acceptable that a `LogHandler` provides some gl
|
||||
|
||||
`LogHandler`s do not control if a message should be logged or not. `Logger` will only invoke the `log` function of a `LogHandler` if `Logger` determines that a log message should be emitted given the configured log level.
|
||||
|
||||
## Source vs Label
|
||||
|
||||
A `Logger` carries an (immutable) `label` and each log message carries a `source` parameter (since SwiftLog 1.3.0). The `Logger`'s label
|
||||
identifies the creator of the `Logger`. If you are using structured logging by preserving metadata across multiple modules, the `Logger`'s
|
||||
`label` is not a good way to identify where a log message originated from as it identifies the creator of a `Logger` which is often passed
|
||||
around between libraries to preserve metadata and the like.
|
||||
|
||||
If you want to filter all log messages originating from a certain subsystem, filter by `source` which defaults to the module that is emitting the
|
||||
log message.
|
||||
|
||||
## SwiftLog for Swift 4
|
||||
<a name="help-i-need-swift-4"></a>
|
||||
|
||||
|
||||
+36
-29
@@ -38,7 +38,8 @@ import Glibc
|
||||
///
|
||||
/// This object provides a lock on top of a single `pthread_mutex_t`. This kind
|
||||
/// of lock is safe to use with `libpthread`-based threading models, such as the
|
||||
/// one used by NIO.
|
||||
/// one used by NIO. On Windows, the lock is based on the substantially similar
|
||||
/// `SRWLOCK` type.
|
||||
internal final class Lock {
|
||||
#if os(Windows)
|
||||
fileprivate let mutex: UnsafeMutablePointer<SRWLOCK> =
|
||||
@@ -53,8 +54,12 @@ internal final class Lock {
|
||||
#if os(Windows)
|
||||
InitializeSRWLock(self.mutex)
|
||||
#else
|
||||
let err = pthread_mutex_init(self.mutex, nil)
|
||||
precondition(err == 0)
|
||||
var attr = pthread_mutexattr_t()
|
||||
pthread_mutexattr_init(&attr)
|
||||
pthread_mutexattr_settype(&attr, .init(PTHREAD_MUTEX_ERRORCHECK))
|
||||
|
||||
let err = pthread_mutex_init(self.mutex, &attr)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -63,7 +68,7 @@ internal final class Lock {
|
||||
// SRWLOCK does not need to be free'd
|
||||
#else
|
||||
let err = pthread_mutex_destroy(self.mutex)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
self.mutex.deallocate()
|
||||
}
|
||||
@@ -77,7 +82,7 @@ internal final class Lock {
|
||||
AcquireSRWLockExclusive(self.mutex)
|
||||
#else
|
||||
let err = pthread_mutex_lock(self.mutex)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -90,7 +95,7 @@ internal final class Lock {
|
||||
ReleaseSRWLockExclusive(self.mutex)
|
||||
#else
|
||||
let err = pthread_mutex_unlock(self.mutex)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -120,11 +125,12 @@ extension Lock {
|
||||
}
|
||||
}
|
||||
|
||||
/// A threading lock based on `libpthread` instead of `libdispatch`.
|
||||
/// A reader/writer threading lock based on `libpthread` instead of `libdispatch`.
|
||||
///
|
||||
/// This object provides a lock on top of a single `pthread_mutex_t`. This kind
|
||||
/// This object provides a lock on top of a single `pthread_rwlock_t`. This kind
|
||||
/// of lock is safe to use with `libpthread`-based threading models, such as the
|
||||
/// one used by NIO.
|
||||
/// one used by NIO. On Windows, the lock is based on the substantially similar
|
||||
/// `SRWLOCK` type.
|
||||
internal final class ReadWriteLock {
|
||||
#if os(Windows)
|
||||
fileprivate let rwlock: UnsafeMutablePointer<SRWLOCK> =
|
||||
@@ -141,7 +147,7 @@ internal final class ReadWriteLock {
|
||||
InitializeSRWLock(self.rwlock)
|
||||
#else
|
||||
let err = pthread_rwlock_init(self.rwlock, nil)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -150,43 +156,44 @@ internal final class ReadWriteLock {
|
||||
// SRWLOCK does not need to be free'd
|
||||
#else
|
||||
let err = pthread_rwlock_destroy(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
self.rwlock.deallocate()
|
||||
}
|
||||
|
||||
/// Acquire a reader lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `unlock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withReaderLock` instead of this
|
||||
/// method and `unlock`, to simplify lock handling.
|
||||
public func lockRead() {
|
||||
#if os(Windows)
|
||||
AcquireSRWLockShared(self.rwlock)
|
||||
self.shared = true
|
||||
#else
|
||||
let err = pthread_rwlock_rdlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire a writer lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `unlock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withWriterLock` instead of this
|
||||
/// method and `unlock`, to simplify lock handling.
|
||||
public func lockWrite() {
|
||||
#if os(Windows)
|
||||
AcquireSRWLockExclusive(self.rwlock)
|
||||
self.shared = true
|
||||
self.shared = false
|
||||
#else
|
||||
let err = pthread_rwlock_wrlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Release the lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `lock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withReaderLock` and `withWriterLock`
|
||||
/// instead of this method and `lockRead` and `lockWrite`, to simplify lock
|
||||
/// handling.
|
||||
public func unlock() {
|
||||
#if os(Windows)
|
||||
if self.shared {
|
||||
@@ -196,7 +203,7 @@ internal final class ReadWriteLock {
|
||||
}
|
||||
#else
|
||||
let err = pthread_rwlock_unlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -204,11 +211,11 @@ internal final class ReadWriteLock {
|
||||
extension ReadWriteLock {
|
||||
/// Acquire the reader lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
/// This convenience method should be preferred to `lockRead` and `unlock`
|
||||
/// in most situations, as it ensures that the lock will be released
|
||||
/// regardless of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Parameter body: The block to execute while holding the reader lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withReaderLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
@@ -221,11 +228,11 @@ extension ReadWriteLock {
|
||||
|
||||
/// Acquire the writer lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
/// This convenience method should be preferred to `lockWrite` and `unlock`
|
||||
/// in most situations, as it ensures that the lock will be released
|
||||
/// regardless of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Parameter body: The block to execute while holding the writer lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withWriterLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
|
||||
@@ -56,9 +56,11 @@
|
||||
/// `LogHandlerWithGlobalLogLevelOverride.overrideGlobalLogLevel = .debug`, for example.
|
||||
///
|
||||
/// ```swift
|
||||
/// import class Foundation.NSLock
|
||||
///
|
||||
/// public struct LogHandlerWithGlobalLogLevelOverride: LogHandler {
|
||||
/// // the static properties hold the globally overridden log level (if overridden)
|
||||
/// private static let overrideLock = Lock()
|
||||
/// private static let overrideLock = NSLock()
|
||||
/// private static var overrideLogLevel: Logger.Level? = nil
|
||||
///
|
||||
/// // this holds the log level if not overridden
|
||||
@@ -74,9 +76,9 @@
|
||||
/// public var logLevel: Logger.Level {
|
||||
/// // when we get asked for the log level, we check if it was globally overridden or not
|
||||
/// get {
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLock.withLock {
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
/// } ?? self._logLevel
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.lock()
|
||||
/// defer { LogHandlerWithGlobalLogLevelOverride.overrideLock.unlock() }
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel ?? self._logLevel
|
||||
/// }
|
||||
/// // we set the log level whenever we're asked (note: this might not have an effect if globally
|
||||
/// // overridden)
|
||||
@@ -86,7 +88,7 @@
|
||||
/// }
|
||||
///
|
||||
/// public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?,
|
||||
/// file: String, function: String, line: UInt) {
|
||||
/// source: String, file: String, function: String, line: UInt) {
|
||||
/// // [...]
|
||||
/// }
|
||||
///
|
||||
@@ -101,9 +103,9 @@
|
||||
///
|
||||
/// // this is the function to globally override the log level, it is not part of the `LogHandler` protocol
|
||||
/// public static func overrideGlobalLogLevel(_ logLevel: Logger.Level) {
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.withLock {
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLogLevel = logLevel
|
||||
/// }
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.lock()
|
||||
/// defer { LogHandlerWithGlobalLogLevelOverride.overrideLock.unlock() }
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLogLevel = logLevel
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
@@ -120,13 +122,22 @@ public protocol LogHandler {
|
||||
/// - level: The log level the message was logged at.
|
||||
/// - message: The message to log. To obtain a `String` representation call `message.description`.
|
||||
/// - metadata: The metadata associated to this log message.
|
||||
/// - source: The source where the log message originated, for example the logging module.
|
||||
/// - file: The file the log message was emitted from.
|
||||
/// - function: The function the log line was emitted from.
|
||||
/// - line: The line the log message was emitted from.
|
||||
func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt)
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt)
|
||||
|
||||
/// SwiftLog 1.0 compatibility method. Please do _not_ implement, implement
|
||||
/// `log(level:message:metadata:source:file:function:line:)` instead.
|
||||
@available(*, deprecated, renamed: "log(level:message:metadata:source:file:function:line:)")
|
||||
func log(level: Logging.Logger.Level, message: Logging.Logger.Message, metadata: Logging.Logger.Metadata?, file: String, function: String, line: UInt)
|
||||
|
||||
/// Add, remove, or change the logging metadata.
|
||||
///
|
||||
@@ -151,3 +162,27 @@ public protocol LogHandler {
|
||||
/// `LogHandler`.
|
||||
var logLevel: Logger.Level { get set }
|
||||
}
|
||||
|
||||
extension LogHandler {
|
||||
@available(*, deprecated, message: "You should implement this method instead of using the default implementation")
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
self.log(level: level, message: message, metadata: metadata, file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "log(level:message:metadata:source:file:function:line:)")
|
||||
public func log(level: Logging.Logger.Level, message: Logging.Logger.Message, metadata: Logging.Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
self.log(level: level,
|
||||
message: message,
|
||||
metadata: metadata,
|
||||
source: Logger.currentModule(filePath: file),
|
||||
file: file,
|
||||
function: function,
|
||||
line: line)
|
||||
}
|
||||
}
|
||||
+158
-31
@@ -23,6 +23,10 @@ import Glibc
|
||||
/// A `Logger` is the central type in `SwiftLog`. Its central function is to emit log messages using one of the methods
|
||||
/// corresponding to a log level.
|
||||
///
|
||||
/// `Logger`s are value types with respect to the `logLevel` and the `metadata` (as well as the immutable `label`
|
||||
/// and the selected `LogHandler`). Therefore, `Logger`s are suitable to be passed around between libraries if you want
|
||||
/// to preserve metadata across libraries.
|
||||
///
|
||||
/// The most basic usage of a `Logger` is
|
||||
///
|
||||
/// logger.info("Hello World!")
|
||||
@@ -49,7 +53,9 @@ extension Logger {
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -60,11 +66,13 @@ extension Logger {
|
||||
public func log(level: Logger.Level,
|
||||
_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
if self.logLevel <= level {
|
||||
self.handler.log(level: level,
|
||||
message: message(),
|
||||
metadata: metadata(),
|
||||
source: source() ?? Logger.currentModule(filePath: (file)),
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
}
|
||||
@@ -109,6 +117,8 @@ extension Logger {
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -118,8 +128,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func trace(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .trace, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .trace, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.debug` log level.
|
||||
@@ -129,7 +140,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -139,8 +152,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func debug(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .debug, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .debug, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.info` log level.
|
||||
@@ -150,7 +164,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -160,8 +176,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func info(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .info, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .info, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.notice` log level.
|
||||
@@ -171,7 +188,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -181,8 +200,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func notice(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .notice, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .notice, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.warning` log level.
|
||||
@@ -192,7 +212,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -202,8 +224,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func warning(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .warning, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .warning, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.error` log level.
|
||||
@@ -213,7 +236,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -223,8 +248,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func error(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .error, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .error, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.critical` log level.
|
||||
@@ -233,7 +259,9 @@ extension Logger {
|
||||
///
|
||||
/// - parameters:
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - metadata: One-off metadata to attach to this log message.
|
||||
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
|
||||
/// file that is emitting the log message, which usually is the module.
|
||||
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
|
||||
/// defaults to `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
@@ -243,8 +271,9 @@ extension Logger {
|
||||
@inlinable
|
||||
public func critical(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
source: @autoclosure () -> String? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .critical, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
self.log(level: .critical, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -258,7 +287,7 @@ public enum LoggingSystem {
|
||||
|
||||
/// `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 behaviour, most likely a crash.
|
||||
/// lead to undefined behavior, most likely a crash.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - factory: A closure that given a `Logger` identifier, produces an instance of the `LogHandler`.
|
||||
@@ -291,7 +320,7 @@ extension Logger {
|
||||
/// Examples:
|
||||
/// - prefer `logger.info("user logged in", metadata: ["user-id": "\(user.id)"])` over
|
||||
/// `..., metadata: ["user-id": .string(user.id.description)])`
|
||||
/// - prefer `logger.info("user selected colours", metadata: ["colors": ["\(user.topColor)", "\(user.secondColor)"]])`
|
||||
/// - prefer `logger.info("user selected colors", metadata: ["colors": ["\(user.topColor)", "\(user.secondColor)"]])`
|
||||
/// over `..., metadata: ["colors": .array([.string("\(user.topColor)"), .string("\(user.secondColor)")])`
|
||||
/// - prefer `logger.info("nested info", metadata: ["nested": ["fave-numbers": ["\(1)", "\(2)", "\(3)"], "foo": "bar"]])`
|
||||
/// over `..., metadata: ["nested": .dictionary(["fave-numbers": ...])])`
|
||||
@@ -458,11 +487,52 @@ extension Logger {
|
||||
|
||||
/// A pseudo-`LogHandler` that can be used to send messages to multiple other `LogHandler`s.
|
||||
///
|
||||
/// The first `LogHandler` passed to the initialisation function of `MultiplexLogHandler` control the `logLevel` as
|
||||
/// well as the `metadata` for this `LogHandler`. Any subsequent `LogHandler`s used to initialise a
|
||||
/// `MultiplexLogHandler` are merely to emit the log message to another place.
|
||||
/// ### Effective Logger.Level
|
||||
///
|
||||
/// When first initialized the multiplex log handlers' log level is automatically set to the minimum of all the
|
||||
/// passed in log handlers. This ensures that each of the handlers will be able to log at their appropriate level
|
||||
/// any log events they might be interested in.
|
||||
///
|
||||
/// Example:
|
||||
/// If log handler `A` is logging at `.debug` level, and log handler `B` is logging at `.info` level, the constructed
|
||||
/// `MultiplexLogHandler([A, B])`'s effective log level will be set to `.debug`, meaning that debug messages will be
|
||||
/// handled by this handler, while only logged by the underlying `A` log handler (since `B`'s log level is `.info`
|
||||
/// and thus it would not actually log that log message).
|
||||
///
|
||||
/// If the log level is _set_ on a `Logger` backed by an `MultiplexLogHandler` the log level will apply to *all*
|
||||
/// underlying log handlers, allowing a logger to still select at what level it wants to log regardless of if the underlying
|
||||
/// handler is a multiplex or a normal one. If for some reason one might want to not allow changing a log level of a specific
|
||||
/// handler passed into the multiplex log handler, this is possible by wrapping it in a handler which ignores any log level changes.
|
||||
///
|
||||
/// ### Effective Logger.Metadata
|
||||
///
|
||||
/// Since a `MultiplexLogHandler` is a combination of multiple log handlers, the handling of metadata can be non-obvious.
|
||||
/// For example, the underlying log handlers may have metadata of their own set before they are used to initialize the multiplex log handler.
|
||||
///
|
||||
/// The multiplex log handler acts purely as proxy and does not make any changes to underlying handler metadata other than
|
||||
/// proxying writes that users made on a `Logger` instance backed by this handler.
|
||||
///
|
||||
/// Setting metadata is always proxied through to _all_ underlying handlers, meaning that if a modification like
|
||||
/// `logger[metadataKey: "x"] = "y"` is made, all underlying log handlers that this multiplex handler was initiated with
|
||||
/// will observe this change.
|
||||
///
|
||||
/// Reading metadata from the multiplex log handler MAY need to pick one of conflicting values if the underlying log handlers
|
||||
/// were already initiated with some metadata before passing them into the multiplex handler. The multiplex handler uses
|
||||
/// the order in which the handlers were passed in during its initialization as a priority indicator - the first handler's
|
||||
/// values are more important than the next handlers values, etc.
|
||||
///
|
||||
/// Example:
|
||||
/// If the multiplex log handler was initiated with two handlers like this: `MultiplexLogHandler([handler1, handler2])`.
|
||||
/// The handlers each have some already set metadata: `handler1` has metadata values for keys `one` and `all`, and `handler2`
|
||||
/// has values for keys `two` and `all`.
|
||||
///
|
||||
/// A query through the multiplex log handler the key `one` naturally returns `handler1`'s value, and a query for `two`
|
||||
/// naturally returns `handler2`'s value. Querying for the key `all` will return `handler1`'s value, as that handler was indicated
|
||||
/// "more important" than the second handler. The same rule applies when querying for the `metadata` property of the
|
||||
/// multiplex log handler - it constructs `Metadata` uniquing values.
|
||||
public struct MultiplexLogHandler: LogHandler {
|
||||
private var handlers: [LogHandler]
|
||||
private var effectiveLogLevel: Logger.Level
|
||||
|
||||
/// Create a `MultiplexLogHandler`.
|
||||
///
|
||||
@@ -470,42 +540,56 @@ public struct MultiplexLogHandler: LogHandler {
|
||||
/// - handlers: An array of `LogHandler`s, each of which will receive the log messages sent to this `Logger`.
|
||||
/// The array must not be empty.
|
||||
public init(_ handlers: [LogHandler]) {
|
||||
assert(!handlers.isEmpty)
|
||||
assert(!handlers.isEmpty, "MultiplexLogHandler.handlers MUST NOT be empty")
|
||||
self.handlers = handlers
|
||||
self.effectiveLogLevel = handlers.map { $0.logLevel }.min() ?? .trace
|
||||
}
|
||||
|
||||
public var logLevel: Logger.Level {
|
||||
get {
|
||||
return self.handlers[0].logLevel
|
||||
return self.effectiveLogLevel
|
||||
}
|
||||
set {
|
||||
self.mutatingForEachHandler {
|
||||
$0.logLevel = newValue
|
||||
}
|
||||
self.mutatingForEachHandler { $0.logLevel = newValue }
|
||||
self.effectiveLogLevel = newValue
|
||||
}
|
||||
}
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt) {
|
||||
self.handlers.forEach { handler in
|
||||
handler.log(level: level, message: message, metadata: metadata, file: file, function: function, line: line)
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
for handler in self.handlers where handler.logLevel <= level {
|
||||
handler.log(level: level, message: message, metadata: metadata, source: source, file: file, function: function, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
public var metadata: Logger.Metadata {
|
||||
get {
|
||||
return self.handlers[0].metadata
|
||||
var effectiveMetadata: 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 })
|
||||
}
|
||||
}
|
||||
set {
|
||||
self.mutatingForEachHandler { $0.metadata = newValue }
|
||||
}
|
||||
}
|
||||
|
||||
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
public subscript(metadataKey metadataKey: Logger.Metadata.Key) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.handlers[0].metadata[metadataKey]
|
||||
for handler in self.handlers {
|
||||
if let value = handler[metadataKey: metadataKey] {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
set {
|
||||
self.mutatingForEachHandler { $0[metadataKey: metadataKey] = newValue }
|
||||
@@ -618,7 +702,10 @@ public struct StreamLogHandler: LogHandler {
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt) {
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
let prettyMetadata = metadata?.isEmpty ?? true
|
||||
? self.prettyMetadata
|
||||
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
|
||||
@@ -644,6 +731,46 @@ public struct StreamLogHandler: LogHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/// No operation LogHandler, used when no logging is required
|
||||
public struct SwiftLogNoOpLogHandler: LogHandler {
|
||||
@inlinable public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {}
|
||||
|
||||
@inlinable public subscript(metadataKey _: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return nil
|
||||
}
|
||||
set {}
|
||||
}
|
||||
|
||||
@inlinable public var metadata: Logger.Metadata {
|
||||
get {
|
||||
return [:]
|
||||
}
|
||||
set {}
|
||||
}
|
||||
|
||||
@inlinable public var logLevel: Logger.Level {
|
||||
get {
|
||||
return .critical
|
||||
}
|
||||
set {}
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger {
|
||||
@inlinable
|
||||
internal static func currentModule(filePath: String = #file) -> String {
|
||||
let utf8All = filePath.utf8
|
||||
return filePath.utf8.lastIndex(of: UInt8(ascii: "/")).flatMap { lastSlash -> Substring? in
|
||||
utf8All[..<lastSlash].lastIndex(of: UInt8(ascii: "/")).map { secondLastSlash -> Substring in
|
||||
filePath[utf8All.index(after: secondLastSlash) ..< lastSlash]
|
||||
}
|
||||
}.map {
|
||||
String($0)
|
||||
} ?? "n/a"
|
||||
}
|
||||
}
|
||||
|
||||
// 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: ExpressibleByStringLiteral {
|
||||
|
||||
@@ -26,6 +26,7 @@ import XCTest
|
||||
@testable import LoggingTests
|
||||
|
||||
XCTMain([
|
||||
testCase(CompatibilityTest.allTests),
|
||||
testCase(GlobalLoggerTest.allTests),
|
||||
testCase(LocalLoggerTest.allTests),
|
||||
testCase(LoggingTest.allTests),
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// CompatibilityTest+XCTest.swift
|
||||
//
|
||||
import XCTest
|
||||
|
||||
///
|
||||
/// NOTE: This file was generated by generate_linux_tests.rb
|
||||
///
|
||||
/// Do NOT edit this file directly as it will be regenerated automatically when needed.
|
||||
///
|
||||
|
||||
extension CompatibilityTest {
|
||||
static var allTests: [(String, (CompatibilityTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testAllLogLevelsWorkWithOldSchoolLogHandlerWorks", testAllLogLevelsWorkWithOldSchoolLogHandlerWorks),
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2020 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/* NOT @testable */ import Logging
|
||||
import XCTest
|
||||
|
||||
final class CompatibilityTest: XCTestCase {
|
||||
func testAllLogLevelsWorkWithOldSchoolLogHandlerWorks() {
|
||||
let testLogging = OldSchoolTestLogging()
|
||||
|
||||
var logger = Logger(label: "\(#function)", factory: testLogging.make)
|
||||
logger.logLevel = .trace
|
||||
|
||||
logger.trace("yes: trace")
|
||||
logger.debug("yes: debug")
|
||||
logger.info("yes: info")
|
||||
logger.notice("yes: notice")
|
||||
logger.warning("yes: warning")
|
||||
logger.error("yes: error")
|
||||
logger.critical("yes: critical", source: "any also with some new argument that isn't propagated")
|
||||
|
||||
// Please note that the source is _not_ propagated (because the backend doesn't support it).
|
||||
testLogging.history.assertExist(level: .trace, message: "yes: trace", source: "no source")
|
||||
testLogging.history.assertExist(level: .debug, message: "yes: debug", source: "no source")
|
||||
testLogging.history.assertExist(level: .info, message: "yes: info", source: "no source")
|
||||
testLogging.history.assertExist(level: .notice, message: "yes: notice", source: "no source")
|
||||
testLogging.history.assertExist(level: .warning, message: "yes: warning", source: "no source")
|
||||
testLogging.history.assertExist(level: .error, message: "yes: error", source: "no source")
|
||||
testLogging.history.assertExist(level: .critical, message: "yes: critical", source: "no source")
|
||||
}
|
||||
}
|
||||
|
||||
private struct OldSchoolTestLogging {
|
||||
private let _config = Config() // shared among loggers
|
||||
private let recorder = Recorder() // shared among loggers
|
||||
|
||||
func make(label: String) -> LogHandler {
|
||||
return OldSchoolLogHandler(label: label,
|
||||
config: self.config,
|
||||
recorder: self.recorder,
|
||||
metadata: [:],
|
||||
logLevel: .info)
|
||||
}
|
||||
|
||||
var config: Config { return self._config }
|
||||
var history: History { return self.recorder }
|
||||
}
|
||||
|
||||
private struct OldSchoolLogHandler: LogHandler {
|
||||
var label: String
|
||||
let config: Config
|
||||
let recorder: Recorder
|
||||
|
||||
func make(label: String) -> LogHandler {
|
||||
return TestLogHandler(label: label, config: self.config, recorder: self.recorder)
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: "no source")
|
||||
}
|
||||
|
||||
subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.metadata[metadataKey]
|
||||
}
|
||||
set {
|
||||
self.metadata[metadataKey] = newValue
|
||||
}
|
||||
}
|
||||
|
||||
var metadata: Logger.Metadata
|
||||
|
||||
var logLevel: Logger.Level
|
||||
}
|
||||
@@ -26,7 +26,7 @@ class LocalLoggerTest: XCTestCase {
|
||||
let context = Context()
|
||||
Struct1().doSomething(context: context)
|
||||
// test results
|
||||
logging.history.assertExist(level: .debug, message: "Struct1::doSomething")
|
||||
logging.history.assertExist(level: .debug, message: "Struct1::doSomething", source: "LoggingTests")
|
||||
logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse")
|
||||
logging.history.assertExist(level: .info, message: "Struct2::doSomething")
|
||||
logging.history.assertExist(level: .info, message: "Struct2::doSomethingElse")
|
||||
|
||||
@@ -27,6 +27,10 @@ extension LoggingTest {
|
||||
return [
|
||||
("testAutoclosure", testAutoclosure),
|
||||
("testMultiplex", testMultiplex),
|
||||
("testMultiplexLogHandlerWithVariousLogLevels", testMultiplexLogHandlerWithVariousLogLevels),
|
||||
("testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes", testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes),
|
||||
("testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers", testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers),
|
||||
("testMultiplexLogHandlerMetadata_readingHandlerMetadata", testMultiplexLogHandlerMetadata_readingHandlerMetadata),
|
||||
("testDictionaryMetadata", testDictionaryMetadata),
|
||||
("testListMetadata", testListMetadata),
|
||||
("testStringConvertibleMetadata", testStringConvertibleMetadata),
|
||||
|
||||
@@ -74,6 +74,154 @@ class LoggingTest: XCTestCase {
|
||||
logging2.history.assertExist(level: .warning, message: "hello world!", metadata: ["foo": "bar"])
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerWithVariousLogLevels() throws {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.logLevel = .info
|
||||
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.logLevel = .debug
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
multiplexLogger.trace("trace")
|
||||
multiplexLogger.debug("debug")
|
||||
multiplexLogger.info("info")
|
||||
multiplexLogger.warning("warning")
|
||||
|
||||
logging1.history.assertNotExist(level: .trace, message: "trace")
|
||||
logging1.history.assertNotExist(level: .debug, message: "debug")
|
||||
logging1.history.assertExist(level: .info, message: "info")
|
||||
logging1.history.assertExist(level: .warning, message: "warning")
|
||||
|
||||
logging2.history.assertNotExist(level: .trace, message: "trace")
|
||||
logging2.history.assertExist(level: .debug, message: "debug")
|
||||
logging2.history.assertExist(level: .info, message: "info")
|
||||
logging2.history.assertExist(level: .warning, message: "warning")
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes() throws {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.logLevel = .info
|
||||
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.logLevel = .info
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
var messageMaterializations: Int = 0
|
||||
var metadataMaterializations: Int = 0
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
multiplexLogger.info(
|
||||
{ () -> Logger.Message in
|
||||
messageMaterializations += 1
|
||||
return "info"
|
||||
}(),
|
||||
metadata: { () ->
|
||||
Logger.Metadata in metadataMaterializations += 1
|
||||
return [:]
|
||||
}()
|
||||
)
|
||||
|
||||
logging1.history.assertExist(level: .info, message: "info")
|
||||
logging2.history.assertExist(level: .info, message: "info")
|
||||
|
||||
XCTAssertEqual(messageMaterializations, 1)
|
||||
XCTAssertEqual(metadataMaterializations, 1)
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.metadata["one"] = "111"
|
||||
logger1.metadata["in"] = "in-1"
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.metadata["two"] = "222"
|
||||
logger2.metadata["in"] = "in-2"
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
var multiplexLogger = Logger(label: "test")
|
||||
|
||||
// each logs its own metadata
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "in-1",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "in-2",
|
||||
])
|
||||
|
||||
// if modified, change applies to both underlying handlers
|
||||
multiplexLogger[metadataKey: "new"] = "new"
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "in-1",
|
||||
"new": "new",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "in-2",
|
||||
"new": "new",
|
||||
])
|
||||
|
||||
// overriding an existing value works the same way as adding a new one
|
||||
multiplexLogger[metadataKey: "in"] = "multi"
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "multi",
|
||||
"new": "new",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "multi",
|
||||
"new": "new",
|
||||
])
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerMetadata_readingHandlerMetadata() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.metadata["one"] = "111"
|
||||
logger1.metadata["in"] = "in-1"
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.metadata["two"] = "222"
|
||||
logger2.metadata["in"] = "in-2"
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
|
||||
XCTAssertEqual(multiplexLogger.handler.metadata, [
|
||||
"one": "111",
|
||||
"two": "222",
|
||||
"in": "in-1",
|
||||
])
|
||||
}
|
||||
|
||||
enum TestError: Error {
|
||||
case boom
|
||||
}
|
||||
@@ -153,7 +301,7 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
|
||||
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> Logger.Message {
|
||||
XCTFail("should not have been evaluated", file: file, line: line)
|
||||
XCTFail("should not have been evaluated", file: (file), line: line)
|
||||
return "should not have been evaluated"
|
||||
}
|
||||
|
||||
@@ -188,7 +336,7 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
func testCustomFactory() {
|
||||
struct CustomHandler: LogHandler {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {}
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt) {}
|
||||
|
||||
subscript(metadataKey _: String) -> Logger.Metadata.Value? {
|
||||
get { return nil }
|
||||
@@ -344,8 +492,8 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message)
|
||||
source: String, file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: source)
|
||||
}
|
||||
|
||||
subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
|
||||
@@ -43,10 +43,10 @@ internal struct TestLogHandler: LogHandler {
|
||||
self.logger.logLevel = .debug
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt) {
|
||||
let metadata = (self._metadataSet ? self.metadata : MDC.global.metadata).merging(metadata ?? [:], uniquingKeysWith: { _, new in new })
|
||||
self.logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
|
||||
self.recorder.record(level: level, metadata: metadata, message: message)
|
||||
self.logger.log(level: level, message, metadata: metadata, source: source, file: file, function: function, line: line)
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: source)
|
||||
}
|
||||
|
||||
private var _logLevel: Logger.Level?
|
||||
@@ -123,9 +123,9 @@ internal class Recorder: History {
|
||||
private let lock = NSLock()
|
||||
private var _entries = [LogEntry]()
|
||||
|
||||
func record(level: Logger.Level, metadata: Logger.Metadata?, message: Logger.Message) {
|
||||
func record(level: Logger.Level, metadata: Logger.Metadata?, message: Logger.Message, source: String) {
|
||||
return self.lock.withLock {
|
||||
self._entries.append(LogEntry(level: level, metadata: metadata, message: message.description))
|
||||
self._entries.append(LogEntry(level: level, metadata: metadata, message: message.description, source: source))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -170,24 +170,40 @@ internal struct LogEntry {
|
||||
let level: Logger.Level
|
||||
let metadata: Logger.Metadata?
|
||||
let message: String
|
||||
let source: String
|
||||
}
|
||||
|
||||
extension History {
|
||||
func assertExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let entry = self.find(level: level, message: message, metadata: metadata)
|
||||
XCTAssertNotNil(entry, "entry not found: \(level), \(String(describing: metadata)), \(message) ", file: file, line: line)
|
||||
func assertExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(filePath: "\(file)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNotNil(entry, "entry not found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: (file), line: line)
|
||||
}
|
||||
|
||||
func assertNotExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let entry = self.find(level: level, message: message, metadata: metadata)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(String(describing: metadata)), \(message)", file: file, line: line)
|
||||
func assertNotExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(filePath: "\(file)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: (file), line: line)
|
||||
}
|
||||
|
||||
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil) -> LogEntry? {
|
||||
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, source: String) -> LogEntry? {
|
||||
return self.entries.first { entry in
|
||||
entry.level == level &&
|
||||
entry.message == message &&
|
||||
entry.metadata ?? [:] == metadata ?? [:]
|
||||
entry.metadata ?? [:] == metadata ?? [:] &&
|
||||
entry.source == source
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@ services:
|
||||
image: swift-log:18.04-5.3
|
||||
build:
|
||||
args:
|
||||
base_image: "swiftlang/swift:nightly-master-bionic"
|
||||
base_image: "swiftlang/swift:nightly-5.3-bionic"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.3
|
||||
|
||||
+1
-1
@@ -32,7 +32,7 @@ here="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
|
||||
function replace_acceptable_years() {
|
||||
# this needs to replace all acceptable forms with 'YEARS'
|
||||
sed -e 's/2018-2019/YEARS/' -e 's/2019/YEARS/'
|
||||
sed -e 's/20[12][78901]-20[12][8901]/YEARS/' -e 's/20[12][8901]/YEARS/'
|
||||
}
|
||||
|
||||
printf "=> Checking linux tests... "
|
||||
|
||||
Reference in new issue
Block a user