mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f4240bf022 | ||
|
|
ea3eea9dcb | ||
|
|
67b2425b4c | ||
|
|
dbb9d24d8d | ||
|
|
3e8f2138a1 | ||
|
|
a26395d403 | ||
|
|
0c403de592 | ||
|
|
9ac2ad4064 | ||
|
|
75c08c0611 | ||
|
|
cfd8740667 | ||
|
|
250cef01ad | ||
|
|
33ceed2816 | ||
|
|
6397eee678 | ||
|
|
4fe877816a | ||
|
|
851eacf76e | ||
|
|
856a83e9f4 | ||
|
|
e37f28a5ff |
No files matched your search
@@ -0,0 +1,20 @@
|
||||
### Expected behavior
|
||||
_[what you expected to happen]_
|
||||
|
||||
### Actual behavior
|
||||
_[what actually happened]_
|
||||
|
||||
### Steps to reproduce
|
||||
|
||||
1. ...
|
||||
2. ...
|
||||
|
||||
### If possible, minimal yet complete reproducer code (or URL to code)
|
||||
|
||||
_[anything to help us reproducing the issue]_
|
||||
|
||||
### SwiftLog version/commit hash
|
||||
|
||||
_[the SwiftLog tag/commit hash]_
|
||||
|
||||
### Swift & OS version (output of `swift --version && uname -a`)
|
||||
@@ -0,0 +1,13 @@
|
||||
_[One line description of your change]_
|
||||
|
||||
### Motivation:
|
||||
|
||||
_[Explain here the context, and why you're making that change. What is the problem you're trying to solve.]_
|
||||
|
||||
### Modifications:
|
||||
|
||||
_[Describe the modifications you've done.]_
|
||||
|
||||
### Result:
|
||||
|
||||
_[After your change, what will change.]_
|
||||
@@ -0,0 +1,11 @@
|
||||
# file options
|
||||
|
||||
# format options
|
||||
|
||||
--self insert
|
||||
--patternlet inline
|
||||
--stripunusedargs unnamed-only
|
||||
--comments ignore
|
||||
|
||||
# rules
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
## Legal
|
||||
|
||||
By submitting a pull request, you represent that you have the right to license
|
||||
your contribution to Apple and the community, and agree by submitting the patch
|
||||
that your contributions are licensed under the Apache 2.0 license (see
|
||||
`LICENSE.txt`).
|
||||
|
||||
## How to submit a bug report
|
||||
|
||||
Please ensure to specify the following:
|
||||
|
||||
* SwiftLog commit hash
|
||||
* Contextual information (e.g. what you were trying to achieve with SwiftLog)
|
||||
* Simplest possible steps to reproduce
|
||||
* More complex the steps are, lower the priority will be.
|
||||
* A pull request with failing test case is preferred, but it's just fine to paste the test case into the issue description.
|
||||
* Anything that might be relevant in your opinion, such as:
|
||||
* Swift version or the output of `swift --version`
|
||||
* OS version and the output of `uname -a`
|
||||
* Network configuration
|
||||
|
||||
### Example
|
||||
|
||||
```
|
||||
SwiftLog commit hash: 4fe877816ad82627602377f415b6a66850214824
|
||||
|
||||
Context:
|
||||
While testing my application that uses with SwiftLog, I noticed that ...
|
||||
|
||||
Steps to reproduce:
|
||||
1. ...
|
||||
2. ...
|
||||
3. ...
|
||||
4. ...
|
||||
|
||||
$ swift --version
|
||||
Swift version 4.0.2 (swift-4.0.2-RELEASE)
|
||||
Target: x86_64-unknown-linux-gnu
|
||||
|
||||
Operating system: Ubuntu Linux 16.04 64-bit
|
||||
|
||||
$ uname -a
|
||||
Linux beefy.machine 4.4.0-101-generic #124-Ubuntu SMP Fri Nov 10 18:29:59 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
|
||||
|
||||
My system has IPv6 disabled.
|
||||
```
|
||||
|
||||
## Writing a Patch
|
||||
|
||||
A good SwiftLog patch is:
|
||||
|
||||
1. Concise, and contains as few changes as needed to achieve the end result.
|
||||
2. Tested, ensuring that any tests provided failed before the patch and pass after it.
|
||||
3. Documented, adding API documentation as needed to cover new functions and properties.
|
||||
4. Accompanied by a great commit message, using our commit message template.
|
||||
|
||||
### Commit Message Template
|
||||
|
||||
We require that your commit messages match our template. The easiest way to do that is to get git to help you by explicitly using the template. To do that, `cd` to the root of our repository and run:
|
||||
|
||||
git config commit.template dev/git.commit.template
|
||||
|
||||
### Make sure Tests work on Linux
|
||||
|
||||
SwiftLog uses XCTest to run tests on both macOS and Linux. While the macOS version of XCTest is able to use the Objective-C runtime to discover tests at execution time, the Linux version is not.
|
||||
For this reason, whenever you add new tests **you have to run a script** that generates the hooks needed to run those tests on Linux, or our CI will complain that the tests are not all present on Linux. To do this, merely execute `ruby ./scripts/generate_linux_tests.rb` at the root of the package and check the changes it made.
|
||||
|
||||
## How to contribute your work
|
||||
|
||||
Please open a pull request at https://github.com/apple/swift-log. Make sure the CI passes, and then wait for code review.
|
||||
+2
-1
@@ -35,7 +35,8 @@ This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
|
||||
|
||||
---
|
||||
|
||||
This product contains a derivation of SwiftNIO locks.
|
||||
This product contains a derivation of the lock implementation and various
|
||||
scripts from SwiftNIO.
|
||||
|
||||
* LICENSE (Apache License 2.0):
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:4.0
|
||||
// swift-tools-version:5.0
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
|
||||
@@ -1,3 +1,236 @@
|
||||
# SwiftLog for Swift 4
|
||||
# SwiftLog
|
||||
|
||||
Please refer to the documentation on the [master branch](https://github.com/apple/swift-log/blob/master/README.md).
|
||||
A Logging API package for Swift. Version `1.0.0` requires Swift 5.0 but there is a version `0.x.y` series available for Swift 4 to ease your transition towards Swift 5. If you intend to use or support SwiftLog for Swift 4, please check the [paragraph](#help-i-need-swift-4) at the end of the document.
|
||||
|
||||
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!
|
||||
```
|
||||
|
||||
#### Default `Logger` behavior
|
||||
|
||||
`SwiftLog` provides for very basic console logging out-of-the-box by way of `StreamLogHandler`. It is possible to switch the default output to `stderr` like so:
|
||||
```
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardError)
|
||||
```
|
||||
|
||||
`StreamLogHandler` is primarily a convenience only and does not provide any substantial customization. Library maintainers who aim to build their own logging backends for integration and consumption should implement the `LogHandler` protocol directly as laid out in [the "On the implementation of a logging backend" section](#on-the-implementation-of-a-logging-backend-a-loghandler).
|
||||
|
||||
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.
|
||||
|
||||
## SwiftLog for Swift 4
|
||||
<a name="help-i-need-swift-4"></a>
|
||||
|
||||
First of, SwiftLog 1.0.x and SwiftLog 0.0.x are mostly compatible so don't be afraid. In fact, SwiftLog 0.0.0 is the same source code as SwiftLog 1.0.0 with a few changes made to make it Swift 4 compatible.
|
||||
|
||||
### How can I use SwiftLog 0 library or application?
|
||||
|
||||
If you have a application or a library that needs to be compatible with both Swift 4 and 5, then we recommend using the following in your `Package.swift`:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-log.git", Version("0.0.0") ..< Version("2.0.0")),
|
||||
```
|
||||
|
||||
This will instruct SwiftPM to allow any SwiftLog 0 and any SwiftLog 1 version. This is an unusual form because usually packages don't support multiple major versions of a package. Because SwiftLog 0 and 1 are mostly compatible however, this should not be a real issue and will enable everybody to get the best. If compiled with a Swift 4 compiler, this will be a SwiftLog 0 version but if compiled with a Swift 5 compiler everybody will get the best experience and performance delivered by SwiftLog 1.
|
||||
|
||||
In most cases, there is only one thing you need to remember: Always use _string literals_ and _string interpolations_ in the log methods and don't rely on the fact that SwiftLog 0 also allows `String`.
|
||||
|
||||
Good:
|
||||
|
||||
logger.info("hello world")
|
||||
|
||||
Bad:
|
||||
|
||||
let message = "hello world"
|
||||
logger.info(message)
|
||||
|
||||
If you have a `String` that you received from elsewhere, please use
|
||||
|
||||
logger.info("\(stringIAlreadyHave)")
|
||||
|
||||
For more details, have a look in the next section.
|
||||
|
||||
|
||||
### What are the differences between SwiftLog 1 and 0?
|
||||
|
||||
- SwiftLog 0 does not use `@inlinable`.
|
||||
- Apart from accepting `Logger.Message` for the message, SwiftLog 0 has a `String` overload.
|
||||
- In SwiftLog 0, `Logger.Message` is not `ExpressibleByStringLiteral` or `ExpressibleByStringInterpolation`.
|
||||
- In SwiftLog 0, `Logger.MetadataValue` is not `ExpressibleByStringLiteral` or `ExpressibleByStringInterpolation`.
|
||||
|
||||
#### Why these differences?
|
||||
|
||||
##### @inlinable
|
||||
|
||||
Swift 4.0 & 4.1 don't support `@inlinable`, so SwiftLog 0 can't use them.
|
||||
|
||||
##### Logger.Message
|
||||
Because all Swift 4 versions don't have a (non-deprecated) mechanism for a type to be `ExpressibleByStringInterpolation` we couldn't make `Logger.Message` expressible by string literals. Unfortunately, the most basic form of our logging API is `logger.info("Hello \(world)")`. For this to work however, `"Hello \(world)"` needs to be accepted and because we can't make `Logger.Message` `ExpressibleByStringInterpolation` we added an overload for all the logging methods to also accept `String`. In most cases, you won't even notice that with SwiftLog 0 you're creating a `String` (which is then transformed to a `Logger.Message`) and with SwiftLog 1 you're creating a `Logger.Message` directly. That is because both `String` and `Logger.Message` will accept all forms of string literals and string interpolations.
|
||||
Unfortunately, there is code that will make this seemingly small difference visible. If you write
|
||||
|
||||
let message = "Hello world"
|
||||
logger.info(message)
|
||||
|
||||
then this will only work in SwiftLog 0 and not in SwiftLog 1. Why? Because SwiftLog 1 will want a `Logger.Message` but `let message = "Hello world"` will make `message` to be of type `String` and in SwiftLog 1, the logging methods don't accept `String`s.
|
||||
|
||||
So if you intend to be compatible with SwiftLog 0 and 1 at the same time, please make sure to always use a _string literal_ or a _string interpolation_ inside of the logging methods.
|
||||
|
||||
In the case that you already have a `String` handy that you want to log, don't worry at all, just use
|
||||
|
||||
let message = "Hello world"
|
||||
logger.info("\(message)")
|
||||
|
||||
and again, you will be okay with SwiftLog 0 and 1.
|
||||
|
||||
## 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
|
||||
@@ -49,11 +49,7 @@ 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.
|
||||
@@ -84,6 +80,7 @@ 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 {
|
||||
@@ -93,6 +90,7 @@ extension Lock {
|
||||
}
|
||||
|
||||
// specialise Void return (for performance)
|
||||
@inlinable
|
||||
internal func withLockVoid(_ body: () throws -> Void) rethrows {
|
||||
try self.withLock(body)
|
||||
}
|
||||
@@ -115,11 +113,7 @@ 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.
|
||||
@@ -159,6 +153,7 @@ 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 {
|
||||
@@ -175,6 +170,7 @@ 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 {
|
||||
@@ -184,11 +180,13 @@ 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)
|
||||
}
|
||||
|
||||
+132
-250
@@ -26,7 +26,10 @@
|
||||
/// logger.info("Hello World!")
|
||||
///
|
||||
public struct Logger {
|
||||
@usableFromInline
|
||||
var handler: LogHandler
|
||||
|
||||
/// An identifier of the creator of this `Logger`.
|
||||
public let label: String
|
||||
|
||||
internal init(label: String, _ handler: LogHandler) {
|
||||
@@ -46,11 +49,12 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// defaults to `#line`).
|
||||
@inlinable
|
||||
public func log(level: Logger.Level,
|
||||
_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
@@ -63,21 +67,11 @@ 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]
|
||||
@@ -93,6 +87,7 @@ 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
|
||||
@@ -104,7 +99,7 @@ extension Logger {
|
||||
}
|
||||
|
||||
extension Logger {
|
||||
/// Log a message passing with the `Logger.trace` log level.
|
||||
/// Log a message passing with the `Logger.Level.trace` log level.
|
||||
///
|
||||
/// If `.trace` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
/// otherwise nothing will happen.
|
||||
@@ -114,38 +109,19 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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.
|
||||
/// Log a message passing with the `Logger.Level.debug` log level.
|
||||
///
|
||||
/// If `.debug` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
/// otherwise nothing will happen.
|
||||
@@ -155,37 +131,18 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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,
|
||||
@@ -196,37 +153,18 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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,
|
||||
@@ -237,37 +175,18 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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,
|
||||
@@ -278,37 +197,18 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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,
|
||||
@@ -319,37 +219,18 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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.
|
||||
@@ -359,36 +240,17 @@ 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 `#file`).
|
||||
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
|
||||
/// it defaults to `#file`.
|
||||
/// 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`.
|
||||
/// 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
|
||||
@@ -396,7 +258,7 @@ extension Logger {
|
||||
/// implementation.
|
||||
public enum LoggingSystem {
|
||||
fileprivate static let lock = ReadWriteLock()
|
||||
fileprivate static var factory: (String) -> LogHandler = StdoutLogHandler.init
|
||||
fileprivate static var factory: (String) -> LogHandler = StreamLogHandler.standardOutput
|
||||
fileprivate static var initialized = false
|
||||
|
||||
/// `bootstrap` is a one-time configuration function which globally selects the desired logging backend
|
||||
@@ -406,7 +268,7 @@ public enum LoggingSystem {
|
||||
/// - parameters:
|
||||
/// - factory: A closure that given a `Logger` identifier, produces an instance of the `LogHandler`.
|
||||
public static func bootstrap(_ factory: @escaping (String) -> LogHandler) {
|
||||
lock.withWriterLock {
|
||||
self.lock.withWriterLock {
|
||||
precondition(!self.initialized, "logging system can only be initialized once per process.")
|
||||
self.factory = factory
|
||||
self.initialized = true
|
||||
@@ -444,7 +306,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 {
|
||||
public enum Level: CaseIterable {
|
||||
/// Appropriate for messages that contain information only when debugging a program.
|
||||
case trace
|
||||
|
||||
@@ -466,7 +328,7 @@ extension Logger {
|
||||
/// Appropriate for error conditions.
|
||||
case error
|
||||
|
||||
/// Appropriate for criticial error conditions that usually require immediate
|
||||
/// Appropriate for critical error conditions that usually require immediate
|
||||
/// attention.
|
||||
///
|
||||
/// When a `critical` message is logged, the logging backend (`LogHandler`) is free to perform
|
||||
@@ -562,7 +424,10 @@ extension Logger {
|
||||
///
|
||||
/// logger.info("Hello \(world)")
|
||||
///
|
||||
public struct Message: CustomStringConvertible {
|
||||
public struct Message: ExpressibleByStringLiteral,
|
||||
Equatable,
|
||||
CustomStringConvertible,
|
||||
ExpressibleByStringInterpolation {
|
||||
public typealias StringLiteralType = String
|
||||
|
||||
private var value: String
|
||||
@@ -577,34 +442,6 @@ 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
|
||||
@@ -613,8 +450,13 @@ extension Logger.Message: Equatable {}
|
||||
public struct MultiplexLogHandler: LogHandler {
|
||||
private var handlers: [LogHandler]
|
||||
|
||||
/// Create a `MultiplexLogHandler`.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - 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.count > 0)
|
||||
assert(!handlers.isEmpty)
|
||||
self.handlers = handlers
|
||||
}
|
||||
|
||||
@@ -663,32 +505,74 @@ public struct MultiplexLogHandler: LogHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/// Ships with the logging module, really boring just prints something using the `print` function
|
||||
internal struct StdoutLogHandler: LogHandler {
|
||||
private let lock = Lock()
|
||||
/// A wrapper to facilitate `print`-ing to stderr and stdio that
|
||||
/// ensures access to the underlying `FILE` is locked to prevent
|
||||
/// cross-thread interleaving of output.
|
||||
internal struct StdioOutputStream: TextOutputStream {
|
||||
internal let file: UnsafeMutablePointer<FILE>
|
||||
|
||||
public init(label: String) {}
|
||||
|
||||
private var _logLevel: Logger.Level = .info
|
||||
|
||||
public var logLevel: Logger.Level {
|
||||
get {
|
||||
return self.lock.withLock { self._logLevel }
|
||||
}
|
||||
set {
|
||||
self.lock.withLock {
|
||||
self._logLevel = newValue
|
||||
internal func write(_ string: String) {
|
||||
string.withCString { ptr in
|
||||
flockfile(file)
|
||||
defer {
|
||||
funlockfile(file)
|
||||
}
|
||||
_ = fputs(ptr, file)
|
||||
}
|
||||
}
|
||||
|
||||
internal static let stderr = StdioOutputStream(file: systemStderr)
|
||||
internal static let stdout = StdioOutputStream(file: systemStdout)
|
||||
}
|
||||
|
||||
// Prevent name clashes
|
||||
#if os(macOS) || os(tvOS) || os(iOS) || os(watchOS)
|
||||
let systemStderr = Darwin.stderr
|
||||
let systemStdout = Darwin.stdout
|
||||
#else
|
||||
let systemStderr = Glibc.stderr!
|
||||
let systemStdout = Glibc.stdout!
|
||||
#endif
|
||||
|
||||
/// `StreamLogHandler` is a simple implementation of `LogHandler` for directing
|
||||
/// `Logger` output to either `stderr` or `stdout` via the factory methods.
|
||||
public struct StreamLogHandler: LogHandler {
|
||||
|
||||
/// Factory that makes a `StreamLogHandler` to directs its output to `stdout`
|
||||
public static func standardOutput(label: String) -> StreamLogHandler {
|
||||
return StreamLogHandler(label: label, stream: StdioOutputStream.stdout)
|
||||
}
|
||||
|
||||
/// Factory that makes a `StreamLogHandler` to directs its output to `stderr`
|
||||
public static func standardError(label: String) -> StreamLogHandler {
|
||||
return StreamLogHandler(label: label, stream: StdioOutputStream.stderr)
|
||||
}
|
||||
|
||||
private let stream: TextOutputStream
|
||||
|
||||
public var logLevel: Logger.Level = .info
|
||||
|
||||
private var prettyMetadata: String?
|
||||
private var _metadata = Logger.Metadata() {
|
||||
public var metadata = Logger.Metadata() {
|
||||
didSet {
|
||||
self.prettyMetadata = self.prettify(self._metadata)
|
||||
prettyMetadata = prettify(metadata)
|
||||
}
|
||||
}
|
||||
|
||||
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return metadata[metadataKey]
|
||||
}
|
||||
set {
|
||||
metadata[metadataKey] = newValue
|
||||
}
|
||||
}
|
||||
|
||||
// internal for testing only
|
||||
internal init(label: String, stream: TextOutputStream) {
|
||||
self.stream = stream
|
||||
}
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
@@ -696,27 +580,9 @@ internal struct StdoutLogHandler: LogHandler {
|
||||
let prettyMetadata = metadata?.isEmpty ?? true
|
||||
? self.prettyMetadata
|
||||
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
|
||||
print("\(self.timestamp()) \(level):\(prettyMetadata.map { " \($0)" } ?? "") \(message)")
|
||||
}
|
||||
|
||||
public var metadata: Logger.Metadata {
|
||||
get {
|
||||
return self.lock.withLock { self._metadata }
|
||||
}
|
||||
set {
|
||||
self.lock.withLock { self._metadata = newValue }
|
||||
}
|
||||
}
|
||||
|
||||
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.lock.withLock { self._metadata[metadataKey] }
|
||||
}
|
||||
set {
|
||||
self.lock.withLock {
|
||||
self._metadata[metadataKey] = newValue
|
||||
}
|
||||
}
|
||||
var stream = self.stream
|
||||
stream.write("\(timestamp()) \(level):\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
|
||||
}
|
||||
|
||||
private func prettify(_ metadata: Logger.Metadata) -> String? {
|
||||
@@ -729,13 +595,25 @@ internal struct StdoutLogHandler: LogHandler {
|
||||
let localTime = localtime(×tamp)
|
||||
strftime(&buffer, buffer.count, "%Y-%m-%dT%H:%M:%S%z", localTime)
|
||||
return buffer.withUnsafeBufferPointer {
|
||||
$0.baseAddress!.withMemoryRebound(to: CChar.self, capacity: $0.count) { ptr in
|
||||
String(cString: ptr)
|
||||
$0.withMemoryRebound(to: CChar.self) {
|
||||
String(cString: $0.baseAddress!)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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 {
|
||||
public typealias StringLiteralType = String
|
||||
|
||||
public init(stringLiteral value: String) {
|
||||
self = .string(value)
|
||||
}
|
||||
}
|
||||
|
||||
// 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: CustomStringConvertible {
|
||||
public var description: String {
|
||||
switch self {
|
||||
@@ -753,6 +631,10 @@ extension Logger.MetadataValue: CustomStringConvertible {
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringInterpolation {}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9686
|
||||
extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
|
||||
public typealias Key = String
|
||||
public typealias Value = Logger.Metadata.Value
|
||||
@@ -763,7 +645,7 @@ extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
|
||||
}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
// https://bugs.swift.org/browse/SR-9686
|
||||
extension Logger.MetadataValue: ExpressibleByArrayLiteral {
|
||||
public typealias ArrayLiteralElement = Logger.Metadata.Value
|
||||
|
||||
|
||||
@@ -23,12 +23,12 @@ import XCTest
|
||||
///
|
||||
|
||||
#if os(Linux) || os(FreeBSD)
|
||||
@testable import LoggingTests
|
||||
@testable import LoggingTests
|
||||
|
||||
XCTMain([
|
||||
testCase(GlobalLoggerTest.allTests),
|
||||
testCase(LocalLoggerTest.allTests),
|
||||
testCase(LoggingTest.allTests),
|
||||
testCase(MDCTest.allTests),
|
||||
XCTMain([
|
||||
testCase(GlobalLoggerTest.allTests),
|
||||
testCase(LocalLoggerTest.allTests),
|
||||
testCase(LoggingTest.allTests),
|
||||
testCase(MDCTest.allTests),
|
||||
])
|
||||
#endif
|
||||
@@ -23,13 +23,11 @@ import XCTest
|
||||
///
|
||||
|
||||
extension GlobalLoggerTest {
|
||||
|
||||
static var allTests : [(String, (GlobalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
("test3", test3),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (GlobalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
("test3", test3),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,11 +11,8 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Dispatch
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
class GlobalLoggerTest: XCTestCase {
|
||||
func test1() throws {
|
||||
@@ -145,7 +142,7 @@ private struct Struct3 {
|
||||
}
|
||||
|
||||
private func doSomethingElse() {
|
||||
MDC.global["foo"] = .string("bar")
|
||||
MDC.global["foo"] = "bar"
|
||||
self.logger.error("Struct3::doSomethingElse")
|
||||
let group = DispatchGroup()
|
||||
group.enter()
|
||||
@@ -164,7 +161,7 @@ private struct Struct3 {
|
||||
MDC.global["foo"] = nil
|
||||
// only effects the logger instance
|
||||
var l = logger
|
||||
l[metadataKey: "baz"] = .string("qux")
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
|
||||
@@ -23,12 +23,10 @@ import XCTest
|
||||
///
|
||||
|
||||
extension LocalLoggerTest {
|
||||
|
||||
static var allTests : [(String, (LocalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (LocalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,11 +11,8 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Dispatch
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
class LocalLoggerTest: XCTestCase {
|
||||
func test1() throws {
|
||||
@@ -132,7 +129,7 @@ private struct Struct3 {
|
||||
|
||||
func doSomething(context: Context) {
|
||||
var c = context
|
||||
c["bar"] = .string("baz") // only effects from this point on
|
||||
c["bar"] = "baz" // only effects from this point on
|
||||
c.logger.error("Struct3::doSomething")
|
||||
doSomethingElse(context: c)
|
||||
c.logger.debug("Struct3::doSomething::end")
|
||||
@@ -153,7 +150,7 @@ private struct Struct3 {
|
||||
group.wait()
|
||||
// only effects the logger instance
|
||||
var l = context.logger
|
||||
l[metadataKey: "baz"] = .string("qux")
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
context.logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
|
||||
@@ -23,22 +23,25 @@ import XCTest
|
||||
///
|
||||
|
||||
extension LoggingTest {
|
||||
|
||||
static var allTests : [(String, (LoggingTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testAutoclosure", testAutoclosure),
|
||||
("testMultiplex", testMultiplex),
|
||||
("testAutoClosuresAreNotForcedUnlessNeeded", testAutoClosuresAreNotForcedUnlessNeeded),
|
||||
("testLocalMetadata", testLocalMetadata),
|
||||
("testCustomFactory", testCustomFactory),
|
||||
("testAllLogLevelsExceptCriticalCanBeBlocked", testAllLogLevelsExceptCriticalCanBeBlocked),
|
||||
("testAllLogLevelsWork", testAllLogLevelsWork),
|
||||
("testLogMessageWithStringInterpolation", testLogMessageWithStringInterpolation),
|
||||
("testLoggingAString", testLoggingAString),
|
||||
("testMultiplexerIsValue", testMultiplexerIsValue),
|
||||
("testLoggerWithGlobalOverride", testLoggerWithGlobalOverride),
|
||||
("testLogLevelOrdering", testLogLevelOrdering),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (LoggingTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testAutoclosure", testAutoclosure),
|
||||
("testMultiplex", testMultiplex),
|
||||
("testDictionaryMetadata", testDictionaryMetadata),
|
||||
("testListMetadata", testListMetadata),
|
||||
("testStringConvertibleMetadata", testStringConvertibleMetadata),
|
||||
("testAutoClosuresAreNotForcedUnlessNeeded", testAutoClosuresAreNotForcedUnlessNeeded),
|
||||
("testLocalMetadata", testLocalMetadata),
|
||||
("testCustomFactory", testCustomFactory),
|
||||
("testAllLogLevelsExceptCriticalCanBeBlocked", testAllLogLevelsExceptCriticalCanBeBlocked),
|
||||
("testAllLogLevelsWork", testAllLogLevelsWork),
|
||||
("testLogMessageWithStringInterpolation", testLogMessageWithStringInterpolation),
|
||||
("testLoggingAString", testLoggingAString),
|
||||
("testMultiplexerIsValue", testMultiplexerIsValue),
|
||||
("testLoggerWithGlobalOverride", testLoggerWithGlobalOverride),
|
||||
("testLogLevelCases", testLogLevelCases),
|
||||
("testLogLevelOrdering", testLogLevelOrdering),
|
||||
("testStreamLogHandlerWritesToAStream", testStreamLogHandlerWritesToAStream),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,12 +22,10 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .info
|
||||
logger.log(level: .debug, { () -> String in
|
||||
logger.log(level: .debug, {
|
||||
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"
|
||||
@@ -36,26 +34,6 @@ 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"
|
||||
}())
|
||||
@@ -82,7 +60,7 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .warning
|
||||
logger.info("hello world?")
|
||||
logger[metadataKey: "foo"] = .string("bar")
|
||||
logger[metadataKey: "foo"] = "bar"
|
||||
logger.warning("hello world!")
|
||||
logging1.history.assertNotExist(level: .info, message: "hello world?")
|
||||
logging2.history.assertNotExist(level: .info, message: "hello world?")
|
||||
@@ -94,11 +72,43 @@ 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 {
|
||||
private var makeValue: (() -> String)?
|
||||
private var _value: String? = nil
|
||||
private var _value: String?
|
||||
|
||||
public init(_ makeValue: @escaping () -> String) {
|
||||
self.makeValue = makeValue
|
||||
@@ -121,24 +131,25 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
#if swift(>=4.1.50)
|
||||
#if compiler(>=5.0)
|
||||
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" }))])
|
||||
}
|
||||
|
||||
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()
|
||||
@@ -160,8 +171,8 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.info("hello world!", metadata: ["foo": "bar"])
|
||||
logger[metadataKey: "bar"] = .string("baz")
|
||||
logger[metadataKey: "baz"] = .string("qux")
|
||||
logger[metadataKey: "bar"] = "baz"
|
||||
logger[metadataKey: "baz"] = "qux"
|
||||
logger.warning("hello world!")
|
||||
logger.error("hello world!", metadata: ["baz": "quc"])
|
||||
testLogging.history.assertExist(level: .info, message: "hello world!", metadata: ["foo": "bar"])
|
||||
@@ -250,7 +261,7 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .debug
|
||||
|
||||
let someInt = 42
|
||||
let someInt = Int.random(in: 23 ..< 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)
|
||||
@@ -273,7 +284,7 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
|
||||
func testMultiplexerIsValue() {
|
||||
let multi = MultiplexLogHandler([StdoutLogHandler(label: "x"), StdoutLogHandler(label: "y")])
|
||||
let multi = MultiplexLogHandler([StreamLogHandler.standardOutput(label: "x"), StreamLogHandler.standardOutput(label: "y")])
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
print("new multi")
|
||||
return multi
|
||||
@@ -281,17 +292,17 @@ class LoggingTest: XCTestCase {
|
||||
var logger1: Logger = {
|
||||
var logger = Logger(label: "foo")
|
||||
logger.logLevel = .debug
|
||||
logger[metadataKey: "only-on"] = .string("first")
|
||||
logger[metadataKey: "only-on"] = "first"
|
||||
return logger
|
||||
}()
|
||||
XCTAssertEqual(.debug, logger1.logLevel)
|
||||
var logger2 = logger1
|
||||
logger2.logLevel = .error
|
||||
logger2[metadataKey: "only-on"] = .string("second")
|
||||
logger2[metadataKey: "only-on"] = "second"
|
||||
XCTAssertEqual(.error, logger2.logLevel)
|
||||
XCTAssertEqual(.debug, logger1.logLevel)
|
||||
XCTAssertEqual(.string("first"), logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual(.string("second"), logger2[metadataKey: "only-on"])
|
||||
XCTAssertEqual("first", logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual("second", logger2[metadataKey: "only-on"])
|
||||
logger1.error("hey")
|
||||
}
|
||||
|
||||
@@ -299,7 +310,7 @@ class LoggingTest: XCTestCase {
|
||||
struct LogHandlerWithGlobalLogLevelOverride: LogHandler {
|
||||
// the static properties hold the globally overridden log level (if overridden)
|
||||
private static let overrideLock = Lock()
|
||||
private static var overrideLogLevel: Logger.Level? = nil
|
||||
private static var overrideLogLevel: Logger.Level?
|
||||
|
||||
private let recorder: Recorder
|
||||
// this holds the log level if not overridden
|
||||
@@ -316,7 +327,7 @@ class LoggingTest: XCTestCase {
|
||||
// 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
|
||||
LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
} ?? self._logLevel
|
||||
}
|
||||
// we set the log level whenever we're asked (note: this might not have an effect if globally
|
||||
@@ -356,13 +367,13 @@ class LoggingTest: XCTestCase {
|
||||
var logger1 = Logger(label: "logger-\(#file):\(#line)")
|
||||
var logger2 = logger1
|
||||
logger1.logLevel = .warning
|
||||
logger1[metadataKey: "only-on"] = .string("first")
|
||||
logger1[metadataKey: "only-on"] = "first"
|
||||
logger2.logLevel = .error
|
||||
logger2[metadataKey: "only-on"] = .string("second")
|
||||
logger2[metadataKey: "only-on"] = "second"
|
||||
XCTAssertEqual(.error, logger2.logLevel)
|
||||
XCTAssertEqual(.warning, logger1.logLevel)
|
||||
XCTAssertEqual(Logger.MetadataValue.string("first"), logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual(Logger.MetadataValue.string("second"), logger2[metadataKey: "only-on"])
|
||||
XCTAssertEqual("first", logger1[metadataKey: "only-on"])
|
||||
XCTAssertEqual("second", logger2[metadataKey: "only-on"])
|
||||
|
||||
logger1.notice("logger1, before")
|
||||
logger2.notice("logger2, before")
|
||||
@@ -378,6 +389,11 @@ 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)
|
||||
@@ -401,4 +417,31 @@ class LoggingTest: XCTestCase {
|
||||
XCTAssertLessThan(Logger.Level.warning, Logger.Level.critical)
|
||||
XCTAssertLessThan(Logger.Level.error, Logger.Level.critical)
|
||||
}
|
||||
|
||||
final class InterceptStream: TextOutputStream {
|
||||
var interceptedText: String?
|
||||
var strings = [String]()
|
||||
|
||||
func write(_ string: String) {
|
||||
// This is a test implementation, a real implementation would include locking
|
||||
strings.append(string)
|
||||
interceptedText = (interceptedText ?? "") + string
|
||||
}
|
||||
}
|
||||
|
||||
func testStreamLogHandlerWritesToAStream() {
|
||||
let interceptStream = InterceptStream()
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
StreamLogHandler(label: "test", stream: interceptStream)
|
||||
}
|
||||
let log = Logger(label: "test")
|
||||
|
||||
let testString = "my message is better than yours"
|
||||
log.critical("\(testString)")
|
||||
|
||||
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).hasSuffix(testString)
|
||||
|
||||
XCTAssertTrue(messageSucceeded ?? false)
|
||||
XCTAssertEqual(interceptStream.strings.count, 1)
|
||||
}
|
||||
}
|
||||
@@ -23,11 +23,9 @@ import XCTest
|
||||
///
|
||||
|
||||
extension MDCTest {
|
||||
|
||||
static var allTests : [(String, (MDCTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (MDCTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,15 +22,15 @@ class MDCTest: XCTestCase {
|
||||
LoggingSystem.bootstrapInternal(logging.make)
|
||||
|
||||
// run the program
|
||||
MDC.global["foo"] = .string("bar")
|
||||
MDC.global["foo"] = "bar"
|
||||
let group = DispatchGroup()
|
||||
for r in 5 ... 10 {
|
||||
group.enter()
|
||||
DispatchQueue(label: "mdc-test-queue-\(r)").async {
|
||||
let add = 999
|
||||
let remove = 123
|
||||
let add = Int.random(in: 10 ... 1000)
|
||||
let remove = Int.random(in: 0 ... add - 1)
|
||||
for i in 0 ... add {
|
||||
MDC.global["key-\(i)"] = .string("value-\(i)")
|
||||
MDC.global["key-\(i)"] = "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"], .string("bar"), "expecting to find top items")
|
||||
XCTAssertEqual(MDC.global["foo"], "bar", "expecting to find top items")
|
||||
MDC.global["foo"] = nil
|
||||
XCTAssertTrue(MDC.global.metadata.isEmpty, "MDC should be empty")
|
||||
}
|
||||
|
||||
@@ -11,12 +11,9 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Dispatch
|
||||
import Foundation
|
||||
import XCTest
|
||||
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
internal struct TestLogging {
|
||||
private let _config = Config() // shared among loggers
|
||||
@@ -42,7 +39,7 @@ internal struct TestLogHandler: LogHandler {
|
||||
self.label = label
|
||||
self.config = config
|
||||
self.recorder = recorder
|
||||
self.logger = Logger(label: "test", StdoutLogHandler(label: label))
|
||||
self.logger = Logger(label: "test", StreamLogHandler.standardOutput(label: label))
|
||||
self.logger.logLevel = .debug
|
||||
}
|
||||
|
||||
@@ -176,14 +173,12 @@ internal struct LogEntry {
|
||||
}
|
||||
|
||||
extension History {
|
||||
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) } }
|
||||
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 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) } }
|
||||
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)
|
||||
}
|
||||
@@ -257,11 +252,11 @@ public class MDC {
|
||||
}
|
||||
|
||||
private var threadId: Int {
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
return Int(pthread_mach_thread_np(pthread_self()))
|
||||
#else
|
||||
return Int(pthread_self())
|
||||
#endif
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
return Int(pthread_mach_thread_np(pthread_self()))
|
||||
#else
|
||||
return Int(pthread_self())
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
One line description of your change
|
||||
|
||||
Motivation:
|
||||
|
||||
Explain here the context, and why you're making that change.
|
||||
What is the problem you're trying to solve.
|
||||
|
||||
Modifications:
|
||||
|
||||
Describe the modifications you've done.
|
||||
|
||||
Result:
|
||||
|
||||
After your change, what will change.
|
||||
@@ -1,13 +0,0 @@
|
||||
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
|
||||
@@ -8,8 +8,6 @@ services:
|
||||
args:
|
||||
ubuntu_version: "18.04"
|
||||
swift_version: "5.0"
|
||||
swift_flavour: "DEVELOPMENT-SNAPSHOT-2019-03-06-a"
|
||||
swift_builds_suffix: "branch"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.0
|
||||
Executable
+94
@@ -0,0 +1,94 @@
|
||||
#!/bin/bash
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the Swift Logging API open source project
|
||||
##
|
||||
## Copyright (c) 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
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the SwiftNIO open source project
|
||||
##
|
||||
## Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
set -eu
|
||||
|
||||
function usage() {
|
||||
echo "$0 [-u] version"
|
||||
echo
|
||||
echo "OPTIONS:"
|
||||
echo " -u: Additionally upload the podspec"
|
||||
}
|
||||
|
||||
upload=false
|
||||
while getopts ":u" opt; do
|
||||
case $opt in
|
||||
u)
|
||||
upload=true
|
||||
;;
|
||||
\?)
|
||||
usage
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
shift "$((OPTIND-1))"
|
||||
|
||||
if [[ $# -eq 0 ]]; then
|
||||
echo "Must provide target version"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
version=$1
|
||||
podspec_name="Logging"
|
||||
|
||||
here="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
tmpdir=$(mktemp -d /tmp/.build_podspecsXXXXXX)
|
||||
echo "Building podspec in $tmpdir"
|
||||
|
||||
cat > "${tmpdir}/${podspec_name}.podspec" <<- EOF
|
||||
Pod::Spec.new do |s|
|
||||
s.name = '$podspec_name'
|
||||
s.version = '$version'
|
||||
s.license = { :type => 'Apache 2.0', :file => 'LICENSE.txt' }
|
||||
s.summary = 'A Logging API for Swift.'
|
||||
s.homepage = 'https://github.com/apple/swift-log'
|
||||
s.author = 'Apple Inc.'
|
||||
s.source = { :git => 'https://github.com/apple/swift-log.git', :tag => s.version.to_s }
|
||||
s.documentation_url = 'https://apple.github.io/swift-log'
|
||||
s.module_name = 'Logging'
|
||||
|
||||
s.swift_version = '5.0'
|
||||
s.cocoapods_version = '>=1.6.0'
|
||||
s.ios.deployment_target = '8.0'
|
||||
s.osx.deployment_target = '10.9'
|
||||
s.tvos.deployment_target = '9.0'
|
||||
s.watchos.deployment_target = '2.0'
|
||||
|
||||
s.source_files = 'Sources/Logging/**/*.swift'
|
||||
end
|
||||
EOF
|
||||
|
||||
if $upload; then
|
||||
echo "Uploading ${tmpdir}/${podspec_name}.podspec"
|
||||
pod trunk push "${tmpdir}/${podspec_name}.podspec"
|
||||
else
|
||||
echo "Linting ${tmpdir}/${podspec_name}.podspec"
|
||||
pod spec lint "${tmpdir}/${podspec_name}.podspec"
|
||||
fi
|
||||
@@ -57,6 +57,7 @@ jazzy_args=(--clean
|
||||
--readme "$module_switcher"
|
||||
--author_url https://github.com/apple/swift-log
|
||||
--github_url https://github.com/apple/swift-log
|
||||
--github-file-prefix https://github.com/apple/swift-log/tree/$version
|
||||
--theme fullwidth
|
||||
--xcodebuild-arguments -scheme,swift-log-Package)
|
||||
cat > "$module_switcher" <<"EOF"
|
||||
|
||||
@@ -71,17 +71,17 @@ def createExtensionFile(fileName, classes)
|
||||
file.write "\n"
|
||||
|
||||
for classArray in classes
|
||||
file.write 'extension ' + classArray[0] + " {\n\n"
|
||||
file.write ' static var allTests : [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
|
||||
file.write " return [\n"
|
||||
file.write 'extension ' + classArray[0] + " {\n"
|
||||
file.write ' static var allTests: [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
|
||||
file.write " return [\n"
|
||||
|
||||
for funcName in classArray[1]
|
||||
file.write ' ("' + funcName + '", ' + funcName + "),\n"
|
||||
file.write ' ("' + funcName + '", ' + funcName + "),\n"
|
||||
end
|
||||
|
||||
file.write " ]\n"
|
||||
file.write " }\n"
|
||||
file.write "}\n\n"
|
||||
file.write " ]\n"
|
||||
file.write " }\n"
|
||||
file.write "}\n"
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -96,10 +96,10 @@ def createLinuxMain(testsDirectory, allTestSubDirectories, files)
|
||||
|
||||
file.write "#if os(Linux) || os(FreeBSD)\n"
|
||||
for testSubDirectory in allTestSubDirectories.sort { |x, y| x <=> y }
|
||||
file.write ' @testable import ' + testSubDirectory + "\n"
|
||||
file.write ' @testable import ' + testSubDirectory + "\n"
|
||||
end
|
||||
file.write "\n"
|
||||
file.write " XCTMain([\n"
|
||||
file.write " XCTMain([\n"
|
||||
|
||||
testCases = []
|
||||
for classes in files
|
||||
@@ -109,7 +109,7 @@ def createLinuxMain(testsDirectory, allTestSubDirectories, files)
|
||||
end
|
||||
|
||||
for testCase in testCases.sort { |x, y| x <=> y }
|
||||
file.write ' testCase(' + testCase + ".allTests),\n"
|
||||
file.write ' testCase(' + testCase + ".allTests),\n"
|
||||
end
|
||||
file.write " ])\n"
|
||||
file.write "#endif\n"
|
||||
|
||||
+24
-5
@@ -13,9 +13,28 @@
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the SwiftNIO open source project
|
||||
##
|
||||
## Copyright (c) 2017-2019 Apple Inc. and the SwiftNIO project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
set -eu
|
||||
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/'
|
||||
}
|
||||
|
||||
printf "=> Checking linux tests... "
|
||||
FIRST_OUT="$(git status --porcelain)"
|
||||
ruby "$here/../scripts/generate_linux_tests.rb" > /dev/null
|
||||
@@ -45,7 +64,7 @@ for language in swift-or-c bash dtrace; do
|
||||
//
|
||||
// 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
|
||||
// Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
@@ -64,7 +83,7 @@ EOF
|
||||
##
|
||||
## 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
|
||||
## Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
@@ -83,7 +102,7 @@ EOF
|
||||
*
|
||||
* 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
|
||||
* Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
* Licensed under Apache License v2.0
|
||||
*
|
||||
* See LICENSE.txt for license information
|
||||
@@ -108,9 +127,9 @@ EOF
|
||||
\( \! -path './.build/*' -a \
|
||||
\( "${matching_files[@]}" \) -a \
|
||||
\( \! \( "${exceptions[@]}" \) \) \) | while read line; do
|
||||
if [[ "$(cat "$line" | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
if [[ "$(cat "$line" | replace_acceptable_years | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
printf "\033[0;31mmissing headers in file '$line'!\033[0m\n"
|
||||
diff -u <(cat "$line" | head -n $expected_lines) "$tmp"
|
||||
diff -u <(cat "$line" | replace_acceptable_years | head -n $expected_lines) "$tmp"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
|
||||
Reference in new issue
Block a user