diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt index f2331f45543..70abce9cb4c 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-logging-otlp.txt @@ -1,2 +1,11 @@ Comparing source compatibility of opentelemetry-exporter-logging-otlp-1.42.0-SNAPSHOT.jar against opentelemetry-exporter-logging-otlp-1.41.0.jar -No changes. \ No newline at end of file +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) java.lang.String toString() +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingMetricExporter (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.metrics.Aggregation getDefaultAggregation(io.opentelemetry.sdk.metrics.InstrumentType) + +++ NEW METHOD: PUBLIC(+) java.lang.String toString() +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingSpanExporter (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) java.lang.String toString() diff --git a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingMetricExporter.java b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingMetricExporter.java index 89145e43585..4a9d740c54a 100644 --- a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingMetricExporter.java +++ b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/OtlpJsonLoggingMetricExporter.java @@ -186,6 +186,12 @@ public String toString() { joiner.add("memoryMode=" + memoryMode); joiner.add("wrapperJsonObject=" + wrapperJsonObject); joiner.add("jsonWriter=" + jsonWriter); + joiner.add( + "aggregationTemporalitySelector=" + + AggregationTemporalitySelector.asString(aggregationTemporalitySelector)); + joiner.add( + "defaultAggregationSelector=" + + DefaultAggregationSelector.asString(defaultAggregationSelector)); return joiner.toString(); } } diff --git a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/logs/OtlpStdoutLogRecordExporterProvider.java b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/logs/OtlpStdoutLogRecordExporterProvider.java index 76544e1da65..9d9e0f52cd5 100644 --- a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/logs/OtlpStdoutLogRecordExporterProvider.java +++ b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/logs/OtlpStdoutLogRecordExporterProvider.java @@ -5,6 +5,7 @@ package io.opentelemetry.exporter.logging.otlp.internal.logs; +import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider; import io.opentelemetry.sdk.logs.export.LogRecordExporter; @@ -18,7 +19,9 @@ public class OtlpStdoutLogRecordExporterProvider implements ConfigurableLogRecordExporterProvider { @Override public LogRecordExporter createExporter(ConfigProperties config) { - return OtlpStdoutLogRecordExporter.create(); + OtlpJsonLoggingLogRecordExporterBuilder builder = OtlpStdoutLogRecordExporter.builder(); + ExporterBuilderUtil.configureExporterMemoryMode(config, builder::setMemoryMode); + return builder.build(); } @Override diff --git a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/metrics/OtlpStdoutMetricExporterProvider.java b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/metrics/OtlpStdoutMetricExporterProvider.java index ea6722d84fb..2e6c7bd59ae 100644 --- a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/metrics/OtlpStdoutMetricExporterProvider.java +++ b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/metrics/OtlpStdoutMetricExporterProvider.java @@ -5,6 +5,7 @@ package io.opentelemetry.exporter.logging.otlp.internal.metrics; +import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider; import io.opentelemetry.sdk.metrics.export.MetricExporter; @@ -18,7 +19,13 @@ public class OtlpStdoutMetricExporterProvider implements ConfigurableMetricExporterProvider { @Override public MetricExporter createExporter(ConfigProperties config) { - return OtlpStdoutMetricExporter.create(); + OtlpJsonLoggingMetricExporterBuilder builder = OtlpStdoutMetricExporter.builder(); + ExporterBuilderUtil.configureExporterMemoryMode(config, builder::setMemoryMode); + ExporterBuilderUtil.configureOtlpAggregationTemporality( + config, builder::setAggregationTemporalitySelector); + ExporterBuilderUtil.configureOtlpHistogramDefaultAggregation( + config, builder::setDefaultAggregationSelector); + return builder.build(); } @Override diff --git a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/trace/OtlpStdoutSpanExporterProvider.java b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/trace/OtlpStdoutSpanExporterProvider.java index 79471dcdd1c..15dc9272d8e 100644 --- a/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/trace/OtlpStdoutSpanExporterProvider.java +++ b/exporters/logging-otlp/src/main/java/io/opentelemetry/exporter/logging/otlp/internal/trace/OtlpStdoutSpanExporterProvider.java @@ -5,6 +5,7 @@ package io.opentelemetry.exporter.logging.otlp.internal.trace; +import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider; import io.opentelemetry.sdk.trace.export.SpanExporter; @@ -18,7 +19,9 @@ public class OtlpStdoutSpanExporterProvider implements ConfigurableSpanExporterProvider { @Override public SpanExporter createExporter(ConfigProperties config) { - return OtlpStdoutSpanExporter.create(); + OtlpJsonLoggingSpanExporterBuilder builder = OtlpStdoutSpanExporter.builder(); + ExporterBuilderUtil.configureExporterMemoryMode(config, builder::setMemoryMode); + return builder.build(); } @Override diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpJsonLoggingExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpJsonLoggingExporterTest.java index 56ef98387c1..2c7efab6133 100644 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpJsonLoggingExporterTest.java +++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/AbstractOtlpJsonLoggingExporterTest.java @@ -5,13 +5,18 @@ package io.opentelemetry.exporter.logging.otlp; +import static java.util.Collections.emptyMap; +import static java.util.Collections.singletonMap; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatCode; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Streams; import com.google.common.io.Resources; import io.github.netmikey.logunit.api.LogCapturer; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; +import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties; import io.opentelemetry.sdk.autoconfigure.spi.internal.StructuredConfigProperties; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.common.export.MemoryMode; @@ -22,6 +27,9 @@ import java.io.PrintStream; import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Map; +import java.util.ServiceLoader; import java.util.concurrent.TimeUnit; import java.util.stream.Stream; import javax.annotation.Nullable; @@ -49,15 +57,29 @@ abstract class AbstractOtlpJsonLoggingExporterTest { private final Class exporterClass; @RegisterExtension LogCapturer logs; + private final String defaultConfigString; + private final Class providerClass; + + @SuppressWarnings("unused") + private final Class componentProviderType; // todo remove once used + private final String expectedFileNoWrapper; private final String expectedFileWrapper; public AbstractOtlpJsonLoggingExporterTest( - Class exporterClass, String expectedFileNoWrapper, String expectedFileWrapper) { + Class exporterClass, + Class providerClass, + Class componentProviderType, + String expectedFileNoWrapper, + String expectedFileWrapper, + String defaultConfigString) { this.exporterClass = exporterClass; - logs = LogCapturer.create().captureForType(exporterClass); + this.providerClass = providerClass; + this.componentProviderType = componentProviderType; this.expectedFileNoWrapper = expectedFileNoWrapper; this.expectedFileWrapper = expectedFileWrapper; + logs = LogCapturer.create().captureForType(exporterClass); + this.defaultConfigString = defaultConfigString; } protected abstract T createExporter( @@ -67,19 +89,21 @@ protected abstract T createExporter( protected abstract T createDefaultStdoutExporter(); - protected abstract T createExporterWithProperties(ConfigProperties properties); - - protected abstract T createStdoutExporterWithProperties(ConfigProperties properties); - - protected abstract T createStdoutExporterWithStructuredProperties( - StructuredConfigProperties properties); - protected abstract T toBuilderAndBack(T exporter); protected abstract CompletableResultCode export(T exporter); protected abstract CompletableResultCode shutdown(T exporter); + protected Map> stdoutConfigPropertiesTestCases() { + return emptyMap(); + } + + protected Map> + stdoutStructuredPropertiesTestCases() { + return emptyMap(); + } + private String output(@Nullable OutputStream outputStream) { if (outputStream == null) { return logs.getEvents().stream() @@ -168,7 +192,8 @@ public static Stream exportTestCases() { @ParameterizedTest(name = "{0}") @MethodSource("exportTestCases") - void testExport(String name, TestCase testCase) throws JSONException, IOException { + void exportWithProgrammaticConfig(String name, TestCase testCase) + throws JSONException, IOException { setUp(); if (testCase.getMemoryMode() == MemoryMode.REUSABLE_DATA && !testCase.isWrapperJsonObject()) { @@ -203,22 +228,6 @@ void testExport(String name, TestCase testCase) throws JSONException, IOExceptio } } - @Test - void config() { - assertToString( - createDefaultExporter(), - "{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=false, jsonWriter=LoggerJsonWriter}"); - assertToString( - createDefaultStdoutExporter(), - "{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=true, jsonWriter=StreamJsonWriter{outputStream=stdout}}"); - } - - private void assertToString(T exporter, String expected) { - assertThat(exporter.toString()).isEqualTo(exporterClass.getSimpleName() + expected); - assertThat(toBuilderAndBack(exporter).toString()) - .isEqualTo(exporterClass.getSimpleName() + expected); - } - @Test void testShutdown() { T exporter = createDefaultExporter(); @@ -228,4 +237,128 @@ void testShutdown() { assertThat(shutdown(exporter).isSuccess()).isTrue(); logs.assertContains("Calling shutdown() multiple times."); } + + @Test + void loggingOtlpProviderConfig() { + assertFullToString(createDefaultExporter(), defaultConfigString); + + assertFullToString( + loadExporter(DefaultConfigProperties.createFromMap(emptyMap()), "logging-otlp"), + defaultConfigString); + } + + @Test + void stdoutProviderConfig() { + assertToStringProperties( + createDefaultStdoutExporter(), + ImmutableMap.of( + "memoryMode", "IMMUTABLE_DATA", + "wrapperJsonObject", "true", + "jsonWriter", "StreamJsonWriter{outputStream=stdout}")); + + assertToStringProperties( + loadExporter(DefaultConfigProperties.createFromMap(emptyMap()), "otlp-stdout"), + ImmutableMap.of( + "memoryMode", "IMMUTABLE_DATA", + "wrapperJsonObject", "true", + "jsonWriter", "StreamJsonWriter{outputStream=stdout}")); + + assertToStringProperties( + loadExporter( + DefaultConfigProperties.createFromMap( + singletonMap("otel.java.experimental.exporter.memory_mode", "reusable_data")), + "otlp-stdout"), + ImmutableMap.of("memoryMode", "REUSABLE_DATA")); + + stdoutConfigPropertiesTestCases() + .forEach( + (config, expected) -> { + assertToStringProperties(loadExporter(config, "otlp-stdout"), expected); + }); + } + + @Test + void stdoutComponentProviderConfig() { + // ComponentProvider provider = (ComponentProvider) + // loadSpi(ComponentProvider.class).filter( + // p -> { + // ComponentProvider c = (ComponentProvider) p; + // return "otlp-stdout".equals(c.getName()) && c.getType() + // .equals(componentProviderType); + // }).findFirst().orElseThrow(() -> new IllegalStateException("No provider found")); + + // todo: implement DefaultStructuredConfigProperties + + // assertToString( + // provider.create(DefaultStructuredConfigProperties.createFromMap(emptyMap())), + // loadExporter(DefaultConfigProperties.createFromMap(emptyMap()), "otlp-stdout"), + // "{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=true, + // jsonWriter=StreamJsonWriter{outputStream=stdout}}"); + // + // assertToString( + // provider.create((DefaultStructuredConfigProperties.createFromMap(singletonMap( + // "memory_mode", "reusable_data" + // )), "otlp-stdout"), + // "{memoryMode=REUSABLE_DATA, wrapperJsonObject=true, + // jsonWriter=StreamJsonWriter{outputStream=stdout}}"); + // + // stdoutStructuredPropertiesTestCases().forEach( + // (config, expected) -> { + // assertToString( + // (T) provider.create(config), + // expected); + // }); + } + + @SuppressWarnings("unchecked") + private T loadExporter(ConfigProperties config, String name) { + Object provider = loadProvider(name); + + try { + return (T) + provider + .getClass() + .getDeclaredMethod("createExporter", ConfigProperties.class) + .invoke(provider, config); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + private Object loadProvider(String want) { + return loadSpi(providerClass) + .filter( + p -> { + try { + return want.equals(p.getClass().getDeclaredMethod("getName").invoke(p)); + } catch (Exception e) { + throw new RuntimeException(e); + } + }) + .findFirst() + .orElseThrow(() -> new IllegalStateException("No provider found")); + } + + private static Stream loadSpi(Class type) { + return Streams.stream(ServiceLoader.load(type, type.getClassLoader()).iterator()); + } + + private void assertFullToString(T exporter, String expected) { + assertThat(exporter.toString()).isEqualTo(expected); + assertThat(toBuilderAndBack(exporter).toString()).isEqualTo(expected); + } + + private void assertToStringProperties(T exporter, Map expected) { + String exporterString = exporter.toString(); + Map got = new HashMap<>(); + for (String entry : + exporterString + .substring(exporterClass.getSimpleName().length() + 1, exporterString.length() - 1) + .split(", ")) { + String[] split = entry.split("=", 2); + got.put(split[0], split[1]); + } + assertThat(got).containsAllEntriesOf(expected); + assertThat(toBuilderAndBack(exporter).toString()).isEqualTo(exporterString); + } } diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutLogRecordExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/LogRecordExporterTest.java similarity index 75% rename from exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutLogRecordExporterTest.java rename to exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/LogRecordExporterTest.java index a892fd077a4..05e7df1d63d 100644 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutLogRecordExporterTest.java +++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/LogRecordExporterTest.java @@ -14,18 +14,15 @@ import io.opentelemetry.api.trace.SpanContext; import io.opentelemetry.api.trace.TraceFlags; import io.opentelemetry.api.trace.TraceState; -import io.opentelemetry.exporter.logging.otlp.internal.logs.LoggingLogRecordExporterProvider; import io.opentelemetry.exporter.logging.otlp.internal.logs.OtlpJsonLoggingLogRecordExporterBuilder; import io.opentelemetry.exporter.logging.otlp.internal.logs.OtlpStdoutLogRecordExporter; -import io.opentelemetry.exporter.logging.otlp.internal.logs.OtlpStdoutLogRecordExporterComponentProvider; -import io.opentelemetry.exporter.logging.otlp.internal.logs.OtlpStdoutLogRecordExporterProvider; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; -import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; -import io.opentelemetry.sdk.autoconfigure.spi.internal.StructuredConfigProperties; +import io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.common.export.MemoryMode; import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; import io.opentelemetry.sdk.testing.logs.TestLogRecordData; import java.io.OutputStream; import java.util.Arrays; @@ -33,7 +30,7 @@ import javax.annotation.Nullable; @SuppressLogger(OtlpJsonLoggingLogRecordExporter.class) -class OtlpStdoutLogRecordExporterTest +class LogRecordExporterTest extends AbstractOtlpJsonLoggingExporterTest { private static final LogRecordData LOG1 = @@ -77,9 +74,14 @@ class OtlpStdoutLogRecordExporterTest TraceState.getDefault())) .build(); - public OtlpStdoutLogRecordExporterTest() { + public LogRecordExporterTest() { super( - OtlpJsonLoggingLogRecordExporter.class, "expected-logs.json", "expected-logs-wrapper.json"); + OtlpJsonLoggingLogRecordExporter.class, + ConfigurableLogRecordExporterProvider.class, + LogRecordExporter.class, + "expected-logs.json", + "expected-logs-wrapper.json", + "OtlpJsonLoggingLogRecordExporter{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=false, jsonWriter=LoggerJsonWriter}"); } @Override @@ -105,27 +107,6 @@ protected OtlpJsonLoggingLogRecordExporter createDefaultStdoutExporter() { return OtlpStdoutLogRecordExporter.create(); } - @Override - protected OtlpJsonLoggingLogRecordExporter createExporterWithProperties( - ConfigProperties properties) { - return (OtlpJsonLoggingLogRecordExporter) - new LoggingLogRecordExporterProvider().createExporter(properties); - } - - @Override - protected OtlpJsonLoggingLogRecordExporter createStdoutExporterWithProperties( - ConfigProperties properties) { - return (OtlpJsonLoggingLogRecordExporter) - new OtlpStdoutLogRecordExporterProvider().createExporter(properties); - } - - @Override - protected OtlpJsonLoggingLogRecordExporter createStdoutExporterWithStructuredProperties( - StructuredConfigProperties properties) { - return (OtlpJsonLoggingLogRecordExporter) - new OtlpStdoutLogRecordExporterComponentProvider().create(properties); - } - @Override protected OtlpJsonLoggingLogRecordExporter toBuilderAndBack( OtlpJsonLoggingLogRecordExporter exporter) { diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutMetricExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/MetricExporterTest.java similarity index 70% rename from exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutMetricExporterTest.java rename to exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/MetricExporterTest.java index e680f6944d8..18880c007c7 100644 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutMetricExporterTest.java +++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/MetricExporterTest.java @@ -13,6 +13,10 @@ import io.opentelemetry.exporter.logging.otlp.internal.metrics.OtlpJsonLoggingMetricExporterBuilder; import io.opentelemetry.exporter.logging.otlp.internal.metrics.OtlpStdoutMetricExporter; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; +import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; +import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties; +import io.opentelemetry.sdk.autoconfigure.spi.internal.StructuredConfigProperties; +import io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.common.export.MemoryMode; @@ -22,16 +26,20 @@ import io.opentelemetry.sdk.metrics.data.MetricData; import io.opentelemetry.sdk.metrics.export.AggregationTemporalitySelector; import io.opentelemetry.sdk.metrics.export.DefaultAggregationSelector; +import io.opentelemetry.sdk.metrics.export.MetricExporter; import io.opentelemetry.sdk.metrics.internal.data.ImmutableDoublePointData; import io.opentelemetry.sdk.metrics.internal.data.ImmutableMetricData; import io.opentelemetry.sdk.metrics.internal.data.ImmutableSumData; import java.io.OutputStream; import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import javax.annotation.Nullable; import org.junit.jupiter.api.Test; @SuppressLogger(OtlpJsonLoggingMetricExporter.class) -class OtlpStdoutMetricExporterTest +class MetricExporterTest extends AbstractOtlpJsonLoggingExporterTest { private static final MetricData METRIC1 = @@ -65,11 +73,14 @@ class OtlpStdoutMetricExporterTest ImmutableDoublePointData.create( 1, 2, Attributes.of(stringKey("cat"), "meow"), 4)))); - public OtlpStdoutMetricExporterTest() { + public MetricExporterTest() { super( OtlpJsonLoggingMetricExporter.class, + ConfigurableMetricExporterProvider.class, + MetricExporter.class, "expected-metrics.json", - "expected-metrics-wrapper.json"); + "expected-metrics-wrapper.json", + "OtlpJsonLoggingMetricExporter{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=false, jsonWriter=LoggerJsonWriter, aggregationTemporalitySelector=AggregationTemporalitySelector{COUNTER=CUMULATIVE, UP_DOWN_COUNTER=CUMULATIVE, HISTOGRAM=CUMULATIVE, OBSERVABLE_COUNTER=CUMULATIVE, OBSERVABLE_UP_DOWN_COUNTER=CUMULATIVE, OBSERVABLE_GAUGE=CUMULATIVE, GAUGE=CUMULATIVE}, defaultAggregationSelector=DefaultAggregationSelector{COUNTER=default, UP_DOWN_COUNTER=default, HISTOGRAM=default, OBSERVABLE_COUNTER=default, OBSERVABLE_UP_DOWN_COUNTER=default, OBSERVABLE_GAUGE=default, GAUGE=default}}"); } @Override @@ -110,6 +121,32 @@ protected CompletableResultCode shutdown(OtlpJsonLoggingMetricExporter exporter) return exporter.shutdown(); } + @Override + protected Map> stdoutConfigPropertiesTestCases() { + Map> cases = new HashMap<>(); + cases.put( + DefaultConfigProperties.createFromMap( + Collections.singletonMap("otel.exporter.otlp.metrics.temporality.preference", "DELTA")), + Collections.singletonMap( + "aggregationTemporalitySelector", "AggregationTemporalitySelector{COUNTER=DELTA")); + cases.put( + DefaultConfigProperties.createFromMap( + Collections.singletonMap( + "otel.exporter.otlp.metrics.default.histogram.aggregation", + "BASE2_EXPONENTIAL_BUCKET_HISTOGRAM")), + Collections.singletonMap("HISTOGRAM", "base2_exponential_bucket_histogram")); + return cases; + } + + @Override + protected Map> + stdoutStructuredPropertiesTestCases() { + // todo: implement this + // default_histogram_aggregation + // temporality_preference + return Collections.emptyMap(); + } + /** Test configuration specific to metric exporter. */ @Test void validMetricConfig() { diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutSpanExporterTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/SpanExporterTest.java similarity index 88% rename from exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutSpanExporterTest.java rename to exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/SpanExporterTest.java index 18385008bfa..0037cc48783 100644 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/OtlpStdoutSpanExporterTest.java +++ b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/SpanExporterTest.java @@ -17,6 +17,7 @@ import io.opentelemetry.exporter.logging.otlp.internal.trace.OtlpJsonLoggingSpanExporterBuilder; import io.opentelemetry.exporter.logging.otlp.internal.trace.OtlpStdoutSpanExporter; import io.opentelemetry.internal.testing.slf4j.SuppressLogger; +import io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.common.export.MemoryMode; @@ -24,14 +25,14 @@ import io.opentelemetry.sdk.trace.data.EventData; import io.opentelemetry.sdk.trace.data.SpanData; import io.opentelemetry.sdk.trace.data.StatusData; +import io.opentelemetry.sdk.trace.export.SpanExporter; import java.io.OutputStream; import java.util.Arrays; import java.util.Collections; import javax.annotation.Nullable; @SuppressLogger(OtlpJsonLoggingSpanExporter.class) -class OtlpStdoutSpanExporterTest - extends AbstractOtlpJsonLoggingExporterTest { +class SpanExporterTest extends AbstractOtlpJsonLoggingExporterTest { private static final SpanData SPAN1 = TestSpanData.builder() @@ -84,8 +85,14 @@ class OtlpStdoutSpanExporterTest InstrumentationScopeInfo.builder("instrumentation2").setVersion("2").build()) .build(); - public OtlpStdoutSpanExporterTest() { - super(OtlpJsonLoggingSpanExporter.class, "expected-spans.json", "expected-spans-wrapper.json"); + public SpanExporterTest() { + super( + OtlpJsonLoggingSpanExporter.class, + ConfigurableSpanExporterProvider.class, + SpanExporter.class, + "expected-spans.json", + "expected-spans-wrapper.json", + "OtlpJsonLoggingSpanExporter{memoryMode=IMMUTABLE_DATA, wrapperJsonObject=false, jsonWriter=LoggerJsonWriter}"); } @Override diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/LoggingExporterProviderTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/LoggingExporterProviderTest.java deleted file mode 100644 index 15214fb6d93..00000000000 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/LoggingExporterProviderTest.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.exporter.logging.otlp.internal; - -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; - -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter; -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingMetricExporter; -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingSpanExporter; -import io.opentelemetry.exporter.logging.otlp.internal.logs.LoggingLogRecordExporterProvider; -import io.opentelemetry.exporter.logging.otlp.internal.metrics.LoggingMetricExporterProvider; -import io.opentelemetry.exporter.logging.otlp.internal.trace.LoggingSpanExporterProvider; -import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties; -import java.util.Collections; -import org.junit.jupiter.api.Test; - -class LoggingExporterProviderTest { - - @Test - void logRecordExporterProvider() { - LoggingLogRecordExporterProvider provider = new LoggingLogRecordExporterProvider(); - assertThat(provider.getName()).isEqualTo("logging-otlp"); - assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingLogRecordExporter.class); - } - - @Test - void metricExporterProvider() { - LoggingMetricExporterProvider provider = new LoggingMetricExporterProvider(); - assertThat(provider.getName()).isEqualTo("logging-otlp"); - assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingMetricExporter.class); - } - - @Test - void spanExporterProvider() { - LoggingSpanExporterProvider provider = new LoggingSpanExporterProvider(); - assertThat(provider.getName()).isEqualTo("logging-otlp"); - assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingSpanExporter.class); - } -} diff --git a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/OtlpStdoutExporterProviderTest.java b/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/OtlpStdoutExporterProviderTest.java deleted file mode 100644 index d91703b81c0..00000000000 --- a/exporters/logging-otlp/src/test/java/io/opentelemetry/exporter/logging/otlp/internal/OtlpStdoutExporterProviderTest.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.exporter.logging.otlp.internal; - -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; - -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter; -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingMetricExporter; -import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingSpanExporter; -import io.opentelemetry.exporter.logging.otlp.internal.logs.OtlpStdoutLogRecordExporterProvider; -import io.opentelemetry.exporter.logging.otlp.internal.metrics.OtlpStdoutMetricExporterProvider; -import io.opentelemetry.exporter.logging.otlp.internal.trace.OtlpStdoutSpanExporterProvider; -import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties; -import java.util.Collections; -import org.assertj.core.api.Assertions; -import org.junit.jupiter.api.Test; - -class OtlpStdoutExporterProviderTest { - - @Test - void logRecordExporterProvider() { - OtlpStdoutLogRecordExporterProvider provider = new OtlpStdoutLogRecordExporterProvider(); - Assertions.assertThat(provider.getName()).isEqualTo("otlp-stdout"); - Assertions.assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingLogRecordExporter.class); - } - - @Test - void metricExporterProvider() { - OtlpStdoutMetricExporterProvider provider = new OtlpStdoutMetricExporterProvider(); - assertThat(provider.getName()).isEqualTo("otlp-stdout"); - assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingMetricExporter.class); - // todo metric exporter does not have any configuration - } - - @Test - void spanExporterProvider() { - OtlpStdoutSpanExporterProvider provider = new OtlpStdoutSpanExporterProvider(); - assertThat(provider.getName()).isEqualTo("otlp-stdout"); - assertThat( - provider.createExporter(DefaultConfigProperties.createFromMap(Collections.emptyMap()))) - .isInstanceOf(OtlpJsonLoggingSpanExporter.class); - } -} diff --git a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProviderTest.java b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProviderTest.java index 2f882b3ebfd..bab89d8a69a 100644 --- a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProviderTest.java +++ b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProviderTest.java @@ -30,6 +30,7 @@ import java.util.Collections; import java.util.HashMap; import java.util.Map; +import org.assertj.core.api.AbstractObjectAssert; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -128,11 +129,15 @@ void createExporter_GrpcDefaults() { verify(grpcBuilder, never()).setTrustedCertificates(any()); verify(grpcBuilder, never()).setClientTls(any(), any()); assertThat(grpcBuilder).extracting("delegate").extracting("retryPolicy").isNotNull(); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.IMMUTABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.IMMUTABLE_DATA); } Mockito.verifyNoInteractions(httpBuilder); } + private static AbstractObjectAssert getMemoryMode(LogRecordExporter exporter) { + return assertThat(exporter).extracting("marshaler").extracting("memoryMode"); + } + @Test void createExporter_GrpcWithGeneralConfiguration() throws CertificateEncodingException { Map config = new HashMap<>(); @@ -191,7 +196,7 @@ void createExporter_GrpcWithSignalConfiguration() throws CertificateEncodingExce verify(grpcBuilder).setTrustedCertificates(serverTls.certificate().getEncoded()); verify(grpcBuilder) .setClientTls(clientTls.privateKey().getEncoded(), clientTls.certificate().getEncoded()); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.REUSABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.REUSABLE_DATA); } Mockito.verifyNoInteractions(httpBuilder); } @@ -211,7 +216,7 @@ void createExporter_HttpDefaults() { verify(httpBuilder, never()).setTrustedCertificates(any()); verify(httpBuilder, never()).setClientTls(any(), any()); assertThat(httpBuilder).extracting("delegate").extracting("retryPolicy").isNotNull(); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.IMMUTABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.IMMUTABLE_DATA); } Mockito.verifyNoInteractions(grpcBuilder); } @@ -277,7 +282,7 @@ void createExporter_HttpWithSignalConfiguration() throws CertificateEncodingExce verify(httpBuilder).setTrustedCertificates(serverTls.certificate().getEncoded()); verify(httpBuilder) .setClientTls(clientTls.privateKey().getEncoded(), clientTls.certificate().getEncoded()); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.REUSABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.REUSABLE_DATA); } Mockito.verifyNoInteractions(grpcBuilder); } diff --git a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProviderTest.java b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProviderTest.java index 06d39054a0f..084826d47ff 100644 --- a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProviderTest.java +++ b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProviderTest.java @@ -30,6 +30,7 @@ import java.util.Collections; import java.util.HashMap; import java.util.Map; +import org.assertj.core.api.AbstractObjectAssert; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -129,11 +130,15 @@ void createExporter_GrpcDefaults() { verify(grpcBuilder, never()).setTrustedCertificates(any()); verify(grpcBuilder, never()).setClientTls(any(), any()); assertThat(grpcBuilder).extracting("delegate").extracting("retryPolicy").isNotNull(); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.IMMUTABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.IMMUTABLE_DATA); } Mockito.verifyNoInteractions(httpBuilder); } + private static AbstractObjectAssert getMemoryMode(SpanExporter exporter) { + return assertThat(exporter).extracting("marshaler").extracting("memoryMode"); + } + @Test void createExporter_GrpcWithGeneralConfiguration() throws CertificateEncodingException { Map config = new HashMap<>(); @@ -192,7 +197,7 @@ void createExporter_GrpcWithSignalConfiguration() throws CertificateEncodingExce verify(grpcBuilder).setTrustedCertificates(serverTls.certificate().getEncoded()); verify(grpcBuilder) .setClientTls(clientTls.privateKey().getEncoded(), clientTls.certificate().getEncoded()); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.REUSABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.REUSABLE_DATA); } Mockito.verifyNoInteractions(httpBuilder); } @@ -212,7 +217,7 @@ void createExporter_HttpDefaults() { verify(httpBuilder, never()).setTrustedCertificates(any()); verify(httpBuilder, never()).setClientTls(any(), any()); assertThat(httpBuilder).extracting("delegate").extracting("retryPolicy").isNotNull(); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.IMMUTABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.IMMUTABLE_DATA); } Mockito.verifyNoInteractions(grpcBuilder); } @@ -244,7 +249,7 @@ void createExporter_HttpWithGeneralConfiguration() throws CertificateEncodingExc verify(httpBuilder) .setClientTls(clientTls.privateKey().getEncoded(), clientTls.certificate().getEncoded()); assertThat(httpBuilder).extracting("delegate").extracting("retryPolicy").isNull(); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.IMMUTABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.IMMUTABLE_DATA); } Mockito.verifyNoInteractions(grpcBuilder); } @@ -281,7 +286,7 @@ void createExporter_HttpWithSignalConfiguration() throws CertificateEncodingExce verify(httpBuilder).setTrustedCertificates(serverTls.certificate().getEncoded()); verify(httpBuilder) .setClientTls(clientTls.privateKey().getEncoded(), clientTls.certificate().getEncoded()); - assertThat(exporter).extracting("memoryMode").isEqualTo(MemoryMode.REUSABLE_DATA); + getMemoryMode(exporter).isEqualTo(MemoryMode.REUSABLE_DATA); } Mockito.verifyNoInteractions(grpcBuilder); }