forked from open-telemetry/opentelemetry-java
-
Notifications
You must be signed in to change notification settings - Fork 1
/
SdkLoggerProvider.java
120 lines (107 loc) · 4.12 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
/*
* 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);
}
}