Compare commits

..
1 Commits
Author SHA1 Message Date
tomer doron 5f3f75eb2f Update README.md 2024-02-19 15:25:58 -08:00
176 changed files with 4380 additions and 12641 deletions

No files matched your search

-8
View File
@@ -1,8 +0,0 @@
root = true
[*]
indent_style = space
indent_size = 4
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
-8
View File
@@ -1,8 +0,0 @@
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "daily"
labels:
- "semver/none"
-14
View File
@@ -1,14 +0,0 @@
changelog:
categories:
- title: SemVer Major
labels:
- ⚠️ semver/major
- title: SemVer Minor
labels:
- 🆕 semver/minor
- title: SemVer Patch
labels:
- 🔨 semver/patch
- title: Other Changes
labels:
- semver/none
-12
View File
@@ -1,12 +0,0 @@
name: Auto Release
on:
workflow_dispatch:
permissions:
contents: write
pull-requests: read
jobs:
auto-release:
uses: apple/swift-temporal-sdk/.github/workflows/auto-release.yml@main
-73
View File
@@ -1,73 +0,0 @@
name: Main
permissions:
contents: read
on:
push:
branches: [main]
schedule:
- cron: "0 8,20 * * *"
jobs:
tests:
name: Tests
uses: swiftlang/github-workflows/.github/workflows/package_test.yml@0.0.18
with:
# After https://github.com/swiftlang/github-workflows/pull/362 fix is available, this can be simplified to:
# windows_command: |
# Debug-Test: swift test
# Release-Build: swift build -c release
# windows_version_overrides: |
# default: -Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
# nightly-release: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
# nightly-main: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
windows_env_vars: '{"COMMON_SWIFT_FLAGS": "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"}'
windows_command: |
Debug-Test:
command: swift test -Xswiftc -warnings-as-errors %COMMON_SWIFT_FLAGS%
versions: ["current-2", "current-1", "current"]
Release-Build:
command: swift build -c release -Xswiftc -warnings-as-errors %COMMON_SWIFT_FLAGS%
versions: ["current-2", "current-1", "current"]
Debug-Test-Nightly:
command: swift test %COMMON_SWIFT_FLAGS%
versions: ["nightly-release", "nightly-main"]
Release-Build-Nightly:
command: swift build -c release %COMMON_SWIFT_FLAGS%
versions: ["nightly-release", "nightly-main"]
# The Windows runner installs a pinned Swift patch release. The container image tracks the newest patch release.
# Context: https://github.com/swiftlang/github-workflows/issues/356
windows_use_docker: true
# Strict flags for the release toolchains. The nightly toolchains skip -warnings-as-errors.
linux_version_overrides: |
default: -Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
nightly-release: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
nightly-main: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
macos_runner_pool: nightly
xcode_scheme: swift-log-Package
xcode_targets: |
macOS:
build: true
test: true
wasm_sdk_versions: '["current", "nightly-main"]'
enable_embedded_wasm_sdk_build: false
enable_macos_swiftly: false
enable_freebsd: false
macos-benchmarks:
name: macOS benchmarks
uses: swiftlang/github-workflows/.github/workflows/benchmarks.yml@0.0.18
with:
benchmark_package_paths: '["Benchmarks/NoTraits", "Benchmarks/MaxLogLevelWarning", "Benchmarks/MaxLogLevelNone"]'
enable_linux: false
enable_macos: true
macos_swift_versions: '["current-1", "current"]'
macos_runner_pool: nightly
cmake-build:
name: CMake build
uses: swiftlang/github-workflows/.github/workflows/cmake_build.yml@0.0.18
with:
enable_windows_checks: false
linux_pre_build_command: apt-get update && apt-get install -y ninja-build
-77
View File
@@ -1,77 +0,0 @@
name: PR
permissions:
contents: read
on:
pull_request:
types: [opened, reopened, synchronize]
jobs:
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@0.0.18
with:
license_header_check_project_name: "Swift Logging API"
tests:
name: Tests
uses: swiftlang/github-workflows/.github/workflows/package_test.yml@0.0.18
with:
# After https://github.com/swiftlang/github-workflows/pull/362 fix is available, this can be simplified to:
# windows_command: |
# Debug-Test: swift test
# Release-Build: swift build -c release
# windows_version_overrides: |
# default: -Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
# nightly-release: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
# nightly-main: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
windows_env_vars: '{"COMMON_SWIFT_FLAGS": "--explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable"}'
windows_command: |
Debug-Test:
command: swift test -Xswiftc -warnings-as-errors %COMMON_SWIFT_FLAGS%
versions: ["current-2", "current-1", "current"]
Release-Build:
command: swift build -c release -Xswiftc -warnings-as-errors %COMMON_SWIFT_FLAGS%
versions: ["current-2", "current-1", "current"]
Debug-Test-Nightly:
command: swift test %COMMON_SWIFT_FLAGS%
versions: ["nightly-release", "nightly-main"]
Release-Build-Nightly:
command: swift build -c release %COMMON_SWIFT_FLAGS%
versions: ["nightly-release", "nightly-main"]
# The Windows runner installs a pinned Swift patch release. The container image tracks the newest patch release.
# Context: https://github.com/swiftlang/github-workflows/issues/356
windows_use_docker: true
# Strict flags for the release toolchains. The nightly toolchains skip -warnings-as-errors.
linux_version_overrides: |
default: -Xswiftc -warnings-as-errors --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
nightly-release: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
nightly-main: --explicit-target-dependency-import-check error -Xswiftc -require-explicit-sendable
macos_runner_pool: general
xcode_scheme: swift-log-Package
xcode_targets: |
macOS:
build: true
test: true
wasm_sdk_versions: '["current", "nightly-main"]'
enable_embedded_wasm_sdk_build: false
enable_macos_swiftly: false
enable_freebsd: false
macos-benchmarks:
name: macOS benchmarks
uses: swiftlang/github-workflows/.github/workflows/benchmarks.yml@0.0.18
with:
benchmark_package_paths: '["Benchmarks/NoTraits", "Benchmarks/MaxLogLevelWarning", "Benchmarks/MaxLogLevelNone"]'
enable_linux: false
enable_macos: true
macos_swift_versions: '["current-1", "current"]'
macos_runner_pool: general
cmake-build:
name: CMake build
uses: swiftlang/github-workflows/.github/workflows/cmake_build.yml@0.0.18
with:
enable_windows_checks: false
linux_pre_build_command: apt-get update && apt-get install -y ninja-build
-14
View File
@@ -1,14 +0,0 @@
name: PR label
permissions:
contents: read
pull-requests: read
on:
pull_request:
types: [labeled, unlabeled, opened, reopened, synchronize]
jobs:
semver-label-check:
name: Semantic version label check
uses: swiftlang/github-workflows/.github/workflows/pull_request_label.yml@0.0.18
-42
View File
@@ -1,42 +0,0 @@
.gitignore
**/.gitignore
.licenseignore
.unacceptablelanguageignore
.gitattributes
.git-blame-ignore-revs
.mailfilter
.spi.yml
.swift-format
.editorconfig
.github/*
*.md
*.txt
*.yml
*.yaml
*.json
Package.swift
**/Package.swift
Package@-*.swift
**/Package@-*.swift
Package@swift-*.swift
**/Package@swift-*.swift
Package.resolved
**/Package.resolved
Makefile
*.modulemap
**/*.modulemap
**/*.docc/*
*.xcprivacy
**/*.xcprivacy
*.symlink
**/*.symlink
Dockerfile
**/Dockerfile
Snippets/*
dev/update-benchmark-thresholds
*.crt
**/*.crt
*.pem
**/*.pem
*.der
**/*.der
+6
View File
@@ -0,0 +1,6 @@
Tomer Doron <tomer@apple.com> <tomer.doron@gmail.com>
Tomer Doron <tomer@apple.com> tomer doron <tomer@apple.com>
Tomer Doron <tomer@apple.com> tomer doron <tomerd@apple.com>
Johannes Weiss <johannesweiss@apple.com> <johannes@jweiss.io>
Max Moiseev <moiseev@apple.com> <moiseev@users.noreply.github.com>
Konrad `ktoso` Malawski <ktoso@apple.com> <konrad.malawski@project13.pl>
-62
View File
@@ -1,62 +0,0 @@
{
"version" : 1,
"indentation" : {
"spaces" : 4
},
"tabWidth" : 4,
"fileScopedDeclarationPrivacy" : {
"accessLevel" : "private"
},
"spacesAroundRangeFormationOperators" : false,
"indentConditionalCompilationBlocks" : false,
"indentSwitchCaseLabels" : false,
"lineBreakAroundMultilineExpressionChainComponents" : false,
"lineBreakBeforeControlFlowKeywords" : false,
"lineBreakBeforeEachArgument" : true,
"lineBreakBeforeEachGenericRequirement" : true,
"lineLength" : 120,
"maximumBlankLines" : 1,
"respectsExistingLineBreaks" : true,
"prioritizeKeepingFunctionOutputTogether" : true,
"rules" : {
"AllPublicDeclarationsHaveDocumentation" : false,
"AlwaysUseLiteralForEmptyCollectionInit" : false,
"AlwaysUseLowerCamelCase" : false,
"AmbiguousTrailingClosureOverload" : true,
"BeginDocumentationCommentWithOneLineSummary" : false,
"DoNotUseSemicolons" : true,
"DontRepeatTypeInStaticProperties" : true,
"FileScopedDeclarationPrivacy" : true,
"FullyIndirectEnum" : true,
"GroupNumericLiterals" : true,
"IdentifiersMustBeASCII" : true,
"NeverForceUnwrap" : false,
"NeverUseForceTry" : false,
"NeverUseImplicitlyUnwrappedOptionals" : false,
"NoAccessLevelOnExtensionDeclaration" : true,
"NoAssignmentInExpressions" : true,
"NoBlockComments" : true,
"NoCasesWithOnlyFallthrough" : true,
"NoEmptyTrailingClosureParentheses" : true,
"NoLabelsInCasePatterns" : true,
"NoLeadingUnderscores" : false,
"NoParensAroundConditions" : true,
"NoVoidReturnOnFunctionSignature" : true,
"OmitExplicitReturns" : true,
"OneCasePerLine" : true,
"OneVariableDeclarationPerLine" : true,
"OnlyOneTrailingClosureArgument" : true,
"OrderedImports" : true,
"ReplaceForEachWithForLoop" : true,
"ReturnVoidInsteadOfEmptyTuple" : true,
"UseEarlyExits" : false,
"UseExplicitNilCheckInConditions" : false,
"UseLetInEveryBoundCaseVariable" : false,
"UseShorthandTypeNames" : true,
"UseSingleLinePropertyGetter" : false,
"UseSynthesizedInitializer" : false,
"UseTripleSlashForDocumentationComments" : true,
"UseWhereClausesInForLoops" : false,
"ValidateDocumentationComments" : false
}
}
+15
View File
@@ -0,0 +1,15 @@
# file options
--swiftversion 5.0
--exclude .build
# format options
--self insert
--patternlet inline
--stripunusedargs unnamed-only
--ifdef no-indent
# rules
--disable redundantParens # https://github.com/nicklockwood/SwiftFormat/issues/638
-8
View File
@@ -1,8 +0,0 @@
.DS_Store
/.build
/Packages
xcuserdata/
DerivedData/
.swiftpm/configuration/registries.json
.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
.netrc
-8
View File
@@ -1,8 +0,0 @@
.DS_Store
/.build
/Packages
xcuserdata/
DerivedData/
.swiftpm/configuration/registries.json
.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
.netrc
@@ -1,35 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2026 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Benchmark
import BenchmarksFactory
import Foundation
import Logging
public let benchmarks: @Sendable () -> Void = {
makeBenchmark(loggerLevel: .critical, logLevel: .critical) { logger in
logger.critical("hello, benchmarking world")
}
makeBenchmark(loggerLevel: .critical, logLevel: .critical, "_generic") { logger in
logger.log(level: .critical, "hello, benchmarking world")
}
makeBenchmark(loggerLevel: .critical, logLevel: .critical, "_metadata_set") { logger in
var logger = logger
logger[metadataKey: "user-id"] = "42"
}
makeBenchmark(loggerLevel: .critical, logLevel: .critical, "_logLevel_set") { logger in
var logger = logger
logger.logLevel = .info
}
}
-38
View File
@@ -1,38 +0,0 @@
// swift-tools-version: 6.2.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "MaxLogLevelNone",
platforms: [
.macOS(.v13)
],
products: [
.executable(name: "MaxLogLevelNone", targets: ["MaxLogLevelNone"])
],
dependencies: [
// swift-log
.package(
path: "../../",
traits: ["MaxLogLevelNone"]
),
// Parent Benchmarks
.package(name: "Benchmarks", path: "../"),
.package(url: "https://github.com/ordo-one/benchmark.git", from: "1.29.6"),
],
targets: [
.executableTarget(
name: "MaxLogLevelNone",
dependencies: [
.product(name: "BenchmarksFactory", package: "Benchmarks"),
.product(name: "Benchmark", package: "benchmark"),
.product(name: "Logging", package: "swift-log"),
],
path: "Benchmarks/MaxLogLevelNoneBenchmarks",
plugins: [
.plugin(name: "BenchmarkPlugin", package: "benchmark")
]
)
]
)
@@ -1,4 +0,0 @@
{
"instructions" : 6771,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6767,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6775,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6771,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6875,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6879,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6895,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6867,
"objectAllocCount" : 0
}
-8
View File
@@ -1,8 +0,0 @@
.DS_Store
/.build
/Packages
xcuserdata/
DerivedData/
.swiftpm/configuration/registries.json
.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
.netrc
@@ -1,43 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Benchmark
import BenchmarksFactory
import Foundation
import Logging
public let benchmarks: @Sendable () -> Void = {
makeBenchmark(loggerLevel: .notice, logLevel: .notice) { logger in
logger.notice("hello, benchmarking world")
}
makeBenchmark(loggerLevel: .notice, logLevel: .notice, "_generic") { logger in
logger.log(level: .notice, "hello, benchmarking world")
}
makeBenchmark(loggerLevel: .warning, logLevel: .warning) { logger in
logger.warning("hello, benchmarking world")
}
makeBenchmark(loggerLevel: .warning, logLevel: .warning, "_generic") { logger in
logger.log(level: .warning, "hello, benchmarking world")
}
makeBenchmark(loggerLevel: .notice, logLevel: .notice, "_attributed_generic") { logger in
logger.log(
level: .notice,
"hello, benchmarking world",
metadata: [
"public-key": "\("public-value", sensitivity: .public)",
"private-key": "\("private-value", sensitivity: .sensitive)",
]
)
}
}
@@ -1,38 +0,0 @@
// swift-tools-version: 6.2.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "MaxLogLevelWarning",
platforms: [
.macOS(.v13)
],
products: [
.executable(name: "MaxLogLevelWarning", targets: ["MaxLogLevelWarning"])
],
dependencies: [
// swift-log
.package(
path: "../../",
traits: ["MaxLogLevelWarning"]
),
// Parent Benchmarks
.package(name: "Benchmarks", path: "../"),
.package(url: "https://github.com/ordo-one/benchmark.git", from: "1.29.6"),
],
targets: [
.executableTarget(
name: "MaxLogLevelWarning",
dependencies: [
.product(name: "BenchmarksFactory", package: "Benchmarks"),
.product(name: "Benchmark", package: "benchmark"),
.product(name: "Logging", package: "swift-log"),
],
path: "Benchmarks/MaxLogLevelWarningBenchmarks",
plugins: [
.plugin(name: "BenchmarkPlugin", package: "benchmark")
]
)
]
)
@@ -1,4 +0,0 @@
{
"instructions" : 6775,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6747,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6775,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1251327,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1251327,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6847,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6863,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 6871,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1189887,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1189887,
"objectAllocCount" : 0
}
-8
View File
@@ -1,8 +0,0 @@
.DS_Store
/.build
/Packages
xcuserdata/
DerivedData/
.swiftpm/configuration/registries.json
.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
.netrc
@@ -1,106 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Benchmark
import BenchmarksFactory
import Foundation
import Logging
public let benchmarks: @Sendable () -> Void = {
makeBenchmark(loggerLevel: .error, logLevel: .error, "_generic") { logger in
logger.log(level: .error, "hello, benchmarking world")
}
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_generic") { logger in
logger.log(level: .debug, "hello, benchmarking world")
}
// MARK: - Task-local logger benchmarks
makeBenchmark(loggerLevel: .error, logLevel: .error, "_current_read_fallback") { _ in
blackHole(Logger.current)
}
makeBenchmark(loggerLevel: .error, logLevel: .error, setScopedLogger: true, "_current_read_inside_scope") {
logger in
blackHole(Logger.current)
}
makeBenchmark(loggerLevel: .error, logLevel: .error, setScopedLogger: true, "_withLogger_mergingMetadata") {
logger in
withLogger(mergingMetadata: ["key": "value"]) { inner in
blackHole(inner)
}
}
makeBenchmark(loggerLevel: .error, logLevel: .error, setScopedLogger: true, "_withLogger_handler") { logger in
withLogger(handler: logger.handler) { inner in
blackHole(inner)
}
}
makeBenchmark(loggerLevel: .error, logLevel: .error, "_1_attribute") { logger in
logger.log(
level: .error,
"hello, benchmarking world",
metadata: [
"public-key": "\("public-value", sensitivity: .public)"
]
)
}
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_1_attribute") { logger in
logger.log(
level: .debug,
"hello, benchmarking world",
metadata: [
"public-key": "\("public-value", sensitivity: .public)"
]
)
}
makeBenchmark(loggerLevel: .error, logLevel: .error, "_2_attributes") { logger in
logger.log(
level: .error,
"hello, benchmarking world",
metadata: [
"public-key": "\("public-value", attributes: [BenchmarkSensitivity.public, BenchmarkColor.red])"
]
)
}
makeBenchmark(loggerLevel: .error, logLevel: .debug, "_2_attributes") { logger in
logger.log(
level: .debug,
"hello, benchmarking world",
metadata: [
"public-key": "\("public-value", attributes: [BenchmarkSensitivity.public, BenchmarkColor.red])"
]
)
}
// MARK: - metadata serialization performance
func nestedArrayMetadataValue(depth: Int) -> Logger.MetadataValue {
var value: Logger.MetadataValue = .string("leaf")
for _ in 0..<depth {
value = .array([value])
}
return value
}
for depth in [1, 5, 20, 1_000] {
let nested = nestedArrayMetadataValue(depth: depth)
makeBenchmark(loggerLevel: .info, logLevel: .debug, "_metadata_nesting_depth_\(depth)") { _ in
blackHole(nested.description)
}
}
}
-37
View File
@@ -1,37 +0,0 @@
// swift-tools-version:6.2.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "NoTraits",
platforms: [
.macOS(.v13)
],
products: [
.executable(name: "NoTraits", targets: ["NoTraits"])
],
dependencies: [
// swift-log
.package(
path: "../../"
),
// Parent Benchmarks
.package(name: "Benchmarks", path: "../"),
.package(url: "https://github.com/ordo-one/benchmark.git", from: "1.29.6"),
],
targets: [
.executableTarget(
name: "NoTraits",
dependencies: [
.product(name: "BenchmarksFactory", package: "Benchmarks"),
.product(name: "Benchmark", package: "benchmark"),
.product(name: "Logging", package: "swift-log"),
],
path: "Benchmarks/NoTraitsBenchmarks",
plugins: [
.plugin(name: "BenchmarkPlugin", package: "benchmark")
]
)
]
)
@@ -1,4 +0,0 @@
{
"instructions" : 324863,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 324863,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 320767,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 4751359,
"objectAllocCount" : 1000
}
@@ -1,4 +0,0 @@
{
"instructions" : 5039157355,
"objectAllocCount" : 2016000
}
@@ -1,4 +0,0 @@
{
"instructions" : 81723391,
"objectAllocCount" : 37000
}
@@ -1,4 +0,0 @@
{
"instructions" : 17661951,
"objectAllocCount" : 6000
}
@@ -1,4 +0,0 @@
{
"instructions" : 5644287,
"objectAllocCount" : 2000
}
@@ -1,4 +0,0 @@
{
"instructions" : 7065599,
"objectAllocCount" : 3000
}
@@ -1,4 +0,0 @@
{
"instructions" : 272895,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 284927,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1249279,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 3273000,
"objectAllocCount" : 1000
}
@@ -1,4 +0,0 @@
{
"instructions" : 9117695,
"objectAllocCount" : 4000
}
@@ -1,4 +0,0 @@
{
"instructions" : 324863,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 324863,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 323071,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 4415487,
"objectAllocCount" : 1000
}
@@ -1,4 +0,0 @@
{
"instructions" : 4322989256,
"objectAllocCount" : 2016000
}
@@ -1,4 +0,0 @@
{
"instructions" : 68354047,
"objectAllocCount" : 37000
}
@@ -1,4 +0,0 @@
{
"instructions" : 14581759,
"objectAllocCount" : 6000
}
@@ -1,4 +0,0 @@
{
"instructions" : 5795839,
"objectAllocCount" : 2000
}
@@ -1,4 +0,0 @@
{
"instructions" : 7192575,
"objectAllocCount" : 3000
}
@@ -1,4 +0,0 @@
{
"instructions" : 301055,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 243967,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 1189887,
"objectAllocCount" : 0
}
@@ -1,4 +0,0 @@
{
"instructions" : 2841000,
"objectAllocCount" : 1000
}
@@ -1,4 +0,0 @@
{
"instructions" : 8929279,
"objectAllocCount" : 4000
}
-27
View File
@@ -1,27 +0,0 @@
// swift-tools-version:6.2.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription
let package = Package(
name: "BenchmarksFactory",
platforms: [
.macOS(.v13)
],
products: [
.library(name: "BenchmarksFactory", targets: ["BenchmarksFactory"])
],
dependencies: [
.package(url: "https://github.com/ordo-one/benchmark.git", from: "1.29.6"),
.package(path: "../"), // swift-log
],
targets: [
.target(
name: "BenchmarksFactory",
dependencies: [
.product(name: "Benchmark", package: "benchmark"),
.product(name: "Logging", package: "swift-log"),
]
)
]
)
@@ -1,71 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Benchmark
import Foundation
import Logging
public func makeBenchmark(
loggerLevel: Logger.Level,
logLevel: Logger.Level,
setScopedLogger: Bool = false,
_ suffix: String = "",
_ body: @escaping (Logger) -> Void
) {
let iterations = 1_000_000
let metrics: [BenchmarkMetric] = [.instructions, .objectAllocCount]
var logger = Logger(label: "BenchmarkRunner_\(loggerLevel)_\(logLevel)")
// Use a NoOpLogHandler to avoid polluting the logs
logger.handler = NoOpLogHandler(label: "NoOpLogHandler")
logger.logLevel = loggerLevel
Benchmark(
"\(logLevel)_log_with_\(loggerLevel)_log_level\(suffix)",
configuration: .init(
metrics: metrics,
scalingFactor: .kilo,
maxIterations: iterations,
thresholds: [
.instructions: BenchmarkThresholds(
relative: [
.p90: 10.0 // we only record p90
]
),
.objectAllocCount: BenchmarkThresholds(
absolute: [
.p90: 0 // we only record p90
]
),
]
)
) { benchmark in
if setScopedLogger {
withLogger(logger) { logger in
benchmark.startMeasurement()
for _ in benchmark.scaledIterations {
body(logger)
}
benchmark.stopMeasurement()
}
} else {
benchmark.startMeasurement()
for _ in benchmark.scaledIterations {
body(logger)
}
benchmark.stopMeasurement()
}
}
}
@@ -1,132 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import Logging
// MARK: - Benchmark attributes
public enum BenchmarkSensitivity: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case sensitive = 1
case `public` = 2
}
extension Logger.MetadataValue.StringInterpolation {
@inlinable
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T,
sensitivity: BenchmarkSensitivity
) {
self.appendInterpolation(value, attributes: { $0[BenchmarkSensitivity.self] = sensitivity })
}
}
public enum BenchmarkColor: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case red = 1
case blue = 2
}
extension Logger.MetadataValue.StringInterpolation {
@inlinable
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T,
color: BenchmarkColor
) {
self.appendInterpolation(value, attributes: { $0[BenchmarkColor.self] = color })
}
}
// MARK: - NoOpLogHandler
struct NoOpLogHandler: LogHandler {
let label: String
public var metadataProvider: Logger.MetadataProvider?
init(label: String, metadataProvider: Logger.MetadataProvider?) {
self.label = label
self.metadataProvider = metadataProvider
}
init(label: String) {
self.label = label
self.metadataProvider = LoggingSystem.metadataProvider
}
func log(
event: LogEvent
) {
// Access metadata attributes
if let metadata = event.metadata {
for (_, value) in metadata {
let _ = value.attributes
}
}
// Do nothing
}
func log(
level: Logger.Level,
message: Logger.Message,
metadata explicitMetadata: Logger.Metadata?,
source: String,
file: String,
function: String,
line: UInt
) {
// Access metadata attributes
if let metadata = explicitMetadata {
for (_, value) in metadata {
let _ = value.attributes
}
}
// Do nothing
}
private var _logLevel: Logger.Level?
var logLevel: Logger.Level {
get {
self._logLevel ?? .debug
}
set {
self._logLevel = newValue
}
}
private var _metadataSet = false
private var _metadata = Logger.Metadata() {
didSet {
self._metadataSet = true
}
}
public var metadata: Logger.Metadata {
get {
self._metadata
}
set {
self._metadata = newValue
}
}
// TODO: would be nice to delegate to local copy of logger but StdoutLogger is a reference type. why?
subscript(metadataKey metadataKey: Logger.Metadata.Key) -> Logger.Metadata.Value? {
get {
self._metadata[metadataKey]
}
set {
self._metadata[metadataKey] = newValue
}
}
}
-72
View File
@@ -1,72 +0,0 @@
#===----------------------------------------------------------------------===#
#
# This source file is part of the Swift Logging API open source project
#
# Copyright (c) 2018-2026 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
#
#===----------------------------------------------------------------------===#
cmake_minimum_required(VERSION 3.19)
# Initialize C language first to inspect the compiler environment
project(swift-log LANGUAGES C)
# Set Swift compiler target from C compiler target if not manually set for Windows
if(WIN32 AND NOT CMAKE_Swift_COMPILER_TARGET)
if(CMAKE_C_COMPILER_ARCHITECTURE_ID MATCHES "(ARM64|arm64|aarch64)")
set(CMAKE_Swift_COMPILER_TARGET "aarch64-unknown-windows-msvc" CACHE STRING "Swift compiler target triple")
elseif(CMAKE_C_COMPILER_ARCHITECTURE_ID MATCHES "(X86|x64|AMD64|x86_64)")
set(CMAKE_Swift_COMPILER_TARGET "x86_64-unknown-windows-msvc" CACHE STRING "Swift compiler target triple")
endif()
endif()
# Enable Swift after C defines the architecture
enable_language(Swift)
option(BUILD_SHARED_LIBS "Build shared libraries by default" YES)
set(CMAKE_Swift_LANGUAGE_VERSION 6)
if(CMAKE_Swift_COMPILER_VERSION VERSION_LESS "6.2.3")
message(FATAL_ERROR "swift-log requires Swift compiler version 6.2.3 or newer. Detected version: ${CMAKE_Swift_COMPILER_VERSION}")
endif()
set(SWIFT_LOG_COMMON_COMPILE_OPTIONS
"SHELL:-enable-upcoming-feature ExistentialAny"
"SHELL:-enable-upcoming-feature MemberImportVisibility"
"SHELL:-enable-upcoming-feature InternalImportsByDefault"
"SHELL:-enable-upcoming-feature NonisolatedNonsendingByDefault"
"SHELL:-Xfrontend -require-explicit-sendable"
"SHELL:-package-name swift_log")
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift)
if(MSVC)
message(STATUS "MSVC condition triggered successfully!")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
set(CMAKE_Swift_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()
include(GNUInstallDirs)
include(SwiftSupport)
if(NOT APPLE)
find_package(dispatch QUIET)
find_package(Foundation QUIET)
endif()
add_subdirectory(Sources)
add_subdirectory(cmake/modules)
+3
View File
@@ -0,0 +1,3 @@
# Code of Conduct
The code of conduct for this project can be found at https://swift.org/code-of-conduct.
+39 -58
View File
@@ -45,71 +45,52 @@ Linux beefy.machine 4.4.0-101-generic #124-Ubuntu SMP Fri Nov 10 18:29:59 UTC 20
My system has IPv6 disabled.
```
## Make sure Tests work on Linux
## Writing a Patch
SwiftLog uses Swift Testing to run tests on all supported platforms.
A good SwiftLog patch is:
## Run CI checks locally
1. Concise, and contains as few changes as needed to achieve the end result.
2. Tested, ensuring that any tests provided failed before the patch and pass after it.
3. Documented, adding API documentation as needed to cover new functions and properties.
4. Accompanied by a great commit message, using our commit message template.
You can run the Github Actions workflows locally using
[act](https://github.com/nektos/act). To run all the jobs that run on a pull
request, use the following command:
### Commit Message Template
```
% act pull_request
We require that your commit messages match our template. The easiest way to do that is to get git to help you by explicitly using the template. To do that, `cd` to the root of our repository and run:
git config commit.template dev/git.commit.template
### Make sure Tests work on Linux
SwiftLog uses XCTest to run tests on both macOS and Linux. While the macOS version of XCTest is able to use the Objective-C runtime to discover tests at execution time, the Linux version is not.
For this reason, whenever you add new tests **you have to run a script** that generates the hooks needed to run those tests on Linux, or our CI will complain that the tests are not all present on Linux. To do this, merely execute `ruby ./scripts/generate_linux_tests.rb` at the root of the package and check the changes it made.
### Run `./scripts/soundness.sh`
The scripts directory contains a [soundness.sh script](https://github.com/apple/swift-log/blob/main/scripts/soundness.sh)
that enforces additional checks, like license headers and formatting style.
Please make sure to `./scripts/soundness.sh` before pushing a change upstream, otherwise it is likely the PR validation will fail
on minor changes such as a missing `self.` or similar formatting issues.
> The script also executes the above mentioned `generate_linux_tests.rb`.
For frequent contributors, we recommend adding the script as a [git pre-push hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks), which you can do via executing the following command in the project root directory:
```bash
cat << EOF > .git/hooks/pre-push
#!/bin/bash
if [[ -f "scripts/soundness.sh" ]]; then
scripts/soundness.sh
fi
EOF
```
To run just a single job, use `workflow_call -j <job>`, and specify the inputs
the job expects. For example, to run just shellcheck:
```
% act workflow_call -j soundness --input shell_check_enabled=true
```
To bind-mount the working directory to the container, rather than a copy, use
`--bind`. For example, to run just the formatting, and have the results
reflected in your working directory:
```
% act --bind workflow_call -j soundness --input format_check_enabled=true
```
If you'd like `act` to always run with certain flags, these can be be placed in
an `.actrc` file either in the current working directory or your home
directory, for example:
```
--container-architecture=linux/amd64
--remote-name upstream
--action-offline-mode
```
## Benchmarks
Benchmarks for `swift-log` are in a separate Swift Package in the `Benchmarks` subfolder of this repository.
They use the [`benchmark`](https://github.com/ordo-one/benchmark) plugin.
On Swift versions prior to 6.3 Benchmarks depends on the [`jemalloc`](https://jemalloc.net) memory allocation library, which is used by `benchmark` to capture memory allocation statistics.
An installation guide can be found in the [Getting Started article](https://swiftpackageindex.com/ordo-one/benchmark/documentation/benchmark/gettingstarted#Installing-Prerequisites-and-Platform-Support) of `benchmark`.
Afterwards you can run the benchmarks from CLI by going to the `Benchmarks` subfolder (e.g. `cd Benchmarks`) and invoking:
```
swift package benchmark
```
For more information please refer to `swift package benchmark --help` or the [documentation of `benchmark`](https://swiftpackageindex.com/ordo-one/benchmark/documentation/benchmark).
Which makes the script execute, and only allow the `git push` to complete if the check has passed.
In the case of formatting issues, you can then `git add` the formatting changes, and attempt the push again.
## How to contribute your work
For non-trivial changes that affect the public API, it is good practice to have a discussion phase before writing code. Please follow the [proposal process](Sources/Logging/Docs.docc/Proposals/Proposals.md) to gather feedback and align on the approach with other contributors.
1. Prepare your change, keeping in mind that a good patch is:
- Concise, and contains as few changes as needed to achieve the end result.
- Tested, ensuring that any tests provided failed before the patch and pass after it.
- Documented, adding API documentation as needed to cover new functions and properties.
- Accompanied by a great commit message.
2. Open a pull request at https://github.com/apple/swift-log and wait for code review by the maintainers.
## Automated release process
This repository uses automated releases based on semantic versioning labels. See the [Auto Release Workflow documentation](https://github.com/apple/swift-temporal-sdk/blob/main/.github/workflows/README.md) for details.
Please open a pull request at https://github.com/apple/swift-log. Make sure the CI passes, and then wait for code review.
+27
View File
@@ -0,0 +1,27 @@
For the purpose of tracking copyright, this is the list of individuals and
organizations who have contributed source code to the Swift Logging API.
For employees of an organization/company where the copyright of work done
by employees of that company is held by the company itself, only the company
needs to be listed here.
## COPYRIGHT HOLDERS
- Apple Inc. (all contributors with '@apple.com')
### Contributors
- David Hart <david@hartbit.com>
- Iain Smith <iainsmith@users.noreply.github.com>
- Ian Partridge <i.partridge@uk.ibm.com>
- Johannes Weiss <johannesweiss@apple.com>
- Kevin Sweeney <kevin.t.sweeney@gmail.com>
- Konrad `ktoso` Malawski <ktoso@apple.com>
- Max Moiseev <moiseev@apple.com>
- Tanner <me@tanner.xyz>
- Thomas Krajacic <tkrajacic@users.noreply.github.com>
- Tomer Doron <tomer@apple.com>
**Updating this list**
Please do not edit this file manually. It is generated using `./scripts/generate_contributors_list.sh`. If a name is misspelled or appearing multiple times: add an entry in `./.mailmap`
+9
View File
@@ -26,6 +26,15 @@ components that this product depends on.
-------------------------------------------------------------------------------
This product contains a derivation of the Tony Stone's 'process_test_files.rb'.
* LICENSE (Apache License 2.0):
* https://www.apache.org/licenses/LICENSE-2.0
* HOMEPAGE:
* https://codegists.com/snippet/ruby/generate_xctest_linux_runnerrb_tonystone_ruby
---
This product contains a derivation of the lock implementation and various
scripts from SwiftNIO.
+17 -55
View File
@@ -1,4 +1,17 @@
// swift-tools-version:6.2.3
// swift-tools-version:5.6
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
@@ -6,69 +19,18 @@ let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
.library(name: "InMemoryLogging", targets: ["InMemoryLogging"]),
],
traits: [
.trait(name: "MaxLogLevelDebug", description: "Debug and above available (compiles out trace)"),
.trait(name: "MaxLogLevelInfo", description: "Info and above available (compiles out trace, debug)"),
.trait(name: "MaxLogLevelNotice", description: "Notice and above available (compiles out trace, debug, info)"),
.trait(
name: "MaxLogLevelWarning",
description: "Warning and above available (compiles out trace, debug, info, notice)"
),
.trait(
name: "MaxLogLevelError",
description: "Error and above available (compiles out trace, debug, info, notice, warning)"
),
.trait(name: "MaxLogLevelCritical", description: "Only critical available (compiles out all except critical)"),
.trait(name: "MaxLogLevelNone", description: "All logging compiled out (no log levels available)"),
// By default, no traits are enabled (all log levels available)
.default(enabledTraits: []),
dependencies: [
.package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
],
targets: [
.target(
name: "Logging",
dependencies: [],
exclude: ["CMakeLists.txt"]
),
.target(
name: "InMemoryLogging",
dependencies: ["Logging"],
exclude: ["CMakeLists.txt"]
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
.testTarget(
name: "InMemoryLoggingTests",
dependencies: ["InMemoryLogging", "Logging"]
),
]
)
for target in package.targets
where [.executable, .test, .regular].contains(
target.type
) {
var settings = target.swiftSettings ?? []
// https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md
// Require `any` for existential types.
settings.append(.enableUpcomingFeature("ExistentialAny"))
// https://github.com/swiftlang/swift-evolution/blob/main/proposals/0444-member-import-visibility.md
settings.append(.enableUpcomingFeature("MemberImportVisibility"))
// https://github.com/swiftlang/swift-evolution/blob/main/proposals/0409-access-level-on-imports.md
settings.append(.enableUpcomingFeature("InternalImportsByDefault"))
// https://docs.swift.org/compiler/documentation/diagnostics/nonisolated-nonsending-by-default/
settings.append(.enableUpcomingFeature("NonisolatedNonsendingByDefault"))
// Ensure all public types are explicitly annotated as Sendable or not Sendable.
settings.append(.unsafeFlags(["-Xfrontend", "-require-explicit-sendable"]))
target.swiftSettings = settings
}
+33
View File
@@ -0,0 +1,33 @@
// swift-tools-version:5.1
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
],
targets: [
.target(
name: "Logging",
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
]
)
+33
View File
@@ -0,0 +1,33 @@
// swift-tools-version:5.2
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
],
targets: [
.target(
name: "Logging",
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
]
)
+33
View File
@@ -0,0 +1,33 @@
// swift-tools-version:5.3
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
],
targets: [
.target(
name: "Logging",
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
]
)
+33
View File
@@ -0,0 +1,33 @@
// swift-tools-version:5.4
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
],
targets: [
.target(
name: "Logging",
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
]
)
+33
View File
@@ -0,0 +1,33 @@
// swift-tools-version:5.5
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2019 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import PackageDescription
let package = Package(
name: "swift-log",
products: [
.library(name: "Logging", targets: ["Logging"]),
],
targets: [
.target(
name: "Logging",
dependencies: []
),
.testTarget(
name: "LoggingTests",
dependencies: ["Logging"]
),
]
)
+201 -52
View File
@@ -1,74 +1,223 @@
# SwiftLog
[![](https://img.shields.io/badge/docc-read_documentation-blue)](https://swiftpackageindex.com/apple/swift-log/documentation)
[![](https://img.shields.io/github/v/release/apple/swift-log)](https://github.com/apple/swift-log/releases)
[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fapple%2Fswift-log%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/apple/swift-log)
[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fapple%2Fswift-log%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/apple/swift-log)
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](https://github.com/apple/swift-log?tab=security-ov-file)
- 🔀 **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.
The following snippet shows how to add SwiftLog to your Swift Package:
#### Adding the dependency
`SwiftLog` is designed for Swift 5. To depend on the logging API package, you need to declare your dependency in your `Package.swift`:
```swift
// swift-tools-version: 6.2.3
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")
]
)
]
)
.package(url: "https://github.com/apple/swift-log.git", from: "1.0.0"),
```
Then start logging:
and to your application/library target, add `"Logging"` to your `dependencies`, e.g. like this:
```swift
// Target syntax for Swift up to version 5.1
.target(name: "BestExampleApp", dependencies: ["Logging"]),
// Target for Swift 5.2
.target(name: "BestExampleApp", dependencies: [
.product(name: "Logging", package: "swift-log")
],
```
#### Let's log
```swift
// 1) let's import the logging API package
import Logging
// Create a logger
let logger = Logger(label: "com.example.YourApp")
// 2) we need to create a logger, the label works similarly to a DispatchQueue label
let logger = Logger(label: "com.example.BestExampleApp.main")
// 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")
// 3) we're now ready to use it
logger.info("Hello World!")
```
## Available log handler backends
#### Output
The community has built numerous specialized logging backends.
```
2019-03-13T15:46:38+0000 info: Hello World!
```
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.
#### Default `Logger` behavior
## Building with CMake
`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)
```
While Swift Package Manager (SPM) is the primary build system for development and testing, CMake build support is also available for integrated or mixed build environments if needed. Note that tests are not included in the CMake build, they are managed through Swift Package Manager with `swift test`.
`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 |
| [luoxiu/LogDog](https://github.com/luoxiu/LogDog) | user-friendly logging with sinks and appenders |
| [ShivaHuang/swift-log-SwiftyBeaver](https://github.com/ShivaHuang/swift-log-SwiftyBeaver) | a logging backend for printing colored logging to Xcode console / file, or sending encrypted logging to [SwiftyBeaver](https://swiftybeaver.com) platform. |
| [Apodini/swift-log-elk](https://github.com/Apodini/swift-log-elk) | a logging backend that formats, caches and sends log data to [elastic/logstash](https://github.com/elastic/logstash) |
| [binaryscraping/swift-log-supabase](https://github.com/binaryscraping/swift-log-supabase) | a logging backend that sends log entries to [Supabase](https://github.com/supabase/supabase). |
| [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. |
| 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:
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://github.com/swift-server/sswg/blob/master/process/incubation.md).
- [pitch](https://forums.swift.org/t/logging/16027), [discussion](https://forums.swift.org/t/discussion-server-logging-api/18834), [feedback](https://forums.swift.org/t/feedback-server-logging-api-with-revisions/19375)
- [log levels](https://forums.swift.org/t/logging-levels-for-swifts-server-side-logging-apis-and-new-os-log-apis/20365)
[api-docs]: https://apple.github.io/swift-log/docs/current/Logging/Structs/Logger.html
+43
View File
@@ -0,0 +1,43 @@
# Security
This document specifies the security process for the SwiftLog project.
## Disclosures
### Private Disclosure Process
The SwiftLog maintainers ask that known and suspected vulnerabilities be
privately and responsibly disclosed by emailing
[sswg-security-reports@forums.swift.org](mailto:sswg-security-reports@forums.swift.org)
with the all the required detail.
**Do not file a public issue.**
#### When to report a vulnerability
* You think you have discovered a potential security vulnerability in SwiftLog.
* You are unsure how a vulnerability affects SwiftLog.
#### What happens next?
* A member of the team will acknowledge receipt of the report within 3
working days (United States). This may include a request for additional
information about reproducing the vulnerability.
* We will privately inform the Swift Server Work Group ([SSWG][sswg]) of the
vulnerability within 10 days of the report as per their [security
guidelines][sswg-security].
* Once we have identified a fix we may ask you to validate it. We aim to do this
within 30 days. In some cases this may not be possible, for example when the
vulnerability exists at the protocol level and the industry must coordinate on
the disclosure process.
* If a CVE number is required, one will be requested from [MITRE][mitre]
providing you with full credit for the discovery.
* We will decide on a planned release date and let you know when it is.
* Prior to release, we will inform major dependents that a security-related
patch is impending.
* Once the fix has been released we will publish a security advisory on GitHub
and in the Server → Security Updates category on the [Swift forums][swift-forums-sec].
[sswg]: https://github.com/swift-server/sswg
[sswg-security]: https://github.com/swift-server/sswg/blob/main/security/README.md
[swift-forums-sec]: https://forums.swift.org/c/server/security-updates/
[mitre]: https://cveform.mitre.org/
-8
View File
@@ -1,8 +0,0 @@
// 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!")
-16
View File
@@ -1,16 +0,0 @@
#===----------------------------------------------------------------------===#
#
# This source file is part of the Swift Logging API open source project
#
# Copyright (c) 2018-2026 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
#
#===----------------------------------------------------------------------===#
add_subdirectory(Logging)
add_subdirectory(InMemoryLogging)
-28
View File
@@ -1,28 +0,0 @@
#===----------------------------------------------------------------------===#
#
# This source file is part of the Swift Logging API open source project
#
# Copyright (c) 2018-2026 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
#
#===----------------------------------------------------------------------===#
add_library(InMemoryLogging
"InMemoryLogHandler.swift"
)
set_target_properties(InMemoryLogging PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "$<BUILD_INTERFACE:$<TARGET_PROPERTY:Swift_MODULE_DIRECTORY>>;$<BUILD_INTERFACE:$<TARGET_FILE_DIR:InMemoryLogging>>")
target_compile_options(InMemoryLogging PRIVATE
${SWIFT_LOG_COMMON_COMPILE_OPTIONS})
target_link_libraries(InMemoryLogging PRIVATE Logging)
_install_target(InMemoryLogging)
set_property(GLOBAL APPEND PROPERTY SwiftLog_EXPORTS InMemoryLogging)
@@ -1,194 +0,0 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Logging API open source project
//
// Copyright (c) 2018-2022 Apple Inc. and the Swift Logging API project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift Logging API project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
public import Logging
/// A custom log handler which just collects logs into memory.
/// You can then retrieve an array of those log entries.
/// Example use cases include testing and buffering.
///
/// # Usage
/// ```swift
/// let logHandler = InMemoryLogHandler()
/// let logger = Logger(
/// label: "MyApp",
/// factory: { _ in
/// logHandler
/// }
/// )
/// // Use logger to emit some logs
/// someFunction(logger: logger)
///
/// // Retrieve what was logged
/// let logEntries = logger.entries
/// ```
///
public struct InMemoryLogHandler: LogHandler {
public var metadata: Logger.Metadata = [:]
public var metadataProvider: Logger.MetadataProvider?
public var logLevel: Logger.Level = .info
private let logStore: LogStore
/// A struct representing a log entry.
public struct Entry: Sendable, Equatable {
/// The level we logged at.
public var level: Logger.Level
/// The message which was logged.
public var message: Logger.Message
/// The error which was logged.
public var error: (any Error)?
/// The metadata which was logged.
public var metadata: Logger.Metadata
public init(level: Logger.Level, message: Logger.Message, metadata: Logger.Metadata) {
self.level = level
self.message = message
self.metadata = metadata
}
public init(
level: Logger.Level,
message: Logger.Message,
error: (any Error)?,
metadata: Logger.Metadata
) {
self.level = level
self.message = message
self.error = error
self.metadata = metadata
}
public static func == (lhs: Entry, rhs: Entry) -> Bool {
lhs.level == rhs.level
&& lhs.message == rhs.message
&& lhs.metadata == rhs.metadata
&& errorsEqual(lhs.error, rhs.error)
}
private static func errorsEqual(_ lhs: (any Error)?, _ rhs: (any Error)?) -> Bool {
switch (lhs, rhs) {
case (nil, nil):
return true
case let (l?, r?):
return "\(l)" == "\(r)" && String(reflecting: type(of: l)) == String(reflecting: type(of: r))
default:
return false
}
}
}
private final class LogStore: @unchecked Sendable {
private var _entries: [Entry] = []
private let lock = Lock()
fileprivate func append(
level: Logger.Level,
message: Logger.Message,
error: (any Error)?,
metadata: Logger.Metadata
) {
self.lock.withLockVoid {
self._entries.append(
Entry(
level: level,
message: message,
error: error,
metadata: metadata
)
)
}
}
fileprivate func clear() {
self.lock.withLockVoid {
_entries.removeAll()
}
}
var entries: [Entry] {
self.lock.withLock { self._entries }
}
}
private init(logStore: LogStore) {
self.logStore = logStore
}
/// Create a new ``InMemoryLogHandler``.
public init() {
self.init(logStore: .init())
}
public func log(event: LogEvent) {
var merged = self.metadata
if let provider = self.metadataProvider {
let provided = provider.get()
merged.merge(provided, uniquingKeysWith: { _, rhs in rhs })
}
if let eventMetadata = event.metadata {
merged.merge(eventMetadata, uniquingKeysWith: { _, rhs in rhs })
}
self.logStore.append(
level: event.level,
message: event.message,
error: event.error,
metadata: merged
)
}
@available(*, deprecated, renamed: "log(event:)")
public func log(
level: Logger.Level,
message: Logger.Message,
metadata: Logger.Metadata?,
source: String,
file: String,
function: String,
line: UInt
) {
self.log(
event: LogEvent(
level: level,
message: message,
metadata: metadata,
source: source,
file: file,
function: function,
line: line
)
)
}
public subscript(metadataKey key: String) -> Logger.Metadata.Value? {
get {
self.metadata[key]
}
set {
self.metadata[key] = newValue
}
}
/// All logs that have been collected.
public var entries: [Entry] {
self.logStore.entries
}
/// Clear all entries.
public func clear() {
self.logStore.clear()
}
}
-36
View File
@@ -1,36 +0,0 @@
#===----------------------------------------------------------------------===#
#
# This source file is part of the Swift Logging API open source project
#
# Copyright (c) 2018-2026 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
#
#===----------------------------------------------------------------------===#
add_library(Logging
"Handlers/MultiplexLogHandler.swift"
"Handlers/StreamLogHandler.swift"
"Handlers/SwiftLogNoOpLogHandler.swift"
"Locks.swift"
"LogEvent.swift"
"LogHandler.swift"
"Logger+Attributes.swift"
"Logger+With.swift"
"Logger.swift"
"LoggingSystem.swift"
"MetadataProvider.swift"
)
set_target_properties(Logging PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "$<BUILD_INTERFACE:$<TARGET_PROPERTY:Swift_MODULE_DIRECTORY>>;$<BUILD_INTERFACE:$<TARGET_FILE_DIR:Logging>>")
target_compile_options(Logging PRIVATE
${SWIFT_LOG_COMMON_COMPILE_OPTIONS})
_install_target(Logging)
set_property(GLOBAL APPEND PROPERTY SwiftLog_EXPORTS Logging)
@@ -1,138 +0,0 @@
# 001: Choosing log levels
Select 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 less severe** (info, debug, trace).
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.
Each level serves different purposes:
##### 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 - Don't use 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: ["sql": "\(query)"])
logger.debug("Request completed", metadata: ["status": "\(status)"])
```
@@ -1,96 +0,0 @@
# 002: Structured logging
Use metadata to create machine-readable, searchable log entries.
## Overview
Structured logging uses metadata to separate human-readable messages from
machine-readable data. This practice makes logs easier to search, filter, and
analyze programmatically while maintaining readability.
### Motivation
Traditional string-based logging embeds all information in the message text,
making it more difficult for automated tools to parse and extract.
Structured logging separates these concerns; messages provide human readable
context while metadata provides structured data for tooling.
### Example
#### Recommended: Structured logging
```swift
// ✅ Structured - message provides context, metadata provides data
logger.info(
"Accepted connection",
metadata: [
"connection.id": "\(id)",
"connection.peer": "\(peer)",
"connections.total": "\(count)"
]
)
logger.error(
"Database query failed",
metadata: [
"query.retries": "\(retries)",
"query.error": "\(error)",
"query.duration": "\(duration)"
]
)
```
### Advanced: Nested metadata for complex data
```swift
// ✅ Complex structured data
logger.trace(
"HTTP request started",
metadata: [
"request.id": "\(requestId)",
"request.method": "GET",
"request.path": "/api/users",
"request.headers": [
"user-agent": "\(userAgent)"
],
"client.ip": "\(clientIP)",
"client.country": "\(country)"
]
)
```
#### Avoid: Unstructured logging
```swift
// ❌ Not structured - hard to parse programmatically
logger.info("Accepted connection \(id) from \(peer), total: \(count)")
logger.error("Database query failed after \(retries) retries: \(error)")
```
### Metadata key conventions
Use hierarchical dot-notation for related fields:
```swift
// ✅ Good: Hierarchical keys
logger.debug(
"Database operation completed",
metadata: [
"db.operation": "SELECT",
"db.table": "users",
"db.duration": "\(duration)",
"db.rows": "\(rowCount)"
]
)
// ✅ Good: Consistent prefixing
logger.info(
"HTTP response",
metadata: [
"http.method": "POST",
"http.status": "201",
"http.path": "/api/users",
"http.duration": "\(duration)"
]
)
```
@@ -1,185 +0,0 @@
# 003: Logger propagation in libraries
Propagate caller context by accepting a `Logger` parameter or reading the task-local
``Logger/current`` — never by constructing your own logger.
## Overview
Libraries should obtain a `Logger` in one of two ways: accept one through a method
parameter or read ``Logger/current`` from the task-local. Both approaches
preserve the caller's metadata, log level, and handler choice. Constructing a logger
inside a library — via ``Logger/init(label:)`` — takes those choices away from the
application and breaks metadata propagation.
### Motivation
The application controls logging: which backend, which log level, which metadata
travels with each request. Libraries that participate in this picture obtain a logger
the application has set up, rather than constructing their own from scratch. This
ensures correlation IDs and other contextual metadata flow through the entire call
stack, and gives the application a single place to redirect or filter all log output.
Two propagation mechanisms are available, and they coexist. Choose the explicit
parameter when the library's API already accepts a `Logger` (or it's natural to add
one) — the call site stays declarative about what gets logged where. Choose the
task-local when adding a `logger:` parameter would pollute an API that otherwise has
no logging concern in its signature. Application code binds the initial task-local;
library code reads it and updates the metadata.
### Example
#### Recommended: Read ``Logger/current`` from the task-local
When there is no `logger:` parameter in the API, read the
task-local. The application's accumulated metadata (`request.id`, etc.) flows in
automatically without an explicit hand-off.
```swift
// ✅ Good: Library reads Logger.current; caller scopes context via withLogger.
public struct AnalyticsClient {
public func track(_ event: String) {
Logger.current.info("event", metadata: ["event.name": "\(event)"])
}
}
// Application binds at @main and scopes per-request metadata.
@main
struct MyServer {
static func main() async throws {
let logger = Logger(label: "my-server")
try await withLogger(logger) { _ in
try await runServices()
}
}
}
func handleRequest(_ req: HTTPRequest) async throws {
try await withLogger(mergingMetadata: ["request.id": "\(req.id)"]) { _ in
AnalyticsClient().track("request.received") // sees request.id automatically
}
}
```
For per-statement metadata, pass it via the `metadata:` parameter on the log call:
```swift
Logger.current.info("step", metadata: ["step.name": "validate"])
```
For a few back-to-back lines, take a local copy and stamp metadata there — also no
propagation:
```swift
var local = Logger.current
local[metadataKey: "step.name"] = "validate"
local.info("entering")
local.info("done")
```
#### Alternative: Accept logger through method parameters
```swift
// ✅ Good: Pass the logger through method parameters,
// default to Logger.current in the public API.
struct RequestProcessor {
func processRequest(_ request: HTTPRequest, logger: Logger = Logger.current) async throws -> HTTPResponse {
// Add structured metadata that every log statement should contain.
var logger = logger
logger[metadataKey: "request.method"] = "\(request.method)"
logger[metadataKey: "request.path"] = "\(request.path)"
logger[metadataKey: "request.id"] = "\(request.id)"
logger.debug("Processing request")
// Pass the logger down to maintain metadata context.
let validatedData = try validateRequest(request, logger: logger)
let result = try await executeBusinessLogic(validatedData, logger: logger)
logger.debug("Request processed successfully")
return result
}
private func validateRequest(_ request: HTTPRequest, logger: Logger) throws -> ValidatedRequest {
logger.debug("Validating request parameters")
return ValidatedRequest(request)
}
private func executeBusinessLogic(_ data: ValidatedRequest, logger: Logger) async throws -> HTTPResponse {
logger.debug("Executing business logic")
let dbResult = try await databaseService.query(data.query, logger: logger)
logger.debug("Business logic completed")
return HTTPResponse(data: dbResult)
}
}
```
#### Alternative: Accept logger through initializer for long-lived components
```swift
// ⚠️ Acceptable: Logger through initializer for long-lived components
final class BackgroundJobProcessor {
private let logger: Logger
init(logger: Logger) {
self.logger = logger
}
func run() async {
// Execute some long running work
logger.debug("Update about long running work")
// Execute some more long running work
}
}
```
#### Avoid: Libraries creating their own loggers
Constructing ``Logger/init(label:)`` inside a library takes control over the handler, log
level, and base metadata away from the application. The application cannot redirect,
filter, or silence the library's output.
```swift
// ❌ Bad: Library creates its own logger — loses caller's context.
final class MyLibrary {
private let logger = Logger(label: "MyLibrary")
}
```
``Logger/init(label:)`` is for the application — typically at `@main` paired with `.withLogger()`.
Library code, including internal application modules, should not construct loggers.
If they do, setting up the global factory with ``LoggingSystem/bootstrap(_:)`` allows
enforcing a specific factory on all the loggers constructed in the process. This
does not necessary need to be the same factory as was used to create the task-local
logger.
#### Avoid: Relying on ``Logger/current`` across non-Task boundaries
``Logger/current`` is backed by a `TaskLocal` and propagates through Swift's structured
concurrency model only. Callbacks invoked on non-Task threads — GCD blocks,
`URLSession` completion handlers, delegate methods dispatched onto specific queues,
`NotificationCenter` observers, C-API callbacks — see the *default* fallback logger,
not the bound one. Metadata bound by the calling `Task` is invisible inside those
callbacks.
```swift
// ❌ Bad: completion handler runs without the Task context; Logger.current is the fallback.
try await withLogger(mergingMetadata: ["request.id": "r1"]) { _ in
URLSession.shared.dataTask(with: req) { data, _, _ in
Logger.current.info("response") // empty-label fallback, no request.id
}.resume()
}
```
For libraries with async completion-handler APIs, accept an explicit `Logger` parameter.
If capturing and rebinding across the boundary is the only option:
```swift
// ✅ Good: capture before the boundary, rebind on the other side.
try await withLogger(mergingMetadata: ["request.id": "r1"]) { captured in
URLSession.shared.dataTask(with: req) { data, _, _ in
withLogger(captured) { _ in // Bind Logger.current inside the callback
Logger.current.info("response") // Logger.current now has request.id
}
}.resume()
}
```
@@ -1,81 +0,0 @@
# 004: Testing code that logs
Validate what you code logs by capturing entries in memory rather than bootstrapping a process-wide backend.
## Overview
Import and use `InMemoryLogging`, which provides an `InMemoryLogHandler` that collects every emitted record into an array you can inspect.
Keep a handler you create local to each test.
Each handler that you create in a test has no shared state, so the test stays isolated is safe to run on parallel with other tests.
Don't use ``LoggingSystem/bootstrap(_:)`` in a test, it sets one process-wide backend and traps if called twice.
Add the product to your test target:
```swift
.product(name: "InMemoryLogging", package: "swift-log")
```
### Capture logs from a logger you pass in
When the code under test accepts a `Logger` (see <doc:003-AcceptingLoggers>), back it with
an `InMemoryLogHandler` and validate the results on `entries`.
The following code illustrates how to set up and validate a handler using `InMemoryLogging` to check the expected results:
```swift
import InMemoryLogging
import Logging
import Testing
struct RequestProcessor {
func handle(id: String, logger: Logger) {
logger.info("request received", metadata: ["request.id": "\(id)"])
}
}
@Test
func stampsRequestID() {
let handler = InMemoryLogHandler()
let logger = Logger(label: "test", factory: { _ in handler })
RequestProcessor().handle(id: "42", logger: logger)
#expect(handler.entries.count == 1)
#expect(handler.entries[0].message == "request received")
#expect(handler.entries[0].metadata["request.id"] == "42")
}
```
Each `Entry` is equatable and exposes `level`, `message`, `metadata`, and `error`.
The handler log level defaults to ``Logger/Level/info``; set `handler.logLevel = .trace` before you use it to
capture lower levels.
### Capture logs from code that reads `Logger.current`
When the code you want to test reads the task-local ``Logger/current`` instead of taking a parameter, bind an `InMemoryLogHandler` for the scope of that by using ``withLogger(logLevel:handler:metadata:_:)-2pd9p``.
The handler shares its storage by reference, so the copy you hold sees what was logged.
Bind the handler for the scope of the call and validate the captured entry:
```swift
import InMemoryLogging
import Logging
import Testing
struct AnalyticsClient {
func track(_ event: String) {
Logger.current.info("event", metadata: ["event.name": "\(event)"])
}
}
@Test
func tracksEvent() {
let handler = InMemoryLogHandler()
withLogger(handler: handler) { _ in
AnalyticsClient().track("signup") // calls Logger.current.info(...)
}
#expect(handler.entries.count == 1)
#expect(handler.entries[0].metadata["event.name"] == "signup")
}
```
@@ -1,84 +0,0 @@
# Disable log levels during compilation
SwiftLog provides compile-time traits to eliminate less severe log levels from
your binary reducing the runtime overhead.
## Overview
### Motivation
When deploying applications to production, you often know in advance which log
levels will never be needed. For example, a production service might only need
warning and above, while trace and debug levels are only useful during
development. By using traits, you can completely remove these unnecessary log
levels at compile time, achieving zero runtime overhead.
### Available traits
SwiftLog defines seven maximum log level traits, ordered from most permissive
to most restrictive:
- `MaxLogLevelDebug`: Debug and above available (compiles out trace)
- `MaxLogLevelInfo`: Info and above available (compiles out trace, debug)
- `MaxLogLevelNotice`: Notice and above available (compiles out trace, debug,
info)
- `MaxLogLevelWarning`: Warning and above available (compiles out trace, debug,
info, notice)
- `MaxLogLevelError`: Error and above available (compiles out trace, debug,
info, notice, warning)
- `MaxLogLevelCritical`: Only critical available (compiles out all except
critical)
- `MaxLogLevelNone`: All logging compiled out (no log levels available)
By default (when no traits are specified), all log levels are available.
When you specify a maximum log level trait, all less severe levels are
completely removed from your binary at compile time. This applies to both
level-specific methods (e.g., `logger.debug()`) and calls to the generic
`logger.log(level:)` method. Traits are additive. If multiple max level traits
are specified, the most restrictive one takes effect.
> Note: Traits should only be set by the applications and not libraries as
> any traits defined in a transitive dependency will affect the whole resolution tree.
### Example
To enable a trait, specify it when declaring your package dependency:
```swift
// In your Package.swift:
dependencies: [
.package(
url: "https://github.com/apple/swift-log.git",
from: "1.0.0",
traits: ["MaxLogLevelWarning"]
)
]
```
With `MaxLogLevelWarning` enabled, all trace, debug, info, and notice log
statements are compiled out:
```swift
// These become no-ops (compiled out completely):
logger.trace("This will not be in the binary")
logger.debug("This will not be in the binary")
logger.info("This will not be in the binary")
logger.notice("This will not be in the binary")
logger.log(level: .debug, "This will not log anything")
// These work normally:
logger.warning("This still works")
logger.error("This still works")
logger.critical("This still works")
logger.log(level: .error, "This still works")
```
When `MaxLogLevelNone` is enabled no log statement can ever fire, so
mutations that only configure the underlying ``LogHandler`` for future log
statements are also compiled out. Specifically, the body of the
``Logger/subscript(metadataKey:)`` setter and the body of the
``Logger/logLevel`` setter become empty, so calls like
`logger[metadataKey: "user-id"] = "\(id)"` and `logger.logLevel = .info`
do not reach the handler. Reads continue to work and return whatever the
handler reports.
@@ -1,366 +0,0 @@
# 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(event: LogEvent) {
let timestamp = ISO8601DateFormatter().string(from: Date())
let levelString = event.level.rawValue.uppercased()
// Merge handler metadata with message metadata
let combinedMetadata = Self.prepareMetadata(
base: self.metadata,
explicit: event.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)]: \(event.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
}
}
```
### Constructing handlers that need more than a label
Many log handler backends need more than a `label` in order to construct them: a file path, a remote address, credentials, or
a buffer. A handler is an ordinary value that you construct, so nothing constrains its
initializer — it can take any parameters it needs, and it can `throw`. There is no
protocol-required `init(label:)`. The single `label` argument on factory methods such as
`StreamLogHandler.standardOutput(label:)` is a convention, not a requirement.
Open expensive or fallible resources, such as a file, a socket, early and up front in your own initializer that can `throw`, so that failures surface at setup time.
``LogHandler/log(event:)`` cannot throw, so an error deferred to logging time has nowhere to go.
Keep the handler `struct` cheap and copyable by placing any shared resource behind a thread-safe reference type.
Value semantics apply to a handler's *configuration* — its level and metadata — not its *destination*, so copies writing to
the same file are correct and expected.
The `FileLogHandler` below opens its file once, in an initializer that throws and exception when you create it with an overlapping `Destination`.
The handler `struct` itself stays a cheap, copyable value:
```swift
import Foundation
import Logging
import Synchronization
/// A log handler that appends formatted log lines to a file on disk.
public struct FileLogHandler: LogHandler {
/// The shared, thread-safe destination. Open it once, then share it across handlers: because
/// the destination is a reference type, all those value-semantic handlers write through a single
/// locked file handle.
public final class Destination: @unchecked Sendable {
private let fileHandle: Mutex<FileHandle>
/// Opens `url` for appending. All validation happens here, at setup time.
public init(writingTo url: URL) throws {
let fileManager = FileManager.default
if !fileManager.fileExists(atPath: url.path) {
guard fileManager.createFile(atPath: url.path, contents: nil) else {
throw Failure.cannotCreateFile(url)
}
}
self.fileHandle = .init(try FileHandle(forWritingTo: url))
_ = try self.fileHandle.withLock { try $0.seekToEnd() }
}
func write(_ line: String) {
// `log(event:)` cannot throw, so a write failure is handled here, not propagated.
do {
try self.fileHandle.withLock { try $0.write(contentsOf: Data(line.utf8)) }
} catch {
// Surface the failure without crashing the application.
try? FileHandle.standardError.write(contentsOf: Data("FileLogHandler: \(error)\n".utf8))
}
}
/// Flushes and closes the file. Call this during shutdown.
public func close() {
self.fileHandle.withLock { try? $0.close() }
}
}
/// Errors thrown while opening a ``Destination``.
public enum Failure: Error {
case cannotCreateFile(URL)
}
private let label: String
private let destination: Destination
// Per-logger configuration — this is what must carry value semantics.
public var logLevel: Logger.Level = .info
public var metadata: Logger.Metadata = [:]
public var metadataProvider: Logger.MetadataProvider?
/// Cheap and non-throwing, so it is safe to call from a bootstrap factory closure per label.
public init(label: String, destination: Destination, metadataProvider: Logger.MetadataProvider? = nil) {
self.label = label
self.destination = destination
self.metadataProvider = metadataProvider
}
public func log(event: LogEvent) {
var merged = self.metadata
if let provided = self.metadataProvider?.get() {
merged.merge(provided, uniquingKeysWith: { _, new in new })
}
if let explicit = event.metadata {
merged.merge(explicit, uniquingKeysWith: { _, new in new })
}
let renderedMetadata =
merged.isEmpty
? ""
: " " + merged.sorted { $0.key < $1.key }.map { "\($0.key)=\($0.value)" }.joined(separator: " ")
self.destination.write("\(event.level) \(self.label):\(renderedMetadata) \(event.message)\n")
}
public subscript(metadataKey key: String) -> Logger.Metadata.Value? {
get { self.metadata[key] }
set { self.metadata[key] = newValue }
}
}
```
#### Using your log handler
Construct the destination where you can use `try` to build a logger backed by your handler, then bind it
as ``Logger/current`` for the application's lifetime using `withLogger`:
```swift
// Open the file once, where setup can throw.
let destination = try FileLogHandler.Destination(writingTo: URL(fileURLWithPath: "/var/log/myapp.log"))
defer { destination.close() }
// Build a logger backed by the handler, then bind it for the scope.
let logger = Logger(label: "app") { label in
FileLogHandler(label: label, destination: destination)
}
try await withLogger(logger) { logger in
logger.info("Application started")
// Code in this scope reads the handler through Logger.current.
}
```
The `try` on `Destination` is where setup fails if the path is unwritable: validation happens
before the logger is constructed, so you never need a throwing factory overload.
Use the same pattern for handlers that connect to a remote service:
- validate and connect up front
- keep ``LogHandler/log(event:)`` non-blocking by buffering onto a background task
- provide a `close()` or `shutdown()` (or use [Swift Service Lifecycle](https://github.com/swift-server/swift-service-lifecycle) service) to flush on shutdown
For runtime failures the handler can't avoid, such as a full disk or a broken pipe, degrade gracefully inside `log(event:)` by dropping the log message, retrying, or reporting to `stderr`.
Never call `fatalError` on the logging path.
### 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(event: LogEvent) {
let timestamp = ISO8601DateFormatter().string(from: Date())
let levelString = event.level.rawValue.uppercased()
// Merge handler metadata with message metadata
let combinedMetadata = Self.prepareMetadata(
base: self.metadata,
provider: self.metadataProvider,
explicit: event.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)]: \(event.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
}
}
```
#### Reading metadata attributes in LogHandlers
Metadata values can carry attributes alongside their string representation. Attributes are embedded inside
`MetadataValue` via the `.stringConvertible` case and are accessible through the `value.attributes` property. This
enables features like sensitivity annotations without any changes to your handler's protocol conformance.
To read attributes in your log handler:
```swift
public func log(event: LogEvent) {
// Merge handler metadata, provider metadata, and event metadata as usual
var merged = self.metadata
if let provider = self.metadataProvider {
merged.merge(provider.get(), uniquingKeysWith: { _, rhs in rhs })
}
if let eventMetadata = event.metadata {
merged.merge(eventMetadata, uniquingKeysWith: { _, rhs in rhs })
}
// Read attributes from individual values:
for (key, value) in merged {
let attributes = value.attributes // Empty if the value carries no attributes
// Process based on your handler's needs
// For example, check for a custom attribute:
// if attributes[MyAttribute.self] == .flagged { ... }
}
}
```
**Key considerations:**
- **Opt-in inspection**: Attributes are invisible unless you call `value.attributes`. Handlers that do not care about
attributes work without any changes.
- **No new protocol requirements**: Reading attributes does not require implementing any new `LogHandler` properties
or subscripts. The `metadata` property and `metadataKey` subscript work exactly as before.
- **Attributes flow through metadata**: Attributed values flow naturally through metadata merging, `MetadataProvider`,
and `MultiplexLogHandler` — no special handling needed.
### 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``
@@ -2,7 +2,7 @@
## Topics
### Log Levels
### Log levels
- ``trace``
- ``debug``
@@ -1,44 +0,0 @@
# 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>
- <doc:002-StructuredLogging>
- <doc:003-AcceptingLoggers>
- <doc:004-TestingLogging>
@@ -1,49 +0,0 @@
# Proposals
Collaborate on API changes to SwiftLog by writing a proposal.
## Overview
For non-trivial changes that affect the public API, the SwiftLog project adopts a lightweight version of the [Swift Evolution](https://github.com/apple/swift-evolution/blob/main/process.md) process.
Writing a proposal first helps discuss multiple possible solutions early, apply useful feedback from other contributors, and avoid reimplementing the same feature multiple times.
While it's encouraged to get feedback by opening a pull request with a proposal early in the process, it's also important to consider the complexity of the implementation when evaluating different solutions. For example, this might mean including a link to a branch containing a prototype implementation of the feature in the pull request description.
> Note: The goal of this process is to help solicit feedback from the whole community around the project, and we will continue to refine the proposal process itself. Use your best judgement, and don't hesitate to propose changes to the proposal structure itself!
### Steps
1. Make sure there's a GitHub issue for the feature or change you would like to propose.
2. Duplicate the `SLG-NNNN.md` document and replace `NNNN` with the next available proposal number.
3. Link the GitHub issue from your proposal, and fill in the proposal.
4. Open a pull request with your proposal and solicit feedback from other contributors.
5. Once a maintainer confirms that the proposal is ready for review, the state is updated accordingly. The review period is 7 days, and ends when one of the maintainers marks the proposal as Ready for Implementation, or Deferred.
6. Before the pull request is merged, there should be an implementation ready, either in the same pull request, or a separate one, linked from the proposal.
7. The proposal is considered Approved once the implementation, proposal PRs have been merged, and, if originally disabled by a feature flag, feature flag enabled unconditionally.
If you have any questions, ask in an issue on GitHub.
### Possible review states
- Awaiting Review
- In Review
- Ready for Implementation
- In Preview
- Approved
- Deferred
## Topics
### Implemented Proposals
- <doc:SLG-0001-metadata-providers>
- <doc:SLG-0002>
- <doc:SLG-0003>
- <doc:SLG-0004-metadata-value-attributes>
- <doc:SLG-0005-log-event-LogHandler-API>
- <doc:SLG-0006-task-local-logger>
### Proposal Template
- <doc:SLG-NNNN>
@@ -1,173 +0,0 @@
# SLG-0002: Compile-time log level elimination using traits
Enable compile-time elimination of log levels to achieve zero runtime overhead for logs that will never be needed in production.
## Overview
- Proposal: SLG-0002
- Author(s): [Vladimir Kukushkin](https://github.com/kukushechkin)
- Status: **Approved**
- Issue: [apple/swift-log#378](https://github.com/apple/swift-log/issues/378)
- Implementation:
- [apple/swift-log#389](https://github.com/apple/swift-log/pull/389)
- Related links:
- [Lightweight proposals process description](https://github.com/apple/swift-log/blob/main/Sources/Logging/Docs.docc/Proposals/Proposals.md)
### Introduction
Add Swift package traits to allow applications to compile out less severe log levels, completely eliminating their runtime overhead from the final binary.
### Motivation
In production deployments, applications often know in advance which log levels will never be needed. For example, a production service typically only needs warning and above, while trace and debug levels are exclusively useful during development. Currently, even with the log level set to `.warning` at runtime, the code for trace and debug statements still exists in the binary and incurs overhead.
For performance-critical applications or resource-constrained environments, this overhead is unacceptable. Applications need a way to completely remove unnecessary log levels at compile time, achieving zero runtime cost.
Before this proposal, the only workarounds were:
- Manually wrapping log statements in `#if DEBUG` checks (error-prone and verbose)
- Accepting the runtime overhead (unacceptable for many use cases)
### Proposed solution
This proposal introduces seven package traits that correspond to maximum log level thresholds. Applications specify a trait when declaring their dependency on SwiftLog, and all less severe log levels are completely compiled out.
In your `Package.swift`:
```swift
dependencies: [
.package(
url: "https://github.com/apple/swift-log.git",
from: "1.0.0",
traits: ["MaxLogLevelWarning"]
)
]
```
With `MaxLogLevelWarning` enabled:
```swift
// These become no-ops (compiled out completely):
logger.trace("This will not be in the binary")
logger.debug("This will not be in the binary")
logger.info("This will not be in the binary")
logger.notice("This will not be in the binary")
logger.log(level: .debug, "This will not log anything")
// These work normally:
logger.warning("This still works")
logger.error("This still works")
logger.critical("This still works")
logger.log(level: .error, "This still works")
```
### Detailed design
The seven available traits, ordered from most permissive to most restrictive, are:
```swift
traits: [
.trait(name: "MaxLogLevelDebug", description: "Debug and above available (compiles out trace)"),
.trait(name: "MaxLogLevelInfo", description: "Info and above available (compiles out trace, debug)"),
.trait(name: "MaxLogLevelNotice", description: "Notice and above available (compiles out trace, debug, info)"),
.trait(
name: "MaxLogLevelWarning",
description: "Warning and above available (compiles out trace, debug, info, notice)"
),
.trait(
name: "MaxLogLevelError",
description: "Error and above available (compiles out trace, debug, info, notice, warning)"
),
.trait(name: "MaxLogLevelCritical", description: "Only critical available (compiles out all except critical)"),
.trait(name: "MaxLogLevelNone", description: "All logging compiled out (no log levels available)"),
.default(enabledTraits: []),
]
```
By default (when no traits are specified), all log levels remain available.
Traits are additive: if multiple max level traits are specified in the dependency graph, the most restrictive one takes effect. This ensures that if any dependency requests stricter elimination, the entire build respects it.
> Important: Traits should only be set by applications, not libraries, as any trait defined in a transitive dependency will affect the entire dependency resolution tree.
For the generic `log(level:)` method, the implementation switches behavior based on whether any trait is enabled:
```swift
public func log(
level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
) {
#if MaxLogLevelDebug || MaxLogLevelInfo || MaxLogLevelNotice || MaxLogLevelWarning || MaxLogLevelError || MaxLogLevelCritical || MaxLogLevelNone
// When traits are enabled, dispatch to level-specific methods
// to leverage their compile-time elimination
switch level {
case .trace:
self.trace(message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
case .debug:
self.debug(message(), metadata: metadata(), source: source(), file: file, function: function, line: line)
// ... (all levels)
}
#else
// When no traits are enabled, avoid the switch overhead
self._log(
level: level,
message(),
metadata: metadata(),
source: source(),
file: file,
function: function,
line: line
)
#endif
}
```
This approach adds a minimal switch statement overhead when traits are enabled, but allows the level-specific methods' compile-time elimination to work even when called through `log(level:)`. When no traits are enabled, the original zero-overhead path is preserved. Level-specific methods has no additional overhead.
### API stability
**For existing `Logger` users:**
- When no traits are enabled (the default), behavior is identical to before
- Users can opt in to traits at the application level without modifying any source code
**For existing `LogHandler` implementations:**
- No changes are required to any `LogHandler` implementation
### Future directions
No future directions identified.
### Alternatives considered
#### Per-log-level traits
An alternative approach would be to define one trait per log level that could be individually disabled:
```swift
traits: [
.trait(name: "DisableTraceLogs"),
.trait(name: "DisableDebugLogs"),
.trait(name: "DisableInfoLogs"),
.trait(name: "DisableNoticeLogs"),
.trait(name: "DisableWarningLogs"),
.trait(name: "DisableErrorLogs"),
.trait(name: "DisableCriticalLogs"),
]
```
Users would specify multiple traits to eliminate multiple levels:
```swift
.package(
url: "https://github.com/apple/swift-log.git",
from: "1.0.0",
traits: ["DisableTraceLogs", "DisableDebugLogs", "DisableInfoLogs", "DisableNoticeLogs"]
)
```
This approach was rejected in favor of a `MaxLogLevel` semantics to make it less verbose to use the functionality and to be aligned with the similar functionality in logging packages in other languages users might already be familiar with.
@@ -1,416 +0,0 @@
# SLG-0003: Support for Attaching Errors to Log Entries
Add standardized way of attaching data from `Error` instances to log entries.
## Overview
- Proposal: SLG-0003
- Author(s): [Samuel Murray](https://github.com/samuelmurray)
- Status: **Approved**
- Issue: [apple/swift-log#291](https://github.com/apple/swift-log/issues/291)
- Implementation:
- [apple/swift-log#425](https://github.com/apple/swift-log/pull/425)
- Related links:
- [Lightweight proposals process description](https://github.com/apple/swift-log/blob/main/Sources/Logging/Docs.docc/Proposals/Proposals.md)
- [First attempt at solution](https://github.com/apple/swift-log/pull/384)
### Introduction
Add new methods on `Logger` that accept an `Error` instance, which is passed as-is to the underlying `LogHandler`. To ensure backwards compatibility and a smooth adoption, a default implementation where the error is serialized into `MetadataValue`s is provided.
### Motivation
SwiftLog advocates for the use of _structured logging_, which in its implementation is achieved by using the `metadata` attribute in the log methods. This is important since it allows for automated tools to parse the logs and extract metadata values for filtering and/or visualization. When logging in a catch-block, it often makes sense to attach some information from the thrown `Error` in the log post, so as to capture the root cause.
```swift
do {
try someThrowingFunc()
} catch {
logger.warning("Something went wrong") // Want to somehow attach information about the error
}
```
Currently, there is no standardized way of doing this. The simplest way to do it would be to simply attach the stringified error to the message.
```swift
logger.warning("Something went wrong: \(error)")
```
This of course is not _structured_, so a better way would be:
```swift
logger.warning("Something went wrong", metadata: ["error": "\(error)"])
```
However, since there is no clear preference for what metadata key to use, it is likely that different code bases use variations of the above. This makes it hard for automated tools to extract error information, since there is no single key to look for.
Additionally, there is more information that we could extract from the error, such as the type name.
```swift
logger.warning("Something went wrong", metadata: ["error.message": "\(error)", "error.type": "\(String(reflecting: type(of: error)))"])
```
The above is a reasonable way to log a generic error, but it is unlikely that everyone will use the same metadata keys. It is also quite a lot of code, for something that feels like it should be easy to do - i.e. attach an error to a log.
Finally, even if you log errors in a consistent way in your code, you do not control logs generated in other modules/packages that you use. In practice, this makes it so that different parts of your application could log error information under different keys, which, again, makes it harder for tooling.
### Proposed solution
The solution we propose is to add convenience methods in `Logger` that allows the caller to do the following:
```swift
do {
try someThrowingFunc()
} catch {
logger.warning("Something went wrong", error: error)
}
```
The error would get passed as-is to the underlying `LogHandler`, which is free to serialize it in an appropriate way. We propose that such convenience methods are added for all log methods (even if it arguably makes less sense for e.g. `trace` and `debug` than `warning`).
There are two clear gains from this:
* It is obvious for the caller _how_ to attach an `Error` to a log (and the caller code also looks cleaner).
* `LogHandler`s are free to serialize the `Error` in an way appropriate to that handler.
A `LogHandler` instance can access the `Error` using a new protocol method. A typical `LogHandler` implementation could be to extract the string representation and type name, and serialize it as metadata.
```swift
struct ErrorLogHandler: LogHandler {
func log(
level: Logger.Level,
message: Logger.Message,
error: (any Error)?,
metadata: Logger.Metadata?,
source: String,
file: String,
function: String,
line: UInt
) {
var metadata = metadata ?? [:]
if let error {
metadata.merge([
"error.message": "\(error)",
"error.type": "\(String(reflecting: type(of: error)))",
]) { $1 }
}
// ...
}
/* ... */
}
```
As we extend the API of both `Logger` and `LogHandler`, we need to ensure compatibility with existing solutions on both sides. Specifically, users should be able to use the new `Logger` methods with existing `LogHandler`s, and get a reasonable serialization of the error. Otherwise, early adopters would have to manually serialize it _in addition to_ passing it using the new argument, until all `LogHandler`s have been updated. To achieve this, we add a default implementation on the `LogHandler` method, that serializes the `Error` as metadata, similar to the example above.
### Detailed design
The proposed solution is to add a new overload for each log method (`trace`, ..., `critical`) that accepts an `Error` as its second argument, as well as a new overload for `Logger.log`, that accepts an `Error` as its third argument.
```swift
extension Logger {
/// Log a message at the 'trace' log level with the source that you provide.
///
/// If ``Level/trace`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func trace(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'debug' log level with the source that you provide.
///
/// If ``Level/debug`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func debug(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'info' log level with the source that you provide.
///
/// If ``Level/info`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func info(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'notice' log level with the source that you provide.
///
/// If ``Level/notice`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func notice(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'warning' log level with the source that you provide.
///
/// If ``Level/warning`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func warning(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'error' log level with the source that you provide.
///
/// If ``Level/error`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func error(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message at the 'critical' log level with the source that you provide.
///
/// If ``Level/critical`` is at least as severe as this logger's ``logLevel`` the system logs the message;
/// otherwise nothing will happen.
///
/// - parameters:
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func critical(
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
/// Log a message using the log level and source that you provide.
///
/// If the `logLevel` passed to this method is more severe than the `Logger`'s ``logLevel``, the library
/// logs the message, otherwise nothing will happen.
///
/// - parameters:
/// - level: The severity level of the `message`.
/// - message: The message to be logged. The `message` parameter supports any string interpolation literal.
/// - error: An `Error` to attach to this log message.
/// - metadata: One-off metadata to attach to this log message.
/// - source: The source this log message originates from. The value defaults
/// to the module that emits the log message.
/// - file: The file this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#fileID`.
/// - function: The function this log message originates from. There's usually no need to pass it explicitly, as
/// it defaults to `#function`.
/// - line: The line this log message originates from. There's usually no need to pass it explicitly, as it
/// defaults to `#line`.
@inlinable
public func log(
level: Logger.Level,
_ message: @autoclosure () -> Logger.Message,
error: (any Error)?,
metadata: @autoclosure () -> Logger.Metadata? = nil,
source: @autoclosure () -> String? = nil,
file: String = #fileID,
function: String = #function,
line: UInt = #line
)
}
```
A new method is also added to `LogHandler`, which receives the `Error` passed to `Logger`.
```swift
protocol LogHandler {
/// The library calls this method when a log handler must emit a log message.
///
/// There is no need for the `LogHandler` to check if the `level` is above or
/// below the configured `logLevel` as `Logger` already performed this check and
/// determined that a message should be logged.
///
/// - Parameters:
/// - level: The log level of the message.
/// - message: The message to log. To obtain a `String` representation call `message.description`.
/// - error: The `Error` associated to this log message.
/// - metadata: The metadata associated to this log message.
/// - source: The source where the log message originated, for example the logging module.
/// - file: The file this log message originates from.
/// - function: The function this log message originates from.
/// - line: The line this log message originates from.
func log(
level: Logger.Level,
message: Logger.Message,
error: (any Error)?,
metadata: Logger.Metadata?,
source: String,
file: String,
function: String,
line: UInt
)
}
```
A default implementation is included via an extension method, that calls the existing `log` function. This is to ensure backwards compatibility, and is similar to how `source` was added. The default implementation will serialize the `Error`, extracting its string representation and fully qualified type name, and add those to the metadata under the keys `"error.message"` and `"error.type"` respectively.
A draft implementation can be found in [apple/swift-log#425](https://github.com/apple/swift-log/pull/425).
We choose the keys `"error.message"` and `"error.type"` since they correspond to what [ECS](https://www.elastic.co/docs/reference/ecs/ecs-error) and [OpenTelemetry](https://opentelemetry.io/docs/specs/semconv/registry/attributes/error/#error-type) use. However, we propose that the metadata keys used should **not** be considered stable or part of the `swift-log` API. Instead, if a `LogHandler` wants to use separate keys, it should implement the new protocol method, rather than re-map the metadata keys.
### API stability
The proposed additions are fully backwards compatible, meaning that all existing code will continue to function as is. Additionally, a user of `Logger` can start using the new convenience methods, without any modifications of the `LogHandler`, thanks to the default implementation and since a `LogHandler` is already expected to handle `Metadata`.
However, when using the default implementation, a potential metadata collision exists when an `Error` is passed via the new methods while the same keys (`"error.message"`, `"error.type"`) are present in metadata:
```swift
logger.warning("Something went wrong", error: error, metadata: ["error.message": "some other info"])
```
We recommend that the `error` parameter takes precedence in such cases, with conflicting metadata values discarded. This aligns with the principle that explicit `error:` parameters represent primary data, while the same keys in metadata are likely incidental. In practice, we don't expect callers to deliberately pass conflicting error information.
Conversely, a `LogHandler` can implement the new protocol method, and still function with existing users of `Logger` - the `error` parameter will then always be `nil`.
### Future directions
#### recordError
If `swift-log` develops better support for scoped loggers, it might be possible to add a `recordError` method on `Logger`, that would attach the `Error` to all logs in that scope.
### Alternatives considered
#### Standardized Error metadata via Logger convenience
The first proposed solution was to treat the new `Logger` methods as "convenience methods", that simply serialized the `Error` as metadata and did not pass the raw `Error` to `LogHandler`. The end result was similar to the currently proposed default implementation in `LogHandler`. In this solution, the metadata keys (`"error.message"` and `"error.type"`) were considered stable and part of the API, since that allowed for `LogHandler` implementations to re-map the keys (e.g. to `"err.*"`).
Ultimately, this was declined in favor of the current proposal. While the metadata based solution was simple, it lacked the flexibility that passing the raw `Error` allows for.
#### recordError convenience method
In the first iteration, we considered adding a new convenience method `recordError` on `Logger`, that would take an `Error`, serialize it, and add to the metadata on the `Logger`. This would primarily have been useful for when a `Logger` instance were passed down a call hierarchy and the `Error` metadata were relevant further down. However, it doesn't work well with the current proposal, since the serialization happens at a later stage.
#### Using .stringConvertible to pass Error to LogHandler
An alternative way to let the `LogHandler` get access to the raw `Error` would be to use the existing `.stringConvertible` enum case of `MetadataValue`. By putting the `Error` under a well-known metadata key (such as `"error"`), a `LogHandler` could get access to it, without any changes to the `LogHandler` protocol. However, this would only work for `Error`s that conform to `CustomStringConvertible`.
#### some Error vs any Error
The error argument in `Logger` was considered to be `some Error` rather than `any Error`. Ultimately, `any Error` was preferred. This is because in most typical use cases (e.g. general catch blocks), the error is an existential, so by using `some Error` we would get a slight performance penalty.
@@ -1,512 +0,0 @@
# SLG-0004: Metadata value attributes
Add an extensible per-value attribute mechanism for metadata.
## Overview
- Proposal: SLG-0004
- Author(s): [Vladimir Kukushkin](https://github.com/kukushechkin)
- Status: **Approved**
- Issue: [apple/swift-log#204](https://github.com/apple/swift-log/issues/204)
- Implementation:
- [apple/swift-log#453](https://github.com/apple/swift-log/pull/453)
- Related links:
- [Lightweight proposals process description](https://github.com/apple/swift-log/blob/main/Sources/Logging/Docs.docc/Proposals/Proposals.md)
- [First iteration of the proposal](https://forums.swift.org/t/proposal-slg-0004-metadata-values-privacy-attribute/85249)
### Introduction
Introduce an extensible mechanism for attaching per-value attributes to metadata. The core `Logging` module provides
the protocol and storage. Attribute packages define concrete attributes using the
`Logger.MetadataValueAttributes.Attribute` protocol.
### Motivation
Metadata values in `swift-log` are opaque strings by the time the `LogHandler` receives them. The call site often
knows things about a value that the handler cannot infer — for example, whether the value should be redacted in
different environments.
Today, there is no way to express this. A single log statement can contain values that need different treatment, and
log levels cannot help because they are per-statement, not per-value:
```swift
logger.info("Login", metadata: [
"action": "\(action)", // safe to log
"user_email": "\(email)", // should be redacted in production, but nothing tells the handler
])
```
The workaround is handler-side key-based rules (`redact: ["email", "card-*", ...]`), but this is fragile:
- Rules break when libraries rename keys.
- Rules require coordination across all dependencies.
- The rule mapping is invisible at the call site.
### Proposed solution
Attributes are embedded directly in `MetadataValue` via the existing `.stringConvertible` case. A custom
`MetadataValue.StringInterpolation` type produces attributed values when any interpolation segment specifies
attributes. Libraries define attribute types conforming to `Logger.MetadataValueAttributes.Attribute` and provide
ergonomic string interpolation overloads. Handlers read the attributes via `value.attributes` and act on them:
```swift
import Logging
public enum Sensitivity: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case sensitive = 1
case `public` = 2
}
extension Logger.MetadataValue.StringInterpolation {
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T, sensitivity: Sensitivity
) {
self.appendInterpolation(value, attributes: { $0[Sensitivity.self] = sensitivity })
}
}
logger.info("Request", metadata: [
"method": "\(req.method)",
"user_id": "\(req.userId, sensitivity: .sensitive)",
])
```
Handlers that support specific attributes read them from `value.attributes` and act accordingly. Handlers that do not
understand attributes see plain `MetadataValue` instances — attributes are invisible unless explicitly inspected. The
existing `metadata:` parameter is the only parameter needed; no new log method overloads are added.
Attributed values can also be created programmatically with the `.attributed` factory, which behaves like an additional
enum case without breaking existing exhaustive switches:
```swift
let value: Logger.MetadataValue = .attributed(userId, attributes: [Sensitivity.sensitive])
```
Intermediate handlers can read **and modify** attributes as metadata flows through a handler chain. The `attributes`
property supports both getting and setting, enabling composable pipelines where each handler in the chain can enrich,
transform, or strip attributes before forwarding:
```swift
// An enriching handler that tags all metadata with a processing timestamp attribute
func log(event: LogEvent) {
var mutatedEvent = event
if var eventMetadata = event.metadata {
for (key, _) in eventMetadata {
var attrs = eventMetadata[key]!.attributes
attrs[ProcessingStage.self] = .enriched
eventMetadata[key]?.attributes = attrs
}
mutatedEvent.metadata = eventMetadata
}
self.inner.log(event: mutatedEvent)
}
```
Attributes are **classifications, not enforcement**. An attribute does not guarantee any particular handler behavior —
the handler may not support it. Applications needing guaranteed behavior must enforce it at a different abstraction.
The attribute mechanism is extensible: packages define their own attribute types using
`Logger.MetadataValueAttributes.Attribute`. A
chained `LogHandler` can read the attributes it cares about, act on them, and forward the rest to the next handler in
the chain — enabling composable handler pipelines (e.g., redaction handler -> metrics-extraction handler -> output
handler). Common attributes should be defined in separate packages so that the core `Logging` module remains free of
domain-specific attributes while providing shared vocabulary across libraries. To improve discoverability, `swift-log`
can reference attribute packages that are common across the whole ecosystem.
### Detailed design
#### `Attribute` protocol
```swift
extension Logger.MetadataValueAttributes {
/// A protocol for defining custom metadata attributes.
///
/// Conform to this protocol to define a custom attribute that can be stored in
/// ``MetadataValueAttributes``. Each conforming type acts as both the key (identified
/// by its metatype) and the value.
///
/// This protocol is designed for **small, fixed-vocabulary attributes**.
/// Each attribute value is stored as an `Int64` raw value, so attributes occupy minimal
/// space (one inline slot without heap allocation for the common single-attribute case).
///
/// ## Examples
///
/// ```swift
/// public enum Priority: Int64, Sendable, Logger.MetadataValueAttributes.Attribute {
/// case low = 1
/// case high = 2
/// }
/// ```
///
/// ```swift
/// public struct Priority: Sendable, Hashable, Logger.MetadataValueAttributes.Attribute {
/// public let rawValue: Int64
/// public init(rawValue: Int64) {
/// self.rawValue = rawValue
/// }
/// public static let low = Priority(rawValue: 1)
/// public static let high = Priority(rawValue: 2)
/// }
/// ```
public protocol Attribute: Sendable,
RawRepresentable where RawValue == Int64 {}
}
```
Each conforming type serves as both the key and the value for an attribute. The metatype (`Key.Type`) identifies
the attribute at runtime — no coordination between packages is needed.
#### `MetadataValueAttributes`
```swift
extension Logger {
/// Attributes that can be associated with metadata values.
public struct MetadataValueAttributes: Sendable, Equatable, ExpressibleByArrayLiteral {
/// Nested ``Attribute`` protocol (see above).
public protocol Attribute: Sendable, RawRepresentable where RawValue == Int64 {}
/// Create empty metadata value attributes.
public init()
/// Create metadata value attributes from an array literal of attribute values.
///
/// ```swift
/// let attrs: MetadataValueAttributes = [Sensitivity.sensitive, ValueType.int64]
/// ```
public init(arrayLiteral elements: any Attribute...)
/// Get or set a custom attribute by its type.
///
/// - Parameter attribute: The metatype of the attribute to access.
/// - Returns: The attribute value, or `nil` if not set.
public subscript<Attr: Attribute>(attribute: Attr.Type) -> Attr? { get set }
}
}
```
The common case (0–1 attributes) avoids heap allocation. `Equatable` compares entries as an unordered set (O(n²),
n typically 0–2).
#### `MetadataValue.attributes` computed property
```swift
extension Logger.MetadataValue {
/// The attributes associated with this metadata value, if any.
///
/// **Getting:** When the value is a ``stringConvertible(_:)`` wrapping an attributed carrier,
/// returns that carrier's attributes. For all other cases returns empty attributes.
///
/// **Setting:** Replaces the value with `.stringConvertible(AttributedStringCarrier(...))`
/// carrying the given attributes. For `.string` and `.stringConvertible` cases the string
/// representation is preserved. For `.dictionary` and `.array` cases the setter is a no-op.
public var attributes: Logger.MetadataValueAttributes { get set }
}
```
This is the handler-side read/write API. Internally, the `Logging` module stores attributes in an internal
`AttributedStringCarrier` class wrapped by `.stringConvertible`. The getter check is a concrete type comparison — no
protocol conformance lookup. Users attach attributes via string interpolation and read them via this property. The
setter allows handlers to modify or add attributes as they process metadata values through the handler chain.
#### `MetadataValue.attributed` factory method
```swift
extension Logger.MetadataValue {
/// Creates an attributed metadata value from a string-convertible value and attributes.
public static func attributed(
_ value: some CustomStringConvertible & Sendable,
attributes: Logger.MetadataValueAttributes
) -> Self
}
```
This convenience factory behaves like an additional enum case, producing a
`.stringConvertible(AttributedStringCarrier(...))` value without requiring string interpolation:
```swift
let value: Logger.MetadataValue = .attributed(userId, attributes: [Sensitivity.sensitive])
```
#### String interpolation
`MetadataValue` replaces its empty `ExpressibleByStringInterpolation` conformance with a custom `StringInterpolation`
type. When no attributes are specified, the result is `.string(...)` — identical to the previous behavior. When any
interpolation segment specifies attributes, the result is `.stringConvertible(...)` wrapping the internal carrier:
```swift
extension Logger.MetadataValue: ExpressibleByStringInterpolation {
/// Custom string interpolation that optionally captures metadata attributes.
///
/// When no attributes are specified, produces `.string(...)` — identical to the
/// default `DefaultStringInterpolation` behavior. When any interpolation segment
/// specifies attributes (via the `attributes:` parameter), the result is
/// `.stringConvertible(AttributedStringCarrier(...))` carrying both the string
/// and the accumulated attributes.
///
/// Attribute packages (like `LoggingAttributes`) can add overloads with
/// domain-specific parameters (e.g. `sensitivity:`) that call through to
/// `appendInterpolation(_:attributes:)`.
public struct StringInterpolation: StringInterpolationProtocol, Sendable {
public init(literalCapacity: Int, interpolationCount: Int)
public mutating func appendLiteral(_ literal: String)
/// Interpolation with a custom attributes closure.
///
/// When called, the result will be `.stringConvertible(AttributedStringCarrier(...))`
/// instead of `.string(...)`.
///
/// ```swift
/// "\(userId, attributes: { $0[MyAttribute.self] = .flagged })"
/// ```
public mutating func appendInterpolation<T>(
_ value: T,
attributes: @Sendable (inout Logger.MetadataValueAttributes) -> Void
) where T: CustomStringConvertible & Sendable
/// Plain interpolation without attributes.
public mutating func appendInterpolation<T>(
_ value: T
) where T: CustomStringConvertible & Sendable
/// Fallback interpolation for types that are not `CustomStringConvertible`.
public mutating func appendInterpolation<T>(
_ value: T
) where T: Sendable
/// Unconstrained fallback for non-`Sendable` types.
///
/// The value is immediately converted to `String` via `String(describing:)` and never
/// stored, so no `Sendable` safety issue arises. This overload exists so that interpolating
/// a non-`Sendable` type into a `MetadataValue` continues to compile, matching the behavior
/// of `DefaultStringInterpolation`.
public mutating func appendInterpolation<T>(
_ value: T
)
}
/// Creates a metadata value from string interpolation.
///
/// If any interpolation segment specified attributes, the result is
/// `.stringConvertible(AttributedStringCarrier(...))`. Otherwise, `.string(...)`.
public init(stringInterpolation: StringInterpolation)
}
```
Attribute packages add ergonomic overloads that wrap the closure-based method — for example:
```swift
extension Logger.MetadataValue.StringInterpolation {
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T, sensitivity: Sensitivity
) {
self.appendInterpolation(value, attributes: { $0[Sensitivity.self] = sensitivity })
}
}
```
This enables the clean call-site syntax: `"\(userId, sensitivity: .sensitive)"`.
When a single `MetadataValue` contains multiple interpolated segments with different attributes, the merging behavior
is defined by each attribute's `appendInterpolation` implementation.
#### No changes to `Logger`, `LogHandler`, `LogEvent`, or `MetadataProvider`
Unlike earlier iterations of this proposal, the piggyback approach requires **no new API** on `Logger`, `LogHandler`,
`LogEvent`, or `MetadataProvider`:
- **`Logger`**: No new `attributedMetadata:` log method overloads. Attributes flow through the existing `metadata:`
parameter.
- **`LogHandler`**: No new protocol requirements. No `attributedMetadata` property, no `attributedMetadataKey`
subscript. Existing handlers work unchanged.
- **`LogEvent`**: No dual storage. `metadata` remains a simple `Logger.Metadata?` stored property. Values inside the
dictionary may carry attributes, but `LogEvent` is unaware of this.
- **`MetadataProvider`**: No `.attributed()` factory or `getAttributedMetadata()` method. Providers return
`Logger.Metadata` where values may carry attributes via string interpolation.
### API stability
- **Existing `Logger` users.** No changes to existing API. The same `metadata:` parameter carries attributed values.
- **Existing `LogHandler` implementations.** No protocol changes. Handlers that only call `.description` on metadata
values see the string as before — attributes are invisible. Handlers that want to inspect attributes read
`value.attributes`.
### Future directions
- **Attribute-aware equality.** The current `MetadataValue` equality for `.stringConvertible` values compares only
`.description`, ignoring attributes. Two values with the same text but different attributes compare as equal. A
future proposal could refine equality to include attributes when both sides carry them, but this
requires careful consideration of backward compatibility since existing code may rely on description-only equality.
- **Metadata values sensitivity attribute.** A separate ecosystem package could add the sensitivity attribute,
allowing compatible `LogHandler` to redact values in certain situations.
- **Typed metadata values.** A separate ecosystem package could add typed variants to `MetadataValue` (`.int64`,
`.double`, `.bool`), reducing the need for attributes that compensate for stringly-typed metadata.
### Alternatives considered
#### Wrapper type with parallel API ("attributed metadata value" approach)
Introduce an `AttributedMetadataValue` struct wrapping `MetadataValue` + `MetadataValueAttributes`, a separate
`AttributedMetadata` typealias, new `attributedMetadata:` overloads on all Logger methods, dual storage in
`LogEvent`, and new `LogHandler` protocol requirements. This was the design in the first iteration of this proposal.
It provides strong type separation but creates a parallel API surface: 7 new convenience methods, new protocol
requirements with default implementations, dual `MetadataStorage` enum in `LogEvent`, and `mapValues` bridging
between plain and attributed representations. The piggyback approach achieves the same functionality by embedding
attributes inside `MetadataValue` via the existing `.stringConvertible` case, avoiding the parallel universe
entirely.
#### Sidecar dictionary on `LogEvent`
Store attributes in a separate `[String: MetadataValueAttributes]` dictionary on `LogEvent`, keyed by the same
metadata keys. This keeps `MetadataValue` unchanged but introduces sync issues — attributes can drift out of sync
with metadata keys when handlers merge or transform metadata. The piggyback approach avoids this by co-locating
attributes with the value they describe.
#### New enum case on `MetadataValue`
Add a dedicated `.attributed(String, MetadataValueAttributes)` case to the `MetadataValue` enum. This would make
attributes statically visible in the type — no runtime downcast needed, and `switch` statements would handle
attributed values explicitly. However, `MetadataValue` is a public enum that is exhaustively matched by every
`LogHandler` in the ecosystem. Adding a case is source-breaking: every existing handler's `switch` over
`MetadataValue` would fail to compile until updated. The piggyback approach avoids this by reusing the existing
`.stringConvertible` case, which handlers already handle.
#### Concrete stored property instead of extensible mechanism
Add concrete stored properties (e.g., `var sensitivity: Sensitivity?`) on `MetadataValueAttributes`. Simpler, but
closed — chained handlers cannot define their own attributes. The extensible mechanism keeps the core `Logging` module
free of domain-specific attributes.
#### Bitmask storage
Pack attribute values into an inline `UInt64` using declared bit offsets. O(1) access, but requires authors to
coordinate bit layout and risks collisions between independent packages.
#### Pure dynamic array storage
Use a dynamic array for all attributes with no inline slot. Simpler, but requires heap allocation even for the first
attribute.
#### No per-value attributes
Rely on handler-side configuration (key-name-based rules). Simpler, but fragile — rules break when keys are renamed,
require coordination across all dependencies, and are invisible at the call site.
### Example attributes
The following examples illustrate how ecosystem packages could define attributes using the
`Logger.MetadataValueAttributes.Attribute` protocol. These are not part of this proposal.
#### Sensitivity
A sensitivity attribute for marking metadata values that contain private or personally identifiable information:
```swift
public enum Sensitivity: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case sensitive = 1
case `public` = 2
}
extension Logger.MetadataValue.StringInterpolation {
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T, sensitivity: Sensitivity
) {
self.appendInterpolation(value, attributes: { $0[Sensitivity.self] = sensitivity })
}
}
logger.info("Request", metadata: [
"method": "\(req.method)",
"user_id": "\(req.userId, sensitivity: .sensitive)",
])
```
A handler reads the attribute:
```swift
for (key, value) in mergedMetadata {
if value.attributes[Sensitivity.self] == .sensitive {
// redact this value
}
}
```
#### Value type hint
A type hint for structured logging backends that benefit from native types:
```swift
public enum ValueType: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case string = 1
case int64 = 2
case double = 3
case bool = 4
}
extension Logger.MetadataValue.StringInterpolation {
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T, valueType: ValueType
) {
self.appendInterpolation(value, attributes: { $0[ValueType.self] = valueType })
}
}
logger.info("Metrics", metadata: [
"latency_ms": "\(latency, valueType: .double)",
"retry_count": "\(retries, valueType: .int64)",
])
```
#### Metric extraction
A metric attribute for a chained `LogHandler` that dual-writes to swift-metrics:
```swift
public enum MetricKind: Int64, Logger.MetadataValueAttributes.Attribute, Sendable {
case counter = 1
case gauge = 2
case histogram = 3
}
extension Logger.MetadataValue.StringInterpolation {
public mutating func appendInterpolation<T: CustomStringConvertible & Sendable>(
_ value: T, metricKind: MetricKind
) {
self.appendInterpolation(value, attributes: { $0[MetricKind.self] = metricKind })
}
}
logger.info("Request completed", metadata: [
"duration_ms": "\(duration, metricKind: .histogram)",
"error_count": "\(errors, metricKind: .counter)",
])
```
#### Attribute-enriching intermediate handler
An intermediate `LogHandler` that reads and modifies attributes before forwarding to the next handler in the chain.
This pattern enables composable pipelines — for example, a handler that adds a default sensitivity to all metadata
values that do not already carry one:
```swift
struct DefaultSensitivityHandler: LogHandler {
private var inner: any LogHandler
// ... logLevel, metadata, metadataProvider forwarded to inner ...
func log(event: LogEvent) {
var mutatedEvent = event
if var eventMetadata = event.metadata {
for (key, _) in eventMetadata {
if eventMetadata[key]?.attributes[Sensitivity.self] == nil {
eventMetadata[key]?.attributes = [Sensitivity.sensitive]
}
}
mutatedEvent.metadata = eventMetadata
}
self.inner.log(event: mutatedEvent)
}
}
```
With this handler in the chain, any metadata value without an explicit sensitivity annotation is treated as sensitive
by default — a "deny by default" policy that individual call sites can override with `.public`.
Loaded 100 of 176 files, more files were not shown because too many files have changed in this diff. Show more