Rename LogExporter to LogRecordExporter (#4773)
This commit is contained in:
jack-berg
GitHub
parent
f7317c6e8d
commit
9b17be3114
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,2 +1,15 @@
|
|||
Comparing source compatibility of against
|
||||
No changes.
|
||||
---! 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()
|
||||
|
|
|
|||
|
|
@ -1,2 +1,17 @@
|
|||
Comparing source compatibility of against
|
||||
No changes.
|
||||
---! 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()
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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<LogData> logs) {
|
||||
|
|
@ -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
|
||||
|
|
@ -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.
|
||||
*
|
||||
* <p>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<LogData> logs) {
|
||||
|
|
@ -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 "
|
||||
|
|
@ -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<LogsRequestMarshaler> delegate;
|
||||
|
||||
OtlpHttpLogExporter(OkHttpExporter<LogsRequestMarshaler> delegate) {
|
||||
OtlpHttpLogRecordExporter(OkHttpExporter<LogsRequestMarshaler> 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();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -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<LogsRequestMarshaler> 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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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<LogsRequestMarshaler> 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<LogsRequestMarshaler> delegate) {
|
||||
OtlpGrpcLogRecordExporter(GrpcExporter<LogsRequestMarshaler> delegate) {
|
||||
this.delegate = delegate;
|
||||
}
|
||||
|
||||
|
|
@ -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<LogsRequestMarshaler> 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());
|
||||
}
|
||||
}
|
||||
|
|
@ -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<LogData> 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> resourceLogs =
|
||||
|
|
@ -27,9 +27,10 @@ import java.time.Instant;
|
|||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class OtlpGrpcLogExporterTest extends AbstractGrpcTelemetryExporterTest<LogData, ResourceLogs> {
|
||||
class OtlpGrpcLogRecordExporterTest
|
||||
extends AbstractGrpcTelemetryExporterTest<LogData, ResourceLogs> {
|
||||
|
||||
OtlpGrpcLogExporterTest() {
|
||||
OtlpGrpcLogRecordExporterTest() {
|
||||
super("log", ResourceLogs.getDefaultInstance());
|
||||
}
|
||||
|
||||
|
|
@ -38,20 +39,20 @@ class OtlpGrpcLogExporterTest extends AbstractGrpcTelemetryExporterTest<LogData,
|
|||
assertThatCode(
|
||||
() ->
|
||||
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<LogData> exporterBuilder() {
|
||||
return TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder());
|
||||
return TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -29,10 +29,10 @@ import java.time.Instant;
|
|||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class OtlpGrpcNettyLogExporterTest
|
||||
class OtlpGrpcNettyLogRecordExporterTest
|
||||
extends AbstractGrpcTelemetryExporterTest<LogData, ResourceLogs> {
|
||||
|
||||
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<LogData> exporterBuilder() {
|
||||
return ManagedChannelTelemetryExporterBuilder.wrap(
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder()));
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder()));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -26,10 +26,10 @@ import java.time.Instant;
|
|||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class OtlpGrpcNettyShadedLogExporterTest
|
||||
class OtlpGrpcNettyShadedLogRecordExporterTest
|
||||
extends AbstractGrpcTelemetryExporterTest<LogData, ResourceLogs> {
|
||||
|
||||
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<LogData> exporterBuilder() {
|
||||
return ManagedChannelTelemetryExporterBuilder.wrap(
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder()));
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder()));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -26,10 +26,10 @@ import java.time.Instant;
|
|||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
class OtlpGrpcNettyOkHttpLogExporterTest
|
||||
class OtlpGrpcNettyOkHttpLogRecordExporterTest
|
||||
extends AbstractGrpcTelemetryExporterTest<LogData, ResourceLogs> {
|
||||
|
||||
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<LogData> exporterBuilder() {
|
||||
return ManagedChannelTelemetryExporterBuilder.wrap(
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogExporter.builder()));
|
||||
TelemetryExporterBuilder.wrap(OtlpGrpcLogRecordExporter.builder()));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -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<LogData> {
|
||||
private final OtlpGrpcLogExporterBuilder builder;
|
||||
final class GrpcLogRecordExporterBuilderWrapper implements TelemetryExporterBuilder<LogData> {
|
||||
private final OtlpGrpcLogRecordExporterBuilder builder;
|
||||
|
||||
GrpcLogExporterBuilderWrapper(OtlpGrpcLogExporterBuilder builder) {
|
||||
GrpcLogRecordExporterBuilderWrapper(OtlpGrpcLogRecordExporterBuilder builder) {
|
||||
this.builder = builder;
|
||||
}
|
||||
|
||||
|
|
@ -98,7 +98,7 @@ public final class ManagedChannelTelemetryExporterBuilder<T>
|
|||
@Override
|
||||
public TelemetryExporterBuilder<T> 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";
|
||||
|
|
|
|||
|
|
@ -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<T> {
|
|||
};
|
||||
}
|
||||
|
||||
/** Wraps a LogExporter. */
|
||||
static TelemetryExporter<LogData> wrap(LogExporter exporter) {
|
||||
/** Wraps a LogRecordExporter. */
|
||||
static TelemetryExporter<LogData> wrap(LogRecordExporter exporter) {
|
||||
return new TelemetryExporter<LogData>() {
|
||||
@Override
|
||||
public CompletableResultCode export(Collection<LogData> items) {
|
||||
|
|
|
|||
|
|
@ -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<T> {
|
|||
return new GrpcMetricExporterBuilderWrapper(builder);
|
||||
}
|
||||
|
||||
static TelemetryExporterBuilder<LogData> wrap(OtlpGrpcLogExporterBuilder builder) {
|
||||
return new GrpcLogExporterBuilderWrapper(builder);
|
||||
static TelemetryExporterBuilder<LogData> wrap(OtlpGrpcLogRecordExporterBuilder builder) {
|
||||
return new GrpcLogRecordExporterBuilderWrapper(builder);
|
||||
}
|
||||
|
||||
TelemetryExporterBuilder<T> setEndpoint(String endpoint);
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
*
|
||||
* <p>Multiple calls will execute the customizers in order.
|
||||
*/
|
||||
default AutoConfigurationCustomizer addLogExporterCustomizer(
|
||||
BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter> exporterCustomizer) {
|
||||
default AutoConfigurationCustomizer addLogRecordExporterCustomizer(
|
||||
BiFunction<? super LogRecordExporter, ConfigProperties, ? extends LogRecordExporter>
|
||||
exporterCustomizer) {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
@ -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<SdkLoggerProviderBuilder, ConfigProperties, SdkLoggerProviderBuilder>
|
||||
loggerProviderCustomizer = (a, unused) -> a;
|
||||
private BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter>
|
||||
logExporterCustomizer = (a, unused) -> a;
|
||||
private BiFunction<? super LogRecordExporter, ConfigProperties, ? extends LogRecordExporter>
|
||||
logRecordExporterCustomizer = (a, unused) -> a;
|
||||
|
||||
private BiFunction<? super Resource, ConfigProperties, ? extends Resource> 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.
|
||||
*
|
||||
* <p>Multiple calls will execute the customizers in order.
|
||||
*/
|
||||
@Override
|
||||
public AutoConfiguredOpenTelemetrySdkBuilder addLogExporterCustomizer(
|
||||
BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter>
|
||||
logExporterCustomizer) {
|
||||
requireNonNull(logExporterCustomizer, "logExporterCustomizer");
|
||||
this.logExporterCustomizer = mergeCustomizer(this.logExporterCustomizer, logExporterCustomizer);
|
||||
public AutoConfiguredOpenTelemetrySdkBuilder addLogRecordExporterCustomizer(
|
||||
BiFunction<? super LogRecordExporter, ConfigProperties, ? extends LogRecordExporter>
|
||||
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();
|
||||
|
||||
|
|
|
|||
|
|
@ -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<String, LogExporter> configureLogExporters(
|
||||
static Map<String, LogRecordExporter> configureLogRecordExporters(
|
||||
ConfigProperties config,
|
||||
ClassLoader serviceClassLoader,
|
||||
MeterProvider meterProvider,
|
||||
BiFunction<? super LogExporter, ConfigProperties, ? extends LogExporter>
|
||||
logExporterCustomizer) {
|
||||
BiFunction<? super LogRecordExporter, ConfigProperties, ? extends LogRecordExporter>
|
||||
logRecordExporterCustomizer) {
|
||||
Set<String> exporterNames = DefaultConfigProperties.getSet(config, "otel.logs.exporter");
|
||||
|
||||
// Default to no exporter
|
||||
|
|
@ -53,20 +53,22 @@ class LogExporterConfiguration {
|
|||
return Collections.emptyMap();
|
||||
}
|
||||
|
||||
NamedSpiManager<LogExporter> spiExportersManager =
|
||||
NamedSpiManager<LogRecordExporter> spiExportersManager =
|
||||
SpiUtil.loadConfigurable(
|
||||
ConfigurableLogExporterProvider.class,
|
||||
ConfigurableLogExporterProvider::getName,
|
||||
ConfigurableLogExporterProvider::createExporter,
|
||||
ConfigurableLogRecordExporterProvider.class,
|
||||
ConfigurableLogRecordExporterProvider::getName,
|
||||
ConfigurableLogRecordExporterProvider::createExporter,
|
||||
config,
|
||||
serviceClassLoader);
|
||||
|
||||
Map<String, LogExporter> exportersByName = new HashMap<>();
|
||||
Map<String, LogRecordExporter> 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<LogExporter> spiExportersManager,
|
||||
NamedSpiManager<LogRecordExporter> 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() {}
|
||||
}
|
||||
|
|
@ -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<? super LogExporter, ConfigProperties, ? extends LogExporter>
|
||||
logExporterCustomizer) {
|
||||
BiFunction<? super LogRecordExporter, ConfigProperties, ? extends LogRecordExporter>
|
||||
logRecordExporterCustomizer) {
|
||||
|
||||
loggerProviderBuilder.setLogLimits(() -> configureLogLimits(config));
|
||||
|
||||
Map<String, LogExporter> exportersByName =
|
||||
configureLogExporters(config, serviceClassLoader, meterProvider, logExporterCustomizer);
|
||||
Map<String, LogRecordExporter> exportersByName =
|
||||
configureLogRecordExporters(
|
||||
config, serviceClassLoader, meterProvider, logRecordExporterCustomizer);
|
||||
|
||||
configureLogProcessors(exportersByName, meterProvider)
|
||||
.forEach(loggerProviderBuilder::addLogProcessor);
|
||||
|
|
@ -43,19 +44,22 @@ final class LoggerProviderConfiguration {
|
|||
|
||||
// Visible for testing
|
||||
static List<LogProcessor> configureLogProcessors(
|
||||
Map<String, LogExporter> exportersByName, MeterProvider meterProvider) {
|
||||
Map<String, LogExporter> exportersByNameCopy = new HashMap<>(exportersByName);
|
||||
Map<String, LogRecordExporter> exportersByName, MeterProvider meterProvider) {
|
||||
Map<String, LogRecordExporter> exportersByNameCopy = new HashMap<>(exportersByName);
|
||||
List<LogProcessor> 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;
|
||||
|
|
|
|||
|
|
@ -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() {
|
||||
|
|
|
|||
|
|
@ -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()))
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<String, LogExporter> exportersByName =
|
||||
LogExporterConfiguration.configureLogExporters(
|
||||
Map<String, LogRecordExporter> 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(),
|
||||
|
|
@ -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<LogData> logs) {
|
||||
Collection<LogData> filtered =
|
||||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
@ -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");
|
||||
}
|
||||
|
||||
|
|
@ -1,3 +1,3 @@
|
|||
io.opentelemetry.sdk.autoconfigure.SpanExporterCustomizer
|
||||
io.opentelemetry.sdk.autoconfigure.MetricCustomizer
|
||||
io.opentelemetry.sdk.autoconfigure.LogExporterCustomizer
|
||||
io.opentelemetry.sdk.autoconfigure.LogRecordExporterCustomizer
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
io.opentelemetry.sdk.autoconfigure.TestConfigurableLogExporterProvider
|
||||
io.opentelemetry.sdk.autoconfigure.ThrowingConfigurableLogExporterProvider
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
io.opentelemetry.sdk.autoconfigure.TestConfigurableLogRecordExporterProvider
|
||||
io.opentelemetry.sdk.autoconfigure.ThrowingConfigurableLogRecordExporterProvider
|
||||
|
|
@ -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<String, String> 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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<String, String> 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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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<String, String> 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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<String, String> 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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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<LogData> batch;
|
||||
|
||||
private Worker(
|
||||
LogExporter logExporter,
|
||||
LogRecordExporter logRecordExporter,
|
||||
MeterProvider meterProvider,
|
||||
long scheduleDelayNanos,
|
||||
int maxExportBatchSize,
|
||||
long exporterTimeoutNanos,
|
||||
Queue<ReadWriteLogRecord> 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);
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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<LogData> 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.
|
||||
*
|
||||
* <p>Any subsequent call to export() function on this LogExporter, will return {@code
|
||||
* <p>Any subsequent call to export() function on this exporter, will return {@code
|
||||
* CompletableResultCode.ofFailure()}
|
||||
*/
|
||||
@Override
|
||||
|
|
@ -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.
|
||||
*
|
||||
* <p>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.
|
||||
*
|
||||
* <p>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<LogExporter> exporters) {
|
||||
List<LogExporter> exportersList = new ArrayList<>();
|
||||
for (LogExporter exporter : exporters) {
|
||||
static LogRecordExporter composite(Iterable<LogRecordExporter> exporters) {
|
||||
List<LogRecordExporter> 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);
|
||||
|
|
@ -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}.
|
||||
*
|
||||
* <p>Can be used to export to multiple backends using the same {@link LogExporter} like a {@link
|
||||
* SimpleLogProcessor} or a {@link BatchLogProcessor}.
|
||||
* <p>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<LogExporter> logExporters) {
|
||||
return new MultiLogExporter(logExporters.toArray(new LogExporter[0]));
|
||||
static LogRecordExporter create(List<LogRecordExporter> logRecordExporters) {
|
||||
return new MultiLogRecordExporter(logRecordExporters.toArray(new LogRecordExporter[0]));
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletableResultCode export(Collection<LogData> logs) {
|
||||
List<CompletableResultCode> results = new ArrayList<>(logExporters.length);
|
||||
for (LogExporter logExporter : logExporters) {
|
||||
List<CompletableResultCode> 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<CompletableResultCode> results = new ArrayList<>(logExporters.length);
|
||||
for (LogExporter logExporter : logExporters) {
|
||||
List<CompletableResultCode> 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<CompletableResultCode> results = new ArrayList<>(logExporters.length);
|
||||
for (LogExporter logExporter : logExporters) {
|
||||
List<CompletableResultCode> 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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
@ -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<CompletableResultCode> 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.
|
||||
*
|
||||
* <p>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<LogData> 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()) {
|
||||
|
|
|
|||
|
|
@ -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<LogData> exported = waitingLogExporter.waitForExport();
|
||||
List<LogData> 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<LogData> exported = waitingLogExporter.waitForExport();
|
||||
List<LogData> 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<LogData> exported1 = waitingLogExporter1.waitForExport();
|
||||
List<LogData> exported2 = waitingLogExporter2.waitForExport();
|
||||
List<LogData> exported1 = waitingLogRecordExporter1.waitForExport();
|
||||
List<LogData> 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<LogData> exported = waitingLogExporter.waitForExport();
|
||||
List<LogData> 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<LogData> exported = waitingLogExporter.waitForExport();
|
||||
List<LogData> 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<LogData> exported = waitingLogExporter.getExported();
|
||||
List<LogData> 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<CompletableResultCode> results = new ArrayList<>();
|
||||
|
||||
|
|
@ -508,7 +513,7 @@ class BatchLogProcessorTest {
|
|||
}
|
||||
}
|
||||
|
||||
static class WaitingLogExporter implements LogExporter {
|
||||
static class WaitingLogRecordExporter implements LogRecordExporter {
|
||||
|
||||
private final List<LogData> 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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
@ -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<LogData> 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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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<LogData> 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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue