1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import Foundation
public final class LoggingScope {
/// The name of the current logging subsystem or `nil` if no logging scope is set.
@TaskLocal fileprivate static var _subsystem: String?
/// The name of the current logging scope or `nil` if no logging scope is set.
@TaskLocal fileprivate static var _scope: String?
/// The name of the current logging subsystem.
public static var subsystem: String {
return _subsystem ?? "org.swift.sourcekit-lsp"
}
/// The name of the current logging scope.
public static var scope: String {
return _scope ?? "default"
}
}
/// Logs all messages created from the operation to the given subsystem.
///
/// This overrides the current logging subsystem.
///
/// - Note: Since this stores the logging subsystem in a task-local value, it only works when run inside a task.
/// Outside a task, this is a no-op.
public func withLoggingSubsystemAndScope<Result>(
subsystem: String,
scope: String?,
@_inheritActorContext _ operation: @Sendable () throws -> Result
) rethrows -> Result {
return try LoggingScope.$_subsystem.withValue(subsystem) {
return try LoggingScope.$_scope.withValue(scope, operation: operation)
}
}
/// Same as `withLoggingSubsystemAndScope` but allows the operation to be `async`.
public func withLoggingSubsystemAndScope<Result>(
subsystem: String,
scope: String?,
@_inheritActorContext _ operation: @Sendable () async throws -> Result
) async rethrows -> Result {
return try await LoggingScope.$_subsystem.withValue(subsystem) {
return try await LoggingScope.$_scope.withValue(scope, operation: operation)
}
}
/// Create a new logging scope, which will be used as the category in any log messages created from the operation.
///
/// This overrides the current logging scope.
///
/// - Note: Since this stores the logging scope in a task-local value, it only
/// works when run inside a task. Outside a task, this is a no-op.
/// - Warning: Be very careful with the dynamic creation of logging scopes. The logging scope is used as the os_log
/// category, os_log only supports 4000 different loggers and thus at most 4000 different scopes must be used.
public func withLoggingScope<Result>(
_ scope: String,
_ operation: () throws -> Result
) rethrows -> Result {
return try LoggingScope.$_scope.withValue(
scope,
operation: operation
)
}
/// Same as `withLoggingScope` but allows the operation to be `async`.
///
/// - SeeAlso: ``withLoggingScope(_:_:)-6qtga``
public func withLoggingScope<Result>(
_ scope: String,
@_inheritActorContext _ operation: @Sendable () async throws -> Result
) async rethrows -> Result {
return try await LoggingScope.$_scope.withValue(
scope,
operation: operation
)
}
|
