mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
4
Commits
tomerd-patch-3
...
0.0.0
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
eba9b323b5 | ||
|
|
2f65697362 | ||
|
|
9533e02d79 | ||
|
|
d1af77eebd |
No files matched your search
+1
-1
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:5.0
|
||||
// swift-tools-version:4.0
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
|
||||
@@ -1,163 +1,3 @@
|
||||
# SwiftLog
|
||||
# SwiftLog for Swift 4
|
||||
|
||||
A Logging API package for Swift. Version `1.0.0` requires Swift 5.0 but in due course we will also tag a mostly compatible version for Swift 4 (which will be tagged `0.x`) to ease your transition towards Swift 5.
|
||||
|
||||
First things first: This is the beginning of a community-driven open-source project actively seeking contributions, be it code, documentation, or ideas. Apart from contributing to `SwiftLog` itself, there's another huge gap at the moment: `SwiftLog` is an _API package_ which tries to establish a common API the ecosystem can use. To make logging really work for real-world workloads, we need `SwiftLog`-compatible _logging backends_ which then either persist the log messages in files, render them in nicer colors on the terminal, or send them over to Splunk or ELK.
|
||||
|
||||
What `SwiftLog` provides today can be found in the [API docs][api-docs].
|
||||
|
||||
## Great, what's the tl;dr
|
||||
|
||||
If you have a server-side Swift application, or maybe a cross-platform (for example Linux & macOS) app/library, and you would like to log, we think targeting this logging API package is a great idea. Below you'll find all you need to know to get started.
|
||||
|
||||
#### 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`:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
|
||||
```
|
||||
|
||||
and to your application/library target, add `"Logging"` to your `dependencies`, e.g. like this:
|
||||
|
||||
```swift
|
||||
.target(name: "BestExampleApp", dependencies: ["Logging']),
|
||||
```
|
||||
|
||||
#### Let's log
|
||||
|
||||
```swift
|
||||
// 1) let's import the logging API package
|
||||
import Logging
|
||||
|
||||
// 2) we need to create a logger, the label works similarly to a DispatchQueue label
|
||||
let logger = Logger(label: "com.example.BestExampleApp.main")
|
||||
|
||||
// 3) we're now ready to use it
|
||||
logger.info("Hello World!")
|
||||
```
|
||||
|
||||
#### Output
|
||||
|
||||
```
|
||||
2019-03-13T15:46:38+0000 info: Hello World!
|
||||
```
|
||||
|
||||
For further information, please check the [API documentation][api-docs].
|
||||
|
||||
## What is an API package?
|
||||
|
||||
Glad you asked. We believe that for the Swift on Server ecosystem, it's crucial to have a logging API that can be adopted by anybody so a multitude of libraries from different parties can all log to a shared destination. More concretely this means that we believe all the log messages from all libraries end up in the same file, database, Elastic Stack/Splunk instance, or whatever you may choose.
|
||||
|
||||
In the real-world however, there are so many opinions over how exactly a logging system should behave, what a log message should be formatted like, and where/how it should be persisted. We think it's not feasible to wait for one logging package to support everything that a specific deployment needs whilst still being easy enough to use and remain performant. That's why we decided to cut the problem in half:
|
||||
|
||||
1. a logging API
|
||||
2. a logging backend implementation
|
||||
|
||||
This package only provides the logging API itself and therefore `SwiftLog` is a 'logging API package'. `SwiftLog` (using `LoggingSystem.bootstrap`) can be configured to choose any compatible logging backend implementation. This way packages can adopt the API and the _application_ can choose any compatible logging backend implementation without requiring any changes from any of the libraries.
|
||||
|
||||
Just for completeness sake: This API package does actually include an overly simplistic and non-configurable logging backend implementation which simply writes all log messages to `stdout`. The reason to include this overly simplistic logging backend implementation is to improve the first-time usage experience. Let's assume you start a project and try out `SwiftLog` for the first time, it's just a whole lot better to see something you logged appear on `stdout` in a simplistic format rather than nothing happening at all. For any real-world application, we advise configuring another logging backend implementation that logs in the style you like.
|
||||
|
||||
## The core concepts
|
||||
|
||||
### Loggers
|
||||
|
||||
`Logger`s are used to emit log messages and therefore the most important type in `SwiftLog`, so their use should be as simple as possible. Most commonly, they are used to emit log messages in a certain log level. For example:
|
||||
|
||||
```swift
|
||||
// logging an informational message
|
||||
logger.info("Hello World!")
|
||||
|
||||
// ouch, something went wrong
|
||||
logger.error("Houston, we have a problem: \(problem)")
|
||||
```
|
||||
|
||||
### Log levels
|
||||
|
||||
The following log levels are supported:
|
||||
|
||||
- `trace`
|
||||
- `debug`
|
||||
- `info`
|
||||
- `notice`
|
||||
- `warning`
|
||||
- `error`
|
||||
- `critical`
|
||||
|
||||
The log level of a given logger can be changed, but the change will only affect the specific logger you changed it on. You could say the `Logger` is a _value type_ regarding the log level.
|
||||
|
||||
|
||||
### Logging metadata
|
||||
|
||||
Logging metadata is metadata that can be attached to loggers to add information that is crucial when debugging a problem. In servers, the usual example is attaching a request UUID to a logger that will then be present on all log messages logged with that logger. Example:
|
||||
|
||||
```swift
|
||||
var logger = logger
|
||||
logger[metadataKey: "request-uuid"] = "\(UUID())"
|
||||
logger.info("hello world")
|
||||
```
|
||||
|
||||
will print
|
||||
|
||||
```
|
||||
2019-03-13T18:30:02+0000 info: request-uuid=F8633013-3DD8-481C-9256-B296E43443ED hello world
|
||||
```
|
||||
|
||||
with the default logging backend implementation that ships with `SwiftLog`. Needless to say, the format is fully defined by the logging backend you choose.
|
||||
|
||||
## On the implementation of a logging backend (a `LogHandler`)
|
||||
|
||||
Note: If you don't want to implement a custom logging backend, everything in this section is probably not very relevant, so please feel free to skip.
|
||||
|
||||
To become a compatible logging backend that all `SwiftLog` consumers can use, you need to do two things: 1) Implement a type (usually a `struct`) that implements `LogHandler`, a protocol provided by `SwiftLog` and 2) instruct `SwiftLog` to use your logging backend implementation.
|
||||
|
||||
A `LogHandler` or logging backend implementation is anything that conforms to the following protocol
|
||||
|
||||
```swift
|
||||
public protocol LogHandler {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt)
|
||||
|
||||
subscript(metadataKey _: String) -> Logger.Metadata.Value? { get set }
|
||||
|
||||
var metadata: Logger.Metadata { get set }
|
||||
|
||||
var logLevel: Logger.Level { get set }
|
||||
}
|
||||
```
|
||||
|
||||
Instructing `SwiftLog` to use your logging backend as the one the whole application (including all libraries) should use is very simple:
|
||||
|
||||
LoggingSystem.bootstrap(MyLogHandler.init)
|
||||
|
||||
### Implementation considerations
|
||||
|
||||
`LogHandler`s control most parts of the logging system:
|
||||
|
||||
#### Under control of a `LogHandler`
|
||||
|
||||
##### Configuration
|
||||
|
||||
`LogHandler`s control the two crucial pieces of `Logger` configuration, namely:
|
||||
|
||||
- log level (`logger.logLevel` property)
|
||||
- logging metadata (`logger[metadataKey:]` and `logger.metadata`)
|
||||
|
||||
For the system to work, however, it is important that `LogHandler` treat the configuration as _value types_. This means that `LogHandler`s should be `struct`s and a change in log level or logging metadata should only affect the very `LogHandler` it was changed on.
|
||||
|
||||
However, in special cases, it is acceptable that a `LogHandler` provides some global log level override that may affect all `LogHandler`s created.
|
||||
|
||||
##### Emitting
|
||||
- emitting the log message itself
|
||||
|
||||
### Not under control of `LogHandler`s
|
||||
|
||||
`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.
|
||||
|
||||
## Design
|
||||
|
||||
This logging API was designed with the contributors to the Swift on Server community and approved by the [SSWG (Swift Server Work Group)](https://swift.org/server/) to the 'sandbox level' of the SSWG's [incubation process](https://github.com/swift-server/sswg/blob/master/process/incubation.md).
|
||||
|
||||
- [pitch](https://forums.swift.org/t/logging/16027), [discussion](https://forums.swift.org/t/discussion-server-logging-api/18834), [feedback](https://forums.swift.org/t/feedback-server-logging-api-with-revisions/19375)
|
||||
- [log levels](https://forums.swift.org/t/logging-levels-for-swifts-server-side-logging-apis-and-new-os-log-apis/20365)
|
||||
|
||||
[api-docs]: https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger.html
|
||||
Please refer to the documentation on the [master branch](https://github.com/apple/swift-log/blob/master/README.md).
|
||||
@@ -49,7 +49,11 @@ internal final class Lock {
|
||||
deinit {
|
||||
let err = pthread_mutex_destroy(self.mutex)
|
||||
precondition(err == 0)
|
||||
#if swift(>=4.0) && !swift(>=4.0.50)
|
||||
self.mutex.deallocate(capacity: 1)
|
||||
#else
|
||||
self.mutex.deallocate()
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire the lock.
|
||||
@@ -80,7 +84,6 @@ extension Lock {
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
self.lock()
|
||||
defer {
|
||||
@@ -90,7 +93,6 @@ extension Lock {
|
||||
}
|
||||
|
||||
// specialise Void return (for performance)
|
||||
@inlinable
|
||||
internal func withLockVoid(_ body: () throws -> Void) rethrows {
|
||||
try self.withLock(body)
|
||||
}
|
||||
@@ -113,7 +115,11 @@ internal final class ReadWriteLock {
|
||||
deinit {
|
||||
let err = pthread_rwlock_destroy(self.rwlock)
|
||||
precondition(err == 0)
|
||||
#if swift(>=4.0) && !swift(>=4.0.50)
|
||||
self.rwlock.deallocate(capacity: 1)
|
||||
#else
|
||||
self.rwlock.deallocate()
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire a reader lock.
|
||||
@@ -153,7 +159,6 @@ extension ReadWriteLock {
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withReaderLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
self.lockRead()
|
||||
defer {
|
||||
@@ -170,7 +175,6 @@ extension ReadWriteLock {
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withWriterLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
self.lockWrite()
|
||||
defer {
|
||||
@@ -180,13 +184,11 @@ extension ReadWriteLock {
|
||||
}
|
||||
|
||||
// specialise Void return (for performance)
|
||||
@inlinable
|
||||
internal func withReaderLockVoid(_ body: () throws -> Void) rethrows {
|
||||
try self.withReaderLock(body)
|
||||
}
|
||||
|
||||
// specialise Void return (for performance)
|
||||
@inlinable
|
||||
internal func withWriterLockVoid(_ body: () throws -> Void) rethrows {
|
||||
try self.withWriterLock(body)
|
||||
}
|
||||
|
||||
+183
-33
@@ -26,7 +26,6 @@
|
||||
/// logger.info("Hello World!")
|
||||
///
|
||||
public struct Logger {
|
||||
@usableFromInline
|
||||
var handler: LogHandler
|
||||
public let label: String
|
||||
|
||||
@@ -52,7 +51,6 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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,
|
||||
@@ -65,11 +63,21 @@ extension Logger {
|
||||
}
|
||||
}
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: level,
|
||||
Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
|
||||
/// Add, change, or remove a logging metadata item.
|
||||
///
|
||||
/// - note: Logging metadata behaves as a value that means a change to the logging metadata will only affect the
|
||||
/// very `Logger` it was changed on.
|
||||
@inlinable
|
||||
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.handler[metadataKey: metadataKey]
|
||||
@@ -85,7 +93,6 @@ extension Logger {
|
||||
/// very `Logger`. It it acceptable for logging backends to have some form of global log level override
|
||||
/// that affects multiple or even all loggers. This means a change in `logLevel` to one `Logger` might in
|
||||
/// certain cases have no effect.
|
||||
@inlinable
|
||||
public var logLevel: Logger.Level {
|
||||
get {
|
||||
return self.handler.logLevel
|
||||
@@ -112,13 +119,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 trace(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .trace, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func trace(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.trace(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func trace(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.trace(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.info` log level.
|
||||
///
|
||||
/// If `.debug` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
@@ -134,13 +160,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 debug(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .debug, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func debug(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.debug(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func debug(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.debug(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.Level.info` log level.
|
||||
///
|
||||
/// If `.info` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
@@ -156,13 +201,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 info(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .info, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func info(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.info(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func info(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.info(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.Level.notice` log level.
|
||||
///
|
||||
/// If `.notice` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
@@ -178,13 +242,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 notice(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .notice, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func notice(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.notice(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func notice(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.notice(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.Level.warning` log level.
|
||||
///
|
||||
/// If `.warning` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
@@ -200,13 +283,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 warning(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .warning, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func warning(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.warning(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func warning(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.warning(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.Level.error` log level.
|
||||
///
|
||||
/// If `.error` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
@@ -222,13 +324,32 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 error(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .error, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func error(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.error(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func error(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.error(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Log a message passing with the `Logger.Level.critical` log level.
|
||||
///
|
||||
/// `.critical` messages will always be logged.
|
||||
@@ -243,12 +364,31 @@ extension Logger {
|
||||
/// it defaults to `#file`.
|
||||
/// - 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 critical(_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.log(level: .critical, message(), metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if !compiler(>=5.0)
|
||||
public func critical(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.critical(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
public func critical(_ message: @autoclosure () -> String,
|
||||
metadata: @autoclosure () -> [String: String]? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.critical(Logger.Message(stringLiteral: message()),
|
||||
metadata: metadata().map { $0.mapValues { Logger.MetadataValue.string($0) } },
|
||||
file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/// The `LoggingSystem` is a global facility where the default logging backend implementation (`LogHandler`) can be
|
||||
@@ -304,7 +444,7 @@ extension Logger {
|
||||
///
|
||||
/// Raw values of log levels correspond to their severity, and are ordered by lowest numeric value (0) being
|
||||
/// the most severe. The raw values match the syslog values.
|
||||
public enum Level: CaseIterable {
|
||||
public enum Level {
|
||||
/// Appropriate for messages that contain information only when debugging a program.
|
||||
case trace
|
||||
|
||||
@@ -422,10 +562,7 @@ extension Logger {
|
||||
///
|
||||
/// logger.info("Hello \(world)")
|
||||
///
|
||||
public struct Message: ExpressibleByStringLiteral,
|
||||
Equatable,
|
||||
CustomStringConvertible,
|
||||
ExpressibleByStringInterpolation {
|
||||
public struct Message: CustomStringConvertible {
|
||||
public typealias StringLiteralType = String
|
||||
|
||||
private var value: String
|
||||
@@ -440,6 +577,34 @@ extension Logger {
|
||||
}
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if compiler(>=5.0)
|
||||
extension Logger.Message: ExpressibleByStringLiteral,
|
||||
ExpressibleByStringInterpolation {}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringLiteral, ExpressibleByStringInterpolation {
|
||||
public typealias StringLiteralType = String
|
||||
|
||||
public init(stringLiteral value: String) {
|
||||
self = .string(value)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !swift(>=4.1.50)
|
||||
extension Logger.Message: Equatable {
|
||||
public static func == (lhs: Logger.Message, rhs: Logger.Message) -> Bool {
|
||||
return lhs.value == rhs.value
|
||||
}
|
||||
}
|
||||
#else
|
||||
extension Logger.Message: Equatable {}
|
||||
#endif
|
||||
|
||||
|
||||
/// 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
|
||||
@@ -564,23 +729,13 @@ internal struct StdoutLogHandler: LogHandler {
|
||||
let localTime = localtime(×tamp)
|
||||
strftime(&buffer, buffer.count, "%Y-%m-%dT%H:%M:%S%z", localTime)
|
||||
return buffer.withUnsafeBufferPointer {
|
||||
$0.withMemoryRebound(to: CChar.self) {
|
||||
String(cString: $0.baseAddress!)
|
||||
$0.baseAddress!.withMemoryRebound(to: CChar.self, capacity: $0.count) { ptr in
|
||||
String(cString: ptr)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringLiteral {
|
||||
public typealias StringLiteralType = String
|
||||
|
||||
public init(stringLiteral value: String) {
|
||||
self = .string(value)
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger.MetadataValue: CustomStringConvertible {
|
||||
public var description: String {
|
||||
switch self {
|
||||
@@ -596,11 +751,6 @@ extension Logger.MetadataValue: CustomStringConvertible {
|
||||
}
|
||||
}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringInterpolation {
|
||||
}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
|
||||
|
||||
@@ -11,9 +11,12 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@testable import Logging
|
||||
|
||||
import Dispatch
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
|
||||
class GlobalLoggerTest: XCTestCase {
|
||||
func test1() throws {
|
||||
// bootstrap with our test logging impl
|
||||
@@ -142,7 +145,7 @@ private struct Struct3 {
|
||||
}
|
||||
|
||||
private func doSomethingElse() {
|
||||
MDC.global["foo"] = "bar"
|
||||
MDC.global["foo"] = .string("bar")
|
||||
self.logger.error("Struct3::doSomethingElse")
|
||||
let group = DispatchGroup()
|
||||
group.enter()
|
||||
@@ -161,7 +164,7 @@ private struct Struct3 {
|
||||
MDC.global["foo"] = nil
|
||||
// only effects the logger instance
|
||||
var l = logger
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
l[metadataKey: "baz"] = .string("qux")
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
|
||||
@@ -11,9 +11,12 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@testable import Logging
|
||||
|
||||
import Dispatch
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
|
||||
class LocalLoggerTest: XCTestCase {
|
||||
func test1() throws {
|
||||
// bootstrap with our test logging impl
|
||||
@@ -129,7 +132,7 @@ private struct Struct3 {
|
||||
|
||||
func doSomething(context: Context) {
|
||||
var c = context
|
||||
c["bar"] = "baz" // only effects from this point on
|
||||
c["bar"] = .string("baz") // only effects from this point on
|
||||
c.logger.error("Struct3::doSomething")
|
||||
doSomethingElse(context: c)
|
||||
c.logger.debug("Struct3::doSomething::end")
|
||||
@@ -150,7 +153,7 @@ private struct Struct3 {
|
||||
group.wait()
|
||||
// only effects the logger instance
|
||||
var l = context.logger
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
l[metadataKey: "baz"] = .string("qux")
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
context.logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
|
||||
@@ -28,9 +28,6 @@ extension LoggingTest {
|
||||
return [
|
||||
("testAutoclosure", testAutoclosure),
|
||||
("testMultiplex", testMultiplex),
|
||||
("testDictionaryMetadata", testDictionaryMetadata),
|
||||
("testListMetadata", testListMetadata),
|
||||
("testStringConvertibleMetadata", testStringConvertibleMetadata),
|
||||
("testAutoClosuresAreNotForcedUnlessNeeded", testAutoClosuresAreNotForcedUnlessNeeded),
|
||||
("testLocalMetadata", testLocalMetadata),
|
||||
("testCustomFactory", testCustomFactory),
|
||||
@@ -40,7 +37,6 @@ extension LoggingTest {
|
||||
("testLoggingAString", testLoggingAString),
|
||||
("testMultiplexerIsValue", testMultiplexerIsValue),
|
||||
("testLoggerWithGlobalOverride", testLoggerWithGlobalOverride),
|
||||
("testLogLevelCases", testLogLevelCases),
|
||||
("testLogLevelOrdering", testLogLevelOrdering),
|
||||
]
|
||||
}
|
||||
|
||||
@@ -22,10 +22,12 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .info
|
||||
logger.log(level: .debug, {
|
||||
logger.log(level: .debug, { () -> String in
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
}())
|
||||
#if swift(>=4.1.50)
|
||||
#if compiler(>=5.0)
|
||||
logger.debug({
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
@@ -34,6 +36,26 @@ class LoggingTest: XCTestCase {
|
||||
XCTFail("debug should not be called")
|
||||
return "debug"
|
||||
}())
|
||||
#else
|
||||
logger.debug({ () -> String in
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
}())
|
||||
logger.debug({ () -> String in
|
||||
XCTFail("debug should not be called")
|
||||
return "debug"
|
||||
}())
|
||||
#endif
|
||||
#else
|
||||
logger.debug({ () -> String in
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
}())
|
||||
logger.debug({ () -> String in
|
||||
XCTFail("debug should not be called")
|
||||
return "debug"
|
||||
}())
|
||||
#endif
|
||||
logger.info({
|
||||
"info"
|
||||
}())
|
||||
@@ -60,7 +82,7 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .warning
|
||||
logger.info("hello world?")
|
||||
logger[metadataKey: "foo"] = "bar"
|
||||
logger[metadataKey: "foo"] = .string("bar")
|
||||
logger.warning("hello world!")
|
||||
logging1.history.assertNotExist(level: .info, message: "hello world?")
|
||||
logging2.history.assertNotExist(level: .info, message: "hello world?")
|
||||
@@ -72,38 +94,6 @@ class LoggingTest: XCTestCase {
|
||||
case boom
|
||||
}
|
||||
|
||||
func testDictionaryMetadata() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger[metadataKey: "foo"] = ["bar": "buz"]
|
||||
logger[metadataKey: "empty-dict"] = [:]
|
||||
logger[metadataKey: "nested-dict"] = ["l1key": ["l2key": ["l3key": "l3value"]]]
|
||||
logger.info("hello world!")
|
||||
testLogging.history.assertExist(level: .info,
|
||||
message: "hello world!",
|
||||
metadata: ["foo": ["bar": "buz"],
|
||||
"empty-dict": [:],
|
||||
"nested-dict": ["l1key": ["l2key": ["l3key": "l3value"]]]])
|
||||
}
|
||||
|
||||
func testListMetadata() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger[metadataKey: "foo"] = ["bar", "buz"]
|
||||
logger[metadataKey: "empty-list"] = []
|
||||
logger[metadataKey: "nested-list"] = ["l1str", ["l2str1", "l2str2"]]
|
||||
logger.info("hello world!")
|
||||
testLogging.history.assertExist(level: .info,
|
||||
message: "hello world!",
|
||||
metadata: ["foo": ["bar", "buz"],
|
||||
"empty-list": [],
|
||||
"nested-list": ["l1str", ["l2str1", "l2str2"]]])
|
||||
}
|
||||
|
||||
// Example of custom "box" which may be used to implement "render at most once" semantics
|
||||
// Not thread-safe, thus should not be shared across threads.
|
||||
internal class LazyMetadataBox: CustomStringConvertible {
|
||||
@@ -131,25 +121,24 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func testStringConvertibleMetadata() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
var logger = Logger(label: "\(#function)")
|
||||
|
||||
logger[metadataKey: "foo"] = .stringConvertible("raw-string")
|
||||
let lazyBox = LazyMetadataBox({ "rendered-at-first-use" })
|
||||
logger[metadataKey: "lazy"] = .stringConvertible(lazyBox)
|
||||
logger.info("hello world!")
|
||||
testLogging.history.assertExist(level: .info,
|
||||
message: "hello world!",
|
||||
metadata: ["foo": .stringConvertible("raw-string"),
|
||||
"lazy": .stringConvertible(LazyMetadataBox({ "rendered-at-first-use" }))])
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if compiler(>=5.0)
|
||||
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> Logger.Message {
|
||||
XCTFail("should not have been evaluated", file: file, line: line)
|
||||
return "should not have been evaluated"
|
||||
}
|
||||
#else
|
||||
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> String {
|
||||
XCTFail("should not have been evaluated", file: file, line: line)
|
||||
return "should not have been evaluated"
|
||||
}
|
||||
#endif
|
||||
#else
|
||||
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> String {
|
||||
XCTFail("should not have been evaluated", file: file, line: line)
|
||||
return "should not have been evaluated"
|
||||
}
|
||||
#endif
|
||||
|
||||
func testAutoClosuresAreNotForcedUnlessNeeded() {
|
||||
let testLogging = TestLogging()
|
||||
@@ -171,8 +160,8 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.info("hello world!", metadata: ["foo": "bar"])
|
||||
logger[metadataKey: "bar"] = "baz"
|
||||
logger[metadataKey: "baz"] = "qux"
|
||||
logger[metadataKey: "bar"] = .string("baz")
|
||||
logger[metadataKey: "baz"] = .string("qux")
|
||||
logger.warning("hello world!")
|
||||
logger.error("hello world!", metadata: ["baz": "quc"])
|
||||
testLogging.history.assertExist(level: .info, message: "hello world!", metadata: ["foo": "bar"])
|
||||
@@ -261,7 +250,7 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .debug
|
||||
|
||||
let someInt = Int.random(in: 23..<42)
|
||||
let someInt = 42
|
||||
logger.debug("My favourite number is \(someInt) and not \(someInt - 1)")
|
||||
testLogging.history.assertExist(level: .debug,
|
||||
message: "My favourite number is \(someInt) and not \(someInt - 1)" as String)
|
||||
@@ -292,17 +281,17 @@ class LoggingTest: XCTestCase {
|
||||
var logger1: Logger = {
|
||||
var logger = Logger(label: "foo")
|
||||
logger.logLevel = .debug
|
||||
logger[metadataKey: "only-on"] = "first"
|
||||
logger[metadataKey: "only-on"] = .string("first")
|
||||
return logger
|
||||
}()
|
||||
XCTAssertEqual(.debug, logger1.logLevel)
|
||||
var logger2 = logger1
|
||||
logger2.logLevel = .error
|
||||
logger2[metadataKey: "only-on"] = "second"
|
||||
logger2[metadataKey: "only-on"] = .string("second")
|
||||
XCTAssertEqual(.error, logger2.logLevel)
|
||||
XCTAssertEqual(.debug, logger1.logLevel)
|
||||
XCTAssertEqual("first", logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual("second", logger2[metadataKey: "only-on"])
|
||||
XCTAssertEqual(.string("first"), logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual(.string("second"), logger2[metadataKey: "only-on"])
|
||||
logger1.error("hey")
|
||||
}
|
||||
|
||||
@@ -367,13 +356,13 @@ class LoggingTest: XCTestCase {
|
||||
var logger1 = Logger(label: "logger-\(#file):\(#line)")
|
||||
var logger2 = logger1
|
||||
logger1.logLevel = .warning
|
||||
logger1[metadataKey: "only-on"] = "first"
|
||||
logger1[metadataKey: "only-on"] = .string("first")
|
||||
logger2.logLevel = .error
|
||||
logger2[metadataKey: "only-on"] = "second"
|
||||
logger2[metadataKey: "only-on"] = .string("second")
|
||||
XCTAssertEqual(.error, logger2.logLevel)
|
||||
XCTAssertEqual(.warning, logger1.logLevel)
|
||||
XCTAssertEqual("first", logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual("second", logger2[metadataKey: "only-on"])
|
||||
XCTAssertEqual(Logger.MetadataValue.string("first"), logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual(Logger.MetadataValue.string("second"), logger2[metadataKey: "only-on"])
|
||||
|
||||
logger1.notice("logger1, before")
|
||||
logger2.notice("logger2, before")
|
||||
@@ -389,11 +378,6 @@ class LoggingTest: XCTestCase {
|
||||
logRecorder.assertExist(level: .notice, message: "logger2, after")
|
||||
}
|
||||
|
||||
func testLogLevelCases() {
|
||||
let levels = Logger.Level.allCases
|
||||
XCTAssertEqual(7, levels.count)
|
||||
}
|
||||
|
||||
func testLogLevelOrdering() {
|
||||
XCTAssertLessThan(Logger.Level.trace, Logger.Level.debug)
|
||||
XCTAssertLessThan(Logger.Level.trace, Logger.Level.info)
|
||||
|
||||
@@ -22,15 +22,15 @@ class MDCTest: XCTestCase {
|
||||
LoggingSystem.bootstrapInternal(logging.make)
|
||||
|
||||
// run the program
|
||||
MDC.global["foo"] = "bar"
|
||||
MDC.global["foo"] = .string("bar")
|
||||
let group = DispatchGroup()
|
||||
for r in 5 ... 10 {
|
||||
group.enter()
|
||||
DispatchQueue(label: "mdc-test-queue-\(r)").async {
|
||||
let add = Int.random(in: 10 ... 1000)
|
||||
let remove = Int.random(in: 0 ... add - 1)
|
||||
let add = 999
|
||||
let remove = 123
|
||||
for i in 0 ... add {
|
||||
MDC.global["key-\(i)"] = "value-\(i)"
|
||||
MDC.global["key-\(i)"] = .string("value-\(i)")
|
||||
}
|
||||
for i in 0 ... remove {
|
||||
MDC.global["key-\(i)"] = nil
|
||||
@@ -47,7 +47,7 @@ class MDCTest: XCTestCase {
|
||||
}
|
||||
}
|
||||
group.wait()
|
||||
XCTAssertEqual(MDC.global["foo"], "bar", "expecting to find top items")
|
||||
XCTAssertEqual(MDC.global["foo"], .string("bar"), "expecting to find top items")
|
||||
MDC.global["foo"] = nil
|
||||
XCTAssertTrue(MDC.global.metadata.isEmpty, "MDC should be empty")
|
||||
}
|
||||
|
||||
@@ -11,10 +11,13 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Dispatch
|
||||
import Foundation
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
|
||||
internal struct TestLogging {
|
||||
private let _config = Config() // shared among loggers
|
||||
private let recorder = Recorder() // shared among loggers
|
||||
@@ -173,12 +176,14 @@ internal struct LogEntry {
|
||||
}
|
||||
|
||||
extension History {
|
||||
func assertExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
func assertExist(level: Logger.Level, message: String, metadata: [String: String]? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let metadata = metadata.map { $0.mapValues { Logger.MetadataValue.string($0) } }
|
||||
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 assertNotExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
func assertNotExist(level: Logger.Level, message: String, metadata: [String: String]? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let metadata = metadata.map { $0.mapValues { Logger.MetadataValue.string($0) } }
|
||||
let entry = self.find(level: level, message: message, metadata: metadata)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(String(describing: metadata)), \(message)", file: file, line: line)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:16.04-4.0
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "16.04"
|
||||
swift_version: "4.0"
|
||||
|
||||
test:
|
||||
image: swift-log:16.04-4.0
|
||||
Reference in new issue
Block a user