mirror of
https://github.com/apple/swift-log
synced 2026-11-22 03:40:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ce592ae52f | ||
|
|
e1600be8ec | ||
|
|
cbd28c274b | ||
|
|
c05d67286c | ||
|
|
2281e43060 | ||
|
|
81d3d07f14 | ||
|
|
09c99dd25a | ||
|
|
748d1eb5d9 | ||
|
|
765db8bc47 | ||
|
|
222bf1b48b |
No files matched your search
@@ -14,15 +14,30 @@ jobs:
|
||||
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
|
||||
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
|
||||
linux_6_0_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_6_1_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_6_0_enabled: true
|
||||
windows_6_1_enabled: true
|
||||
windows_nightly_next_enabled: true
|
||||
windows_nightly_main_enabled: true
|
||||
windows_6_0_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_6_1_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
|
||||
cxx-interop:
|
||||
name: Cxx interop
|
||||
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
|
||||
|
||||
static-sdk:
|
||||
name: Static SDK
|
||||
# Workaround https://github.com/nektos/act/issues/1875
|
||||
uses: apple/swift-nio/.github/workflows/static_sdk.yml@main
|
||||
|
||||
macos-tests:
|
||||
name: macOS tests
|
||||
uses: apple/swift-nio/.github/workflows/macos_tests.yml@main
|
||||
with:
|
||||
runner_pool: nightly
|
||||
build_scheme: swift-log
|
||||
@@ -18,15 +18,30 @@ jobs:
|
||||
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
|
||||
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
|
||||
linux_6_0_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_6_1_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_6_0_enabled: true
|
||||
windows_6_1_enabled: true
|
||||
windows_nightly_next_enabled: true
|
||||
windows_nightly_main_enabled: true
|
||||
windows_6_0_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_6_1_arguments_override: "-Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_nightly_next_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
windows_nightly_main_arguments_override: "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"
|
||||
|
||||
cxx-interop:
|
||||
name: Cxx interop
|
||||
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
|
||||
|
||||
static-sdk:
|
||||
name: Static SDK
|
||||
# Workaround https://github.com/nektos/act/issues/1875
|
||||
uses: apple/swift-nio/.github/workflows/static_sdk.yml@main
|
||||
|
||||
macos-tests:
|
||||
name: macOS tests
|
||||
uses: apple/swift-nio/.github/workflows/macos_tests.yml@main
|
||||
with:
|
||||
runner_pool: general
|
||||
build_scheme: swift-log
|
||||
@@ -1,224 +1,64 @@
|
||||
# SwiftLog
|
||||
|
||||
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.
|
||||
This repository contains a logging API implementation for Swift.
|
||||
SwiftLog provides a unified, performant, and ergonomic logging API that can be
|
||||
adopted by libraries and applications across the Swift ecosystem.
|
||||
|
||||
What `SwiftLog` provides today can be found in the [API docs][api-docs].
|
||||
- 📚 **Documentation** and **tutorials** are available on the [Swift Package Index](https://swiftpackageindex.com/apple/swift-log)
|
||||
- 🚀 **Contributions** are welcome, please see [CONTRIBUTING.md](CONTRIBUTING.md)
|
||||
- 🪪 **License** is Apache 2.0, repeated in [LICENSE.txt](LICENSE.txt)
|
||||
- 🔒 **Security** issues should be reported via the process in [SECURITY.md](SECURITY.md)
|
||||
- 🔀 **Available Logging Backends**: SwiftLog is an API package - you'll want to
|
||||
choose from the many
|
||||
[community-maintained logging backends](#available-log-handler-backends) for production use
|
||||
|
||||
## Getting started
|
||||
## Quick Start
|
||||
|
||||
If you have a server-side Swift application, or maybe a cross-platform (for example Linux & macOS) app/library, and you would like to log, we think targeting this logging API package is a great idea. Below you'll find all you need to know to get started.
|
||||
|
||||
#### Adding the dependency
|
||||
|
||||
`SwiftLog` is designed for Swift 5.8 and later. To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
|
||||
The following snippet shows how to add SwiftLog to your Swift Package:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
|
||||
// swift-tools-version: 6.1
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "YourApp",
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-log", from: "1.6.0")
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
name: "YourApp",
|
||||
dependencies: [
|
||||
.product(name: "Logging", package: "swift-log")
|
||||
]
|
||||
)
|
||||
]
|
||||
)
|
||||
```
|
||||
|
||||
and to your application/library target, add `"Logging"` to your `dependencies`, e.g. like this:
|
||||
Then start logging:
|
||||
|
||||
```swift
|
||||
.target(name: "BestExampleApp", dependencies: [
|
||||
.product(name: "Logging", package: "swift-log")
|
||||
],
|
||||
```
|
||||
|
||||
|
||||
#### Let's log
|
||||
|
||||
```swift
|
||||
// 1) let's import the logging API package
|
||||
import Logging
|
||||
|
||||
// 2) we need to create a logger, the label works similarly to a DispatchQueue label
|
||||
let logger = Logger(label: "com.example.BestExampleApp.main")
|
||||
// Create a logger
|
||||
let logger = Logger(label: "com.example.YourApp")
|
||||
|
||||
// 3) we're now ready to use it
|
||||
logger.info("Hello World!")
|
||||
// Log at different levels
|
||||
logger.info("Application started")
|
||||
logger.warning("This is a warning")
|
||||
logger.error("Something went wrong", metadata: ["error": "\(error)"])
|
||||
|
||||
// Add metadata for context
|
||||
var requestLogger = logger
|
||||
requestLogger[metadataKey: "request-id"] = "\(UUID())"
|
||||
requestLogger.info("Processing request")
|
||||
```
|
||||
|
||||
#### Output
|
||||
## Available log handler backends
|
||||
|
||||
```
|
||||
2019-03-13T15:46:38+0000 info: Hello World!
|
||||
```
|
||||
The community has built numerous specialized logging backends.
|
||||
|
||||
#### 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>
|
||||
## Available Logging Backends For Applications
|
||||
|
||||
You can choose from one of the following backends to consume your logs. If you are interested in implementing one see the "Implementation considerations" section below explaining how to do so. List of existing SwiftLog API compatible libraries:
|
||||
|
||||
| Repository | Handler Description|
|
||||
| ----------- | ----------- |
|
||||
| [Kitura/HeliumLogger](https://github.com/Kitura/HeliumLogger) |a logging backend widely used in the Kitura ecosystem |
|
||||
| [ianpartridge/swift-log-**syslog**](https://github.com/ianpartridge/swift-log-syslog) | a [syslog](https://en.wikipedia.org/wiki/Syslog) backend|
|
||||
| [Adorkable/swift-log-**format-and-pipe**](https://github.com/Adorkable/swift-log-format-and-pipe) | a backend that allows customization of the output format and the resulting destination |
|
||||
| [chrisaljoudi/swift-log-**oslog**](https://github.com/chrisaljoudi/swift-log-oslog) | an OSLog [Unified Logging](https://developer.apple.com/documentation/os/logging) backend for use on Apple platforms. **Important Note:** we recommend using os_log directly as described [here](https://developer.apple.com/documentation/os/logging). Using os_log through swift-log using this backend will be less efficient and will also prevent specifying the privacy of the message. The backend always uses `%{public}@` as the format string and eagerly converts all string interpolations to strings. This has two drawbacks: 1. the static components of the string interpolation would be eagerly copied by the unified logging system, which will result in loss of performance. 2. It makes all messages public, which changes the default privacy policy of os_log, and doesn't allow specifying fine-grained privacy of sections of the message. In a separate on-going work, Swift APIs for os_log are being improved and made to align closely with swift-log APIs. References: [Unifying Logging Levels](https://forums.swift.org/t/custom-string-interpolation-and-compile-time-interpretation-applied-to-logging/18799), [Making os_log accept string interpolations using compile-time interpretation](https://forums.swift.org/t/logging-levels-for-swifts-server-side-logging-apis-and-new-os-log-apis/20365). |
|
||||
| [Brainfinance/StackdriverLogging](https://github.com/Brainfinance/StackdriverLogging) | a structured JSON logging backend for use on Google Cloud Platform with the [Stackdriver logging agent](https://cloud.google.com/logging/docs/agent) |
|
||||
| [DnV1eX/GoogleCloudLogging](https://github.com/DnV1eX/GoogleCloudLogging) | a client-side library for logging application events in [Google Cloud](https://console.cloud.google.com/logs) via REST API v2. |
|
||||
| [vapor/console-kit](https://github.com/vapor/console-kit/) | a logger to the current terminal or stdout with stylized ([ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code)) output. The default logger for all Vapor applications |
|
||||
| [neallester/swift-log-testing](https://github.com/neallester/swift-log-testing) | provides access to log messages for use in assertions (within test targets) |
|
||||
| [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack) | a logging backend that sends critical log messages to Slack |
|
||||
| [NSHipster/swift-log-github-actions](https://github.com/NSHipster/swift-log-github-actions) | a logging backend that translates logging messages into [workflow commands for GitHub Actions](https://help.github.com/en/actions/reference/workflow-commands-for-github-actions). |
|
||||
| [stevapple/swift-log-telegram](https://github.com/stevapple/swift-log-telegram) | a logging backend that sends log messages to any Telegram chat (Inspired by and forked from [wlisac/swift-log-slack](https://github.com/wlisac/swift-log-slack)) |
|
||||
| [jagreenwood/swift-log-datadog](https://github.com/jagreenwood/swift-log-datadog) | a logging backend which sends log messages to the [Datadog](https://www.datadoghq.com/log-management/) log management service |
|
||||
| [google/SwiftLogFireCloud](https://github.com/google/swiftlogfirecloud) | a logging backend for time series logging which pushes logs as flat files to Firebase Cloud Storage. |
|
||||
| [crspybits/swift-log-file](https://github.com/crspybits/swift-log-file) | a simple local file logger (using `Foundation` `FileManager`) |
|
||||
| [sushichop/Puppy](https://github.com/sushichop/Puppy) | a logging backend that supports multiple transports(console, file, syslog, etc.) and has the feature with formatting and file log rotation |
|
||||
| [ShivaHuang/swift-log-SwiftyBeaver](https://github.com/ShivaHuang/swift-log-SwiftyBeaver) | a logging backend for printing colored logging to Xcode console / file, or sending encrypted logging to [SwiftyBeaver](https://swiftybeaver.com) platform. |
|
||||
| [Apodini/swift-log-elk](https://github.com/Apodini/swift-log-elk) | a logging backend that formats, caches and sends log data to [elastic/logstash](https://github.com/elastic/logstash) |
|
||||
| [binaryscraping/swift-log-supabase](https://github.com/binaryscraping/swift-log-supabase) | a logging backend that sends log entries to [Supabase](https://github.com/supabase/supabase). |
|
||||
| [kiliankoe/swift-log-matrix](https://swiftpackageindex.com/kiliankoe/swift-log-matrix) | a logging backend for sending logs directly to a [Matrix](https://matrix.org) room |
|
||||
| [DiscordBM/DiscordLogger](https://github.com/DiscordBM/DiscordLogger) | a Discord logging implementation to send your logs over to a Discord channel in a good-looking manner and with a lot of configuration options including the ability to send only a few important log-levels such as `warning`/`error`/`critical`. |
|
||||
| [CocoaLumberjack](https://github.com/CocoaLumberjack/CocoaLumberjack) | a fast & simple, yet powerful & flexible logging framework for macOS, iOS, tvOS and watchOS, which includes a logging backend for swift-log. |
|
||||
| [rwbutler/swift-log-ecs](https://github.com/rwbutler/swift-log-ecs) | a logging backend for logging in [ECS Log format](https://www.elastic.co/guide/en/ecs-logging/overview/current/intro.html). Compatible with [Vapor](https://github.com/vapor/vapor) and allows chaining of multiple LogHandlers. |
|
||||
| [ShipBook/swift-log-**shipbook**](https://github.com/ShipBook/swift-log-shipbook) | a logging backend that sends log entries to [Shipbook](https://www.shipbook.io) - Shipbook gives you the power to remotely gather, search and analyze your user logs and exceptions in the cloud, on a per-user & session basis. |
|
||||
| [kasianov-mikhail/scout](https://github.com/kasianov-mikhail/scout) | CloudKit as a log storage |
|
||||
| [PADL/AndroidLogging](https://github.com/PADL/AndroidLogging) | a logging backend for the Android in-kernel log buffer |
|
||||
| [xtremekforever/swift-systemd](https://github.com/xtremekforever/swift-systemd) | a logging backend for the [systemd](https://systemd.io/) journal |
|
||||
| Your library? | [Get in touch!](https://forums.swift.org/c/server) |
|
||||
|
||||
## What is an API package?
|
||||
|
||||
Glad you asked. We believe that for the Swift on Server ecosystem, it's crucial to have a logging API that can be adopted by anybody so a multitude of libraries from different parties can all log to a shared destination. More concretely this means that we believe all the log messages from all libraries end up in the same file, database, Elastic Stack/Splunk instance, or whatever you may choose.
|
||||
|
||||
In the real-world however, there are so many opinions over how exactly a logging system should behave, what a log message should be formatted like, and where/how it should be persisted. We think it's not feasible to wait for one logging package to support everything that a specific deployment needs whilst still being easy enough to use and remain performant. That's why we decided to cut the problem in half:
|
||||
|
||||
1. a logging API
|
||||
2. a logging backend implementation
|
||||
|
||||
This package only provides the logging API itself and therefore `SwiftLog` is a 'logging API package'. `SwiftLog` (using `LoggingSystem.bootstrap`) can be configured to choose any compatible logging backend implementation. This way packages can adopt the API and the _application_ can choose any compatible logging backend implementation without requiring any changes from any of the libraries.
|
||||
|
||||
Just for completeness sake: This API package does actually include an overly simplistic and non-configurable logging backend implementation which simply writes all log messages to `stdout`. The reason to include this overly simplistic logging backend implementation is to improve the first-time usage experience. Let's assume you start a project and try out `SwiftLog` for the first time, it's just a whole lot better to see something you logged appear on `stdout` in a simplistic format rather than nothing happening at all. For any real-world application, we advise configuring another logging backend implementation that logs in the style you like.
|
||||
|
||||
## The core concepts
|
||||
|
||||
### Loggers
|
||||
|
||||
`Logger`s are used to emit log messages and therefore the most important type in `SwiftLog`, so their use should be as simple as possible. Most commonly, they are used to emit log messages in a certain log level. For example:
|
||||
|
||||
```swift
|
||||
// logging an informational message
|
||||
logger.info("Hello World!")
|
||||
|
||||
// ouch, something went wrong
|
||||
logger.error("Houston, we have a problem: \(problem)")
|
||||
```
|
||||
|
||||
### Log levels
|
||||
|
||||
The following log levels are supported:
|
||||
|
||||
- `trace`
|
||||
- `debug`
|
||||
- `info`
|
||||
- `notice`
|
||||
- `warning`
|
||||
- `error`
|
||||
- `critical`
|
||||
|
||||
The log level of a given logger can be changed, but the change will only affect the specific logger you changed it on. You could say the `Logger` is a _value type_ regarding the log level.
|
||||
|
||||
|
||||
### Logging metadata
|
||||
|
||||
Logging metadata is metadata that can be attached to loggers to add information that is crucial when debugging a problem. In servers, the usual example is attaching a request UUID to a logger that will then be present on all log messages logged with that logger. Example:
|
||||
|
||||
```swift
|
||||
var logger = logger
|
||||
logger[metadataKey: "request-uuid"] = "\(UUID())"
|
||||
logger.info("hello world")
|
||||
```
|
||||
|
||||
will print
|
||||
|
||||
```
|
||||
2019-03-13T18:30:02+0000 info: request-uuid=F8633013-3DD8-481C-9256-B296E43443ED hello world
|
||||
```
|
||||
|
||||
with the default logging backend implementation that ships with `SwiftLog`. Needless to say, the format is fully defined by the logging backend you choose.
|
||||
|
||||
## On the implementation of a logging backend (a `LogHandler`)
|
||||
|
||||
Note: If you don't want to implement a custom logging backend, everything in this section is probably not very relevant, so please feel free to skip.
|
||||
|
||||
To become a compatible logging backend that all `SwiftLog` consumers can use, you need to do two things: 1) Implement a type (usually a `struct`) that implements `LogHandler`, a protocol provided by `SwiftLog` and 2) instruct `SwiftLog` to use your logging backend implementation.
|
||||
|
||||
A `LogHandler` or logging backend implementation is anything that conforms to the following protocol
|
||||
|
||||
```swift
|
||||
public protocol LogHandler {
|
||||
func log(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata?, source: String, file: String, function: String, line: UInt)
|
||||
|
||||
subscript(metadataKey _: String) -> Logger.Metadata.Value? { get set }
|
||||
|
||||
var metadata: Logger.Metadata { get set }
|
||||
|
||||
var logLevel: Logger.Level { get set }
|
||||
}
|
||||
```
|
||||
|
||||
Instructing `SwiftLog` to use your logging backend as the one the whole application (including all libraries) should use is very simple:
|
||||
|
||||
```swift
|
||||
LoggingSystem.bootstrap(MyLogHandler.init)
|
||||
```
|
||||
|
||||
### Implementation considerations
|
||||
|
||||
`LogHandler`s control most parts of the logging system:
|
||||
|
||||
#### Under control of a `LogHandler`
|
||||
|
||||
##### Configuration
|
||||
|
||||
`LogHandler`s control the two crucial pieces of `Logger` configuration, namely:
|
||||
|
||||
- log level (`logger.logLevel` property)
|
||||
- logging metadata (`logger[metadataKey:]` and `logger.metadata`)
|
||||
|
||||
For the system to work, however, it is important that `LogHandler` treat the configuration as _value types_. This means that `LogHandler`s should be `struct`s and a change in log level or logging metadata should only affect the very `LogHandler` it was changed on.
|
||||
|
||||
However, in special cases, it is acceptable that a `LogHandler` provides some global log level override that may affect all `LogHandler`s created.
|
||||
|
||||
##### Emitting
|
||||
- emitting the log message itself
|
||||
|
||||
### Not under control of `LogHandler`s
|
||||
|
||||
`LogHandler`s do not control if a message should be logged or not. `Logger` will only invoke the `log` function of a `LogHandler` if `Logger` determines that a log message should be emitted given the configured log level.
|
||||
|
||||
## Source vs Label
|
||||
|
||||
A `Logger` carries an (immutable) `label` and each log message carries a `source` parameter (since SwiftLog 1.3.0). The `Logger`'s label
|
||||
identifies the creator of the `Logger`. If you are using structured logging by preserving metadata across multiple modules, the `Logger`'s
|
||||
`label` is not a good way to identify where a log message originated from as it identifies the creator of a `Logger` which is often passed
|
||||
around between libraries to preserve metadata and the like.
|
||||
|
||||
If you want to filter all log messages originating from a certain subsystem, filter by `source` which defaults to the module that is emitting the
|
||||
log message.
|
||||
|
||||
## Security
|
||||
|
||||
Please see [SECURITY.md](SECURITY.md) for SwiftLog's security process.
|
||||
|
||||
## Design
|
||||
|
||||
This logging API was designed with the contributors to the Swift on Server community and approved by the [SSWG (Swift Server Work Group)](https://swift.org/server/) to the 'sandbox level' of the SSWG's [incubation process](https://www.swift.org/sswg/incubation-process.html).
|
||||
|
||||
- [pitch](https://forums.swift.org/t/logging/16027), [discussion](https://forums.swift.org/t/discussion-server-logging-api/18834), [feedback](https://forums.swift.org/t/feedback-server-logging-api-with-revisions/19375)
|
||||
- [log levels](https://forums.swift.org/t/logging-levels-for-swifts-server-side-logging-apis-and-new-os-log-apis/20365)
|
||||
|
||||
[api-docs]: https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger.html
|
||||
A great way to discover available log backend implementations is searching the
|
||||
[Swift Package Index](https://swiftpackageindex.com/search?query=swift-log)
|
||||
for the `swift-log` keyword.
|
||||
@@ -0,0 +1,138 @@
|
||||
# 001: Choosing log levels
|
||||
|
||||
Best practice for selecting appropriate log levels in applications and
|
||||
libraries.
|
||||
|
||||
## Overview
|
||||
|
||||
SwiftLog defines seven log levels, and choosing the right level is crucial for
|
||||
creating well-behaved libraries that don't overwhelm logging systems or misuse
|
||||
severity levels. This practice provides clear guidance on when to use each
|
||||
level.
|
||||
|
||||
### Motivation
|
||||
|
||||
Libraries must be well-behaved across various use cases and cannot assume
|
||||
specific logging backend configurations. Using inappropriate log levels can
|
||||
flood production logs, trigger false alerts, or make debugging more difficult.
|
||||
Following consistent log level guidelines ensures your library integrates well
|
||||
with diverse application environments.
|
||||
|
||||
### Log levels
|
||||
|
||||
SwiftLog defines seven log levels via ``Logger/Level``, ordered from least to
|
||||
most severe:
|
||||
|
||||
- ``Logger/Level/trace``
|
||||
- ``Logger/Level/debug``
|
||||
- ``Logger/Level/info``
|
||||
- ``Logger/Level/notice``
|
||||
- ``Logger/Level/warning``
|
||||
- ``Logger/Level/error``
|
||||
- ``Logger/Level/critical``
|
||||
|
||||
### Level guidelines
|
||||
|
||||
How you use log levels depends in large part if you are developing a library, or
|
||||
an application which bootstraps its logging system and is in full control over
|
||||
its logging environment.
|
||||
|
||||
#### For libraries
|
||||
|
||||
Libraries should use **info level or lower** (info, debug, trace). Each level
|
||||
serves different purposes:
|
||||
|
||||
Libraries **should not** log information on **warning or more severe levels**,
|
||||
unless it is a one-time (for example during startup) warning, that cannot lead
|
||||
to overwhelming log outputs.
|
||||
|
||||
##### Trace Level
|
||||
- **Usage**: Log everything needed to diagnose hard-to-reproduce bugs
|
||||
- **Performance**: May impact performance; assume it won't be used in production
|
||||
- **Content**: Internal state, detailed operation flows, diagnostic information
|
||||
|
||||
##### Debug Level
|
||||
- **Usage**: May be enabled in some production deployments
|
||||
- **Performance**: Should not significantly undermine production performance
|
||||
- **Content**: High-level operation overview, connection events, major decisions
|
||||
|
||||
##### Info Level
|
||||
- **Usage**: Reserved for things that went wrong but can't be communicated
|
||||
through other means like throwing from a method
|
||||
- **Examples**: Connection retry attempts, fallback mechanisms, recoverable
|
||||
failures
|
||||
- **Guideline**: Use sparingly - not for normal successful operations
|
||||
|
||||
#### For applications
|
||||
|
||||
Applications can use **any level** depending on the context and what they want
|
||||
to achieve. Applications have full control over their logging strategy.
|
||||
|
||||
#### Configuring logger log levels
|
||||
|
||||
It depends on the use-case of your application which log level your logger
|
||||
should use. For **console and other end-user-visible displays**: Consider using
|
||||
**notice level** as the minimum visible level to avoid overwhelming users with
|
||||
technical details.
|
||||
|
||||
### Example
|
||||
|
||||
#### Recommended: Libraries should use info level or lower
|
||||
|
||||
```swift
|
||||
// ✅ Good: Trace level for detailed diagnostics
|
||||
logger.trace("Connection pool state", metadata: [
|
||||
"active": "\(activeConnections)",
|
||||
"idle": "\(idleConnections)",
|
||||
"pending": "\(pendingRequests)"
|
||||
])
|
||||
|
||||
// ✅ Good: Debug level for high-value operational info
|
||||
logger.debug("Database connection established", metadata: [
|
||||
"host": "\(host)",
|
||||
"database": "\(database)",
|
||||
"connectionTime": "\(duration)"
|
||||
])
|
||||
|
||||
// ✅ Good: Info level for issues that can't be communicated through other means
|
||||
logger.info("Connection failed, retrying", metadata: [
|
||||
"attempt": "\(attemptNumber)",
|
||||
"maxRetries": "\(maxRetries)",
|
||||
"host": "\(host)"
|
||||
])
|
||||
```
|
||||
|
||||
#### Use sparingly: Warning and error levels
|
||||
|
||||
```swift
|
||||
// ✅ Good: One-time startup warning or error
|
||||
logger.warning("Deprecated TLS version detected. Consider upgrading to TLS 1.3")
|
||||
```
|
||||
|
||||
#### Avoid: Logging potentially intentional failures at info level
|
||||
|
||||
Some failures may be completely intentional from the high-level perspective of a
|
||||
developer or system using your library. For example: failure to resolve a
|
||||
domain, failure to make a request, or failure to complete some task;
|
||||
|
||||
Instead, log at debug or trace levels and offer alternative ways to observe
|
||||
these behaviors, for example using `swift-metrics` to emit counts.
|
||||
|
||||
```swift
|
||||
// ❌ Bad: Normal operations at info level flood production logs
|
||||
logger.info("Request failed")
|
||||
```
|
||||
|
||||
#### Avoid: Normal operations at info level
|
||||
|
||||
```swift
|
||||
// ❌ Bad: Normal operations at info level flood production logs
|
||||
logger.info("HTTP request received")
|
||||
logger.info("Database query executed")
|
||||
logger.info("Response sent")
|
||||
|
||||
// ✅ Good: Use appropriate levels instead
|
||||
logger.debug("Processing request", metadata: ["path": "\(path)"])
|
||||
logger.trace("Query", , metadata: ["path": "\(query)"])
|
||||
logger.debug("Request completed", metadata: ["status": "\(status)"])
|
||||
```
|
||||
@@ -0,0 +1,213 @@
|
||||
# Implementing a log handler
|
||||
|
||||
Create a custom logging backend that provides logging services for your apps
|
||||
and libraries.
|
||||
|
||||
## Overview
|
||||
|
||||
To become a compatible logging backend that any `SwiftLog` consumer can use,
|
||||
you need to fulfill a few requirements, primarily conforming to the
|
||||
``LogHandler`` protocol.
|
||||
|
||||
### Implement with value type semantics
|
||||
|
||||
Your log handler **must be a `struct`** and exhibit value semantics. This
|
||||
ensures that changes to one logger don't affect others.
|
||||
|
||||
To verify that your handler reflects value semantics ensure that it passes this
|
||||
test:
|
||||
|
||||
```swift
|
||||
@Test
|
||||
func logHandlerValueSemantics() {
|
||||
LoggingSystem.bootstrap(MyLogHandler.init)
|
||||
var logger1 = Logger(label: "first logger")
|
||||
logger1.logLevel = .debug
|
||||
logger1[metadataKey: "only-on"] = "first"
|
||||
|
||||
var logger2 = logger1
|
||||
logger2.logLevel = .error // Must not affect logger1
|
||||
logger2[metadataKey: "only-on"] = "second" // Must not affect logger1
|
||||
|
||||
// These expectations must pass
|
||||
#expect(logger1.logLevel == .debug)
|
||||
#expect(logger2.logLevel == .error)
|
||||
#expect(logger1[metadataKey: "only-on"] == "first")
|
||||
#expect(logger2[metadataKey: "only-on"] == "second")
|
||||
}
|
||||
```
|
||||
|
||||
> Note: In special cases, it is acceptable for a log handler to provide
|
||||
> global log level overrides that may affect all log handlers created.
|
||||
|
||||
### Example implementation
|
||||
|
||||
Here's a complete example of a simple print-based log handler:
|
||||
|
||||
```swift
|
||||
import Foundation
|
||||
import Logging
|
||||
|
||||
public struct PrintLogHandler: LogHandler {
|
||||
private let label: String
|
||||
public var logLevel: Logger.Level = .info
|
||||
public var metadata: Logger.Metadata = [:]
|
||||
|
||||
public init(label: String) {
|
||||
self.label = label
|
||||
}
|
||||
|
||||
public func log(
|
||||
level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt
|
||||
) {
|
||||
let timestamp = ISO8601DateFormatter().string(from: Date())
|
||||
let levelString = level.rawValue.uppercased()
|
||||
|
||||
// Merge handler metadata with message metadata
|
||||
let combinedMetadata = Self.prepareMetadata(
|
||||
base: self.metadata
|
||||
explicit: metadata
|
||||
)
|
||||
|
||||
// Format metadata
|
||||
let metadataString = combinedMetadata.map { "\($0.key)=\($0.value)" }.joined(separator: ",")
|
||||
|
||||
// Create log line and print to console
|
||||
let logLine = "\(label) \(timestamp) \(levelString) [\(metadataString)]: \(message)"
|
||||
print(logLine)
|
||||
}
|
||||
|
||||
public subscript(metadataKey key: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.metadata[key]
|
||||
}
|
||||
set {
|
||||
self.metadata[key] = newValue
|
||||
}
|
||||
}
|
||||
|
||||
static func prepareMetadata(
|
||||
base: Logger.Metadata,
|
||||
explicit: Logger.Metadata?
|
||||
) -> Logger.Metadata? {
|
||||
var metadata = base
|
||||
|
||||
guard let explicit else {
|
||||
// all per-log-statement values are empty
|
||||
return metadata
|
||||
}
|
||||
|
||||
metadata.merge(explicit, uniquingKeysWith: { _, explicit in explicit })
|
||||
|
||||
return metadata
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### Advanced features
|
||||
|
||||
#### Metadata providers
|
||||
|
||||
Metadata providers allow you to dynamically add contextual information to all
|
||||
log messages without explicitly passing it each time. Common use cases include
|
||||
request IDs, user sessions, or trace contexts that should be included in logs
|
||||
throughout a request's lifecycle.
|
||||
|
||||
```swift
|
||||
import Foundation
|
||||
import Logging
|
||||
|
||||
public struct PrintLogHandler: LogHandler {
|
||||
private let label: String
|
||||
public var logLevel: Logger.Level = .info
|
||||
public var metadata: Logger.Metadata = [:]
|
||||
public var metadataProvider: Logger.MetadataProvider?
|
||||
|
||||
public init(label: String) {
|
||||
self.label = label
|
||||
}
|
||||
|
||||
public func log(
|
||||
level: Logger.Level,
|
||||
message: Logger.Message,
|
||||
metadata: Logger.Metadata?,
|
||||
source: String,
|
||||
file: String,
|
||||
function: String,
|
||||
line: UInt
|
||||
) {
|
||||
let timestamp = ISO8601DateFormatter().string(from: Date())
|
||||
let levelString = level.rawValue.uppercased()
|
||||
|
||||
// Get provider metadata
|
||||
let providerMetadata = metadataProvider?.get() ?? [:]
|
||||
|
||||
// Merge handler metadata with message metadata
|
||||
let combinedMetadata = Self.prepareMetadata(
|
||||
base: self.metadata,
|
||||
provider: self.metadataProvider,
|
||||
explicit: metadata
|
||||
)
|
||||
|
||||
// Format metadata
|
||||
let metadataString = combinedMetadata.map { "\($0.key)=\($0.value)" }.joined(separator: ",")
|
||||
|
||||
// Create log line and print to console
|
||||
let logLine = "\(label) \(timestamp) \(levelString) [\(metadataString)]: \(message)"
|
||||
print(logLine)
|
||||
}
|
||||
|
||||
public subscript(metadataKey key: String) -> Logger.Metadata.Value? {
|
||||
get {
|
||||
return self.metadata[key]
|
||||
}
|
||||
set {
|
||||
self.metadata[key] = newValue
|
||||
}
|
||||
}
|
||||
|
||||
static func prepareMetadata(
|
||||
base: Logger.Metadata,
|
||||
provider: Logger.MetadataProvider?,
|
||||
explicit: Logger.Metadata?
|
||||
) -> Logger.Metadata? {
|
||||
var metadata = base
|
||||
|
||||
let provided = provider?.get() ?? [:]
|
||||
|
||||
guard !provided.isEmpty || !((explicit ?? [:]).isEmpty) else {
|
||||
// all per-log-statement values are empty
|
||||
return metadata
|
||||
}
|
||||
|
||||
if !provided.isEmpty {
|
||||
metadata.merge(provided, uniquingKeysWith: { _, provided in provided })
|
||||
}
|
||||
|
||||
if let explicit = explicit, !explicit.isEmpty {
|
||||
metadata.merge(explicit, uniquingKeysWith: { _, explicit in explicit })
|
||||
}
|
||||
|
||||
return metadata
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Performance considerations
|
||||
|
||||
1. **Avoid blocking**: Don't block the calling thread for I/O operations.
|
||||
2. **Lazy evaluation**: Remember that messages and metadata are autoclosures.
|
||||
3. **Memory efficiency**: Don't hold onto large amounts of messages.
|
||||
|
||||
## See Also
|
||||
|
||||
- ``LogHandler``
|
||||
- ``StreamLogHandler``
|
||||
- ``MultiplexLogHandler``
|
||||
@@ -1,13 +0,0 @@
|
||||
# ``Logging/Logger/Level``
|
||||
|
||||
## Topics
|
||||
|
||||
### Log levels
|
||||
|
||||
- ``trace``
|
||||
- ``debug``
|
||||
- ``info``
|
||||
- ``notice``
|
||||
- ``warning``
|
||||
- ``error``
|
||||
- ``critical``
|
||||
@@ -0,0 +1,41 @@
|
||||
# Logging best practices
|
||||
|
||||
Best practices for effective logging with SwiftLog.
|
||||
|
||||
## Overview
|
||||
|
||||
This collection of best practices helps library authors and application
|
||||
developers create effective, maintainable logging that works well across diverse
|
||||
environments. Each practice is designed to ensure your logs are useful for
|
||||
debugging while being respectful of system resources and operational
|
||||
requirements.
|
||||
|
||||
### Who Should Use These Practices
|
||||
|
||||
- **Library Authors**: Creating reusable components that log appropriately.
|
||||
- **Application Developers**: Implementing logging strategies in applications.
|
||||
|
||||
### Philosophy
|
||||
|
||||
Good logging strikes a balance between providing useful information and avoiding
|
||||
system overhead. These practices are based on real-world experience with
|
||||
production systems and emphasize:
|
||||
|
||||
- **Predictable behavior** across different environments.
|
||||
- **Performance consciousness** to avoid impacting application speed.
|
||||
- **Operational awareness** to support production debugging and monitoring.
|
||||
- **Developer experience** to make debugging efficient and pleasant.
|
||||
|
||||
### Contributing to these practices
|
||||
|
||||
These best practices evolve based on community experience and are maintained by
|
||||
the Swift Server Working Group ([SSWG](https://www.swift.org/sswg/)). Each
|
||||
practice includes:
|
||||
|
||||
- **Clear motivation** explaining why the practice matters
|
||||
- **Concrete examples** showing good and bad patterns
|
||||
- **Alternatives considered** documenting trade-offs and rejected approaches
|
||||
|
||||
## Topics
|
||||
|
||||
- <doc:001-ChoosingLogLevels>
|
||||
@@ -1,18 +1,149 @@
|
||||
# ``Logging``
|
||||
|
||||
A Logging API for Swift.
|
||||
A unified, performant, and ergonomic logging API for Swift.
|
||||
|
||||
## Overview
|
||||
|
||||
SwiftLog provides a logging API package designed to establish a common API the
|
||||
ecosystem can use. It allows packages to emit log messages without tying them to
|
||||
any specific logging implementation, while applications can choose any
|
||||
compatible logging backend.
|
||||
|
||||
SwiftLog is an _API package_ which cuts the logging problem in half:
|
||||
1. A logging API (this package)
|
||||
2. Logging backend implementations (community-provided)
|
||||
|
||||
This separation allows libraries to adopt the API while applications choose any
|
||||
compatible logging backend implementation without requiring changes from
|
||||
libraries.
|
||||
|
||||
## 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.
|
||||
Use this If you are writing a cross-platform application (for example, Linux and
|
||||
macOS) or library, target this logging API.
|
||||
|
||||
### Log handler implementations
|
||||
### Adding the Dependency
|
||||
|
||||
This package offers the common Logging API as well as a very simple stdout log handler.
|
||||
Add the dependency to your `Package.swift`:
|
||||
|
||||
In a real system or application, you will want to use one of the many community maintained log handler implementations.
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-log", from: "1.6.0")
|
||||
```
|
||||
|
||||
And to your target:
|
||||
|
||||
```swift
|
||||
.target(
|
||||
name: "YourTarget",
|
||||
dependencies: [
|
||||
.product(name: "Logging", package: "swift-log")
|
||||
]
|
||||
)
|
||||
```
|
||||
|
||||
### Basic Usage
|
||||
|
||||
```swift
|
||||
// Import the logging API
|
||||
import Logging
|
||||
|
||||
// Create a logger with a label
|
||||
let logger = Logger(label: "MyLogger")
|
||||
|
||||
// Use it to log messages
|
||||
logger.info("Hello World!")
|
||||
```
|
||||
|
||||
This outputs:
|
||||
```
|
||||
2019-03-13T15:46:38+0000 info: Hello World!
|
||||
```
|
||||
|
||||
### Default Behavior
|
||||
|
||||
SwiftLog provides basic console logging via ``StreamLogHandler``. By default it
|
||||
uses `stdout`, however, you can configure it to use `stderr` instead:
|
||||
|
||||
```swift
|
||||
LoggingSystem.bootstrap(StreamLogHandler.standardError)
|
||||
```
|
||||
|
||||
``StreamLogHandler`` is primarily for convenience. For production applications,
|
||||
implement the ``LogHandler`` protocol directly or use a community-maintained
|
||||
backend.
|
||||
|
||||
## Core Concepts
|
||||
|
||||
### Loggers
|
||||
|
||||
Loggers are used to emit log messages at different severity levels:
|
||||
|
||||
```swift
|
||||
// Informational message
|
||||
logger.info("Processing request")
|
||||
|
||||
// Something went wrong
|
||||
logger.error("Houston, we have a problem")
|
||||
```
|
||||
|
||||
``Logger`` is a value type with value semantics, meaning that when you modify a
|
||||
logger's configuration (like its log level or metadata), it only affects that
|
||||
specific logger instance:
|
||||
|
||||
```swift
|
||||
let baseLogger = Logger(label: "MyApp")
|
||||
|
||||
// Create a new logger with different configuration.
|
||||
var requestLogger = baseLogger
|
||||
requestLogger.logLevel = .debug
|
||||
requestLogger[metadataKey: "request-id"] = "\(UUID())"
|
||||
|
||||
// baseLogger is unchanged. It still has default log level and no metadata
|
||||
// requestLogger has debug level and request-id metadata.
|
||||
```
|
||||
|
||||
This value type behavior makes loggers safe to pass between functions and modify
|
||||
without unexpected side effects.
|
||||
|
||||
### Log Levels
|
||||
|
||||
SwiftLog supports seven log levels (from least to most severe):
|
||||
- ``Logger/Level/trace``
|
||||
- ``Logger/Level/debug``
|
||||
- ``Logger/Level/info``
|
||||
- ``Logger/Level/notice``
|
||||
- ``Logger/Level/warning``
|
||||
- ``Logger/Level/error``
|
||||
- ``Logger/Level/critical``
|
||||
|
||||
Log levels can be changed per logger without affecting others:
|
||||
|
||||
```swift
|
||||
var logger = Logger(label: "MyLogger")
|
||||
logger.logLevel = .debug
|
||||
```
|
||||
|
||||
### Logging Metadata
|
||||
|
||||
Metadata provides contextual information crucial for debugging:
|
||||
|
||||
```swift
|
||||
var logger = Logger(label: "com.example.server")
|
||||
logger[metadataKey: "request-uuid"] = "\(UUID())"
|
||||
logger.info("Processing request")
|
||||
```
|
||||
|
||||
Output:
|
||||
```
|
||||
2019-03-13T18:30:02+0000 info: request-uuid=F8633013-3DD8-481C-9256-B296E43443ED Processing request
|
||||
```
|
||||
|
||||
### Source vs Label
|
||||
|
||||
A ``Logger`` has an immutable `label` identifying its creator, while each log
|
||||
message carries a `source` parameter identifying where the message originated.
|
||||
Use `source` for filtering messages from specific subsystems.
|
||||
|
||||
Please refer to the [complete list of community maintained logging backend implementations](https://github.com/apple/swift-log#selecting-a-logging-backend-implementation-applications-only).
|
||||
|
||||
## Topics
|
||||
|
||||
@@ -28,3 +159,8 @@ Please refer to the [complete list of community maintained logging backend imple
|
||||
- ``StreamLogHandler``
|
||||
- ``SwiftLogNoOpLogHandler``
|
||||
|
||||
### Best Practices
|
||||
|
||||
- <doc:LoggingBestPractices>
|
||||
- <doc:001-ChoosingLogLevels>
|
||||
|
||||
@@ -31,19 +31,23 @@
|
||||
/// When developing your `LogHandler`, please make sure the following test works.
|
||||
///
|
||||
/// ```swift
|
||||
/// LoggingSystem.bootstrap(MyLogHandler.init) // your LogHandler might have a different bootstrapping step
|
||||
/// var logger1 = Logger(label: "first logger")
|
||||
/// logger1.logLevel = .debug
|
||||
/// logger1[metadataKey: "only-on"] = "first"
|
||||
/// @Test
|
||||
/// func logHandlerValueSemantics() {
|
||||
/// LoggingSystem.bootstrap(MyLogHandler.init)
|
||||
/// var logger1 = Logger(label: "first logger")
|
||||
/// logger1.logLevel = .debug
|
||||
/// logger1[metadataKey: "only-on"] = "first"
|
||||
///
|
||||
/// var logger2 = logger1
|
||||
/// logger2.logLevel = .error // this must not override `logger1`'s log level
|
||||
/// logger2[metadataKey: "only-on"] = "second" // this must not override `logger1`'s metadata
|
||||
/// var logger2 = logger1
|
||||
/// logger2.logLevel = .error // Must not affect logger1
|
||||
/// logger2[metadataKey: "only-on"] = "second" // Must not affect logger1
|
||||
///
|
||||
/// XCTAssertEqual(.debug, logger1.logLevel)
|
||||
/// XCTAssertEqual(.error, logger2.logLevel)
|
||||
/// XCTAssertEqual("first", logger1[metadataKey: "only-on"])
|
||||
/// XCTAssertEqual("second", logger2[metadataKey: "only-on"])
|
||||
/// // These expectations must pass
|
||||
/// #expect(logger1.logLevel == .debug)
|
||||
/// #expect(logger2.logLevel == .error)
|
||||
/// #expect(logger1[metadataKey: "only-on"] == "first")
|
||||
/// #expect(logger2[metadataKey: "only-on"] == "second")
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// ### Special cases
|
||||
|
||||
@@ -1242,7 +1242,6 @@ internal struct StdioOutputStream: TextOutputStream, @unchecked Sendable {
|
||||
}
|
||||
|
||||
/// Flush the underlying stream.
|
||||
/// This has no effect when using the `.always` flush mode, which is the default
|
||||
internal func flush() {
|
||||
_ = fflush(self.file)
|
||||
}
|
||||
@@ -1397,7 +1396,7 @@ public struct StreamLogHandler: LogHandler {
|
||||
|
||||
var stream = self.stream
|
||||
stream.write(
|
||||
"\(self.timestamp()) \(level) \(self.label) :\(prettyMetadata.map { " \($0)" } ?? "") [\(source)] \(message)\n"
|
||||
"\(self.timestamp()) \(level)\(self.label.isEmpty ? "" : " ")\(self.label):\(prettyMetadata.map { " \($0)" } ?? "") [\(source)] \(message)\n"
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -20,6 +20,8 @@ import XCTest
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import WinSDK
|
||||
#elseif canImport(Android)
|
||||
import Android
|
||||
#else
|
||||
import Glibc
|
||||
#endif
|
||||
@@ -987,7 +989,31 @@ class LoggingTest: XCTestCase {
|
||||
log.critical("\(testString)", source: source)
|
||||
|
||||
let pattern =
|
||||
"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\s\\[\(source)\\]\\s\(testString)$"
|
||||
"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label):\\s\\[\(source)\\]\\s\(testString)$"
|
||||
|
||||
let messageSucceeded =
|
||||
interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(
|
||||
of: pattern,
|
||||
options: .regularExpression
|
||||
) != nil
|
||||
|
||||
XCTAssertTrue(messageSucceeded)
|
||||
XCTAssertEqual(interceptStream.strings.count, 1)
|
||||
}
|
||||
|
||||
func testStreamLogHandlerOutputFormatWithEmptyLabel() {
|
||||
let interceptStream = InterceptStream()
|
||||
LoggingSystem.bootstrapInternal { label in
|
||||
StreamLogHandler(label: label, stream: interceptStream)
|
||||
}
|
||||
let source = "testSource"
|
||||
let log = Logger(label: "")
|
||||
|
||||
let testString = "my message is better than yours"
|
||||
log.critical("\(testString)", source: source)
|
||||
|
||||
let pattern =
|
||||
"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical):\\s\\[\(source)\\]\\s\(testString)$"
|
||||
|
||||
let messageSucceeded =
|
||||
interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(
|
||||
@@ -1012,7 +1038,7 @@ class LoggingTest: XCTestCase {
|
||||
log.critical("\(testString)", metadata: ["test": "test"], source: source)
|
||||
|
||||
let pattern =
|
||||
"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label)\\s:\\stest=test\\s\\[\(source)\\]\\s\(testString)$"
|
||||
"^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\+|-)\\d{4}\\s\(Logger.Level.critical)\\s\(label):\\stest=test\\s\\[\(source)\\]\\s\(testString)$"
|
||||
|
||||
let messageSucceeded =
|
||||
interceptStream.interceptedText?.trimmingCharacters(in: .whitespacesAndNewlines).range(
|
||||
|
||||
@@ -20,6 +20,8 @@ import XCTest
|
||||
import Darwin
|
||||
#elseif os(Windows)
|
||||
import WinSDK
|
||||
#elseif canImport(Android)
|
||||
import Android
|
||||
#else
|
||||
import Glibc
|
||||
#endif
|
||||
|
||||
Reference in new issue
Block a user