Compare commits

..
35 Commits
Author SHA1 Message Date
tomer doron f1a88bda3e improve 5.3 docker setup
motivation: pin to 5.3 nighties 

changes: use swiftlang/swift:nightly-5.3-master-bionic instead of swiftlang/swift:nightly-master-bionic
2020-05-04 22:23:27 -07: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
23 changed files with 607 additions and 139 deletions

No files matched your search

+3
View File
@@ -4,6 +4,9 @@
/*.xcodeproj
.xcode
DerivedData
.swiftpm
.SourceKitten/
docs/
.*.sw?
+7 -5
View File
@@ -1,11 +1,13 @@
# file options
--swiftversion 5.0
--exclude .build
# format options
--self insert
--patternlet inline
--stripunusedargs unnamed-only
--comments ignore
--self insert
--patternlet inline
--stripunusedargs unnamed-only
--ifdef no-indent
# rules
+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.
+39 -10
View File
@@ -6,7 +6,7 @@ First things first: This is the beginning of a community-driven open-source proj
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.
@@ -46,7 +46,7 @@ logger.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)
```
@@ -54,6 +54,25 @@ LoggingSystem.bootstrap(StreamLogHandler.standardError)
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)) |
| 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.
@@ -181,16 +200,22 @@ In most cases, there is only one thing you need to remember: Always use _string
Good:
logger.info("hello world")
```swift
logger.info("hello world")
```
Bad:
let message = "hello world"
logger.info(message)
```swift
let message = "hello world"
logger.info(message)
```
If you have a `String` that you received from elsewhere, please use
logger.info("\(stringIAlreadyHave)")
```swift
logger.info("\(stringIAlreadyHave)")
```
For more details, have a look in the next section.
@@ -212,8 +237,10 @@ Swift 4.0 & 4.1 don't support `@inlinable`, so SwiftLog 0 can't use them.
Because all Swift 4 versions don't have a (non-deprecated) mechanism for a type to be `ExpressibleByStringInterpolation` we couldn't make `Logger.Message` expressible by string literals. Unfortunately, the most basic form of our logging API is `logger.info("Hello \(world)")`. For this to work however, `"Hello \(world)"` needs to be accepted and because we can't make `Logger.Message` `ExpressibleByStringInterpolation` we added an overload for all the logging methods to also accept `String`. In most cases, you won't even notice that with SwiftLog 0 you're creating a `String` (which is then transformed to a `Logger.Message`) and with SwiftLog 1 you're creating a `Logger.Message` directly. That is because both `String` and `Logger.Message` will accept all forms of string literals and string interpolations.
Unfortunately, there is code that will make this seemingly small difference visible. If you write
let message = "Hello world"
logger.info(message)
```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.
@@ -221,8 +248,10 @@ So if you intend to be compatible with SwiftLog 0 and 1 at the same time, please
In the case that you already have a `String` handy that you want to log, don't worry at all, just use
let message = "Hello world"
logger.info("\(message)")
```swift
let message = "Hello world"
logger.info("\(message)")
```
and again, you will be okay with SwiftLog 0 and 1.
+61 -4
View File
@@ -27,9 +27,11 @@
//===----------------------------------------------------------------------===//
#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`.
@@ -38,17 +40,31 @@
/// of lock is safe to use with `libpthread`-based threading models, such as the
/// one used by NIO.
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() {
#if os(Windows)
InitializeSRWLock(self.mutex)
#else
let err = pthread_mutex_init(self.mutex, nil)
precondition(err == 0)
#endif
}
deinit {
#if os(Windows)
// SRWLOCK does not need to be free'd
#else
let err = pthread_mutex_destroy(self.mutex)
precondition(err == 0)
#endif
self.mutex.deallocate()
}
@@ -57,8 +73,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)
#endif
}
/// Release the lock.
@@ -66,8 +86,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)
#endif
}
}
@@ -102,17 +126,32 @@ extension Lock {
/// of lock is safe to use with `libpthread`-based threading models, such as the
/// one used by NIO.
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)
#endif
}
deinit {
#if os(Windows)
// SRWLOCK does not need to be free'd
#else
let err = pthread_rwlock_destroy(self.rwlock)
precondition(err == 0)
#endif
self.rwlock.deallocate()
}
@@ -121,8 +160,13 @@ internal final class ReadWriteLock {
/// Whenever possible, consider using `withLock` 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)
#endif
}
/// Acquire a writer lock.
@@ -130,8 +174,13 @@ internal final class ReadWriteLock {
/// Whenever possible, consider using `withLock` instead of this method and
/// `unlock`, to simplify lock handling.
public func lockWrite() {
#if os(Windows)
AcquireSRWLockExclusive(self.rwlock)
self.shared = true
#else
let err = pthread_rwlock_wrlock(self.rwlock)
precondition(err == 0)
#endif
}
/// Release the lock.
@@ -139,8 +188,16 @@ internal final class ReadWriteLock {
/// Whenever possible, consider using `withLock` instead of this method and
/// `lock`, 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)
#endif
}
}
+1 -1
View File
@@ -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"
///
+69 -27
View File
@@ -13,9 +13,11 @@
//===----------------------------------------------------------------------===//
#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 `SwiftLog`. Its central function is to emit log messages using one of the methods
@@ -105,7 +107,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -127,7 +128,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -149,7 +149,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -171,7 +170,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -193,7 +191,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -215,7 +212,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -236,7 +232,6 @@ 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
/// - file: The file this log message originates from (there's usually no need to pass it explicitly as it
@@ -288,26 +283,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 colours", metadata: ["colors": ["\(user.topColor)", "\(user.secondColor)"]])`
/// over `..., metadata: ["colors": .array([.string("\(user.topColor)"), .string("\(user.secondColor)")])`
/// - prefer `logger.info("nested info", metadata: ["nested": ["fave-numbers": ["\(1)", "\(2)", "\(3)"], "foo": "bar"]])`
/// over `..., metadata: ["nested": .dictionary(["fave-numbers": ...])])`
public enum MetadataValue {
/// A metadata value which is a `String`.
///
/// Because `MetadataValue` implements `ExpressibleByStringInterpolation`, and `ExpressibleByStringLiteral`,
/// you don't need to type `.string(someType.description)` you can use the string interpolation `"\(someType)"`.
case string(String)
/// A metadata value which is some `CustomStringConvertible`.
case stringConvertible(CustomStringConvertible)
/// A metadata value which is a dictionary from `String` to `Logger.MetadataValue`.
///
/// Because `MetadataValue` implements `ExpressibleByDictionaryLiteral`, you don't need to type
/// `.dictionary(["foo": .string("bar \(buz)")])`, you can just use the more natural `["foo": "bar \(buz)"]`.
case dictionary(Metadata)
/// A metadata value which is an array of `Logger.MetadataValue`s.
///
/// Because `MetadataValue` implements `ExpressibleByArrayLiteral`, you don't need to type
/// `.array([.string("foo"), .string("bar \(buz)")])`, you can just use the more natural `["foo", "bar \(buz)"]`.
case array([Metadata.Value])
}
/// The log level.
///
/// Raw values of log levels correspond to their severity, and are ordered by lowest numeric value (0) being
/// the most severe. The raw values match the syslog values.
public enum Level: CaseIterable {
/// 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
@@ -424,10 +441,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
@@ -510,25 +524,52 @@ public struct MultiplexLogHandler: LogHandler {
/// cross-thread interleaving of output.
internal struct StdioOutputStream: TextOutputStream {
internal let file: UnsafeMutablePointer<FILE>
internal let flushMode: FlushMode
internal func write(_ string: String) {
string.withCString { ptr in
flockfile(file)
#if os(Windows)
_lock_file(self.file)
#else
flockfile(self.file)
#endif
defer {
funlockfile(file)
#if os(Windows)
_unlock_file(self.file)
#else
funlockfile(self.file)
#endif
}
_ = fputs(ptr, self.file)
if case .always = self.flushMode {
self.flush()
}
_ = fputs(ptr, file)
}
}
internal static let stderr = StdioOutputStream(file: systemStderr)
internal static let stdout = StdioOutputStream(file: systemStdout)
/// 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!
@@ -537,7 +578,6 @@ let systemStdout = Glibc.stdout!
/// `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)
@@ -549,27 +589,29 @@ public struct StreamLogHandler: LogHandler {
}
private let stream: TextOutputStream
private let label: String
public var logLevel: Logger.Level = .info
private var prettyMetadata: String?
public var metadata = Logger.Metadata() {
didSet {
prettyMetadata = prettify(metadata)
self.prettyMetadata = self.prettify(self.metadata)
}
}
public subscript(metadataKey metadataKey: String) -> Logger.Metadata.Value? {
get {
return metadata[metadataKey]
return self.metadata[metadataKey]
}
set {
metadata[metadataKey] = newValue
self.metadata[metadataKey] = newValue
}
}
// internal for testing only
internal init(label: String, stream: TextOutputStream) {
self.label = label
self.stream = stream
}
@@ -582,7 +624,7 @@ public struct StreamLogHandler: LogHandler {
: self.prettify(self.metadata.merging(metadata!, uniquingKeysWith: { _, new in new }))
var stream = self.stream
stream.write("\(timestamp()) \(level):\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
stream.write("\(self.timestamp()) \(level) \(self.label) :\(prettyMetadata.map { " \($0)" } ?? "") \(message)\n")
}
private func prettify(_ metadata: Logger.Metadata) -> String? {
+7 -7
View File
@@ -23,12 +23,12 @@ import XCTest
///
#if os(Linux) || os(FreeBSD)
@testable import LoggingTests
@testable import LoggingTests
XCTMain([
testCase(GlobalLoggerTest.allTests),
testCase(LocalLoggerTest.allTests),
testCase(LoggingTest.allTests),
testCase(MDCTest.allTests),
])
XCTMain([
testCase(GlobalLoggerTest.allTests),
testCase(LocalLoggerTest.allTests),
testCase(LoggingTest.allTests),
testCase(MDCTest.allTests),
])
#endif
+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")
}
}
+3 -3
View File
@@ -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()
@@ -42,6 +42,10 @@ extension LoggingTest {
("testLogLevelCases", testLogLevelCases),
("testLogLevelOrdering", testLogLevelOrdering),
("testStreamLogHandlerWritesToAStream", testStreamLogHandlerWritesToAStream),
("testStreamLogHandlerOutputFormat", testStreamLogHandlerOutputFormat),
("testStreamLogHandlerOutputFormatWithMetaData", testStreamLogHandlerOutputFormatWithMetaData),
("testStdioOutputStreamFlush", testStdioOutputStreamFlush),
("testOverloadingError", testOverloadingError),
]
}
}
+142 -11
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
@@ -137,13 +143,13 @@ class LoggingTest: XCTestCase {
var logger = Logger(label: "\(#function)")
logger[metadataKey: "foo"] = .stringConvertible("raw-string")
let lazyBox = LazyMetadataBox({ "rendered-at-first-use" })
let lazyBox = LazyMetadataBox { "rendered-at-first-use" }
logger[metadataKey: "lazy"] = .stringConvertible(lazyBox)
logger.info("hello world!")
testLogging.history.assertExist(level: .info,
message: "hello world!",
metadata: ["foo": .stringConvertible("raw-string"),
"lazy": .stringConvertible(LazyMetadataBox({ "rendered-at-first-use" }))])
"lazy": .stringConvertible(LazyMetadataBox { "rendered-at-first-use" })])
}
private func dontEvaluateThisString(file: StaticString = #file, line: UInt = #line) -> Logger.Message {
@@ -289,7 +295,7 @@ class LoggingTest: XCTestCase {
print("new multi")
return multi
}
var logger1: Logger = {
let logger1: Logger = {
var logger = Logger(label: "foo")
logger.logLevel = .debug
logger[metadataKey: "only-on"] = "first"
@@ -361,7 +367,7 @@ class LoggingTest: XCTestCase {
let logRecorder = Recorder()
LoggingSystem.bootstrapInternal { _ in
return LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
LogHandlerWithGlobalLogLevelOverride(recorder: logRecorder)
}
var logger1 = Logger(label: "logger-\(#file):\(#line)")
@@ -388,7 +394,7 @@ class LoggingTest: XCTestCase {
logRecorder.assertExist(level: .notice, message: "logger1, after")
logRecorder.assertExist(level: .notice, message: "logger2, after")
}
func testLogLevelCases() {
let levels = Logger.Level.allCases
XCTAssertEqual(7, levels.count)
@@ -424,8 +430,8 @@ class LoggingTest: XCTestCase {
func write(_ string: String) {
// This is a test implementation, a real implementation would include locking
strings.append(string)
interceptedText = (interceptedText ?? "") + string
self.strings.append(string)
self.interceptedText = (self.interceptedText ?? "") + string
}
}
@@ -444,4 +450,129 @@ class LoggingTest: XCTestCase {
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 -5
View File
@@ -45,7 +45,7 @@ internal struct TestLogHandler: LogHandler {
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, file: String, function: String, line: UInt) {
let metadata = (self._metadataSet ? self.metadata : MDC.global.metadata).merging(metadata ?? [:], uniquingKeysWith: { _, new in new })
logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
self.logger.log(level: level, message, metadata: metadata, file: file, function: function, line: line)
self.recorder.record(level: level, metadata: metadata, message: message)
}
@@ -208,7 +208,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
@@ -253,9 +253,9 @@ public class MDC {
private var threadId: Int {
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
return Int(pthread_mach_thread_np(pthread_self()))
return Int(pthread_mach_thread_np(pthread_self()))
#else
return Int(pthread_self())
return Int(pthread_self())
#endif
}
}
@@ -284,7 +284,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()
+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 -1
View File
@@ -6,8 +6,11 @@ services:
image: swift-log:18.04-5.0
build:
args:
ubuntu_version: "18.04"
ubuntu_version: "bionic"
swift_version: "5.0"
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
+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"
+14 -8
View File
@@ -13,7 +13,7 @@
##
##===----------------------------------------------------------------------===##
set -e
set -ex
my_path="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
root_path="$my_path/.."
@@ -51,7 +51,12 @@ fi
if ! command -v jazzy > /dev/null; then
gem install jazzy --no-ri --no-rdoc
fi
module_switcher="docs/$version/README.md"
jazzy_dir="$root_path/.build/jazzy"
rm -rf "$jazzy_dir"
mkdir -p "$jazzy_dir"
module_switcher="$jazzy_dir/README.md"
jazzy_args=(--clean
--author 'SwiftLog team'
--readme "$module_switcher"
@@ -68,12 +73,12 @@ SwiftLog is a Swift logging API package.
To get started with SwiftLog, [`import Logging`](../Logging/index.html). The
most important type is [`Logger`](https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger.html)
which you can use to emit log messages.
EOF
tmp=`mktemp -d`
for module in "${modules[@]}"; do
args=("${jazzy_args[@]}" --output "$tmp/docs/$version/$module" --docset-path "$tmp/docset/$version/$module" --module "$module")
args=("${jazzy_args[@]}" --output "$jazzy_dir/docs/$version/$module" --docset-path "$jazzy_dir/docset/$version/$module"
--module "$module" --module-version $version
--root-url "https://apple.github.io/swift-log/docs/$version/$module/")
if [[ -f "$root_path/.build/sourcekitten/$module.json" ]]; then
args+=(--sourcekitten-sourcefile "$root_path/.build/sourcekitten/$module.json")
fi
@@ -81,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
+4 -4
View File
@@ -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
+14 -1
View File
@@ -47,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=( )