Compare commits

..
68 Commits
Author SHA1 Message Date
Adam Fowler 173f567a2d Make SwiftLogNoOpLogHandler.init() public 2020-07-08 13:05:43 +09:00
Konrad `ktoso` Malawski 57c6bd0425 =doc #82 avoid showcasing internal lock in public docs 2020-07-07 03:12:19 +09:00
Konrad `ktoso` Malawski 024f44d4d5 -log remove the LoggerWithSource for the time being 2020-07-06 20:01:11 +09:00
Johannes Weiss c37c434930 add source for log messages 2020-07-06 20:01:11 +09:00
0c61f3610d =multiplex #139 more properly handle logLevel in multiplex handler (#140)
* =multiplex #139 more properly handle logLevel in multiplex handler

* swift 5.0 needs explicit return

* no need to loop over the settings

* =metadata MultiplexLogHandler now consistently handles metadata read/write

* Apply suggestions from code review

Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: George Barnett <gbrntt@gmail.com>

Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: George Barnett <gbrntt@gmail.com>
2020-07-06 18:34:43 +09:00
Adam Fowler 237094d249 Add NoOpLogHandler for when you don't want logging (#142)
* Add NoOpLogHandler for when you don't want logging

* Make NoOpLogHandler functions @inlinable

* Renamed to SwiftLogNoOpLogHandler
2020-07-02 20:54:26 +09:00
Gwynne Raskind 2caaa7fc10 Improvements to Lock and ReadWriteLock, and PTHREAD_MUTEX_ERRORCHECK (#141)
* Update comments in Locks.swift to correctly reflect the Windows implementation and to correctly describe the operation of the `ReadWriteLock`.

* Add error messages to the preconditions on pthread function call return values. Copied from NIO's `Lock` implementation.

* In `Lock`, create the underlying mutex (where applicable) using `PTHREAD_MUTEX_ERRORCHECK`. Copied from NIO's `Lock` implementation. Performance loss is minor on Xenial, Bionic, CentOS, and AmazonLinux; no loss was measurable on Focal at all.

* On Windows, correctly set the `shared` flag in `ReadWriteLock` so the correct `ReleaseSRWLock*()` function is called in `unlock()`. It appears that in practice Windows does not actually care whether the correct release function is called for the type of lock the thread was holding, but this is undocumented (along with most other semantics of `SRWLOCK`) and thus can not be relied upon.

* Fix formatting (that's what I get for copy-pasting from NIO verbatim)
2020-06-30 16:10:18 +09:00
Johannes Weiss afc50b29de forward #file to #filePath differently (#137)
Motivation:

only works if done when _calling_ a function, not when defining one :|.

- https://github.com/apple/swift/pull/32445
- https://bugs.swift.org/browse/SR-12936
- https://bugs.swift.org/browse/SR-12934
- https://bugs.swift.org/browse/SR-13041

Modifications:

Silence #file to #filePath differently.

Result:

Hopefully at some point we get this working.
2020-06-22 11:47:59 +01:00
Johannes Weiss ee8b3c5044 silence #file to #filePath warnings (#133)
Motivation:

Swift 5.3 will keep `#file` == `#filePath` but starts warning if you
pass `#file` to an argument that's `#filePath` defaulted (XCTest).

Modification:

- Replace `#file` with `(#file)` to silence the warning. In Swift 5.3
  `#file` == `#filePath`.

Result:

No warnings
2020-06-09 11:16:12 +09:00
Shiva HuangandShiva Huang 6d233ae476 Fix doc typo (#134)
* Fix typo in "MetadataValue" words in docs

* Fix typo in "bootstrap" words in docs

Co-authored-by: Shiva Huang <shiva.huang@ailabs.tw>
2020-06-08 13:28:23 +09:00
Jeremy Greenwood a9784b00a6 add swift-log-datadog to list of backends (#132) 2020-06-02 08:28:20 +09:00
tomer doron 4f87671873 improve 5.3 docker setup (#131)
motivation: pin to 5.3 nighties 

changes: use swiftlang/swift:nightly-5.3-master-bionic instead of swiftlang/swift:nightly-master-bionic
2020-05-05 11:07:38 +01:00
zach wick 87c2553da2 Updates the docstring for the 'trace' log level (#130)
Motivation:

The current docstring seems to be missing some words that indicate
when a 'trace' log level is more appropriate than a 'debug' log
level. This was brought up in https://github.com/vapor/docs/issues/463
and has been fixed there. This PR is being submitted to the upstream
project as a courtesy.

Modifications:

This PR adds a clause to the docstring of the 'trace' log level to
clearly indicate when this log level shuld be used.

Result:

The docstring for the 'trace' log level will mirror the structure of
the docstring for the 'debug' log level, but will include a clear
opinion of when the 'trace' log level is appropriate.

Signed-off-by: zach wick <zach@zachwick.com>
2020-05-04 09:27:54 -07:00
YR Chen c08d7f72b9 add stevapple/swift-log-telegram to list of backends (#129) 2020-04-11 11:57:42 +01:00
Mattt da2c8aa854 Add NSHipster/swift-log-github-actions to list of backends (#124) 2020-04-04 09:51:35 -07:00
tomer doron fa15ddefc4 update ci setup (#127)
motivation: 5.2 adoption, prepare for 5.3

changes:
* add 5.2 docker-compose setup
* add 5.3 docker-compose setup (placeholder)
* fix formatting
2020-04-04 00:20:45 -07:00
Tanner 8ede07bf98 Add easy link to backends section (#125)
* Update README.md

* Update README.md

* Update README.md
2020-04-02 08:33:44 +09:00
Johannes Weiss 0e21dd7893 test that demonstrates overloading (#123)
Motivation:

SwiftLog is meant as a base logging library so users will often overload
certain functions with their own specialised and opinionated overloads.

Modification:

Add a test as demonstration.

Result:

More tests.
2020-03-17 14:35:48 -07:00
tomer doron 4d7ef13e01 additional doc generation fixes (#122)
motivation: better doc generation

changes:
* dont remove older docs when pushing new ones
* add version inforamtion and source links
2020-02-28 12:21:07 -08:00
tomer doron 4aad45c1c1 update docs generation script to work better with selinux (#121)
motivation: docs scripts is broken on selinux due to restriction on ssh-agent

changes: change the jazzy worksapce to a directory accessible by the CI node so we can push from the agent instead of from the docker container
2020-02-27 12:58:29 -08:00
Saleem AbdulrasoolandJohannes Weiss 1b5f8a5034 Logging: port to Windows (#118)
This adjusts the APIs to enable building swift-log on Windows.

Co-authored-by: Johannes Weiss <johannesweiss@apple.com>
2020-02-26 17:08:18 +00:00
Saleem Abdulrasool 01ce2959de gitignore: ignore vim swapfiles (#119) 2020-02-26 14:30:38 +09:00
Ravi Kandhadai 57d2a6d872 Update README to clarify the drawbacks of using os_log through swift-log (#117)
The README file links to an implementation of a backend that uses os_log.
However, 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 also changes the default privacy scheme used by os_log and make all message
private, which runs the risk of no message getting logged. Update the
README to capture this drawback. Also, link to the on-going effort on
improving os_log Swift APIs and aligning it with swift-log.
2020-02-24 19:33:16 +00:00
Will Lisac 7b01660491 Add wlisac/swift-log-slack to logging backend list (#115)
LoggingSlack is a logging backend for SwiftLog that sends log messages to Slack.
2020-02-16 23:46:17 -08:00
Artur Dryomov 27da3424c7 Add more syntax highlighting to the readme file (#114) 2020-02-06 11:02:57 +09:00
Franz Busch 3a9a783347 Fix small typo in tests (#113)
* Update LoggingTest.swift

* Apply suggestions from code review
2020-02-03 22:09:34 +09:00
tomer doron b321ca1807 improve docker security (#111)
motivation: more secured ci setup

changes:
* enable :z selinux flag on bind mounts so we can enable selinux on ci
* drop potentially exploitable capabilities from docker-compose
2020-01-29 08:36:34 +00:00
prafsoni 068014614c [feat] StreamLogHandler now adds label to log output (#108)
* [feat] StreamLogHandler now adds label to log output
* [test] add test cases for log out format assertion.
2019-12-18 01:38:07 -08:00
Neal Lester 012cff81f6 Reformatted backend implementation list as a table. Added swift-log-testing to the backend implementation (new) table. https://github.com/apple/swift-log/issues/105 (#106) 2019-11-21 14:35:36 -08:00
tomer doron f0f77b00c4 check for api breakage in ci and prepare to test with thread sanitizer (#102)
motivation: better ci testing

changes:
* add api breakage script to test api breakage in ci
* add "shell" utility docker-compose task to run api breakage script
* change test task to treat warning as errors
* prepare to test with thread sanitizer in 5.1
2019-11-04 16:42:41 -08:00
Thomas Krajacic 74d7b91cee Add .swiftpm to gitignore (#100) 2019-10-11 14:58:34 -07:00
Julian Kahnert 77b2e836f1 make Logger.Level codable (#99) 2019-09-26 17:47:27 +01:00
tomer doron 1111d309a5 swift 5.1 docker setup (#97)
motivation: support swift 5.1

changes:
* add docker compose file for swift 5.1, will add CI job once merged
* update swiftformat version to 0.40.12
* fix warning in tests
2019-09-23 22:39:36 -07:00
Tanner e5a4bd1003 add vapor/console-kit backend to README (#95) 2019-09-06 08:31:41 +01:00
Jordane Belanger fd6c6b338d Add StackdriverLogging to README (#93) #92
* Add StackdriverLogging to README

* Switch the  description in the README from using 'logger' to the 'logging backend' terminology
2019-08-27 08:16:48 +09:00
Nate Sanchez-Goodwin 6669bdf615 Remove level parameter from log helpers (#91) 2019-08-21 16:21:31 +01:00
tomer doron 6171b4483e update conduct email group (#90)
motivation: use consistent email across swift server projects 

changes: set conduct email address to swift-server-conduct@group.apple.com
2019-08-20 20:58:57 +01:00
Chris Aljoudi 2b7d68a486 Add swift-log-oslog logging backend link (#89) 2019-08-20 13:45:42 +01:00
Ian Partridge e8aabbe95d Add HeliumLogger to README (#88) 2019-08-16 17:13:06 +01:00
tomer doron e309184b89 add flush api to default stdout/stderr logger (#87)
* add flush api to default stdout/stderr logger

motivation: default logger may not flush the streams on crush, so need to make flushing moe explicit

changes:
* add a constructor argument to control flushing behaviour, default to "everytime"
* add a "flush" method to allow user defined flush timing. this api is now internal but we could expose it if there is a need
* add tests

* fixup
2019-08-13 10:59:48 +01:00
Johannes Weiss ebdfdcf0ff better documentation around MetadataValue being expressible by literals (#85)
* better documentation around MetadataValue being expressible by literals

Motivation:

In many examples, I could see that users seem to construct metadata
values using the explicit enum cases `.string("foo")`, `.array(...)`, as
well as `.dictionary(...)`. It's much more readable and easier to type
to just use `"foo"`, `["bar", "buz"]`, and `["qux": "quux"]` and rely on
the `ExpressibleBy...Literal` conformances.

Modifications:

Add the docs and examples.

Result:

Hopefully, users will read the docs and write more idiomatic code.

* Update Logging.swift
2019-08-07 11:43:28 +09:00
tomer doron 263735081c test formatting issues as part of sanity check (#84)
motivaiton: unified format

changes:
* use official docker image 🎉
* fix outstanding formatting issues
* add a call to swiftformat as part of sanity script
* fix sanity script language check debugging statements
2019-07-30 13:34:00 -07:00
Ian G 99786c85ac Add Adorkable/swift-log-format-and-pipe to Backend list (#83)
LoggingFormatAndPipe provides a Swift Logging API Handler which allows you to customized both your log messages' formats as well as their destinations.
2019-07-30 08:27:00 +01:00
Kevin Sweeney b33865f66b Fix documented ordering of Level (#78)
Levels are actually ordered from least severe to most severe, and their raw values are not exposed.
2019-06-25 22:52:56 +01:00
Konrad `ktoso` Malawski 9fc3834d3f Link to ianpartridge/swift-log-syslog backend impl (#73)
motivation: @ianpartridge implemented a backend for syslog (awesome :-)) so we should link to it so people are easily able to discover it (and any other future implementations we'd want to link to).
2019-06-24 19:55:56 -07:00
Max Desiatov df4d2c80df Fix typo in LogHandler doc comment (#76) 2019-06-03 10:01:42 -07:00
Max Desiatov f4240bf022 Add internal section link to README.md (#71) 2019-05-05 20:34:31 -07:00
Allen Humphreys ea3eea9dcb Expose an API for configuring basic stdio log handling (#61)
Expose `StreamLogHandler` to the public which replaces the previously internal `StdoutLogHandlers`. Users can choose now the output stream, while `stdout` is the default.

### Motivation:

As discussed on #51 and #60

### Modifications:

Rename `StdoutLogHandler` to `StreamLogHandler` and provide 2 factory methods `standardOutput(label:)` and `standardError(label:)` for using during bootstrapping.

### Result:

Users who adopt other logging backends during `LoggingSystem` bootstrapping will still be able to use the default log handler to get very basic console output to their choice of `stdout` or `stderr`.

### Example:
```
// Log to both stderr and stdout for good measure
LoggingSystem.bootstrap { 
    MultiplexLogHandler([
        FancyLoggingBackend(label: $0),
        StreamLogHandler.standardError(label: $0), 
        StreamLogHandler.standardOutput(label: $0)
    ])
}
```
2019-05-01 16:44:16 +01:00
Johannes Weiss 67b2425b4c add a CocoaPods podspec generator (#54)
Motivation:

Users ask for a CocoaPod. Unfortunately, the CocodPod `SwiftLog` is
already taken, so I went for `SwiftLogAPI`.

Modification:

Add a podspec generator.

Result:

Happier users.
2019-04-30 16:32:19 +01:00
Johannes Weiss dbb9d24d8d Update README.md 2019-04-26 09:03:08 +01:00
Johannes Weiss 3e8f2138a1 explain the upcoming SwiftLog 0 (#69) 2019-04-25 19:29:27 +01:00
tsuyoshi hyuga a26395d403 changed to isEmpty. (#65) 2019-04-25 10:48:14 +01:00
Ian Partridge 0c403de592 docs: improve API documentation coverage (#67) 2019-04-25 10:47:00 +01:00
Yim Lee 9ac2ad4064 Fix API documentation (#66)
Motivation:

API doc contains misinformation.

Modifications:

Update documentation for `Logger` API to match code.

Result:

API doc is correct.
2019-04-24 22:14:10 +01:00
tomer doron 75c08c0611 Add 'Show on GitHub' link to API docs (#64)
Motivation:

Allowing readers of the API documentation to drill into the implementation of documented declarations can be educational and helpful for debugging, among several other reasons.

Modifications:

Add --github-file-prefix appending the current version in order to keep stable links. This means that documentation generated from any non-release revision may resolve incorrectly. This can be refined in the doc generation script later if it is deemed problematic by resolving to the commit sha if it doesn't exactly align with the version.

Result:

Users will be able to click a 'Show on GitHub' for all documented API declarations.
2019-04-23 12:16:48 -07:00
tomer doron cfd8740667 add git commit template (#62)
motivation: missing the template mentioned in the contribution guides

changes: add dev directory with the git commit template
2019-04-19 10:55:23 +01:00
grundoon 250cef01ad fix docs #file -> #function (#59)
* fix docs #file -> #function

Multiple occurrences of `#file` in docs where `#function` was intended.

* add missing parentheses to parameter docs
2019-04-17 08:59:41 +01:00
Daniel Höpfl 33ceed2816 Fixed typo. (#58) 2019-04-16 09:30:39 -07:00
tomer doron 6397eee678 add contribution guidelines and github default config (#55)
motivation: adopt contribution guidelines and github PR conventions

changes:
* add contributing guidelines, including commit message template
* add github PR guidelines, including PR message template
2019-04-15 11:11:04 -07:00
tomer doron 4fe877816a fix linux tests formatting (#45)
motivation: use consistent formatting

changes: update generate_linux_tests to match the formatting rules we use: `swiftformat --self insert --patternlet inline --stripunusedargs unnamed-only --comments ignore`
2019-04-15 17:29:30 +01:00
tomer doron 851eacf76e fix docker setup to use release version of swift 5 (#48)
motivation: swift 5 was already released, use the release version for CI

changes: remove the dev verion from docker compose setup
2019-04-15 17:28:03 +01:00
Konrad `ktoso` Malawski 856a83e9f4 Link to more appropriate (still open) Swift issue (#50)
The original issue that was https://bugs.swift.org/browse/SR-9687 has been closed as duplicate of https://bugs.swift.org/browse/SR-9686
Perhaps it would be less confusing for others reading the code if we linked to the not-closed issue?

Not a big deal, just something I noticed; if we want to continue to link to the original issue that's fine too.
2019-04-15 11:59:33 +01:00
Konrad `ktoso` Malawski e37f28a5ff Fix typo in "critical" words in docs (#49) 2019-04-15 11:19:09 +01:00
David Okun a4828d9184 Added CaseIterable to Logger.Level enum (#46)
* Added CaseIterable to Logger.Level enum
2019-04-12 14:49:25 +01:00
tomer doron 9a393a5d35 retain SwiftNIO copyright header (#44)
motivation: retain copyrights

changes:
* add notice file with references to derived work
* add swift-nio license header to lock
2019-04-11 14:12:41 +01:00
Johannes Weiss 3924b3b96e readme: fix log levels (#43) 2019-04-10 10:04:51 -07:00
tomer doron 23f0f6ee6e fix typo in API docs (#42)
motivation: better docs

changes: swidft-log -> SwiftLog in an API doc that got it wrong
2019-04-10 18:02:11 +01:00
tomer doron f6a420460d use consistent, swifty naming convention (#41)
motivation: prepare to release

changes: refer to package as SwiftLog across the board isntead of swift-log
2019-04-10 17:45:54 +01:00
34 changed files with 1724 additions and 358 deletions

No files matched your search

+20
View File
@@ -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`)
+13
View File
@@ -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.]_
+3
View File
@@ -4,6 +4,9 @@
/*.xcodeproj
.xcode
DerivedData
.swiftpm
.SourceKitten/
docs/
.*.sw?
+15
View File
@@ -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
View File
@@ -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.
+70
View File
@@ -0,0 +1,70 @@
## Legal
By submitting a pull request, you represent that you have the right to license
your contribution to Apple and the community, and agree by submitting the patch
that your contributions are licensed under the Apache 2.0 license (see
`LICENSE.txt`).
## How to submit a bug report
Please ensure to specify the following:
* SwiftLog commit hash
* Contextual information (e.g. what you were trying to achieve with SwiftLog)
* Simplest possible steps to reproduce
* More complex the steps are, lower the priority will be.
* A pull request with failing test case is preferred, but it's just fine to paste the test case into the issue description.
* Anything that might be relevant in your opinion, such as:
* Swift version or the output of `swift --version`
* OS version and the output of `uname -a`
* Network configuration
### Example
```
SwiftLog commit hash: 4fe877816ad82627602377f415b6a66850214824
Context:
While testing my application that uses with SwiftLog, I noticed that ...
Steps to reproduce:
1. ...
2. ...
3. ...
4. ...
$ swift --version
Swift version 4.0.2 (swift-4.0.2-RELEASE)
Target: x86_64-unknown-linux-gnu
Operating system: Ubuntu Linux 16.04 64-bit
$ uname -a
Linux beefy.machine 4.4.0-101-generic #124-Ubuntu SMP Fri Nov 10 18:29:59 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
My system has IPv6 disabled.
```
## Writing a Patch
A good SwiftLog patch is:
1. Concise, and contains as few changes as needed to achieve the end result.
2. Tested, ensuring that any tests provided failed before the patch and pass after it.
3. Documented, adding API documentation as needed to cover new functions and properties.
4. Accompanied by a great commit message, using our commit message template.
### Commit Message Template
We require that your commit messages match our template. The easiest way to do that is to get git to help you by explicitly using the template. To do that, `cd` to the root of our repository and run:
git config commit.template dev/git.commit.template
### Make sure Tests work on Linux
SwiftLog uses XCTest to run tests on both macOS and Linux. While the macOS version of XCTest is able to use the Objective-C runtime to discover tests at execution time, the Linux version is not.
For this reason, whenever you add new tests **you have to run a script** that generates the hooks needed to run those tests on Linux, or our CI will complain that the tests are not all present on Linux. To do this, merely execute `ruby ./scripts/generate_linux_tests.rb` at the root of the package and check the changes it made.
## How to contribute your work
Please open a pull request at https://github.com/apple/swift-log. Make sure the CI passes, and then wait for code review.
+44
View File
@@ -0,0 +1,44 @@
The SwiftLog Project
========================
Please visit the SwiftLog web site for more information:
* https://github.com/apple/swift-log
Copyright 2018, 2019 The SwiftLog Project
The SwiftLog Project licenses this file to you under the Apache License,
version 2.0 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at:
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
License for the specific language governing permissions and limitations
under the License.
Also, please refer to each LICENSE.<component>.txt file, which is located in
the 'license' directory of the distribution file, for the license terms of the
components that this product depends on.
-------------------------------------------------------------------------------
This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
* LICENSE (Apache License 2.0):
* https://www.apache.org/licenses/LICENSE-2.0
* HOMEPAGE:
* https://codegists.com/snippet/ruby/generate_xctest_linux_runnerrb_tonystone_ruby
---
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
* HOMEPAGE:
* https://github.com/apple/swift-nio
+128 -16
View File
@@ -1,18 +1,18 @@
# swift-log
# 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.
A Logging API package for Swift. Version `1.0.0` requires Swift 5.0 but there is a version `0.x.y` series available for Swift 4 to ease your transition towards Swift 5. If you intend to use or support SwiftLog for Swift 4, please check the [paragraph](#help-i-need-swift-4) at the end of the document.
First things first: This is the beginning of a community-driven open-source project actively seeking contributions, be it code, documentation, or ideas. Apart from contributing to `swift-log` itself, there's another huge gap at the moment: `swift-log` 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 `swift-log`-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.
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 `swift-log` provides today can be found in the [API docs][api-docs].
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
`swift-log` 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, the `1.0.0` release requires Swift 5 (however we will soon tag a `0.x` version that will work with Swift 4 for the transition period). To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
```swift
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
@@ -21,7 +21,7 @@ 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(name: "BestExampleApp", dependencies: ["Logging"]),
```
#### Let's log
@@ -43,8 +43,37 @@ 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|
| ----------- | ----------- |
| [IBM-Swift/HeliumLogger](https://github.com/IBM-Swift/HeliumLogger) |a logging backend widely used in the Kitura ecosystem |
| [ianpartridge/swift-log-**syslog**](https://github.com/ianpartridge/swift-log-syslog) | a [syslog](https://en.wikipedia.org/wiki/Syslog) backend|
| [Adorkable/swift-log-**format-and-pipe**](https://github.com/Adorkable/swift-log-format-and-pipe) | a backend that allows customization of the output format and the resulting destination |
| [chrisaljoudi/swift-log-**oslog**](https://github.com/chrisaljoudi/swift-log-oslog) | an OSLog [Unified Logging](https://developer.apple.com/documentation/os/logging) backend for use on Apple platforms. **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) |
| [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 |
| 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.
@@ -54,15 +83,15 @@ In the real-world however, there are so many opinions over how exactly a logging
1. a logging API
2. a logging backend implementation
This package only provides the logging API itself and therefore `swift-log` is a 'logging API package'. `swift-log` (using `LoggingSystem.bootstrap`) can be configured to choose any compatible logging backend implementation. This way packages can adopt the API and the _application_ can choose any compatible logging backend implementation without requiring any changes from any of the libraries.
This package only provides the logging API itself and therefore `SwiftLog` is a 'logging API package'. `SwiftLog` (using `LoggingSystem.bootstrap`) can be configured to choose any compatible logging backend implementation. This way packages can adopt the API and the _application_ can choose any compatible logging backend implementation without requiring any changes from any of the libraries.
Just for completeness sake: This API package does actually include an overly simplistic and non-configurable logging backend implementation which simply writes all log messages to `stdout`. The reason to include this overly simplistic logging backend implementation is to improve the first-time usage experience. Let's assume you start a project and try out `swift-log` for the first time, it's just a whole lot better to see something you logged appear on `stdout` in a simplistic format rather than nothing happening at all. For any real-world application, we advise configuring another logging backend implementation that logs in the style you like.
Just for completeness sake: This API package does actually include an overly simplistic and non-configurable logging backend implementation which simply writes all log messages to `stdout`. The reason to include this overly simplistic logging backend implementation is to improve the first-time usage experience. Let's assume you start a project and try out `SwiftLog` for the first time, it's just a whole lot better to see something you logged appear on `stdout` in a simplistic format rather than nothing happening at all. For any real-world application, we advise configuring another logging backend implementation that logs in the style you like.
## The core concepts
### Loggers
`Logger`s are used to emit log messages and therefore the most important type in `swift-log`, so their use should be as simple as possible. Most commonly, they are used to emit log messages in a certain log level. For example:
`Logger`s are used to emit log messages and therefore the most important type in `SwiftLog`, so their use should be as simple as possible. Most commonly, they are used to emit log messages in a certain log level. For example:
```swift
// logging an informational message
@@ -74,16 +103,15 @@ logger.error("Houston, we have a problem: \(problem)")
### Log levels
The following log levels are supported, they match the [syslog severity levels](https://en.wikipedia.org/wiki/Syslog#Severity_level):
The following log levels are supported:
- `trace`
- `debug`
- `info`
- `notice`
- `warning`
- `error`
- `critical`
- `alert`
- `emergency`
The log level of a given logger can be changed, but the change will only affect the specific logger you changed it on. You could say the `Logger` is a _value type_ regarding the log level.
@@ -104,13 +132,13 @@ will print
2019-03-13T18:30:02+0000 info: request-uuid=F8633013-3DD8-481C-9256-B296E43443ED hello world
```
with the default logging backend implementation that ships with `swift-log`. Needless to say, the format is fully defined by the logging backend you choose.
with the default logging backend implementation that ships with `SwiftLog`. Needless to say, the format is fully defined by the logging backend you choose.
## On the implementation of a logging backend (a `LogHandler`)
Note: If you don't want to implement a custom logging backend, everything in this section is probably not very relevant, so please feel free to skip.
To become a compatible logging backend that all `swift-log` consumers can use, you need to do two things: 1) Implement a type (usually a `struct`) that implements `LogHandler`, a protocol provided by `swift-log` and 2) instruct `swift-log` to use your logging backend implementation.
To become a compatible logging backend that all `SwiftLog` consumers can use, you need to do two things: 1) Implement a type (usually a `struct`) that implements `LogHandler`, a protocol provided by `SwiftLog` and 2) instruct `SwiftLog` to use your logging backend implementation.
A `LogHandler` or logging backend implementation is anything that conforms to the following protocol
@@ -126,7 +154,7 @@ public protocol LogHandler {
}
```
Instructing `swift-log` to use your logging backend as the one the whole application (including all libraries) should use is very simple:
Instructing `SwiftLog` to use your logging backend as the one the whole application (including all libraries) should use is very simple:
LoggingSystem.bootstrap(MyLogHandler.init)
@@ -154,6 +182,90 @@ 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.
## SwiftLog for Swift 4
<a name="help-i-need-swift-4"></a>
First of, SwiftLog 1.0.x and SwiftLog 0.0.x are mostly compatible so don't be afraid. In fact, SwiftLog 0.0.0 is the same source code as SwiftLog 1.0.0 with a few changes made to make it Swift 4 compatible.
### How can I use SwiftLog 0 library or application?
If you have a application or a library that needs to be compatible with both Swift 4 and 5, then we recommend using the following in your `Package.swift`:
```swift
.package(url: "https://github.com/apple/swift-log.git", Version("0.0.0") ..< Version("2.0.0")),
```
This will instruct SwiftPM to allow any SwiftLog 0 and any SwiftLog 1 version. This is an unusual form because usually packages don't support multiple major versions of a package. Because SwiftLog 0 and 1 are mostly compatible however, this should not be a real issue and will enable everybody to get the best. If compiled with a Swift 4 compiler, this will be a SwiftLog 0 version but if compiled with a Swift 5 compiler everybody will get the best experience and performance delivered by SwiftLog 1.
In most cases, there is only one thing you need to remember: Always use _string literals_ and _string interpolations_ in the log methods and don't rely on the fact that SwiftLog 0 also allows `String`.
Good:
```swift
logger.info("hello world")
```
Bad:
```swift
let message = "hello world"
logger.info(message)
```
If you have a `String` that you received from elsewhere, please use
```swift
logger.info("\(stringIAlreadyHave)")
```
For more details, have a look in the next section.
### What are the differences between SwiftLog 1 and 0?
- SwiftLog 0 does not use `@inlinable`.
- Apart from accepting `Logger.Message` for the message, SwiftLog 0 has a `String` overload.
- In SwiftLog 0, `Logger.Message` is not `ExpressibleByStringLiteral` or `ExpressibleByStringInterpolation`.
- In SwiftLog 0, `Logger.MetadataValue` is not `ExpressibleByStringLiteral` or `ExpressibleByStringInterpolation`.
#### Why these differences?
##### @inlinable
Swift 4.0 & 4.1 don't support `@inlinable`, so SwiftLog 0 can't use them.
##### Logger.Message
Because all Swift 4 versions don't have a (non-deprecated) mechanism for a type to be `ExpressibleByStringInterpolation` we couldn't make `Logger.Message` expressible by string literals. Unfortunately, the most basic form of our logging API is `logger.info("Hello \(world)")`. For this to work however, `"Hello \(world)"` needs to be accepted and because we can't make `Logger.Message` `ExpressibleByStringInterpolation` we added an overload for all the logging methods to also accept `String`. In most cases, you won't even notice that with SwiftLog 0 you're creating a `String` (which is then transformed to a `Logger.Message`) and with SwiftLog 1 you're creating a `Logger.Message` directly. That is because both `String` and `Logger.Message` will accept all forms of string literals and string interpolations.
Unfortunately, there is code that will make this seemingly small difference visible. If you write
```swift
let message = "Hello world"
logger.info(message)
```
then this will only work in SwiftLog 0 and not in SwiftLog 1. Why? Because SwiftLog 1 will want a `Logger.Message` but `let message = "Hello world"` will make `message` to be of type `String` and in SwiftLog 1, the logging methods don't accept `String`s.
So if you intend to be compatible with SwiftLog 0 and 1 at the same time, please make sure to always use a _string literal_ or a _string interpolation_ inside of the logging methods.
In the case that you already have a `String` handy that you want to log, don't worry at all, just use
```swift
let message = "Hello world"
logger.info("\(message)")
```
and again, you will be okay with SwiftLog 0 and 1.
## Design
This logging API was designed with the contributors to the Swift on Server community and approved by the [SSWG (Swift Server Work Group)](https://swift.org/server/) to the 'sandbox level' of the SSWG's [incubation process](https://github.com/swift-server/sswg/blob/master/process/incubation.md).
+111 -32
View File
@@ -11,29 +11,65 @@
// 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
//
//===----------------------------------------------------------------------===//
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
import Darwin
import Darwin
#elseif os(Windows)
import WinSDK
#else
import Glibc
import Glibc
#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 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 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 {
#if os(Windows)
// SRWLOCK does not need to be free'd
#else
let err = pthread_mutex_destroy(self.mutex)
precondition(err == 0)
precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
#endif
self.mutex.deallocate()
}
@@ -42,8 +78,12 @@ internal final class Lock {
/// Whenever possible, consider using `withLock` instead of this method and
/// `unlock`, to simplify lock handling.
public func lock() {
#if 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.
@@ -51,8 +91,12 @@ internal final class Lock {
/// Whenever possible, consider using `withLock` instead of this method and
/// `lock`, to simplify lock handling.
public func unlock() {
#if 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
}
}
@@ -81,62 +125,97 @@ 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 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 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 {
#if os(Windows)
// SRWLOCK does not need to be free'd
#else
let err = pthread_rwlock_destroy(self.rwlock)
precondition(err == 0)
precondition(err == 0, "\(#function) failed in pthread_rwlock with error \(err)")
#endif
self.rwlock.deallocate()
}
/// 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 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 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 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 {
@@ -149,11 +228,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 {
+46 -11
View File
@@ -15,7 +15,7 @@
/// 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 swift-log API, please refer to the documentation of `Logger`.
/// To use the SwiftLog API, please refer to the documentation of `Logger`.
///
/// # Implementation requirements
///
@@ -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
/// }
/// }
/// ```
@@ -120,13 +122,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 +162,27 @@ public protocol LogHandler {
/// `LogHandler`.
var logLevel: Logger.Level { get set }
}
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)
}
}
+323 -120
View File
@@ -13,14 +13,20 @@
//===----------------------------------------------------------------------===//
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
import Darwin
import Darwin
#elseif os(Windows)
import MSVCRT
#else
import Glibc
import Glibc
#endif
/// A `Logger` is the central type in `swift-log`. Its central function is to emit log messages using one of the methods
/// A `Logger` is the central type in `SwiftLog`. Its central function is to emit log messages using one of the methods
/// corresponding to a log level.
///
/// `Logger`s are value types with respect to the `logLevel` and the `metadata` (as well as the immutable `label`
/// and the selected `LogHandler`). Therefore, `Logger`s are suitable to be passed around between libraries if you want
/// to preserve metadata across libraries.
///
/// The most basic usage of a `Logger` is
///
/// logger.info("Hello World!")
@@ -28,6 +34,8 @@
public struct Logger {
@usableFromInline
var handler: LogHandler
/// An identifier of the creator of this `Logger`.
public let label: String
internal init(label: String, _ handler: LogHandler) {
@@ -45,22 +53,26 @@ extension Logger {
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func log(level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
if self.logLevel <= level {
self.handler.log(level: level,
message: message(),
metadata: metadata(),
source: source() ?? Logger.currentModule(filePath: (file)),
file: file, function: function, line: line)
}
}
@@ -97,48 +109,52 @@ extension Logger {
}
extension Logger {
/// Log a message passing with the `Logger.trace` log level.
/// Log a message passing with the `Logger.Level.trace` log level.
///
/// If `.trace` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func trace(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .trace, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .trace, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.info` log level.
/// Log a message passing with the `Logger.Level.debug` log level.
///
/// If `.debug` is at least as severe as the `Logger`'s `logLevel`, it will be logged,
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func debug(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .debug, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .debug, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.Level.info` log level.
@@ -147,20 +163,22 @@ extension Logger {
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func info(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .info, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .info, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.Level.notice` log level.
@@ -169,20 +187,22 @@ extension Logger {
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func notice(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .notice, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .notice, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.Level.warning` log level.
@@ -191,20 +211,22 @@ extension Logger {
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func warning(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .warning, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .warning, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.Level.error` log level.
@@ -213,20 +235,22 @@ extension Logger {
/// otherwise nothing will happen.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func error(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .error, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .error, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
/// Log a message passing with the `Logger.Level.critical` log level.
@@ -234,20 +258,22 @@ extension Logger {
/// `.critical` messages will always be logged.
///
/// - parameters:
/// - level: The log level to log `message` at. For the available log levels, see `Logger.Level`.
/// - message: The message to be logged. `message` can be used with any string interpolation literal.
/// - metadata: One-off metadata to attach to this log message
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log messages originates to. Currently, it defaults to the folder containing the
/// file that is emitting the log message, which usually is the module.
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#file`.
/// defaults to `#file`).
/// - function: The function this log message originates from (there's usually no need to pass it explicitly as
/// it defaults to `#file`.
/// it defaults to `#function`).
/// - line: The line this log message originates from (there's usually no need to pass it explicitly as it
/// defaults to `#line`.
/// defaults to `#line`).
@inlinable
public func critical(_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #file, function: String = #function, line: UInt = #line) {
self.log(level: .critical, message(), metadata: metadata(), file: file, function: function, line: line)
self.log(level: .critical, message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
}
}
@@ -256,17 +282,17 @@ extension Logger {
/// implementation.
public enum LoggingSystem {
fileprivate static let lock = ReadWriteLock()
fileprivate static var factory: (String) -> LogHandler = StdoutLogHandler.init
fileprivate static var factory: (String) -> LogHandler = StreamLogHandler.standardOutput
fileprivate static var initialized = false
/// `bootstrap` is a one-time configuration function which globally selects the desired logging backend
/// implementation. `bootstrap` can be called at maximum once in any given program, calling it more than once will
/// lead to undefined behaviour, most likely a crash.
/// lead to undefined behavior, most likely a crash.
///
/// - parameters:
/// - factory: A closure that given a `Logger` identifier, produces an instance of the `LogHandler`.
public static func bootstrap(_ factory: @escaping (String) -> LogHandler) {
lock.withWriterLock {
self.lock.withWriterLock {
precondition(!self.initialized, "logging system can only be initialized once per process.")
self.factory = factory
self.initialized = true
@@ -286,26 +312,48 @@ extension Logger {
public typealias Metadata = [String: MetadataValue]
/// A logging metadata value. `Logger.MetadataValue` is string, array, and dictionary literal convertible.
///
/// `MetadataValue` provides convenient conformances to `ExpressibleByStringInterpolation`,
/// `ExpressibleByStringLiteral`, `ExpressibleByArrayLiteral`, and `ExpressibleByDictionaryLiteral` which means
/// that when constructing `MetadataValue`s you should default to using Swift's usual literals.
///
/// Examples:
/// - prefer `logger.info("user logged in", metadata: ["user-id": "\(user.id)"])` over
/// `..., metadata: ["user-id": .string(user.id.description)])`
/// - prefer `logger.info("user selected colors", metadata: ["colors": ["\(user.topColor)", "\(user.secondColor)"]])`
/// over `..., metadata: ["colors": .array([.string("\(user.topColor)"), .string("\(user.secondColor)")])`
/// - prefer `logger.info("nested info", metadata: ["nested": ["fave-numbers": ["\(1)", "\(2)", "\(3)"], "foo": "bar"]])`
/// over `..., metadata: ["nested": .dictionary(["fave-numbers": ...])])`
public enum MetadataValue {
/// A metadata value which is a `String`.
///
/// Because `MetadataValue` implements `ExpressibleByStringInterpolation`, and `ExpressibleByStringLiteral`,
/// you don't need to type `.string(someType.description)` you can use the string interpolation `"\(someType)"`.
case string(String)
/// A metadata value which is some `CustomStringConvertible`.
case stringConvertible(CustomStringConvertible)
/// A metadata value which is a dictionary from `String` to `Logger.MetadataValue`.
///
/// Because `MetadataValue` implements `ExpressibleByDictionaryLiteral`, you don't need to type
/// `.dictionary(["foo": .string("bar \(buz)")])`, you can just use the more natural `["foo": "bar \(buz)"]`.
case dictionary(Metadata)
/// A metadata value which is an array of `Logger.MetadataValue`s.
///
/// Because `MetadataValue` implements `ExpressibleByArrayLiteral`, you don't need to type
/// `.array([.string("foo"), .string("bar \(buz)")])`, you can just use the more natural `["foo", "bar \(buz)"]`.
case array([Metadata.Value])
}
/// The log level.
///
/// Raw values of log levels correspond to their severity, and are ordered by lowest numeric value (0) being
/// the most severe. The raw values match the syslog values.
public enum Level {
/// Appropriate for messages that contain information only when debugging a program.
/// Log levels are ordered by their severity, with `.trace` being the least severe and
/// `.critical` being the most severe.
public enum Level: String, Codable, CaseIterable {
/// Appropriate for messages that contain information normally of use only when
/// tracing the execution of a program.
case trace
/// Appropriate for messages that contain information normally of use only when
@@ -326,7 +374,7 @@ extension Logger {
/// Appropriate for error conditions.
case error
/// Appropriate for criticial error conditions that usually require immediate
/// Appropriate for critical error conditions that usually require immediate
/// attention.
///
/// When a `critical` message is logged, the logging backend (`LogHandler`) is free to perform
@@ -422,10 +470,7 @@ extension Logger {
///
/// logger.info("Hello \(world)")
///
public struct Message: ExpressibleByStringLiteral,
Equatable,
CustomStringConvertible,
ExpressibleByStringInterpolation {
public struct Message: ExpressibleByStringLiteral, Equatable, CustomStringConvertible, ExpressibleByStringInterpolation {
public typealias StringLiteralType = String
private var value: String
@@ -442,49 +487,109 @@ extension Logger {
/// A pseudo-`LogHandler` that can be used to send messages to multiple other `LogHandler`s.
///
/// The first `LogHandler` passed to the initialisation function of `MultiplexLogHandler` control the `logLevel` as
/// well as the `metadata` for this `LogHandler`. Any subsequent `LogHandler`s used to initialise a
/// `MultiplexLogHandler` are merely to emit the log message to another place.
/// ### Effective Logger.Level
///
/// When first initialized the multiplex log handlers' log level is automatically set to the minimum of all the
/// passed in log handlers. This ensures that each of the handlers will be able to log at their appropriate level
/// any log events they might be interested in.
///
/// Example:
/// If log handler `A` is logging at `.debug` level, and log handler `B` is logging at `.info` level, the constructed
/// `MultiplexLogHandler([A, B])`'s effective log level will be set to `.debug`, meaning that debug messages will be
/// handled by this handler, while only logged by the underlying `A` log handler (since `B`'s log level is `.info`
/// and thus it would not actually log that log message).
///
/// If the log level is _set_ on a `Logger` backed by an `MultiplexLogHandler` the log level will apply to *all*
/// underlying log handlers, allowing a logger to still select at what level it wants to log regardless of if the underlying
/// handler is a multiplex or a normal one. If for some reason one might want to not allow changing a log level of a specific
/// handler passed into the multiplex log handler, this is possible by wrapping it in a handler which ignores any log level changes.
///
/// ### Effective Logger.Metadata
///
/// Since a `MultiplexLogHandler` is a combination of multiple log handlers, the handling of metadata can be non-obvious.
/// For example, the underlying log handlers may have metadata of their own set before they are used to initialize the multiplex log handler.
///
/// The multiplex log handler acts purely as proxy and does not make any changes to underlying handler metadata other than
/// proxying writes that users made on a `Logger` instance backed by this handler.
///
/// Setting metadata is always proxied through to _all_ underlying handlers, meaning that if a modification like
/// `logger[metadataKey: "x"] = "y"` is made, all underlying log handlers that this multiplex handler was initiated with
/// will observe this change.
///
/// Reading metadata from the multiplex log handler MAY need to pick one of conflicting values if the underlying log handlers
/// were already initiated with some metadata before passing them into the multiplex handler. The multiplex handler uses
/// the order in which the handlers were passed in during its initialization as a priority indicator - the first handler's
/// values are more important than the next handlers values, etc.
///
/// Example:
/// If the multiplex log handler was initiated with two handlers like this: `MultiplexLogHandler([handler1, handler2])`.
/// The handlers each have some already set metadata: `handler1` has metadata values for keys `one` and `all`, and `handler2`
/// has values for keys `two` and `all`.
///
/// A query through the multiplex log handler the key `one` naturally returns `handler1`'s value, and a query for `two`
/// naturally returns `handler2`'s value. Querying for the key `all` will return `handler1`'s value, as that handler was indicated
/// "more important" than the second handler. The same rule applies when querying for the `metadata` property of the
/// multiplex log handler - it constructs `Metadata` uniquing values.
public struct MultiplexLogHandler: LogHandler {
private var handlers: [LogHandler]
private var effectiveLogLevel: Logger.Level
/// Create a `MultiplexLogHandler`.
///
/// - parameters:
/// - handlers: An array of `LogHandler`s, each of which will receive the log messages sent to this `Logger`.
/// The array must not be empty.
public init(_ handlers: [LogHandler]) {
assert(handlers.count > 0)
assert(!handlers.isEmpty, "MultiplexLogHandler.handlers MUST NOT be empty")
self.handlers = handlers
self.effectiveLogLevel = handlers.map { $0.logLevel }.min() ?? .trace
}
public var logLevel: Logger.Level {
get {
return self.handlers[0].logLevel
return self.effectiveLogLevel
}
set {
self.mutatingForEachHandler {
$0.logLevel = newValue
}
self.mutatingForEachHandler { $0.logLevel = newValue }
self.effectiveLogLevel = newValue
}
}
public func log(level: Logger.Level,
message: Logger.Message,
metadata: Logger.Metadata?,
file: String, function: String, line: UInt) {
self.handlers.forEach { handler in
handler.log(level: level, message: message, metadata: metadata, file: file, function: function, line: line)
source: String,
file: String,
function: String,
line: UInt) {
for handler in self.handlers where handler.logLevel <= level {
handler.log(level: level, message: message, metadata: metadata, source: source, file: file, function: function, line: line)
}
}
public var metadata: Logger.Metadata {
get {
return self.handlers[0].metadata
var effectiveMetadata: Logger.Metadata = [:]
// as a rough estimate we assume that the underlying handlers have a similar metadata count,
// and we use the first one's current count to estimate how big of a dictionary we need to allocate:
effectiveMetadata.reserveCapacity(self.handlers.first!.metadata.count) // !-safe, we always have at least one handler
return self.handlers.reduce(into: effectiveMetadata) { effectiveMetadata, handler in
effectiveMetadata.merge(handler.metadata, uniquingKeysWith: { l, _ in l })
}
}
set {
self.mutatingForEachHandler { $0.metadata = newValue }
}
}
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
public subscript(metadataKey metadataKey: Logger.Metadata.Key) -> Logger.Metadata.Value? {
get {
return self.handlers[0].metadata[metadataKey]
for handler in self.handlers {
if let value = handler[metadataKey: metadataKey] {
return value
}
}
return nil
}
set {
self.mutatingForEachHandler { $0[metadataKey: metadataKey] = newValue }
@@ -498,62 +603,117 @@ public struct MultiplexLogHandler: LogHandler {
}
}
/// Ships with the logging module, really boring just prints something using the `print` function
internal struct StdoutLogHandler: LogHandler {
private let lock = Lock()
/// A wrapper to facilitate `print`-ing to stderr and stdio that
/// ensures access to the underlying `FILE` is locked to prevent
/// cross-thread interleaving of output.
internal struct StdioOutputStream: TextOutputStream {
internal let file: UnsafeMutablePointer<FILE>
internal let flushMode: FlushMode
public init(label: String) {}
private var _logLevel: Logger.Level = .info
public var logLevel: Logger.Level {
get {
return self.lock.withLock { self._logLevel }
}
set {
self.lock.withLock {
self._logLevel = newValue
internal func write(_ string: String) {
string.withCString { ptr in
#if os(Windows)
_lock_file(self.file)
#else
flockfile(self.file)
#endif
defer {
#if os(Windows)
_unlock_file(self.file)
#else
funlockfile(self.file)
#endif
}
_ = fputs(ptr, self.file)
if case .always = self.flushMode {
self.flush()
}
}
}
/// Flush the underlying stream.
/// This has no effect when using the `.always` flush mode, which is the default
internal func flush() {
_ = fflush(self.file)
}
internal static let stderr = StdioOutputStream(file: systemStderr, flushMode: .always)
internal static let stdout = StdioOutputStream(file: systemStdout, flushMode: .always)
/// Defines the flushing strategy for the underlying stream.
internal enum FlushMode {
case undefined
case always
}
}
// Prevent name clashes
#if os(macOS) || os(tvOS) || os(iOS) || os(watchOS)
let systemStderr = Darwin.stderr
let systemStdout = Darwin.stdout
#elseif os(Windows)
let systemStderr = MSVCRT.stderr
let systemStdout = MSVCRT.stdout
#else
let systemStderr = Glibc.stderr!
let systemStdout = Glibc.stdout!
#endif
/// `StreamLogHandler` is a simple implementation of `LogHandler` for directing
/// `Logger` output to either `stderr` or `stdout` via the factory methods.
public struct StreamLogHandler: LogHandler {
/// Factory that makes a `StreamLogHandler` to directs its output to `stdout`
public static func standardOutput(label: String) -> StreamLogHandler {
return StreamLogHandler(label: label, stream: StdioOutputStream.stdout)
}
/// Factory that makes a `StreamLogHandler` to directs its output to `stderr`
public static func standardError(label: String) -> StreamLogHandler {
return StreamLogHandler(label: label, stream: StdioOutputStream.stderr)
}
private let stream: TextOutputStream
private let label: String
public var logLevel: Logger.Level = .info
private var prettyMetadata: String?
private var _metadata = Logger.Metadata() {
public var metadata = Logger.Metadata() {
didSet {
self.prettyMetadata = self.prettify(self._metadata)
}
}
public func log(level: Logger.Level,
message: Logger.Message,
metadata: Logger.Metadata?,
file: String, function: String, line: UInt) {
let prettyMetadata = metadata?.isEmpty ?? true
? self.prettyMetadata
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
print("\(self.timestamp()) \(level):\(prettyMetadata.map { " \($0)" } ?? "") \(message)")
}
public var metadata: Logger.Metadata {
get {
return self.lock.withLock { self._metadata }
}
set {
self.lock.withLock { self._metadata = newValue }
self.prettyMetadata = self.prettify(self.metadata)
}
}
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
get {
return self.lock.withLock { self._metadata[metadataKey] }
return self.metadata[metadataKey]
}
set {
self.lock.withLock {
self._metadata[metadataKey] = newValue
}
self.metadata[metadataKey] = newValue
}
}
// internal for testing only
internal init(label: String, stream: TextOutputStream) {
self.label = label
self.stream = stream
}
public func log(level: Logger.Level,
message: Logger.Message,
metadata: Logger.Metadata?,
source: String,
file: String,
function: String,
line: UInt) {
let prettyMetadata = metadata?.isEmpty ?? true
? self.prettyMetadata
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
var stream = self.stream
stream.write("\(self.timestamp()) \(level) \(self.label) :\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
}
private func prettify(_ metadata: Logger.Metadata) -> String? {
return !metadata.isEmpty ? metadata.map { "\($0)=\($1)" }.joined(separator: " ") : nil
}
@@ -571,8 +731,50 @@ internal struct StdoutLogHandler: LogHandler {
}
}
/// No operation LogHandler, used when no logging is required
public struct SwiftLogNoOpLogHandler: LogHandler {
public init() {}
@inlinable public func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {}
@inlinable public subscript(metadataKey _: String) -> Logger.Metadata.Value? {
get {
return nil
}
set {}
}
@inlinable public var metadata: Logger.Metadata {
get {
return [:]
}
set {}
}
@inlinable public var logLevel: Logger.Level {
get {
return .critical
}
set {}
}
}
extension Logger {
@inlinable
internal static func currentModule(filePath: String = #file) -> String {
let utf8All = filePath.utf8
return filePath.utf8.lastIndex(of: UInt8(ascii: "/")).flatMap { lastSlash -> Substring? in
utf8All[..<lastSlash].lastIndex(of: UInt8(ascii: "/")).map { secondLastSlash -> Substring in
filePath[utf8All.index(after: secondLastSlash) ..< lastSlash]
}
}.map {
String($0)
} ?? "n/a"
}
}
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
// https://bugs.swift.org/browse/SR-9687
// https://bugs.swift.org/browse/SR-9686
extension Logger.MetadataValue: ExpressibleByStringLiteral {
public typealias StringLiteralType = String
@@ -581,6 +783,8 @@ extension Logger.MetadataValue: ExpressibleByStringLiteral {
}
}
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
// https://bugs.swift.org/browse/SR-9686
extension Logger.MetadataValue: CustomStringConvertible {
public var description: String {
switch self {
@@ -598,11 +802,10 @@ extension Logger.MetadataValue: CustomStringConvertible {
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
// https://bugs.swift.org/browse/SR-9687
extension Logger.MetadataValue: ExpressibleByStringInterpolation {
}
extension Logger.MetadataValue: ExpressibleByStringInterpolation {}
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
// https://bugs.swift.org/browse/SR-9687
// https://bugs.swift.org/browse/SR-9686
extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
public typealias Key = String
public typealias Value = Logger.Metadata.Value
@@ -613,7 +816,7 @@ extension Logger.MetadataValue: ExpressibleByDictionaryLiteral {
}
// Extension has to be done on explicit type rather than Logger.Metadata.Value as workaround for
// https://bugs.swift.org/browse/SR-9687
// https://bugs.swift.org/browse/SR-9686
extension Logger.MetadataValue: ExpressibleByArrayLiteral {
public typealias ArrayLiteralElement = Logger.Metadata.Value
+8 -7
View File
@@ -23,12 +23,13 @@ import XCTest
///
#if os(Linux) || os(FreeBSD)
@testable import LoggingTests
@testable import LoggingTests
XCTMain([
testCase(GlobalLoggerTest.allTests),
testCase(LocalLoggerTest.allTests),
testCase(LoggingTest.allTests),
testCase(MDCTest.allTests),
])
XCTMain([
testCase(CompatibilityTest.allTests),
testCase(GlobalLoggerTest.allTests),
testCase(LocalLoggerTest.allTests),
testCase(LoggingTest.allTests),
testCase(MDCTest.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),
]
}
}
+3 -3
View File
@@ -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),
]
}
}
+5 -5
View File
@@ -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")
@@ -65,8 +65,8 @@ class LocalLoggerTest: XCTestCase {
logging.history.assertNotExist(level: .info, message: "TestLibrary::doSomethingAsync") // global context
logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::Local", metadata: ["bar": "baz", "baz": "qux"]) // hyper local context
logging.history.assertExist(level: .debug, message: "Struct3::doSomethingElse::end", metadata: ["bar": "baz"]) // local context
logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end", metadata: ["bar": "baz"]) // local context
logging.history.assertExist(level: .debug, message: "Struct2::doSomethingElse::end") // local context
logging.history.assertExist(level: .debug, message: "Struct3::doSomething::end", metadata: ["bar": "baz"]) // local context
logging.history.assertNotExist(level: .debug, message: "Struct1::doSomethingElse::end") // global context
logging.history.assertNotExist(level: .debug, message: "Struct1::doSomething::end") // global context
}
@@ -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()
+29 -21
View File
@@ -23,25 +23,33 @@ 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),
("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),
("testLogMessageWithStringInterpolation", testLogMessageWithStringInterpolation),
("testLoggingAString", testLoggingAString),
("testMultiplexerIsValue", testMultiplexerIsValue),
("testLoggerWithGlobalOverride", testLoggerWithGlobalOverride),
("testLogLevelCases", testLogLevelCases),
("testLogLevelOrdering", testLogLevelOrdering),
("testStreamLogHandlerWritesToAStream", testStreamLogHandlerWritesToAStream),
("testStreamLogHandlerOutputFormat", testStreamLogHandlerOutputFormat),
("testStreamLogHandlerOutputFormatWithMetaData", testStreamLogHandlerOutputFormatWithMetaData),
("testStdioOutputStreamFlush", testStdioOutputStreamFlush),
("testOverloadingError", testOverloadingError),
]
}
}
+328 -17
View File
@@ -14,6 +14,12 @@
@testable import Logging
import XCTest
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
import Darwin
#else
import Glibc
#endif
class LoggingTest: XCTestCase {
func testAutoclosure() throws {
// bootstrap with our test logging impl
@@ -23,10 +29,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 +61,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 +74,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
}
@@ -108,7 +262,7 @@ class LoggingTest: XCTestCase {
// Not thread-safe, thus should not be shared across threads.
internal class LazyMetadataBox: CustomStringConvertible {
private var makeValue: (() -> String)?
private var _value: String? = nil
private var _value: String?
public init(_ makeValue: @escaping () -> String) {
self.makeValue = makeValue
@@ -137,17 +291,17 @@ 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 {
XCTFail("should not have been evaluated", file: file, line: line)
XCTFail("should not have been evaluated", file: (file), line: line)
return "should not have been evaluated"
}
@@ -182,7 +336,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 }
@@ -261,7 +415,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)
@@ -284,12 +438,12 @@ class LoggingTest: XCTestCase {
}
func testMultiplexerIsValue() {
let multi = MultiplexLogHandler([StdoutLogHandler(label: "x"), StdoutLogHandler(label: "y")])
let multi = MultiplexLogHandler([StreamLogHandler.standardOutput(label: "x"), StreamLogHandler.standardOutput(label: "y")])
LoggingSystem.bootstrapInternal { _ in
print("new multi")
return multi
}
var logger1: Logger = {
let logger1: Logger = {
var logger = Logger(label: "foo")
logger.logLevel = .debug
logger[metadataKey: "only-on"] = "first"
@@ -310,7 +464,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 +481,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 +492,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 +515,7 @@ class LoggingTest: XCTestCase {
let logRecorder = Recorder()
LoggingSystem.bootstrapInternal { _ in
return LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
}
var logger1 = Logger(label: "logger-\(#file):\(#line)")
@@ -389,6 +543,11 @@ class LoggingTest: XCTestCase {
logRecorder.assertExist(level: .notice, message: "logger2, after")
}
func testLogLevelCases() {
let levels = Logger.Level.allCases
XCTAssertEqual(7, levels.count)
}
func testLogLevelOrdering() {
XCTAssertLessThan(Logger.Level.trace, Logger.Level.debug)
XCTAssertLessThan(Logger.Level.trace, Logger.Level.info)
@@ -412,4 +571,156 @@ 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 { _ in
StreamLogHandler(label: label, stream: interceptStream)
}
let log = Logger(label: label)
let testString = "my message is better than yours"
log.critical("\(testString)")
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\s\(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 { _ in
StreamLogHandler(label: label, stream: interceptStream)
}
let log = Logger(label: label)
let testString = "my message is better than yours"
log.critical("\(testString)", metadata: ["test": "test"])
let pattern = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\stest=test\\s\(testString)$"
let messageSucceeded = interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(of: pattern, options: .regularExpression) != nil
XCTAssertTrue(messageSucceeded)
XCTAssertEqual(interceptStream.strings.count, 1)
}
func testStdioOutputStreamFlush() {
// flush on every statement
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
let logStream = StdioOutputStream(file: writeFD, flushMode: .always)
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
Logger(label: "test").critical("test")
let size = read(readFD, readBuffer, 256)
XCTAssertGreaterThan(size, -1, "expected flush")
logStream.flush()
let size2 = read(readFD, readBuffer, 256)
XCTAssertEqual(size2, -1, "expected no flush")
}
// default flushing
self.withWriteReadFDsAndReadBuffer { writeFD, readFD, readBuffer in
let logStream = StdioOutputStream(file: writeFD, flushMode: .undefined)
LoggingSystem.bootstrapInternal { StreamLogHandler(label: $0, stream: logStream) }
Logger(label: "test").critical("test")
let size = read(readFD, readBuffer, 256)
XCTAssertEqual(size, -1, "expected no flush")
logStream.flush()
let size2 = read(readFD, readBuffer, 256)
XCTAssertGreaterThan(size2, -1, "expected flush")
}
}
func withWriteReadFDsAndReadBuffer(_ body: (UnsafeMutablePointer<FILE>, CInt, UnsafeMutablePointer<Int8>) -> Void) {
var fds: [Int32] = [-1, -1]
fds.withUnsafeMutableBufferPointer { ptr in
let err = pipe(ptr.baseAddress!)
XCTAssertEqual(err, 0, "pipe faild \(err)")
}
let writeFD = fdopen(fds[1], "w")
let writeBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: 256)
defer {
writeBuffer.deinitialize(count: 256)
writeBuffer.deallocate()
}
var err = setvbuf(writeFD, writeBuffer, _IOFBF, 256)
XCTAssertEqual(err, 0, "setvbuf faild \(err)")
let readFD = fds[0]
err = fcntl(readFD, F_SETFL, fcntl(readFD, F_GETFL) | O_NONBLOCK)
XCTAssertEqual(err, 0, "fcntl faild \(err)")
let readBuffer = UnsafeMutablePointer<Int8>.allocate(capacity: 256)
defer {
readBuffer.deinitialize(count: 256)
readBuffer.deallocate()
}
// the actual test
body(writeFD!, readFD, readBuffer)
fds.forEach { close($0) }
}
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(Dummy())
logging.history.assertExist(level: .error, message: "errorDescription")
}
}
extension Logger {
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)
}
}
+5 -7
View File
@@ -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),
]
}
}
+37 -21
View File
@@ -39,14 +39,14 @@ internal struct TestLogHandler: LogHandler {
self.label = label
self.config = config
self.recorder = recorder
self.logger = Logger(label: "test", StdoutLogHandler(label: label))
self.logger = Logger(label: "test", StreamLogHandler.standardOutput(label: label))
self.logger.logLevel = .debug
}
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) {
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)
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?
@@ -123,9 +123,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 +170,40 @@ 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)
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, 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,
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)
}
func find(level: Logger.Level, message: String, metadata: Logger.Metadata? = nil) -> LogEntry? {
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 ?? [:]
entry.metadata ?? [:] == metadata ?? [:] &&
entry.source == source
}
}
}
@@ -208,7 +224,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 +268,11 @@ public class MDC {
}
private var threadId: Int {
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
return Int(pthread_mach_thread_np(pthread_self()))
#else
return Int(pthread_self())
#endif
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
return Int(pthread_mach_thread_np(pthread_self()))
#else
return Int(pthread_self())
#endif
}
}
@@ -284,7 +300,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()
+14
View File
@@ -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 -45
View File
@@ -1,56 +1,36 @@
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
# 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
# script to allow mapping framepointers on linux (until part of the toolchain)
RUN wget -q https://raw.githubusercontent.com/apple/swift/master/utils/symbolicate-linux-fatal -O $HOME/.tools/symbolicate-linux-fatal
RUN chmod 755 $HOME/.tools/symbolicate-linux-fatal
# 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
# swiftformat (until part of the toolchain)
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
+4 -3
View File
@@ -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
+18
View File
@@ -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
+18
View File
@@ -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
+17
View File
@@ -0,0 +1,17 @@
version: "3"
services:
runtime-setup:
image: swift-log:18.04-5.3
build:
args:
base_image: "swiftlang/swift:nightly-5.3-bionic"
test:
image: swift-log:18.04-5.3
environment: []
#- SANITIZER_ARG=--sanitize=thread
shell:
image: swift-log:18.04-5.3
+12 -3
View File
@@ -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:
<<: *common
command: /bin/bash -cl "./scripts/sanity.sh"
command: /bin/bash -xcl "./scripts/sanity.sh"
test:
<<: *common
command: /bin/bash -cl "swift test"
command: /bin/bash -xcl "swift test -Xswiftc -warnings-as-errors $${SANITIZER_ARG-}"
# util
shell:
<<: *common
entrypoint: /bin/bash
+94
View File
@@ -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
+136
View File
@@ -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
View File
@@ -13,7 +13,7 @@
##
##===----------------------------------------------------------------------===##
set -e
set -ex
my_path="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
root_path="$my_path/.."
@@ -51,28 +51,34 @@ 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 'swift-log team'
--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"
# swift-log Docs
# SwiftLog Docs
swift-log is a Swift 5 logging API package.
SwiftLog is a Swift logging API package.
To get started with swift-log, [`import Logging`](../Logging/index.html). The
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
+11 -11
View File
@@ -71,17 +71,17 @@ def createExtensionFile(fileName, classes)
file.write "\n"
for classArray in classes
file.write 'extension ' + classArray[0] + " {\n\n"
file.write ' static var allTests : [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
file.write " return [\n"
file.write 'extension ' + classArray[0] + " {\n"
file.write ' static var allTests: [(String, (' + classArray[0] + ") -> () throws -> Void)] {\n"
file.write " return [\n"
for funcName in classArray[1]
file.write ' ("' + funcName + '", ' + funcName + "),\n"
file.write ' ("' + funcName + '", ' + funcName + "),\n"
end
file.write " ]\n"
file.write " }\n"
file.write "}\n\n"
file.write " ]\n"
file.write " }\n"
file.write "}\n"
end
end
end
@@ -96,10 +96,10 @@ def createLinuxMain(testsDirectory, allTestSubDirectories, files)
file.write "#if os(Linux) || os(FreeBSD)\n"
for testSubDirectory in allTestSubDirectories.sort { |x, y| x <=> y }
file.write ' @testable import ' + testSubDirectory + "\n"
file.write '@testable import ' + testSubDirectory + "\n"
end
file.write "\n"
file.write " XCTMain([\n"
file.write "XCTMain([\n"
testCases = []
for classes in files
@@ -109,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
+38 -6
View File
@@ -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][78901]-20[12][8901]/YEARS/' -e 's/20[12][8901]/YEARS/'
}
printf "=> Checking linux tests... "
FIRST_OUT="$(git status --porcelain)"
ruby "$here/../scripts/generate_linux_tests.rb" > /dev/null
@@ -28,10 +47,23 @@ else
printf "\033[0;32mokay.\033[0m\n"
fi
printf "=> Checking license headers... "
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-sanity_XXXXXX)
for language in swift-or-c bash dtrace; do
printf " * $language... "
declare -a matching_files
declare -a exceptions
expections=( )
@@ -45,7 +77,7 @@ for language in swift-or-c bash dtrace; do
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Copyright (c) YEARS Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
@@ -64,7 +96,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 +115,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 +140,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