moving the compression setter to lower level api and modifying the exporters as per feedback

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.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.RetryPolicy;
@@ -115,6 +118,18 @@ public class GrpcExporterBuilder<T extends Marshaler> {
     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<T> setCompression(String compressionMethod) {
+    requireNonNull(compressionMethod, "compressionMethod");
+    Compressor compressor =
+        CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader);
+    return setCompression(compressor);
+  }
+
   public GrpcExporterBuilder<T> setTrustManagerFromCerts(byte[] trustedCertificatesPem) {
     tlsConfigHelper.setTrustManagerFromCerts(trustedCertificatesPem);
     return this;
@@ -158,8 +173,8 @@ public class GrpcExporterBuilder<T extends Marshaler> {
     return this;
   }
 
-  public GrpcExporterBuilder<T> setServiceClassLoader(ClassLoader servieClassLoader) {
-    this.serviceClassLoader = servieClassLoader;
+  public GrpcExporterBuilder<T> setServiceClassLoader(ClassLoader serviceClassLoader) {
+    this.serviceClassLoader = serviceClassLoader;
     return this;
   }
 

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 final class HttpExporterBuilder<T extends Marshaler> {
     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<T> setCompression(String compressionMethod) {
+    requireNonNull(compressionMethod, "compressionMethod");
+    Compressor compressor =
+        CompressorUtil.validateAndResolveCompressor(compressionMethod, serviceClassLoader);
+    return setCompression(compressor);
+  }
+
   public HttpExporterBuilder<T> addConstantHeaders(String key, String value) {
     constantHeaders.put(key, value);
     return this;
@@ -143,8 +158,8 @@ public final class HttpExporterBuilder<T extends Marshaler> {
     return this;
   }
 
-  public HttpExporterBuilder<T> setServiceClassLoader(ClassLoader servieClassLoader) {
-    this.serviceClassLoader = servieClassLoader;
+  public HttpExporterBuilder<T> setServiceClassLoader(ClassLoader serviceClassLoader) {
+    this.serviceClassLoader = serviceClassLoader;
     return this;
   }
 

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()));
+  }
+}

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 @@ class GrpcExporterBuilderTest {
 
   @Test
   void compressionNone() {
-    builder.setCompression(null);
+    builder.setCompression((Compressor) null);
 
     assertThat(builder).extracting("compressor").isNull();
   }
@@ -50,8 +54,44 @@ class GrpcExporterBuilderTest {
 
   @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();
+  }
 }

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<Marshaler> 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();
+  }
+}

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java

@@ -11,8 +11,6 @@ import static java.util.Objects.requireNonNull;
 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<Marshaler> delegate;
   private MemoryMode memoryMode;
-  private ClassLoader serviceClassLoader = OtlpHttpLogRecordExporterBuilder.class.getClassLoader();
 
   OtlpHttpLogRecordExporterBuilder(HttpExporterBuilder<Marshaler> delegate, MemoryMode memoryMode) {
     this.delegate = delegate;
@@ -113,14 +110,11 @@ public final class OtlpHttpLogRecordExporterBuilder {
 
   /**
    * 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 final class OtlpHttpLogRecordExporterBuilder {
    */
   public OtlpHttpLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java

@@ -11,8 +11,6 @@ import static java.util.Objects.requireNonNull;
 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<Marshaler> delegate,
@@ -133,14 +130,12 @@ public final class OtlpHttpMetricExporterBuilder {
 
   /**
    * 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 final class OtlpHttpMetricExporterBuilder {
    */
   public OtlpHttpMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java

@@ -11,8 +11,6 @@ import static java.util.Objects.requireNonNull;
 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<Marshaler> delegate;
   private MemoryMode memoryMode;
-  private ClassLoader serviceClassLoader = OtlpHttpSpanExporterBuilder.class.getClassLoader();
 
   OtlpHttpSpanExporterBuilder(HttpExporterBuilder<Marshaler> delegate, MemoryMode memoryMode) {
     this.delegate = delegate;
@@ -113,14 +110,12 @@ public final class OtlpHttpSpanExporterBuilder {
 
   /**
    * 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 final class OtlpHttpSpanExporterBuilder {
    */
   public OtlpHttpSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java

@@ -12,8 +12,6 @@ import io.grpc.ManagedChannel;
 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<Marshaler> delegate;
   private MemoryMode memoryMode;
-  private ClassLoader serviceClassLoader = OtlpGrpcLogRecordExporterBuilder.class.getClassLoader();
 
   OtlpGrpcLogRecordExporterBuilder(GrpcExporterBuilder<Marshaler> delegate, MemoryMode memoryMode) {
     this.delegate = delegate;
@@ -146,14 +143,12 @@ public final class OtlpGrpcLogRecordExporterBuilder {
 
   /**
    * 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 final class OtlpGrpcLogRecordExporterBuilder {
    */
   public OtlpGrpcLogRecordExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java

@@ -12,8 +12,6 @@ import io.grpc.ManagedChannel;
 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<Marshaler> delegate,
@@ -165,14 +162,12 @@ public final class OtlpGrpcMetricExporterBuilder {
 
   /**
    * 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 final class OtlpGrpcMetricExporterBuilder {
    */
   public OtlpGrpcMetricExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java

@@ -12,8 +12,6 @@ import io.grpc.ManagedChannel;
 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<Marshaler> delegate;
   private MemoryMode memoryMode;
-  private ClassLoader serviceClassLoader = OtlpGrpcSpanExporterBuilder.class.getClassLoader();
 
   OtlpGrpcSpanExporterBuilder(GrpcExporterBuilder<Marshaler> delegate, MemoryMode memoryMode) {
     this.delegate = delegate;
@@ -142,14 +139,12 @@ public final class OtlpGrpcSpanExporterBuilder {
 
   /**
    * 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 final class OtlpGrpcSpanExporterBuilder {
    */
   public OtlpGrpcSpanExporterBuilder setServiceClassLoader(ClassLoader serviceClassLoader) {
     requireNonNull(serviceClassLoader, "serviceClassLoader");
-    this.serviceClassLoader = serviceClassLoader;
     delegate.setServiceClassLoader(serviceClassLoader);
     return this;
   }

exporters/otlp/profiles/src/main/java/io/opentelemetry/exporter/otlp/profiles/OtlpGrpcProfilesExporterBuilder.java

@@ -11,8 +11,6 @@ import static java.util.Objects.requireNonNull;
 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 final class OtlpGrpcProfilesExporterBuilder {
 
   /**
    * 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 final class OtlpGrpcProfilesExporterBuilder {
   /** 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;
   }