mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
eba9b323b5 | ||
|
|
2f65697362 | ||
|
|
9533e02d79 | ||
|
|
d1af77eebd |
No files matched your search
@@ -1,20 +0,0 @@
|
||||
### 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`)
|
||||
@@ -1,13 +0,0 @@
|
||||
_[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.]_
|
||||
@@ -4,7 +4,6 @@
|
||||
/*.xcodeproj
|
||||
.xcode
|
||||
DerivedData
|
||||
.swiftpm
|
||||
|
||||
.SourceKitten/
|
||||
docs/
|
||||
@@ -1,13 +0,0 @@
|
||||
# file options
|
||||
|
||||
--exclude .build
|
||||
|
||||
# format options
|
||||
|
||||
--self insert
|
||||
--patternlet inline
|
||||
--stripunusedargs unnamed-only
|
||||
--comments ignore
|
||||
--ifdef no-indent
|
||||
|
||||
# rules
|
||||
+1
-1
@@ -49,7 +49,7 @@ of an incident.
|
||||
*This policy is adapted from the Contributor Code of Conduct [version 1.3.0](https://contributor-covenant.org/version/1/3/0/).*
|
||||
|
||||
### Reporting
|
||||
A working group of community members is committed to promptly addressing any [reported issues](mailto:swift-server-conduct@group.apple.com).
|
||||
A working group of community members is committed to promptly addressing any [reported issues](mailto:swift-log-conduct@group.apple.com).
|
||||
Working group members are volunteers appointed by the project lead, with a
|
||||
preference for individuals with varied backgrounds and perspectives. Membership is expected
|
||||
to change regularly, and may grow or shrink.
|
||||
@@ -1,70 +0,0 @@
|
||||
## 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.
|
||||
+1
-2
@@ -35,8 +35,7 @@ This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
|
||||
|
||||
---
|
||||
|
||||
This product contains a derivation of the lock implementation and various
|
||||
scripts from SwiftNIO.
|
||||
This product contains a derivation of SwiftNIO locks.
|
||||
|
||||
* LICENSE (Apache License 2.0):
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
+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,248 +1,3 @@
|
||||
# SwiftLog
|
||||
# SwiftLog for Swift 4
|
||||
|
||||
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].
|
||||
|
||||
## Getting started
|
||||
|
||||
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].
|
||||
|
||||
#### Selecting a logging backend implementation (applications only)
|
||||
|
||||
As the API has just launched, not many implementations exist yet. If you are interested in implementing one see the "Implementation considerations" section below explaining how to do so. List of existing SwiftLog API compatible libraries:
|
||||
|
||||
- [IBM-Swift/HeliumLogger](https://github.com/IBM-Swift/HeliumLogger) - a logging backend widely used in the Kitura ecosystem
|
||||
- [ianpartridge/swift-log-**syslog**](https://github.com/ianpartridge/swift-log-syslog) – a [syslog](https://en.wikipedia.org/wiki/Syslog) backend
|
||||
- [Adorkable/swift-log-**format-and-pipe**](https://github.com/Adorkable/swift-log-format-and-pipe) – a backend that allows customization of the output format and the resulting destination
|
||||
- [chrisaljoudi/swift-log-**oslog**](https://github.com/chrisaljoudi/swift-log-oslog) - an OSLog [Unified Logging](https://developer.apple.com/documentation/os/logging) backend for use on Apple platforms
|
||||
- [Brainfinance/StackdriverLogging](https://github.com/Brainfinance/StackdriverLogging) - a structured JSON logging backend for use on Google Cloud Platform with the [Stackdriver logging agent](https://cloud.google.com/logging/docs/agent)
|
||||
- [vapor/console-kit](https://github.com/vapor/console-kit/) - print log messages to a terminal with stylized ([ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code)) output
|
||||
- Your library? [Get in touch!](https://forums.swift.org/c/server)
|
||||
|
||||
## 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
|
||||
Please refer to the documentation on the [master branch](https://github.com/apple/swift-log/blob/master/README.md).
|
||||
@@ -27,9 +27,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
import Darwin
|
||||
#else
|
||||
import Glibc
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
/// A threading lock based on `libpthread` instead of `libdispatch`.
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -32,7 +32,7 @@
|
||||
///
|
||||
/// ```swift
|
||||
/// LoggingSystem.bootstrap(MyLogHandler.init) // your LogHandler might have a different bootstrapping step
|
||||
/// var logger1 = Logger(label: "first logger")
|
||||
/// var logger1: Logger(label: "first logger")
|
||||
/// logger1.logLevel = .debug
|
||||
/// logger1[metadataKey: "only-on"] = "first"
|
||||
///
|
||||
|
||||
+260
-171
@@ -13,9 +13,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
import Darwin
|
||||
#else
|
||||
import Glibc
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
/// A `Logger` is the central type in `SwiftLog`. Its central function is to emit log messages using one of the methods
|
||||
@@ -26,10 +26,7 @@ import Glibc
|
||||
/// 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) {
|
||||
@@ -49,12 +46,11 @@ 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
public func log(level: Logger.Level,
|
||||
_ message: @autoclosure () -> Logger.Message,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
@@ -67,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]
|
||||
@@ -87,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
|
||||
@@ -99,151 +104,291 @@ extension Logger {
|
||||
}
|
||||
|
||||
extension Logger {
|
||||
/// Log a message passing with the `Logger.Level.trace` log level.
|
||||
/// Log a message passing with the `Logger.trace` log level.
|
||||
///
|
||||
/// If `.trace` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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)
|
||||
}
|
||||
|
||||
/// Log a message passing with the `Logger.Level.debug` log level.
|
||||
#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,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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,
|
||||
/// otherwise nothing will happen.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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.
|
||||
///
|
||||
/// - parameters:
|
||||
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
|
||||
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
|
||||
/// - metadata: One-off metadata to attach to this log message
|
||||
/// - 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 `#function`).
|
||||
/// 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
|
||||
/// defaults to `#line`.
|
||||
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
|
||||
@@ -251,7 +396,7 @@ extension Logger {
|
||||
/// implementation.
|
||||
public enum LoggingSystem {
|
||||
fileprivate static let lock = ReadWriteLock()
|
||||
fileprivate static var factory: (String) -> LogHandler = StreamLogHandler.standardOutput
|
||||
fileprivate static var factory: (String) -> LogHandler = StdoutLogHandler.init
|
||||
fileprivate static var initialized = false
|
||||
|
||||
/// `bootstrap` is a one-time configuration function which globally selects the desired logging backend
|
||||
@@ -261,7 +406,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) {
|
||||
self.lock.withWriterLock {
|
||||
lock.withWriterLock {
|
||||
precondition(!self.initialized, "logging system can only be initialized once per process.")
|
||||
self.factory = factory
|
||||
self.initialized = true
|
||||
@@ -281,46 +426,25 @@ extension Logger {
|
||||
public typealias Metadata = [String: MetadataValue]
|
||||
|
||||
/// A logging metadata value. `Logger.MetadataValue` is string, array, and dictionary literal convertible.
|
||||
///
|
||||
/// `MetadataValue` provides convenient conformances to `ExpressibleByStringInterpolation`,
|
||||
/// `ExpressibleByStringLiteral`, `ExpressibleByArrayLiteral`, and `ExpressibleByDictionaryLiteral` which means
|
||||
/// that when constructing `MetadataValue`s you should default to using Swift's usual literals.
|
||||
///
|
||||
/// Examples:
|
||||
/// - prefer `logger.info("user logged in", metadata: ["user-id": "\(user.id)"])` over
|
||||
/// `..., metadata: ["user-id": .string(user.id.description)])`
|
||||
/// - prefer `logger.info("user selected colours", metadata: ["colors": ["\(user.topColor)", "\(user.secondColor)"]])`
|
||||
/// over `..., metadata: ["colors": .array([.string("\(user.topColor)"), .string("\(user.secondColor)")])`
|
||||
/// - prefer `logger.info("nested info", metadata: ["nested": ["fave-numbers": ["\(1)", "\(2)", "\(3)"], "foo": "bar"]])`
|
||||
/// over `..., metadata: ["nested": .dictionary(["fave-numbers": ...])])`
|
||||
public enum MetadataValue {
|
||||
/// A metadata value which is a `String`.
|
||||
///
|
||||
/// Because `MetadataValue` implements `ExpressibleByStringInterpolation`, and `ExpressibleByStringLiteral`,
|
||||
/// you don't need to type `.string(someType.description)` you can use the string interpolation `"\(someType)"`.
|
||||
case string(String)
|
||||
|
||||
/// A metadata value which is some `CustomStringConvertible`.
|
||||
case stringConvertible(CustomStringConvertible)
|
||||
|
||||
/// A metadata value which is a dictionary from `String` to `Logger.MetadataValue`.
|
||||
///
|
||||
/// Because `MetadataValue` implements `ExpressibleByDictionaryLiteral`, you don't need to type
|
||||
/// `.dictionary(["foo": .string("bar \(buz)")])`, you can just use the more natural `["foo": "bar \(buz)"]`.
|
||||
case dictionary(Metadata)
|
||||
|
||||
/// A metadata value which is an array of `Logger.MetadataValue`s.
|
||||
///
|
||||
/// Because `MetadataValue` implements `ExpressibleByArrayLiteral`, you don't need to type
|
||||
/// `.array([.string("foo"), .string("bar \(buz)")])`, you can just use the more natural `["foo", "bar \(buz)"]`.
|
||||
case array([Metadata.Value])
|
||||
}
|
||||
|
||||
/// The log level.
|
||||
///
|
||||
/// Log levels are ordered by their severity, with `.trace` being the least severe and
|
||||
/// `.critical` being the most severe.
|
||||
public enum Level: String, Codable, CaseIterable {
|
||||
/// 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 {
|
||||
/// Appropriate for messages that contain information only when debugging a program.
|
||||
case trace
|
||||
|
||||
@@ -342,7 +466,7 @@ extension Logger {
|
||||
/// Appropriate for error conditions.
|
||||
case error
|
||||
|
||||
/// Appropriate for critical error conditions that usually require immediate
|
||||
/// Appropriate for criticial error conditions that usually require immediate
|
||||
/// attention.
|
||||
///
|
||||
/// When a `critical` message is logged, the logging backend (`LogHandler`) is free to perform
|
||||
@@ -438,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
|
||||
@@ -456,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
|
||||
@@ -464,13 +613,8 @@ extension Logger {
|
||||
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.isEmpty)
|
||||
assert(handlers.count > 0)
|
||||
self.handlers = handlers
|
||||
}
|
||||
|
||||
@@ -519,87 +663,30 @@ public struct MultiplexLogHandler: LogHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/// 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>
|
||||
internal let flushMode: FlushMode
|
||||
/// Ships with the logging module, really boring just prints something using the `print` function
|
||||
internal struct StdoutLogHandler: LogHandler {
|
||||
private let lock = Lock()
|
||||
|
||||
internal func write(_ string: String) {
|
||||
string.withCString { ptr in
|
||||
flockfile(self.file)
|
||||
defer {
|
||||
funlockfile(self.file)
|
||||
}
|
||||
_ = fputs(ptr, self.file)
|
||||
if case .always = self.flushMode {
|
||||
self.flush()
|
||||
}
|
||||
}
|
||||
}
|
||||
public init(label: String) {}
|
||||
|
||||
/// Flush the underlying stream.
|
||||
/// This has no effect when using the `.always` flush mode, which is the default
|
||||
internal func flush() {
|
||||
_ = fflush(self.file)
|
||||
}
|
||||
private var _logLevel: Logger.Level = .info
|
||||
|
||||
internal static let stderr = StdioOutputStream(file: systemStderr, flushMode: .always)
|
||||
internal static let stdout = StdioOutputStream(file: systemStdout, flushMode: .always)
|
||||
|
||||
/// Defines the flushing strategy for the underlying stream.
|
||||
internal enum FlushMode {
|
||||
case undefined
|
||||
case always
|
||||
}
|
||||
}
|
||||
|
||||
// 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?
|
||||
public var metadata = Logger.Metadata() {
|
||||
didSet {
|
||||
self.prettyMetadata = self.prettify(self.metadata)
|
||||
}
|
||||
}
|
||||
|
||||
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
public var logLevel: Logger.Level {
|
||||
get {
|
||||
return self.metadata[metadataKey]
|
||||
return self.lock.withLock { self._logLevel }
|
||||
}
|
||||
set {
|
||||
self.metadata[metadataKey] = newValue
|
||||
self.lock.withLock {
|
||||
self._logLevel = newValue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// internal for testing only
|
||||
internal init(label: String, stream: TextOutputStream) {
|
||||
self.stream = stream
|
||||
private var prettyMetadata: String?
|
||||
private var _metadata = Logger.Metadata() {
|
||||
didSet {
|
||||
self.prettyMetadata = self.prettify(self._metadata)
|
||||
}
|
||||
}
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
@@ -609,9 +696,27 @@ public struct StreamLogHandler: 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)")
|
||||
}
|
||||
|
||||
var stream = self.stream
|
||||
stream.write("\(self.timestamp()) \(level):\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
|
||||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func prettify(_ metadata: Logger.Metadata) -> String? {
|
||||
@@ -624,25 +729,13 @@ public struct StreamLogHandler: 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-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 {
|
||||
@@ -660,10 +753,6 @@ extension Logger.MetadataValue: CustomStringConvertible {
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
extension Logger.MetadataValue: ExpressibleByStringInterpolation {}
|
||||
|
||||
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
|
||||
// https://bugs.swift.org/browse/SR-9686
|
||||
extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
|
||||
public typealias Key = String
|
||||
public typealias Value = Logger.Metadata.Value
|
||||
@@ -674,7 +763,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-9686
|
||||
// https://bugs.swift.org/browse/SR-9687
|
||||
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,11 +23,13 @@ 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,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,12 +145,12 @@ 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()
|
||||
let loggingMetadata = MDC.global.metadata
|
||||
self.queue.async {
|
||||
queue.async {
|
||||
MDC.global.with(metadata: loggingMetadata) {
|
||||
self.logger.warning("Struct3::doSomethingElseAsync")
|
||||
let library = TestLibrary()
|
||||
@@ -160,9 +163,9 @@ private struct Struct3 {
|
||||
group.wait()
|
||||
MDC.global["foo"] = nil
|
||||
// only effects the logger instance
|
||||
var l = self.logger
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
var l = logger
|
||||
l[metadataKey: "baz"] = .string("qux")
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
self.logger.debug("Struct3::doSomethingElse::end")
|
||||
logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
}
|
||||
@@ -23,10 +23,12 @@ 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,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
|
||||
@@ -111,7 +114,7 @@ private struct Struct2 {
|
||||
var c = context
|
||||
c.logLevel = .info // only effects from this point on
|
||||
c.logger.info("Struct2::doSomething")
|
||||
self.doSomethingElse(context: c)
|
||||
doSomethingElse(context: c)
|
||||
c.logger.debug("Struct2::doSomething::end")
|
||||
}
|
||||
|
||||
@@ -129,9 +132,9 @@ 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")
|
||||
self.doSomethingElse(context: c)
|
||||
doSomethingElse(context: c)
|
||||
c.logger.debug("Struct3::doSomething::end")
|
||||
}
|
||||
|
||||
@@ -139,7 +142,7 @@ private struct Struct3 {
|
||||
context.logger.error("Struct3::doSomethingElse")
|
||||
let group = DispatchGroup()
|
||||
group.enter()
|
||||
self.queue.async {
|
||||
queue.async {
|
||||
context.logger.warning("Struct3::doSomethingElseAsync")
|
||||
let library = TestLibrary()
|
||||
library.doSomething()
|
||||
@@ -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")
|
||||
}
|
||||
|
||||
@@ -23,26 +23,22 @@ import XCTest
|
||||
///
|
||||
|
||||
extension LoggingTest {
|
||||
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),
|
||||
("testStdioOutputStreamFlush", testStdioOutputStreamFlush),
|
||||
]
|
||||
}
|
||||
|
||||
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),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -14,12 +14,6 @@
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
#else
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
class LoggingTest: XCTestCase {
|
||||
func testAutoclosure() throws {
|
||||
// bootstrap with our test logging impl
|
||||
@@ -28,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"
|
||||
@@ -40,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"
|
||||
}())
|
||||
@@ -61,12 +77,12 @@ class LoggingTest: XCTestCase {
|
||||
// bootstrap with our test logging impl
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
LoggingSystem.bootstrapInternal { MultiplexLogHandler([logging1.make(label: $0), logging2.make(label: $0)]) }
|
||||
LoggingSystem.bootstrapInternal({ MultiplexLogHandler([logging1.make(label: $0), logging2.make(label: $0)]) })
|
||||
|
||||
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?")
|
||||
@@ -78,43 +94,11 @@ 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?
|
||||
private var _value: String? = nil
|
||||
|
||||
public init(_ makeValue: @escaping () -> String) {
|
||||
self.makeValue = makeValue
|
||||
@@ -137,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()
|
||||
@@ -177,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"])
|
||||
@@ -267,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)
|
||||
@@ -290,25 +273,25 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
|
||||
func testMultiplexerIsValue() {
|
||||
let multi = MultiplexLogHandler([StreamLogHandler.standardOutput(label: "x"), StreamLogHandler.standardOutput(label: "y")])
|
||||
let multi = MultiplexLogHandler([StdoutLogHandler(label: "x"), StdoutLogHandler(label: "y")])
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
print("new multi")
|
||||
return multi
|
||||
}
|
||||
let logger1: Logger = {
|
||||
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")
|
||||
}
|
||||
|
||||
@@ -316,7 +299,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?
|
||||
private static var overrideLogLevel: Logger.Level? = nil
|
||||
|
||||
private let recorder: Recorder
|
||||
// this holds the log level if not overridden
|
||||
@@ -333,7 +316,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 {
|
||||
LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
} ?? self._logLevel
|
||||
}
|
||||
// we set the log level whenever we're asked (note: this might not have an effect if globally
|
||||
@@ -367,19 +350,19 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
let logRecorder = Recorder()
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
|
||||
return LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
|
||||
}
|
||||
|
||||
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")
|
||||
@@ -394,12 +377,7 @@ class LoggingTest: XCTestCase {
|
||||
logRecorder.assertExist(level: .notice, message: "logger1, after")
|
||||
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)
|
||||
@@ -423,93 +401,4 @@ 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
|
||||
self.strings.append(string)
|
||||
self.interceptedText = (self.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)
|
||||
}
|
||||
|
||||
func testStdioOutputStreamFlush() {
|
||||
// flush on every statement
|
||||
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
|
||||
let logStream = StdioOutputStream(file: writeFD, flushMode: .always)
|
||||
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
|
||||
Logger(label: "test").critical("test")
|
||||
|
||||
let size = read(readFD, readBuffer, 256)
|
||||
XCTAssertGreaterThan(size, -1, "expected flush")
|
||||
|
||||
logStream.flush()
|
||||
let size2 = read(readFD, readBuffer, 256)
|
||||
XCTAssertEqual(size2, -1, "expected no flush")
|
||||
}
|
||||
// default flushing
|
||||
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
|
||||
let logStream = StdioOutputStream(file: writeFD, flushMode: .undefined)
|
||||
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
|
||||
Logger(label: "test").critical("test")
|
||||
|
||||
let size = read(readFD, readBuffer, 256)
|
||||
XCTAssertEqual(size, -1, "expected no flush")
|
||||
|
||||
logStream.flush()
|
||||
let size2 = read(readFD, readBuffer, 256)
|
||||
XCTAssertGreaterThan(size2, -1, "expected flush")
|
||||
}
|
||||
}
|
||||
|
||||
func withWriteReadFDsAndReadBuffer(_ body: (UnsafeMutablePointer<FILE>, CInt, UnsafeMutablePointer<Int8>) -> Void) {
|
||||
var fds: [Int32] = [-1, -1]
|
||||
fds.withUnsafeMutableBufferPointer { ptr in
|
||||
let err = pipe(ptr.baseAddress!)
|
||||
XCTAssertEqual(err, 0, "pipe faild \(err)")
|
||||
}
|
||||
|
||||
let writeFD = fdopen(fds[1], "w")
|
||||
let writeBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: 256)
|
||||
defer {
|
||||
writeBuffer.deinitialize(count: 256)
|
||||
writeBuffer.deallocate()
|
||||
}
|
||||
|
||||
var err = setvbuf(writeFD, writeBuffer, _IOFBF, 256)
|
||||
XCTAssertEqual(err, 0, "setvbuf faild \(err)")
|
||||
|
||||
let readFD = fds[0]
|
||||
err = fcntl(readFD, F_SETFL, fcntl(readFD, F_GETFL) | O_NONBLOCK)
|
||||
XCTAssertEqual(err, 0, "fcntl faild \(err)")
|
||||
|
||||
let readBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: 256)
|
||||
defer {
|
||||
readBuffer.deinitialize(count: 256)
|
||||
readBuffer.deallocate()
|
||||
}
|
||||
|
||||
// the actual test
|
||||
body(writeFD!, readFD, readBuffer)
|
||||
|
||||
fds.forEach { close($0) }
|
||||
}
|
||||
}
|
||||
@@ -23,9 +23,11 @@ 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"] = "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
|
||||
@@ -39,13 +42,13 @@ internal struct TestLogHandler: LogHandler {
|
||||
self.label = label
|
||||
self.config = config
|
||||
self.recorder = recorder
|
||||
self.logger = Logger(label: "test", StreamLogHandler.standardOutput(label: label))
|
||||
self.logger = Logger(label: "test", StdoutLogHandler(label: label))
|
||||
self.logger.logLevel = .debug
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
let metadata = (self._metadataSet ? self.metadata : MDC.global.metadata).merging(metadata ?? [:], uniquingKeysWith: { _, new in new })
|
||||
self.logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
|
||||
logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
|
||||
self.recorder.record(level: level, metadata: metadata, message: message)
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -208,7 +213,7 @@ public class MDC {
|
||||
}
|
||||
set {
|
||||
self.lock.withLock {
|
||||
if self.storage[self.threadId] == nil {
|
||||
if nil == self.storage[self.threadId] {
|
||||
self.storage[self.threadId] = Logger.Metadata()
|
||||
}
|
||||
self.storage[self.threadId]![metadataKey] = newValue
|
||||
@@ -252,11 +257,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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -284,7 +289,7 @@ internal struct TestLibrary {
|
||||
// libraries that use global loggers and async, need to make sure they propagate the
|
||||
// logging metadata when creating a new thread
|
||||
let metadata = MDC.global.metadata
|
||||
self.queue.asyncAfter(deadline: .now() + 0.1) {
|
||||
queue.asyncAfter(deadline: .now() + 0.1) {
|
||||
MDC.global.with(metadata: metadata) {
|
||||
self.logger.info("TestLibrary::doSomethingAsync")
|
||||
completion()
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
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.
|
||||
+45
-24
@@ -1,35 +1,56 @@
|
||||
ARG swift_version=5.0
|
||||
ARG ubuntu_version=bionic
|
||||
FROM swift:$swift_version-$ubuntu_version
|
||||
ARG ubuntu_version=18.04
|
||||
FROM ubuntu:$ubuntu_version
|
||||
# needed to do again after FROM due to docker limitation
|
||||
ARG swift_version
|
||||
ARG ubuntu_version
|
||||
|
||||
# set as UTF-8
|
||||
RUN apt-get update && apt-get install -y locales locales-all
|
||||
ENV LC_ALL en_US.UTF-8
|
||||
ENV LANG en_US.UTF-8
|
||||
ENV LANGUAGE en_US.UTF-8
|
||||
ARG DEBIAN_FRONTEND=noninteractive
|
||||
# do not start services during installation as this will fail and log a warning / error.
|
||||
RUN echo "#!/bin/sh\nexit 0" > /usr/sbin/policy-rc.d
|
||||
|
||||
# dependencies
|
||||
RUN apt-get update && apt-get install -y wget
|
||||
RUN apt-get update && apt-get install -y lsof dnsutils netcat-openbsd net-tools # used by integration tests
|
||||
# basic dependencies
|
||||
RUN apt-get update && apt-get install -y wget git build-essential software-properties-common pkg-config locales
|
||||
RUN apt-get update && apt-get install -y libicu-dev libblocksruntime0 curl libcurl4-openssl-dev libz-dev
|
||||
|
||||
# local
|
||||
RUN locale-gen en_US.UTF-8
|
||||
RUN locale-gen en_US en_US.UTF-8
|
||||
RUN dpkg-reconfigure locales
|
||||
RUN echo 'export LANG=en_US.UTF-8' >> $HOME/.profile
|
||||
RUN echo 'export LANGUAGE=en_US:en' >> $HOME/.profile
|
||||
RUN echo 'export LC_ALL=en_US.UTF-8' >> $HOME/.profile
|
||||
|
||||
# known_hosts
|
||||
RUN mkdir -p $HOME/.ssh
|
||||
RUN touch $HOME/.ssh/known_hosts
|
||||
RUN ssh-keyscan github.com 2> /dev/null >> $HOME/.ssh/known_hosts
|
||||
|
||||
# clang
|
||||
RUN apt-get update && apt-get install -y clang-3.9
|
||||
RUN update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.9 100
|
||||
RUN update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.9 100
|
||||
|
||||
# ruby and jazzy for docs generation
|
||||
#ARG skip_ruby_from_ppa
|
||||
#RUN [ -n "$skip_ruby_from_ppa" ] || apt-add-repository -y ppa:brightbox/ruby-ng
|
||||
#RUN [ -n "$skip_ruby_from_ppa" ] || { apt-get update && apt-get install -y ruby2.4 ruby2.4-dev; }
|
||||
#RUN [ -z "$skip_ruby_from_ppa" ] || { apt-get update && apt-get install -y ruby ruby-dev; }
|
||||
#RUN apt-get update && apt-get install -y libsqlite3-dev
|
||||
RUN apt-get update && apt-get install -y ruby ruby-dev libsqlite3-dev
|
||||
RUN gem install jazzy --no-ri --no-rdoc
|
||||
|
||||
# tools
|
||||
RUN mkdir -p $HOME/.tools
|
||||
RUN echo 'export PATH="$HOME/.tools:$PATH"' >> $HOME/.profile
|
||||
# swift
|
||||
ARG swift_version=4.2.3
|
||||
ARG swift_flavour=RELEASE
|
||||
ARG swift_builds_suffix=release
|
||||
|
||||
# script to allow mapping framepointers on linux (until part of the toolchain)
|
||||
RUN wget -q https://raw.githubusercontent.com/apple/swift/master/utils/symbolicate-linux-fatal -O $HOME/.tools/symbolicate-linux-fatal
|
||||
RUN chmod 755 $HOME/.tools/symbolicate-linux-fatal
|
||||
RUN mkdir $HOME/.swift
|
||||
RUN wget -q "https://swift.org/builds/swift-${swift_version}-${swift_builds_suffix}/ubuntu$(echo $ubuntu_version | sed 's/\.//g')/swift-${swift_version}-${swift_flavour}/swift-${swift_version}-${swift_flavour}-ubuntu${ubuntu_version}.tar.gz" -O $HOME/swift.tar.gz
|
||||
RUN tar xzf $HOME/swift.tar.gz --directory $HOME/.swift --strip-components=1
|
||||
RUN echo 'export PATH="$HOME/.swift/usr/bin:$PATH"' >> $HOME/.profile
|
||||
RUN echo 'export LINUX_SOURCEKIT_LIB_PATH="$HOME/.swift/usr/lib"' >> $HOME/.profile
|
||||
|
||||
# swiftformat (until part of the toolchain)
|
||||
|
||||
ARG swiftformat_version=0.40.12
|
||||
RUN git clone --branch $swiftformat_version --depth 1 https://github.com/nicklockwood/SwiftFormat $HOME/.tools/swift-format
|
||||
RUN cd $HOME/.tools/swift-format && swift build -c release
|
||||
RUN ln -s $HOME/.tools/swift-format/.build/release/swiftformat $HOME/.tools/swiftformat
|
||||
# script to allow mapping framepointers on linux
|
||||
RUN mkdir -p $HOME/.scripts
|
||||
RUN wget -q https://raw.githubusercontent.com/apple/swift/master/utils/symbolicate-linux-fatal -O $HOME/.scripts/symbolicate-linux-fatal
|
||||
RUN chmod 755 $HOME/.scripts/symbolicate-linux-fatal
|
||||
RUN echo 'export PATH="$HOME/.scripts:$PATH"' >> $HOME/.profile
|
||||
@@ -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
|
||||
@@ -6,8 +6,10 @@ services:
|
||||
image: swift-log:18.04-5.0
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "bionic"
|
||||
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
|
||||
@@ -1,13 +0,0 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:18.04-5.1
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "bionic"
|
||||
swift_version: "5.1"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.1
|
||||
@@ -1,94 +0,0 @@
|
||||
#!/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,7 +57,6 @@ 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"
|
||||
file.write ' static var allTests: [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
|
||||
file.write " return [\n"
|
||||
file.write 'extension ' + classArray[0] + " {\n\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"
|
||||
file.write " ]\n"
|
||||
file.write " }\n"
|
||||
file.write "}\n\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,9 +109,9 @@ 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 " ])\n"
|
||||
file.write "#endif\n"
|
||||
end
|
||||
end
|
||||
|
||||
+6
-38
@@ -13,28 +13,9 @@
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## 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
|
||||
@@ -47,23 +28,10 @@ else
|
||||
printf "\033[0;32mokay.\033[0m\n"
|
||||
fi
|
||||
|
||||
printf "=> Checking format... "
|
||||
FIRST_OUT="$(git status --porcelain)"
|
||||
swiftformat . > /dev/null 2>&1
|
||||
SECOND_OUT="$(git status --porcelain)"
|
||||
if [[ "$FIRST_OUT" != "$SECOND_OUT" ]]; then
|
||||
printf "\033[0;31mformatting issues!\033[0m\n"
|
||||
git --no-pager diff
|
||||
exit 1
|
||||
else
|
||||
printf "\033[0;32mokay.\033[0m\n"
|
||||
fi
|
||||
|
||||
printf "=> Checking license headers\n"
|
||||
printf "=> Checking license headers... "
|
||||
tmp=$(mktemp /tmp/.swift-log-sanity_XXXXXX)
|
||||
|
||||
for language in swift-or-c bash dtrace; do
|
||||
printf " * $language... "
|
||||
declare -a matching_files
|
||||
declare -a exceptions
|
||||
expections=( )
|
||||
@@ -77,7 +45,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) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
@@ -96,7 +64,7 @@ EOF
|
||||
##
|
||||
## This source file is part of the Swift Logging API open source project
|
||||
##
|
||||
## Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
## Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
@@ -115,7 +83,7 @@ EOF
|
||||
*
|
||||
* This source file is part of the Swift Logging API open source project
|
||||
*
|
||||
* Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
* Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
* Licensed under Apache License v2.0
|
||||
*
|
||||
* See LICENSE.txt for license information
|
||||
@@ -140,9 +108,9 @@ EOF
|
||||
\( \! -path './.build/*' -a \
|
||||
\( "${matching_files[@]}" \) -a \
|
||||
\( \! \( "${exceptions[@]}" \) \) \) | while read line; do
|
||||
if [[ "$(cat "$line" | replace_acceptable_years | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
if [[ "$(cat "$line" | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
printf "\033[0;31mmissing headers in file '$line'!\033[0m\n"
|
||||
diff -u <(cat "$line" | replace_acceptable_years | head -n $expected_lines) "$tmp"
|
||||
diff -u <(cat "$line" | head -n $expected_lines) "$tmp"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
|
||||
Reference in new issue
Block a user