open-telemetry
/
opentelemetry-java
mirror of https://github.com/open-telemetry/opentelemetry-java.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change LogEmitter to Logger, LogEmitterProvider to LoggerProvider (#4721)

This commit is contained in:
jack-berg 2022-09-16 13:41:30 -05:00 committed by GitHub
parent a50ceb3959
commit 6209109e0a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
39 changed files with 388 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts
View File

@ -38,6 +38,9 @@ class AllowDefaultMethodRule : AbstractRecordingSeenMembers() {
if (isAbstractMethodOnAutoValue(member, change)) {
continue
}
if (isLogEmitterProvider(member)) {
continue
}
if (!change.isSourceCompatible) {
return Violation.error(member, "Not source compatible")
}
@ -59,6 +62,19 @@ class AllowDefaultMethodRule : AbstractRecordingSeenMembers() {
member is JApiMethod &&
member.getjApiClass().newClass.get().getAnnotation(AutoValue::class.java) != null
}
/**
* Check if the change is related to LogEmitterProvider name change to LoggerProvider.
*/
// TODO(jack-berg): remove after 1.19.0.
fun isLogEmitterProvider(member: JApiCompatibility): Boolean {
try {
return member is JApiMethod &&
member.oldMethod.get().methodInfo.name.matches("(getSdk|set|add)LogEmitterProvider(.*)".toRegex())
} catch (e: IllegalStateException) {
return false
}
}
}
/**

5
docs/apidiffs/current_vs_latest/opentelemetry-sdk-extension-autoconfigure-spi.txt
View File

@ -1,2 +1,5 @@
Comparing source compatibility of against
No changes.
***! MODIFIED INTERFACE: PUBLIC ABSTRACT io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer (not serializable)
=== CLASS FILE FORMAT VERSION: 52.0 <- 52.0
---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer addLogEmitterProviderCustomizer(java.util.function.BiFunction)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer addLoggerProviderCustomizer(java.util.function.BiFunction)

9
docs/apidiffs/current_vs_latest/opentelemetry-sdk.txt
View File

@ -1,2 +1,9 @@
Comparing source compatibility of against
No changes.
***! MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.OpenTelemetrySdk (not serializable)
=== CLASS FILE FORMAT VERSION: 52.0 <- 52.0
---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.logs.SdkLogEmitterProvider getSdkLogEmitterProvider()
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProvider getSdkLoggerProvider()
***! MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.OpenTelemetrySdkBuilder (not serializable)
=== CLASS FILE FORMAT VERSION: 52.0 <- 52.0
---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.OpenTelemetrySdkBuilder setLogEmitterProvider(io.opentelemetry.sdk.logs.SdkLogEmitterProvider)
+++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.OpenTelemetrySdkBuilder setLoggerProvider(io.opentelemetry.sdk.logs.SdkLoggerProvider)

14
integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java
View File

@ -53,8 +53,8 @@ import io.opentelemetry.proto.metrics.v1.Sum;
import io.opentelemetry.proto.trace.v1.ResourceSpans;
import io.opentelemetry.proto.trace.v1.ScopeSpans;
import io.opentelemetry.proto.trace.v1.Span.Link;
import io.opentelemetry.sdk.logs.LogEmitter;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.Logger;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.data.Severity;
import io.opentelemetry.sdk.logs.export.LogExporter;
import io.opentelemetry.sdk.logs.export.SimpleLogProcessor;
@ -502,13 +502,13 @@ abstract class OtlpExporterIntegrationTest {
}
private static void testLogExporter(LogExporter logExporter) {
SdkLogEmitterProvider logEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider loggerProvider =
SdkLoggerProvider.builder()
.setResource(RESOURCE)
.addLogProcessor(SimpleLogProcessor.create(logExporter))
.build();
LogEmitter logEmitter = logEmitterProvider.get(OtlpExporterIntegrationTest.class.getName());
Logger logger = loggerProvider.get(OtlpExporterIntegrationTest.class.getName());
SpanContext spanContext =
SpanContext.create(
@ -518,7 +518,7 @@ abstract class OtlpExporterIntegrationTest {
TraceState.getDefault());
try (Scope unused = Span.wrap(spanContext).makeCurrent()) {
logEmitter
logger
.logRecordBuilder()
.setBody("log body")
.setAllAttributes(Attributes.builder().put("key", "value").build())
@ -530,7 +530,7 @@ abstract class OtlpExporterIntegrationTest {
}
// Closing triggers flush of processor
logEmitterProvider.close();
loggerProvider.close();
await()
.atMost(Duration.ofSeconds(30))

2
sdk-extensions/autoconfigure-spi/build.gradle.kts
View File

@ -13,6 +13,6 @@ dependencies {
// SdkMeterProviderBuilder.
implementation(project(":sdk:metrics"))
// implementation dependency to require users to add the artifact directly to their build to use
// SdkLogEmitterProviderBuilder.
// SdkLoggerProviderBuilder.
implementation(project(":sdk:logs"))
}

8
sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/AutoConfigurationCustomizer.java
View File

@ -6,7 +6,7 @@
package io.opentelemetry.sdk.autoconfigure.spi;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.logs.export.LogExporter;
import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
import io.opentelemetry.sdk.metrics.export.MetricExporter;
@ -137,13 +137,13 @@ public interface AutoConfigurationCustomizer {
}
/**
* Adds a {@link BiFunction} to invoke the with the {@link SdkLogEmitterProviderBuilder} to allow
* Adds a {@link BiFunction} to invoke the with the {@link SdkLoggerProviderBuilder} to allow
* customization. The return value of the {@link BiFunction} will replace the passed-in argument.
*
* <p>Multiple calls will execute the customizers in order.
*/
default AutoConfigurationCustomizer addLogEmitterProviderCustomizer(
BiFunction<SdkLogEmitterProviderBuilder, ConfigProperties, SdkLogEmitterProviderBuilder>
default AutoConfigurationCustomizer addLoggerProviderCustomizer(
BiFunction<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder>
meterProviderCustomizer) {
return this;
}

43
sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java
View File

@ -16,8 +16,8 @@ import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer;
import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider;
import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.logs.export.LogExporter;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
@ -68,8 +68,8 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
private BiFunction<? super MetricExporter, ConfigProperties, ? extends MetricExporter>
metricExporterCustomizer = (a, unused) -> a;
private BiFunction<SdkLogEmitterProviderBuilder, ConfigProperties, SdkLogEmitterProviderBuilder>
logEmitterProviderCustomizer = (a, unused) -> a;
private BiFunction<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder>
loggerProviderCustomizer = (a, unused) -> a;
private BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter>
logExporterCustomizer = (a, unused) -> a;
@ -246,18 +246,18 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
}
/**
* Adds a {@link BiFunction} to invoke the with the {@link SdkLogEmitterProviderBuilder} to allow
* Adds a {@link BiFunction} to invoke the with the {@link SdkLoggerProviderBuilder} to allow
* customization. The return value of the {@link BiFunction} will replace the passed-in argument.
*
* <p>Multiple calls will execute the customizers in order.
*/
@Override
public AutoConfiguredOpenTelemetrySdkBuilder addLogEmitterProviderCustomizer(
BiFunction<SdkLogEmitterProviderBuilder, ConfigProperties, SdkLogEmitterProviderBuilder>
logEmitterProviderCustomizer) {
requireNonNull(logEmitterProviderCustomizer, "logEmitterProviderCustomizer");
this.logEmitterProviderCustomizer =
mergeCustomizer(this.logEmitterProviderCustomizer, logEmitterProviderCustomizer);
public AutoConfiguredOpenTelemetrySdkBuilder addLoggerProviderCustomizer(
BiFunction<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder>
loggerProviderCustomizer) {
requireNonNull(loggerProviderCustomizer, "loggerProviderCustomizer");
this.loggerProviderCustomizer =
mergeCustomizer(this.loggerProviderCustomizer, loggerProviderCustomizer);
return this;
}
@ -352,17 +352,12 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
tracerProviderBuilder = tracerProviderCustomizer.apply(tracerProviderBuilder, config);
SdkTracerProvider tracerProvider = tracerProviderBuilder.build();
SdkLogEmitterProviderBuilder logEmitterProviderBuilder = SdkLogEmitterProvider.builder();
logEmitterProviderBuilder.setResource(resource);
LogEmitterProviderConfiguration.configureLogEmitterProvider(
logEmitterProviderBuilder,
config,
serviceClassLoader,
meterProvider,
logExporterCustomizer);
logEmitterProviderBuilder =
logEmitterProviderCustomizer.apply(logEmitterProviderBuilder, config);
SdkLogEmitterProvider logEmitterProvider = logEmitterProviderBuilder.build();
SdkLoggerProviderBuilder loggerProviderBuilder = SdkLoggerProvider.builder();
loggerProviderBuilder.setResource(resource);
LoggerProviderConfiguration.configureLoggerProvider(
loggerProviderBuilder, config, serviceClassLoader, meterProvider, logExporterCustomizer);
loggerProviderBuilder = loggerProviderCustomizer.apply(loggerProviderBuilder, config);
SdkLoggerProvider loggerProvider = loggerProviderBuilder.build();
if (registerShutdownHook) {
Runtime.getRuntime()
@ -372,7 +367,7 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
List<CompletableResultCode> shutdown = new ArrayList<>();
shutdown.add(tracerProvider.shutdown());
shutdown.add(meterProvider.shutdown());
shutdown.add(logEmitterProvider.shutdown());
shutdown.add(loggerProvider.shutdown());
CompletableResultCode.ofAll(shutdown).join(10, TimeUnit.SECONDS);
}));
}
@ -384,7 +379,7 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur
OpenTelemetrySdkBuilder sdkBuilder =
OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
.setLogEmitterProvider(logEmitterProvider)
.setLoggerProvider(loggerProvider)
.setMeterProvider(meterProvider)
.setPropagators(propagators);

14
sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogEmitterProviderConfiguration.java → sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java
View File

@ -12,7 +12,7 @@ import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
import io.opentelemetry.sdk.logs.LogLimits;
import io.opentelemetry.sdk.logs.LogLimitsBuilder;
import io.opentelemetry.sdk.logs.LogProcessor;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.logs.export.BatchLogProcessor;
import io.opentelemetry.sdk.logs.export.LogExporter;
import io.opentelemetry.sdk.logs.export.SimpleLogProcessor;
@ -22,23 +22,23 @@ import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
final class LogEmitterProviderConfiguration {
final class LoggerProviderConfiguration {
static void configureLogEmitterProvider(
SdkLogEmitterProviderBuilder logEmitterProviderBuilder,
static void configureLoggerProvider(
SdkLoggerProviderBuilder loggerProviderBuilder,
ConfigProperties config,
ClassLoader serviceClassLoader,
MeterProvider meterProvider,
BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter>
logExporterCustomizer) {
logEmitterProviderBuilder.setLogLimits(() -> configureLogLimits(config));
loggerProviderBuilder.setLogLimits(() -> configureLogLimits(config));
Map<String, LogExporter> exportersByName =
configureLogExporters(config, serviceClassLoader, meterProvider, logExporterCustomizer);
configureLogProcessors(exportersByName, meterProvider)
.forEach(logEmitterProviderBuilder::addLogProcessor);
.forEach(loggerProviderBuilder::addLogProcessor);
}
// Visible for testing
@ -78,5 +78,5 @@ final class LogEmitterProviderConfiguration {
return builder.build();
}
private LogEmitterProviderConfiguration() {}
private LoggerProviderConfiguration() {}
}

42
sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java
View File

@ -28,8 +28,8 @@ import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.logs.LogProcessor;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder;
import io.opentelemetry.sdk.metrics.export.MetricReader;
@ -264,19 +264,19 @@ class AutoConfiguredOpenTelemetrySdkTest {
// TODO: add test for addMetricExporterCustomizer once OTLP export is enabled by default
@Test
void builder_addLogEmitterProviderCustomizer() {
void builder_addLoggerProviderCustomizer() {
Mockito.lenient().when(logProcessor.shutdown()).thenReturn(CompletableResultCode.ofSuccess());
when(logProcessor.forceFlush()).thenReturn(CompletableResultCode.ofSuccess());
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLoggerProvider sdkLoggerProvider =
builder
.addLogEmitterProviderCustomizer(
(logEmitterProviderBuilder, configProperties) ->
logEmitterProviderBuilder.addLogProcessor(logProcessor))
.addLoggerProviderCustomizer(
(loggerProviderBuilder, configProperties) ->
loggerProviderBuilder.addLogProcessor(logProcessor))
.build()
.getOpenTelemetrySdk()
.getSdkLogEmitterProvider();
sdkLogEmitterProvider.forceFlush().join(10, TimeUnit.SECONDS);
.getSdkLoggerProvider();
sdkLoggerProvider.forceFlush().join(10, TimeUnit.SECONDS);
verify(logProcessor).forceFlush();
}
@ -331,26 +331,22 @@ class AutoConfiguredOpenTelemetrySdkTest {
return builder;
}
});
BiFunction<SdkLogEmitterProviderBuilder, ConfigProperties, SdkLogEmitterProviderBuilder>
logCustomizer =
spy(
new BiFunction<
SdkLogEmitterProviderBuilder,
ConfigProperties,
SdkLogEmitterProviderBuilder>() {
@Override
public SdkLogEmitterProviderBuilder apply(
SdkLogEmitterProviderBuilder builder, ConfigProperties config) {
return builder;
}
});
BiFunction<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder> logCustomizer =
spy(
new BiFunction<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder>() {
@Override
public SdkLoggerProviderBuilder apply(
SdkLoggerProviderBuilder builder, ConfigProperties config) {
return builder;
}
});
AutoConfiguredOpenTelemetrySdk autoConfiguredSdk =
AutoConfiguredOpenTelemetrySdk.builder()
.addPropertiesSupplier(() -> singletonMap("otel.experimental.sdk.enabled", "false"))
.addTracerProviderCustomizer(traceCustomizer)
.addMeterProviderCustomizer(metricCustomizer)
.addLogEmitterProviderCustomizer(logCustomizer)
.addLoggerProviderCustomizer(logCustomizer)
.build();
assertThat(autoConfiguredSdk.getOpenTelemetrySdk()).isInstanceOf(OpenTelemetrySdk.class);

22
sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogEmitterProviderConfigurationTest.java → sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java
View File

@ -13,8 +13,8 @@ import io.opentelemetry.api.metrics.MeterProvider;
import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
import io.opentelemetry.sdk.logs.LogLimits;
import io.opentelemetry.sdk.logs.LogProcessor;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.trace.SpanLimits;
import java.util.Collections;
import java.util.Map;
@ -22,13 +22,13 @@ import java.util.function.Supplier;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.jupiter.api.Test;
class LogEmitterProviderConfigurationTest {
class LoggerProviderConfigurationTest {
private static final ConfigProperties EMPTY =
DefaultConfigProperties.createForTest(Collections.emptyMap());
@Test
void configureLogEmitterProvider() {
void configureLoggerProvider() {
Map<String, String> properties =
ImmutableMap.of(
"otel.logs.exporter", "none",
@ -36,17 +36,17 @@ class LogEmitterProviderConfigurationTest {
// We don't have any exporters on classpath for this test so check no-op case. Exporter cases
// are verified in other test sets like testFullConfig.
SdkLogEmitterProviderBuilder builder = SdkLogEmitterProvider.builder();
LogEmitterProviderConfiguration.configureLogEmitterProvider(
SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();
LoggerProviderConfiguration.configureLoggerProvider(
builder,
DefaultConfigProperties.createForTest(properties),
LogEmitterProviderConfiguration.class.getClassLoader(),
LoggerProviderConfiguration.class.getClassLoader(),
MeterProvider.noop(),
(a, unused) -> a);
SdkLogEmitterProvider logEmitterProvider = builder.build();
SdkLoggerProvider loggerProvider = builder.build();
try {
assertThat(logEmitterProvider)
assertThat(loggerProvider)
.extracting("sharedState")
.satisfies(
sharedState -> {
@ -60,13 +60,13 @@ class LogEmitterProviderConfigurationTest {
.isEqualTo(LogLimits.builder().setMaxNumberOfAttributes(5).build());
});
} finally {
logEmitterProvider.shutdown();
loggerProvider.shutdown();
}
}
@Test
void configureSpanLimits() {
assertThat(LogEmitterProviderConfiguration.configureLogLimits(EMPTY))
assertThat(LoggerProviderConfiguration.configureLogLimits(EMPTY))
.isEqualTo(LogLimits.getDefault());
SpanLimits config =

14
sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/FullConfigTest.java
View File

@ -39,7 +39,7 @@ import io.opentelemetry.proto.logs.v1.LogRecord;
import io.opentelemetry.proto.metrics.v1.Metric;
import io.opentelemetry.proto.metrics.v1.ResourceMetrics;
import io.opentelemetry.proto.metrics.v1.ScopeMetrics;
import io.opentelemetry.sdk.logs.LogEmitter;
import io.opentelemetry.sdk.logs.Logger;
import io.opentelemetry.sdk.logs.data.Severity;
import java.util.ArrayList;
import java.util.Collection;
@ -155,7 +155,7 @@ class FullConfigTest {
System.setProperty("otel.exporter.otlp.endpoint", endpoint);
System.setProperty("otel.exporter.otlp.timeout", "10000");
// Initialize here so we get SdkLogEmitterProvider and shutdown when done
// Initialize here so we get SdkLoggerProvider and shutdown when done
autoConfiguredOpenTelemetrySdk = AutoConfiguredOpenTelemetrySdk.initialize();
}
@ -168,7 +168,7 @@ class FullConfigTest {
.join(10, TimeUnit.SECONDS);
autoConfiguredOpenTelemetrySdk
.getOpenTelemetrySdk()
.getSdkLogEmitterProvider()
.getSdkLoggerProvider()
.shutdown()
.join(10, TimeUnit.SECONDS);
autoConfiguredOpenTelemetrySdk
@ -211,10 +211,10 @@ class FullConfigTest {
.add(1, Attributes.builder().put("allowed", "bear").put("not allowed", "dog").build());
meter.counterBuilder("my-other-metric").build().add(1);
LogEmitter logEmitter =
autoConfiguredOpenTelemetrySdk.getOpenTelemetrySdk().getSdkLogEmitterProvider().get("test");
logEmitter.logRecordBuilder().setBody("debug log message").setSeverity(Severity.DEBUG).emit();
logEmitter.logRecordBuilder().setBody("info log message").setSeverity(Severity.INFO).emit();
Logger logger =
autoConfiguredOpenTelemetrySdk.getOpenTelemetrySdk().getSdkLoggerProvider().get("test");
logger.logRecordBuilder().setBody("debug log message").setSeverity(Severity.DEBUG).emit();
logger.logRecordBuilder().setBody("info log message").setSeverity(Severity.INFO).emit();
await().untilAsserted(() -> assertThat(otlpTraceRequests).hasSize(1));

22
sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogEmitterProviderConfigurationTest.java → sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java
View File

@ -11,8 +11,8 @@ import com.google.common.collect.ImmutableMap;
import io.opentelemetry.api.metrics.MeterProvider;
import io.opentelemetry.exporter.logging.SystemOutLogExporter;
import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporter;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.logs.export.BatchLogProcessor;
import io.opentelemetry.sdk.logs.export.LogExporter;
import io.opentelemetry.sdk.logs.export.SimpleLogProcessor;
@ -22,23 +22,23 @@ import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test;
class LogEmitterProviderConfigurationTest {
class LoggerProviderConfigurationTest {
@Test
void configureLogEmitterProvider() {
void configureLoggerProvider() {
Map<String, String> properties = Collections.singletonMap("otel.logs.exporter", "otlp");
SdkLogEmitterProviderBuilder builder = SdkLogEmitterProvider.builder();
LogEmitterProviderConfiguration.configureLogEmitterProvider(
SdkLoggerProviderBuilder builder = SdkLoggerProvider.builder();
LoggerProviderConfiguration.configureLoggerProvider(
builder,
DefaultConfigProperties.createForTest(properties),
LogEmitterProviderConfiguration.class.getClassLoader(),
LoggerProviderConfiguration.class.getClassLoader(),
MeterProvider.noop(),
(a, unused) -> a);
SdkLogEmitterProvider logEmitterProvider = builder.build();
SdkLoggerProvider loggerProvider = builder.build();
try {
assertThat(logEmitterProvider)
assertThat(loggerProvider)
.extracting("sharedState")
.satisfies(
sharedState ->
@ -62,7 +62,7 @@ class LogEmitterProviderConfigurationTest {
queue -> assertThat(queue.remainingCapacity()).isEqualTo(2048));
}));
} finally {
logEmitterProvider.shutdown();
loggerProvider.shutdown();
}
}
@ -72,7 +72,7 @@ class LogEmitterProviderConfigurationTest {
LogExporter otlpExporter = OtlpGrpcLogExporter.builder().build();
assertThat(
LogEmitterProviderConfiguration.configureLogProcessors(
LoggerProviderConfiguration.configureLogProcessors(
ImmutableMap.of("logging", loggingExporter, "otlp", otlpExporter),
MeterProvider.noop()))
.hasSize(2)

2
sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcConfigTest.java
View File

@ -347,7 +347,7 @@ class OtlpGrpcConfigTest {
OpenTelemetrySdk sdk = ((OpenTelemetrySdk) delegate);
sdk.getSdkTracerProvider().shutdown().join(10, TimeUnit.SECONDS);
sdk.getSdkMeterProvider().shutdown().join(10, TimeUnit.SECONDS);
sdk.getSdkLogEmitterProvider().shutdown().join(10, TimeUnit.SECONDS);
sdk.getSdkLoggerProvider().shutdown().join(10, TimeUnit.SECONDS);
}
} catch (NoSuchFieldException | IllegalAccessException | ClassNotFoundException e) {
throw new IllegalStateException("Error shutting down global SDK.", e);

2
sdk/all/build.gradle.kts
View File

@ -17,7 +17,7 @@ dependencies {
api(project(":sdk:metrics"))
// implementation dependency to require users to add the artifact directly to their build to use
// SdkLogEmitterProvider.
// SdkLoggerProvider.
implementation(project(":sdk:logs"))
annotationProcessor("com.google.auto.value:auto-value")

14
sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdk.java
View File

@ -12,7 +12,7 @@ import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.api.trace.TracerBuilder;
import io.opentelemetry.api.trace.TracerProvider;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import javax.annotation.concurrent.ThreadSafe;
@ -22,17 +22,17 @@ import javax.annotation.concurrent.ThreadSafe;
public final class OpenTelemetrySdk implements OpenTelemetry {
private final ObfuscatedTracerProvider tracerProvider;
private final ObfuscatedMeterProvider meterProvider;
private final SdkLogEmitterProvider logEmitterProvider;
private final SdkLoggerProvider loggerProvider;
private final ContextPropagators propagators;
OpenTelemetrySdk(
SdkTracerProvider tracerProvider,
SdkMeterProvider meterProvider,
SdkLogEmitterProvider logEmitterProvider,
SdkLoggerProvider loggerProvider,
ContextPropagators propagators) {
this.tracerProvider = new ObfuscatedTracerProvider(tracerProvider);
this.meterProvider = new ObfuscatedMeterProvider(meterProvider);
this.logEmitterProvider = logEmitterProvider;
this.loggerProvider = loggerProvider;
this.propagators = propagators;
}
@ -64,9 +64,9 @@ public final class OpenTelemetrySdk implements OpenTelemetry {
return meterProvider.unobfuscate();
}
/** Returns the {@link SdkLogEmitterProvider} for this {@link OpenTelemetrySdk}. */
public SdkLogEmitterProvider getSdkLogEmitterProvider() {
return logEmitterProvider;
/** Returns the {@link SdkLoggerProvider} for this {@link OpenTelemetrySdk}. */
public SdkLoggerProvider getSdkLoggerProvider() {
return loggerProvider;
}
@Override

24
sdk/all/src/main/java/io/opentelemetry/sdk/OpenTelemetrySdkBuilder.java
View File

@ -7,7 +7,8 @@ package io.opentelemetry.sdk;
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
@ -19,7 +20,7 @@ public final class OpenTelemetrySdkBuilder {
private ContextPropagators propagators = ContextPropagators.noop();
@Nullable private SdkTracerProvider tracerProvider;
@Nullable private SdkMeterProvider meterProvider;
@Nullable private SdkLogEmitterProvider logEmitterProvider;
@Nullable private SdkLoggerProvider loggerProvider;
/**
* Package protected to disallow direct initialization.
@ -52,14 +53,13 @@ public final class OpenTelemetrySdkBuilder {
}
/**
* Sets the {@link SdkLogEmitterProvider} to use. This can be used to configure log settings by
* returning the instance created by a {@link
* io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder}.
* Sets the {@link SdkLoggerProvider} to use. This can be used to configure log settings by
* returning the instance created by a {@link SdkLoggerProviderBuilder}.
*
* @see SdkLogEmitterProvider#builder()
* @see SdkLoggerProvider#builder()
*/
public OpenTelemetrySdkBuilder setLogEmitterProvider(SdkLogEmitterProvider logEmitterProvider) {
this.logEmitterProvider = logEmitterProvider;
public OpenTelemetrySdkBuilder setLoggerProvider(SdkLoggerProvider loggerProvider) {
this.loggerProvider = loggerProvider;
return this;
}
@ -105,11 +105,11 @@ public final class OpenTelemetrySdkBuilder {
meterProvider = SdkMeterProvider.builder().build();
}
SdkLogEmitterProvider logEmitterProvider = this.logEmitterProvider;
if (logEmitterProvider == null) {
logEmitterProvider = SdkLogEmitterProvider.builder().build();
SdkLoggerProvider loggerProvider = this.loggerProvider;
if (loggerProvider == null) {
loggerProvider = SdkLoggerProvider.builder().build();
}
return new OpenTelemetrySdk(tracerProvider, meterProvider, logEmitterProvider, propagators);
return new OpenTelemetrySdk(tracerProvider, meterProvider, loggerProvider, propagators);
}
}

8
sdk/all/src/test/java/io/opentelemetry/sdk/OpenTelemetrySdkTest.java
View File

@ -18,7 +18,7 @@ import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.context.propagation.ContextPropagators;
import io.opentelemetry.context.propagation.TextMapPropagator;
import io.opentelemetry.sdk.common.Clock;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.metrics.Aggregation;
import io.opentelemetry.sdk.metrics.InstrumentSelector;
import io.opentelemetry.sdk.metrics.InstrumentType;
@ -46,7 +46,7 @@ class OpenTelemetrySdkTest {
@Mock private MetricExporter metricExporter;
@Mock private SdkTracerProvider tracerProvider;
@Mock private SdkMeterProvider meterProvider;
@Mock private SdkLogEmitterProvider logEmitterProvider;
@Mock private SdkLoggerProvider loggerProvider;
@Mock private ContextPropagators propagators;
@AfterEach
@ -107,7 +107,7 @@ class OpenTelemetrySdkTest {
OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
.setMeterProvider(meterProvider)
.setLogEmitterProvider(logEmitterProvider)
.setLoggerProvider(loggerProvider)
.setPropagators(propagators)
.build();
assertThat(
@ -119,7 +119,7 @@ class OpenTelemetrySdkTest {
((OpenTelemetrySdk.ObfuscatedMeterProvider) openTelemetry.getMeterProvider())
.unobfuscate())
.isEqualTo(meterProvider);
assertThat(openTelemetry.getSdkLogEmitterProvider()).isEqualTo(logEmitterProvider);
assertThat(openTelemetry.getSdkLoggerProvider()).isEqualTo(loggerProvider);
assertThat(openTelemetry.getPropagators()).isEqualTo(propagators);
}

2
sdk/logs/build.gradle.kts
View File

@ -5,7 +5,7 @@ plugins {
id("otel.animalsniffer-conventions")
}
description = "OpenTelemetry Contrib Logging Support"
description = "OpenTelemetry Log SDK"
otelJava.moduleName.set("io.opentelemetry.sdk.logs")
dependencies {

5
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogLimits.java
View File

@ -14,9 +14,8 @@ import javax.annotation.concurrent.Immutable;
* Class that holds limits enforced during log recording.
*
* <p>Note: To allow dynamic updates of {@link LogLimits} you should register a {@link
* java.util.function.Supplier} with {@link
* io.opentelemetry.sdk.logs.SdkLogEmitterProviderBuilder#setLogLimits(Supplier)} which supplies
* dynamic configs when queried.
* java.util.function.Supplier} with {@link SdkLoggerProviderBuilder#setLogLimits(Supplier)} which
* supplies dynamic configs when queried.
*/
@AutoValue
@Immutable

4
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogProcessor.java
View File

@ -15,7 +15,7 @@ import javax.annotation.concurrent.ThreadSafe;
/**
* {@link LogProcessor} is the interface to allow synchronous hooks for log records emitted by
* {@link LogEmitter}s.
* {@link Logger}s.
*/
@ThreadSafe
public interface LogProcessor extends Closeable {
@ -47,7 +47,7 @@ public interface LogProcessor extends Closeable {
}
/**
* Called when a {@link LogEmitter} {@link LogRecordBuilder#emit()}s a log record.
* Called when a {@link Logger} {@link LogRecordBuilder#emit()}s a log record.
*
* @param logRecord the log record
*/

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogRecordBuilder.java
View File

@ -13,10 +13,10 @@ import java.time.Instant;
import java.util.concurrent.TimeUnit;
/**
* Used to construct and emit logs from a {@link LogEmitter}.
* Used to construct and emit logs from a {@link Logger}.
*
* <p>Obtain a {@link LogEmitter#logRecordBuilder()}, add properties using the setters, and emit the
* log to downstream {@link LogProcessor}(s) by calling {@link #emit()}.
* <p>Obtain a {@link Logger#logRecordBuilder()}, add properties using the setters, and emit the log
* to downstream {@link LogProcessor}(s) by calling {@link #emit()}.
*/
public interface LogRecordBuilder {

4
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogEmitter.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/Logger.java
View File

@ -8,13 +8,13 @@ package io.opentelemetry.sdk.logs;
import javax.annotation.concurrent.ThreadSafe;
/**
* A {@link LogEmitter} is the entry point into a log pipeline.
* A {@link Logger} is the entry point into a log pipeline.
*
* <p>Obtain a {@link #logRecordBuilder()}, add properties using the setters, and emit it to
* downstream {@link LogProcessor}(s) via {@link LogRecordBuilder#emit()}.
*/
@ThreadSafe
public interface LogEmitter {
public interface Logger {
/**
* Return a {@link LogRecordBuilder} to emit a log record.

18
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogEmitterBuilder.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LoggerBuilder.java
View File

@ -5,29 +5,29 @@
package io.opentelemetry.sdk.logs;
/** Builder class for creating {@link LogEmitter} instances. */
public interface LogEmitterBuilder {
/** Builder class for creating {@link Logger} instances. */
public interface LoggerBuilder {
/**
* Assign an OpenTelemetry schema URL to the resulting {@link LogEmitter}.
* Assign an OpenTelemetry schema URL to the resulting {@link Logger}.
*
* @param schemaUrl the URL of the OpenTelemetry schema being used by this instrumentation scope
* @return this
*/
LogEmitterBuilder setSchemaUrl(String schemaUrl);
LoggerBuilder setSchemaUrl(String schemaUrl);
/**
* Assign a version to the instrumentation scope that is using the resulting {@link LogEmitter}.
* Assign a version to the instrumentation scope that is using the resulting {@link Logger}.
*
* @param instrumentationScopeVersion the version of the instrumentation scope
* @return this
*/
LogEmitterBuilder setInstrumentationVersion(String instrumentationScopeVersion);
LoggerBuilder setInstrumentationVersion(String instrumentationScopeVersion);
/**
* Gets or creates a {@link LogEmitter} instance.
* Gets or creates a {@link Logger} instance.
*
* @return a log emitter instance configured with the provided options
* @return a logger instance configured with the provided options
*/
LogEmitter build();
Logger build();
}

8
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LogEmitterSharedState.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LoggerSharedState.java
View File

@ -12,10 +12,10 @@ import java.util.function.Supplier;
import javax.annotation.Nullable;
/**
* Represents shared state and config between all {@link SdkLogEmitter}s created by the same {@link
* SdkLogEmitterProvider}.
* Represents shared state and config between all {@link SdkLogger}s created by the same {@link
* SdkLoggerProvider}.
*/
final class LogEmitterSharedState {
final class LoggerSharedState {
private final Object lock = new Object();
private final Resource resource;
private final Supplier<LogLimits> logLimitsSupplier;
@ -23,7 +23,7 @@ final class LogEmitterSharedState {
private final Clock clock;
@Nullable private volatile CompletableResultCode shutdownResult = null;
LogEmitterSharedState(
LoggerSharedState(
Resource resource,
Supplier<LogLimits> logLimitsSupplier,
LogProcessor logProcessor,

28
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/NoopLogEmitterBuilder.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/NoopLoggerBuilder.java
View File

@ -11,37 +11,37 @@ import io.opentelemetry.sdk.logs.data.Severity;
import java.time.Instant;
import java.util.concurrent.TimeUnit;
class NoopLogEmitterBuilder implements LogEmitterBuilder {
class NoopLoggerBuilder implements LoggerBuilder {
private static final NoopLogEmitterBuilder INSTANCE = new NoopLogEmitterBuilder();
private static final NoopLogEmitter NOOP_LOG_EMITTER = new NoopLogEmitter();
private static final NoopLoggerBuilder INSTANCE = new NoopLoggerBuilder();
private static final NoopLogger NOOP_LOGGER = new NoopLogger();
private NoopLogEmitterBuilder() {}
private NoopLoggerBuilder() {}
static LogEmitterBuilder getInstance() {
static LoggerBuilder getInstance() {
return INSTANCE;
}
@Override
public LogEmitterBuilder setSchemaUrl(String schemaUrl) {
public LoggerBuilder setSchemaUrl(String schemaUrl) {
return this;
}
@Override
public LogEmitterBuilder setInstrumentationVersion(String instrumentationScopeVersion) {
public LoggerBuilder setInstrumentationVersion(String instrumentationScopeVersion) {
return this;
}
@Override
public LogEmitter build() {
return NOOP_LOG_EMITTER;
public Logger build() {
return NOOP_LOGGER;
}
private static class NoopLogEmitter implements LogEmitter {
private static class NoopLogger implements Logger {
private static final NoopLogBuilder NOOP_LOG_BUILDER = new NoopLogBuilder();
private static final NoopLogRecordBuilder NOOP_LOG_BUILDER = new NoopLogRecordBuilder();
private NoopLogEmitter() {}
private NoopLogger() {}
@Override
public LogRecordBuilder logRecordBuilder() {
@ -49,9 +49,9 @@ class NoopLogEmitterBuilder implements LogEmitterBuilder {
}
}
private static class NoopLogBuilder implements LogRecordBuilder {
private static class NoopLogRecordBuilder implements LogRecordBuilder {
private NoopLogBuilder() {}
private NoopLogRecordBuilder() {}
@Override
public LogRecordBuilder setEpoch(long timestamp, TimeUnit unit) {

21
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java
View File

@ -20,7 +20,7 @@ import javax.annotation.Nullable;
/** SDK implementation of {@link LogRecordBuilder}. */
final class SdkLogRecordBuilder implements LogRecordBuilder {
private final LogEmitterSharedState logEmitterSharedState;
private final LoggerSharedState loggerSharedState;
private final LogLimits logLimits;
private final InstrumentationScopeInfo instrumentationScopeInfo;
@ -32,10 +32,9 @@ final class SdkLogRecordBuilder implements LogRecordBuilder {
@Nullable private AttributesMap attributes;
SdkLogRecordBuilder(
LogEmitterSharedState logEmitterSharedState,
InstrumentationScopeInfo instrumentationScopeInfo) {
this.logEmitterSharedState = logEmitterSharedState;
this.logLimits = logEmitterSharedState.getLogLimits();
LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {
this.loggerSharedState = loggerSharedState;
this.logLimits = loggerSharedState.getLogLimits();
this.instrumentationScopeInfo = instrumentationScopeInfo;
}
@ -91,19 +90,17 @@ final class SdkLogRecordBuilder implements LogRecordBuilder {
@Override
public void emit() {
if (logEmitterSharedState.hasBeenShutdown()) {
if (loggerSharedState.hasBeenShutdown()) {
return;
}
logEmitterSharedState
loggerSharedState
.getLogProcessor()
.onEmit(
SdkReadWriteLogRecord.create(
logEmitterSharedState.getLogLimits(),
logEmitterSharedState.getResource(),
loggerSharedState.getLogLimits(),
loggerSharedState.getResource(),
instrumentationScopeInfo,
this.epochNanos == 0
? this.logEmitterSharedState.getClock().now()
: this.epochNanos,
this.epochNanos == 0 ? this.loggerSharedState.getClock().now() : this.epochNanos,
spanContext,
severity,
severityText,

15
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogEmitter.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogger.java
View File

@ -7,22 +7,21 @@ package io.opentelemetry.sdk.logs;
import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
/** SDK implementation of {@link LogEmitter}. */
final class SdkLogEmitter implements LogEmitter {
/** SDK implementation of {@link Logger}. */
final class SdkLogger implements Logger {
private final LogEmitterSharedState logEmitterSharedState;
private final LoggerSharedState loggerSharedState;
private final InstrumentationScopeInfo instrumentationScopeInfo;
SdkLogEmitter(
LogEmitterSharedState logEmitterSharedState,
InstrumentationScopeInfo instrumentationScopeInfo) {
this.logEmitterSharedState = logEmitterSharedState;
SdkLogger(
LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {
this.loggerSharedState = loggerSharedState;
this.instrumentationScopeInfo = instrumentationScopeInfo;
}
@Override
public LogRecordBuilder logRecordBuilder() {
return new SdkLogRecordBuilder(logEmitterSharedState, instrumentationScopeInfo);
return new SdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo);
}
// VisibleForTesting

12
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogEmitterBuilder.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerBuilder.java
View File

@ -9,30 +9,30 @@ import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
import io.opentelemetry.sdk.common.InstrumentationScopeInfoBuilder;
import io.opentelemetry.sdk.internal.ComponentRegistry;
final class SdkLogEmitterBuilder implements LogEmitterBuilder {
final class SdkLoggerBuilder implements LoggerBuilder {
private final ComponentRegistry<SdkLogEmitter> registry;
private final ComponentRegistry<SdkLogger> registry;
private final InstrumentationScopeInfoBuilder scopeBuilder;
SdkLogEmitterBuilder(ComponentRegistry<SdkLogEmitter> registry, String instrumentationScopeName) {
SdkLoggerBuilder(ComponentRegistry<SdkLogger> registry, String instrumentationScopeName) {
this.registry = registry;
this.scopeBuilder = InstrumentationScopeInfo.builder(instrumentationScopeName);
}
@Override
public SdkLogEmitterBuilder setSchemaUrl(String schemaUrl) {
public SdkLoggerBuilder setSchemaUrl(String schemaUrl) {
scopeBuilder.setSchemaUrl(schemaUrl);
return this;
}
@Override
public SdkLogEmitterBuilder setInstrumentationVersion(String instrumentationScopeVersion) {
public SdkLoggerBuilder setInstrumentationVersion(String instrumentationScopeVersion) {
scopeBuilder.setVersion(instrumentationScopeVersion);
return this;
}
@Override
public SdkLogEmitter build() {
public SdkLogger build() {
return registry.get(scopeBuilder.build());
}
}

50
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogEmitterProvider.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProvider.java
View File

@ -14,66 +14,66 @@ import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.logging.Level;
import java.util.logging.Logger;
/** SDK registry for creating {@link LogEmitter}s. */
public final class SdkLogEmitterProvider implements Closeable {
/** SDK registry for creating {@link Logger}s. */
public final class SdkLoggerProvider implements Closeable {
static final String DEFAULT_EMITTER_NAME = "unknown";
private static final Logger LOGGER = Logger.getLogger(SdkLogEmitterProvider.class.getName());
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 LogEmitterSharedState sharedState;
private final ComponentRegistry<SdkLogEmitter> logEmitterComponentRegistry;
private final LoggerSharedState sharedState;
private final ComponentRegistry<SdkLogger> loggerComponentRegistry;
private final boolean isNoopLogProcessor;
/**
* Returns a new {@link SdkLogEmitterProviderBuilder} for {@link SdkLogEmitterProvider}.
* Returns a new {@link SdkLoggerProviderBuilder} for {@link SdkLoggerProvider}.
*
* @return a new builder instance
*/
public static SdkLogEmitterProviderBuilder builder() {
return new SdkLogEmitterProviderBuilder();
public static SdkLoggerProviderBuilder builder() {
return new SdkLoggerProviderBuilder();
}
SdkLogEmitterProvider(
SdkLoggerProvider(
Resource resource,
Supplier<LogLimits> logLimitsSupplier,
List<LogProcessor> processors,
Clock clock) {
LogProcessor logProcessor = LogProcessor.composite(processors);
this.sharedState = new LogEmitterSharedState(resource, logLimitsSupplier, logProcessor, clock);
this.logEmitterComponentRegistry =
this.sharedState = new LoggerSharedState(resource, logLimitsSupplier, logProcessor, clock);
this.loggerComponentRegistry =
new ComponentRegistry<>(
instrumentationScopeInfo -> new SdkLogEmitter(sharedState, instrumentationScopeInfo));
instrumentationScopeInfo -> new SdkLogger(sharedState, instrumentationScopeInfo));
this.isNoopLogProcessor = logProcessor instanceof NoopLogProcessor;
}
/**
* Gets or creates a named log emitter instance.
* 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 log emitter instance
* @return a logger instance
*/
public LogEmitter get(String instrumentationScopeName) {
return logEmitterBuilder(instrumentationScopeName).build();
public Logger get(String instrumentationScopeName) {
return loggerBuilder(instrumentationScopeName).build();
}
/**
* Creates a {@link LogEmitterBuilder} instance.
* Creates a {@link LoggerBuilder} instance.
*
* @param instrumentationScopeName the name of the instrumentation scope
* @return a log emitter builder instance
* @return a logger builder instance
*/
public LogEmitterBuilder logEmitterBuilder(String instrumentationScopeName) {
public LoggerBuilder loggerBuilder(String instrumentationScopeName) {
if (isNoopLogProcessor) {
return NoopLogEmitterBuilder.getInstance();
return NoopLoggerBuilder.getInstance();
}
if (instrumentationScopeName == null || instrumentationScopeName.isEmpty()) {
LOGGER.fine("LogEmitter requested without instrumentation scope name.");
instrumentationScopeName = DEFAULT_EMITTER_NAME;
LOGGER.fine("Logger requested without instrumentation scope name.");
instrumentationScopeName = DEFAULT_LOGGER_NAME;
}
return new SdkLogEmitterBuilder(logEmitterComponentRegistry, instrumentationScopeName);
return new SdkLoggerBuilder(loggerComponentRegistry, instrumentationScopeName);
}
/**

28
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogEmitterProviderBuilder.java → sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProviderBuilder.java
View File

@ -14,24 +14,24 @@ import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
/** Builder class for {@link SdkLogEmitterProvider} instances. */
public final class SdkLogEmitterProviderBuilder {
/** Builder class for {@link SdkLoggerProvider} instances. */
public final class SdkLoggerProviderBuilder {
private final List<LogProcessor> logProcessors = new ArrayList<>();
private Resource resource = Resource.getDefault();
private Supplier<LogLimits> logLimitsSupplier = LogLimits::getDefault;
private Clock clock = Clock.getDefault();
SdkLogEmitterProviderBuilder() {}
SdkLoggerProviderBuilder() {}
/**
* Assign a {@link Resource} to be attached to all {@link LogData} created by {@link LogEmitter}s
* obtained from the {@link SdkLogEmitterProvider}.
* Assign a {@link Resource} to be attached to all {@link LogData} created by {@link Logger}s
* obtained from the {@link SdkLoggerProvider}.
*
* @param resource the resource
* @return this
*/
public SdkLogEmitterProviderBuilder setResource(Resource resource) {
public SdkLoggerProviderBuilder setResource(Resource resource) {
requireNonNull(resource, "resource");
this.resource = resource;
return this;
@ -39,7 +39,7 @@ public final class SdkLogEmitterProviderBuilder {
/**
* Assign a {@link Supplier} of {@link LogLimits}. {@link LogLimits} will be retrieved each time a
* {@link LogEmitter#logRecordBuilder()} is called.
* {@link Logger#logRecordBuilder()} is called.
*
* <p>The {@code logLimitsSupplier} must be thread-safe and return immediately (no remote calls,
* as contention free as possible).
@ -48,7 +48,7 @@ public final class SdkLogEmitterProviderBuilder {
* every {@link LogRecordBuilder}.
* @return this
*/
public SdkLogEmitterProviderBuilder setLogLimits(Supplier<LogLimits> logLimitsSupplier) {
public SdkLoggerProviderBuilder setLogLimits(Supplier<LogLimits> logLimitsSupplier) {
requireNonNull(logLimitsSupplier, "logLimitsSupplier");
this.logLimitsSupplier = logLimitsSupplier;
return this;
@ -56,12 +56,12 @@ public final class SdkLogEmitterProviderBuilder {
/**
* Add a log processor. {@link LogProcessor#onEmit(ReadWriteLogRecord)} will be called each time a
* log is emitted by {@link LogEmitter} instances obtained from the {@link SdkLogEmitterProvider}.
* log is emitted by {@link Logger} instances obtained from the {@link SdkLoggerProvider}.
*
* @param processor the log processor
* @return this
*/
public SdkLogEmitterProviderBuilder addLogProcessor(LogProcessor processor) {
public SdkLoggerProviderBuilder addLogProcessor(LogProcessor processor) {
requireNonNull(processor, "processor");
logProcessors.add(processor);
return this;
@ -77,18 +77,18 @@ public final class SdkLogEmitterProviderBuilder {
* @param clock The clock to use for all temporal needs.
* @return this
*/
public SdkLogEmitterProviderBuilder setClock(Clock clock) {
public SdkLoggerProviderBuilder setClock(Clock clock) {
requireNonNull(clock, "clock");
this.clock = clock;
return this;
}
/**
* Create a {@link SdkLogEmitterProvider} instance.
* Create a {@link SdkLoggerProvider} instance.
*
* @return an instance configured with the provided options
*/
public SdkLogEmitterProvider build() {
return new SdkLogEmitterProvider(resource, logLimitsSupplier, logProcessors, clock);
public SdkLoggerProvider build() {
return new SdkLoggerProvider(resource, logLimitsSupplier, logProcessors, clock);
}
}

6
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogExporter.java
View File

@ -7,7 +7,7 @@ package io.opentelemetry.sdk.logs.export;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.logs.LogProcessor;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.data.LogData;
import java.io.Closeable;
import java.util.ArrayList;
@ -68,8 +68,8 @@ public interface LogExporter extends Closeable {
CompletableResultCode flush();
/**
* Shutdown the log exporter. Called when {@link SdkLogEmitterProvider#shutdown()} is called when
* this exporter is registered to the provider via {@link BatchLogProcessor} or {@link
* Shutdown the log exporter. Called when {@link SdkLoggerProvider#shutdown()} is called when this
* exporter is registered to the provider via {@link BatchLogProcessor} or {@link
* SimpleLogProcessor}.
*
* @return a {@link CompletableResultCode} which is completed when shutdown completes

2
sdk/logs/src/main/java/io/opentelemetry/sdk/logs/package-info.java
View File

@ -6,7 +6,7 @@
/**
* The OpenTelemetry SDK implementation of logging.
*
* @see io.opentelemetry.sdk.logs.SdkLogEmitterProvider
* @see io.opentelemetry.sdk.logs.SdkLoggerProvider
*/
@ParametersAreNonnullByDefault
package io.opentelemetry.sdk.logs;

6
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/LogEmitterSharedStateTest.java → sdk/logs/src/test/java/io/opentelemetry/sdk/logs/LoggerSharedStateTest.java
View File

@ -15,15 +15,15 @@ import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.resources.Resource;
import org.junit.jupiter.api.Test;
class LogEmitterSharedStateTest {
class LoggerSharedStateTest {
@Test
void shutdown() {
LogProcessor logProcessor = mock(LogProcessor.class);
CompletableResultCode code = new CompletableResultCode();
when(logProcessor.shutdown()).thenReturn(code);
LogEmitterSharedState state =
new LogEmitterSharedState(
LoggerSharedState state =
new LoggerSharedState(
Resource.empty(), LogLimits::getDefault, logProcessor, Clock.getDefault());
state.shutdown();
state.shutdown();

4
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/NoopLogEmitterBuilderTest.java → sdk/logs/src/test/java/io/opentelemetry/sdk/logs/NoopLoggerBuilderTest.java
View File

@ -12,11 +12,11 @@ import java.time.Instant;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test;
class NoopLogEmitterBuilderTest {
class NoopLoggerBuilderTest {
@Test
void buildAndEmit() {
NoopLogEmitterBuilder.getInstance()
NoopLoggerBuilder.getInstance()
.setSchemaUrl("http://endpoint")
.setInstrumentationVersion("1.0.0")
.build()

14
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java
View File

@ -39,19 +39,19 @@ class SdkLogRecordBuilderTest {
private static final Resource RESOURCE = Resource.empty();
private static final InstrumentationScopeInfo SCOPE_INFO = InstrumentationScopeInfo.empty();
@Mock LogEmitterSharedState logEmitterSharedState;
@Mock LoggerSharedState loggerSharedState;
private final AtomicReference<ReadWriteLogRecord> emittedLog = new AtomicReference<>();
private SdkLogRecordBuilder builder;
@BeforeEach
void setup() {
when(logEmitterSharedState.getLogLimits()).thenReturn(LogLimits.getDefault());
when(logEmitterSharedState.getLogProcessor()).thenReturn(emittedLog::set);
when(logEmitterSharedState.getResource()).thenReturn(RESOURCE);
when(logEmitterSharedState.getClock()).thenReturn(Clock.getDefault());
when(loggerSharedState.getLogLimits()).thenReturn(LogLimits.getDefault());
when(loggerSharedState.getLogProcessor()).thenReturn(emittedLog::set);
when(loggerSharedState.getResource()).thenReturn(RESOURCE);
when(loggerSharedState.getClock()).thenReturn(Clock.getDefault());
builder = new SdkLogRecordBuilder(logEmitterSharedState, SCOPE_INFO);
builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO);
}
@Test
@ -92,7 +92,7 @@ class SdkLogRecordBuilderTest {
void emit_NoFields() {
Clock clock = mock(Clock.class);
when(clock.now()).thenReturn(10L);
when(logEmitterSharedState.getClock()).thenReturn(clock);
when(loggerSharedState.getClock()).thenReturn(clock);
builder.emit();

142
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogEmitterProviderTest.java → sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLoggerProviderTest.java
View File

@ -41,24 +41,24 @@ import org.mockito.quality.Strictness;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class SdkLogEmitterProviderTest {
class SdkLoggerProviderTest {
@Mock private LogProcessor logProcessor;
private SdkLogEmitterProvider sdkLogEmitterProvider;
private SdkLoggerProvider sdkLoggerProvider;
@BeforeEach
void setup() {
sdkLogEmitterProvider = SdkLogEmitterProvider.builder().addLogProcessor(logProcessor).build();
sdkLoggerProvider = SdkLoggerProvider.builder().addLogProcessor(logProcessor).build();
when(logProcessor.forceFlush()).thenReturn(CompletableResultCode.ofSuccess());
when(logProcessor.shutdown()).thenReturn(CompletableResultCode.ofSuccess());
}
@Test
void builder_defaultResource() {
assertThat(SdkLogEmitterProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getResource)
assertThat(SdkLoggerProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getResource)
.isEqualTo(Resource.getDefault());
}
@ -66,25 +66,25 @@ class SdkLogEmitterProviderTest {
void builder_resourceProvided() {
Resource resource = Resource.create(Attributes.builder().put("key", "value").build());
assertThat(SdkLogEmitterProvider.builder().setResource(resource).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getResource)
assertThat(SdkLoggerProvider.builder().setResource(resource).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getResource)
.isEqualTo(resource);
}
@Test
void builder_noProcessor() {
assertThat(SdkLogEmitterProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getLogProcessor)
assertThat(SdkLoggerProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getLogProcessor)
.isSameAs(NoopLogProcessor.getInstance());
}
@Test
void builder_defaultLogLimits() {
assertThat(SdkLogEmitterProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getLogLimits)
assertThat(SdkLoggerProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getLogLimits)
.isSameAs(LogLimits.getDefault());
}
@ -92,38 +92,38 @@ class SdkLogEmitterProviderTest {
void builder_logLimitsProvided() {
LogLimits logLimits =
LogLimits.builder().setMaxNumberOfAttributes(1).setMaxAttributeValueLength(1).build();
assertThat(SdkLogEmitterProvider.builder().setLogLimits(() -> logLimits).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getLogLimits)
assertThat(SdkLoggerProvider.builder().setLogLimits(() -> logLimits).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getLogLimits)
.isSameAs(logLimits);
}
@Test
void builder_defaultClock() {
assertThat(SdkLogEmitterProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getClock)
assertThat(SdkLoggerProvider.builder().build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getClock)
.isSameAs(Clock.getDefault());
}
@Test
void builder_clockProvided() {
Clock clock = mock(Clock.class);
assertThat(SdkLogEmitterProvider.builder().setClock(clock).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getClock)
assertThat(SdkLoggerProvider.builder().setClock(clock).build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getClock)
.isSameAs(clock);
}
@Test
void builder_multipleProcessors() {
assertThat(
SdkLogEmitterProvider.builder()
SdkLoggerProvider.builder()
.addLogProcessor(logProcessor)
.addLogProcessor(logProcessor)
.build())
.extracting("sharedState", as(InstanceOfAssertFactories.type(LogEmitterSharedState.class)))
.extracting(LogEmitterSharedState::getLogProcessor)
.extracting("sharedState", as(InstanceOfAssertFactories.type(LoggerSharedState.class)))
.extracting(LoggerSharedState::getLogProcessor)
.satisfies(
activeLogProcessor -> {
assertThat(activeLogProcessor).isInstanceOf(MultiLogProcessor.class);
@ -135,64 +135,54 @@ class SdkLogEmitterProviderTest {
}
@Test
void logEmitterBuilder_SameName() {
assertThat(sdkLogEmitterProvider.logEmitterBuilder("test").build())
.isSameAs(sdkLogEmitterProvider.get("test"))
.isSameAs(sdkLogEmitterProvider.logEmitterBuilder("test").build())
void loggerBuilder_SameName() {
assertThat(sdkLoggerProvider.loggerBuilder("test").build())
.isSameAs(sdkLoggerProvider.get("test"))
.isSameAs(sdkLoggerProvider.loggerBuilder("test").build())
.isNotSameAs(
sdkLogEmitterProvider
.logEmitterBuilder("test")
.setInstrumentationVersion("version")
.build());
sdkLoggerProvider.loggerBuilder("test").setInstrumentationVersion("version").build());
}
@Test
void logEmitterBuilder_SameNameAndVersion() {
assertThat(
sdkLogEmitterProvider
.logEmitterBuilder("test")
.setInstrumentationVersion("version")
.build())
void loggerBuilder_SameNameAndVersion() {
assertThat(sdkLoggerProvider.loggerBuilder("test").setInstrumentationVersion("version").build())
.isSameAs(
sdkLogEmitterProvider
.logEmitterBuilder("test")
.setInstrumentationVersion("version")
.build())
sdkLoggerProvider.loggerBuilder("test").setInstrumentationVersion("version").build())
.isNotSameAs(
sdkLogEmitterProvider
.logEmitterBuilder("test")
sdkLoggerProvider
.loggerBuilder("test")
.setInstrumentationVersion("version")
.setSchemaUrl("http://url")
.build());
}
@Test
void logEmitterBuilder_SameNameVersionAndSchema() {
void loggerBuilder_SameNameVersionAndSchema() {
assertThat(
sdkLogEmitterProvider
.logEmitterBuilder("test")
sdkLoggerProvider
.loggerBuilder("test")
.setInstrumentationVersion("version")
.setSchemaUrl("http://url")
.build())
.isSameAs(
sdkLogEmitterProvider
.logEmitterBuilder("test")
sdkLoggerProvider
.loggerBuilder("test")
.setInstrumentationVersion("version")
.setSchemaUrl("http://url")
.build());
}
@Test
void logEmitterBuilder_PropagatesToEmitter() {
void loggerBuilder_PropagatesToLogger() {
InstrumentationScopeInfo expected =
InstrumentationScopeInfo.builder("test")
.setVersion("version")
.setSchemaUrl("http://url")
.build();
assertThat(
((SdkLogEmitter)
sdkLogEmitterProvider
.logEmitterBuilder("test")
((SdkLogger)
sdkLoggerProvider
.loggerBuilder("test")
.setInstrumentationVersion("version")
.setSchemaUrl("http://url")
.build())
@ -201,32 +191,32 @@ class SdkLogEmitterProviderTest {
}
@Test
void logEmitterBuilder_DefaultEmitterName() {
void loggerBuilder_DefaultLoggerName() {
assertThat(
((SdkLogEmitter) sdkLogEmitterProvider.logEmitterBuilder(null).build())
((SdkLogger) sdkLoggerProvider.loggerBuilder(null).build())
.getInstrumentationScopeInfo()
.getName())
.isEqualTo(SdkLogEmitterProvider.DEFAULT_EMITTER_NAME);
.isEqualTo(SdkLoggerProvider.DEFAULT_LOGGER_NAME);
assertThat(
((SdkLogEmitter) sdkLogEmitterProvider.logEmitterBuilder("").build())
((SdkLogger) sdkLoggerProvider.loggerBuilder("").build())
.getInstrumentationScopeInfo()
.getName())
.isEqualTo(SdkLogEmitterProvider.DEFAULT_EMITTER_NAME);
.isEqualTo(SdkLoggerProvider.DEFAULT_LOGGER_NAME);
}
@Test
void logEmitterBuilder_NoProcessor_UsesNoop() {
assertThat(SdkLogEmitterProvider.builder().build().logEmitterBuilder("test"))
.isInstanceOf(NoopLogEmitterBuilder.class);
void loggerBuilder_NoProcessor_UsesNoop() {
assertThat(SdkLoggerProvider.builder().build().loggerBuilder("test"))
.isInstanceOf(NoopLoggerBuilder.class);
}
@Test
void logEmitterBuilder_WithLogProcessor() {
void loggerBuilder_WithLogProcessor() {
Resource resource = Resource.builder().put("r1", "v1").build();
AtomicReference<LogData> logData = new AtomicReference<>();
sdkLogEmitterProvider =
SdkLogEmitterProvider.builder()
sdkLoggerProvider =
SdkLoggerProvider.builder()
.setResource(resource)
.addLogProcessor(
logRecord -> {
@ -245,7 +235,7 @@ class SdkLogEmitterProviderTest {
"7777777777777777",
TraceFlags.getSampled(),
TraceState.getDefault());
sdkLogEmitterProvider
sdkLoggerProvider
.get("test")
.logRecordBuilder()
.setEpoch(100, TimeUnit.NANOSECONDS)
@ -271,21 +261,21 @@ class SdkLogEmitterProviderTest {
@Test
void forceFlush() {
sdkLogEmitterProvider.forceFlush();
sdkLoggerProvider.forceFlush();
verify(logProcessor).forceFlush();
}
@Test
@SuppressLogger(SdkLogEmitterProvider.class)
@SuppressLogger(SdkLoggerProvider.class)
void shutdown() {
sdkLogEmitterProvider.shutdown();
sdkLogEmitterProvider.shutdown();
sdkLoggerProvider.shutdown();
sdkLoggerProvider.shutdown();
verify(logProcessor, times(1)).shutdown();
}
@Test
void close() {
sdkLogEmitterProvider.close();
sdkLoggerProvider.close();
verify(logProcessor).shutdown();
}
@ -296,9 +286,9 @@ class SdkLogEmitterProviderTest {
when(clock.now()).thenReturn(now);
List<ReadWriteLogRecord> seenLogs = new ArrayList<>();
logProcessor = seenLogs::add;
sdkLogEmitterProvider =
SdkLogEmitterProvider.builder().setClock(clock).addLogProcessor(logProcessor).build();
sdkLogEmitterProvider.logEmitterBuilder(null).build().logRecordBuilder().emit();
sdkLoggerProvider =
SdkLoggerProvider.builder().setClock(clock).addLogProcessor(logProcessor).build();
sdkLoggerProvider.loggerBuilder(null).build().logRecordBuilder().emit();
assertThat(seenLogs.size()).isEqualTo(1);
assertThat(seenLogs.get(0).toLogData().getEpochNanos()).isEqualTo(now);
}

28
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogEmitterTest.java → sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLoggerTest.java
View File

@ -30,11 +30,11 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.Test;
class SdkLogEmitterTest {
class SdkLoggerTest {
@Test
void logRecordBuilder() {
LogEmitterSharedState state = mock(LogEmitterSharedState.class);
LoggerSharedState state = mock(LoggerSharedState.class);
InstrumentationScopeInfo info = InstrumentationScopeInfo.create("foo");
AtomicReference<ReadWriteLogRecord> seenLog = new AtomicReference<>();
LogProcessor logProcessor = seenLog::set;
@ -45,8 +45,8 @@ class SdkLogEmitterTest {
when(state.getLogProcessor()).thenReturn(logProcessor);
when(state.getClock()).thenReturn(clock);
SdkLogEmitter emitter = new SdkLogEmitter(state, info);
LogRecordBuilder logRecordBuilder = emitter.logRecordBuilder();
SdkLogger logger = new SdkLogger(state, info);
LogRecordBuilder logRecordBuilder = logger.logRecordBuilder();
logRecordBuilder.setBody("foo");
// Have to test through the builder
@ -58,12 +58,12 @@ class SdkLogEmitterTest {
void logRecordBuilder_maxAttributeLength() {
int maxLength = 25;
AtomicReference<ReadWriteLogRecord> seenLog = new AtomicReference<>();
SdkLogEmitterProvider logEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider loggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(seenLog::set)
.setLogLimits(() -> LogLimits.builder().setMaxAttributeValueLength(maxLength).build())
.build();
LogRecordBuilder logRecordBuilder = logEmitterProvider.get("test").logRecordBuilder();
LogRecordBuilder logRecordBuilder = loggerProvider.get("test").logRecordBuilder();
String strVal = StringUtils.padLeft("", maxLength);
String tooLongStrVal = strVal + strVal;
@ -98,14 +98,14 @@ class SdkLogEmitterTest {
void logRecordBuilder_maxAttributes() {
int maxNumberOfAttrs = 8;
AtomicReference<ReadWriteLogRecord> seenLog = new AtomicReference<>();
SdkLogEmitterProvider logEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider loggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(seenLog::set)
.setLogLimits(
() -> LogLimits.builder().setMaxNumberOfAttributes(maxNumberOfAttrs).build())
.build();
LogRecordBuilder builder = logEmitterProvider.get("test").logRecordBuilder();
LogRecordBuilder builder = loggerProvider.get("test").logRecordBuilder();
AttributesBuilder expectedAttributes = Attributes.builder();
for (int i = 0; i < 2 * maxNumberOfAttrs; i++) {
AttributeKey<Long> key = AttributeKey.longKey("key" + i);
@ -125,11 +125,11 @@ class SdkLogEmitterTest {
void logRecordBuilder_AfterShutdown() {
LogProcessor logProcessor = mock(LogProcessor.class);
when(logProcessor.shutdown()).thenReturn(CompletableResultCode.ofSuccess());
SdkLogEmitterProvider logEmitterProvider =
SdkLogEmitterProvider.builder().addLogProcessor(logProcessor).build();
SdkLoggerProvider loggerProvider =
SdkLoggerProvider.builder().addLogProcessor(logProcessor).build();
logEmitterProvider.shutdown().join(10, TimeUnit.SECONDS);
logEmitterProvider.get("test").logRecordBuilder().emit();
loggerProvider.shutdown().join(10, TimeUnit.SECONDS);
loggerProvider.get("test").logRecordBuilder().emit();
verify(logProcessor, never()).onEmit(any());
}

76
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorTest.java
View File

@ -18,7 +18,7 @@ import static org.mockito.Mockito.when;
import io.opentelemetry.api.internal.GuardedBy;
import io.opentelemetry.internal.testing.slf4j.SuppressLogger;
import io.opentelemetry.sdk.common.CompletableResultCode;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.data.LogData;
import io.opentelemetry.sdk.testing.assertj.LogAssertions;
import java.util.ArrayList;
@ -54,9 +54,9 @@ class BatchLogProcessorTest {
when(mockLogExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess());
}
private void emitLog(SdkLogEmitterProvider sdkLogEmitterProvider, String message) {
sdkLogEmitterProvider
.logEmitterBuilder(getClass().getName())
private void emitLog(SdkLoggerProvider sdkLoggerProvider, String message) {
sdkLoggerProvider
.loggerBuilder(getClass().getName())
.build()
.logRecordBuilder()
.setBody(message)
@ -110,16 +110,16 @@ class BatchLogProcessorTest {
void emitMultipleLogs() {
WaitingLogExporter waitingLogExporter =
new WaitingLogExporter(2, CompletableResultCode.ofSuccess());
SdkLogEmitterProvider logEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider loggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(waitingLogExporter)
.setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS)
.build())
.build();
emitLog(logEmitterProvider, LOG_MESSAGE_1);
emitLog(logEmitterProvider, LOG_MESSAGE_2);
emitLog(loggerProvider, LOG_MESSAGE_1);
emitLog(loggerProvider, LOG_MESSAGE_2);
List<LogData> exported = waitingLogExporter.waitForExport();
assertThat(exported)
.satisfiesExactly(
@ -131,8 +131,8 @@ class BatchLogProcessorTest {
void emitMoreLogsThanBufferSize() {
CompletableLogExporter logExporter = new CompletableLogExporter();
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider sdkLoggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(logExporter)
.setMaxQueueSize(6)
@ -141,12 +141,12 @@ class BatchLogProcessorTest {
.build())
.build();
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
logExporter.succeed();
@ -171,17 +171,17 @@ class BatchLogProcessorTest {
.setScheduleDelay(10, TimeUnit.SECONDS)
.build();
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder().addLogProcessor(batchLogProcessor).build();
SdkLoggerProvider sdkLoggerProvider =
SdkLoggerProvider.builder().addLogProcessor(batchLogProcessor).build();
for (int i = 0; i < 50; i++) {
emitLog(sdkLogEmitterProvider, "notExported");
emitLog(sdkLoggerProvider, "notExported");
}
List<LogData> exported = waitingLogExporter.waitForExport();
assertThat(exported).isNotNull();
assertThat(exported.size()).isEqualTo(49);
for (int i = 0; i < 50; i++) {
emitLog(sdkLogEmitterProvider, "notExported");
emitLog(sdkLoggerProvider, "notExported");
}
exported = waitingLogExporter.waitForExport();
assertThat(exported).isNotNull();
@ -199,8 +199,8 @@ class BatchLogProcessorTest {
new WaitingLogExporter(2, CompletableResultCode.ofSuccess());
WaitingLogExporter waitingLogExporter2 =
new WaitingLogExporter(2, CompletableResultCode.ofSuccess());
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider sdkLoggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(
LogExporter.composite(
@ -209,8 +209,8 @@ class BatchLogProcessorTest {
.build())
.build();
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_2);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_2);
List<LogData> exported1 = waitingLogExporter1.waitForExport();
List<LogData> exported2 = waitingLogExporter2.waitForExport();
assertThat(exported1)
@ -231,8 +231,8 @@ class BatchLogProcessorTest {
BlockingLogExporter blockingLogExporter = new BlockingLogExporter();
WaitingLogExporter waitingLogExporter =
new WaitingLogExporter(maxQueuedLogs, CompletableResultCode.ofSuccess());
SdkLogEmitterProvider sdkTracerProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider sdkTracerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(
LogExporter.composite(
@ -297,8 +297,8 @@ class BatchLogProcessorTest {
doThrow(new IllegalArgumentException("No export for you."))
.when(mockLogExporter)
.export(anyList());
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider sdkLoggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(
LogExporter.composite(Arrays.asList(mockLogExporter, waitingLogExporter)))
@ -306,12 +306,12 @@ class BatchLogProcessorTest {
.build())
.build();
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
List<LogData> exported = waitingLogExporter.waitForExport();
assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_1));
waitingLogExporter.reset();
// Continue to export after the exception was received.
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_2);
emitLog(sdkLoggerProvider, LOG_MESSAGE_2);
exported = waitingLogExporter.waitForExport();
assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_2));
}
@ -326,8 +326,7 @@ class BatchLogProcessorTest {
.setScheduleDelay(1, TimeUnit.MILLISECONDS)
.setMaxQueueSize(1)
.build();
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder().addLogProcessor(blp).build();
SdkLoggerProvider sdkLoggerProvider = SdkLoggerProvider.builder().addLogProcessor(blp).build();
CountDownLatch exported = new CountDownLatch(1);
// We return a result we never complete, meaning it will timeout.
@ -340,7 +339,7 @@ class BatchLogProcessorTest {
return true;
})))
.thenReturn(new CompletableResultCode());
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_1);
emitLog(sdkLoggerProvider, LOG_MESSAGE_1);
exported.await();
// Timed out so the log was dropped.
await().untilAsserted(() -> assertThat(blp.getBatch()).isEmpty());
@ -358,7 +357,7 @@ class BatchLogProcessorTest {
return true;
})))
.thenReturn(CompletableResultCode.ofSuccess());
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_2);
emitLog(sdkLoggerProvider, LOG_MESSAGE_2);
exported.await();
await().untilAsserted(() -> assertThat(blp.getBatch()).isEmpty());
}
@ -370,22 +369,21 @@ class BatchLogProcessorTest {
new WaitingLogExporter(1, CompletableResultCode.ofSuccess());
// Set the export delay to large value, in order to confirm the #flush() below works
SdkLogEmitterProvider sdkLogEmitterProvider =
SdkLogEmitterProvider.builder()
SdkLoggerProvider sdkLoggerProvider =
SdkLoggerProvider.builder()
.addLogProcessor(
BatchLogProcessor.builder(waitingLogExporter)
.setScheduleDelay(10, TimeUnit.SECONDS)
.build())
.build();
emitLog(sdkLogEmitterProvider, LOG_MESSAGE_2);
emitLog(sdkLoggerProvider, LOG_MESSAGE_2);
// Force a shutdown, which forces processing of all remaining logs.
sdkLogEmitterProvider.shutdown().join(10, TimeUnit.SECONDS);
sdkLoggerProvider.shutdown().join(10, TimeUnit.SECONDS);
List<LogData> exported = waitingLogExporter.getExported();
assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_2));
;
assertThat(waitingLogExporter.shutDownCalled.get()).isTrue();
}

38
sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporterTest.java
View File

@ -8,8 +8,8 @@ package io.opentelemetry.sdk.logs.export;
import static io.opentelemetry.sdk.logs.data.Severity.DEBUG;
import static org.assertj.core.api.Assertions.assertThat;
import io.opentelemetry.sdk.logs.LogEmitter;
import io.opentelemetry.sdk.logs.SdkLogEmitterProvider;
import io.opentelemetry.sdk.logs.Logger;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.data.LogData;
import io.opentelemetry.sdk.testing.assertj.LogAssertions;
import io.opentelemetry.sdk.testing.logs.TestLogData;
@ -23,28 +23,26 @@ import org.junit.jupiter.api.Test;
class InMemoryLogExporterTest {
private final InMemoryLogExporter exporter = InMemoryLogExporter.create();
private SdkLogEmitterProvider logEmitterProvider;
private LogEmitter logEmitter;
private SdkLoggerProvider loggerProvider;
private Logger logger;
@BeforeEach
void setup() {
logEmitterProvider =
SdkLogEmitterProvider.builder()
.addLogProcessor(SimpleLogProcessor.create(exporter))
.build();
logEmitter = logEmitterProvider.logEmitterBuilder("emitter").build();
loggerProvider =
SdkLoggerProvider.builder().addLogProcessor(SimpleLogProcessor.create(exporter)).build();
logger = loggerProvider.loggerBuilder("logger").build();
}
@AfterEach
void tearDown() {
logEmitterProvider.shutdown();
loggerProvider.shutdown();
}
@Test
void getFinishedLogItems() {
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
List<LogData> logItems = exporter.getFinishedLogItems();
assertThat(logItems).isNotNull();
@ -56,9 +54,9 @@ class InMemoryLogExporterTest {
@Test
void reset() {
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
List<LogData> logItems = exporter.getFinishedLogItems();
assertThat(logItems).isNotNull();
assertThat(logItems.size()).isEqualTo(3);
@ -69,9 +67,9 @@ class InMemoryLogExporterTest {
@Test
void shutdown() {
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 2").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 3").emit();
List<LogData> logItems = exporter.getFinishedLogItems();
assertThat(logItems).isNotNull();
assertThat(logItems.size()).isEqualTo(3);
@ -79,7 +77,7 @@ class InMemoryLogExporterTest {
exporter.shutdown();
assertThat(exporter.getFinishedLogItems()).isEmpty();
// Cannot add new elements after the shutdown.
logEmitter.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
logger.logRecordBuilder().setSeverity(DEBUG).setBody("message 1").emit();
assertThat(exporter.getFinishedLogItems()).isEmpty();
}