Compare commits

...
6 Commits
Author SHA1 Message Date
tomer doron 9788e74ef2 update 5.4 to release docker image
motivation: 5.4 is out!

changes: use release docker images instead of nightly
2021-05-06 17:58:57 -07:00
George Barnett 08ec50d7b1 Add SwiftLogNoOpLogHandler.init(_: String) (#194)
Motivation:

`LogHandler` facotories are given a label as input and return a
`LogHandler`. Since the no-op handler doesn't care about the label
callers must provide a thunk: `{ _ in SwiftLogNoOpLogHandler() }`.
That's fine but slightly more annoying to type than it needs to be.

Modifications:

- Add `SwiftLogNoOpLogHandler.init(_: String)`

Result:

Users can create a logger with the no-op handler with:

```swift
Logger(label: "foo", factory: SwiftLogNoOpLogHandler.init)
```

instead of:

```swift
Logger(label: "foo", factory: { _ in SwiftLogNoOpLogHandler() })
```
2021-05-05 19:02:50 +09:00
Johannes Weiss 3577a992d3 use #fileID for Swift 5.3+ (#187)
Motivation:

Right now, we use the full path (`#file`) for the logging as well as for
parsing out the module name (which goes into `source` by default).

This has two problems:

1. The file names contain the build server's full path, ie. aren't
   portable across different compiles (and are very long).
2. The module name parsing fails if we log from a file that's not in a
   directory named just like the module.

Modification:

Switch `#file` for `#fileID`. This changes a bunch of things:

- `source` is always the module name by default (great!)
- `file` changes from `/the/full/path/on/disk` to `ModuleName/FileBaseName.swift` (I think better, but it's a change)

Result:

`source` is more correct, `file` will be different.
2021-04-06 14:28:43 +01:00
felipejinliandJohannes Weiss b1d1c0372a Improve StdioOutputStream with fwrite (#180) (#188)
Replaced `fputs` with `fwrite`, added test and made spelling corrections

Motivation:

If a 0 byte is logged, `fputs` would not output the content after the 0 byte making it harder to debug (see #180). `fwrite` uses a count argument so content after 0 byte can be logged.

Modifications:

Replaced `fputs` with the correct call to `fwrite`.   Added helper internal func `contiguousUTF8(_ string: String) -> String.UTF8View`. Added `testStdioOutputStreamWrite()` to test ability to log content after 0 byte.

Result:

Improved debugging experience

Co-authored-by: Johannes Weiss <johannesweiss@apple.com>
2021-04-06 14:19:35 +01:00
Moritz Lang bc049d05d0 Include source in StreamLogHandler output (#189)
Motivation:

When using the same Logger across an application in combination
with the default StreamLogHandler, it may be difficult to differentiate
between logs produced by different modules. ServiceLifecycle works around
this by prepending the log message with [Lifecycle], which is what I'd like
to do StreamLogHandler by default, leveraging the source log parameter.

Modifications:

StreamLogHandler will include the source in brackets right before
the log message when writing a log.

Result:

Logs from different modules are easily differentiable when produced
using the same Logger instance.
2021-04-06 21:41:35 +09:00
Peter Steinberger bda2661797 Remove references to Swift 4 (#186)
I found https://github.com/apple/swift-log/releases/tag/0.0.0 however these are just shims.
Seems unlikely that this is still needed.
2021-03-05 08:32:41 +09:00
7 changed files with 388 additions and 52 deletions

No files matched your search

+1 -1
View File
@@ -10,7 +10,7 @@ If you have a server-side Swift application, or maybe a cross-platform (for exam
#### Adding the dependency
`SwiftLog` is designed for Swift 5, the `1.0.0` release requires Swift 5 (however we will soon tag a `0.x` version that will work with Swift 4 for the transition period). To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
`SwiftLog` is designed for Swift 5. To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
```swift
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
+258 -40
View File
@@ -49,6 +49,7 @@ public struct Logger {
}
extension Logger {
#if compiler(>=5.3)
/// Log a message passing the log level as a parameter.
///
/// If the `logLevel` passed to this method is more severe than the `Logger`'s `logLevel`, it will be logged,
@@ -58,15 +59,33 @@ extension Logger {
/// - 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.
/// - 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
@inlinable
public func log(level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
if self.logLevel <= level {
self.handler.log(level: level,
message: message(),
metadata: metadata(),
source: source() ?? Logger.currentModule(fileID: (file)),
file: file, function: function, line: line)
}
}
#else
@inlinable
public func log(level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -80,6 +99,7 @@ extension Logger {
file: file, function: function, line: line)
}
}
#endif
/// Log a message passing the log level as a parameter.
///
@@ -91,11 +111,21 @@ extension Logger {
/// - 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.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func log(level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: level, message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func log(level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
@@ -103,6 +133,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: level, message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Add, change, or remove a logging metadata item.
///
@@ -144,14 +175,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func trace(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .trace, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func trace(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -159,6 +202,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .trace, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// If `.trace` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
/// otherwise nothing will happen.
@@ -167,17 +211,27 @@ extension Logger {
/// - 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func trace(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.trace(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func trace(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.trace(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.debug` log level.
///
@@ -187,21 +241,33 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func debug(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .debug, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
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(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.debug` log level.
///
@@ -212,17 +278,27 @@ extension Logger {
/// - 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.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func debug(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.debug(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func debug(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.debug(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.info` log level.
///
@@ -232,14 +308,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func info(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .info, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func info(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -247,6 +335,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .info, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.info` log level.
///
@@ -257,17 +346,27 @@ extension Logger {
/// - 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.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func info(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.info(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func info(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.info(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.notice` log level.
///
@@ -277,14 +376,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func notice(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .notice, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func notice(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -292,6 +403,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .notice, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.notice` log level.
///
@@ -301,20 +413,31 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func notice(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.notice(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
public func notice(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.notice(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.warning` log level.
///
@@ -324,14 +447,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func warning(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .warning, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func warning(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -339,6 +474,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .warning, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.warning` log level.
///
@@ -349,17 +485,27 @@ extension Logger {
/// - 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.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func warning(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.warning(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func warning(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.warning(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.error` log level.
///
@@ -369,14 +515,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func error(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .error, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func error(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -384,6 +542,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .error, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.error` log level.
///
@@ -394,17 +553,27 @@ extension Logger {
/// - 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.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func error(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.error(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func error(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.error(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.critical` log level.
///
@@ -413,14 +582,26 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func critical(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.log(level: .critical, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#else
@inlinable
public func critical(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
@@ -428,6 +609,7 @@ extension Logger {
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .critical, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
#endif
/// Log a message passing with the `Logger.Level.critical` log level.
///
@@ -436,20 +618,32 @@ 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.
/// - source: The source this log messages originates from. Defaults
/// to the module emitting the log message (on Swift 5.3 or
/// newer and the folder name containing the log emitting file on Swift 5.2 or
/// older).
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`).
/// defaults to `#fileID` (on Swift 5.3 or newer and `#file` on Swift 5.2 or older).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`).
#if compiler(>=5.3)
@inlinable
public func critical(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.critical(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#else
@inlinable
public func critical(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.critical(message(), metadata: metadata(), source: nil, file: file, function: function, line: line)
}
#endif
}
/// The `LoggingSystem` is a global facility where the default logging backend implementation (`LogHandler`) can be
@@ -808,7 +1002,7 @@ internal struct StdioOutputStream: TextOutputStream {
internal let flushMode: FlushMode
internal func write(_ string: String) {
string.withCString { ptr in
self.contiguousUTF8(string).withContiguousStorageIfAvailable { utf8Bytes in
#if os(Windows)
_lock_file(self.file)
#elseif canImport(WASILibc)
@@ -825,11 +1019,11 @@ internal struct StdioOutputStream: TextOutputStream {
funlockfile(self.file)
#endif
}
_ = fputs(ptr, self.file)
_ = fwrite(utf8Bytes.baseAddress!, 1, utf8Bytes.count, self.file)
if case .always = self.flushMode {
self.flush()
}
}
}!
}
/// Flush the underlying stream.
@@ -838,6 +1032,16 @@ internal struct StdioOutputStream: TextOutputStream {
_ = fflush(self.file)
}
internal func contiguousUTF8(_ string: String) -> String.UTF8View {
var contiguousString = string
#if compiler(>=5.1)
contiguousString.makeContiguousUTF8()
#else
contiguousString = string + ""
#endif
return contiguousString.utf8
}
internal static let stderr = StdioOutputStream(file: systemStderr, flushMode: .always)
internal static let stdout = StdioOutputStream(file: systemStdout, flushMode: .always)
@@ -917,7 +1121,7 @@ public struct StreamLogHandler: LogHandler {
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
var stream = self.stream
stream.write("\(self.timestamp()) \(level) \(self.label) :\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
stream.write("\(self.timestamp()) \(level) \(self.label) :\(prettyMetadata.map { " \($0)" } ?? "") [\(source)] \(message)\n")
}
private func prettify(_ metadata: Logger.Metadata) -> String? {
@@ -943,6 +1147,8 @@ public struct StreamLogHandler: LogHandler {
public struct SwiftLogNoOpLogHandler: LogHandler {
public init() {}
public init(_: String) {}
@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? {
@@ -979,6 +1185,18 @@ extension Logger {
String($0)
} ?? "n/a"
}
#if compiler(>=5.3)
@inlinable
internal static func currentModule(fileID: String = #fileID) -> String {
let utf8All = fileID.utf8
if let slashIndex = utf8All.firstIndex(of: UInt8(ascii: "/")) {
return String(fileID[..<slashIndex])
} else {
return "n/a"
}
}
#endif
}
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
@@ -41,6 +41,7 @@ extension LoggingTest {
("testAllLogLevelsWork", testAllLogLevelsWork),
("testAllLogLevelByFunctionRefWithSource", testAllLogLevelByFunctionRefWithSource),
("testAllLogLevelByFunctionRefWithoutSource", testAllLogLevelByFunctionRefWithoutSource),
("testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts", testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts),
("testLogMessageWithStringInterpolation", testLogMessageWithStringInterpolation),
("testLoggingAString", testLoggingAString),
("testMultiplexerIsValue", testMultiplexerIsValue),
@@ -51,6 +52,7 @@ extension LoggingTest {
("testStreamLogHandlerOutputFormat", testStreamLogHandlerOutputFormat),
("testStreamLogHandlerOutputFormatWithMetaData", testStreamLogHandlerOutputFormatWithMetaData),
("testStreamLogHandlerOutputFormatWithOrderedMetadata", testStreamLogHandlerOutputFormatWithOrderedMetadata),
("testStdioOutputStreamWrite", testStdioOutputStreamWrite),
("testStdioOutputStreamFlush", testStdioOutputStreamFlush),
("testOverloadingError", testOverloadingError),
]
+69 -8
View File
@@ -301,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"
}
@@ -455,6 +455,15 @@ class LoggingTest: XCTestCase {
let error = logger.error(_:metadata:file:function:line:)
let critical = logger.critical(_:metadata:file:function:line:)
#if compiler(>=5.3)
trace("yes: trace", [:], #fileID, #function, #line)
debug("yes: debug", [:], #fileID, #function, #line)
info("yes: info", [:], #fileID, #function, #line)
notice("yes: notice", [:], #fileID, #function, #line)
warning("yes: warning", [:], #fileID, #function, #line)
error("yes: error", [:], #fileID, #function, #line)
critical("yes: critical", [:], #fileID, #function, #line)
#else
trace("yes: trace", [:], #file, #function, #line)
debug("yes: debug", [:], #file, #function, #line)
info("yes: info", [:], #file, #function, #line)
@@ -462,6 +471,7 @@ class LoggingTest: XCTestCase {
warning("yes: warning", [:], #file, #function, #line)
error("yes: error", [:], #file, #function, #line)
critical("yes: critical", [:], #file, #function, #line)
#endif
testLogging.history.assertExist(level: .trace, message: "yes: trace")
testLogging.history.assertExist(level: .debug, message: "yes: debug")
@@ -472,6 +482,30 @@ class LoggingTest: XCTestCase {
testLogging.history.assertExist(level: .critical, message: "yes: critical")
}
func testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts() {
let testLogging = TestLogging()
LoggingSystem.bootstrapInternal(testLogging.make)
var logger = Logger(label: "\(#function)")
logger.logLevel = .trace
emitLogMessage("hello", to: logger)
#if compiler(>=5.3)
let moduleName = "LoggingTests" // the actual name
#else
let moduleName = "SubDirectoryOfLoggingTests" // the last path component of `#file` showing the failure mode
#endif
testLogging.history.assertExist(level: .trace, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .debug, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .info, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .notice, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .warning, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .error, message: "hello", source: moduleName)
testLogging.history.assertExist(level: .critical, message: "hello", source: moduleName)
}
func testLogMessageWithStringInterpolation() {
let testLogging = TestLogging()
LoggingSystem.bootstrapInternal(testLogging.make)
@@ -669,12 +703,13 @@ class LoggingTest: XCTestCase {
LoggingSystem.bootstrapInternal { _ in
StreamLogHandler(label: label, stream: interceptStream)
}
let source = "testSource"
let log = Logger(label: label)
let testString = "my message is better than yours"
log.critical("\(testString)")
log.critical("\(testString)", source: source)
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\s\(testString)$"
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\s\\[\(source)\\]\\s\(testString)$"
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(of: pattern, options: .regularExpression) != nil
@@ -688,12 +723,13 @@ class LoggingTest: XCTestCase {
LoggingSystem.bootstrapInternal { _ in
StreamLogHandler(label: label, stream: interceptStream)
}
let source = "testSource"
let log = Logger(label: label)
let testString = "my message is better than yours"
log.critical("\(testString)", metadata: ["test": "test"])
log.critical("\(testString)", metadata: ["test": "test"], source: source)
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\stest=test\\s\(testString)$"
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\stest=test\\s\\[\(source)\\]\\s\(testString)$"
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(of: pattern, options: .regularExpression) != nil
@@ -723,6 +759,22 @@ class LoggingTest: XCTestCase {
XCTAssert(interceptStream.strings[1].contains("a=a1 b=b1"))
}
func testStdioOutputStreamWrite() {
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
let logStream = StdioOutputStream(file: writeFD, flushMode: .always)
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
let log = Logger(label: "test")
let testString = "hello\u{0} world"
log.critical("\(testString)")
let size = read(readFD, readBuffer, 256)
let output = String(decoding: UnsafeRawBufferPointer(start: UnsafeRawPointer(readBuffer), count: size), as: UTF8.self)
let messageSucceeded = output.trimmingCharacters(in: .whitespacesAndNewlines).hasSuffix(testString)
XCTAssertTrue(messageSucceeded)
}
}
func testStdioOutputStreamFlush() {
// flush on every statement
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
@@ -756,7 +808,7 @@ class LoggingTest: XCTestCase {
var fds: [Int32] = [-1, -1]
fds.withUnsafeMutableBufferPointer { ptr in
let err = pipe(ptr.baseAddress!)
XCTAssertEqual(err, 0, "pipe faild \(err)")
XCTAssertEqual(err, 0, "pipe failed \(err)")
}
let writeFD = fdopen(fds[1], "w")
@@ -767,11 +819,11 @@ class LoggingTest: XCTestCase {
}
var err = setvbuf(writeFD, writeBuffer, _IOFBF, 256)
XCTAssertEqual(err, 0, "setvbuf faild \(err)")
XCTAssertEqual(err, 0, "setvbuf failed \(err)")
let readFD = fds[0]
err = fcntl(readFD, F_SETFL, fcntl(readFD, F_GETFL) | O_NONBLOCK)
XCTAssertEqual(err, 0, "fcntl faild \(err)")
XCTAssertEqual(err, 0, "fcntl failed \(err)")
let readBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: 256)
defer {
@@ -804,9 +856,18 @@ class LoggingTest: XCTestCase {
}
extension Logger {
#if compiler(>=5.3)
public func error(error: Error,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #fileID, function: String = #function, line: UInt = #line) {
self.error("\(error.localizedDescription)", metadata: metadata(), file: file, function: function, line: line)
}
#else
public func error(error: Error,
metadata: @autoclosure () -> Logger.Metadata? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.error("\(error.localizedDescription)", metadata: metadata(), file: file, function: function, line: line)
}
#endif
}
@@ -0,0 +1,25 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2021 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
internal func emitLogMessage(_ message: Logger.Message, to logger: Logger) {
logger.trace(message)
logger.debug(message)
logger.info(message)
logger.notice(message)
logger.warning(message)
logger.error(message)
logger.critical(message)
}
+31 -2
View File
@@ -174,6 +174,34 @@ internal struct LogEntry {
}
extension History {
#if compiler(>=5.3)
func assertExist(level: Logger.Level,
message: String,
metadata: Logger.Metadata? = nil,
source: String? = nil,
file: StaticString = #file,
fileID: String = #fileID,
line: UInt = #line) {
let source = source ?? Logger.currentModule(fileID: "\(fileID)")
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,
source: String? = nil,
file: StaticString = #file,
fileID: String = #file,
line: UInt = #line) {
let source = source ?? Logger.currentModule(fileID: "\(fileID)")
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)
}
#else
func assertExist(level: Logger.Level,
message: String,
metadata: Logger.Metadata? = nil,
@@ -183,7 +211,7 @@ extension History {
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)
file: file, line: line)
}
func assertNotExist(level: Logger.Level,
@@ -195,8 +223,9 @@ extension History {
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)
file: file, line: line)
}
#endif
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, source: String) -> LogEntry? {
return self.entries.first { entry in
+2 -1
View File
@@ -6,7 +6,8 @@ services:
image: swift-log:20.04-5.4
build:
args:
base_image: "swiftlang/swift:nightly-5.4-focal"
ubuntu_version: "focal"
swift_version: "5.4"
test:
image: swift-log:20.04-5.4