Give `Logger.handler` a `_modify` accessor and replace its `get` with `_read`, so metadata writes update the stored handler instead of a copy. ### Motivation: `Logger.handler` only has `get` and `set`. A write such as `logger[metadataKey: "k"] = "v"` gets a copy of the handler, writes to it while the stored handler still shares the metadata dictionary, and sets it back. So every write copies the whole dictionary, and `withLogger(mergingMetadata:)` does that once per key. ### Modifications: - Give `Logger.handler` `_read`, `set` and `_modify` accessors. `_read` yields the stored handler. `_modify` keeps the existing uniqueness check on the storage and then yields the stored handler, so metadata and log level writes change it in place. `set` keeps the same check for plain `logger.handler = newHandler` assignments, which are cheaper through a setter than through `_modify`. - Add a test handler that counts copies of its metadata, with tests for direct writes and for `withLogger(mergingMetadata:)`. Without the change they report 10 copies instead of 0, and 5 instead of 1. ### Result: A metadata write on a logger that owns its storage no longer copies the dictionary. A copied logger still copies once on its first write, so value semantics are unchanged. 1,000 metadata writes with a handler that keeps metadata in a plain dictionary, debug build, three runs each: | Keys on the logger | Before | After | |---|---|---| | 10 | 7.2 to 8.1 ms | 0.46 to 0.50 ms | | 1,000 | 20.2 to 20.6 ms | 0.46 to 0.55 ms | | 10,000 | 134.0 to 134.4 ms | 0.47 to 0.50 ms | | 100,000 | 1.29 to 1.30 s | 0.32 to 0.35 ms | `withLogger(mergingMetadata:)` with 10,000 keys went from 0.64 to 0.65 s down to 2.9 to 3.1 ms. `StreamLogHandler` still rebuilds its pretty metadata string on every write; this change does not touch that. All 176 tests pass on macOS with Swift 6.4, and `swift format lint --strict` and `swift package diagnose-api-breaking-changes` are clean. Once yielding accessors land, `_read` and `_modify` can become `yielding borrow` and `yielding mutate`. Fixes #526.
SwiftLog
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.
- 📚 Documentation and tutorials are available on the Swift Package Index
- 🚀 Contributions are welcome, please see CONTRIBUTING.md
- 🪪 License is Apache 2.0, repeated in LICENSE.txt
- 🔒 Security issues should be reported via the process in Security
- 🔀 Available Logging Backends: SwiftLog is an API package - you'll want to choose from the many community-maintained logging backends for production use
Quick Start
The following snippet shows how to add SwiftLog to your Swift Package:
// swift-tools-version: 6.2
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")
]
)
]
)
Then start logging:
import Logging
// Create a logger
let logger = Logger(label: "com.example.YourApp")
// 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")
Available log handler backends
The community has built numerous specialized logging backends.
A great way to discover available log backend implementations is searching the
Swift Package Index
for the swift-log keyword.
Building with CMake
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.