mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3e3ef75109 | ||
|
|
bd4519f1c2 | ||
|
|
e6ca651cbc | ||
|
|
dc77805fdc | ||
|
|
e979c6945c | ||
|
|
d86803715f | ||
|
|
f7b7977065 | ||
|
|
ce09fe6dac | ||
|
|
a8e1148aa5 | ||
|
|
483e2bbcdd | ||
|
|
d5bf59c6b2 | ||
|
|
6fe203dc33 | ||
|
|
6b0ccb1ca8 | ||
|
|
8fc79cae9d | ||
|
|
f2e8667d50 | ||
|
|
9f3731aa55 | ||
|
|
2bf6215b68 | ||
|
|
432a93204e | ||
|
|
dc6dd5caaa | ||
|
|
5db2bc495a | ||
|
|
4e75f88c6a | ||
|
|
77192b9e21 | ||
|
|
b172d1ae3d | ||
|
|
a7e6d7fef5 | ||
|
|
9cdea8c2af | ||
|
|
d8af258aec | ||
|
|
02770d91fc | ||
|
|
7ebe44cb03 | ||
|
|
65a8e5e921 | ||
|
|
08ec50d7b1 | ||
|
|
3577a992d3 | ||
|
|
b1d1c0372a | ||
|
|
bc049d05d0 | ||
|
|
bda2661797 | ||
|
|
5d66f7ba25 | ||
|
|
c7988420c2 | ||
|
|
7d1d4e29ea | ||
|
|
12d3a8651d | ||
|
|
b5440510b6 | ||
|
|
c6437b76d8 | ||
|
|
16cfcc60e4 | ||
|
|
974b90e008 | ||
|
|
cb77380f88 | ||
|
|
7bc87ea4ca | ||
|
|
04b23c1c17 | ||
|
|
5fa4a664a0 | ||
|
|
6a1fd374f8 | ||
|
|
4a0205445c | ||
|
|
b8eedd521d | ||
|
|
5a1b9cfc71 | ||
|
|
1d40828ecc | ||
|
|
a4aa2d5bd9 | ||
|
|
de30f5bfc2 | ||
|
|
dc3970db38 | ||
|
|
a885be7bff | ||
|
|
173f567a2d | ||
|
|
57c6bd0425 | ||
|
|
024f44d4d5 | ||
|
|
c37c434930 | ||
|
|
0c61f3610d | ||
|
|
237094d249 | ||
|
|
2caaa7fc10 | ||
|
|
afc50b29de | ||
|
|
ee8b3c5044 | ||
|
|
6d233ae476 | ||
|
|
a9784b00a6 | ||
|
|
4f87671873 | ||
|
|
87c2553da2 | ||
|
|
c08d7f72b9 | ||
|
|
da2c8aa854 | ||
|
|
fa15ddefc4 | ||
|
|
8ede07bf98 | ||
|
|
0e21dd7893 | ||
|
|
4d7ef13e01 | ||
|
|
4aad45c1c1 | ||
|
|
1b5f8a5034 | ||
|
|
01ce2959de | ||
|
|
57d2a6d872 | ||
|
|
7b01660491 | ||
|
|
27da3424c7 | ||
|
|
3a9a783347 | ||
|
|
b321ca1807 | ||
|
|
068014614c | ||
|
|
012cff81f6 | ||
|
|
f0f77b00c4 | ||
|
|
74d7b91cee | ||
|
|
77b2e836f1 | ||
|
|
1111d309a5 | ||
|
|
e5a4bd1003 | ||
|
|
fd6c6b338d | ||
|
|
6669bdf615 | ||
|
|
6171b4483e | ||
|
|
2b7d68a486 | ||
|
|
e8aabbe95d | ||
|
|
e309184b89 | ||
|
|
ebdfdcf0ff | ||
|
|
263735081c | ||
|
|
99786c85ac | ||
|
|
b33865f66b | ||
|
|
9fc3834d3f | ||
|
|
df4d2c80df | ||
|
|
f4240bf022 | ||
|
|
ea3eea9dcb | ||
|
|
67b2425b4c | ||
|
|
dbb9d24d8d | ||
|
|
3e8f2138a1 | ||
|
|
a26395d403 | ||
|
|
0c403de592 | ||
|
|
9ac2ad4064 | ||
|
|
75c08c0611 | ||
|
|
cfd8740667 | ||
|
|
250cef01ad | ||
|
|
33ceed2816 | ||
|
|
6397eee678 | ||
|
|
4fe877816a | ||
|
|
851eacf76e | ||
|
|
856a83e9f4 | ||
|
|
e37f28a5ff |
No files matched your search
@@ -0,0 +1,20 @@
|
||||
### Expected behavior
|
||||
_[what you expected to happen]_
|
||||
|
||||
### Actual behavior
|
||||
_[what actually happened]_
|
||||
|
||||
### Steps to reproduce
|
||||
|
||||
1. ...
|
||||
2. ...
|
||||
|
||||
### If possible, minimal yet complete reproducer code (or URL to code)
|
||||
|
||||
_[anything to help us reproducing the issue]_
|
||||
|
||||
### SwiftLog version/commit hash
|
||||
|
||||
_[the SwiftLog tag/commit hash]_
|
||||
|
||||
### Swift & OS version (output of `swift --version && uname -a`)
|
||||
@@ -0,0 +1,13 @@
|
||||
_[One line description of your change]_
|
||||
|
||||
### Motivation:
|
||||
|
||||
_[Explain here the context, and why you're making that change. What is the problem you're trying to solve.]_
|
||||
|
||||
### Modifications:
|
||||
|
||||
_[Describe the modifications you've done.]_
|
||||
|
||||
### Result:
|
||||
|
||||
_[After your change, what will change.]_
|
||||
@@ -1,9 +1,13 @@
|
||||
.DS_Store
|
||||
Package.resolved
|
||||
/.build
|
||||
/Packages
|
||||
/*.xcodeproj
|
||||
.xcode
|
||||
DerivedData
|
||||
.swiftpm
|
||||
|
||||
.SourceKitten/
|
||||
docs/
|
||||
|
||||
.*.sw?
|
||||
@@ -0,0 +1,4 @@
|
||||
version: 1
|
||||
builder:
|
||||
configs:
|
||||
- documentation_targets: [Logging]
|
||||
@@ -0,0 +1,15 @@
|
||||
# file options
|
||||
|
||||
--swiftversion 5.0
|
||||
--exclude .build
|
||||
|
||||
# format options
|
||||
|
||||
--self insert
|
||||
--patternlet inline
|
||||
--stripunusedargs unnamed-only
|
||||
--ifdef no-indent
|
||||
|
||||
# rules
|
||||
|
||||
--disable redundantParens # https://github.com/nicklockwood/SwiftFormat/issues/638
|
||||
+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-log-conduct@group.apple.com).
|
||||
A working group of community members is committed to promptly addressing any [reported issues](mailto:swift-server-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.
|
||||
@@ -0,0 +1,96 @@
|
||||
## 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.
|
||||
|
||||
### Run `./scripts/soundness.sh`
|
||||
|
||||
The scripts directory contains a [soundness.sh script](https://github.com/apple/swift-log/blob/main/scripts/soundness.sh)
|
||||
that enforces additional checks, like license headers and formatting style.
|
||||
|
||||
Please make sure to `./scripts/soundness.sh` before pushing a change upstream, otherwise it is likely the PR validation will fail
|
||||
on minor changes such as a missing `self.` or similar formatting issues.
|
||||
|
||||
> The script also executes the above mentioned `generate_linux_tests.rb`.
|
||||
|
||||
For frequent contributors, we recommend adding the script as a [git pre-push hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), which you can do via executing the following command in the project root directory:
|
||||
|
||||
```bash
|
||||
cat << EOF > .git/hooks/pre-push
|
||||
#!/bin/bash
|
||||
|
||||
if [[ -f "scripts/soundness.sh" ]]; then
|
||||
scripts/soundness.sh
|
||||
fi
|
||||
EOF
|
||||
```
|
||||
|
||||
Which makes the script execute, and only allow the `git push` to complete if the check has passed.
|
||||
|
||||
In the case of formatting issues, you can then `git add` the formatting changes, and attempt the push again.
|
||||
|
||||
## How to contribute your work
|
||||
|
||||
Please open a pull request at https://github.com/apple/swift-log. Make sure the CI passes, and then wait for code review.
|
||||
+2
-1
@@ -35,7 +35,8 @@ This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
|
||||
|
||||
---
|
||||
|
||||
This product contains a derivation of SwiftNIO locks.
|
||||
This product contains a derivation of the lock implementation and various
|
||||
scripts from SwiftNIO.
|
||||
|
||||
* LICENSE (Apache License 2.0):
|
||||
* https://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
+4
-1
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:5.0
|
||||
// swift-tools-version:5.6
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
@@ -20,6 +20,9 @@ let package = Package(
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.0
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.1
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.2
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.3
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.4
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
// swift-tools-version:5.5
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "swift-log",
|
||||
products: [
|
||||
.library(name: "Logging", targets: ["Logging"]),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "Logging",
|
||||
dependencies: []
|
||||
),
|
||||
.testTarget(
|
||||
name: "LoggingTests",
|
||||
dependencies: ["Logging"]
|
||||
),
|
||||
]
|
||||
)
|
||||
@@ -1,18 +1,16 @@
|
||||
# SwiftLog
|
||||
|
||||
A Logging API package for Swift. Version `1.0.0` requires Swift 5.0 but in due course we will also tag a mostly compatible version for Swift 4 (which will be tagged `0.x`) to ease your transition towards Swift 5.
|
||||
|
||||
First things first: This is the beginning of a community-driven open-source project actively seeking contributions, be it code, documentation, or ideas. Apart from contributing to `SwiftLog` itself, there's another huge gap at the moment: `SwiftLog` is an _API package_ which tries to establish a common API the ecosystem can use. To make logging really work for real-world workloads, we need `SwiftLog`-compatible _logging backends_ which then either persist the log messages in files, render them in nicer colors on the terminal, or send them over to Splunk or ELK.
|
||||
|
||||
What `SwiftLog` provides today can be found in the [API docs][api-docs].
|
||||
|
||||
## Great, what's the tl;dr
|
||||
## 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`:
|
||||
`SwiftLog` is designed for Swift 5. To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
|
||||
@@ -21,9 +19,16 @@ If you have a server-side Swift application, or maybe a cross-platform (for exam
|
||||
and to your application/library target, add `"Logging"` to your `dependencies`, e.g. like this:
|
||||
|
||||
```swift
|
||||
.target(name: "BestExampleApp", dependencies: ["Logging']),
|
||||
// Target syntax for Swift up to version 5.1
|
||||
.target(name: "BestExampleApp", dependencies: ["Logging"]),
|
||||
|
||||
// Target for Swift 5.2
|
||||
.target(name: "BestExampleApp", dependencies: [
|
||||
.product(name: "Logging", package: "swift-log")
|
||||
],
|
||||
```
|
||||
|
||||
|
||||
#### Let's log
|
||||
|
||||
```swift
|
||||
@@ -43,8 +48,45 @@ logger.info("Hello World!")
|
||||
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:
|
||||
```swift
|
||||
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].
|
||||
|
||||
<a name="backends"></a>
|
||||
#### 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:
|
||||
|
||||
| Repository | Handler Description|
|
||||
| ----------- | ----------- |
|
||||
| [Kitura/HeliumLogger](https://github.com/Kitura/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. **Important Note:** we recommend using os_log directly as decribed [here](https://developer.apple.com/documentation/os/logging). Using os_log through swift-log using this backend will be less efficient and will also prevent specifying the privacy of the message. The backend always uses `%{public}@` as the format string and eagerly converts all string interpolations to strings. This has two drawbacks: 1. the static components of the string interpolation would be eagerly copied by the unified logging system, which will result in loss of performance. 2. It makes all messages public, which changes the default privacy policy of os_log, and doesn't allow specifying fine-grained privacy of sections of the message. In a separate on-going work, Swift APIs for os_log are being improved and made to align closely with swift-log APIs. References: [Unifying Logging Levels](https://forums.swift.org/t/custom-string-interpolation-and-compile-time-interpretation-applied-to-logging/18799), [Making os_log accept string interpolations using compile-time interpretation](https://forums.swift.org/t/logging-levels-for-swifts-server-side-logging-apis-and-new-os-log-apis/20365). |
|
||||
| [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) |
|
||||
| [DnV1eX/GoogleCloudLogging](https://github.com/DnV1eX/GoogleCloudLogging) | a client-side library for logging application events in [Google Cloud](https://console.cloud.google.com/logs) via REST API v2. |
|
||||
| [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 |
|
||||
| [neallester/swift-log-testing](https://github.com/neallester/swift-log-testing) | provides access to log messages for use in assertions (within test targets) |
|
||||
| [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack) | a logging backend that sends critical log messages to Slack |
|
||||
| [NSHipster/swift-log-github-actions](https://github.com/NSHipster/swift-log-github-actions) | a logging backend that translates logging messages into [workflow commands for GitHub Actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions). |
|
||||
| [stevapple/swift-log-telegram](https://github.com/stevapple/swift-log-telegram) | a logging backend that sends log messages to any Telegram chat (Inspired by and forked from [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack)) |
|
||||
| [jagreenwood/swift-log-datadog](https://github.com/jagreenwood/swift-log-datadog) | a logging backend which sends log messages to the [Datadog](https://www.datadoghq.com/log-management/) log management service |
|
||||
| [google/SwiftLogFireCloud](https://github.com/google/swiftlogfirecloud) | a logging backend for time series logging which pushes logs as flat files to Firebase Cloud Storage. |
|
||||
| [crspybits/swift-log-file](https://github.com/crspybits/swift-log-file) | a simple local file logger (using `Foundation` `FileManager`) |
|
||||
| [sushichop/Puppy](https://github.com/sushichop/Puppy) | a logging backend that supports multiple transports(console, file, syslog, etc.) and has the feature with formatting and file log rotation |
|
||||
| [luoxiu/LogDog](https://github.com/luoxiu/LogDog) | user-friendly logging with sinks and appenders |
|
||||
| [ShivaHuang/swift-log-SwiftyBeaver](https://github.com/ShivaHuang/swift-log-SwiftyBeaver) | a logging backend for printing colored logging to Xcode console / file, or sending encrypted logging to [SwiftyBeaver](https://swiftybeaver.com) platform. |
|
||||
| [Apodini/swift-log-elk](https://github.com/Apodini/swift-log-elk) | a logging backend that formats, caches and sends log data to [elastic/logstash](https://github.com/elastic/logstash) |
|
||||
| [binaryscraping/swift-log-supabase](https://github.com/binaryscraping/swift-log-supabase) | a logging backend that sends log entries to [Supabase](https://github.com/supabase/supabase). |
|
||||
| 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.
|
||||
@@ -115,7 +157,7 @@ A `LogHandler` or logging backend implementation is anything that conforms to th
|
||||
|
||||
```swift
|
||||
public protocol LogHandler {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt)
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt)
|
||||
|
||||
subscript(metadataKey _: String) -> Logger.Metadata.Value? { get set }
|
||||
|
||||
@@ -153,6 +195,20 @@ However, in special cases, it is acceptable that a `LogHandler` provides some gl
|
||||
|
||||
`LogHandler`s do not control if a message should be logged or not. `Logger` will only invoke the `log` function of a `LogHandler` if `Logger` determines that a log message should be emitted given the configured log level.
|
||||
|
||||
## Source vs Label
|
||||
|
||||
A `Logger` carries an (immutable) `label` and each log message carries a `source` parameter (since SwiftLog 1.3.0). The `Logger`'s label
|
||||
identifies the creator of the `Logger`. If you are using structured logging by preserving metadata across multiple modules, the `Logger`'s
|
||||
`label` is not a good way to identify where a log message originated from as it identifies the creator of a `Logger` which is often passed
|
||||
around between libraries to preserve metadata and the like.
|
||||
|
||||
If you want to filter all log messages originating from a certain subsystem, filter by `source` which defaults to the module that is emitting the
|
||||
log message.
|
||||
|
||||
## Security
|
||||
|
||||
Please see [SECURITY.md](SECURITY.md) for SwiftLog's security process.
|
||||
|
||||
## 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).
|
||||
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
# Security
|
||||
|
||||
This document specifies the security process for the SwiftLog project.
|
||||
|
||||
## Disclosures
|
||||
|
||||
### Private Disclosure Process
|
||||
|
||||
The SwiftLog maintainers ask that known and suspected vulnerabilities be
|
||||
privately and responsibly disclosed by emailing
|
||||
[sswg-security-reports@forums.swift.org](mailto:sswg-security-reports@forums.swift.org)
|
||||
with the all the required detail.
|
||||
**Do not file a public issue.**
|
||||
|
||||
#### When to report a vulnerability
|
||||
|
||||
* You think you have discovered a potential security vulnerability in SwiftLog.
|
||||
* You are unsure how a vulnerability affects SwiftLog.
|
||||
|
||||
#### What happens next?
|
||||
|
||||
* A member of the team will acknowledge receipt of the report within 3
|
||||
working days (United States). This may include a request for additional
|
||||
information about reproducing the vulnerability.
|
||||
* We will privately inform the Swift Server Work Group ([SSWG][sswg]) of the
|
||||
vulnerability within 10 days of the report as per their [security
|
||||
guidelines][sswg-security].
|
||||
* Once we have identified a fix we may ask you to validate it. We aim to do this
|
||||
within 30 days. In some cases this may not be possible, for example when the
|
||||
vulnerability exists at the protocol level and the industry must coordinate on
|
||||
the disclosure process.
|
||||
* If a CVE number is required, one will be requested from [MITRE][mitre]
|
||||
providing you with full credit for the discovery.
|
||||
* We will decide on a planned release date and let you know when it is.
|
||||
* Prior to release, we will inform major dependents that a security-related
|
||||
patch is impending.
|
||||
* Once the fix has been released we will publish a security advisory on GitHub
|
||||
and in the Server → Security Updates category on the [Swift forums][swift-forums-sec].
|
||||
|
||||
[sswg]: https://github.com/swift-server/sswg
|
||||
[sswg-security]: https://github.com/swift-server/sswg/blob/main/security/README.md
|
||||
[swift-forums-sec]: https://forums.swift.org/c/server/security-updates/
|
||||
[mitre]: https://cveform.mitre.org/
|
||||
@@ -0,0 +1,13 @@
|
||||
# ``Logging/Logger/Level``
|
||||
|
||||
## Topics
|
||||
|
||||
### Log levels
|
||||
|
||||
- ``trace``
|
||||
- ``debug``
|
||||
- ``info``
|
||||
- ``notice``
|
||||
- ``warning``
|
||||
- ``error``
|
||||
- ``critical``
|
||||
@@ -0,0 +1,30 @@
|
||||
# ``Logging``
|
||||
|
||||
A Logging API for Swift.
|
||||
|
||||
## 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.
|
||||
|
||||
### Log handler implementations
|
||||
|
||||
This package offers the common Logging API as well as a very simple stdout log handler.
|
||||
|
||||
In a real system or application, you will want to use one of the many community maintained log handler implementations.
|
||||
|
||||
Please refer to the [complete list of community maintained logging backend implementations](https://github.com/apple/swift-log#selecting-a-logging-backend-implementation-applications-only).
|
||||
|
||||
## Topics
|
||||
|
||||
### Logging API
|
||||
|
||||
- ``Logger``
|
||||
- ``LoggingSystem``
|
||||
|
||||
### Log Handlers
|
||||
|
||||
- ``LogHandler``
|
||||
- ``MultiplexLogHandler``
|
||||
- ``StreamLogHandler``
|
||||
- ``SwiftLogNoOpLogHandler``
|
||||
|
||||
+127
-35
@@ -26,30 +26,62 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
#if canImport(WASILibc)
|
||||
// No locking on WASILibc
|
||||
#elseif canImport(Darwin)
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import WinSDK
|
||||
#elseif canImport(Glibc)
|
||||
import Glibc
|
||||
#else
|
||||
import Glibc
|
||||
#error("Unsupported runtime")
|
||||
#endif
|
||||
|
||||
/// A threading lock based on `libpthread` instead of `libdispatch`.
|
||||
///
|
||||
/// This object provides a lock on top of a single `pthread_mutex_t`. This kind
|
||||
/// of lock is safe to use with `libpthread`-based threading models, such as the
|
||||
/// one used by NIO.
|
||||
/// one used by NIO. On Windows, the lock is based on the substantially similar
|
||||
/// `SRWLOCK` type.
|
||||
internal final class Lock {
|
||||
fileprivate let mutex: UnsafeMutablePointer<pthread_mutex_t> = UnsafeMutablePointer.allocate(capacity: 1)
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
fileprivate let mutex: UnsafeMutablePointer<SRWLOCK> =
|
||||
UnsafeMutablePointer.allocate(capacity: 1)
|
||||
#else
|
||||
fileprivate let mutex: UnsafeMutablePointer<pthread_mutex_t> =
|
||||
UnsafeMutablePointer.allocate(capacity: 1)
|
||||
#endif
|
||||
|
||||
/// Create a new lock.
|
||||
public init() {
|
||||
let err = pthread_mutex_init(self.mutex, nil)
|
||||
precondition(err == 0)
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
InitializeSRWLock(self.mutex)
|
||||
#else
|
||||
var attr = pthread_mutexattr_t()
|
||||
pthread_mutexattr_init(&attr)
|
||||
pthread_mutexattr_settype(&attr, .init(PTHREAD_MUTEX_ERRORCHECK))
|
||||
|
||||
let err = pthread_mutex_init(self.mutex, &attr)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
deinit {
|
||||
let err = pthread_mutex_destroy(self.mutex)
|
||||
precondition(err == 0)
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
// SRWLOCK does not need to be free'd
|
||||
self.mutex.deallocate()
|
||||
#else
|
||||
let err = pthread_mutex_destroy(self.mutex)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
self.mutex.deallocate()
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire the lock.
|
||||
@@ -57,8 +89,14 @@ internal final class Lock {
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `unlock`, to simplify lock handling.
|
||||
public func lock() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
AcquireSRWLockExclusive(self.mutex)
|
||||
#else
|
||||
let err = pthread_mutex_lock(self.mutex)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Release the lock.
|
||||
@@ -66,8 +104,14 @@ internal final class Lock {
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `lock`, to simplify lock handling.
|
||||
public func unlock() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
ReleaseSRWLockExclusive(self.mutex)
|
||||
#else
|
||||
let err = pthread_mutex_unlock(self.mutex)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -96,62 +140,110 @@ extension Lock {
|
||||
}
|
||||
}
|
||||
|
||||
/// A threading lock based on `libpthread` instead of `libdispatch`.
|
||||
/// A reader/writer threading lock based on `libpthread` instead of `libdispatch`.
|
||||
///
|
||||
/// This object provides a lock on top of a single `pthread_mutex_t`. This kind
|
||||
/// This object provides a lock on top of a single `pthread_rwlock_t`. This kind
|
||||
/// of lock is safe to use with `libpthread`-based threading models, such as the
|
||||
/// one used by NIO.
|
||||
/// one used by NIO. On Windows, the lock is based on the substantially similar
|
||||
/// `SRWLOCK` type.
|
||||
internal final class ReadWriteLock {
|
||||
fileprivate let rwlock: UnsafeMutablePointer<pthread_rwlock_t> = UnsafeMutablePointer.allocate(capacity: 1)
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
fileprivate let rwlock: UnsafeMutablePointer<SRWLOCK> =
|
||||
UnsafeMutablePointer.allocate(capacity: 1)
|
||||
fileprivate var shared: Bool = true
|
||||
#else
|
||||
fileprivate let rwlock: UnsafeMutablePointer<pthread_rwlock_t> =
|
||||
UnsafeMutablePointer.allocate(capacity: 1)
|
||||
#endif
|
||||
|
||||
/// Create a new lock.
|
||||
public init() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
InitializeSRWLock(self.rwlock)
|
||||
#else
|
||||
let err = pthread_rwlock_init(self.rwlock, nil)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
deinit {
|
||||
let err = pthread_rwlock_destroy(self.rwlock)
|
||||
precondition(err == 0)
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
// SRWLOCK does not need to be free'd
|
||||
self.rwlock.deallocate()
|
||||
#else
|
||||
let err = pthread_rwlock_destroy(self.rwlock)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
self.rwlock.deallocate()
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire a reader lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `unlock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withReaderLock` instead of this
|
||||
/// method and `unlock`, to simplify lock handling.
|
||||
public func lockRead() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
AcquireSRWLockShared(self.rwlock)
|
||||
self.shared = true
|
||||
#else
|
||||
let err = pthread_rwlock_rdlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Acquire a writer lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `unlock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withWriterLock` instead of this
|
||||
/// method and `unlock`, to simplify lock handling.
|
||||
public func lockWrite() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
AcquireSRWLockExclusive(self.rwlock)
|
||||
self.shared = false
|
||||
#else
|
||||
let err = pthread_rwlock_wrlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Release the lock.
|
||||
///
|
||||
/// Whenever possible, consider using `withLock` instead of this method and
|
||||
/// `lock`, to simplify lock handling.
|
||||
/// Whenever possible, consider using `withReaderLock` and `withWriterLock`
|
||||
/// instead of this method and `lockRead` and `lockWrite`, to simplify lock
|
||||
/// handling.
|
||||
public func unlock() {
|
||||
#if canImport(WASILibc)
|
||||
// WASILibc is single threaded, provides no locks
|
||||
#elseif os(Windows)
|
||||
if self.shared {
|
||||
ReleaseSRWLockShared(self.rwlock)
|
||||
} else {
|
||||
ReleaseSRWLockExclusive(self.rwlock)
|
||||
}
|
||||
#else
|
||||
let err = pthread_rwlock_unlock(self.rwlock)
|
||||
precondition(err == 0)
|
||||
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
extension ReadWriteLock {
|
||||
/// Acquire the reader lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
/// This convenience method should be preferred to `lockRead` and `unlock`
|
||||
/// in most situations, as it ensures that the lock will be released
|
||||
/// regardless of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Parameter body: The block to execute while holding the reader lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withReaderLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
@@ -164,11 +256,11 @@ extension ReadWriteLock {
|
||||
|
||||
/// Acquire the writer lock for the duration of the given block.
|
||||
///
|
||||
/// This convenience method should be preferred to `lock` and `unlock` in
|
||||
/// most situations, as it ensures that the lock will be released regardless
|
||||
/// of how `body` exits.
|
||||
/// This convenience method should be preferred to `lockWrite` and `unlock`
|
||||
/// in most situations, as it ensures that the lock will be released
|
||||
/// regardless of how `body` exits.
|
||||
///
|
||||
/// - Parameter body: The block to execute while holding the lock.
|
||||
/// - Parameter body: The block to execute while holding the writer lock.
|
||||
/// - Returns: The value returned by the block.
|
||||
@inlinable
|
||||
internal func withWriterLock<T>(_ body: () throws -> T) rethrows -> T {
|
||||
|
||||
@@ -15,14 +15,14 @@
|
||||
/// A `LogHandler` is an implementation of a logging backend.
|
||||
///
|
||||
/// This type is an implementation detail and should not normally be used, unless implementing your own logging backend.
|
||||
/// To use the SwiftLog API, please refer to the documentation of `Logger`.
|
||||
/// To use the SwiftLog API, please refer to the documentation of ``Logger``.
|
||||
///
|
||||
/// # Implementation requirements
|
||||
///
|
||||
/// To implement your own `LogHandler` you should respect a few requirements that are necessary so applications work
|
||||
/// as expected regardless of the selected `LogHandler` implementation.
|
||||
///
|
||||
/// - The `LogHandler` must be a `struct`.
|
||||
/// - The ``LogHandler`` must be a `struct`.
|
||||
/// - The metadata and `logLevel` properties must be implemented so that setting them on a `Logger` does not affect
|
||||
/// other `Logger`s.
|
||||
///
|
||||
@@ -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"
|
||||
///
|
||||
@@ -56,9 +56,11 @@
|
||||
/// `LogHandlerWithGlobalLogLevelOverride.overrideGlobalLogLevel = .debug`, for example.
|
||||
///
|
||||
/// ```swift
|
||||
/// import class Foundation.NSLock
|
||||
///
|
||||
/// public struct LogHandlerWithGlobalLogLevelOverride: LogHandler {
|
||||
/// // the static properties hold the globally overridden log level (if overridden)
|
||||
/// private static let overrideLock = Lock()
|
||||
/// private static let overrideLock = NSLock()
|
||||
/// private static var overrideLogLevel: Logger.Level? = nil
|
||||
///
|
||||
/// // this holds the log level if not overridden
|
||||
@@ -74,9 +76,9 @@
|
||||
/// public var logLevel: Logger.Level {
|
||||
/// // when we get asked for the log level, we check if it was globally overridden or not
|
||||
/// get {
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLock.withLock {
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
/// } ?? self._logLevel
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.lock()
|
||||
/// defer { LogHandlerWithGlobalLogLevelOverride.overrideLock.unlock() }
|
||||
/// return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel ?? self._logLevel
|
||||
/// }
|
||||
/// // we set the log level whenever we're asked (note: this might not have an effect if globally
|
||||
/// // overridden)
|
||||
@@ -86,7 +88,7 @@
|
||||
/// }
|
||||
///
|
||||
/// public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?,
|
||||
/// file: String, function: String, line: UInt) {
|
||||
/// source: String, file: String, function: String, line: UInt) {
|
||||
/// // [...]
|
||||
/// }
|
||||
///
|
||||
@@ -101,9 +103,9 @@
|
||||
///
|
||||
/// // this is the function to globally override the log level, it is not part of the `LogHandler` protocol
|
||||
/// public static func overrideGlobalLogLevel(_ logLevel: Logger.Level) {
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.withLock {
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLogLevel = logLevel
|
||||
/// }
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLock.lock()
|
||||
/// defer { LogHandlerWithGlobalLogLevelOverride.overrideLock.unlock() }
|
||||
/// LogHandlerWithGlobalLogLevelOverride.overrideLogLevel = logLevel
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
@@ -111,7 +113,13 @@
|
||||
/// Please note that the above `LogHandler` will still pass the 'log level is a value' test above it iff the global log
|
||||
/// level has not been overridden. And most importantly it passes the requirement listed above: A change to the log
|
||||
/// level on one `Logger` should not affect the log level of another `Logger` variable.
|
||||
public protocol LogHandler {
|
||||
public protocol LogHandler: _SwiftLogSendableLogHandler {
|
||||
/// The metadata provider this `LogHandler` will use when a log statement is about to be emitted.
|
||||
///
|
||||
/// A ``Logger/MetadataProvider`` may add a constant set of metadata,
|
||||
/// or use task-local values to pick up contextual metadata and add it to emitted logs.
|
||||
var metadataProvider: Logger.MetadataProvider? { get set }
|
||||
|
||||
/// This method is called when a `LogHandler` must emit a log message. There is no need for the `LogHandler` to
|
||||
/// check if the `level` is above or below the configured `logLevel` as `Logger` already performed this check and
|
||||
/// determined that a message should be logged.
|
||||
@@ -120,13 +128,22 @@ public protocol LogHandler {
|
||||
/// - level: The log level the message was logged at.
|
||||
/// - message: The message to log. To obtain a `String` representation call `message.description`.
|
||||
/// - metadata: The metadata associated to this log message.
|
||||
/// - source: The source where the log message originated, for example the logging module.
|
||||
/// - file: The file the log message was emitted from.
|
||||
/// - function: The function the log line was emitted from.
|
||||
/// - line: The line the log message was emitted from.
|
||||
func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt)
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt)
|
||||
|
||||
/// SwiftLog 1.0 compatibility method. Please do _not_ implement, implement
|
||||
/// `log(level:message:metadata:source:file:function:line:)` instead.
|
||||
@available(*, deprecated, renamed: "log(level:message:metadata:source:file:function:line:)")
|
||||
func log(level: Logging.Logger.Level, message: Logging.Logger.Message, metadata: Logging.Logger.Metadata?, file: String, function: String, line: UInt)
|
||||
|
||||
/// Add, remove, or change the logging metadata.
|
||||
///
|
||||
@@ -151,3 +168,48 @@ public protocol LogHandler {
|
||||
/// `LogHandler`.
|
||||
var logLevel: Logger.Level { get set }
|
||||
}
|
||||
|
||||
extension LogHandler {
|
||||
/// Default implementation for `metadataProvider` which defaults to `nil`.
|
||||
/// This default exists in order to facilitate source-compatible introduction of the `metadataProvider` protocol requirement.
|
||||
public var metadataProvider: Logger.MetadataProvider? {
|
||||
get {
|
||||
nil
|
||||
}
|
||||
set {
|
||||
self.log(level: .warning, message: "Attempted to set metadataProvider on \(Self.self) that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", metadata: nil, source: "Logging", file: #file, function: #function, line: #line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension LogHandler {
|
||||
@available(*, deprecated, message: "You should implement this method instead of using the default implementation")
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
self.log(level: level, message: message, metadata: metadata, file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "log(level:message:metadata:source:file:function:line:)")
|
||||
public func log(level: Logging.Logger.Level, message: Logging.Logger.Message, metadata: Logging.Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
self.log(level: level,
|
||||
message: message,
|
||||
metadata: metadata,
|
||||
source: Logger.currentModule(filePath: file),
|
||||
file: file,
|
||||
function: function,
|
||||
line: line)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Sendable support helpers
|
||||
|
||||
#if compiler(>=5.6)
|
||||
@preconcurrency public protocol _SwiftLogSendableLogHandler: Sendable {}
|
||||
#else
|
||||
public protocol _SwiftLogSendableLogHandler {}
|
||||
#endif
|
||||
+977
-146
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,113 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2022 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import CRT
|
||||
#elseif canImport(Glibc)
|
||||
import Glibc
|
||||
#elseif canImport(WASILibc)
|
||||
import WASILibc
|
||||
#else
|
||||
#error("Unsupported runtime")
|
||||
#endif
|
||||
|
||||
#if compiler(>=5.6)
|
||||
@preconcurrency protocol _SwiftLogSendable: Sendable {}
|
||||
#else
|
||||
protocol _SwiftLogSendable {}
|
||||
#endif
|
||||
|
||||
extension Logger {
|
||||
/// A `MetadataProvider` is used to automatically inject runtime-generated metadata
|
||||
/// to all logs emitted by a logger.
|
||||
///
|
||||
/// ### Example
|
||||
/// A metadata provider may be used to automatically inject metadata such as
|
||||
/// trace IDs:
|
||||
///
|
||||
/// ```swift
|
||||
/// import Tracing // https://github.com/apple/swift-distributed-tracing
|
||||
///
|
||||
/// let metadataProvider = MetadataProvider {
|
||||
/// guard let traceID = Baggage.current?.traceID else { return nil }
|
||||
/// return ["traceID": "\(traceID)"]
|
||||
/// }
|
||||
/// let logger = Logger(label: "example", metadataProvider: metadataProvider)
|
||||
/// var baggage = Baggage.topLevel
|
||||
/// baggage.traceID = 42
|
||||
/// Baggage.withValue(baggage) {
|
||||
/// logger.info("hello") // automatically includes ["traceID": "42"] metadata
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// We recommend referring to [swift-distributed-tracing](https://github.com/apple/swift-distributed-tracing)
|
||||
/// for metadata providers which make use of its tracing and metadata propagation infrastructure. It is however
|
||||
/// possible to make use of metadata providers independently of tracing and instruments provided by that library,
|
||||
/// if necessary.
|
||||
public struct MetadataProvider: _SwiftLogSendable {
|
||||
/// Provide ``Logger.Metadata`` from current context.
|
||||
#if swift(>=5.5) && canImport(_Concurrency) // we could instead typealias the function type, but it was requested that we avoid this for better developer experience
|
||||
@usableFromInline
|
||||
internal let _provideMetadata: @Sendable() -> Metadata
|
||||
#else
|
||||
@usableFromInline
|
||||
internal let _provideMetadata: () -> Metadata
|
||||
#endif
|
||||
|
||||
/// Create a new `MetadataProvider`.
|
||||
///
|
||||
/// - Parameter provideMetadata: A closure extracting metadata from the current execution context.
|
||||
#if swift(>=5.5) && canImport(_Concurrency)
|
||||
public init(_ provideMetadata: @escaping @Sendable() -> Metadata) {
|
||||
self._provideMetadata = provideMetadata
|
||||
}
|
||||
|
||||
#else
|
||||
public init(_ provideMetadata: @escaping () -> Metadata) {
|
||||
self._provideMetadata = provideMetadata
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Invoke the metadata provider and return the generated contextual ``Logger/Metadata``.
|
||||
public func get() -> Metadata {
|
||||
return self._provideMetadata()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger.MetadataProvider {
|
||||
/// A pseudo-`MetadataProvider` that can be used to merge metadata from multiple other `MetadataProvider`s.
|
||||
///
|
||||
/// ### Merging conflicting keys
|
||||
///
|
||||
/// `MetadataProvider`s are invoked left to right in the order specified in the `providers` argument.
|
||||
/// In case multiple providers try to add a value for the same key, the last provider "wins" and its value is being used.
|
||||
///
|
||||
/// - Parameter providers: An array of `MetadataProvider`s to delegate to. The array must not be empty.
|
||||
/// - Returns: A pseudo-`MetadataProvider` merging metadata from the given `MetadataProvider`s.
|
||||
public static func multiplex(_ providers: [Logger.MetadataProvider]) -> Logger.MetadataProvider? {
|
||||
assert(!providers.isEmpty, "providers MUST NOT be empty")
|
||||
return Logger.MetadataProvider {
|
||||
providers.reduce(into: [:]) { metadata, provider in
|
||||
let providedMetadata = provider.get()
|
||||
guard !providedMetadata.isEmpty else {
|
||||
return
|
||||
}
|
||||
metadata.merge(providedMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+10
-8
@@ -22,13 +22,15 @@ import XCTest
|
||||
/// Do NOT edit this file directly as it will be regenerated automatically when needed.
|
||||
///
|
||||
|
||||
#if os(Linux) || os(FreeBSD)
|
||||
@testable import LoggingTests
|
||||
#if os(Linux) || os(FreeBSD) || os(Windows) || os(Android)
|
||||
@testable import LoggingTests
|
||||
|
||||
XCTMain([
|
||||
testCase(GlobalLoggerTest.allTests),
|
||||
testCase(LocalLoggerTest.allTests),
|
||||
testCase(LoggingTest.allTests),
|
||||
testCase(MDCTest.allTests),
|
||||
])
|
||||
XCTMain([
|
||||
testCase(CompatibilityTest.allTests),
|
||||
testCase(GlobalLoggerTest.allTests),
|
||||
testCase(LocalLoggerTest.allTests),
|
||||
testCase(LoggingTest.allTests),
|
||||
testCase(MDCTest.allTests),
|
||||
testCase(MetadataProviderTest.allTests),
|
||||
])
|
||||
#endif
|
||||
@@ -0,0 +1,31 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// CompatibilityTest+XCTest.swift
|
||||
//
|
||||
import XCTest
|
||||
|
||||
///
|
||||
/// NOTE: This file was generated by generate_linux_tests.rb
|
||||
///
|
||||
/// Do NOT edit this file directly as it will be regenerated automatically when needed.
|
||||
///
|
||||
|
||||
extension CompatibilityTest {
|
||||
static var allTests: [(String, (CompatibilityTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testAllLogLevelsWorkWithOldSchoolLogHandlerWorks", testAllLogLevelsWorkWithOldSchoolLogHandlerWorks),
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/* NOT @testable */ import Logging
|
||||
import XCTest
|
||||
|
||||
final class CompatibilityTest: XCTestCase {
|
||||
func testAllLogLevelsWorkWithOldSchoolLogHandlerWorks() {
|
||||
let testLogging = OldSchoolTestLogging()
|
||||
|
||||
var logger = Logger(label: "\(#function)", factory: testLogging.make)
|
||||
logger.logLevel = .trace
|
||||
|
||||
logger.trace("yes: trace")
|
||||
logger.debug("yes: debug")
|
||||
logger.info("yes: info")
|
||||
logger.notice("yes: notice")
|
||||
logger.warning("yes: warning")
|
||||
logger.error("yes: error")
|
||||
logger.critical("yes: critical", source: "any also with some new argument that isn't propagated")
|
||||
|
||||
// Please note that the source is _not_ propagated (because the backend doesn't support it).
|
||||
testLogging.history.assertExist(level: .trace, message: "yes: trace", source: "no source")
|
||||
testLogging.history.assertExist(level: .debug, message: "yes: debug", source: "no source")
|
||||
testLogging.history.assertExist(level: .info, message: "yes: info", source: "no source")
|
||||
testLogging.history.assertExist(level: .notice, message: "yes: notice", source: "no source")
|
||||
testLogging.history.assertExist(level: .warning, message: "yes: warning", source: "no source")
|
||||
testLogging.history.assertExist(level: .error, message: "yes: error", source: "no source")
|
||||
testLogging.history.assertExist(level: .critical, message: "yes: critical", source: "no source")
|
||||
}
|
||||
}
|
||||
|
||||
private struct OldSchoolTestLogging {
|
||||
private let _config = Config() // shared among loggers
|
||||
private let recorder = Recorder() // shared among loggers
|
||||
|
||||
func make(label: String) -> LogHandler {
|
||||
return OldSchoolLogHandler(label: label,
|
||||
config: self.config,
|
||||
recorder: self.recorder,
|
||||
metadata: [:],
|
||||
logLevel: .info)
|
||||
}
|
||||
|
||||
var config: Config { return self._config }
|
||||
var history: History { return self.recorder }
|
||||
}
|
||||
|
||||
private struct OldSchoolLogHandler: LogHandler {
|
||||
var label: String
|
||||
let config: Config
|
||||
let recorder: Recorder
|
||||
|
||||
func make(label: String) -> LogHandler {
|
||||
return TestLogHandler(label: label, config: self.config, recorder: self.recorder)
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: "no source")
|
||||
}
|
||||
|
||||
subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.metadata[metadataKey]
|
||||
}
|
||||
set {
|
||||
self.metadata[metadataKey] = newValue
|
||||
}
|
||||
}
|
||||
|
||||
var metadata: Logger.Metadata
|
||||
|
||||
var logLevel: Logger.Level
|
||||
}
|
||||
@@ -23,13 +23,11 @@ import XCTest
|
||||
///
|
||||
|
||||
extension GlobalLoggerTest {
|
||||
|
||||
static var allTests : [(String, (GlobalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
("test3", test3),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (GlobalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
("test3", test3),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -147,7 +147,7 @@ private struct Struct3 {
|
||||
let group = DispatchGroup()
|
||||
group.enter()
|
||||
let loggingMetadata = MDC.global.metadata
|
||||
queue.async {
|
||||
self.queue.async {
|
||||
MDC.global.with(metadata: loggingMetadata) {
|
||||
self.logger.warning("Struct3::doSomethingElseAsync")
|
||||
let library = TestLibrary()
|
||||
@@ -160,9 +160,9 @@ private struct Struct3 {
|
||||
group.wait()
|
||||
MDC.global["foo"] = nil
|
||||
// only effects the logger instance
|
||||
var l = logger
|
||||
var l = self.logger
|
||||
l[metadataKey: "baz"] = "qux"
|
||||
l.debug("Struct3::doSomethingElse::Local")
|
||||
logger.debug("Struct3::doSomethingElse::end")
|
||||
self.logger.debug("Struct3::doSomethingElse::end")
|
||||
}
|
||||
}
|
||||
@@ -23,12 +23,10 @@ import XCTest
|
||||
///
|
||||
|
||||
extension LocalLoggerTest {
|
||||
|
||||
static var allTests : [(String, (LocalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (LocalLoggerTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
("test2", test2),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -26,7 +26,7 @@ class LocalLoggerTest: XCTestCase {
|
||||
let context = Context()
|
||||
Struct1().doSomething(context: context)
|
||||
// test results
|
||||
logging.history.assertExist(level: .debug, message: "Struct1::doSomething")
|
||||
logging.history.assertExist(level: .debug, message: "Struct1::doSomething", source: "LoggingTests")
|
||||
logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse")
|
||||
logging.history.assertExist(level: .info, message: "Struct2::doSomething")
|
||||
logging.history.assertExist(level: .info, message: "Struct2::doSomethingElse")
|
||||
@@ -111,7 +111,7 @@ private struct Struct2 {
|
||||
var c = context
|
||||
c.logLevel = .info // only effects from this point on
|
||||
c.logger.info("Struct2::doSomething")
|
||||
doSomethingElse(context: c)
|
||||
self.doSomethingElse(context: c)
|
||||
c.logger.debug("Struct2::doSomething::end")
|
||||
}
|
||||
|
||||
@@ -131,7 +131,7 @@ private struct Struct3 {
|
||||
var c = context
|
||||
c["bar"] = "baz" // only effects from this point on
|
||||
c.logger.error("Struct3::doSomething")
|
||||
doSomethingElse(context: c)
|
||||
self.doSomethingElse(context: c)
|
||||
c.logger.debug("Struct3::doSomething::end")
|
||||
}
|
||||
|
||||
@@ -139,7 +139,7 @@ private struct Struct3 {
|
||||
context.logger.error("Struct3::doSomethingElse")
|
||||
let group = DispatchGroup()
|
||||
group.enter()
|
||||
queue.async {
|
||||
self.queue.async {
|
||||
context.logger.warning("Struct3::doSomethingElseAsync")
|
||||
let library = TestLibrary()
|
||||
library.doSomething()
|
||||
|
||||
@@ -23,26 +23,44 @@ 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),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (LoggingTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testAutoclosure", testAutoclosure),
|
||||
("testMultiplex", testMultiplex),
|
||||
("testMultiplexLogHandlerWithVariousLogLevels", testMultiplexLogHandlerWithVariousLogLevels),
|
||||
("testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes", testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes),
|
||||
("testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers", testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers),
|
||||
("testMultiplexLogHandlerMetadata_readingHandlerMetadata", testMultiplexLogHandlerMetadata_readingHandlerMetadata),
|
||||
("testDictionaryMetadata", testDictionaryMetadata),
|
||||
("testListMetadata", testListMetadata),
|
||||
("testStringConvertibleMetadata", testStringConvertibleMetadata),
|
||||
("testAutoClosuresAreNotForcedUnlessNeeded", testAutoClosuresAreNotForcedUnlessNeeded),
|
||||
("testLocalMetadata", testLocalMetadata),
|
||||
("testCustomFactory", testCustomFactory),
|
||||
("testAllLogLevelsExceptCriticalCanBeBlocked", testAllLogLevelsExceptCriticalCanBeBlocked),
|
||||
("testAllLogLevelsWork", testAllLogLevelsWork),
|
||||
("testAllLogLevelByFunctionRefWithSource", testAllLogLevelByFunctionRefWithSource),
|
||||
("testAllLogLevelByFunctionRefWithoutSource", testAllLogLevelByFunctionRefWithoutSource),
|
||||
("testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts", testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts),
|
||||
("testLogMessageWithStringInterpolation", testLogMessageWithStringInterpolation),
|
||||
("testLoggingAString", testLoggingAString),
|
||||
("testMultiplexMetadataProviderMergesInSpecifiedOrder", testMultiplexMetadataProviderMergesInSpecifiedOrder),
|
||||
("testLoggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider", testLoggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider),
|
||||
("testLoggerWithPredefinedLibraryMetadataProvider", testLoggerWithPredefinedLibraryMetadataProvider),
|
||||
("testLoggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider", testLoggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider),
|
||||
("testMultiplexerIsValue", testMultiplexerIsValue),
|
||||
("testLoggerWithGlobalOverride", testLoggerWithGlobalOverride),
|
||||
("testLogLevelCases", testLogLevelCases),
|
||||
("testLogLevelOrdering", testLogLevelOrdering),
|
||||
("testStreamLogHandlerWritesToAStream", testStreamLogHandlerWritesToAStream),
|
||||
("testStreamLogHandlerOutputFormat", testStreamLogHandlerOutputFormat),
|
||||
("testStreamLogHandlerOutputFormatWithMetaData", testStreamLogHandlerOutputFormatWithMetaData),
|
||||
("testStreamLogHandlerOutputFormatWithOrderedMetadata", testStreamLogHandlerOutputFormatWithOrderedMetadata),
|
||||
("testStreamLogHandlerWritesIncludeMetadataProviderMetadata", testStreamLogHandlerWritesIncludeMetadataProviderMetadata),
|
||||
("testStdioOutputStreamWrite", testStdioOutputStreamWrite),
|
||||
("testStdioOutputStreamFlush", testStdioOutputStreamFlush),
|
||||
("testOverloadingError", testOverloadingError),
|
||||
("testCompileInitializeStandardStreamLogHandlersWithMetadataProviders", testCompileInitializeStandardStreamLogHandlersWithMetadataProviders),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -14,6 +14,14 @@
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import WinSDK
|
||||
#else
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
class LoggingTest: XCTestCase {
|
||||
func testAutoclosure() throws {
|
||||
// bootstrap with our test logging impl
|
||||
@@ -23,10 +31,10 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .info
|
||||
logger.log(level: .debug, {
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
XCTFail("debug should not be called")
|
||||
return "debug"
|
||||
}())
|
||||
logger.debug({
|
||||
logger.trace({
|
||||
XCTFail("trace should not be called")
|
||||
return "trace"
|
||||
}())
|
||||
@@ -55,7 +63,7 @@ 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
|
||||
@@ -68,6 +76,154 @@ class LoggingTest: XCTestCase {
|
||||
logging2.history.assertExist(level: .warning, message: "hello world!", metadata: ["foo": "bar"])
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerWithVariousLogLevels() throws {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.logLevel = .info
|
||||
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.logLevel = .debug
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
multiplexLogger.trace("trace")
|
||||
multiplexLogger.debug("debug")
|
||||
multiplexLogger.info("info")
|
||||
multiplexLogger.warning("warning")
|
||||
|
||||
logging1.history.assertNotExist(level: .trace, message: "trace")
|
||||
logging1.history.assertNotExist(level: .debug, message: "debug")
|
||||
logging1.history.assertExist(level: .info, message: "info")
|
||||
logging1.history.assertExist(level: .warning, message: "warning")
|
||||
|
||||
logging2.history.assertNotExist(level: .trace, message: "trace")
|
||||
logging2.history.assertExist(level: .debug, message: "debug")
|
||||
logging2.history.assertExist(level: .info, message: "info")
|
||||
logging2.history.assertExist(level: .warning, message: "warning")
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerNeedNotMaterializeValuesMultipleTimes() throws {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.logLevel = .info
|
||||
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.logLevel = .info
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
var messageMaterializations: Int = 0
|
||||
var metadataMaterializations: Int = 0
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
multiplexLogger.info(
|
||||
{ () -> Logger.Message in
|
||||
messageMaterializations += 1
|
||||
return "info"
|
||||
}(),
|
||||
metadata: { () ->
|
||||
Logger.Metadata in metadataMaterializations += 1
|
||||
return [:]
|
||||
}()
|
||||
)
|
||||
|
||||
logging1.history.assertExist(level: .info, message: "info")
|
||||
logging2.history.assertExist(level: .info, message: "info")
|
||||
|
||||
XCTAssertEqual(messageMaterializations, 1)
|
||||
XCTAssertEqual(metadataMaterializations, 1)
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerMetadata_settingMetadataThroughToUnderlyingHandlers() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.metadata["one"] = "111"
|
||||
logger1.metadata["in"] = "in-1"
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.metadata["two"] = "222"
|
||||
logger2.metadata["in"] = "in-2"
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
var multiplexLogger = Logger(label: "test")
|
||||
|
||||
// each logs its own metadata
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "in-1",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "in-2",
|
||||
])
|
||||
|
||||
// if modified, change applies to both underlying handlers
|
||||
multiplexLogger[metadataKey: "new"] = "new"
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "in-1",
|
||||
"new": "new",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "in-2",
|
||||
"new": "new",
|
||||
])
|
||||
|
||||
// overriding an existing value works the same way as adding a new one
|
||||
multiplexLogger[metadataKey: "in"] = "multi"
|
||||
multiplexLogger.info("info")
|
||||
logging1.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"one": "111",
|
||||
"in": "multi",
|
||||
"new": "new",
|
||||
])
|
||||
logging2.history.assertExist(level: .info, message: "info", metadata: [
|
||||
"two": "222",
|
||||
"in": "multi",
|
||||
"new": "new",
|
||||
])
|
||||
}
|
||||
|
||||
func testMultiplexLogHandlerMetadata_readingHandlerMetadata() {
|
||||
let logging1 = TestLogging()
|
||||
let logging2 = TestLogging()
|
||||
|
||||
var logger1 = logging1.make(label: "1")
|
||||
logger1.metadata["one"] = "111"
|
||||
logger1.metadata["in"] = "in-1"
|
||||
var logger2 = logging2.make(label: "2")
|
||||
logger2.metadata["two"] = "222"
|
||||
logger2.metadata["in"] = "in-2"
|
||||
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
MultiplexLogHandler([logger1, logger2])
|
||||
}
|
||||
|
||||
let multiplexLogger = Logger(label: "test")
|
||||
|
||||
XCTAssertEqual(multiplexLogger.handler.metadata, [
|
||||
"one": "111",
|
||||
"two": "222",
|
||||
"in": "in-1",
|
||||
])
|
||||
}
|
||||
|
||||
enum TestError: Error {
|
||||
case boom
|
||||
}
|
||||
@@ -106,9 +262,9 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
// 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 {
|
||||
internal final class LazyMetadataBox: CustomStringConvertible {
|
||||
private var makeValue: (() -> String)?
|
||||
private var _value: String? = nil
|
||||
private var _value: String?
|
||||
|
||||
public init(_ makeValue: @escaping () -> String) {
|
||||
self.makeValue = makeValue
|
||||
@@ -137,13 +293,13 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "\(#function)")
|
||||
|
||||
logger[metadataKey: "foo"] = .stringConvertible("raw-string")
|
||||
let lazyBox = LazyMetadataBox({ "rendered-at-first-use" })
|
||||
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" }))])
|
||||
"lazy": .stringConvertible(LazyMetadataBox { "rendered-at-first-use" })])
|
||||
}
|
||||
|
||||
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> Logger.Message {
|
||||
@@ -182,7 +338,7 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
func testCustomFactory() {
|
||||
struct CustomHandler: LogHandler {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {}
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt) {}
|
||||
|
||||
subscript(metadataKey _: String) -> Logger.Metadata.Value? {
|
||||
get { return nil }
|
||||
@@ -254,6 +410,104 @@ class LoggingTest: XCTestCase {
|
||||
testLogging.history.assertExist(level: .critical, message: "yes: critical")
|
||||
}
|
||||
|
||||
func testAllLogLevelByFunctionRefWithSource() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .trace
|
||||
|
||||
let trace = logger.trace(_:metadata:source:file:function:line:)
|
||||
let debug = logger.debug(_:metadata:source:file:function:line:)
|
||||
let info = logger.info(_:metadata:source:file:function:line:)
|
||||
let notice = logger.notice(_:metadata:source:file:function:line:)
|
||||
let warning = logger.warning(_:metadata:source:file:function:line:)
|
||||
let error = logger.error(_:metadata:source:file:function:line:)
|
||||
let critical = logger.critical(_:metadata:source:file:function:line:)
|
||||
|
||||
trace("yes: trace", [:], "foo", #file, #function, #line)
|
||||
debug("yes: debug", [:], "foo", #file, #function, #line)
|
||||
info("yes: info", [:], "foo", #file, #function, #line)
|
||||
notice("yes: notice", [:], "foo", #file, #function, #line)
|
||||
warning("yes: warning", [:], "foo", #file, #function, #line)
|
||||
error("yes: error", [:], "foo", #file, #function, #line)
|
||||
critical("yes: critical", [:], "foo", #file, #function, #line)
|
||||
|
||||
testLogging.history.assertExist(level: .trace, message: "yes: trace", source: "foo")
|
||||
testLogging.history.assertExist(level: .debug, message: "yes: debug", source: "foo")
|
||||
testLogging.history.assertExist(level: .info, message: "yes: info", source: "foo")
|
||||
testLogging.history.assertExist(level: .notice, message: "yes: notice", source: "foo")
|
||||
testLogging.history.assertExist(level: .warning, message: "yes: warning", source: "foo")
|
||||
testLogging.history.assertExist(level: .error, message: "yes: error", source: "foo")
|
||||
testLogging.history.assertExist(level: .critical, message: "yes: critical", source: "foo")
|
||||
}
|
||||
|
||||
func testAllLogLevelByFunctionRefWithoutSource() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .trace
|
||||
|
||||
let trace = logger.trace(_:metadata:file:function:line:)
|
||||
let debug = logger.debug(_:metadata:file:function:line:)
|
||||
let info = logger.info(_:metadata:file:function:line:)
|
||||
let notice = logger.notice(_:metadata:file:function:line:)
|
||||
let warning = logger.warning(_:metadata:file:function:line:)
|
||||
let error = logger.error(_:metadata:file:function:line:)
|
||||
let critical = logger.critical(_:metadata:file:function:line:)
|
||||
|
||||
#if compiler(>=5.3)
|
||||
trace("yes: trace", [:], #fileID, #function, #line)
|
||||
debug("yes: debug", [:], #fileID, #function, #line)
|
||||
info("yes: info", [:], #fileID, #function, #line)
|
||||
notice("yes: notice", [:], #fileID, #function, #line)
|
||||
warning("yes: warning", [:], #fileID, #function, #line)
|
||||
error("yes: error", [:], #fileID, #function, #line)
|
||||
critical("yes: critical", [:], #fileID, #function, #line)
|
||||
#else
|
||||
trace("yes: trace", [:], #file, #function, #line)
|
||||
debug("yes: debug", [:], #file, #function, #line)
|
||||
info("yes: info", [:], #file, #function, #line)
|
||||
notice("yes: notice", [:], #file, #function, #line)
|
||||
warning("yes: warning", [:], #file, #function, #line)
|
||||
error("yes: error", [:], #file, #function, #line)
|
||||
critical("yes: critical", [:], #file, #function, #line)
|
||||
#endif
|
||||
|
||||
testLogging.history.assertExist(level: .trace, message: "yes: trace")
|
||||
testLogging.history.assertExist(level: .debug, message: "yes: debug")
|
||||
testLogging.history.assertExist(level: .info, message: "yes: info")
|
||||
testLogging.history.assertExist(level: .notice, message: "yes: notice")
|
||||
testLogging.history.assertExist(level: .warning, message: "yes: warning")
|
||||
testLogging.history.assertExist(level: .error, message: "yes: error")
|
||||
testLogging.history.assertExist(level: .critical, message: "yes: critical")
|
||||
}
|
||||
|
||||
func testLogsEmittedFromSubdirectoryGetCorrectModuleInNewerSwifts() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .trace
|
||||
|
||||
emitLogMessage("hello", to: logger)
|
||||
|
||||
#if compiler(>=5.3)
|
||||
let moduleName = "LoggingTests" // the actual name
|
||||
#else
|
||||
let moduleName = "SubDirectoryOfLoggingTests" // the last path component of `#file` showing the failure mode
|
||||
#endif
|
||||
|
||||
testLogging.history.assertExist(level: .trace, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .debug, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .info, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .notice, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .warning, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .error, message: "hello", source: moduleName)
|
||||
testLogging.history.assertExist(level: .critical, message: "hello", source: moduleName)
|
||||
}
|
||||
|
||||
func testLogMessageWithStringInterpolation() {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
@@ -261,7 +515,7 @@ class LoggingTest: XCTestCase {
|
||||
var logger = Logger(label: "\(#function)")
|
||||
logger.logLevel = .debug
|
||||
|
||||
let someInt = Int.random(in: 23..<42)
|
||||
let someInt = Int.random(in: 23 ..< 42)
|
||||
logger.debug("My favourite number is \(someInt) and not \(someInt - 1)")
|
||||
testLogging.history.assertExist(level: .debug,
|
||||
message: "My favourite number is \(someInt) and not \(someInt - 1)" as String)
|
||||
@@ -283,13 +537,76 @@ class LoggingTest: XCTestCase {
|
||||
testLogging.history.assertExist(level: .debug, message: "hello world!")
|
||||
}
|
||||
|
||||
func testMultiplexMetadataProviderMergesInSpecifiedOrder() {
|
||||
let logging = TestLogging()
|
||||
|
||||
let providerA = Logger.MetadataProvider { ["provider": "a", "a": "foo"] }
|
||||
let providerB = Logger.MetadataProvider { ["provider": "b", "b": "bar"] }
|
||||
let logger = Logger(label: #function,
|
||||
factory: { label in
|
||||
logging.makeWithMetadataProvider(label: label, metadataProvider: .multiplex([providerA, providerB]))
|
||||
})
|
||||
|
||||
logger.log(level: .info, "test", metadata: ["one-off": "42"])
|
||||
|
||||
logging.history.assertExist(level: .info,
|
||||
message: "test",
|
||||
metadata: ["provider": "b", "a": "foo", "b": "bar", "one-off": "42"])
|
||||
}
|
||||
|
||||
func testLoggerWithoutFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() {
|
||||
let logging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal({ label, metadataProvider in
|
||||
logging.makeWithMetadataProvider(label: label, metadataProvider: metadataProvider)
|
||||
}, metadataProvider: .init { ["provider": "42"] })
|
||||
|
||||
let logger = Logger(label: #function)
|
||||
|
||||
logger.log(level: .info, "test", metadata: ["one-off": "42"])
|
||||
|
||||
logging.history.assertExist(level: .info,
|
||||
message: "test",
|
||||
metadata: ["provider": "42", "one-off": "42"])
|
||||
}
|
||||
|
||||
func testLoggerWithPredefinedLibraryMetadataProvider() {
|
||||
let logging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(
|
||||
logging.makeWithMetadataProvider,
|
||||
metadataProvider: .exampleMetadataProvider
|
||||
)
|
||||
|
||||
let logger = Logger(label: #function)
|
||||
|
||||
logger.log(level: .info, "test", metadata: ["one-off": "42"])
|
||||
|
||||
logging.history.assertExist(level: .info,
|
||||
message: "test",
|
||||
metadata: ["example": "example-value", "one-off": "42"])
|
||||
}
|
||||
|
||||
func testLoggerWithFactoryOverrideDefaultsToUsingLoggingSystemMetadataProvider() {
|
||||
let logging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(logging.makeWithMetadataProvider, metadataProvider: .init { ["provider": "42"] })
|
||||
|
||||
let logger = Logger(label: #function, factory: { label in
|
||||
logging.makeWithMetadataProvider(label: label, metadataProvider: LoggingSystem.metadataProvider)
|
||||
})
|
||||
|
||||
logger.log(level: .info, "test", metadata: ["one-off": "42"])
|
||||
|
||||
logging.history.assertExist(level: .info,
|
||||
message: "test",
|
||||
metadata: ["provider": "42", "one-off": "42"])
|
||||
}
|
||||
|
||||
func testMultiplexerIsValue() {
|
||||
let multi = MultiplexLogHandler([StdoutLogHandler(label: "x"), StdoutLogHandler(label: "y")])
|
||||
let multi = MultiplexLogHandler([StreamLogHandler.standardOutput(label: "x"), StreamLogHandler.standardOutput(label: "y")])
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
print("new multi")
|
||||
return multi
|
||||
}
|
||||
var logger1: Logger = {
|
||||
let logger1: Logger = {
|
||||
var logger = Logger(label: "foo")
|
||||
logger.logLevel = .debug
|
||||
logger[metadataKey: "only-on"] = "first"
|
||||
@@ -310,7 +627,7 @@ class LoggingTest: XCTestCase {
|
||||
struct LogHandlerWithGlobalLogLevelOverride: LogHandler {
|
||||
// the static properties hold the globally overridden log level (if overridden)
|
||||
private static let overrideLock = Lock()
|
||||
private static var overrideLogLevel: Logger.Level? = nil
|
||||
private static var overrideLogLevel: Logger.Level?
|
||||
|
||||
private let recorder: Recorder
|
||||
// this holds the log level if not overridden
|
||||
@@ -327,7 +644,7 @@ class LoggingTest: XCTestCase {
|
||||
// when we get asked for the log level, we check if it was globally overridden or not
|
||||
get {
|
||||
return LogHandlerWithGlobalLogLevelOverride.overrideLock.withLock {
|
||||
return LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
LogHandlerWithGlobalLogLevelOverride.overrideLogLevel
|
||||
} ?? self._logLevel
|
||||
}
|
||||
// we set the log level whenever we're asked (note: this might not have an effect if globally
|
||||
@@ -338,8 +655,8 @@ class LoggingTest: XCTestCase {
|
||||
}
|
||||
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?,
|
||||
file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message)
|
||||
source: String, file: String, function: String, line: UInt) {
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: source)
|
||||
}
|
||||
|
||||
subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
|
||||
@@ -361,7 +678,7 @@ class LoggingTest: XCTestCase {
|
||||
|
||||
let logRecorder = Recorder()
|
||||
LoggingSystem.bootstrapInternal { _ in
|
||||
return LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
|
||||
LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
|
||||
}
|
||||
|
||||
var logger1 = Logger(label: "logger-\(#file):\(#line)")
|
||||
@@ -388,7 +705,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)
|
||||
@@ -417,4 +734,281 @@ 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 testStreamLogHandlerOutputFormat() {
|
||||
let interceptStream = InterceptStream()
|
||||
let label = "testLabel"
|
||||
LoggingSystem.bootstrapInternal { label in
|
||||
StreamLogHandler(label: label, stream: interceptStream)
|
||||
}
|
||||
let source = "testSource"
|
||||
let log = Logger(label: label)
|
||||
|
||||
let testString = "my message is better than yours"
|
||||
log.critical("\(testString)", source: source)
|
||||
|
||||
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\s\\[\(source)\\]\\s\(testString)$"
|
||||
|
||||
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(of: pattern, options: .regularExpression) != nil
|
||||
|
||||
XCTAssertTrue(messageSucceeded)
|
||||
XCTAssertEqual(interceptStream.strings.count, 1)
|
||||
}
|
||||
|
||||
func testStreamLogHandlerOutputFormatWithMetaData() {
|
||||
let interceptStream = InterceptStream()
|
||||
let label = "testLabel"
|
||||
LoggingSystem.bootstrapInternal { label in
|
||||
StreamLogHandler(label: label, stream: interceptStream)
|
||||
}
|
||||
let source = "testSource"
|
||||
let log = Logger(label: label)
|
||||
|
||||
let testString = "my message is better than yours"
|
||||
log.critical("\(testString)", metadata: ["test": "test"], source: source)
|
||||
|
||||
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\stest=test\\s\\[\(source)\\]\\s\(testString)$"
|
||||
|
||||
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(of: pattern, options: .regularExpression) != nil
|
||||
|
||||
XCTAssertTrue(messageSucceeded)
|
||||
XCTAssertEqual(interceptStream.strings.count, 1)
|
||||
}
|
||||
|
||||
func testStreamLogHandlerOutputFormatWithOrderedMetadata() {
|
||||
let interceptStream = InterceptStream()
|
||||
let label = "testLabel"
|
||||
LoggingSystem.bootstrapInternal { label in
|
||||
StreamLogHandler(label: label, stream: interceptStream)
|
||||
}
|
||||
let log = Logger(label: label)
|
||||
|
||||
let testString = "my message is better than yours"
|
||||
log.critical("\(testString)", metadata: ["a": "a0", "b": "b0"])
|
||||
log.critical("\(testString)", metadata: ["b": "b1", "a": "a1"])
|
||||
|
||||
XCTAssertEqual(interceptStream.strings.count, 2)
|
||||
guard interceptStream.strings.count == 2 else {
|
||||
XCTFail("Intercepted \(interceptStream.strings.count) logs, expected 2")
|
||||
return
|
||||
}
|
||||
|
||||
XCTAssert(interceptStream.strings[0].contains("a=a0 b=b0"), "LINES: \(interceptStream.strings[0])")
|
||||
XCTAssert(interceptStream.strings[1].contains("a=a1 b=b1"), "LINES: \(interceptStream.strings[1])")
|
||||
}
|
||||
|
||||
func testStreamLogHandlerWritesIncludeMetadataProviderMetadata() {
|
||||
let interceptStream = InterceptStream()
|
||||
LoggingSystem.bootstrapInternal({ _, metadataProvider in
|
||||
StreamLogHandler(label: "test", stream: interceptStream, metadataProvider: metadataProvider)
|
||||
}, metadataProvider: .exampleMetadataProvider)
|
||||
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)
|
||||
let message = interceptStream.strings.first!
|
||||
XCTAssertTrue(message.contains("example=example-value"), "message must contain metadata, was: \(message)")
|
||||
}
|
||||
|
||||
func testStdioOutputStreamWrite() {
|
||||
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
|
||||
let logStream = StdioOutputStream(file: writeFD, flushMode: .always)
|
||||
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
|
||||
let log = Logger(label: "test")
|
||||
let testString = "hello\u{0} world"
|
||||
log.critical("\(testString)")
|
||||
|
||||
let size = read(readFD, readBuffer, 256)
|
||||
|
||||
let output = String(decoding: UnsafeRawBufferPointer(start: UnsafeRawPointer(readBuffer), count: numericCast(size)), as: UTF8.self)
|
||||
let messageSucceeded = output.trimmingCharacters(in: .whitespacesAndNewlines).hasSuffix(testString)
|
||||
XCTAssertTrue(messageSucceeded)
|
||||
}
|
||||
}
|
||||
|
||||
func testStdioOutputStreamFlush() {
|
||||
// flush on every statement
|
||||
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
|
||||
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: (CFilePointer, CInt, UnsafeMutablePointer<Int8>) -> Void) {
|
||||
var fds: [Int32] = [-1, -1]
|
||||
#if os(Windows)
|
||||
fds.withUnsafeMutableBufferPointer {
|
||||
let err = _pipe($0.baseAddress, 256, _O_BINARY)
|
||||
XCTAssertEqual(err, 0, "_pipe failed \(err)")
|
||||
}
|
||||
#else
|
||||
fds.withUnsafeMutableBufferPointer { ptr in
|
||||
let err = pipe(ptr.baseAddress!)
|
||||
XCTAssertEqual(err, 0, "pipe failed \(err)")
|
||||
}
|
||||
#endif
|
||||
|
||||
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 failed \(err)")
|
||||
|
||||
let readFD = fds[0]
|
||||
#if os(Windows)
|
||||
let hPipe: HANDLE = HANDLE(bitPattern: _get_osfhandle(readFD))!
|
||||
XCTAssertFalse(hPipe == INVALID_HANDLE_VALUE)
|
||||
|
||||
var dwMode: DWORD = DWORD(PIPE_NOWAIT)
|
||||
let bSucceeded = SetNamedPipeHandleState(hPipe, &dwMode, nil, nil)
|
||||
XCTAssertTrue(bSucceeded)
|
||||
#else
|
||||
err = fcntl(readFD, F_SETFL, fcntl(readFD, F_GETFL) | O_NONBLOCK)
|
||||
XCTAssertEqual(err, 0, "fcntl failed \(err)")
|
||||
#endif
|
||||
|
||||
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) }
|
||||
}
|
||||
|
||||
func testOverloadingError() {
|
||||
struct Dummy: Error, LocalizedError {
|
||||
var errorDescription: String? {
|
||||
return "errorDescription"
|
||||
}
|
||||
}
|
||||
// bootstrap with our test logging impl
|
||||
let logging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(logging.make)
|
||||
|
||||
var logger = Logger(label: "test")
|
||||
logger.logLevel = .error
|
||||
logger.error(error: Dummy())
|
||||
|
||||
logging.history.assertExist(level: .error, message: "errorDescription")
|
||||
}
|
||||
|
||||
func testCompileInitializeStandardStreamLogHandlersWithMetadataProviders() {
|
||||
// avoid "unreachable code" warnings
|
||||
let dontExecute = Int.random(in: 100 ... 200) == 1
|
||||
guard dontExecute else {
|
||||
return
|
||||
}
|
||||
|
||||
// default usage
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardOutput)
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardError)
|
||||
|
||||
// with metadata handler, explicitly, public api
|
||||
LoggingSystem.bootstrap({ label, metadataProvider in
|
||||
StreamLogHandler.standardOutput(label: label, metadataProvider: metadataProvider)
|
||||
}, metadataProvider: .exampleMetadataProvider)
|
||||
LoggingSystem.bootstrap({ label, metadataProvider in
|
||||
StreamLogHandler.standardError(label: label, metadataProvider: metadataProvider)
|
||||
}, metadataProvider: .exampleMetadataProvider)
|
||||
|
||||
// with metadata handler, still pretty
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardOutput, metadataProvider: .exampleMetadataProvider)
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardError, metadataProvider: .exampleMetadataProvider)
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger {
|
||||
#if compiler(>=5.3)
|
||||
public func error(error: Error,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #fileID, function: String = #function, line: UInt = #line) {
|
||||
self.error("\(error.localizedDescription)", metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
|
||||
#else
|
||||
public func error(error: Error,
|
||||
metadata: @autoclosure () -> Logger.Metadata? = nil,
|
||||
file: String = #file, function: String = #function, line: UInt = #line) {
|
||||
self.error("\(error.localizedDescription)", metadata: metadata(), file: file, function: function, line: line)
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
extension Logger.MetadataProvider {
|
||||
static var exampleMetadataProvider: Self {
|
||||
.init { ["example": .string("example-value")] }
|
||||
}
|
||||
}
|
||||
|
||||
// Sendable
|
||||
|
||||
#if compiler(>=5.6)
|
||||
// used to test logging metadata which requires Sendable conformance
|
||||
// @unchecked Sendable since manages it own state
|
||||
extension LoggingTest.LazyMetadataBox: @unchecked Sendable {}
|
||||
|
||||
// used to test logging stream which requires Sendable conformance
|
||||
// @unchecked Sendable since manages it own state
|
||||
extension LoggingTest.InterceptStream: @unchecked Sendable {}
|
||||
#endif
|
||||
@@ -23,11 +23,9 @@ import XCTest
|
||||
///
|
||||
|
||||
extension MDCTest {
|
||||
|
||||
static var allTests : [(String, (MDCTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
]
|
||||
}
|
||||
static var allTests: [(String, (MDCTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("test1", test1),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// MetadataProviderTest+XCTest.swift
|
||||
//
|
||||
import XCTest
|
||||
|
||||
///
|
||||
/// NOTE: This file was generated by generate_linux_tests.rb
|
||||
///
|
||||
/// Do NOT edit this file directly as it will be regenerated automatically when needed.
|
||||
///
|
||||
|
||||
extension MetadataProviderTest {
|
||||
static var allTests: [(String, (MetadataProviderTest) -> () throws -> Void)] {
|
||||
return [
|
||||
("testLoggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed", testLoggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed),
|
||||
("testLogHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt", testLogHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt),
|
||||
("testLogHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt", testLogHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt),
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import WinSDK
|
||||
#else
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
final class MetadataProviderTest: XCTestCase {
|
||||
func testLoggingMergesOneOffMetadataWithProvidedMetadataFromExplicitlyPassed() throws {
|
||||
let logging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(logging.make)
|
||||
|
||||
let logger = Logger(label: #function, metadataProvider: .init {
|
||||
[
|
||||
"common": "provider",
|
||||
"provider": "42",
|
||||
]
|
||||
})
|
||||
|
||||
logger.log(level: .info, "test", metadata: ["one-off": "42", "common": "one-off"])
|
||||
|
||||
logging.history.assertExist(level: .info,
|
||||
message: "test",
|
||||
metadata: ["common": "one-off", "one-off": "42", "provider": "42"])
|
||||
}
|
||||
|
||||
func testLogHandlerThatDidNotImplementProvidersButSomeoneAttemptsToSetOneOnIt() {
|
||||
let logging = TestLogging()
|
||||
var handler = LogHandlerThatDidNotImplementMetadataProviders(testLogging: logging)
|
||||
|
||||
handler.metadataProvider = .simpleTestProvider
|
||||
|
||||
logging.history.assertExist(level: .warning, message: "Attempted to set metadataProvider on LogHandlerThatDidNotImplementMetadataProviders that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", source: "Logging")
|
||||
}
|
||||
|
||||
func testLogHandlerThatDidImplementProvidersButSomeoneAttemptsToSetOneOnIt() {
|
||||
let logging = TestLogging()
|
||||
var handler = LogHandlerThatDidImplementMetadataProviders(testLogging: logging)
|
||||
|
||||
handler.metadataProvider = .simpleTestProvider
|
||||
|
||||
logging.history.assertNotExist(level: .warning, message: "Attempted to set metadataProvider on LogHandlerThatDidImplementMetadataProviders that did not implement support for them. Please contact the log handler maintainer to implement metadata provider support.", source: "Logging")
|
||||
}
|
||||
}
|
||||
|
||||
extension Logger.MetadataProvider {
|
||||
static var simpleTestProvider: Logger.MetadataProvider {
|
||||
return Logger.MetadataProvider {
|
||||
return ["test": "provided"]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public struct LogHandlerThatDidNotImplementMetadataProviders: LogHandler {
|
||||
let testLogging: TestLogging
|
||||
init(testLogging: TestLogging) {
|
||||
self.testLogging = testLogging
|
||||
}
|
||||
|
||||
public subscript(metadataKey _: String) -> Logging.Logger.Metadata.Value? {
|
||||
get {
|
||||
return nil
|
||||
}
|
||||
set(newValue) {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
public var metadata: Logging.Logger.Metadata = [:]
|
||||
|
||||
public var logLevel: Logging.Logger.Level = .trace
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
self.testLogging.make(label: "fake").log(level: level, message: message, metadata: metadata, source: source, file: file, function: function, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
public struct LogHandlerThatDidImplementMetadataProviders: LogHandler {
|
||||
let testLogging: TestLogging
|
||||
init(testLogging: TestLogging) {
|
||||
self.testLogging = testLogging
|
||||
}
|
||||
|
||||
public subscript(metadataKey _: String) -> Logging.Logger.Metadata.Value? {
|
||||
get {
|
||||
return nil
|
||||
}
|
||||
set(newValue) {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
public var metadata: Logging.Logger.Metadata = [:]
|
||||
|
||||
public var logLevel: Logging.Logger.Level = .trace
|
||||
|
||||
public var metadataProvider: Logger.MetadataProvider?
|
||||
|
||||
public func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt) {
|
||||
self.testLogging.make(label: "fake").log(level: level, message: message, metadata: metadata, source: source, file: file, function: function, line: line)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Logging
|
||||
|
||||
internal func emitLogMessage(_ message: Logger.Message, to logger: Logger) {
|
||||
logger.trace(message)
|
||||
logger.debug(message)
|
||||
logger.info(message)
|
||||
logger.notice(message)
|
||||
logger.warning(message)
|
||||
logger.error(message)
|
||||
logger.critical(message)
|
||||
}
|
||||
@@ -14,13 +14,30 @@
|
||||
import Foundation
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
#if os(Windows)
|
||||
import WinSDK
|
||||
#endif
|
||||
|
||||
internal struct TestLogging {
|
||||
private let _config = Config() // shared among loggers
|
||||
private let recorder = Recorder() // shared among loggers
|
||||
|
||||
func make(label: String) -> LogHandler {
|
||||
return TestLogHandler(label: label, config: self.config, recorder: self.recorder)
|
||||
return TestLogHandler(
|
||||
label: label,
|
||||
config: self.config,
|
||||
recorder: self.recorder,
|
||||
metadataProvider: LoggingSystem.metadataProvider
|
||||
)
|
||||
}
|
||||
|
||||
func makeWithMetadataProvider(label: String, metadataProvider: Logger.MetadataProvider?) -> LogHandler {
|
||||
return TestLogHandler(
|
||||
label: label,
|
||||
config: self.config,
|
||||
recorder: self.recorder,
|
||||
metadataProvider: metadataProvider
|
||||
)
|
||||
}
|
||||
|
||||
var config: Config { return self._config }
|
||||
@@ -28,35 +45,60 @@ internal struct TestLogging {
|
||||
}
|
||||
|
||||
internal struct TestLogHandler: LogHandler {
|
||||
private let logLevelLock = NSLock()
|
||||
private let metadataLock = NSLock()
|
||||
private let recorder: Recorder
|
||||
private let config: Config
|
||||
private var logger: Logger // the actual logger
|
||||
|
||||
let label: String
|
||||
public var metadataProvider: Logger.MetadataProvider?
|
||||
|
||||
init(label: String, config: Config, recorder: Recorder, metadataProvider: Logger.MetadataProvider?) {
|
||||
self.label = label
|
||||
self.config = config
|
||||
self.recorder = recorder
|
||||
self.logger = Logger(label: "test", StreamLogHandler.standardOutput(label: label))
|
||||
self.logger.logLevel = .debug
|
||||
self.metadataProvider = metadataProvider
|
||||
}
|
||||
|
||||
init(label: String, config: Config, recorder: Recorder) {
|
||||
self.label = label
|
||||
self.config = config
|
||||
self.recorder = recorder
|
||||
self.logger = Logger(label: "test", StdoutLogHandler(label: label))
|
||||
self.logger = Logger(label: "test", StreamLogHandler.standardOutput(label: label))
|
||||
self.logger.logLevel = .debug
|
||||
self.metadataProvider = LoggingSystem.metadataProvider
|
||||
}
|
||||
|
||||
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 })
|
||||
logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
|
||||
self.recorder.record(level: level, metadata: metadata, message: message)
|
||||
func log(level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata explicitMetadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String, function: String, line: UInt) {
|
||||
// baseline metadata, that was set on handler:
|
||||
var metadata = self._metadataSet ? self.metadata : MDC.global.metadata
|
||||
// contextual metadata, e.g. from task-locals:
|
||||
let contextualMetadata = self.metadataProvider?.get() ?? [:]
|
||||
if !contextualMetadata.isEmpty {
|
||||
metadata.merge(contextualMetadata, uniquingKeysWith: { _, contextual in contextual })
|
||||
}
|
||||
// override using any explicit metadata passed for this log statement:
|
||||
if let explicitMetadata = explicitMetadata {
|
||||
metadata.merge(explicitMetadata, uniquingKeysWith: { _, explicit in explicit })
|
||||
}
|
||||
|
||||
self.logger.log(level: level, message, metadata: metadata, source: source, file: file, function: function, line: line)
|
||||
self.recorder.record(level: level, metadata: metadata, message: message, source: source)
|
||||
}
|
||||
|
||||
private var _logLevel: Logger.Level?
|
||||
var logLevel: Logger.Level {
|
||||
get {
|
||||
// get from config unless set
|
||||
return self.logLevelLock.withLock { self._logLevel } ?? self.config.get(key: self.label)
|
||||
return self._logLevel ?? self.config.get(key: self.label)
|
||||
}
|
||||
set {
|
||||
self.logLevelLock.withLock { self._logLevel = newValue }
|
||||
self._logLevel = newValue
|
||||
}
|
||||
}
|
||||
|
||||
@@ -69,26 +111,20 @@ internal struct TestLogHandler: LogHandler {
|
||||
|
||||
public var metadata: Logger.Metadata {
|
||||
get {
|
||||
// return self.logger.metadata
|
||||
return self.metadataLock.withLock { self._metadata }
|
||||
return self._metadata
|
||||
}
|
||||
set {
|
||||
// self.logger.metadata = newValue
|
||||
self.metadataLock.withLock { self._metadata = newValue }
|
||||
self._metadata = newValue
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: would be nice to delegate to local copy of logger but StdoutLogger is a reference type. why?
|
||||
subscript(metadataKey metadataKey: Logger.Metadata.Key) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
// return self.logger[metadataKey: metadataKey]
|
||||
return self.metadataLock.withLock { self._metadata[metadataKey] }
|
||||
return self._metadata[metadataKey]
|
||||
}
|
||||
set {
|
||||
// return logger[metadataKey: metadataKey] = newValue
|
||||
self.metadataLock.withLock {
|
||||
self._metadata[metadataKey] = newValue
|
||||
}
|
||||
self._metadata[metadataKey] = newValue
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -123,9 +159,9 @@ internal class Recorder: History {
|
||||
private let lock = NSLock()
|
||||
private var _entries = [LogEntry]()
|
||||
|
||||
func record(level: Logger.Level, metadata: Logger.Metadata?, message: Logger.Message) {
|
||||
func record(level: Logger.Level, metadata: Logger.Metadata?, message: Logger.Message, source: String) {
|
||||
return self.lock.withLock {
|
||||
self._entries.append(LogEntry(level: level, metadata: metadata, message: message.description))
|
||||
self._entries.append(LogEntry(level: level, metadata: metadata, message: message.description, source: source))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -170,24 +206,95 @@ internal struct LogEntry {
|
||||
let level: Logger.Level
|
||||
let metadata: Logger.Metadata?
|
||||
let message: String
|
||||
let source: String
|
||||
}
|
||||
|
||||
extension History {
|
||||
func assertExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let entry = self.find(level: level, message: message, metadata: metadata)
|
||||
XCTAssertNotNil(entry, "entry not found: \(level), \(String(describing: metadata)), \(message) ", file: file, line: line)
|
||||
#if compiler(>=5.3)
|
||||
func assertExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
fileID: String = #fileID,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(fileID: "\(fileID)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNotNil(entry, "entry not found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
func assertNotExist(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, file: StaticString = #file, line: UInt = #line) {
|
||||
let entry = self.find(level: level, message: message, metadata: metadata)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(String(describing: metadata)), \(message)", file: file, line: line)
|
||||
func assertNotExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
fileID: String = #file,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(fileID: "\(fileID)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil) -> LogEntry? {
|
||||
#else
|
||||
func assertExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(filePath: "\(file)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNotNil(entry, "entry not found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
func assertNotExist(level: Logger.Level,
|
||||
message: String,
|
||||
metadata: Logger.Metadata? = nil,
|
||||
source: String? = nil,
|
||||
file: StaticString = #file,
|
||||
line: UInt = #line) {
|
||||
let source = source ?? Logger.currentModule(filePath: "\(file)")
|
||||
let entry = self.find(level: level, message: message, metadata: metadata, source: source)
|
||||
XCTAssertNil(entry, "entry was found: \(level), \(source), \(String(describing: metadata)), \(message)",
|
||||
file: file, line: line)
|
||||
}
|
||||
#endif
|
||||
|
||||
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil, source: String) -> LogEntry? {
|
||||
return self.entries.first { entry in
|
||||
entry.level == level &&
|
||||
entry.message == message &&
|
||||
entry.metadata ?? [:] == metadata ?? [:]
|
||||
if entry.level != level {
|
||||
return false
|
||||
}
|
||||
if entry.message != message {
|
||||
return false
|
||||
}
|
||||
if let lhs = entry.metadata, let rhs = metadata {
|
||||
if lhs.count != rhs.count {
|
||||
return false
|
||||
}
|
||||
|
||||
for lk in lhs.keys {
|
||||
if lhs[lk] != rhs[lk] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
for rk in rhs.keys {
|
||||
if lhs[rk] != rhs[rk] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
if entry.source != source {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -208,7 +315,7 @@ public class MDC {
|
||||
}
|
||||
set {
|
||||
self.lock.withLock {
|
||||
if nil == self.storage[self.threadId] {
|
||||
if self.storage[self.threadId] == nil {
|
||||
self.storage[self.threadId] = Logger.Metadata()
|
||||
}
|
||||
self.storage[self.threadId]![metadataKey] = newValue
|
||||
@@ -252,11 +359,13 @@ 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()))
|
||||
#elseif os(Windows)
|
||||
return Int(GetCurrentThreadId())
|
||||
#else
|
||||
return Int(pthread_self())
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
@@ -284,7 +393,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
|
||||
queue.asyncAfter(deadline: .now() + 0.1) {
|
||||
self.queue.asyncAfter(deadline: .now() + 0.1) {
|
||||
MDC.global.with(metadata: metadata) {
|
||||
self.logger.info("TestLibrary::doSomethingAsync")
|
||||
completion()
|
||||
@@ -292,3 +401,12 @@ internal struct TestLibrary {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sendable
|
||||
|
||||
#if compiler(>=5.6)
|
||||
extension TestLogHandler: @unchecked Sendable {}
|
||||
extension Recorder: @unchecked Sendable {}
|
||||
extension Config: @unchecked Sendable {}
|
||||
extension MDC: @unchecked Sendable {}
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2022 Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
import Dispatch
|
||||
@testable import Logging
|
||||
import XCTest
|
||||
|
||||
class SendableTest: XCTestCase {
|
||||
#if compiler(>=5.6)
|
||||
func testSendableLogger() async {
|
||||
let testLogging = TestLogging()
|
||||
LoggingSystem.bootstrapInternal(testLogging.make)
|
||||
|
||||
let logger = Logger(label: "test")
|
||||
let message1 = Logger.Message(stringLiteral: "critical 1")
|
||||
let message2 = Logger.Message(stringLiteral: "critical 2")
|
||||
let metadata: Logger.Metadata = ["key": "value"]
|
||||
|
||||
let task = Task.detached {
|
||||
logger.info("info")
|
||||
logger.critical(message1)
|
||||
logger.critical(message2)
|
||||
logger.warning(.init(stringLiteral: "warning"), metadata: metadata)
|
||||
}
|
||||
|
||||
await task.value
|
||||
testLogging.history.assertExist(level: .info, message: "info", metadata: [:])
|
||||
testLogging.history.assertExist(level: .critical, message: "critical 1", metadata: [:])
|
||||
testLogging.history.assertExist(level: .critical, message: "critical 2", metadata: [:])
|
||||
testLogging.history.assertExist(level: .warning, message: "warning", metadata: metadata)
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
One line description of your change
|
||||
|
||||
Motivation:
|
||||
|
||||
Explain here the context, and why you're making that change.
|
||||
What is the problem you're trying to solve.
|
||||
|
||||
Modifications:
|
||||
|
||||
Describe the modifications you've done.
|
||||
|
||||
Result:
|
||||
|
||||
After your change, what will change.
|
||||
+25
-47
@@ -1,56 +1,34 @@
|
||||
ARG ubuntu_version=18.04
|
||||
FROM ubuntu:$ubuntu_version
|
||||
ARG swift_version=5.0
|
||||
ARG ubuntu_version=bionic
|
||||
ARG base_image=swift:$swift_version-$ubuntu_version
|
||||
FROM $base_image
|
||||
# needed to do again after FROM due to docker limitation
|
||||
ARG swift_version
|
||||
ARG ubuntu_version
|
||||
|
||||
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
|
||||
# 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
|
||||
|
||||
# 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
|
||||
# dependencies
|
||||
RUN apt-get update && apt-get install -y wget
|
||||
RUN apt-get update && apt-get install -y lsof dnsutils netcat-openbsd net-tools curl jq # used by integration tests
|
||||
|
||||
# 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
|
||||
RUN apt-get update && apt-get install -y ruby ruby-dev libsqlite3-dev build-essential
|
||||
# jazzy no longer works on xenial as ruby is too old.
|
||||
RUN if [ "${ubuntu_version}" = "focal" ] ; then echo "gem: --no-document" > ~/.gemrc; fi
|
||||
RUN if [ "${ubuntu_version}" = "focal" ] ; then gem install jazzy; fi
|
||||
|
||||
# swift
|
||||
ARG swift_version=4.2.3
|
||||
ARG swift_flavour=RELEASE
|
||||
ARG swift_builds_suffix=release
|
||||
# tools
|
||||
RUN mkdir -p $HOME/.tools
|
||||
RUN echo 'export PATH="$HOME/.tools:$PATH"' >> $HOME/.profile
|
||||
|
||||
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)
|
||||
|
||||
# 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
|
||||
ARG swiftformat_version=0.44.6
|
||||
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
|
||||
@@ -6,10 +6,11 @@ services:
|
||||
image: swift-log:18.04-5.0
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "18.04"
|
||||
ubuntu_version: "bionic"
|
||||
swift_version: "5.0"
|
||||
swift_flavour: "DEVELOPMENT-SNAPSHOT-2019-03-06-a"
|
||||
swift_builds_suffix: "branch"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.0
|
||||
|
||||
shell:
|
||||
image: swift-log:18.04-5.0
|
||||
@@ -0,0 +1,18 @@
|
||||
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
|
||||
environment: []
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:18.04-5.1
|
||||
@@ -0,0 +1,18 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:18.04-5.2
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "bionic"
|
||||
swift_version: "5.2"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.2
|
||||
environment: []
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:18.04-5.2
|
||||
@@ -0,0 +1,18 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:18.04-5.3
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "bionic"
|
||||
swift_version: "5.3"
|
||||
|
||||
test:
|
||||
image: swift-log:18.04-5.3
|
||||
environment: []
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:18.04-5.3
|
||||
@@ -0,0 +1,18 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:20.04-5.4
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "focal"
|
||||
swift_version: "5.4"
|
||||
|
||||
test:
|
||||
image: swift-log:20.04-5.4
|
||||
environment: []
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:20.04-5.4
|
||||
@@ -0,0 +1,19 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:20.04-5.5
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "focal"
|
||||
swift_version: "5.5"
|
||||
|
||||
test:
|
||||
image: swift-log:20.04-5.5
|
||||
environment:
|
||||
- FORCE_TEST_DISCOVERY=--enable-test-discovery
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:20.04-5.5
|
||||
@@ -0,0 +1,19 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:20.04-5.6
|
||||
build:
|
||||
args:
|
||||
ubuntu_version: "focal"
|
||||
swift_version: "5.6"
|
||||
|
||||
test:
|
||||
image: swift-log:20.04-5.6
|
||||
environment:
|
||||
- FORCE_TEST_DISCOVERY=--enable-test-discovery
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:20.04-5.6
|
||||
@@ -0,0 +1,18 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:20.04-5.7
|
||||
build:
|
||||
args:
|
||||
base_image: "swiftlang/swift:nightly-main-focal"
|
||||
|
||||
test:
|
||||
image: swift-log:20.04-5.7
|
||||
environment:
|
||||
- FORCE_TEST_DISCOVERY=--enable-test-discovery
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:20.04-5.7
|
||||
@@ -0,0 +1,18 @@
|
||||
version: "3"
|
||||
|
||||
services:
|
||||
|
||||
runtime-setup:
|
||||
image: swift-log:20.04-main
|
||||
build:
|
||||
args:
|
||||
base_image: "swiftlang/swift:nightly-main-focal"
|
||||
|
||||
test:
|
||||
image: swift-log:20.04-main
|
||||
environment:
|
||||
- FORCE_TEST_DISCOVERY=--enable-test-discovery
|
||||
#- SANITIZER_ARG=--sanitize=thread
|
||||
|
||||
shell:
|
||||
image: swift-log:20.04-main
|
||||
@@ -16,13 +16,22 @@ services:
|
||||
depends_on: [runtime-setup]
|
||||
volumes:
|
||||
- ~/.ssh:/root/.ssh
|
||||
- ..:/code
|
||||
- ..:/code:z
|
||||
working_dir: /code
|
||||
cap_drop:
|
||||
- CAP_NET_RAW
|
||||
- CAP_NET_BIND_SERVICE
|
||||
|
||||
sanity:
|
||||
soundness:
|
||||
<<: *common
|
||||
command: /bin/bash -cl "./scripts/sanity.sh"
|
||||
command: /bin/bash -xcl "./scripts/soundness.sh"
|
||||
|
||||
test:
|
||||
<<: *common
|
||||
command: /bin/bash -cl "swift test"
|
||||
command: /bin/bash -xcl "swift test -Xswiftc -warnings-as-errors $${FORCE_TEST_DISCOVERY-} $${SANITIZER_ARG-}"
|
||||
|
||||
# util
|
||||
|
||||
shell:
|
||||
<<: *common
|
||||
entrypoint: /bin/bash -l
|
||||
@@ -0,0 +1,328 @@
|
||||
# Metadata Providers
|
||||
|
||||
Authors: [Moritz Lang](https://github.com/slashmo), [Konrad 'ktoso' Malawski](https://github.com/ktoso)
|
||||
|
||||
## Introduction
|
||||
|
||||
While global metadata attributes may be manually set on a `LogHandler` level, there's currently no way of reliably providing contextual, automatically propagated, metadata when logging with swift-log.
|
||||
|
||||
## Motivation
|
||||
|
||||
To benefit from tools such as [Distributed Tracing](https://github.com/apple/swift-distributed-tracing) it is necessary for libraries to make use of the trace information.
|
||||
|
||||
Most notably, loggers should participate in tracing by including some trace metadata (such as e.g. a `trace-id`) when logging, as it transparently enables developers to benefit from log correlation using those IDs.
|
||||
|
||||
Today, the only supported way of providing such metadata is to pass them along to each log call explicitly:
|
||||
|
||||
```swift
|
||||
logger.info("first this ...", metadata: ["trace-id": MyTracingLibrary.currentTraceID])
|
||||
logger.info("... now this", metadata: ["trace-id": MyTracingLibrary.currentTraceID])
|
||||
```
|
||||
|
||||
This comes with a couple of downsides:
|
||||
|
||||
### Error-prone and repetitive
|
||||
|
||||
It's easy to forget passing this metadata to _all_ log statements, resulting in an inconsistent debugging experience as these log statements cannot be found using correlation IDs.
|
||||
|
||||
The repetitiveness and verboseness of logging multiple metadata in-line quickly becomes annoying and vastly decreases the signal-to-noise ratio of Swift code trying to be a good citizen and making use of log correlation techniques such as distributed tracing.
|
||||
|
||||
### Impossible to implement for libraries
|
||||
|
||||
A large portion of logs are not generated by the end-user but by libraries such as AsyncHTTPClient, Vapor etc.
|
||||
These libraries, by design, don't know about the specific metadata keys that should be included in the logs.
|
||||
Those keys are after all runtime dependent, and may change depending on what tracing system is configured by the end user.
|
||||
|
||||
For example, a specific `Tracer` implementation would use a type representing a trace ID, and has a way of extracting
|
||||
that trace ID from a [Swift Distributed Tracing Baggage](https://github.com/apple/swift-distributed-tracing-baggage). But other libraries can't know about this _specific_ trace ID and therefore would not be
|
||||
able to pass such values along to their log statements.
|
||||
|
||||
## Proposed solution
|
||||
|
||||
To support this kind of runtime-generated metadata in `swift-log`, we need to extend the logging APIs in an open-ended way, to allow any kinds of metadata to be provided from the asynchronous context (i.e. task local values).
|
||||
|
||||
We also have a desire to keep `swift-log` a "zero dependencies" library, as it intends only to focus on describing a logging API, and not incur any additional dependencies, so it can be used in the most minimal of projects.
|
||||
|
||||
To solve this, we propose the extension of swift-log APIs with a new concept: _metadata providers_.
|
||||
|
||||
`MetadataProvider` is a struct nested in the `Logger` type, sitting alongside `MetadataValue` and the `Metadata`.
|
||||
Its purpose is to _provide_ `Logger.Metadata` from the asynchronous context, by e.g. looking up various task-local values,
|
||||
and converting them into `Logger.Metadata`. This is performed by calling the `get()` function, like so:
|
||||
|
||||
```swift
|
||||
extension Logger {
|
||||
public struct MetadataProvider: Sendable {
|
||||
// ...
|
||||
public init(_ provideMetadata: @escaping @Sendable () -> Metadata)
|
||||
|
||||
public get() -> Metadata
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Defining a `MetadataProvider`
|
||||
|
||||
While `MetadataProvider`s can be created in an ad-hoc fashion, the struct may be used as a namespace
|
||||
to define providers in.
|
||||
|
||||
For example, a `MyTracer` implementation of swift-distributed-tracing would be expected to provide a metadata provider
|
||||
that is aware of its own `Baggage` and specific keys it uses to carry the trace and span identifiers, like this:
|
||||
|
||||
```swift
|
||||
import Tracing // swift-distributed-tracing
|
||||
|
||||
extension Logger.MetadataProvider {
|
||||
static let myTracer = Logger.MetadataProvider {
|
||||
guard let baggage = Baggage.current else {
|
||||
return [:]
|
||||
}
|
||||
guard let spanContext = baggage.spanContext else {
|
||||
return [:]
|
||||
}
|
||||
|
||||
return [
|
||||
"traceID": "\(spanContext.traceID)",
|
||||
"spanID": "\(spanContext.spanID)",
|
||||
]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Using a `MetadataProvider`
|
||||
|
||||
A `MetadataProvider` can be set up either globally, on a boot-strapped logging system:
|
||||
|
||||
```swift
|
||||
LoggingSystem.bootstrap(
|
||||
metadataProvider: .myTracer,
|
||||
StreamLogHandler.standardOutput
|
||||
)
|
||||
```
|
||||
|
||||
or, using the metadata provider specific bootstrap method:
|
||||
|
||||
```swift
|
||||
LoggingSystem.bootstrapMetadataProvider(.myTracer)
|
||||
```
|
||||
|
||||
It is also possible to configure a metadata provider on a per-logger basis, like this:
|
||||
|
||||
```swift
|
||||
let logger = Logger(label: "example", metadataProvider: Logger.MetadataProvider {
|
||||
guard let baggage = Baggage.current else {
|
||||
return [:]
|
||||
}
|
||||
guard let operationID = baggage.operationID else {
|
||||
return nil
|
||||
}
|
||||
return ["extra/opID": "\(opID)"]
|
||||
})
|
||||
```
|
||||
|
||||
which _overrides_ the default bootstrapped metadata provider.
|
||||
|
||||
> NOTE: Setting the metadata provider on the logger directly means the `LoggingSystem` metadata provider
|
||||
> is skipped (if defined), following how an explicitly passed handler `factory`
|
||||
> overrides the `LoggingSystem`s `factory`.
|
||||
|
||||
Once a metadata provider was set up, when a log statement is about to be emitted, the log handler implementation shall
|
||||
invoke it whenever it is about to emit a log statement. This must be done from the same asynchronous context as the log statement
|
||||
was made; I.e. if a log handler were to asynchronously–in a _detached_ task–create the actual log message, the invocation of
|
||||
the metadata provider still _must_ be performed before passing the data over to the other detached task.
|
||||
|
||||
Usually, metadata providers will reach for the task's Swift Distributed Tracing [`Baggage`](https://github.com/apple/swift-distributed-tracing-baggage) which is the mechanism that swift-distributed-tracing
|
||||
and instrumentation libraries use to propagate metadata across asynchronous, as well as process, boundaries. Handlers
|
||||
may also inspect other task-local values, however they should not expect other libraries to be able to propagage those
|
||||
as well as they will propagate `Baggage` values.
|
||||
|
||||
Those metadata will then be included in the log statement, e.g. like this:
|
||||
|
||||
```swift
|
||||
var baggage = Baggage.topLevel
|
||||
baggage.spanContext = SpanContext()
|
||||
Baggage.withValue(baggage) {
|
||||
test()
|
||||
}
|
||||
|
||||
func test() {
|
||||
log.info("Test", metadata: ["oneOff": "42"])
|
||||
// info [traceID: abc, spanID: 123, onOff: 42] Test
|
||||
}
|
||||
```
|
||||
|
||||
### Multiple `MetadataProvider`s using `MetadataProvider.multiplex(_:)`
|
||||
|
||||
Borrowing the concept from log handlers, metadata providers also have a multiplexing implementation.
|
||||
It is defined as an extension on `MetadataProvider` and is useful in cases where users want to utilize
|
||||
more than one metadata provider at the same time:
|
||||
|
||||
```swift
|
||||
extension Logger.MetadataProvider {
|
||||
public static func multiplex(_ providers: [Logger.MetadataProvider]) -> Logger.MetadataProvider {
|
||||
precondition(!providers.isEmpty, "providers MUST NOT be empty")
|
||||
return Logger.MetadataProvider { baggage in
|
||||
providers.reduce(into: nil) { metadata, provider in
|
||||
if let providedMetadata = provider.metadata(baggage) {
|
||||
if metadata != nil {
|
||||
metadata!.merge(providedMetadata, uniquingKeysWith: { _, rhs in rhs })
|
||||
} else {
|
||||
metadata = providedMetadata
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Metadata keys are unique, so in case multiple metadata providers return the same key,
|
||||
the last provider in the array _wins_ and provides the value.
|
||||
|
||||
Note that it is possible to query the `LoggingSystem` for the configured, system-wide, metadata provider,
|
||||
and combine it using a `multiplex` provider if the system-wide provider should not be replaced, but augmented
|
||||
by additional providers.
|
||||
|
||||
### Understanding Swift Distributed Tracing `Baggage`
|
||||
|
||||
The `Baggage` type is more than just a fancy type-safe container for your values which are meant to be carried across
|
||||
using a single, well-known, [task-local value](https://developer.apple.com/documentation/swift/tasklocal).
|
||||
|
||||
Values stored in `Baggage` are intended to be carried _across process boundaries_, and e.g. libraries such as HTTP clients,
|
||||
or other RPC mechanisms, or even messaging systems implement distributed tracing [instruments](https://github.com/apple/swift-distributed-tracing/blob/main/Sources/Instrumentation/Instrument.swift)
|
||||
which `inject` and `extract` baggage values into their respective carrier objects, e.g. an `HTTPRequest` in the case of an HTTP client.
|
||||
|
||||
In other words, whenever intending to propagate information _across processes_ utilize the `Baggage` type to carry it,
|
||||
and ensure to provide an `Instrument` that is able to inject/extract the values of interest into the carrier types you are interested in.
|
||||
To learn more about baggage and instrumentation, refer to the [Swift Distributed Tracing](https://github.com/apple/swift-distributed-tracing/) library documentation.
|
||||
|
||||
#### When to use `Baggage` vs. `Logger[metadataKey:]`
|
||||
|
||||
While `Baggage` is context-dependent and changes depending on where the log methods are being called from, the metadata set on a `Logger` is static and not context-dependent. E.g, if you wanted to add things like an instance ID or a subsystem name to a `Logger`, that could be seen as static information and set via `Logger[metadataKey:]`.
|
||||
|
||||
```swift
|
||||
var logger = Logger(label: "org.swift.my-service")
|
||||
logger[metadataKey: "instanceId"] = "123"
|
||||
|
||||
logger.info("Service started.")
|
||||
// [instanceId: 123] Service started.
|
||||
```
|
||||
|
||||
On the other hand, things like a trace ID are dynamic and context-dependent, therefore would be obtained via `Baggage`:
|
||||
|
||||
```swift
|
||||
logger.info("Product fetched.")
|
||||
// [traceId: 42] Product fetched.
|
||||
```
|
||||
|
||||
Inline-metadata is suitable for one-offs such as a `productId` or a `paymentMethod` in an online store service, but are not enough to corralate the following log statements, i.e. tying them both to the same request:
|
||||
|
||||
```swift
|
||||
logger.info("Product fetched.", metadata: ["productId": "42"])
|
||||
logger.info("Product purchased.", metadata: ["paymentMethod": "apple-pay"])
|
||||
|
||||
// [productId: 42] Product fetched.
|
||||
// [paymentMethod: apple-pay] Product fetched.
|
||||
```
|
||||
|
||||
If there was a `Baggage` value with a trace ID surrounding these log statements, they would be automatically correlatable:
|
||||
|
||||
```swift
|
||||
var baggage = Baggage.topLevel
|
||||
baggage.traceID = 42
|
||||
Baggage.$current.withValue(baggage) {
|
||||
logger.info("Product fetched.", metadata: ["productId": "42"])
|
||||
logger.info("Product purchased.", metadata: ["paymentMethod": "apple-pay"])
|
||||
}
|
||||
|
||||
// [trace-id: 42, productId: 42] Product fetched.
|
||||
// [trace-id: 42, paymentMethod: apple-pay] Product fetched.
|
||||
```
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
### MetadataProviders as a function of `Baggage -> Metadata`
|
||||
|
||||
This was considered and fully developed, however it would cause swift-log to have a dependency on the instrumentation type `Baggage`,
|
||||
which was seen as in-conflict-with the interest of swift-log remaining a zero-dependency library.
|
||||
|
||||
`Baggage` _is_ the well known type that is intended to be used for any kind of distributed systems instrumentation and tracing,
|
||||
however it adds additional complexity and confusion for users who are not interested in this domain. For example, developers
|
||||
may be confused about why `Baggage` and `Logger.Metadata` look somewhat similar, but behave very differently. This complexity
|
||||
is inherent to the two types actually being _very_ different, however we do not want to overwhelm newcomers or developers
|
||||
who are only intending to use swift-log within process. Such developers do not need to care about the added complexities
|
||||
of distributed systems.
|
||||
|
||||
The tradeoff we take here is that every metadata provider will have to perform its own task-local (and therefore also thread-local),
|
||||
access in order to obtain the `Baggage` value, rather than the lookup being able to be performed _once_ and shared between
|
||||
multiple providers when a multiplex provider was configured in the system. We view this tradeoff as worth taking, as the cost
|
||||
of actually formatting the metadata usually strongly dominates the cost of the task-local lookup.
|
||||
|
||||
### Removing `LogHandler.Metadata` in favor of `Baggage`
|
||||
|
||||
Removing logger metadata is not a good option because it serves a slightly different style of metadata than the baggage.
|
||||
|
||||
Baggage is intended for contextual, task-local, metadata which is _carried across multiple libraries_. The values stored in baggage are well-typed, and must declare keys for accessing values in a baggage, this works well for multiple pieces of an application needing to reach for specific baggage items: everyone aware of the `traceID` key, is able to query the baggage for this key (`baggage.traceID`) and obtain a well-typed value. This comes with a higher cost on declaring keys though, as well as a global namespace for those - which is desirable for such kinds of metadata.
|
||||
|
||||
This is not the same usage pattern as emitting a plain structured log where we'd like to include the name of an item we just queried:
|
||||
|
||||
```swift
|
||||
log.info("Obtained item! Hooray!", metadata: ["item": "\(item)"])
|
||||
```
|
||||
|
||||
In this example, the key/value pair for `"item"` is pretty ad-hoc, and we never need to refer to it elsewhere in the program. It never is queried by other pieces of the application, nor would it be useful to set it in baggage metadata, as the only purpose of the `item` key here is to log, and forget about it.
|
||||
|
||||
### Explicitly passing `Baggage` always
|
||||
|
||||
Baggage is designed for use cases like distributed tracing, or similar instrumentation patterns where "all" participating code may need to reach for it.
|
||||
|
||||
Specifically in logging, this means that _every_ call site for _every_ log statement would have to pass it explicitly resulting in annoying noisy code:
|
||||
|
||||
```swift
|
||||
class StoresRepository {
|
||||
func store(byID id: String, eventLoop: EventLoop, logger: Logger, baggage: Baggage) async throws -> Store {
|
||||
InstrumentationSystem.tracer.withSpan("Fetch Store") { span in
|
||||
logger.info("Fetched store.", baggage: span.baggage)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try await storesRepository.store(
|
||||
byID: storeID,
|
||||
eventLoop: eventLoop,
|
||||
logger: logger,
|
||||
baggage: baggage
|
||||
)
|
||||
```
|
||||
|
||||
### Explicitly passing `Logger` always
|
||||
|
||||
Imagine we don't have metadata providers, we'd have to manually set trace IDs on loggers which doesn't really work as all libraries involved would need to know about the same specific trace ID. Even if we inverted the dependency to have `Tracing` depend on `Logging` so that we'd be able to define something like "Tracing, please populate this logger with metadata", we'd have to make sure this thing is called in all places to avoid dropping contextual metadata.
|
||||
|
||||
```swift
|
||||
import Tracing
|
||||
import Logging
|
||||
|
||||
let contextualLogger = InstrumentationSystem.tracer.populateTraceMetadata(logger)
|
||||
contextualLogger.info("Request received.")
|
||||
```
|
||||
|
||||
### Tracing providing extensions on Logger
|
||||
|
||||
Instead of having `swift-log` depend on `swift-distributed-tracing-baggage` we could also create extensions for `Logger` inside `swift-distributed-tracing` and have users call these new overloaded methods instead:
|
||||
|
||||
```swift
|
||||
extension Logger {
|
||||
func tinfo(_ message: ..., baggage: Baggage?) {
|
||||
// ...
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Such extensions could work like the currently-proposed APIs, but the risk of users calling the wrong methods is incredibly high and we cannot overload the existing methods' signatures because of ambiguity of call-sides without explicit Baggage being passed:
|
||||
|
||||
```swift
|
||||
logger.info("Hello")
|
||||
// we want this to pick up Baggage, but the signature would be ambiguous
|
||||
```
|
||||
|
||||
Also, this extension-based contextual metadata would require basically everyone in Server-side Swift to adapt their usage of `Logging` to use these extensions instead. With the proposed APIs, we'd only need to modify `Logging` and any NIO-based libraries such as `AsyncHTTPClient`, `Vapor`, etc. and not every single log statement in every application.
|
||||
Executable
+94
@@ -0,0 +1,94 @@
|
||||
#!/bin/bash
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the Swift Logging API open source project
|
||||
##
|
||||
## Copyright (c) 2019 Apple Inc. and the Swift Logging API project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.txt for the list of Swift Logging API project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the SwiftNIO open source project
|
||||
##
|
||||
## Copyright (c) 2017-2018 Apple Inc. and the SwiftNIO project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
set -eu
|
||||
|
||||
function usage() {
|
||||
echo "$0 [-u] version"
|
||||
echo
|
||||
echo "OPTIONS:"
|
||||
echo " -u: Additionally upload the podspec"
|
||||
}
|
||||
|
||||
upload=false
|
||||
while getopts ":u" opt; do
|
||||
case $opt in
|
||||
u)
|
||||
upload=true
|
||||
;;
|
||||
\?)
|
||||
usage
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
shift "$((OPTIND-1))"
|
||||
|
||||
if [[ $# -eq 0 ]]; then
|
||||
echo "Must provide target version"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
version=$1
|
||||
podspec_name="Logging"
|
||||
|
||||
here="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
tmpdir=$(mktemp -d /tmp/.build_podspecsXXXXXX)
|
||||
echo "Building podspec in $tmpdir"
|
||||
|
||||
cat > "${tmpdir}/${podspec_name}.podspec" <<- EOF
|
||||
Pod::Spec.new do |s|
|
||||
s.name = '$podspec_name'
|
||||
s.version = '$version'
|
||||
s.license = { :type => 'Apache 2.0', :file => 'LICENSE.txt' }
|
||||
s.summary = 'A Logging API for Swift.'
|
||||
s.homepage = 'https://github.com/apple/swift-log'
|
||||
s.author = 'Apple Inc.'
|
||||
s.source = { :git => 'https://github.com/apple/swift-log.git', :tag => s.version.to_s }
|
||||
s.documentation_url = 'https://apple.github.io/swift-log'
|
||||
s.module_name = 'Logging'
|
||||
|
||||
s.swift_version = '5.0'
|
||||
s.cocoapods_version = '>=1.6.0'
|
||||
s.ios.deployment_target = '8.0'
|
||||
s.osx.deployment_target = '10.9'
|
||||
s.tvos.deployment_target = '9.0'
|
||||
s.watchos.deployment_target = '2.0'
|
||||
|
||||
s.source_files = 'Sources/Logging/**/*.swift'
|
||||
end
|
||||
EOF
|
||||
|
||||
if $upload; then
|
||||
echo "Uploading ${tmpdir}/${podspec_name}.podspec"
|
||||
pod trunk push "${tmpdir}/${podspec_name}.podspec"
|
||||
else
|
||||
echo "Linting ${tmpdir}/${podspec_name}.podspec"
|
||||
pod spec lint "${tmpdir}/${podspec_name}.podspec"
|
||||
fi
|
||||
Executable
+136
@@ -0,0 +1,136 @@
|
||||
#!/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
|
||||
|
||||
# repodir
|
||||
function all_modules() {
|
||||
local repodir="$1"
|
||||
(
|
||||
set -eu
|
||||
cd "$repodir"
|
||||
swift package dump-package | jq '.products |
|
||||
map(select(.type | has("library") )) |
|
||||
map(.name) | .[]' | tr -d '"'
|
||||
)
|
||||
}
|
||||
|
||||
# repodir tag output
|
||||
function build_and_do() {
|
||||
local repodir=$1
|
||||
local tag=$2
|
||||
local output=$3
|
||||
|
||||
(
|
||||
cd "$repodir"
|
||||
git checkout -q "$tag"
|
||||
swift build
|
||||
while read -r module; do
|
||||
swift api-digester -sdk "$sdk" -dump-sdk -module "$module" \
|
||||
-o "$output/$module.json" -I "$repodir/.build/debug"
|
||||
done < <(all_modules "$repodir")
|
||||
)
|
||||
}
|
||||
|
||||
function usage() {
|
||||
echo >&2 "Usage: $0 REPO-GITHUB-URL NEW-VERSION OLD-VERSIONS..."
|
||||
echo >&2
|
||||
echo >&2 "This script requires a Swift 5.1+ toolchain."
|
||||
echo >&2
|
||||
echo >&2 "Examples:"
|
||||
echo >&2
|
||||
echo >&2 "Check between master and tag 2.1.1 of swift-nio:"
|
||||
echo >&2 " $0 https://github.com/apple/swift-nio master 2.1.1"
|
||||
echo >&2
|
||||
echo >&2 "Check between HEAD and commit 64cf63d7 using the provided toolchain:"
|
||||
echo >&2 " xcrun --toolchain org.swift.5120190702a $0 ../some-local-repo HEAD 64cf63d7"
|
||||
}
|
||||
|
||||
if [[ $# -lt 3 ]]; then
|
||||
usage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
sdk=/
|
||||
if [[ "$(uname -s)" == Darwin ]]; then
|
||||
sdk=$(xcrun --show-sdk-path)
|
||||
fi
|
||||
|
||||
hash jq 2> /dev/null || { echo >&2 "ERROR: jq must be installed"; exit 1; }
|
||||
tmpdir=$(mktemp -d /tmp/.check-api_XXXXXX)
|
||||
repo_url=$1
|
||||
new_tag=$2
|
||||
shift 2
|
||||
|
||||
repodir="$tmpdir/repo"
|
||||
git clone "$repo_url" "$repodir"
|
||||
git -C "$repodir" fetch -q origin '+refs/pull/*:refs/remotes/origin/pr/*'
|
||||
errors=0
|
||||
|
||||
for old_tag in "$@"; do
|
||||
mkdir "$tmpdir/api-old"
|
||||
mkdir "$tmpdir/api-new"
|
||||
|
||||
echo "Checking public API breakages from $old_tag to $new_tag"
|
||||
|
||||
build_and_do "$repodir" "$new_tag" "$tmpdir/api-new/"
|
||||
build_and_do "$repodir" "$old_tag" "$tmpdir/api-old/"
|
||||
|
||||
for f in "$tmpdir/api-new"/*; do
|
||||
f=$(basename "$f")
|
||||
report="$tmpdir/$f.report"
|
||||
if [[ ! -f "$tmpdir/api-old/$f" ]]; then
|
||||
echo "NOTICE: NEW MODULE $f"
|
||||
continue
|
||||
fi
|
||||
|
||||
echo -n "Checking $f... "
|
||||
swift api-digester -sdk "$sdk" -diagnose-sdk \
|
||||
--input-paths "$tmpdir/api-old/$f" -input-paths "$tmpdir/api-new/$f" 2>&1 \
|
||||
> "$report" 2>&1
|
||||
|
||||
if ! shasum "$report" | grep -q cefc4ee5bb7bcdb7cb5a7747efa178dab3c794d5; then
|
||||
echo ERROR
|
||||
echo >&2 "=============================="
|
||||
echo >&2 "ERROR: public API change in $f"
|
||||
echo >&2 "=============================="
|
||||
cat >&2 "$report"
|
||||
errors=$(( errors + 1 ))
|
||||
else
|
||||
echo OK
|
||||
fi
|
||||
done
|
||||
rm -rf "$tmpdir/api-new" "$tmpdir/api-old"
|
||||
done
|
||||
|
||||
if [[ "$errors" == 0 ]]; then
|
||||
echo "OK, all seems good"
|
||||
fi
|
||||
echo done
|
||||
exit "$errors"
|
||||
+19
-12
@@ -13,7 +13,7 @@
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
set -e
|
||||
set -ex
|
||||
|
||||
my_path="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
root_path="$my_path/.."
|
||||
@@ -26,20 +26,20 @@ if [[ "$(uname -s)" == "Linux" ]]; then
|
||||
swift build
|
||||
fi
|
||||
# setup source-kitten if required
|
||||
source_kitten_source_path="$root_path/.SourceKitten"
|
||||
mkdir -p "$root_path/.build/sourcekitten"
|
||||
source_kitten_source_path="$root_path/.build/sourcekitten/source"
|
||||
if [[ ! -d "$source_kitten_source_path" ]]; then
|
||||
git clone https://github.com/jpsim/SourceKitten.git "$source_kitten_source_path"
|
||||
fi
|
||||
source_kitten_path="$source_kitten_source_path/.build/x86_64-unknown-linux/debug"
|
||||
source_kitten_path="$source_kitten_source_path/.build/debug"
|
||||
if [[ ! -d "$source_kitten_path" ]]; then
|
||||
rm -rf "$source_kitten_source_path/.swift-version"
|
||||
cd "$source_kitten_source_path" && swift build && cd "$root_path"
|
||||
fi
|
||||
# generate
|
||||
mkdir -p "$root_path/.build/sourcekitten"
|
||||
for module in "${modules[@]}"; do
|
||||
if [[ ! -f "$root_path/.build/sourcekitten/$module.json" ]]; then
|
||||
"$source_kitten_path/sourcekitten" doc --spm-module $module > "$root_path/.build/sourcekitten/$module.json"
|
||||
"$source_kitten_path/sourcekitten" doc --spm --module-name $module > "$root_path/.build/sourcekitten/$module.json"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
@@ -51,12 +51,18 @@ fi
|
||||
if ! command -v jazzy > /dev/null; then
|
||||
gem install jazzy --no-ri --no-rdoc
|
||||
fi
|
||||
module_switcher="docs/$version/README.md"
|
||||
|
||||
jazzy_dir="$root_path/.build/jazzy"
|
||||
rm -rf "$jazzy_dir"
|
||||
mkdir -p "$jazzy_dir"
|
||||
|
||||
module_switcher="$jazzy_dir/README.md"
|
||||
jazzy_args=(--clean
|
||||
--author 'SwiftLog team'
|
||||
--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"
|
||||
@@ -67,12 +73,12 @@ SwiftLog is a Swift logging API package.
|
||||
To get started with SwiftLog, [`import Logging`](../Logging/index.html). The
|
||||
most important type is [`Logger`](https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger.html)
|
||||
which you can use to emit log messages.
|
||||
|
||||
EOF
|
||||
|
||||
tmp=`mktemp -d`
|
||||
for module in "${modules[@]}"; do
|
||||
args=("${jazzy_args[@]}" --output "$tmp/docs/$version/$module" --docset-path "$tmp/docset/$version/$module" --module "$module")
|
||||
args=("${jazzy_args[@]}" --output "$jazzy_dir/docs/$version/$module" --docset-path "$jazzy_dir/docset/$version/$module"
|
||||
--module "$module" --module-version $version
|
||||
--root-url "https://apple.github.io/swift-log/docs/$version/$module/")
|
||||
if [[ -f "$root_path/.build/sourcekitten/$module.json" ]]; then
|
||||
args+=(--sourcekitten-sourcefile "$root_path/.build/sourcekitten/$module.json")
|
||||
fi
|
||||
@@ -80,13 +86,14 @@ for module in "${modules[@]}"; do
|
||||
done
|
||||
|
||||
# push to github pages
|
||||
if [[ $CI == true ]]; then
|
||||
if [[ $PUSH == true ]]; then
|
||||
BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
|
||||
GIT_AUTHOR=$(git --no-pager show -s --format='%an <%ae>' HEAD)
|
||||
git fetch origin +gh-pages:gh-pages
|
||||
git checkout gh-pages
|
||||
rm -rf "docs"
|
||||
cp -r "$tmp/docs" .
|
||||
rm -rf "docs/$version"
|
||||
rm -rf "docs/current"
|
||||
cp -r "$jazzy_dir/docs/$version" docs/
|
||||
cp -r "docs/$version" docs/current
|
||||
git add --all docs
|
||||
echo '<html><head><meta http-equiv="refresh" content="0; url=docs/current/Logging/index.html" /></head></html>' > index.html
|
||||
|
||||
@@ -71,17 +71,17 @@ def createExtensionFile(fileName, classes)
|
||||
file.write "\n"
|
||||
|
||||
for classArray in classes
|
||||
file.write 'extension ' + classArray[0] + " {\n\n"
|
||||
file.write ' static var allTests : [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
|
||||
file.write " return [\n"
|
||||
file.write 'extension ' + classArray[0] + " {\n"
|
||||
file.write ' static var allTests: [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
|
||||
file.write " return [\n"
|
||||
|
||||
for funcName in classArray[1]
|
||||
file.write ' ("' + funcName + '", ' + funcName + "),\n"
|
||||
file.write ' ("' + funcName + '", ' + funcName + "),\n"
|
||||
end
|
||||
|
||||
file.write " ]\n"
|
||||
file.write " }\n"
|
||||
file.write "}\n\n"
|
||||
file.write " ]\n"
|
||||
file.write " }\n"
|
||||
file.write "}\n"
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -94,12 +94,12 @@ def createLinuxMain(testsDirectory, allTestSubDirectories, files)
|
||||
file.write header(fileName)
|
||||
file.write "\n"
|
||||
|
||||
file.write "#if os(Linux) || os(FreeBSD)\n"
|
||||
file.write "#if os(Linux) || os(FreeBSD) || os(Windows) || os(Android)\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
|
||||
|
||||
Executable
+16
@@ -0,0 +1,16 @@
|
||||
#!/bin/bash
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the Swift Logging API open source project
|
||||
##
|
||||
## Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.md for the list of Swift Logging API project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
swift package --disable-sandbox preview-documentation --target Logging
|
||||
@@ -13,9 +13,28 @@
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
##===----------------------------------------------------------------------===##
|
||||
##
|
||||
## This source file is part of the SwiftNIO open source project
|
||||
##
|
||||
## Copyright (c) 2017-2019 Apple Inc. and the SwiftNIO project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
## See CONTRIBUTORS.txt for the list of SwiftNIO project authors
|
||||
##
|
||||
## SPDX-License-Identifier: Apache-2.0
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
set -eu
|
||||
here="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
|
||||
|
||||
function replace_acceptable_years() {
|
||||
# this needs to replace all acceptable forms with 'YEARS'
|
||||
sed -e 's/20[12][789012]-20[12][89012]/YEARS/' -e 's/20[12][89012]/YEARS/'
|
||||
}
|
||||
|
||||
printf "=> Checking linux tests... "
|
||||
FIRST_OUT="$(git status --porcelain)"
|
||||
ruby "$here/../scripts/generate_linux_tests.rb" > /dev/null
|
||||
@@ -28,24 +47,53 @@ else
|
||||
printf "\033[0;32mokay.\033[0m\n"
|
||||
fi
|
||||
|
||||
printf "=> Checking license headers... "
|
||||
tmp=$(mktemp /tmp/.swift-log-sanity_XXXXXX)
|
||||
printf "=> Checking for unacceptable language... "
|
||||
# This greps for unacceptable terminology. The square bracket[s] are so that
|
||||
# "git grep" doesn't find the lines that greps :).
|
||||
unacceptable_terms=(
|
||||
-e blacklis[t]
|
||||
-e whitelis[t]
|
||||
-e slav[e]
|
||||
-e sanit[y]
|
||||
)
|
||||
if git grep --color=never -i "${unacceptable_terms[@]}" > /dev/null; then
|
||||
printf "\033[0;31mUnacceptable language found.\033[0m\n"
|
||||
git grep -i "${unacceptable_terms[@]}"
|
||||
exit 1
|
||||
fi
|
||||
printf "\033[0;32mokay.\033[0m\n"
|
||||
|
||||
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"
|
||||
tmp=$(mktemp /tmp/.swift-log-soundness_XXXXXX)
|
||||
|
||||
for language in swift-or-c bash dtrace; do
|
||||
printf " * $language... "
|
||||
declare -a matching_files
|
||||
declare -a exceptions
|
||||
expections=( )
|
||||
matching_files=( -name '*' )
|
||||
case "$language" in
|
||||
swift-or-c)
|
||||
exceptions=( -name c_nio_http_parser.c -o -name c_nio_http_parser.h -o -name cpp_magic.h -o -name Package.swift -o -name CNIOSHA1.h -o -name c_nio_sha1.c -o -name ifaddrs-android.c -o -name ifaddrs-android.h)
|
||||
exceptions=( -name c_nio_http_parser.c -o -name c_nio_http_parser.h -o -name cpp_magic.h -o -name Package.swift -o name Package-swift5.6.swift -o -name CNIOSHA1.h -o -name c_nio_sha1.c -o -name ifaddrs-android.c -o -name ifaddrs-android.h)
|
||||
matching_files=( -name '*.swift' -o -name '*.c' -o -name '*.h' )
|
||||
cat > "$tmp" <<"EOF"
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Logging API open source project
|
||||
//
|
||||
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
// Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
@@ -64,7 +112,7 @@ EOF
|
||||
##
|
||||
## This source file is part of the Swift Logging API open source project
|
||||
##
|
||||
## Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
## Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
## Licensed under Apache License v2.0
|
||||
##
|
||||
## See LICENSE.txt for license information
|
||||
@@ -83,7 +131,7 @@ EOF
|
||||
*
|
||||
* This source file is part of the Swift Logging API open source project
|
||||
*
|
||||
* Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
|
||||
* Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
|
||||
* Licensed under Apache License v2.0
|
||||
*
|
||||
* See LICENSE.txt for license information
|
||||
@@ -108,9 +156,9 @@ EOF
|
||||
\( \! -path './.build/*' -a \
|
||||
\( "${matching_files[@]}" \) -a \
|
||||
\( \! \( "${exceptions[@]}" \) \) \) | while read line; do
|
||||
if [[ "$(cat "$line" | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
if [[ "$(cat "$line" | replace_acceptable_years | head -n $expected_lines | shasum)" != "$expected_sha" ]]; then
|
||||
printf "\033[0;31mmissing headers in file '$line'!\033[0m\n"
|
||||
diff -u <(cat "$line" | head -n $expected_lines) "$tmp"
|
||||
diff -u <(cat "$line" | replace_acceptable_years | head -n $expected_lines) "$tmp"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
Reference in new issue
Block a user