-
Notifications
You must be signed in to change notification settings - Fork 775
/
SdkLoggerProvider.java
134 lines (120 loc) · 4.46 KB
/
SdkLoggerProvider.java
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.sdk.logs;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.LoggerBuilder;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.sdk.common.Clock;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.internal.ComponentRegistry;
import io.opentelemetry.sdk.resources.Resource;
import java.io.Closeable;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.logging.Level;
import javax.annotation.Nullable;
/** SDK implementation for {@link LoggerProvider}. */
public final class SdkLoggerProvider implements LoggerProvider, Closeable {
static final String DEFAULT_LOGGER_NAME = "unknown";
private static final java.util.logging.Logger LOGGER =
java.util.logging.Logger.getLogger(SdkLoggerProvider.class.getName());
private final LoggerSharedState sharedState;
private final ComponentRegistry<SdkLogger> loggerComponentRegistry;
private final boolean isNoopLogRecordProcessor;
/**
* Returns a new {@link SdkLoggerProviderBuilder} for {@link SdkLoggerProvider}.
*
* @return a new builder instance
*/
public static SdkLoggerProviderBuilder builder() {
return new SdkLoggerProviderBuilder();
}
SdkLoggerProvider(
Resource resource,
Supplier<LogLimits> logLimitsSupplier,
List<LogRecordProcessor> processors,
Clock clock) {
LogRecordProcessor logRecordProcessor = LogRecordProcessor.composite(processors);
this.sharedState =
new LoggerSharedState(resource, logLimitsSupplier, logRecordProcessor, clock);
this.loggerComponentRegistry =
new ComponentRegistry<>(
instrumentationScopeInfo -> new SdkLogger(sharedState, instrumentationScopeInfo));
this.isNoopLogRecordProcessor = logRecordProcessor instanceof NoopLogRecordProcessor;
}
/**
* Gets or creates a named logger instance.
*
* @param instrumentationScopeName A name uniquely identifying the instrumentation scope, such as
* the instrumentation library, package, or fully qualified class name. Must not be null.
* @return a logger instance
*/
@Override
public Logger get(String instrumentationScopeName) {
return loggerComponentRegistry.get(
instrumentationNameOrDefault(instrumentationScopeName), null, null, Attributes.empty());
}
/**
* Creates a {@link LoggerBuilder} instance.
*
* @param instrumentationScopeName the name of the instrumentation scope
* @return a logger builder instance
*/
@Override
public LoggerBuilder loggerBuilder(String instrumentationScopeName) {
if (isNoopLogRecordProcessor) {
return LoggerProvider.noop().loggerBuilder(instrumentationScopeName);
}
return new SdkLoggerBuilder(
loggerComponentRegistry, instrumentationNameOrDefault(instrumentationScopeName));
}
private static String instrumentationNameOrDefault(@Nullable String instrumentationScopeName) {
if (instrumentationScopeName == null || instrumentationScopeName.isEmpty()) {
LOGGER.fine("Logger requested without instrumentation scope name.");
return DEFAULT_LOGGER_NAME;
}
return instrumentationScopeName;
}
/**
* Request the active log processor to process all logs that have not yet been processed.
*
* @return a {@link CompletableResultCode} which is completed when the flush is finished
*/
public CompletableResultCode forceFlush() {
return sharedState.getLogRecordProcessor().forceFlush();
}
/**
* Attempt to shut down the active log processor.
*
* @return a {@link CompletableResultCode} which is completed when the active log process has been
* shut down.
*/
public CompletableResultCode shutdown() {
if (sharedState.hasBeenShutdown()) {
LOGGER.log(Level.WARNING, "Calling shutdown() multiple times.");
return CompletableResultCode.ofSuccess();
}
return sharedState.shutdown();
}
@Override
public void close() {
shutdown().join(10, TimeUnit.SECONDS);
}
@Override
public String toString() {
return "SdkLoggerProvider{"
+ "clock="
+ sharedState.getClock()
+ ", resource="
+ sharedState.getResource()
+ ", logLimits="
+ sharedState.getLogLimits()
+ ", logRecordProcessor="
+ sharedState.getLogRecordProcessor()
+ '}';
}
}