From f89edd9463d4faefbb3fcd5f86508e2f39a834c0 Mon Sep 17 00:00:00 2001 From: Teja Date: Tue, 17 Jun 2025 22:52:47 -0400 Subject: [PATCH 1/2] wip: fix for solving class loader error in compressionutil api. --- .../internal/compression/CompressorUtil.java | 30 +++++++++++++++---- .../OtlpHttpLogRecordExporterBuilder.java | 5 +++- .../OtlpHttpMetricExporterBuilder.java | 5 +++- .../trace/OtlpHttpSpanExporterBuilder.java | 5 +++- .../OtlpGrpcLogRecordExporterBuilder.java | 5 +++- .../OtlpGrpcMetricExporterBuilder.java | 5 +++- .../trace/OtlpGrpcSpanExporterBuilder.java | 5 +++- .../OtlpGrpcProfilesExporterBuilder.java | 5 +++- 8 files changed, 52 insertions(+), 13 deletions(-) diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/compression/CompressorUtil.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/compression/CompressorUtil.java index 9748ea508ad..ef4785ae6cd 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/compression/CompressorUtil.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/compression/CompressorUtil.java @@ -24,7 +24,8 @@ */ public final class CompressorUtil { - private static final Map compressorRegistry = buildCompressorRegistry(); + private static final Map compressorRegistry = + buildCompressorRegistry(CompressorUtil.class.getClassLoader()); private CompressorUtil() {} @@ -36,8 +37,26 @@ private CompressorUtil() {} */ @Nullable public static Compressor validateAndResolveCompressor(String compressionMethod) { - Set supportedEncodings = compressorRegistry.keySet(); - Compressor compressor = compressorRegistry.get(compressionMethod); + return validateAndResolveCompressor(compressionMethod, null); + } + + /** + * Validate that the {@code compressionMethod} is "none" or matches a registered compressor. + * + * @param compressionMethod the compression method to validate and resolve + * @param classLoader the class loader to use for loading SPI implementations, or null to use the + * default + * @return {@code null} if {@code compressionMethod} is "none" or the registered compressor + * @throws IllegalArgumentException if no match is found + */ + @Nullable + public static Compressor validateAndResolveCompressor( + String compressionMethod, @Nullable ClassLoader classLoader) { + Map registry = + classLoader == null ? compressorRegistry : buildCompressorRegistry(classLoader); + + Set supportedEncodings = registry.keySet(); + Compressor compressor = registry.get(compressionMethod); checkArgument( "none".equals(compressionMethod) || compressor != null, "Unsupported compressionMethod. Compression method must be \"none\" or one of: " @@ -45,10 +64,9 @@ public static Compressor validateAndResolveCompressor(String compressionMethod) return compressor; } - private static Map buildCompressorRegistry() { + private static Map buildCompressorRegistry(ClassLoader classLoader) { Map compressors = new HashMap<>(); - for (CompressorProvider spi : - ServiceLoader.load(CompressorProvider.class, CompressorUtil.class.getClassLoader())) { + for (CompressorProvider spi : ServiceLoader.load(CompressorProvider.class, classLoader)) { Compressor compressor = spi.getInstance(); compressors.put(compressor.getEncoding(), compressor); } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java index 7dfe6f74262..1c71150cace 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java @@ -42,6 +42,7 @@ public final class OtlpHttpLogRecordExporterBuilder { private final HttpExporterBuilder delegate; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpHttpLogRecordExporterBuilder.class.getClassLoader(); OtlpHttpLogRecordExporterBuilder(HttpExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -117,7 +118,8 @@ public OtlpHttpLogRecordExporterBuilder setEndpoint(String endpoint) { */ public OtlpHttpLogRecordExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -251,6 +253,7 @@ public OtlpHttpLogRecordExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java index 3d6e6b97e5b..ca4e7c98c29 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java @@ -54,6 +54,7 @@ public final class OtlpHttpMetricExporterBuilder { private AggregationTemporalitySelector aggregationTemporalitySelector; private DefaultAggregationSelector defaultAggregationSelector; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpHttpMetricExporterBuilder.class.getClassLoader(); OtlpHttpMetricExporterBuilder( HttpExporterBuilder delegate, @@ -137,7 +138,8 @@ public OtlpHttpMetricExporterBuilder setEndpoint(String endpoint) { */ public OtlpHttpMetricExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -310,6 +312,7 @@ public OtlpHttpMetricExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java index 4c2737845d1..40877118fbe 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java @@ -42,6 +42,7 @@ public final class OtlpHttpSpanExporterBuilder { private final HttpExporterBuilder delegate; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpHttpSpanExporterBuilder.class.getClassLoader(); OtlpHttpSpanExporterBuilder(HttpExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -117,7 +118,8 @@ public OtlpHttpSpanExporterBuilder setEndpoint(String endpoint) { */ public OtlpHttpSpanExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -252,6 +254,7 @@ public OtlpHttpSpanExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java index dbec072655e..220be09f650 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java @@ -51,6 +51,7 @@ public final class OtlpGrpcLogRecordExporterBuilder { // Visible for testing final GrpcExporterBuilder delegate; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpGrpcLogRecordExporterBuilder.class.getClassLoader(); OtlpGrpcLogRecordExporterBuilder(GrpcExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -150,7 +151,8 @@ public OtlpGrpcLogRecordExporterBuilder setEndpoint(String endpoint) { */ public OtlpGrpcLogRecordExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -280,6 +282,7 @@ public OtlpGrpcLogRecordExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java index 8a56a8188a2..5303352f2ba 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java @@ -62,6 +62,7 @@ public final class OtlpGrpcMetricExporterBuilder { private AggregationTemporalitySelector aggregationTemporalitySelector; private DefaultAggregationSelector defaultAggregationSelector; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpGrpcMetricExporterBuilder.class.getClassLoader(); OtlpGrpcMetricExporterBuilder( GrpcExporterBuilder delegate, @@ -169,7 +170,8 @@ public OtlpGrpcMetricExporterBuilder setEndpoint(String endpoint) { */ public OtlpGrpcMetricExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -338,6 +340,7 @@ public OtlpGrpcMetricExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java index 8b0c8c1f9f7..06b6b272396 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java @@ -47,6 +47,7 @@ public final class OtlpGrpcSpanExporterBuilder { // Visible for testing final GrpcExporterBuilder delegate; private MemoryMode memoryMode; + private ClassLoader serviceClassLoader = OtlpGrpcSpanExporterBuilder.class.getClassLoader(); OtlpGrpcSpanExporterBuilder(GrpcExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -146,7 +147,8 @@ public OtlpGrpcSpanExporterBuilder setEndpoint(String endpoint) { */ public OtlpGrpcSpanExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -277,6 +279,7 @@ public OtlpGrpcSpanExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java b/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java index 91d34b00e6e..271699c6f09 100644 --- a/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java +++ b/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java @@ -40,6 +40,7 @@ public final class OtlpGrpcProfilesExporterBuilder { private static final String DEFAULT_ENDPOINT_URL = "http://localhost:4317"; private static final URI DEFAULT_ENDPOINT = URI.create(DEFAULT_ENDPOINT_URL); private static final long DEFAULT_TIMEOUT_SECS = 10; + private ClassLoader serviceClassLoader = OtlpGrpcProfilesExporterBuilder.class.getClassLoader(); // TODO maybe make more efficient by adding support for MEMORY_MODE @@ -139,7 +140,8 @@ public OtlpGrpcProfilesExporterBuilder setEndpoint(String endpoint) { */ public OtlpGrpcProfilesExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = CompressorUtil.validateAndResolveCompressor(compressionMethod); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); delegate.setCompression(compressor); return this; } @@ -207,6 +209,7 @@ public OtlpGrpcProfilesExporterBuilder setRetryPolicy(@Nullable RetryPolicy retr /** Set the {@link ClassLoader} used to load the sender API. */ public OtlpGrpcProfilesExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); + this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } From 0cd6af723af256fd7460117f30c21db29fa693ff Mon Sep 17 00:00:00 2001 From: Teja Date: Thu, 26 Jun 2025 22:06:35 -0400 Subject: [PATCH 2/2] moving the compression setter to lower level api and modifying the exporters as per feedback --- .../internal/grpc/GrpcExporterBuilder.java | 19 +++- .../internal/http/HttpExporterBuilder.java | 19 +++- .../compression/CompressorUtilTest.java | 88 ++++++++++++++++++ .../grpc/GrpcExporterBuilderTest.java | 44 ++++++++- .../http/HttpExporterBuilderTest.java | 92 +++++++++++++++++++ .../OtlpHttpLogRecordExporterBuilder.java | 13 +-- .../OtlpHttpMetricExporterBuilder.java | 12 +-- .../trace/OtlpHttpSpanExporterBuilder.java | 12 +-- .../OtlpGrpcLogRecordExporterBuilder.java | 12 +-- .../OtlpGrpcMetricExporterBuilder.java | 12 +-- .../trace/OtlpGrpcSpanExporterBuilder.java | 12 +-- .../OtlpGrpcProfilesExporterBuilder.java | 12 +-- 12 files changed, 277 insertions(+), 70 deletions(-) create mode 100644 exporters/common/src/test/java/io/opentelemetry/exporter/internal/compression/CompressorUtilTest.java create mode 100644 exporters/common/src/test/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilderTest.java diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java index 6f2ae64b862..15028492ae6 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java @@ -5,6 +5,8 @@ package io.opentelemetry.exporter.internal.grpc; +import static java.util.Objects.requireNonNull; + import io.grpc.Channel; import io.grpc.ManagedChannel; import io.opentelemetry.api.GlobalOpenTelemetry; @@ -13,6 +15,7 @@ import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.exporter.internal.TlsConfigHelper; import io.opentelemetry.exporter.internal.compression.Compressor; +import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.sdk.common.InternalTelemetryVersion; import io.opentelemetry.sdk.common.export.RetryPolicy; @@ -115,6 +118,18 @@ public GrpcExporterBuilder setCompression(@Nullable Compressor compressor) { return this; } + /** + * Sets the method used to compress payloads. If unset, compression is disabled. Compression + * method "gzip" and "none" are supported out of the box. Support for additional compression + * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + */ + public GrpcExporterBuilder setCompression(String compressionMethod) { + requireNonNull(compressionMethod, "compressionMethod"); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); + return setCompression(compressor); + } + public GrpcExporterBuilder setTrustManagerFromCerts(byte[] trustedCertificatesPem) { tlsConfigHelper.setTrustManagerFromCerts(trustedCertificatesPem); return this; @@ -158,8 +173,8 @@ public GrpcExporterBuilder setInternalTelemetryVersion( return this; } - public GrpcExporterBuilder setServiceClassLoader(ClassLoader servieClassLoader) { - this.serviceClassLoader = servieClassLoader; + public GrpcExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { + this.serviceClassLoader = serviceClassLoader; return this; } diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java index 4cd671c32ca..a2aa14a3abd 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java @@ -5,12 +5,15 @@ package io.opentelemetry.exporter.internal.http; +import static java.util.Objects.requireNonNull; + import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.internal.ConfigUtil; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.exporter.internal.TlsConfigHelper; import io.opentelemetry.exporter.internal.compression.Compressor; +import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.sdk.common.InternalTelemetryVersion; import io.opentelemetry.sdk.common.export.ProxyOptions; @@ -95,6 +98,18 @@ public HttpExporterBuilder setCompression(@Nullable Compressor compressor) { return this; } + /** + * Sets the method used to compress payloads. If unset, compression is disabled. Compression + * method "gzip" and "none" are supported out of the box. Support for additional compression + * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + */ + public HttpExporterBuilder setCompression(String compressionMethod) { + requireNonNull(compressionMethod, "compressionMethod"); + Compressor compressor = + CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); + return setCompression(compressor); + } + public HttpExporterBuilder addConstantHeaders(String key, String value) { constantHeaders.put(key, value); return this; @@ -143,8 +158,8 @@ public HttpExporterBuilder setProxyOptions(ProxyOptions proxyOptions) { return this; } - public HttpExporterBuilder setServiceClassLoader(ClassLoader servieClassLoader) { - this.serviceClassLoader = servieClassLoader; + public HttpExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { + this.serviceClassLoader = serviceClassLoader; return this; } diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/compression/CompressorUtilTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/compression/CompressorUtilTest.java new file mode 100644 index 00000000000..d0c9a8eac69 --- /dev/null +++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/compression/CompressorUtilTest.java @@ -0,0 +1,88 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.exporter.internal.compression; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.net.URL; +import java.net.URLClassLoader; +import org.junit.jupiter.api.Test; + +class CompressorUtilTest { + + @Test + void validateAndResolveCompressor_none() { + assertThat(CompressorUtil.validateAndResolveCompressor("none")).isNull(); + } + + @Test + void validateAndResolveCompressor_gzip() { + assertThat(CompressorUtil.validateAndResolveCompressor("gzip")) + .isEqualTo(GzipCompressor.getInstance()); + } + + @Test + void validateAndResolveCompressor_invalid() { + assertThatThrownBy(() -> CompressorUtil.validateAndResolveCompressor("invalid")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Unsupported compressionMethod"); + } + + @Test + void validateAndResolveCompressor_withClassLoader_none() { + ClassLoader classLoader = CompressorUtilTest.class.getClassLoader(); + assertThat(CompressorUtil.validateAndResolveCompressor("none", classLoader)).isNull(); + } + + @Test + void validateAndResolveCompressor_withClassLoader_gzip() { + ClassLoader classLoader = CompressorUtilTest.class.getClassLoader(); + assertThat(CompressorUtil.validateAndResolveCompressor("gzip", classLoader)) + .isEqualTo(GzipCompressor.getInstance()); + } + + @Test + void validateAndResolveCompressor_withClassLoader_invalid() { + ClassLoader classLoader = CompressorUtilTest.class.getClassLoader(); + assertThatThrownBy(() -> CompressorUtil.validateAndResolveCompressor("invalid", classLoader)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Unsupported compressionMethod"); + } + + @Test + void validateAndResolveCompressor_emptyClassLoader() { + // Create a class loader that cannot load CompressorProvider services + ClassLoader emptyClassLoader = new URLClassLoader(new URL[0], null); + + // Gzip should still work because it's hardcoded + assertThat(CompressorUtil.validateAndResolveCompressor("gzip", emptyClassLoader)) + .isEqualTo(GzipCompressor.getInstance()); + + // None should still work because it doesn't require loading services + assertThat(CompressorUtil.validateAndResolveCompressor("none", emptyClassLoader)).isNull(); + + // Any SPI-based compressor should not be available + assertThatThrownBy( + () -> CompressorUtil.validateAndResolveCompressor("base64", emptyClassLoader)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Unsupported compressionMethod"); + } + + @Test + void validateAndResolveCompressor_delegatesCorrectly() { + // Test that single-parameter method delegates to two-parameter method + assertThat(CompressorUtil.validateAndResolveCompressor("gzip")) + .isEqualTo( + CompressorUtil.validateAndResolveCompressor( + "gzip", CompressorUtil.class.getClassLoader())); + + assertThat(CompressorUtil.validateAndResolveCompressor("none")) + .isEqualTo( + CompressorUtil.validateAndResolveCompressor( + "none", CompressorUtil.class.getClassLoader())); + } +} diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java index cdf797df320..0763309f50c 100644 --- a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java +++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java @@ -6,11 +6,15 @@ package io.opentelemetry.exporter.internal.grpc; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import io.opentelemetry.exporter.internal.compression.Compressor; import io.opentelemetry.exporter.internal.compression.GzipCompressor; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.sdk.internal.StandardComponentId; import java.net.URI; +import java.net.URL; +import java.net.URLClassLoader; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -36,7 +40,7 @@ void compressionDefault() { @Test void compressionNone() { - builder.setCompression(null); + builder.setCompression((Compressor) null); assertThat(builder).extracting("compressor").isNull(); } @@ -50,8 +54,44 @@ void compressionGzip() { @Test void compressionEnabledAndDisabled() { - builder.setCompression(GzipCompressor.getInstance()).setCompression(null); + builder.setCompression(GzipCompressor.getInstance()).setCompression((Compressor) null); assertThat(builder).extracting("compressor").isNull(); } + + @Test + void compressionString_none() { + builder.setCompression("none"); + + assertThat(builder).extracting("compressor").isNull(); + } + + @Test + void compressionString_gzip() { + builder.setCompression("gzip"); + + assertThat(builder).extracting("compressor").isEqualTo(GzipCompressor.getInstance()); + } + + @Test + void compressionString_invalid() { + assertThatThrownBy(() -> builder.setCompression("invalid-compression")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Unsupported compressionMethod"); + } + + @Test + void compressionString_usesServiceClassLoader() { + // Create a class loader that cannot load CompressorProvider services + ClassLoader emptyClassLoader = new URLClassLoader(new URL[0], null); + builder.setServiceClassLoader(emptyClassLoader); + + // This should still work because gzip compressor is hardcoded + builder.setCompression("gzip"); + assertThat(builder).extracting("compressor").isEqualTo(GzipCompressor.getInstance()); + + // This should still work because "none" doesn't require loading services + builder.setCompression("none"); + assertThat(builder).extracting("compressor").isNull(); + } } diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilderTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilderTest.java new file mode 100644 index 00000000000..9e0f74401a7 --- /dev/null +++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilderTest.java @@ -0,0 +1,92 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.exporter.internal.http; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import io.opentelemetry.exporter.internal.compression.Compressor; +import io.opentelemetry.exporter.internal.compression.GzipCompressor; +import io.opentelemetry.exporter.internal.marshal.Marshaler; +import io.opentelemetry.sdk.internal.StandardComponentId; +import java.net.URL; +import java.net.URLClassLoader; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class HttpExporterBuilderTest { + + private HttpExporterBuilder builder; + + @BeforeEach + void setUp() { + builder = + new HttpExporterBuilder<>( + StandardComponentId.ExporterType.OTLP_HTTP_SPAN_EXPORTER, "http://localhost:4318"); + } + + @Test + void compressionDefault() { + assertThat(builder).extracting("compressor").isNull(); + } + + @Test + void compressionNone() { + builder.setCompression((Compressor) null); + + assertThat(builder).extracting("compressor").isNull(); + } + + @Test + void compressionGzip() { + builder.setCompression(GzipCompressor.getInstance()); + + assertThat(builder).extracting("compressor").isEqualTo(GzipCompressor.getInstance()); + } + + @Test + void compressionEnabledAndDisabled() { + builder.setCompression(GzipCompressor.getInstance()).setCompression((Compressor) null); + + assertThat(builder).extracting("compressor").isNull(); + } + + @Test + void compressionString_none() { + builder.setCompression("none"); + + assertThat(builder).extracting("compressor").isNull(); + } + + @Test + void compressionString_gzip() { + builder.setCompression("gzip"); + + assertThat(builder).extracting("compressor").isEqualTo(GzipCompressor.getInstance()); + } + + @Test + void compressionString_invalid() { + assertThatThrownBy(() -> builder.setCompression("invalid-compression")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("Unsupported compressionMethod"); + } + + @Test + void compressionString_usesServiceClassLoader() { + // Create a class loader that cannot load CompressorProvider services + ClassLoader emptyClassLoader = new URLClassLoader(new URL[0], null); + builder.setServiceClassLoader(emptyClassLoader); + + // This should still work because gzip compressor is hardcoded + builder.setCompression("gzip"); + assertThat(builder).extracting("compressor").isEqualTo(GzipCompressor.getInstance()); + + // This should still work because "none" doesn't require loading services + builder.setCompression("none"); + assertThat(builder).extracting("compressor").isNull(); + } +} diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java index 1c71150cace..8ebc1325954 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java @@ -11,8 +11,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.http.HttpExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -42,7 +40,6 @@ public final class OtlpHttpLogRecordExporterBuilder { private final HttpExporterBuilder delegate; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpHttpLogRecordExporterBuilder.class.getClassLoader(); OtlpHttpLogRecordExporterBuilder(HttpExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -113,14 +110,11 @@ public OtlpHttpLogRecordExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpHttpLogRecordExporterBuilder setCompression(String compressionMethod) { - requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -253,7 +247,6 @@ public OtlpHttpLogRecordExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java index ca4e7c98c29..9eb5716ea9c 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java @@ -11,8 +11,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.http.HttpExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -54,7 +52,6 @@ public final class OtlpHttpMetricExporterBuilder { private AggregationTemporalitySelector aggregationTemporalitySelector; private DefaultAggregationSelector defaultAggregationSelector; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpHttpMetricExporterBuilder.class.getClassLoader(); OtlpHttpMetricExporterBuilder( HttpExporterBuilder delegate, @@ -133,14 +130,12 @@ public OtlpHttpMetricExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpHttpMetricExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -312,7 +307,6 @@ public OtlpHttpMetricExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java index 40877118fbe..48864b4639e 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java @@ -11,8 +11,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.http.HttpExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -42,7 +40,6 @@ public final class OtlpHttpSpanExporterBuilder { private final HttpExporterBuilder delegate; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpHttpSpanExporterBuilder.class.getClassLoader(); OtlpHttpSpanExporterBuilder(HttpExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -113,14 +110,12 @@ public OtlpHttpSpanExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpHttpSpanExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -254,7 +249,6 @@ public OtlpHttpSpanExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpHttpSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java index 220be09f650..d1cf9f5798b 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java @@ -12,8 +12,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.grpc.GrpcExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -51,7 +49,6 @@ public final class OtlpGrpcLogRecordExporterBuilder { // Visible for testing final GrpcExporterBuilder delegate; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpGrpcLogRecordExporterBuilder.class.getClassLoader(); OtlpGrpcLogRecordExporterBuilder(GrpcExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -146,14 +143,12 @@ public OtlpGrpcLogRecordExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpGrpcLogRecordExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -282,7 +277,6 @@ public OtlpGrpcLogRecordExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java index 5303352f2ba..e787408331f 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java @@ -12,8 +12,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.grpc.GrpcExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -62,7 +60,6 @@ public final class OtlpGrpcMetricExporterBuilder { private AggregationTemporalitySelector aggregationTemporalitySelector; private DefaultAggregationSelector defaultAggregationSelector; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpGrpcMetricExporterBuilder.class.getClassLoader(); OtlpGrpcMetricExporterBuilder( GrpcExporterBuilder delegate, @@ -165,14 +162,12 @@ public OtlpGrpcMetricExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpGrpcMetricExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -340,7 +335,6 @@ public OtlpGrpcMetricExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java index 06b6b272396..d145ed5b069 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java @@ -12,8 +12,6 @@ import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.grpc.GrpcExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -47,7 +45,6 @@ public final class OtlpGrpcSpanExporterBuilder { // Visible for testing final GrpcExporterBuilder delegate; private MemoryMode memoryMode; - private ClassLoader serviceClassLoader = OtlpGrpcSpanExporterBuilder.class.getClassLoader(); OtlpGrpcSpanExporterBuilder(GrpcExporterBuilder delegate, MemoryMode memoryMode) { this.delegate = delegate; @@ -142,14 +139,12 @@ public OtlpGrpcSpanExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpGrpcSpanExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -279,7 +274,6 @@ public OtlpGrpcSpanExporterBuilder setMemoryMode(MemoryMode memoryMode) { */ public OtlpGrpcSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; } diff --git a/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java b/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java index 271699c6f09..0489cb25f90 100644 --- a/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java +++ b/exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java @@ -11,8 +11,6 @@ import io.grpc.ManagedChannel; import io.opentelemetry.api.metrics.MeterProvider; import io.opentelemetry.exporter.internal.compression.Compressor; -import io.opentelemetry.exporter.internal.compression.CompressorProvider; -import io.opentelemetry.exporter.internal.compression.CompressorUtil; import io.opentelemetry.exporter.internal.grpc.GrpcExporterBuilder; import io.opentelemetry.exporter.internal.marshal.Marshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; @@ -40,7 +38,6 @@ public final class OtlpGrpcProfilesExporterBuilder { private static final String DEFAULT_ENDPOINT_URL = "http://localhost:4317"; private static final URI DEFAULT_ENDPOINT = URI.create(DEFAULT_ENDPOINT_URL); private static final long DEFAULT_TIMEOUT_SECS = 10; - private ClassLoader serviceClassLoader = OtlpGrpcProfilesExporterBuilder.class.getClassLoader(); // TODO maybe make more efficient by adding support for MEMORY_MODE @@ -135,14 +132,12 @@ public OtlpGrpcProfilesExporterBuilder setEndpoint(String endpoint) { /** * Sets the method used to compress payloads. If unset, compression is disabled. Compression - * method "gzip" and "none" are supported out of the box. Support for additional compression - * methods is available by implementing {@link Compressor} and {@link CompressorProvider}. + * method "gzip" and "none" are supported out of the box. Additional compression methods can be + * supported by providing custom {@link Compressor} implementations via the service loader. */ public OtlpGrpcProfilesExporterBuilder setCompression(String compressionMethod) { requireNonNull(compressionMethod, "compressionMethod"); - Compressor compressor = - CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader); - delegate.setCompression(compressor); + delegate.setCompression(compressionMethod); return this; } @@ -209,7 +204,6 @@ public OtlpGrpcProfilesExporterBuilder setRetryPolicy(@Nullable RetryPolicy retr /** Set the {@link ClassLoader} used to load the sender API. */ public OtlpGrpcProfilesExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) { requireNonNull(serviceClassLoader, "serviceClassLoader"); - this.serviceClassLoader = serviceClassLoader; delegate.setServiceClassLoader(serviceClassLoader); return this; }