diff --git a/buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts b/buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts index 23c455e3cd..ab182cb40d 100644 --- a/buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts +++ b/buildSrc/src/main/kotlin/otel.japicmp-conventions.gradle.kts @@ -1,7 +1,9 @@ import com.google.auto.value.AutoValue import japicmp.model.JApiChangeStatus +import japicmp.model.JApiClass import japicmp.model.JApiCompatibility import japicmp.model.JApiCompatibilityChange +import japicmp.model.JApiConstructor import japicmp.model.JApiMethod import me.champeau.gradle.japicmp.JapicmpTask import me.champeau.gradle.japicmp.report.Severity @@ -38,7 +40,7 @@ class AllowDefaultMethodRule : AbstractRecordingSeenMembers() { if (isAbstractMethodOnAutoValue(member, change)) { continue } - if (isLogEmitterProvider(member)) { + if (isLogRename(member)) { continue } if (!change.isSourceCompatible) { @@ -64,13 +66,29 @@ class AllowDefaultMethodRule : AbstractRecordingSeenMembers() { } /** - * Check if the change is related to LogEmitterProvider name change to LoggerProvider. + * Check if the change is related to log related renames. */ // TODO(jack-berg): remove after 1.19.0. - fun isLogEmitterProvider(member: JApiCompatibility): Boolean { + fun isLogRename(member: JApiCompatibility): Boolean { try { - return member is JApiMethod && - member.oldMethod.get().methodInfo.name.matches("(getSdk|set|add)LogEmitterProvider(.*)".toRegex()) + if (member is JApiMethod) { + val longName = member.oldMethod.get().longName + return longName.matches(".*OpenTelemetrySdk\\.getSdkLogEmitterProvider.*".toRegex()) || + longName.matches(".*OpenTelemetrySdkBuilder\\.setLogEmitterProvider.*".toRegex()) || + longName.matches(".*AutoConfigurationCustomizer\\.addLogExporterCustomizer.*".toRegex()) || + longName.matches(".*AutoConfigurationCustomizer\\.addLogEmitterProviderCustomizer.*".toRegex()) || + longName.matches(".*ConfigurableLogExporterProvider.*".toRegex()) || + longName.matches(".*SystemOutLogExporter.*".toRegex()) || + longName.matches(".*OtlpJsonLoggingLogExporter.*".toRegex()) + } else if (member is JApiClass) { + val fqcn = member.fullyQualifiedName + return fqcn.matches(".*SystemOutLogExporter".toRegex()) || + fqcn.matches(".*ConfigurableLogExporterProvider".toRegex()) || + fqcn.matches(".*OtlpJsonLoggingLogExporter".toRegex()) + } else if (member is JApiConstructor) { + return member.oldConstructor.get().longName.matches(".*SystemOutLogExporter.*".toRegex()) + } + return false } catch (e: IllegalStateException) { return false } diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt index df26146497..cfe9a9bbcc 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt @@ -1,2 +1,15 @@ Comparing source compatibility of against -No changes. \ No newline at end of file +---! REMOVED CLASS: PUBLIC(-) FINAL(-) io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogExporter (not serializable) + --- CLASS FILE FORMAT VERSION: n.a. <- 52.0 + ---! REMOVED SUPERCLASS: java.lang.Object + ---! REMOVED METHOD: PUBLIC(-) STATIC(-) io.opentelemetry.sdk.logs.export.LogExporter create() + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode export(java.util.Collection) + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode flush() + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode shutdown() ++++ NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter (not serializable) + +++ CLASS FILE FORMAT VERSION: 52.0 <- n.a. + +++ NEW SUPERCLASS: java.lang.Object + +++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.export.LogRecordExporter create() + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode export(java.util.Collection) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode flush() + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown() diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging.txt index df26146497..fca6cfdf2c 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging.txt @@ -1,2 +1,17 @@ Comparing source compatibility of against -No changes. \ No newline at end of file +---! REMOVED CLASS: PUBLIC(-) io.opentelemetry.exporter.logging.SystemOutLogExporter (not serializable) + --- CLASS FILE FORMAT VERSION: n.a. <- 52.0 + ---! REMOVED SUPERCLASS: java.lang.Object + ---! REMOVED CONSTRUCTOR: PUBLIC(-) SystemOutLogExporter() + --- REMOVED ANNOTATION: java.lang.Deprecated + ---! REMOVED METHOD: PUBLIC(-) STATIC(-) io.opentelemetry.exporter.logging.SystemOutLogExporter create() + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode export(java.util.Collection) + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode flush() + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.common.CompletableResultCode shutdown() ++++ NEW CLASS: PUBLIC(+) io.opentelemetry.exporter.logging.SystemOutLogRecordExporter (not serializable) + +++ CLASS FILE FORMAT VERSION: 52.0 <- n.a. + +++ NEW SUPERCLASS: java.lang.Object + +++ NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.exporter.logging.SystemOutLogRecordExporter create() + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode export(java.util.Collection) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode flush() + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.common.CompletableResultCode shutdown() diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-sdk-extension-autoconfigure-spi.txt b/docs/apidiffs/current_vs_latest/opentelemetry-sdk-extension-autoconfigure-spi.txt index cec2039f90..5f013e87ba 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-sdk-extension-autoconfigure-spi.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-sdk-extension-autoconfigure-spi.txt @@ -2,4 +2,16 @@ Comparing source compatibility of against ***! 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) + ---! REMOVED METHOD: PUBLIC(-) io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer addLogExporterCustomizer(java.util.function.BiFunction) +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer addLoggerProviderCustomizer(java.util.function.BiFunction) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer addLogRecordExporterCustomizer(java.util.function.BiFunction) +---! REMOVED INTERFACE: PUBLIC(-) ABSTRACT(-) io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider (not serializable) + --- CLASS FILE FORMAT VERSION: n.a. <- 52.0 + ---! REMOVED SUPERCLASS: java.lang.Object + ---! REMOVED METHOD: PUBLIC(-) ABSTRACT(-) io.opentelemetry.sdk.logs.export.LogExporter createExporter(io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties) + ---! REMOVED METHOD: PUBLIC(-) ABSTRACT(-) java.lang.String getName() ++++ NEW INTERFACE: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider (not serializable) + +++ CLASS FILE FORMAT VERSION: 52.0 <- n.a. + +++ NEW SUPERCLASS: java.lang.Object + +++ NEW METHOD: PUBLIC(+) ABSTRACT(+) io.opentelemetry.sdk.logs.export.LogRecordExporter createExporter(io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties) + +++ NEW METHOD: PUBLIC(+) ABSTRACT(+) java.lang.String getName() diff --git a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporter.java b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporter.java similarity index 69% rename from exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporter.java rename to exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporter.java index 2f13c1a507..a886c77b88 100644 --- a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporter.java +++ b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporter.java @@ -12,26 +12,27 @@ import com.fasterxml.jackson.core.io.SegmentedStringWriter; import io.opentelemetry.exporter.internal.otlp.logs.ResourceLogsMarshaler; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.io.IOException; import java.util.Collection; import java.util.logging.Level; import java.util.logging.Logger; /** - * A {@link LogExporter} which writes {@linkplain LogData logs} to a {@link Logger} in OTLP JSON - * format. Each log line will include a single {@code ResourceLogs}. + * A {@link LogRecordExporter} which writes {@linkplain LogData logs} to a {@link Logger} in OTLP + * JSON format. Each log line will include a single {@code ResourceLogs}. */ -public final class OtlpJsonLoggingLogExporter implements LogExporter { +public final class OtlpJsonLoggingLogRecordExporter implements LogRecordExporter { - private static final Logger logger = Logger.getLogger(OtlpJsonLoggingLogExporter.class.getName()); + private static final Logger logger = + Logger.getLogger(OtlpJsonLoggingLogRecordExporter.class.getName()); - /** Returns a new {@link OtlpJsonLoggingLogExporter}. */ - public static LogExporter create() { - return new OtlpJsonLoggingLogExporter(); + /** Returns a new {@link OtlpJsonLoggingLogRecordExporter}. */ + public static LogRecordExporter create() { + return new OtlpJsonLoggingLogRecordExporter(); } - private OtlpJsonLoggingLogExporter() {} + private OtlpJsonLoggingLogRecordExporter() {} @Override public CompletableResultCode export(Collection logs) { diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporterTest.java similarity index 95% rename from exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporterTest.java rename to exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporterTest.java index 75df9c0f5a..f7fa58e593 100644 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogExporterTest.java +++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingLogRecordExporterTest.java @@ -19,7 +19,7 @@ import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.testing.logs.TestLogData; import java.util.Arrays; @@ -30,8 +30,8 @@ import org.junit.jupiter.api.extension.RegisterExtension; import org.skyscreamer.jsonassert.JSONAssert; import org.slf4j.event.Level; -@SuppressLogger(OtlpJsonLoggingLogExporter.class) -class OtlpJsonLoggingLogExporterTest { +@SuppressLogger(OtlpJsonLoggingLogRecordExporter.class) +class OtlpJsonLoggingLogRecordExporterTest { private static final Resource RESOURCE = Resource.create(Attributes.builder().put("key", "value").build()); @@ -76,13 +76,13 @@ class OtlpJsonLoggingLogExporterTest { .build(); @RegisterExtension - LogCapturer logs = LogCapturer.create().captureForType(OtlpJsonLoggingLogExporter.class); + LogCapturer logs = LogCapturer.create().captureForType(OtlpJsonLoggingLogRecordExporter.class); - LogExporter exporter; + LogRecordExporter exporter; @BeforeEach void setUp() { - exporter = OtlpJsonLoggingLogExporter.create(); + exporter = OtlpJsonLoggingLogRecordExporter.create(); } @Test diff --git a/exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogExporter.java b/exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporter.java similarity index 80% rename from exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogExporter.java rename to exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporter.java index 597cf97bd2..2976fbd1e7 100644 --- a/exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogExporter.java +++ b/exporters/logging/src/main/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporter.java @@ -10,35 +10,29 @@ import static java.util.concurrent.TimeUnit.NANOSECONDS; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.time.Instant; import java.time.ZoneOffset; import java.time.format.DateTimeFormatter; import java.util.Collection; /** - * A {@link LogExporter} implementation that outputs log records to standard out. The output is not - * intended to be comprehensive, but just usable for debugging. + * A {@link LogRecordExporter} implementation that outputs log records to standard out. The output + * is not intended to be comprehensive, but just usable for debugging. * *

Note: this doesn't use a {@code java.util.logging Logger}, as that could result in * logging-loops if an OTel appender is configured for {@code java.util.logging}. */ @SuppressWarnings("SystemOut") -public class SystemOutLogExporter implements LogExporter { +public class SystemOutLogRecordExporter implements LogRecordExporter { private static final DateTimeFormatter ISO_FORMAT = DateTimeFormatter.ISO_DATE_TIME; - /** Returns a new {@link SystemOutLogExporter}. */ - public static SystemOutLogExporter create() { - return new SystemOutLogExporter(); + /** Returns a new {@link SystemOutLogRecordExporter}. */ + public static SystemOutLogRecordExporter create() { + return new SystemOutLogRecordExporter(); } - /** - * Class constructor. - * - * @deprecated Use {@link #create()}. - */ - @Deprecated - public SystemOutLogExporter() {} + private SystemOutLogRecordExporter() {} @Override public CompletableResultCode export(Collection logs) { diff --git a/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogExporterTest.java b/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporterTest.java similarity index 93% rename from exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogExporterTest.java rename to exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporterTest.java index 4df86a61e8..454c997d9d 100644 --- a/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogExporterTest.java +++ b/exporters/logging/src/test/java/io/opentelemetry/exporter/logging/SystemOutLogRecordExporterTest.java @@ -26,11 +26,11 @@ import java.time.ZoneOffset; import java.util.concurrent.TimeUnit; import org.junit.jupiter.api.Test; -class SystemOutLogExporterTest { +class SystemOutLogRecordExporterTest { @Test void returnCodes() { - SystemOutLogExporter exporter = SystemOutLogExporter.create(); + SystemOutLogRecordExporter exporter = SystemOutLogRecordExporter.create(); CompletableResultCode resultCode = exporter.export(singletonList(sampleLog(System.currentTimeMillis()))); assertThat(resultCode).isSameAs(CompletableResultCode.ofSuccess()); @@ -43,7 +43,7 @@ class SystemOutLogExporterTest { LocalDateTime.of(1970, Month.AUGUST, 7, 10, 0).toInstant(ZoneOffset.UTC).toEpochMilli(); LogData log = sampleLog(timestamp); StringBuilder output = new StringBuilder(); - SystemOutLogExporter.formatLog(output, log); + SystemOutLogRecordExporter.formatLog(output, log); assertThat(output.toString()) .isEqualTo( "1970-08-07T10:00:00Z ERROR3 'message' : 00000000000000010000000000000002 0000000000000003 " diff --git a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporter.java b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporter.java similarity index 73% rename from exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporter.java rename to exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporter.java index dd05f5789a..572302e8f9 100644 --- a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporter.java +++ b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporter.java @@ -9,26 +9,26 @@ import io.opentelemetry.exporter.internal.okhttp.OkHttpExporter; import io.opentelemetry.exporter.internal.otlp.logs.LogsRequestMarshaler; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collection; import javax.annotation.concurrent.ThreadSafe; /** Exports logs using OTLP via HTTP, using OpenTelemetry's protobuf model. */ @ThreadSafe -public final class OtlpHttpLogExporter implements LogExporter { +public final class OtlpHttpLogRecordExporter implements LogRecordExporter { private final OkHttpExporter delegate; - OtlpHttpLogExporter(OkHttpExporter delegate) { + OtlpHttpLogRecordExporter(OkHttpExporter delegate) { this.delegate = delegate; } /** - * Returns a new {@link OtlpHttpLogExporter} using the default values. + * Returns a new {@link OtlpHttpLogRecordExporter} using the default values. * - * @return a new {@link OtlpHttpLogExporter} instance. + * @return a new {@link OtlpHttpLogRecordExporter} instance. */ - public static OtlpHttpLogExporter getDefault() { + public static OtlpHttpLogRecordExporter getDefault() { return builder().build(); } @@ -37,8 +37,8 @@ public final class OtlpHttpLogExporter implements LogExporter { * * @return a new builder instance for this exporter. */ - public static OtlpHttpLogExporterBuilder builder() { - return new OtlpHttpLogExporterBuilder(); + public static OtlpHttpLogRecordExporterBuilder builder() { + return new OtlpHttpLogRecordExporterBuilder(); } /** diff --git a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterBuilder.java b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java similarity index 77% rename from exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterBuilder.java rename to exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java index dd7ea15ba9..3f540464df 100644 --- a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterBuilder.java +++ b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java @@ -14,14 +14,14 @@ import io.opentelemetry.exporter.internal.otlp.logs.LogsRequestMarshaler; import java.time.Duration; import java.util.concurrent.TimeUnit; -/** Builder utility for {@link OtlpHttpLogExporter}. */ -public final class OtlpHttpLogExporterBuilder { +/** Builder utility for {@link OtlpHttpLogRecordExporter}. */ +public final class OtlpHttpLogRecordExporterBuilder { private static final String DEFAULT_ENDPOINT = "http://localhost:4318/v1/logs"; private final OkHttpExporterBuilder delegate; - OtlpHttpLogExporterBuilder() { + OtlpHttpLogRecordExporterBuilder() { delegate = new OkHttpExporterBuilder<>("otlp", "log", DEFAULT_ENDPOINT); } @@ -29,7 +29,7 @@ public final class OtlpHttpLogExporterBuilder { * Sets the maximum time to wait for the collector to process an exported batch of logs. If unset, * defaults to {@value OkHttpExporterBuilder#DEFAULT_TIMEOUT_SECS}s. */ - public OtlpHttpLogExporterBuilder setTimeout(long timeout, TimeUnit unit) { + public OtlpHttpLogRecordExporterBuilder setTimeout(long timeout, TimeUnit unit) { requireNonNull(unit, "unit"); checkArgument(timeout >= 0, "timeout must be non-negative"); delegate.setTimeout(timeout, unit); @@ -40,7 +40,7 @@ public final class OtlpHttpLogExporterBuilder { * Sets the maximum time to wait for the collector to process an exported batch of logs. If unset, * defaults to {@value OkHttpExporterBuilder#DEFAULT_TIMEOUT_SECS}s. */ - public OtlpHttpLogExporterBuilder setTimeout(Duration timeout) { + public OtlpHttpLogRecordExporterBuilder setTimeout(Duration timeout) { requireNonNull(timeout, "timeout"); return setTimeout(timeout.toNanos(), TimeUnit.NANOSECONDS); } @@ -49,7 +49,7 @@ public final class OtlpHttpLogExporterBuilder { * Sets the OTLP endpoint to connect to. If unset, defaults to {@value DEFAULT_ENDPOINT}. The * endpoint must start with either http:// or https://, and include the full HTTP path. */ - public OtlpHttpLogExporterBuilder setEndpoint(String endpoint) { + public OtlpHttpLogRecordExporterBuilder setEndpoint(String endpoint) { requireNonNull(endpoint, "endpoint"); delegate.setEndpoint(endpoint); return this; @@ -59,7 +59,7 @@ public final class OtlpHttpLogExporterBuilder { * Sets the method used to compress payloads. If unset, compression is disabled. Currently * supported compression methods include "gzip" and "none". */ - public OtlpHttpLogExporterBuilder setCompression(String compressionMethod) { + public OtlpHttpLogRecordExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); checkArgument( compressionMethod.equals("gzip") || compressionMethod.equals("none"), @@ -69,7 +69,7 @@ public final class OtlpHttpLogExporterBuilder { } /** Add header to requests. */ - public OtlpHttpLogExporterBuilder addHeader(String key, String value) { + public OtlpHttpLogRecordExporterBuilder addHeader(String key, String value) { delegate.addHeader(key, value); return this; } @@ -79,7 +79,7 @@ public final class OtlpHttpLogExporterBuilder { * should contain an X.509 certificate collection in PEM format. If not set, TLS connections will * use the system default trusted certificates. */ - public OtlpHttpLogExporterBuilder setTrustedCertificates(byte[] trustedCertificatesPem) { + public OtlpHttpLogRecordExporterBuilder setTrustedCertificates(byte[] trustedCertificatesPem) { delegate.setTrustedCertificates(trustedCertificatesPem); return this; } @@ -88,7 +88,8 @@ public final class OtlpHttpLogExporterBuilder { * Sets ths client key and the certificate chain to use for verifying client when TLS is enabled. * The key must be PKCS8, and both must be in PEM format. */ - public OtlpHttpLogExporterBuilder setClientTls(byte[] privateKeyPem, byte[] certificatePem) { + public OtlpHttpLogRecordExporterBuilder setClientTls( + byte[] privateKeyPem, byte[] certificatePem) { delegate.setClientTls(privateKeyPem, certificatePem); return this; } @@ -97,7 +98,7 @@ public final class OtlpHttpLogExporterBuilder { * Sets the {@link MeterProvider} to use to collect metrics related to export. If not set, metrics * will not be collected. */ - public OtlpHttpLogExporterBuilder setMeterProvider(MeterProvider meterProvider) { + public OtlpHttpLogRecordExporterBuilder setMeterProvider(MeterProvider meterProvider) { requireNonNull(meterProvider, "meterProvider"); delegate.setMeterProvider(meterProvider); return this; @@ -108,7 +109,7 @@ public final class OtlpHttpLogExporterBuilder { * * @return a new exporter's instance */ - public OtlpHttpLogExporter build() { - return new OtlpHttpLogExporter(delegate.build()); + public OtlpHttpLogRecordExporter build() { + return new OtlpHttpLogRecordExporter(delegate.build()); } } diff --git a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporter.java b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporter.java similarity index 68% rename from exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporter.java rename to exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporter.java index 089bdb80c2..e22d26fec2 100644 --- a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporter.java +++ b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporter.java @@ -9,24 +9,24 @@ import io.opentelemetry.exporter.internal.grpc.GrpcExporter; import io.opentelemetry.exporter.internal.otlp.logs.LogsRequestMarshaler; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collection; import javax.annotation.concurrent.ThreadSafe; /** Exports logs using OTLP via gRPC, using OpenTelemetry's protobuf model. */ @ThreadSafe -public final class OtlpGrpcLogExporter implements LogExporter { +public final class OtlpGrpcLogRecordExporter implements LogRecordExporter { private final GrpcExporter delegate; /** - * Returns a new {@link OtlpGrpcLogExporter} reading the configuration values from the environment - * and from system properties. System properties override values defined in the environment. If a - * configuration value is missing, it uses the default value. + * Returns a new {@link OtlpGrpcLogRecordExporter} reading the configuration values from the + * environment and from system properties. System properties override values defined in the + * environment. If a configuration value is missing, it uses the default value. * - * @return a new {@link OtlpGrpcLogExporter} instance. + * @return a new {@link OtlpGrpcLogRecordExporter} instance. */ - public static OtlpGrpcLogExporter getDefault() { + public static OtlpGrpcLogRecordExporter getDefault() { return builder().build(); } @@ -35,11 +35,11 @@ public final class OtlpGrpcLogExporter implements LogExporter { * * @return a new builder instance for this exporter. */ - public static OtlpGrpcLogExporterBuilder builder() { - return new OtlpGrpcLogExporterBuilder(); + public static OtlpGrpcLogRecordExporterBuilder builder() { + return new OtlpGrpcLogRecordExporterBuilder(); } - OtlpGrpcLogExporter(GrpcExporter delegate) { + OtlpGrpcLogRecordExporter(GrpcExporter delegate) { this.delegate = delegate; } diff --git a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterBuilder.java b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java similarity index 79% rename from exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterBuilder.java rename to exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java index 7c115254b7..b9622be35d 100644 --- a/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterBuilder.java +++ b/exporters/otlp/logs/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java @@ -17,8 +17,8 @@ import java.net.URI; import java.time.Duration; import java.util.concurrent.TimeUnit; -/** Builder for {@link OtlpGrpcLogExporter}. */ -public final class OtlpGrpcLogExporterBuilder { +/** Builder for {@link OtlpGrpcLogRecordExporter}. */ +public final class OtlpGrpcLogRecordExporterBuilder { private static final String GRPC_SERVICE_NAME = "opentelemetry.proto.collector.logs.v1.LogsService"; @@ -32,7 +32,7 @@ public final class OtlpGrpcLogExporterBuilder { // Visible for testing final GrpcExporterBuilder delegate; - OtlpGrpcLogExporterBuilder() { + OtlpGrpcLogRecordExporterBuilder() { delegate = GrpcExporter.builder( "otlp", @@ -53,7 +53,7 @@ public final class OtlpGrpcLogExporterBuilder { * methods on this builder, please file an issue to let us know what it is. */ @Deprecated - public OtlpGrpcLogExporterBuilder setChannel(ManagedChannel channel) { + public OtlpGrpcLogRecordExporterBuilder setChannel(ManagedChannel channel) { delegate.setChannel(channel); return this; } @@ -62,7 +62,7 @@ public final class OtlpGrpcLogExporterBuilder { * Sets the maximum time to wait for the collector to process an exported batch of logs. If unset, * defaults to {@value DEFAULT_TIMEOUT_SECS}s. */ - public OtlpGrpcLogExporterBuilder setTimeout(long timeout, TimeUnit unit) { + public OtlpGrpcLogRecordExporterBuilder setTimeout(long timeout, TimeUnit unit) { requireNonNull(unit, "unit"); checkArgument(timeout >= 0, "timeout must be non-negative"); delegate.setTimeout(timeout, unit); @@ -73,7 +73,7 @@ public final class OtlpGrpcLogExporterBuilder { * Sets the maximum time to wait for the collector to process an exported batch of logs. If unset, * defaults to {@value DEFAULT_TIMEOUT_SECS}s. */ - public OtlpGrpcLogExporterBuilder setTimeout(Duration timeout) { + public OtlpGrpcLogRecordExporterBuilder setTimeout(Duration timeout) { requireNonNull(timeout, "timeout"); delegate.setTimeout(timeout); return this; @@ -83,7 +83,7 @@ public final class OtlpGrpcLogExporterBuilder { * Sets the OTLP endpoint to connect to. If unset, defaults to {@value DEFAULT_ENDPOINT_URL}. The * endpoint must start with either http:// or https://. */ - public OtlpGrpcLogExporterBuilder setEndpoint(String endpoint) { + public OtlpGrpcLogRecordExporterBuilder setEndpoint(String endpoint) { requireNonNull(endpoint, "endpoint"); delegate.setEndpoint(endpoint); return this; @@ -93,7 +93,7 @@ public final class OtlpGrpcLogExporterBuilder { * Sets the method used to compress payloads. If unset, compression is disabled. Currently * supported compression methods include "gzip" and "none". */ - public OtlpGrpcLogExporterBuilder setCompression(String compressionMethod) { + public OtlpGrpcLogRecordExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); checkArgument( compressionMethod.equals("gzip") || compressionMethod.equals("none"), @@ -107,7 +107,7 @@ public final class OtlpGrpcLogExporterBuilder { * should contain an X.509 certificate collection in PEM format. If not set, TLS connections will * use the system default trusted certificates. */ - public OtlpGrpcLogExporterBuilder setTrustedCertificates(byte[] trustedCertificatesPem) { + public OtlpGrpcLogRecordExporterBuilder setTrustedCertificates(byte[] trustedCertificatesPem) { delegate.setTrustedCertificates(trustedCertificatesPem); return this; } @@ -116,20 +116,21 @@ public final class OtlpGrpcLogExporterBuilder { * Sets ths client key and the certificate chain to use for verifying client when TLS is enabled. * The key must be PKCS8, and both must be in PEM format. */ - public OtlpGrpcLogExporterBuilder setClientTls(byte[] privateKeyPem, byte[] certificatePem) { + public OtlpGrpcLogRecordExporterBuilder setClientTls( + byte[] privateKeyPem, byte[] certificatePem) { delegate.setClientTls(privateKeyPem, certificatePem); return this; } /** * Add header to request. Optional. Applicable only if {@link - * OtlpGrpcLogExporterBuilder#setChannel(ManagedChannel)} is not used to set channel. + * OtlpGrpcLogRecordExporterBuilder#setChannel(ManagedChannel)} is not used to set channel. * * @param key header key * @param value header value * @return this builder's instance */ - public OtlpGrpcLogExporterBuilder addHeader(String key, String value) { + public OtlpGrpcLogRecordExporterBuilder addHeader(String key, String value) { delegate.addHeader(key, value); return this; } @@ -138,7 +139,7 @@ public final class OtlpGrpcLogExporterBuilder { * Sets the {@link MeterProvider} to use to collect metrics related to export. If not set, metrics * will not be collected. */ - public OtlpGrpcLogExporterBuilder setMeterProvider(MeterProvider meterProvider) { + public OtlpGrpcLogRecordExporterBuilder setMeterProvider(MeterProvider meterProvider) { requireNonNull(meterProvider, "meterProvider"); delegate.setMeterProvider(meterProvider); return this; @@ -149,7 +150,7 @@ public final class OtlpGrpcLogExporterBuilder { * * @return a new exporter's instance */ - public OtlpGrpcLogExporter build() { - return new OtlpGrpcLogExporter(delegate.build()); + public OtlpGrpcLogRecordExporter build() { + return new OtlpGrpcLogRecordExporter(delegate.build()); } } diff --git a/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterTest.java b/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterTest.java similarity index 81% rename from exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterTest.java rename to exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterTest.java index 924d7c704b..846baee5c2 100644 --- a/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogExporterTest.java +++ b/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterTest.java @@ -58,7 +58,7 @@ import org.junit.jupiter.api.extension.RegisterExtension; import org.slf4j.event.Level; import org.slf4j.event.LoggingEvent; -class OtlpHttpLogExporterTest { +class OtlpHttpLogRecordExporterTest { private static final MediaType APPLICATION_PROTOBUF = MediaType.create("application", "x-protobuf"); @@ -91,12 +91,12 @@ class OtlpHttpLogExporterTest { @RegisterExtension LogCapturer logs = LogCapturer.create().captureForType(OkHttpExporter.class); - private OtlpHttpLogExporterBuilder builder; + private OtlpHttpLogRecordExporterBuilder builder; @BeforeEach void setup() { builder = - OtlpHttpLogExporter.builder() + OtlpHttpLogRecordExporter.builder() .setEndpoint("http://" + canonicalHostName + ":" + server.httpPort() + "/v1/logs") .addHeader("foo", "bar"); } @@ -104,49 +104,54 @@ class OtlpHttpLogExporterTest { @Test @SuppressWarnings("PreferJavaTimeOverload") void validConfig() { - assertThatCode(() -> OtlpHttpLogExporter.builder().setTimeout(0, TimeUnit.MILLISECONDS)) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setTimeout(0, TimeUnit.MILLISECONDS)) .doesNotThrowAnyException(); - assertThatCode(() -> OtlpHttpLogExporter.builder().setTimeout(Duration.ofMillis(0))) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setTimeout(Duration.ofMillis(0))) .doesNotThrowAnyException(); - assertThatCode(() -> OtlpHttpLogExporter.builder().setTimeout(10, TimeUnit.MILLISECONDS)) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setTimeout(10, TimeUnit.MILLISECONDS)) .doesNotThrowAnyException(); - assertThatCode(() -> OtlpHttpLogExporter.builder().setTimeout(Duration.ofMillis(10))) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setTimeout(Duration.ofMillis(10))) .doesNotThrowAnyException(); assertThatCode( () -> - OtlpHttpLogExporter.builder().setEndpoint("http://" + canonicalHostName + ":4317")) - .doesNotThrowAnyException(); - assertThatCode( - () -> OtlpHttpLogExporter.builder().setEndpoint("http://" + canonicalHostName + "")) - .doesNotThrowAnyException(); - assertThatCode( - () -> OtlpHttpLogExporter.builder().setEndpoint("https://" + canonicalHostName + "")) + OtlpHttpLogRecordExporter.builder() + .setEndpoint("http://" + canonicalHostName + ":4317")) .doesNotThrowAnyException(); assertThatCode( () -> - OtlpHttpLogExporter.builder() + OtlpHttpLogRecordExporter.builder().setEndpoint("http://" + canonicalHostName + "")) + .doesNotThrowAnyException(); + assertThatCode( + () -> + OtlpHttpLogRecordExporter.builder() + .setEndpoint("https://" + canonicalHostName + "")) + .doesNotThrowAnyException(); + assertThatCode( + () -> + OtlpHttpLogRecordExporter.builder() .setEndpoint("http://foo:bar@" + canonicalHostName + "")) .doesNotThrowAnyException(); - assertThatCode(() -> OtlpHttpLogExporter.builder().setCompression("gzip")) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setCompression("gzip")) .doesNotThrowAnyException(); - assertThatCode(() -> OtlpHttpLogExporter.builder().setCompression("none")) - .doesNotThrowAnyException(); - - assertThatCode( - () -> OtlpHttpLogExporter.builder().addHeader("foo", "bar").addHeader("baz", "qux")) + assertThatCode(() -> OtlpHttpLogRecordExporter.builder().setCompression("none")) .doesNotThrowAnyException(); assertThatCode( () -> - OtlpHttpLogExporter.builder() + OtlpHttpLogRecordExporter.builder().addHeader("foo", "bar").addHeader("baz", "qux")) + .doesNotThrowAnyException(); + + assertThatCode( + () -> + OtlpHttpLogRecordExporter.builder() .setTrustedCertificates("foobar".getBytes(StandardCharsets.UTF_8))) .doesNotThrowAnyException(); assertThatCode( () -> - OtlpHttpLogExporter.builder() + OtlpHttpLogRecordExporter.builder() .setClientTls( "foobar".getBytes(StandardCharsets.UTF_8), "foobar".getBytes(StandardCharsets.UTF_8))) @@ -156,39 +161,43 @@ class OtlpHttpLogExporterTest { @Test @SuppressWarnings("PreferJavaTimeOverload") void invalidConfig() { - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setTimeout(-1, TimeUnit.MILLISECONDS)) + assertThatThrownBy( + () -> OtlpHttpLogRecordExporter.builder().setTimeout(-1, TimeUnit.MILLISECONDS)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("timeout must be non-negative"); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setTimeout(1, null)) + assertThatThrownBy(() -> OtlpHttpLogRecordExporter.builder().setTimeout(1, null)) .isInstanceOf(NullPointerException.class) .hasMessage("unit"); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setTimeout(null)) + assertThatThrownBy(() -> OtlpHttpLogRecordExporter.builder().setTimeout(null)) .isInstanceOf(NullPointerException.class) .hasMessage("timeout"); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setEndpoint(null)) + assertThatThrownBy(() -> OtlpHttpLogRecordExporter.builder().setEndpoint(null)) .isInstanceOf(NullPointerException.class) .hasMessage("endpoint"); assertThatThrownBy( - () -> OtlpHttpLogExporter.builder().setEndpoint("😺://" + canonicalHostName + "")) + () -> OtlpHttpLogRecordExporter.builder().setEndpoint("😺://" + canonicalHostName + "")) .isInstanceOf(IllegalArgumentException.class) .hasMessage("Invalid endpoint, must be a URL: 😺://" + canonicalHostName + ""); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setEndpoint("" + canonicalHostName + "")) + assertThatThrownBy( + () -> OtlpHttpLogRecordExporter.builder().setEndpoint("" + canonicalHostName + "")) .isInstanceOf(IllegalArgumentException.class) .hasMessage( "Invalid endpoint, must start with http:// or https://: " + canonicalHostName + ""); assertThatThrownBy( - () -> OtlpHttpLogExporter.builder().setEndpoint("gopher://" + canonicalHostName + "")) + () -> + OtlpHttpLogRecordExporter.builder() + .setEndpoint("gopher://" + canonicalHostName + "")) .isInstanceOf(IllegalArgumentException.class) .hasMessage( "Invalid endpoint, must start with http:// or https://: gopher://" + canonicalHostName + ""); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setCompression(null)) + assertThatThrownBy(() -> OtlpHttpLogRecordExporter.builder().setCompression(null)) .isInstanceOf(NullPointerException.class) .hasMessage("compressionMethod"); - assertThatThrownBy(() -> OtlpHttpLogExporter.builder().setCompression("foo")) + assertThatThrownBy(() -> OtlpHttpLogRecordExporter.builder().setCompression("foo")) .isInstanceOf(IllegalArgumentException.class) .hasMessage( "Unsupported compression method. Supported compression methods include: gzip, none."); @@ -199,14 +208,14 @@ class OtlpHttpLogExporterTest { assertThatCode( () -> RetryUtil.setRetryPolicyOnDelegate( - OtlpHttpLogExporter.builder(), RetryPolicy.getDefault())) + OtlpHttpLogRecordExporter.builder(), RetryPolicy.getDefault())) .doesNotThrowAnyException(); } @Test void testExportUncompressed() { server.enqueue(successResponse()); - OtlpHttpLogExporter exporter = builder.build(); + OtlpHttpLogRecordExporter exporter = builder.build(); ExportLogsServiceRequest payload = exportAndAssertResult(exporter, /* expectedResult= */ true); RecordedRequest recorded = server.takeRequest(); @@ -221,7 +230,7 @@ class OtlpHttpLogExporterTest { @Test void testExportTls() { server.enqueue(successResponse()); - OtlpHttpLogExporter exporter = + OtlpHttpLogRecordExporter exporter = builder .setEndpoint("https://" + canonicalHostName + ":" + server.httpsPort() + "/v1/logs") .setTrustedCertificates( @@ -241,7 +250,7 @@ class OtlpHttpLogExporterTest { @Test void testExportGzipCompressed() { server.enqueue(successResponse()); - OtlpHttpLogExporter exporter = builder.setCompression("gzip").build(); + OtlpHttpLogRecordExporter exporter = builder.setCompression("gzip").build(); ExportLogsServiceRequest payload = exportAndAssertResult(exporter, /* expectedResult= */ true); AggregatedHttpRequest request = server.takeRequest().request(); @@ -283,7 +292,7 @@ class OtlpHttpLogExporterTest { buildResponse( HttpStatus.INTERNAL_SERVER_ERROR, Status.newBuilder().setMessage("Server error!").build())); - OtlpHttpLogExporter exporter = builder.build(); + OtlpHttpLogRecordExporter exporter = builder.build(); exportAndAssertResult(exporter, /* expectedResult= */ false); LoggingEvent log = @@ -297,7 +306,7 @@ class OtlpHttpLogExporterTest { void testServerErrorParseError() { server.enqueue( HttpResponse.of(HttpStatus.INTERNAL_SERVER_ERROR, APPLICATION_PROTOBUF, "Server error!")); - OtlpHttpLogExporter exporter = builder.build(); + OtlpHttpLogRecordExporter exporter = builder.build(); exportAndAssertResult(exporter, /* expectedResult= */ false); LoggingEvent log = @@ -307,9 +316,9 @@ class OtlpHttpLogExporterTest { } private static ExportLogsServiceRequest exportAndAssertResult( - OtlpHttpLogExporter otlpHttpLogExporter, boolean expectedResult) { + OtlpHttpLogRecordExporter otlpHttpLogRecordExporter, boolean expectedResult) { List logs = Collections.singletonList(generateFakeLog()); - CompletableResultCode resultCode = otlpHttpLogExporter.export(logs); + CompletableResultCode resultCode = otlpHttpLogRecordExporter.export(logs); resultCode.join(10, TimeUnit.SECONDS); assertThat(resultCode.isSuccess()).isEqualTo(expectedResult); List resourceLogs = diff --git a/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterTest.java b/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterTest.java similarity index 86% rename from exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterTest.java rename to exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterTest.java index 6138584ec8..0db0a45039 100644 --- a/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogExporterTest.java +++ b/exporters/otlp/logs/src/test/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterTest.java @@ -27,9 +27,10 @@ import java.time.Instant; import java.util.List; import org.junit.jupiter.api.Test; -class OtlpGrpcLogExporterTest extends AbstractGrpcTelemetryExporterTest { +class OtlpGrpcLogRecordExporterTest + extends AbstractGrpcTelemetryExporterTest { - OtlpGrpcLogExporterTest() { + OtlpGrpcLogRecordExporterTest() { super("log", ResourceLogs.getDefaultInstance()); } @@ -38,20 +39,20 @@ class OtlpGrpcLogExporterTest extends AbstractGrpcTelemetryExporterTest RetryUtil.setRetryPolicyOnDelegate( - OtlpGrpcLogExporter.builder(), RetryPolicy.getDefault())) + OtlpGrpcLogRecordExporter.builder(), RetryPolicy.getDefault())) .doesNotThrowAnyException(); } @Test void usingOkHttp() throws Exception { - try (Closeable exporter = OtlpGrpcLogExporter.builder().build()) { + try (Closeable exporter = OtlpGrpcLogRecordExporter.builder().build()) { assertThat(exporter).extracting("delegate").isInstanceOf(OkHttpGrpcExporter.class); } } @Override protected TelemetryExporterBuilder exporterBuilder() { - return TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder()); + return TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder()); } @Override diff --git a/exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogExporterTest.java b/exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogRecordExporterTest.java similarity index 90% rename from exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogExporterTest.java rename to exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogRecordExporterTest.java index 3683d80848..510710edb3 100644 --- a/exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogExporterTest.java +++ b/exporters/otlp/logs/src/testGrpcNetty/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyLogRecordExporterTest.java @@ -29,10 +29,10 @@ import java.time.Instant; import java.util.List; import org.junit.jupiter.api.Test; -class OtlpGrpcNettyLogExporterTest +class OtlpGrpcNettyLogRecordExporterTest extends AbstractGrpcTelemetryExporterTest { - OtlpGrpcNettyLogExporterTest() { + OtlpGrpcNettyLogRecordExporterTest() { super("log", ResourceLogs.getDefaultInstance()); } @@ -41,7 +41,7 @@ class OtlpGrpcNettyLogExporterTest assertThatCode( () -> RetryUtil.setRetryPolicyOnDelegate( - OtlpGrpcLogExporter.builder(), RetryPolicy.getDefault())) + OtlpGrpcLogRecordExporter.builder(), RetryPolicy.getDefault())) .doesNotThrowAnyException(); } @@ -49,7 +49,7 @@ class OtlpGrpcNettyLogExporterTest @SuppressWarnings("deprecation") // testing deprecated feature void usingGrpc() throws Exception { try (Closeable exporter = - OtlpGrpcLogExporter.builder() + OtlpGrpcLogRecordExporter.builder() .setChannel(InProcessChannelBuilder.forName("test").build()) .build()) { assertThat(exporter).extracting("delegate").isInstanceOf(UpstreamGrpcExporter.class); @@ -59,7 +59,7 @@ class OtlpGrpcNettyLogExporterTest @Override protected TelemetryExporterBuilder exporterBuilder() { return ManagedChannelTelemetryExporterBuilder.wrap( - TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder())); + TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder())); } @Override diff --git a/exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogExporterTest.java b/exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogRecordExporterTest.java similarity index 91% rename from exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogExporterTest.java rename to exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogRecordExporterTest.java index 755bda0790..35c76cd300 100644 --- a/exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogExporterTest.java +++ b/exporters/otlp/logs/src/testGrpcNettyShaded/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyShadedLogRecordExporterTest.java @@ -26,10 +26,10 @@ import java.time.Instant; import java.util.List; import org.junit.jupiter.api.Test; -class OtlpGrpcNettyShadedLogExporterTest +class OtlpGrpcNettyShadedLogRecordExporterTest extends AbstractGrpcTelemetryExporterTest { - OtlpGrpcNettyShadedLogExporterTest() { + OtlpGrpcNettyShadedLogRecordExporterTest() { super("log", ResourceLogs.getDefaultInstance()); } @@ -37,7 +37,7 @@ class OtlpGrpcNettyShadedLogExporterTest @SuppressWarnings("deprecation") // testing deprecated feature void usingGrpc() throws Exception { try (Closeable exporter = - OtlpGrpcLogExporter.builder() + OtlpGrpcLogRecordExporter.builder() .setChannel(InProcessChannelBuilder.forName("test").build()) .build()) { assertThat(exporter).extracting("delegate").isInstanceOf(UpstreamGrpcExporter.class); @@ -47,7 +47,7 @@ class OtlpGrpcNettyShadedLogExporterTest @Override protected TelemetryExporterBuilder exporterBuilder() { return ManagedChannelTelemetryExporterBuilder.wrap( - TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder())); + TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder())); } @Override diff --git a/exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogExporterTest.java b/exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogRecordExporterTest.java similarity index 91% rename from exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogExporterTest.java rename to exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogRecordExporterTest.java index b66753ca4b..06c2da9695 100644 --- a/exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogExporterTest.java +++ b/exporters/otlp/logs/src/testGrpcOkhttp/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcNettyOkHttpLogRecordExporterTest.java @@ -26,10 +26,10 @@ import java.time.Instant; import java.util.List; import org.junit.jupiter.api.Test; -class OtlpGrpcNettyOkHttpLogExporterTest +class OtlpGrpcNettyOkHttpLogRecordExporterTest extends AbstractGrpcTelemetryExporterTest { - OtlpGrpcNettyOkHttpLogExporterTest() { + OtlpGrpcNettyOkHttpLogRecordExporterTest() { super("log", ResourceLogs.getDefaultInstance()); } @@ -37,7 +37,7 @@ class OtlpGrpcNettyOkHttpLogExporterTest @SuppressWarnings("deprecation") // testing deprecated feature void usingGrpc() throws Exception { try (Closeable exporter = - OtlpGrpcLogExporter.builder() + OtlpGrpcLogRecordExporter.builder() .setChannel(InProcessChannelBuilder.forName("test").build()) .build()) { assertThat(exporter).extracting("delegate").isInstanceOf(UpstreamGrpcExporter.class); @@ -47,7 +47,7 @@ class OtlpGrpcNettyOkHttpLogExporterTest @Override protected TelemetryExporterBuilder exporterBuilder() { return ManagedChannelTelemetryExporterBuilder.wrap( - TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder())); + TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder())); } @Override diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogExporterBuilderWrapper.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogRecordExporterBuilderWrapper.java similarity index 86% rename from exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogExporterBuilderWrapper.java rename to exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogRecordExporterBuilderWrapper.java index 46fdc025da..c0cdcb1414 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogExporterBuilderWrapper.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/GrpcLogRecordExporterBuilderWrapper.java @@ -8,15 +8,15 @@ package io.opentelemetry.exporter.otlp.testing.internal; import io.grpc.ManagedChannel; import io.opentelemetry.exporter.internal.retry.RetryPolicy; import io.opentelemetry.exporter.internal.retry.RetryUtil; -import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporterBuilder; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder; import io.opentelemetry.sdk.logs.data.LogData; import java.time.Duration; import java.util.concurrent.TimeUnit; -final class GrpcLogExporterBuilderWrapper implements TelemetryExporterBuilder { - private final OtlpGrpcLogExporterBuilder builder; +final class GrpcLogRecordExporterBuilderWrapper implements TelemetryExporterBuilder { + private final OtlpGrpcLogRecordExporterBuilder builder; - GrpcLogExporterBuilderWrapper(OtlpGrpcLogExporterBuilder builder) { + GrpcLogRecordExporterBuilderWrapper(OtlpGrpcLogRecordExporterBuilder builder) { this.builder = builder; } diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java index 6cca127679..1402819ca7 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java @@ -98,7 +98,7 @@ public final class ManagedChannelTelemetryExporterBuilder @Override public TelemetryExporterBuilder setRetryPolicy(RetryPolicy retryPolicy) { String grpcServiceName; - if (delegate instanceof GrpcLogExporterBuilderWrapper) { + if (delegate instanceof GrpcLogRecordExporterBuilderWrapper) { grpcServiceName = "opentelemetry.proto.collector.logs.v1.LogsService"; } else if (delegate instanceof GrpcMetricExporterBuilderWrapper) { grpcServiceName = "opentelemetry.proto.collector.metrics.v1.MetricsService"; diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java index db6eb1c827..59039c8ff1 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java @@ -7,7 +7,7 @@ package io.opentelemetry.exporter.otlp.testing.internal; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.export.MetricExporter; import io.opentelemetry.sdk.trace.data.SpanData; @@ -46,8 +46,8 @@ public interface TelemetryExporter { }; } - /** Wraps a LogExporter. */ - static TelemetryExporter wrap(LogExporter exporter) { + /** Wraps a LogRecordExporter. */ + static TelemetryExporter wrap(LogRecordExporter exporter) { return new TelemetryExporter() { @Override public CompletableResultCode export(Collection items) { diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporterBuilder.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporterBuilder.java index 2758c0ea7c..d084e53114 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporterBuilder.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporterBuilder.java @@ -7,7 +7,7 @@ package io.opentelemetry.exporter.otlp.testing.internal; import io.grpc.ManagedChannel; import io.opentelemetry.exporter.internal.retry.RetryPolicy; -import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporterBuilder; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder; import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporterBuilder; import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporterBuilder; import io.opentelemetry.sdk.logs.data.LogData; @@ -26,8 +26,8 @@ public interface TelemetryExporterBuilder { return new GrpcMetricExporterBuilderWrapper(builder); } - static TelemetryExporterBuilder wrap(OtlpGrpcLogExporterBuilder builder) { - return new GrpcLogExporterBuilderWrapper(builder); + static TelemetryExporterBuilder wrap(OtlpGrpcLogRecordExporterBuilder builder) { + return new GrpcLogRecordExporterBuilderWrapper(builder); } TelemetryExporterBuilder setEndpoint(String endpoint); diff --git a/integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java b/integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java index 3c91072661..b4b2fbd5c2 100644 --- a/integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java +++ b/integration-tests/otlp/src/main/java/io/opentelemetry/integrationtest/OtlpExporterIntegrationTest.java @@ -30,10 +30,10 @@ import io.opentelemetry.api.trace.TraceId; import io.opentelemetry.api.trace.TraceState; import io.opentelemetry.context.Context; import io.opentelemetry.context.Scope; -import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogExporter; +import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporter; import io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporter; import io.opentelemetry.exporter.otlp.http.trace.OtlpHttpSpanExporter; -import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporter; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter; import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter; import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter; import io.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest; @@ -56,7 +56,7 @@ 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.SdkLoggerProvider; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.logs.export.SimpleLogProcessor; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.export.MetricExporter; @@ -438,8 +438,8 @@ abstract class OtlpExporterIntegrationTest { @ParameterizedTest @ValueSource(strings = {"gzip", "none"}) void testOtlpGrpcLogExport(String compression) { - LogExporter otlpGrpcLogExporter = - OtlpGrpcLogExporter.builder() + LogRecordExporter otlpGrpcLogRecordExporter = + OtlpGrpcLogRecordExporter.builder() .setEndpoint( "http://" + collector.getHost() @@ -448,13 +448,13 @@ abstract class OtlpExporterIntegrationTest { .setCompression(compression) .build(); - testLogExporter(otlpGrpcLogExporter); + testLogRecordExporter(otlpGrpcLogRecordExporter); } @Test void testOtlpGrpcLogExport_mtls() throws Exception { - LogExporter exporter = - OtlpGrpcLogExporter.builder() + LogRecordExporter exporter = + OtlpGrpcLogRecordExporter.builder() .setEndpoint( "https://" + collector.getHost() @@ -464,14 +464,14 @@ abstract class OtlpExporterIntegrationTest { .setTrustedCertificates(serverTls.certificate().getEncoded()) .build(); - testLogExporter(exporter); + testLogRecordExporter(exporter); } @ParameterizedTest @ValueSource(strings = {"gzip", "none"}) void testOtlpHttpLogExport(String compression) { - LogExporter otlpHttpLogExporter = - OtlpHttpLogExporter.builder() + LogRecordExporter otlpHttpLogRecordExporter = + OtlpHttpLogRecordExporter.builder() .setEndpoint( "http://" + collector.getHost() @@ -481,13 +481,13 @@ abstract class OtlpExporterIntegrationTest { .setCompression(compression) .build(); - testLogExporter(otlpHttpLogExporter); + testLogRecordExporter(otlpHttpLogRecordExporter); } @Test void testOtlpHttpLogExport_mtls() throws Exception { - LogExporter exporter = - OtlpHttpLogExporter.builder() + LogRecordExporter exporter = + OtlpHttpLogRecordExporter.builder() .setEndpoint( "https://" + collector.getHost() @@ -498,14 +498,14 @@ abstract class OtlpExporterIntegrationTest { .setTrustedCertificates(serverTls.certificate().getEncoded()) .build(); - testLogExporter(exporter); + testLogRecordExporter(exporter); } - private static void testLogExporter(LogExporter logExporter) { + private static void testLogRecordExporter(LogRecordExporter logRecordExporter) { SdkLoggerProvider loggerProvider = SdkLoggerProvider.builder() .setResource(RESOURCE) - .addLogProcessor(SimpleLogProcessor.create(logExporter)) + .addLogProcessor(SimpleLogProcessor.create(logRecordExporter)) .build(); Logger logger = loggerProvider.get(OtlpExporterIntegrationTest.class.getName()); diff --git a/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/AutoConfigurationCustomizer.java b/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/AutoConfigurationCustomizer.java index dd99844124..cce366ec47 100644 --- a/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/AutoConfigurationCustomizer.java +++ b/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/AutoConfigurationCustomizer.java @@ -7,7 +7,7 @@ package io.opentelemetry.sdk.autoconfigure.spi; import io.opentelemetry.context.propagation.TextMapPropagator; import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder; import io.opentelemetry.sdk.metrics.export.MetricExporter; import io.opentelemetry.sdk.resources.Resource; @@ -149,14 +149,15 @@ public interface AutoConfigurationCustomizer { } /** - * Adds a {@link BiFunction} to invoke with the default autoconfigured {@link LogExporter} to - * allow customization. The return value of the {@link BiFunction} will replace the passed-in + * Adds a {@link BiFunction} to invoke with the default autoconfigured {@link LogRecordExporter} + * to allow customization. The return value of the {@link BiFunction} will replace the passed-in * argument. * *

Multiple calls will execute the customizers in order. */ - default AutoConfigurationCustomizer addLogExporterCustomizer( - BiFunction exporterCustomizer) { + default AutoConfigurationCustomizer addLogRecordExporterCustomizer( + BiFunction + exporterCustomizer) { return this; } } diff --git a/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogExporterProvider.java b/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogRecordExporterProvider.java similarity index 75% rename from sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogExporterProvider.java rename to sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogRecordExporterProvider.java index 97c026516d..f01d0467a1 100644 --- a/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogExporterProvider.java +++ b/sdk-extensions/autoconfigure-spi/src/main/java/io/opentelemetry/sdk/autoconfigure/spi/logs/ConfigurableLogRecordExporterProvider.java @@ -6,7 +6,7 @@ package io.opentelemetry.sdk.autoconfigure.spi.logs; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; /** * A service provider interface (SPI) for providing additional exporters that can be used with the @@ -16,13 +16,13 @@ import io.opentelemetry.sdk.logs.export.LogExporter; * * @since 1.17.0 */ -public interface ConfigurableLogExporterProvider { +public interface ConfigurableLogRecordExporterProvider { /** - * Returns a {@link LogExporter} that can be registered to OpenTelemetry by providing the property - * value specified by {@link #getName()}. + * Returns a {@link LogRecordExporter} that can be registered to OpenTelemetry by providing the + * property value specified by {@link #getName()}. */ - LogExporter createExporter(ConfigProperties config); + LogRecordExporter createExporter(ConfigProperties config); /** * Returns the name of this exporter, which can be specified with the {@code otel.logs.exporter} diff --git a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java index cb3bce4e69..e75fd5e18d 100644 --- a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java +++ b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkBuilder.java @@ -19,7 +19,7 @@ import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.SdkLoggerProvider; import io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.SdkMeterProviderBuilder; import io.opentelemetry.sdk.metrics.export.MetricExporter; @@ -71,8 +71,8 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur private BiFunction loggerProviderCustomizer = (a, unused) -> a; - private BiFunction - logExporterCustomizer = (a, unused) -> a; + private BiFunction + logRecordExporterCustomizer = (a, unused) -> a; private BiFunction resourceCustomizer = (a, unused) -> a; @@ -263,18 +263,19 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur } /** - * Adds a {@link BiFunction} to invoke with the default autoconfigured {@link LogExporter} to - * allow customization. The return value of the {@link BiFunction} will replace the passed-in + * Adds a {@link BiFunction} to invoke with the default autoconfigured {@link LogRecordExporter} + * to allow customization. The return value of the {@link BiFunction} will replace the passed-in * argument. * *

Multiple calls will execute the customizers in order. */ @Override - public AutoConfiguredOpenTelemetrySdkBuilder addLogExporterCustomizer( - BiFunction - logExporterCustomizer) { - requireNonNull(logExporterCustomizer, "logExporterCustomizer"); - this.logExporterCustomizer = mergeCustomizer(this.logExporterCustomizer, logExporterCustomizer); + public AutoConfiguredOpenTelemetrySdkBuilder addLogRecordExporterCustomizer( + BiFunction + logRecordExporterCustomizer) { + requireNonNull(logRecordExporterCustomizer, "logRecordExporterCustomizer"); + this.logRecordExporterCustomizer = + mergeCustomizer(this.logRecordExporterCustomizer, logRecordExporterCustomizer); return this; } @@ -356,7 +357,11 @@ public final class AutoConfiguredOpenTelemetrySdkBuilder implements AutoConfigur SdkLoggerProviderBuilder loggerProviderBuilder = SdkLoggerProvider.builder(); loggerProviderBuilder.setResource(resource); LoggerProviderConfiguration.configureLoggerProvider( - loggerProviderBuilder, config, serviceClassLoader, meterProvider, logExporterCustomizer); + loggerProviderBuilder, + config, + serviceClassLoader, + meterProvider, + logRecordExporterCustomizer); loggerProviderBuilder = loggerProviderCustomizer.apply(loggerProviderBuilder, config); SdkLoggerProvider loggerProvider = loggerProviderBuilder.build(); diff --git a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfiguration.java b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfiguration.java similarity index 66% rename from sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfiguration.java rename to sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfiguration.java index 9ff9f21287..927b4eceb2 100644 --- a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfiguration.java +++ b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfiguration.java @@ -11,15 +11,15 @@ import static io.opentelemetry.sdk.autoconfigure.OtlpConfigUtil.PROTOCOL_HTTP_PR import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.retry.RetryUtil; -import io.opentelemetry.exporter.logging.SystemOutLogExporter; -import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogExporter; -import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogExporterBuilder; -import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporter; -import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporterBuilder; +import io.opentelemetry.exporter.logging.SystemOutLogRecordExporter; +import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporter; +import io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporterBuilder; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; -import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collections; import java.util.HashMap; import java.util.Map; @@ -27,17 +27,17 @@ import java.util.Set; import java.util.function.BiFunction; import javax.annotation.Nullable; -class LogExporterConfiguration { +class LogRecordExporterConfiguration { private static final String EXPORTER_NONE = "none"; // Visible for test - static Map configureLogExporters( + static Map configureLogRecordExporters( ConfigProperties config, ClassLoader serviceClassLoader, MeterProvider meterProvider, - BiFunction - logExporterCustomizer) { + BiFunction + logRecordExporterCustomizer) { Set exporterNames = DefaultConfigProperties.getSet(config, "otel.logs.exporter"); // Default to no exporter @@ -53,20 +53,22 @@ class LogExporterConfiguration { return Collections.emptyMap(); } - NamedSpiManager spiExportersManager = + NamedSpiManager spiExportersManager = SpiUtil.loadConfigurable( - ConfigurableLogExporterProvider.class, - ConfigurableLogExporterProvider::getName, - ConfigurableLogExporterProvider::createExporter, + ConfigurableLogRecordExporterProvider.class, + ConfigurableLogRecordExporterProvider::getName, + ConfigurableLogRecordExporterProvider::createExporter, config, serviceClassLoader); - Map exportersByName = new HashMap<>(); + Map exportersByName = new HashMap<>(); for (String name : exporterNames) { - LogExporter logExporter = configureExporter(name, config, spiExportersManager, meterProvider); - if (logExporter != null) { - LogExporter customizedLogExporter = logExporterCustomizer.apply(logExporter, config); - exportersByName.put(name, customizedLogExporter); + LogRecordExporter logRecordExporter = + configureExporter(name, config, spiExportersManager, meterProvider); + if (logRecordExporter != null) { + LogRecordExporter customizedLogRecordExporter = + logRecordExporterCustomizer.apply(logRecordExporter, config); + exportersByName.put(name, customizedLogRecordExporter); } } @@ -75,22 +77,22 @@ class LogExporterConfiguration { // Visible for testing @Nullable - static LogExporter configureExporter( + static LogRecordExporter configureExporter( String name, ConfigProperties config, - NamedSpiManager spiExportersManager, + NamedSpiManager spiExportersManager, MeterProvider meterProvider) { switch (name) { case "otlp": return configureOtlpLogs(config, meterProvider); case "logging": ClasspathUtil.checkClassExists( - "io.opentelemetry.exporter.logging.SystemOutLogExporter", + "io.opentelemetry.exporter.logging.SystemOutLogRecordExporter", "Logging Log Exporter", "opentelemetry-exporter-logging"); - return SystemOutLogExporter.create(); + return SystemOutLogRecordExporter.create(); default: - LogExporter spiExporter = spiExportersManager.getByName(name); + LogRecordExporter spiExporter = spiExportersManager.getByName(name); if (spiExporter == null) { throw new ConfigurationException("Unrecognized value for otel.logs.exporter: " + name); } @@ -100,20 +102,20 @@ class LogExporterConfiguration { // Visible for testing @Nullable - static LogExporter configureOtlpLogs(ConfigProperties config, MeterProvider meterProvider) { + static LogRecordExporter configureOtlpLogs(ConfigProperties config, MeterProvider meterProvider) { String protocol = OtlpConfigUtil.getOtlpProtocol(DATA_TYPE_LOGS, config); if (protocol.equals(PROTOCOL_HTTP_PROTOBUF)) { try { ClasspathUtil.checkClassExists( - "io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogExporter", + "io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporter", "OTLP HTTP Log Exporter", "opentelemetry-exporter-otlp-http-logs"); } catch (ConfigurationException e) { // Squash this for now until logs are stable return null; } - OtlpHttpLogExporterBuilder builder = OtlpHttpLogExporter.builder(); + OtlpHttpLogRecordExporterBuilder builder = OtlpHttpLogRecordExporter.builder(); OtlpConfigUtil.configureOtlpExporterBuilder( DATA_TYPE_LOGS, @@ -132,14 +134,14 @@ class LogExporterConfiguration { } else if (protocol.equals(PROTOCOL_GRPC)) { try { ClasspathUtil.checkClassExists( - "io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogExporter", + "io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter", "OTLP gRPC Log Exporter", "opentelemetry-exporter-otlp-logs"); } catch (ConfigurationException e) { // Squash this for now until logs are stable return null; } - OtlpGrpcLogExporterBuilder builder = OtlpGrpcLogExporter.builder(); + OtlpGrpcLogRecordExporterBuilder builder = OtlpGrpcLogRecordExporter.builder(); OtlpConfigUtil.configureOtlpExporterBuilder( DATA_TYPE_LOGS, @@ -159,5 +161,5 @@ class LogExporterConfiguration { } } - private LogExporterConfiguration() {} + private LogRecordExporterConfiguration() {} } diff --git a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java index b3668ecea5..23c06f2bda 100644 --- a/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java +++ b/sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java @@ -5,7 +5,7 @@ package io.opentelemetry.sdk.autoconfigure; -import static io.opentelemetry.sdk.autoconfigure.LogExporterConfiguration.configureLogExporters; +import static io.opentelemetry.sdk.autoconfigure.LogRecordExporterConfiguration.configureLogRecordExporters; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; @@ -14,7 +14,7 @@ import io.opentelemetry.sdk.logs.LogLimitsBuilder; import io.opentelemetry.sdk.logs.LogProcessor; 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.LogRecordExporter; import io.opentelemetry.sdk.logs.export.SimpleLogProcessor; import java.util.ArrayList; import java.util.HashMap; @@ -29,13 +29,14 @@ final class LoggerProviderConfiguration { ConfigProperties config, ClassLoader serviceClassLoader, MeterProvider meterProvider, - BiFunction - logExporterCustomizer) { + BiFunction + logRecordExporterCustomizer) { loggerProviderBuilder.setLogLimits(() -> configureLogLimits(config)); - Map exportersByName = - configureLogExporters(config, serviceClassLoader, meterProvider, logExporterCustomizer); + Map exportersByName = + configureLogRecordExporters( + config, serviceClassLoader, meterProvider, logRecordExporterCustomizer); configureLogProcessors(exportersByName, meterProvider) .forEach(loggerProviderBuilder::addLogProcessor); @@ -43,19 +44,22 @@ final class LoggerProviderConfiguration { // Visible for testing static List configureLogProcessors( - Map exportersByName, MeterProvider meterProvider) { - Map exportersByNameCopy = new HashMap<>(exportersByName); + Map exportersByName, MeterProvider meterProvider) { + Map exportersByNameCopy = new HashMap<>(exportersByName); List logProcessors = new ArrayList<>(); - LogExporter exporter = exportersByNameCopy.remove("logging"); + LogRecordExporter exporter = exportersByNameCopy.remove("logging"); if (exporter != null) { logProcessors.add(SimpleLogProcessor.create(exporter)); } if (!exportersByNameCopy.isEmpty()) { - LogExporter compositeLogExporter = LogExporter.composite(exportersByNameCopy.values()); + LogRecordExporter compositeLogRecordExporter = + LogRecordExporter.composite(exportersByNameCopy.values()); logProcessors.add( - BatchLogProcessor.builder(compositeLogExporter).setMeterProvider(meterProvider).build()); + BatchLogProcessor.builder(compositeLogRecordExporter) + .setMeterProvider(meterProvider) + .build()); } return logProcessors; diff --git a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java index 3b9916c136..ed40afcd4d 100644 --- a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java +++ b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/AutoConfiguredOpenTelemetrySdkTest.java @@ -282,7 +282,7 @@ class AutoConfiguredOpenTelemetrySdkTest { verify(logProcessor).forceFlush(); } - // TODO: add test for addLogExporterCustomizer once OTLP export is enabled by default + // TODO: add test for addLogRecordExporterCustomizer once OTLP export is enabled by default @Test void builder_setResultAsGlobalFalse() { diff --git a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfigurationTest.java b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfigurationTest.java similarity index 75% rename from sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfigurationTest.java rename to sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfigurationTest.java index ab37dce93e..29884cb565 100644 --- a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogExporterConfigurationTest.java +++ b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterConfigurationTest.java @@ -13,18 +13,18 @@ import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; import org.junit.jupiter.api.Test; -class LogExporterConfigurationTest { +class LogRecordExporterConfigurationTest { @Test - void configureLogExporters_duplicates() { + void configureLogRecordExporters_duplicates() { ConfigProperties config = DefaultConfigProperties.createForTest(ImmutableMap.of("otel.logs.exporter", "otlp,otlp")); assertThatThrownBy( () -> - LogExporterConfiguration.configureLogExporters( + LogRecordExporterConfiguration.configureLogRecordExporters( config, - LogExporterConfiguration.class.getClassLoader(), + LogRecordExporterConfiguration.class.getClassLoader(), MeterProvider.noop(), (a, unused) -> a)) .isInstanceOf(ConfigurationException.class) @@ -32,15 +32,15 @@ class LogExporterConfigurationTest { } @Test - void configureLogExporters_unrecognized() { + void configureLogRecordExporters_unrecognized() { ConfigProperties config = DefaultConfigProperties.createForTest(ImmutableMap.of("otel.logs.exporter", "foo")); assertThatThrownBy( () -> - LogExporterConfiguration.configureLogExporters( + LogRecordExporterConfiguration.configureLogRecordExporters( config, - LogExporterConfiguration.class.getClassLoader(), + LogRecordExporterConfiguration.class.getClassLoader(), MeterProvider.noop(), (a, unused) -> a)) .isInstanceOf(ConfigurationException.class) @@ -48,15 +48,15 @@ class LogExporterConfigurationTest { } @Test - void configureLogExporters_multipleWithNone() { + void configureLogRecordExporters_multipleWithNone() { ConfigProperties config = DefaultConfigProperties.createForTest(ImmutableMap.of("otel.logs.exporter", "otlp,none")); assertThatThrownBy( () -> - LogExporterConfiguration.configureLogExporters( + LogRecordExporterConfiguration.configureLogRecordExporters( config, - LogExporterConfiguration.class.getClassLoader(), + LogRecordExporterConfiguration.class.getClassLoader(), MeterProvider.noop(), (a, unused) -> a)) .isInstanceOf(ConfigurationException.class) @@ -67,7 +67,7 @@ class LogExporterConfigurationTest { void configureOtlpLogs_unsupportedProtocol() { assertThatThrownBy( () -> - LogExporterConfiguration.configureOtlpLogs( + LogRecordExporterConfiguration.configureOtlpLogs( DefaultConfigProperties.createForTest( ImmutableMap.of("otel.exporter.otlp.protocol", "foo")), MeterProvider.noop())) diff --git a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/NotOnClasspathTest.java b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/NotOnClasspathTest.java index c4ee4fdd76..a4a476b2c6 100644 --- a/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/NotOnClasspathTest.java +++ b/sdk-extensions/autoconfigure/src/test/java/io/opentelemetry/sdk/autoconfigure/NotOnClasspathTest.java @@ -100,7 +100,7 @@ class NotOnClasspathTest { void loggingLogs() { assertThatThrownBy( () -> - LogExporterConfiguration.configureExporter( + LogRecordExporterConfiguration.configureExporter( "logging", EMPTY, NamedSpiManager.createEmpty(), MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining( @@ -171,7 +171,7 @@ class NotOnClasspathTest { void otlpGrpcLogs() { assertThatCode( () -> - LogExporterConfiguration.configureExporter( + LogRecordExporterConfiguration.configureExporter( "otlp", EMPTY, NamedSpiManager.createEmpty(), MeterProvider.noop())) .doesNotThrowAnyException(); } @@ -183,7 +183,7 @@ class NotOnClasspathTest { Collections.singletonMap("otel.exporter.otlp.protocol", "http/protobuf")); assertThatCode( () -> - LogExporterConfiguration.configureExporter( + LogRecordExporterConfiguration.configureExporter( "otlp", config, NamedSpiManager.createEmpty(), MeterProvider.noop())) .doesNotThrowAnyException(); } diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogExporterTest.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogRecordExporterTest.java similarity index 75% rename from sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogExporterTest.java rename to sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogRecordExporterTest.java index 3c962b5d32..71e7c5df07 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogExporterTest.java +++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ConfigurableLogRecordExporterTest.java @@ -12,24 +12,24 @@ import com.google.common.collect.ImmutableMap; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.net.URL; import java.net.URLClassLoader; import java.util.Collections; import java.util.Map; import org.junit.jupiter.api.Test; -class ConfigurableLogExporterTest { +class ConfigurableLogRecordExporterTest { @Test - void configureLogExporters_spiExporter() { + void configureLogRecordExporters_spiExporter() { ConfigProperties config = DefaultConfigProperties.createForTest( ImmutableMap.of("test.option", "true", "otel.logs.exporter", "testExporter")); - Map exportersByName = - LogExporterConfiguration.configureLogExporters( + Map exportersByName = + LogRecordExporterConfiguration.configureLogRecordExporters( config, - LogExporterConfiguration.class.getClassLoader(), + LogRecordExporterConfiguration.class.getClassLoader(), MeterProvider.noop(), (a, unused) -> a); @@ -37,19 +37,19 @@ class ConfigurableLogExporterTest { .hasSize(1) .containsKey("testExporter") .extracting(map -> map.get("testExporter")) - .isInstanceOf(TestConfigurableLogExporterProvider.TestLogExporter.class) + .isInstanceOf(TestConfigurableLogRecordExporterProvider.TestLogRecordExporter.class) .extracting("config") .isSameAs(config); } @Test - void configureLogExporters_emptyClassLoader() { + void configureLogRecordExporters_emptyClassLoader() { ConfigProperties config = DefaultConfigProperties.createForTest( ImmutableMap.of("test.option", "true", "otel.logs.exporter", "testExporter")); assertThatThrownBy( () -> - LogExporterConfiguration.configureLogExporters( + LogRecordExporterConfiguration.configureLogRecordExporters( config, new URLClassLoader(new URL[0], null), MeterProvider.noop(), @@ -62,7 +62,7 @@ class ConfigurableLogExporterTest { void configureExporter_NotFound() { assertThatThrownBy( () -> - LogExporterConfiguration.configureExporter( + LogRecordExporterConfiguration.configureExporter( "catExporter", DefaultConfigProperties.createForTest(Collections.emptyMap()), NamedSpiManager.createEmpty(), diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogExporterCustomizer.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterCustomizer.java similarity index 85% rename from sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogExporterCustomizer.java rename to sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterCustomizer.java index bf5443de77..8b5b341e54 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogExporterCustomizer.java +++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LogRecordExporterCustomizer.java @@ -10,16 +10,16 @@ import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizer; import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collection; import java.util.stream.Collectors; -public class LogExporterCustomizer implements AutoConfigurationCustomizerProvider { +public class LogRecordExporterCustomizer implements AutoConfigurationCustomizerProvider { @Override public void customize(AutoConfigurationCustomizer autoConfiguration) { - autoConfiguration.addLogExporterCustomizer( + autoConfiguration.addLogRecordExporterCustomizer( (delegate, config) -> - new LogExporter() { + new LogRecordExporter() { @Override public CompletableResultCode export(Collection logs) { Collection filtered = diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java index 851425ae71..6b1e7af965 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java +++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfigurationTest.java @@ -9,12 +9,12 @@ import static org.assertj.core.api.Assertions.assertThat; 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.exporter.logging.SystemOutLogRecordExporter; +import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter; 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.LogRecordExporter; import io.opentelemetry.sdk.logs.export.SimpleLogProcessor; import java.util.Collections; import java.util.Map; @@ -68,8 +68,8 @@ class LoggerProviderConfigurationTest { @Test void configureSpanProcessors_multipleExportersWithLogging() { - LogExporter loggingExporter = SystemOutLogExporter.create(); - LogExporter otlpExporter = OtlpGrpcLogExporter.builder().build(); + LogRecordExporter loggingExporter = SystemOutLogRecordExporter.create(); + LogRecordExporter otlpExporter = OtlpGrpcLogRecordExporter.builder().build(); assertThat( LoggerProviderConfiguration.configureLogProcessors( diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogExporterProvider.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogRecordExporterProvider.java similarity index 69% rename from sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogExporterProvider.java rename to sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogRecordExporterProvider.java index cee3e1e283..5da73b27bd 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogExporterProvider.java +++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/TestConfigurableLogRecordExporterProvider.java @@ -6,17 +6,18 @@ package io.opentelemetry.sdk.autoconfigure; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; -import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider; +import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collection; -public class TestConfigurableLogExporterProvider implements ConfigurableLogExporterProvider { +public class TestConfigurableLogRecordExporterProvider + implements ConfigurableLogRecordExporterProvider { @Override - public LogExporter createExporter(ConfigProperties config) { - return new TestLogExporter(config); + public LogRecordExporter createExporter(ConfigProperties config) { + return new TestLogRecordExporter(config); } @Override @@ -24,10 +25,10 @@ public class TestConfigurableLogExporterProvider implements ConfigurableLogExpor return "testExporter"; } - public static class TestLogExporter implements LogExporter { + public static class TestLogRecordExporter implements LogRecordExporter { private final ConfigProperties config; - public TestLogExporter(ConfigProperties config) { + public TestLogRecordExporter(ConfigProperties config) { this.config = config; } diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogExporterProvider.java b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogRecordExporterProvider.java similarity index 59% rename from sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogExporterProvider.java rename to sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogRecordExporterProvider.java index 7ecb52a292..68701bbb5e 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogExporterProvider.java +++ b/sdk-extensions/autoconfigure/src/testFullConfig/java/io/opentelemetry/sdk/autoconfigure/ThrowingConfigurableLogRecordExporterProvider.java @@ -6,12 +6,13 @@ package io.opentelemetry.sdk.autoconfigure; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; -import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; -public class ThrowingConfigurableLogExporterProvider implements ConfigurableLogExporterProvider { +public class ThrowingConfigurableLogRecordExporterProvider + implements ConfigurableLogRecordExporterProvider { @Override - public LogExporter createExporter(ConfigProperties config) { + public LogRecordExporter createExporter(ConfigProperties config) { throw new IllegalStateException("always throws"); } diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider b/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider index 32ee9ebc98..8dc13cc7ee 100644 --- a/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider +++ b/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider @@ -1,3 +1,3 @@ io.opentelemetry.sdk.autoconfigure.SpanExporterCustomizer io.opentelemetry.sdk.autoconfigure.MetricCustomizer -io.opentelemetry.sdk.autoconfigure.LogExporterCustomizer \ No newline at end of file +io.opentelemetry.sdk.autoconfigure.LogRecordExporterCustomizer \ No newline at end of file diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider b/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider deleted file mode 100644 index de4c97897e..0000000000 --- a/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogExporterProvider +++ /dev/null @@ -1,2 +0,0 @@ -io.opentelemetry.sdk.autoconfigure.TestConfigurableLogExporterProvider -io.opentelemetry.sdk.autoconfigure.ThrowingConfigurableLogExporterProvider diff --git a/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider b/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider new file mode 100644 index 0000000000..3453394db2 --- /dev/null +++ b/sdk-extensions/autoconfigure/src/testFullConfig/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider @@ -0,0 +1,2 @@ +io.opentelemetry.sdk.autoconfigure.TestConfigurableLogRecordExporterProvider +io.opentelemetry.sdk.autoconfigure.ThrowingConfigurableLogRecordExporterProvider diff --git a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcConfigTest.java b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcConfigTest.java index 0578276975..a349dec426 100644 --- a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcConfigTest.java +++ b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcConfigTest.java @@ -21,7 +21,7 @@ import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.InstrumentType; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.data.MetricData; @@ -81,8 +81,8 @@ class OtlpGrpcConfigTest { "otlp", properties, NamedSpiManager.createEmpty(), MeterProvider.noop()); MetricExporter metricExporter = MetricExporterConfiguration.configureOtlpMetrics(properties); - LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) { + LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) { assertThat(spanExporter) .extracting("delegate.client.callTimeoutMillis", INTEGER) .isEqualTo(TimeUnit.SECONDS.toMillis(15)); @@ -111,10 +111,11 @@ class OtlpGrpcConfigTest { && headers.contains("header-key", "header-value") && headers.contains("grpc-encoding", "gzip")); - assertThat(logExporter) + assertThat(logRecordExporter) .extracting("delegate.client.callTimeoutMillis", INTEGER) .isEqualTo(TimeUnit.SECONDS.toMillis(15)); - assertThat(logExporter.export(LOG_DATA).join(15, TimeUnit.SECONDS).isSuccess()).isTrue(); + assertThat(logRecordExporter.export(LOG_DATA).join(15, TimeUnit.SECONDS).isSuccess()) + .isTrue(); assertThat(server.logRequests).hasSize(1); assertThat(server.requestHeaders) .anyMatch( @@ -205,7 +206,7 @@ class OtlpGrpcConfigTest { } @Test - public void configureLogExporter() { + public void configureLogRecordExporter() { // Set values for general and signal specific properties. Signal specific should override // general. Map props = new HashMap<>(); @@ -220,14 +221,15 @@ class OtlpGrpcConfigTest { props.put("otel.exporter.otlp.logs.headers", "header-key=header-value"); props.put("otel.exporter.otlp.logs.compression", "gzip"); props.put("otel.exporter.otlp.logs.timeout", "15s"); - try (LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs( + try (LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs( DefaultConfigProperties.createForTest(props), MeterProvider.noop())) { - assertThat(logExporter) + assertThat(logRecordExporter) .extracting("delegate.client.callTimeoutMillis", INTEGER) .isEqualTo(TimeUnit.SECONDS.toMillis(15)); - assertThat(logExporter.export(LOG_DATA).join(15, TimeUnit.SECONDS).isSuccess()).isTrue(); + assertThat(logRecordExporter.export(LOG_DATA).join(15, TimeUnit.SECONDS).isSuccess()) + .isTrue(); assertThat(server.logRequests).hasSize(1); assertThat(server.requestHeaders) .anyMatch( @@ -257,7 +259,8 @@ class OtlpGrpcConfigTest { .hasMessageContaining("Invalid OTLP certificate/key path:"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Invalid OTLP certificate/key path:"); } @@ -280,7 +283,8 @@ class OtlpGrpcConfigTest { .hasMessageContaining("Client key provided but certification chain is missing"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Client key provided but certification chain is missing"); } @@ -303,7 +307,8 @@ class OtlpGrpcConfigTest { .hasMessageContaining("Client key chain provided but key is missing"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Client key chain provided but key is missing"); } diff --git a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcRetryTest.java b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcRetryTest.java index 84e25b952e..1daf36919f 100644 --- a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcRetryTest.java +++ b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpGrpcRetryTest.java @@ -20,7 +20,7 @@ import io.opentelemetry.exporter.internal.retry.RetryUtil; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.export.MetricExporter; import io.opentelemetry.sdk.trace.data.SpanData; @@ -92,18 +92,18 @@ class OtlpGrpcRetryTest { @Test @SuppressLogger(OkHttpGrpcExporter.class) - void configureLogExporterRetryPolicy() { + void configureLogRecordExporterRetryPolicy() { Map props = new HashMap<>(); props.put("otel.exporter.otlp.logs.endpoint", "https://localhost:" + server.httpsPort()); props.put( "otel.exporter.otlp.logs.certificate", certificate.certificateFile().getAbsolutePath()); props.put("otel.experimental.exporter.otlp.retry.enabled", "true"); - try (LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs( + try (LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs( DefaultConfigProperties.createForTest(props), MeterProvider.noop())) { - testRetryableStatusCodes(() -> LOG_DATA, logExporter::export, server.logRequests::size); - testDefaultRetryPolicy(() -> LOG_DATA, logExporter::export, server.logRequests::size); + testRetryableStatusCodes(() -> LOG_DATA, logRecordExporter::export, server.logRequests::size); + testDefaultRetryPolicy(() -> LOG_DATA, logRecordExporter::export, server.logRequests::size); } } diff --git a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpConfigTest.java b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpConfigTest.java index 2c1e99a2bb..30d929c230 100644 --- a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpConfigTest.java +++ b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpConfigTest.java @@ -19,7 +19,7 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.InstrumentType; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; import io.opentelemetry.sdk.metrics.export.MetricExporter; @@ -67,8 +67,8 @@ class OtlpHttpConfigTest { SpanExporterConfiguration.configureExporter( "otlp", properties, NamedSpiManager.createEmpty(), MeterProvider.noop()); MetricExporter metricExporter = MetricExporterConfiguration.configureOtlpMetrics(properties); - LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop()); + LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop()); assertThat(spanExporter) .extracting("delegate.client", as(InstanceOfAssertFactories.type(OkHttpClient.class))) @@ -106,12 +106,12 @@ class OtlpHttpConfigTest { && headers.contains("header-key", "header-value") && headers.contains("content-encoding", "gzip")); - assertThat(logExporter) + assertThat(logRecordExporter) .extracting("delegate.client", as(InstanceOfAssertFactories.type(OkHttpClient.class))) .extracting(OkHttpClient::callTimeoutMillis) .isEqualTo((int) TimeUnit.SECONDS.toMillis(15)); assertThat( - logExporter + logRecordExporter .export(Lists.newArrayList(generateFakeLog())) .join(15, TimeUnit.SECONDS) .isSuccess()) @@ -219,7 +219,7 @@ class OtlpHttpConfigTest { } @Test - public void configureLogExporter() { + public void configureLogRecordExporter() { // Set values for general and signal specific properties. Signal specific should override // general. Map props = new HashMap<>(); @@ -238,16 +238,16 @@ class OtlpHttpConfigTest { props.put("otel.exporter.otlp.logs.headers", "header-key=header-value"); props.put("otel.exporter.otlp.logs.compression", "gzip"); props.put("otel.exporter.otlp.logs.timeout", "15s"); - LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs( + LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs( DefaultConfigProperties.createForTest(props), MeterProvider.noop()); - assertThat(logExporter) + assertThat(logRecordExporter) .extracting("delegate.client", as(InstanceOfAssertFactories.type(OkHttpClient.class))) .extracting(OkHttpClient::callTimeoutMillis) .isEqualTo((int) TimeUnit.SECONDS.toMillis(15)); assertThat( - logExporter + logRecordExporter .export(Lists.newArrayList(generateFakeLog())) .join(15, TimeUnit.SECONDS) .isSuccess()) @@ -279,7 +279,8 @@ class OtlpHttpConfigTest { .hasMessageContaining("Invalid OTLP certificate/key path:"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Invalid OTLP certificate/key path:"); } @@ -303,7 +304,8 @@ class OtlpHttpConfigTest { .hasMessageContaining("Client key provided but certification chain is missing"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Client key provided but certification chain is missing"); } @@ -327,7 +329,8 @@ class OtlpHttpConfigTest { .hasMessageContaining("Client key chain provided but key is missing"); assertThatThrownBy( - () -> LogExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) + () -> + LogRecordExporterConfiguration.configureOtlpLogs(properties, MeterProvider.noop())) .isInstanceOf(ConfigurationException.class) .hasMessageContaining("Client key chain provided but key is missing"); } diff --git a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpRetryTest.java b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpRetryTest.java index 8fb520d7db..2030029fd1 100644 --- a/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpRetryTest.java +++ b/sdk-extensions/autoconfigure/src/testOtlp/java/io/opentelemetry/sdk/autoconfigure/OtlpHttpRetryTest.java @@ -21,7 +21,7 @@ import io.opentelemetry.exporter.internal.retry.RetryUtil; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.logs.export.LogExporter; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.export.MetricExporter; import io.opentelemetry.sdk.trace.data.SpanData; @@ -95,7 +95,7 @@ class OtlpHttpRetryTest { @Test @SuppressLogger(OkHttpGrpcExporter.class) - void configureLogExporterRetryPolicy() { + void configureLogRecordExporterRetryPolicy() { Map props = new HashMap<>(); props.put("otel.exporter.otlp.logs.protocol", "http/protobuf"); props.put( @@ -104,12 +104,12 @@ class OtlpHttpRetryTest { "otel.exporter.otlp.logs.certificate", server.selfSignedCertificate.certificate().getPath()); props.put("otel.experimental.exporter.otlp.retry.enabled", "true"); - try (LogExporter logExporter = - LogExporterConfiguration.configureOtlpLogs( + try (LogRecordExporter logRecordExporter = + LogRecordExporterConfiguration.configureOtlpLogs( DefaultConfigProperties.createForTest(props), MeterProvider.noop())) { - testRetryableStatusCodes(() -> LOG_DATA, logExporter::export, server.logRequests::size); - testDefaultRetryPolicy(() -> LOG_DATA, logExporter::export, server.logRequests::size); + testRetryableStatusCodes(() -> LOG_DATA, logRecordExporter::export, server.logRequests::size); + testDefaultRetryPolicy(() -> LOG_DATA, logRecordExporter::export, server.logRequests::size); } } diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessor.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessor.java index 014eac2ebc..8388d034fa 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessor.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessor.java @@ -52,16 +52,16 @@ public final class BatchLogProcessor implements LogProcessor { /** * Returns a new Builder for {@link BatchLogProcessor}. * - * @param logExporter the {@link LogExporter} to which the Logs are pushed + * @param logRecordExporter the {@link LogRecordExporter} to which the Logs are pushed * @return a new {@link BatchLogProcessorBuilder}. - * @throws NullPointerException if the {@code logExporter} is {@code null}. + * @throws NullPointerException if the {@code logRecordExporter} is {@code null}. */ - public static BatchLogProcessorBuilder builder(LogExporter logExporter) { - return new BatchLogProcessorBuilder(logExporter); + public static BatchLogProcessorBuilder builder(LogRecordExporter logRecordExporter) { + return new BatchLogProcessorBuilder(logRecordExporter); } BatchLogProcessor( - LogExporter logExporter, + LogRecordExporter logRecordExporter, MeterProvider meterProvider, long scheduleDelayNanos, int maxQueueSize, @@ -69,7 +69,7 @@ public final class BatchLogProcessor implements LogProcessor { long exporterTimeoutNanos) { this.worker = new Worker( - logExporter, + logRecordExporter, meterProvider, scheduleDelayNanos, maxExportBatchSize, @@ -105,7 +105,8 @@ public final class BatchLogProcessor implements LogProcessor { return worker.batch; } - // Worker is a thread that batches multiple logs and calls the registered LogExporter to export + // Worker is a thread that batches multiple logs and calls the registered LogRecordExporter to + // export // the data. private static final class Worker implements Runnable { @@ -115,7 +116,7 @@ public final class BatchLogProcessor implements LogProcessor { private final Attributes droppedAttrs; private final Attributes exportedAttrs; - private final LogExporter logExporter; + private final LogRecordExporter logRecordExporter; private final long scheduleDelayNanos; private final int maxExportBatchSize; private final long exporterTimeoutNanos; @@ -136,13 +137,13 @@ public final class BatchLogProcessor implements LogProcessor { private final ArrayList batch; private Worker( - LogExporter logExporter, + LogRecordExporter logRecordExporter, MeterProvider meterProvider, long scheduleDelayNanos, int maxExportBatchSize, long exporterTimeoutNanos, Queue queue) { - this.logExporter = logExporter; + this.logRecordExporter = logRecordExporter; this.scheduleDelayNanos = scheduleDelayNanos; this.maxExportBatchSize = maxExportBatchSize; this.exporterTimeoutNanos = exporterTimeoutNanos; @@ -254,7 +255,7 @@ public final class BatchLogProcessor implements LogProcessor { flushResult.whenComplete( () -> { continueWork = false; - CompletableResultCode shutdownResult = logExporter.shutdown(); + CompletableResultCode shutdownResult = logRecordExporter.shutdown(); shutdownResult.whenComplete( () -> { if (!flushResult.isSuccess() || !shutdownResult.isSuccess()) { @@ -287,7 +288,8 @@ public final class BatchLogProcessor implements LogProcessor { } try { - CompletableResultCode result = logExporter.export(Collections.unmodifiableList(batch)); + CompletableResultCode result = + logRecordExporter.export(Collections.unmodifiableList(batch)); result.join(exporterTimeoutNanos, TimeUnit.NANOSECONDS); if (result.isSuccess()) { processedLogsCounter.add(batch.size(), exportedAttrs); diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorBuilder.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorBuilder.java index b4be201d67..f55d0b8649 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorBuilder.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorBuilder.java @@ -24,15 +24,15 @@ public final class BatchLogProcessorBuilder { // Visible for testing static final int DEFAULT_EXPORT_TIMEOUT_MILLIS = 30_000; - private final LogExporter logExporter; + private final LogRecordExporter logRecordExporter; private long scheduleDelayNanos = TimeUnit.MILLISECONDS.toNanos(DEFAULT_SCHEDULE_DELAY_MILLIS); private int maxQueueSize = DEFAULT_MAX_QUEUE_SIZE; private int maxExportBatchSize = DEFAULT_MAX_EXPORT_BATCH_SIZE; private long exporterTimeoutNanos = TimeUnit.MILLISECONDS.toNanos(DEFAULT_EXPORT_TIMEOUT_MILLIS); private MeterProvider meterProvider = MeterProvider.noop(); - BatchLogProcessorBuilder(LogExporter logExporter) { - this.logExporter = requireNonNull(logExporter, "logExporter"); + BatchLogProcessorBuilder(LogRecordExporter logRecordExporter) { + this.logRecordExporter = requireNonNull(logRecordExporter, "logRecordExporter"); } /** @@ -139,13 +139,13 @@ public final class BatchLogProcessorBuilder { /** * Returns a new {@link BatchLogProcessor} that batches, then forwards them to the given {@code - * logExporter}. + * logRecordExporter}. * * @return a new {@link BatchLogProcessor}. */ public BatchLogProcessor build() { return new BatchLogProcessor( - logExporter, + logRecordExporter, meterProvider, scheduleDelayNanos, maxQueueSize, diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporter.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporter.java similarity index 77% rename from sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporter.java rename to sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporter.java index 3b34f27e9a..6377a27e84 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporter.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporter.java @@ -14,20 +14,22 @@ import java.util.List; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; -/** A {@link LogExporter} implementation that can be used to test OpenTelemetry integration. */ -public final class InMemoryLogExporter implements LogExporter { +/** + * A {@link LogRecordExporter} implementation that can be used to test OpenTelemetry integration. + */ +public final class InMemoryLogRecordExporter implements LogRecordExporter { private final Queue finishedLogItems = new ConcurrentLinkedQueue<>(); private boolean isStopped = false; - private InMemoryLogExporter() {} + private InMemoryLogRecordExporter() {} /** - * Returns a new instance of the {@code InMemoryLogExporter}. + * Returns a new instance of the {@link InMemoryLogRecordExporter}. * - * @return a new instance of the {@code InMemoryLogExporter}. + * @return a new instance of the {@link InMemoryLogRecordExporter}. */ - public static InMemoryLogExporter create() { - return new InMemoryLogExporter(); + public static InMemoryLogRecordExporter create() { + return new InMemoryLogRecordExporter(); } /** @@ -70,7 +72,7 @@ public final class InMemoryLogExporter implements LogExporter { /** * Clears the internal {@code List} of finished {@code Log}s. * - *

Any subsequent call to export() function on this LogExporter, will return {@code + *

Any subsequent call to export() function on this exporter, will return {@code * CompletableResultCode.ofFailure()} */ @Override diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogExporter.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogRecordExporter.java similarity index 74% rename from sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogExporter.java rename to sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogRecordExporter.java index 97b5c82306..5ce3495dbb 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogExporter.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/LogRecordExporter.java @@ -20,36 +20,38 @@ import java.util.concurrent.TimeUnit; * An exporter is responsible for taking a collection of {@link LogData}s and transmitting them to * their ultimate destination. */ -public interface LogExporter extends Closeable { +public interface LogRecordExporter extends Closeable { /** - * Returns a {@link LogExporter} which delegates all exports to the {@code exporters} in order. + * Returns a {@link LogRecordExporter} which delegates all exports to the {@code exporters} in + * order. * *

Can be used to export to multiple backends using the same {@link LogProcessor} like a {@link * SimpleLogProcessor} or a {@link BatchLogProcessor}. */ - static LogExporter composite(LogExporter... exporters) { + static LogRecordExporter composite(LogRecordExporter... exporters) { return composite(Arrays.asList(exporters)); } /** - * Returns a {@link LogExporter} which delegates all exports to the {@code exporters} in order. + * Returns a {@link LogRecordExporter} which delegates all exports to the {@code exporters} in + * order. * *

Can be used to export to multiple backends using the same {@link LogProcessor} like a {@link * SimpleLogProcessor} or a {@link BatchLogProcessor}. */ - static LogExporter composite(Iterable exporters) { - List exportersList = new ArrayList<>(); - for (LogExporter exporter : exporters) { + static LogRecordExporter composite(Iterable exporters) { + List exportersList = new ArrayList<>(); + for (LogRecordExporter exporter : exporters) { exportersList.add(exporter); } if (exportersList.isEmpty()) { - return NoopLogExporter.getInstance(); + return NoopLogRecordExporter.getInstance(); } if (exportersList.size() == 1) { return exportersList.get(0); } - return MultiLogExporter.create(exportersList); + return MultiLogRecordExporter.create(exportersList); } /** @@ -76,7 +78,7 @@ public interface LogExporter extends Closeable { */ CompletableResultCode shutdown(); - /** Closes this {@link LogExporter}, releasing any resources. */ + /** Closes this {@link LogRecordExporter}, releasing any resources. */ @Override default void close() { shutdown().join(10, TimeUnit.SECONDS); diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogExporter.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporter.java similarity index 59% rename from sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogExporter.java rename to sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporter.java index 216d03f57e..3cf2dce14e 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogExporter.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporter.java @@ -14,33 +14,33 @@ import java.util.logging.Level; import java.util.logging.Logger; /** - * {@link LogExporter} that forwards all received logs to a list of {@link LogExporter}. + * {@link LogRecordExporter} that forwards all received logs to a list of {@link LogRecordExporter}. * - *

Can be used to export to multiple backends using the same {@link LogExporter} like a {@link - * SimpleLogProcessor} or a {@link BatchLogProcessor}. + *

Can be used to export to multiple backends using the same {@link LogRecordExporter} like a + * {@link SimpleLogProcessor} or a {@link BatchLogProcessor}. */ -final class MultiLogExporter implements LogExporter { - private static final Logger logger = Logger.getLogger(MultiLogExporter.class.getName()); +final class MultiLogRecordExporter implements LogRecordExporter { + private static final Logger logger = Logger.getLogger(MultiLogRecordExporter.class.getName()); - private final LogExporter[] logExporters; + private final LogRecordExporter[] logRecordExporters; /** * Constructs and returns an instance of this class. * - * @param logExporters the exporters logs should be sent to + * @param logRecordExporters the exporters logs should be sent to * @return the aggregate log exporter */ - static LogExporter create(List logExporters) { - return new MultiLogExporter(logExporters.toArray(new LogExporter[0])); + static LogRecordExporter create(List logRecordExporters) { + return new MultiLogRecordExporter(logRecordExporters.toArray(new LogRecordExporter[0])); } @Override public CompletableResultCode export(Collection logs) { - List results = new ArrayList<>(logExporters.length); - for (LogExporter logExporter : logExporters) { + List results = new ArrayList<>(logRecordExporters.length); + for (LogRecordExporter logRecordExporter : logRecordExporters) { CompletableResultCode exportResult; try { - exportResult = logExporter.export(logs); + exportResult = logRecordExporter.export(logs); } catch (RuntimeException e) { // If an exception was thrown by the exporter logger.log(Level.WARNING, "Exception thrown by the export.", e); @@ -53,17 +53,17 @@ final class MultiLogExporter implements LogExporter { } /** - * Flushes the data of all registered {@link LogExporter}s. + * Flushes the data of all registered {@link LogRecordExporter}s. * * @return the result of the operation */ @Override public CompletableResultCode flush() { - List results = new ArrayList<>(logExporters.length); - for (LogExporter logExporter : logExporters) { + List results = new ArrayList<>(logRecordExporters.length); + for (LogRecordExporter logRecordExporter : logRecordExporters) { CompletableResultCode flushResult; try { - flushResult = logExporter.flush(); + flushResult = logRecordExporter.flush(); } catch (RuntimeException e) { // If an exception was thrown by the exporter logger.log(Level.WARNING, "Exception thrown by the flush.", e); @@ -77,11 +77,11 @@ final class MultiLogExporter implements LogExporter { @Override public CompletableResultCode shutdown() { - List results = new ArrayList<>(logExporters.length); - for (LogExporter logExporter : logExporters) { + List results = new ArrayList<>(logRecordExporters.length); + for (LogRecordExporter logRecordExporter : logRecordExporters) { CompletableResultCode shutdownResult; try { - shutdownResult = logExporter.shutdown(); + shutdownResult = logRecordExporter.shutdown(); } catch (RuntimeException e) { // If an exception was thrown by the exporter logger.log(Level.WARNING, "Exception thrown by the shutdown.", e); @@ -93,7 +93,7 @@ final class MultiLogExporter implements LogExporter { return CompletableResultCode.ofAll(results); } - private MultiLogExporter(LogExporter[] logExporters) { - this.logExporters = logExporters; + private MultiLogRecordExporter(LogRecordExporter[] logRecordExporters) { + this.logRecordExporters = logRecordExporters; } } diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogExporter.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogRecordExporter.java similarity index 77% rename from sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogExporter.java rename to sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogRecordExporter.java index fe11b98c4b..607e180ccf 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogExporter.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/NoopLogRecordExporter.java @@ -9,11 +9,11 @@ import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogData; import java.util.Collection; -final class NoopLogExporter implements LogExporter { +final class NoopLogRecordExporter implements LogRecordExporter { - private static final LogExporter INSTANCE = new NoopLogExporter(); + private static final LogRecordExporter INSTANCE = new NoopLogRecordExporter(); - static LogExporter getInstance() { + static LogRecordExporter getInstance() { return INSTANCE; } diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessor.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessor.java index 70745e3f3d..67dc939954 100644 --- a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessor.java +++ b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessor.java @@ -33,13 +33,13 @@ public final class SimpleLogProcessor implements LogProcessor { private static final Logger logger = Logger.getLogger(SimpleLogProcessor.class.getName()); - private final LogExporter logExporter; + private final LogRecordExporter logRecordExporter; private final Set pendingExports = Collections.newSetFromMap(new ConcurrentHashMap<>()); private final AtomicBoolean isShutdown = new AtomicBoolean(false); /** - * Returns a new {@link SimpleLogProcessor} which exports logs to the {@link LogExporter} + * Returns a new {@link SimpleLogProcessor} which exports logs to the {@link LogRecordExporter} * synchronously. * *

This processor will cause all logs to be exported directly as they finish, meaning each @@ -48,20 +48,20 @@ public final class SimpleLogProcessor implements LogProcessor { * BatchLogProcessor} instead, including in special environments such as serverless runtimes. * {@link SimpleLogProcessor} is generally meant to for testing only. */ - public static LogProcessor create(LogExporter exporter) { + public static LogProcessor create(LogRecordExporter exporter) { requireNonNull(exporter, "exporter"); return new SimpleLogProcessor(exporter); } - SimpleLogProcessor(LogExporter logExporter) { - this.logExporter = requireNonNull(logExporter, "logExporter"); + SimpleLogProcessor(LogRecordExporter logRecordExporter) { + this.logRecordExporter = requireNonNull(logRecordExporter, "logRecordExporter"); } @Override public void onEmit(ReadWriteLogRecord logRecord) { try { List logs = Collections.singletonList(logRecord.toLogData()); - CompletableResultCode result = logExporter.export(logs); + CompletableResultCode result = logRecordExporter.export(logs); pendingExports.add(result); result.whenComplete( () -> { @@ -85,7 +85,7 @@ public final class SimpleLogProcessor implements LogProcessor { CompletableResultCode flushResult = forceFlush(); flushResult.whenComplete( () -> { - CompletableResultCode shutdownResult = logExporter.shutdown(); + CompletableResultCode shutdownResult = logRecordExporter.shutdown(); shutdownResult.whenComplete( () -> { if (!flushResult.isSuccess() || !shutdownResult.isSuccess()) { diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorTest.java index bb3f944509..a0417f70e8 100644 --- a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorTest.java +++ b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/BatchLogProcessorTest.java @@ -47,11 +47,11 @@ class BatchLogProcessorTest { private static final String LOG_MESSAGE_2 = "Hello world 2!"; private static final long MAX_SCHEDULE_DELAY_MILLIS = 500; - @Mock private LogExporter mockLogExporter; + @Mock private LogRecordExporter mockLogRecordExporter; @BeforeEach void setUp() { - when(mockLogExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + when(mockLogRecordExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); } private void emitLog(SdkLoggerProvider sdkLoggerProvider, String message) { @@ -65,7 +65,7 @@ class BatchLogProcessorTest { @Test void builderDefaults() { - BatchLogProcessorBuilder builder = BatchLogProcessor.builder(mockLogExporter); + BatchLogProcessorBuilder builder = BatchLogProcessor.builder(mockLogRecordExporter); assertThat(builder.getScheduleDelayNanos()) .isEqualTo( TimeUnit.MILLISECONDS.toNanos(BatchLogProcessorBuilder.DEFAULT_SCHEDULE_DELAY_MILLIS)); @@ -82,45 +82,49 @@ class BatchLogProcessorTest { void builderInvalidConfig() { assertThatThrownBy( () -> - BatchLogProcessor.builder(mockLogExporter) + BatchLogProcessor.builder(mockLogRecordExporter) .setScheduleDelay(-1, TimeUnit.MILLISECONDS)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("delay must be non-negative"); - assertThatThrownBy(() -> BatchLogProcessor.builder(mockLogExporter).setScheduleDelay(1, null)) + assertThatThrownBy( + () -> BatchLogProcessor.builder(mockLogRecordExporter).setScheduleDelay(1, null)) .isInstanceOf(NullPointerException.class) .hasMessage("unit"); - assertThatThrownBy(() -> BatchLogProcessor.builder(mockLogExporter).setScheduleDelay(null)) + assertThatThrownBy( + () -> BatchLogProcessor.builder(mockLogRecordExporter).setScheduleDelay(null)) .isInstanceOf(NullPointerException.class) .hasMessage("delay"); assertThatThrownBy( () -> - BatchLogProcessor.builder(mockLogExporter) + BatchLogProcessor.builder(mockLogRecordExporter) .setExporterTimeout(-1, TimeUnit.MILLISECONDS)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("timeout must be non-negative"); - assertThatThrownBy(() -> BatchLogProcessor.builder(mockLogExporter).setExporterTimeout(1, null)) + assertThatThrownBy( + () -> BatchLogProcessor.builder(mockLogRecordExporter).setExporterTimeout(1, null)) .isInstanceOf(NullPointerException.class) .hasMessage("unit"); - assertThatThrownBy(() -> BatchLogProcessor.builder(mockLogExporter).setExporterTimeout(null)) + assertThatThrownBy( + () -> BatchLogProcessor.builder(mockLogRecordExporter).setExporterTimeout(null)) .isInstanceOf(NullPointerException.class) .hasMessage("timeout"); } @Test void emitMultipleLogs() { - WaitingLogExporter waitingLogExporter = - new WaitingLogExporter(2, CompletableResultCode.ofSuccess()); + WaitingLogRecordExporter waitingLogRecordExporter = + new WaitingLogRecordExporter(2, CompletableResultCode.ofSuccess()); SdkLoggerProvider loggerProvider = SdkLoggerProvider.builder() .addLogProcessor( - BatchLogProcessor.builder(waitingLogExporter) + BatchLogProcessor.builder(waitingLogRecordExporter) .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS) .build()) .build(); emitLog(loggerProvider, LOG_MESSAGE_1); emitLog(loggerProvider, LOG_MESSAGE_2); - List exported = waitingLogExporter.waitForExport(); + List exported = waitingLogRecordExporter.waitForExport(); assertThat(exported) .satisfiesExactly( logData -> assertThat(logData).hasBody(LOG_MESSAGE_1), @@ -129,12 +133,12 @@ class BatchLogProcessorTest { @Test void emitMoreLogsThanBufferSize() { - CompletableLogExporter logExporter = new CompletableLogExporter(); + CompletableLogRecordExporter logRecordExporter = new CompletableLogRecordExporter(); SdkLoggerProvider sdkLoggerProvider = SdkLoggerProvider.builder() .addLogProcessor( - BatchLogProcessor.builder(logExporter) + BatchLogProcessor.builder(logRecordExporter) .setMaxQueueSize(6) .setMaxExportBatchSize(2) .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS) @@ -148,22 +152,22 @@ class BatchLogProcessorTest { emitLog(sdkLoggerProvider, LOG_MESSAGE_1); emitLog(sdkLoggerProvider, LOG_MESSAGE_1); - logExporter.succeed(); + logRecordExporter.succeed(); await() .untilAsserted( () -> - assertThat(logExporter.getExported()) + assertThat(logRecordExporter.getExported()) .hasSize(6) .allSatisfy(logData -> assertThat(logData).hasBody(LOG_MESSAGE_1))); } @Test void forceEmit() { - WaitingLogExporter waitingLogExporter = - new WaitingLogExporter(100, CompletableResultCode.ofSuccess(), 1); + WaitingLogRecordExporter waitingLogRecordExporter = + new WaitingLogRecordExporter(100, CompletableResultCode.ofSuccess(), 1); BatchLogProcessor batchLogProcessor = - BatchLogProcessor.builder(waitingLogExporter) + BatchLogProcessor.builder(waitingLogRecordExporter) .setMaxQueueSize(10_000) // Force flush should send all logs, make sure the number of logs we check here is // not divisible by the batch size. @@ -176,43 +180,43 @@ class BatchLogProcessorTest { for (int i = 0; i < 50; i++) { emitLog(sdkLoggerProvider, "notExported"); } - List exported = waitingLogExporter.waitForExport(); + List exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).isNotNull(); assertThat(exported.size()).isEqualTo(49); for (int i = 0; i < 50; i++) { emitLog(sdkLoggerProvider, "notExported"); } - exported = waitingLogExporter.waitForExport(); + exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).isNotNull(); assertThat(exported.size()).isEqualTo(49); batchLogProcessor.forceFlush().join(10, TimeUnit.SECONDS); - exported = waitingLogExporter.getExported(); + exported = waitingLogRecordExporter.getExported(); assertThat(exported).isNotNull(); assertThat(exported.size()).isEqualTo(2); } @Test void emitLogsToMultipleExporters() { - WaitingLogExporter waitingLogExporter1 = - new WaitingLogExporter(2, CompletableResultCode.ofSuccess()); - WaitingLogExporter waitingLogExporter2 = - new WaitingLogExporter(2, CompletableResultCode.ofSuccess()); + WaitingLogRecordExporter waitingLogRecordExporter1 = + new WaitingLogRecordExporter(2, CompletableResultCode.ofSuccess()); + WaitingLogRecordExporter waitingLogRecordExporter2 = + new WaitingLogRecordExporter(2, CompletableResultCode.ofSuccess()); SdkLoggerProvider sdkLoggerProvider = SdkLoggerProvider.builder() .addLogProcessor( BatchLogProcessor.builder( - LogExporter.composite( - Arrays.asList(waitingLogExporter1, waitingLogExporter2))) + LogRecordExporter.composite( + Arrays.asList(waitingLogRecordExporter1, waitingLogRecordExporter2))) .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS) .build()) .build(); emitLog(sdkLoggerProvider, LOG_MESSAGE_1); emitLog(sdkLoggerProvider, LOG_MESSAGE_2); - List exported1 = waitingLogExporter1.waitForExport(); - List exported2 = waitingLogExporter2.waitForExport(); + List exported1 = waitingLogRecordExporter1.waitForExport(); + List exported2 = waitingLogRecordExporter2.waitForExport(); assertThat(exported1) .hasSize(2) .satisfiesExactly( @@ -228,15 +232,15 @@ class BatchLogProcessorTest { @Test void emitMoreLogsThanTheMaximumLimit() { int maxQueuedLogs = 8; - BlockingLogExporter blockingLogExporter = new BlockingLogExporter(); - WaitingLogExporter waitingLogExporter = - new WaitingLogExporter(maxQueuedLogs, CompletableResultCode.ofSuccess()); + BlockingLogRecordExporter blockingLogRecordExporter = new BlockingLogRecordExporter(); + WaitingLogRecordExporter waitingLogRecordExporter = + new WaitingLogRecordExporter(maxQueuedLogs, CompletableResultCode.ofSuccess()); SdkLoggerProvider sdkTracerProvider = SdkLoggerProvider.builder() .addLogProcessor( BatchLogProcessor.builder( - LogExporter.composite( - Arrays.asList(blockingLogExporter, waitingLogExporter))) + LogRecordExporter.composite( + Arrays.asList(blockingLogRecordExporter, waitingLogRecordExporter))) .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS) .setMaxQueueSize(maxQueuedLogs) .setMaxExportBatchSize(maxQueuedLogs / 2) @@ -247,7 +251,7 @@ class BatchLogProcessorTest { // can be removed from the queue. Need to add a log to trigger the export otherwise the // pipeline is never called. emitLog(sdkTracerProvider, "blocking log"); - blockingLogExporter.waitUntilIsBlocked(); + blockingLogRecordExporter.waitUntilIsBlocked(); for (int i = 0; i < maxQueuedLogs; i++) { // First export maxQueuedLogs, the worker thread is blocked so all items should be queued. @@ -260,28 +264,28 @@ class BatchLogProcessorTest { } // Release the blocking exporter - blockingLogExporter.unblock(); + blockingLogRecordExporter.unblock(); // While we wait for maxQueuedLogs we ensure that the queue is also empty after this. - List exported = waitingLogExporter.waitForExport(); + List exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).isNotNull(); assertThat(exported).hasSize(maxQueuedLogs + 1); // Clear, reset, add another batch of logs, and confirm they are exported exported.clear(); - waitingLogExporter.reset(); + waitingLogRecordExporter.reset(); for (int i = 0; i < maxQueuedLogs; i++) { emitLog(sdkTracerProvider, "log_3_" + i); } - exported = waitingLogExporter.waitForExport(); + exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).isNotNull(); assertThat(exported).hasSize(maxQueuedLogs); } @Test void ignoresNullLogs() { - BatchLogProcessor processor = BatchLogProcessor.builder(mockLogExporter).build(); + BatchLogProcessor processor = BatchLogProcessor.builder(mockLogRecordExporter).build(); try { assertThatCode(() -> processor.onEmit(null)).doesNotThrowAnyException(); } finally { @@ -290,29 +294,30 @@ class BatchLogProcessorTest { } @Test - @SuppressLogger(MultiLogExporter.class) + @SuppressLogger(MultiLogRecordExporter.class) void exporterThrowsException() { - WaitingLogExporter waitingLogExporter = - new WaitingLogExporter(1, CompletableResultCode.ofSuccess()); + WaitingLogRecordExporter waitingLogRecordExporter = + new WaitingLogRecordExporter(1, CompletableResultCode.ofSuccess()); doThrow(new IllegalArgumentException("No export for you.")) - .when(mockLogExporter) + .when(mockLogRecordExporter) .export(anyList()); SdkLoggerProvider sdkLoggerProvider = SdkLoggerProvider.builder() .addLogProcessor( BatchLogProcessor.builder( - LogExporter.composite(Arrays.asList(mockLogExporter, waitingLogExporter))) + LogRecordExporter.composite( + Arrays.asList(mockLogRecordExporter, waitingLogRecordExporter))) .setScheduleDelay(MAX_SCHEDULE_DELAY_MILLIS, TimeUnit.MILLISECONDS) .build()) .build(); emitLog(sdkLoggerProvider, LOG_MESSAGE_1); - List exported = waitingLogExporter.waitForExport(); + List exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_1)); - waitingLogExporter.reset(); + waitingLogRecordExporter.reset(); // Continue to export after the exception was received. emitLog(sdkLoggerProvider, LOG_MESSAGE_2); - exported = waitingLogExporter.waitForExport(); + exported = waitingLogRecordExporter.waitForExport(); assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_2)); } @@ -321,7 +326,7 @@ class BatchLogProcessorTest { public void continuesIfExporterTimesOut() throws InterruptedException { int exporterTimeoutMillis = 10; BatchLogProcessor blp = - BatchLogProcessor.builder(mockLogExporter) + BatchLogProcessor.builder(mockLogRecordExporter) .setExporterTimeout(exporterTimeoutMillis, TimeUnit.MILLISECONDS) .setScheduleDelay(1, TimeUnit.MILLISECONDS) .setMaxQueueSize(1) @@ -330,7 +335,7 @@ class BatchLogProcessorTest { CountDownLatch exported = new CountDownLatch(1); // We return a result we never complete, meaning it will timeout. - when(mockLogExporter.export( + when(mockLogRecordExporter.export( argThat( logs -> { assertThat(logs) @@ -346,9 +351,9 @@ class BatchLogProcessorTest { // Still processing new logs. CountDownLatch exportedAgain = new CountDownLatch(1); - reset(mockLogExporter); - when(mockLogExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - when(mockLogExporter.export( + reset(mockLogRecordExporter); + when(mockLogRecordExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + when(mockLogRecordExporter.export( argThat( logs -> { assertThat(logs) @@ -365,14 +370,14 @@ class BatchLogProcessorTest { @Test @Timeout(10) void shutdownFlushes() { - WaitingLogExporter waitingLogExporter = - new WaitingLogExporter(1, CompletableResultCode.ofSuccess()); + WaitingLogRecordExporter waitingLogRecordExporter = + new WaitingLogRecordExporter(1, CompletableResultCode.ofSuccess()); // Set the export delay to large value, in order to confirm the #flush() below works SdkLoggerProvider sdkLoggerProvider = SdkLoggerProvider.builder() .addLogProcessor( - BatchLogProcessor.builder(waitingLogExporter) + BatchLogProcessor.builder(waitingLogRecordExporter) .setScheduleDelay(10, TimeUnit.SECONDS) .build()) .build(); @@ -382,14 +387,14 @@ class BatchLogProcessorTest { // Force a shutdown, which forces processing of all remaining logs. sdkLoggerProvider.shutdown().join(10, TimeUnit.SECONDS); - List exported = waitingLogExporter.getExported(); + List exported = waitingLogRecordExporter.getExported(); assertThat(exported).satisfiesExactly(logData -> assertThat(logData).hasBody(LOG_MESSAGE_2)); - assertThat(waitingLogExporter.shutDownCalled.get()).isTrue(); + assertThat(waitingLogRecordExporter.shutDownCalled.get()).isTrue(); } @Test void shutdownPropagatesSuccess() { - BatchLogProcessor processor = BatchLogProcessor.builder(mockLogExporter).build(); + BatchLogProcessor processor = BatchLogProcessor.builder(mockLogRecordExporter).build(); CompletableResultCode result = processor.shutdown(); result.join(1, TimeUnit.SECONDS); assertThat(result.isSuccess()).isTrue(); @@ -397,14 +402,14 @@ class BatchLogProcessorTest { @Test void shutdownPropagatesFailure() { - when(mockLogExporter.shutdown()).thenReturn(CompletableResultCode.ofFailure()); - BatchLogProcessor processor = BatchLogProcessor.builder(mockLogExporter).build(); + when(mockLogRecordExporter.shutdown()).thenReturn(CompletableResultCode.ofFailure()); + BatchLogProcessor processor = BatchLogProcessor.builder(mockLogRecordExporter).build(); CompletableResultCode result = processor.shutdown(); result.join(1, TimeUnit.SECONDS); assertThat(result.isSuccess()).isFalse(); } - private static final class BlockingLogExporter implements LogExporter { + private static final class BlockingLogRecordExporter implements LogRecordExporter { final Object monitor = new Object(); @@ -465,7 +470,7 @@ class BatchLogProcessorTest { } } - private static class CompletableLogExporter implements LogExporter { + private static class CompletableLogRecordExporter implements LogRecordExporter { private final List results = new ArrayList<>(); @@ -508,7 +513,7 @@ class BatchLogProcessorTest { } } - static class WaitingLogExporter implements LogExporter { + static class WaitingLogRecordExporter implements LogRecordExporter { private final List logDataList = new ArrayList<>(); private final int numberToWaitFor; @@ -517,13 +522,14 @@ class BatchLogProcessorTest { private int timeout = 10; private final AtomicBoolean shutDownCalled = new AtomicBoolean(false); - WaitingLogExporter(int numberToWaitFor, CompletableResultCode exportResultCode) { + WaitingLogRecordExporter(int numberToWaitFor, CompletableResultCode exportResultCode) { countDownLatch = new CountDownLatch(numberToWaitFor); this.numberToWaitFor = numberToWaitFor; this.exportResultCode = exportResultCode; } - WaitingLogExporter(int numberToWaitFor, CompletableResultCode exportResultCode, int timeout) { + WaitingLogRecordExporter( + int numberToWaitFor, CompletableResultCode exportResultCode, int timeout) { this(numberToWaitFor, exportResultCode); this.timeout = timeout; } diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporterTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporterTest.java similarity index 94% rename from sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporterTest.java rename to sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporterTest.java index c91a680c4f..d188241f17 100644 --- a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogExporterTest.java +++ b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/InMemoryLogRecordExporterTest.java @@ -19,9 +19,9 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -/** Unit tests for {@link InMemoryLogExporter}. */ -class InMemoryLogExporterTest { - private final InMemoryLogExporter exporter = InMemoryLogExporter.create(); +/** Unit tests for {@link InMemoryLogRecordExporter}. */ +class InMemoryLogRecordExporterTest { + private final InMemoryLogRecordExporter exporter = InMemoryLogRecordExporter.create(); private SdkLoggerProvider loggerProvider; private Logger logger; diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogExporterTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogExporterTest.java deleted file mode 100644 index 29981cb31d..0000000000 --- a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogExporterTest.java +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.sdk.logs.export; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.same; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import io.opentelemetry.api.logs.Severity; -import io.opentelemetry.internal.testing.slf4j.SuppressLogger; -import io.opentelemetry.sdk.common.CompletableResultCode; -import io.opentelemetry.sdk.logs.data.LogData; -import io.opentelemetry.sdk.testing.logs.TestLogData; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentMatchers; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.junit.jupiter.MockitoExtension; - -@ExtendWith(MockitoExtension.class) -class MultiLogExporterTest { - @Mock private LogExporter logExporter1; - @Mock private LogExporter logExporter2; - private static final List LOG_LIST = - Collections.singletonList( - TestLogData.builder().setBody("Message!").setSeverity(Severity.DEBUG).build()); - - @Test - void empty() { - LogExporter multiLogExporter = LogExporter.composite(Collections.emptyList()); - multiLogExporter.export(LOG_LIST); - multiLogExporter.shutdown(); - } - - @Test - void oneLogExporter() { - LogExporter multiLogExporter = LogExporter.composite(Collections.singletonList(logExporter1)); - - when(logExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.export(LOG_LIST).isSuccess()).isTrue(); - verify(logExporter1).export(same(LOG_LIST)); - - when(logExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.flush().isSuccess()).isTrue(); - verify(logExporter1).flush(); - - when(logExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - multiLogExporter.shutdown(); - verify(logExporter1).shutdown(); - } - - @Test - void twoLogExporter() { - LogExporter multiLogExporter = LogExporter.composite(Arrays.asList(logExporter1, logExporter2)); - - when(logExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.export(LOG_LIST).isSuccess()).isTrue(); - verify(logExporter1).export(same(LOG_LIST)); - verify(logExporter2).export(same(LOG_LIST)); - - when(logExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.flush()).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.flush().isSuccess()).isTrue(); - verify(logExporter1).flush(); - verify(logExporter2).flush(); - - when(logExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - multiLogExporter.shutdown(); - verify(logExporter1).shutdown(); - verify(logExporter2).shutdown(); - } - - @Test - void twoLogExporter_OneReturnFailure() { - LogExporter multiLogExporter = LogExporter.composite(Arrays.asList(logExporter1, logExporter2)); - - when(logExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofFailure()); - assertThat(multiLogExporter.export(LOG_LIST).isSuccess()).isFalse(); - verify(logExporter1).export(same(LOG_LIST)); - verify(logExporter2).export(same(LOG_LIST)); - - when(logExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.flush()).thenReturn(CompletableResultCode.ofFailure()); - assertThat(multiLogExporter.flush().isSuccess()).isFalse(); - verify(logExporter1).flush(); - verify(logExporter2).flush(); - - when(logExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter2.shutdown()).thenReturn(CompletableResultCode.ofFailure()); - assertThat(multiLogExporter.shutdown().isSuccess()).isFalse(); - verify(logExporter1).shutdown(); - verify(logExporter2).shutdown(); - } - - @Test - @SuppressLogger(MultiLogExporter.class) - void twoLogExporter_FirstThrows() { - LogExporter multiLogExporter = LogExporter.composite(Arrays.asList(logExporter1, logExporter2)); - - Mockito.doThrow(new IllegalArgumentException("No export for you.")) - .when(logExporter1) - .export(ArgumentMatchers.anyList()); - when(logExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.export(LOG_LIST).isSuccess()).isFalse(); - verify(logExporter1).export(same(LOG_LIST)); - verify(logExporter2).export(same(LOG_LIST)); - - Mockito.doThrow(new IllegalArgumentException("No flush for you.")).when(logExporter1).flush(); - when(logExporter2.flush()).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.flush().isSuccess()).isFalse(); - verify(logExporter1).flush(); - verify(logExporter2).flush(); - - Mockito.doThrow(new IllegalArgumentException("No shutdown for you.")) - .when(logExporter1) - .shutdown(); - when(logExporter2.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); - assertThat(multiLogExporter.shutdown().isSuccess()).isFalse(); - verify(logExporter1).shutdown(); - verify(logExporter2).shutdown(); - } -} diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporterTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporterTest.java new file mode 100644 index 0000000000..f8800d59c2 --- /dev/null +++ b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/MultiLogRecordExporterTest.java @@ -0,0 +1,139 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.sdk.logs.export; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.same; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.opentelemetry.api.logs.Severity; +import io.opentelemetry.internal.testing.slf4j.SuppressLogger; +import io.opentelemetry.sdk.common.CompletableResultCode; +import io.opentelemetry.sdk.logs.data.LogData; +import io.opentelemetry.sdk.testing.logs.TestLogData; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentMatchers; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +@ExtendWith(MockitoExtension.class) +class MultiLogRecordExporterTest { + @Mock private LogRecordExporter logRecordExporter1; + @Mock private LogRecordExporter logRecordExporter2; + private static final List LOG_LIST = + Collections.singletonList( + TestLogData.builder().setBody("Message!").setSeverity(Severity.DEBUG).build()); + + @Test + void empty() { + LogRecordExporter multiLogRecordExporter = LogRecordExporter.composite(Collections.emptyList()); + multiLogRecordExporter.export(LOG_LIST); + multiLogRecordExporter.shutdown(); + } + + @Test + void oneLogRecordExporter() { + LogRecordExporter multiLogRecordExporter = + LogRecordExporter.composite(Collections.singletonList(logRecordExporter1)); + + when(logRecordExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.export(LOG_LIST).isSuccess()).isTrue(); + verify(logRecordExporter1).export(same(LOG_LIST)); + + when(logRecordExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.flush().isSuccess()).isTrue(); + verify(logRecordExporter1).flush(); + + when(logRecordExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + multiLogRecordExporter.shutdown(); + verify(logRecordExporter1).shutdown(); + } + + @Test + void twoLogRecordExporter() { + LogRecordExporter multiLogRecordExporter = + LogRecordExporter.composite(Arrays.asList(logRecordExporter1, logRecordExporter2)); + + when(logRecordExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.export(LOG_LIST).isSuccess()).isTrue(); + verify(logRecordExporter1).export(same(LOG_LIST)); + verify(logRecordExporter2).export(same(LOG_LIST)); + + when(logRecordExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.flush()).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.flush().isSuccess()).isTrue(); + verify(logRecordExporter1).flush(); + verify(logRecordExporter2).flush(); + + when(logRecordExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + multiLogRecordExporter.shutdown(); + verify(logRecordExporter1).shutdown(); + verify(logRecordExporter2).shutdown(); + } + + @Test + void twoLogRecordExporter_OneReturnFailure() { + LogRecordExporter multiLogRecordExporter = + LogRecordExporter.composite(Arrays.asList(logRecordExporter1, logRecordExporter2)); + + when(logRecordExporter1.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofFailure()); + assertThat(multiLogRecordExporter.export(LOG_LIST).isSuccess()).isFalse(); + verify(logRecordExporter1).export(same(LOG_LIST)); + verify(logRecordExporter2).export(same(LOG_LIST)); + + when(logRecordExporter1.flush()).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.flush()).thenReturn(CompletableResultCode.ofFailure()); + assertThat(multiLogRecordExporter.flush().isSuccess()).isFalse(); + verify(logRecordExporter1).flush(); + verify(logRecordExporter2).flush(); + + when(logRecordExporter1.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter2.shutdown()).thenReturn(CompletableResultCode.ofFailure()); + assertThat(multiLogRecordExporter.shutdown().isSuccess()).isFalse(); + verify(logRecordExporter1).shutdown(); + verify(logRecordExporter2).shutdown(); + } + + @Test + @SuppressLogger(MultiLogRecordExporter.class) + void twoLogRecordExporter_FirstThrows() { + LogRecordExporter multiLogRecordExporter = + LogRecordExporter.composite(Arrays.asList(logRecordExporter1, logRecordExporter2)); + + Mockito.doThrow(new IllegalArgumentException("No export for you.")) + .when(logRecordExporter1) + .export(ArgumentMatchers.anyList()); + when(logRecordExporter2.export(same(LOG_LIST))).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.export(LOG_LIST).isSuccess()).isFalse(); + verify(logRecordExporter1).export(same(LOG_LIST)); + verify(logRecordExporter2).export(same(LOG_LIST)); + + Mockito.doThrow(new IllegalArgumentException("No flush for you.")) + .when(logRecordExporter1) + .flush(); + when(logRecordExporter2.flush()).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.flush().isSuccess()).isFalse(); + verify(logRecordExporter1).flush(); + verify(logRecordExporter2).flush(); + + Mockito.doThrow(new IllegalArgumentException("No shutdown for you.")) + .when(logRecordExporter1) + .shutdown(); + when(logRecordExporter2.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + assertThat(multiLogRecordExporter.shutdown().isSuccess()).isFalse(); + verify(logRecordExporter1).shutdown(); + verify(logRecordExporter2).shutdown(); + } +} diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessorTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessorTest.java index 8f52aabbc5..fbc166d539 100644 --- a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessorTest.java +++ b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/export/SimpleLogProcessorTest.java @@ -36,16 +36,16 @@ class SimpleLogProcessorTest { private static final LogData LOG_DATA = TestLogData.builder().build(); - @Mock private LogExporter logExporter; + @Mock private LogRecordExporter logRecordExporter; @Mock private ReadWriteLogRecord readWriteLogRecord; private LogProcessor logProcessor; @BeforeEach void setUp() { - logProcessor = SimpleLogProcessor.create(logExporter); - when(logExporter.export(anyCollection())).thenReturn(CompletableResultCode.ofSuccess()); - when(logExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); + logProcessor = SimpleLogProcessor.create(logRecordExporter); + when(logRecordExporter.export(anyCollection())).thenReturn(CompletableResultCode.ofSuccess()); + when(logRecordExporter.shutdown()).thenReturn(CompletableResultCode.ofSuccess()); when(readWriteLogRecord.toLogData()).thenReturn(LOG_DATA); } @@ -59,16 +59,16 @@ class SimpleLogProcessorTest { @Test void onEmit() { logProcessor.onEmit(readWriteLogRecord); - verify(logExporter).export(Collections.singletonList(LOG_DATA)); + verify(logRecordExporter).export(Collections.singletonList(LOG_DATA)); } @Test @SuppressLogger(SimpleLogProcessor.class) void onEmit_ExporterError() { - when(logExporter.export(any())).thenThrow(new RuntimeException("Exporter error!")); + when(logRecordExporter.export(any())).thenThrow(new RuntimeException("Exporter error!")); logProcessor.onEmit(readWriteLogRecord); logProcessor.onEmit(readWriteLogRecord); - verify(logExporter, times(2)).export(anyList()); + verify(logRecordExporter, times(2)).export(anyList()); } @Test @@ -76,12 +76,12 @@ class SimpleLogProcessorTest { CompletableResultCode export1 = new CompletableResultCode(); CompletableResultCode export2 = new CompletableResultCode(); - when(logExporter.export(any())).thenReturn(export1, export2); + when(logRecordExporter.export(any())).thenReturn(export1, export2); logProcessor.onEmit(readWriteLogRecord); logProcessor.onEmit(readWriteLogRecord); - verify(logExporter, times(2)).export(Collections.singletonList(LOG_DATA)); + verify(logRecordExporter, times(2)).export(Collections.singletonList(LOG_DATA)); CompletableResultCode flush = logProcessor.forceFlush(); assertThat(flush.isDone()).isFalse(); @@ -99,23 +99,23 @@ class SimpleLogProcessorTest { CompletableResultCode export1 = new CompletableResultCode(); CompletableResultCode export2 = new CompletableResultCode(); - when(logExporter.export(any())).thenReturn(export1, export2); + when(logRecordExporter.export(any())).thenReturn(export1, export2); logProcessor.onEmit(readWriteLogRecord); logProcessor.onEmit(readWriteLogRecord); - verify(logExporter, times(2)).export(Collections.singletonList(LOG_DATA)); + verify(logRecordExporter, times(2)).export(Collections.singletonList(LOG_DATA)); CompletableResultCode shutdown = logProcessor.shutdown(); assertThat(shutdown.isDone()).isFalse(); export1.succeed(); assertThat(shutdown.isDone()).isFalse(); - verify(logExporter, never()).shutdown(); + verify(logRecordExporter, never()).shutdown(); export2.succeed(); assertThat(shutdown.isDone()).isTrue(); assertThat(shutdown.isSuccess()).isTrue(); - verify(logExporter).shutdown(); + verify(logRecordExporter).shutdown(); } }