Merge branch 'main' of https://github.com/open-telemetry/opentelemetry-java into promote-component-loader

Author: jack-berg

README.md

@@ -256,33 +256,35 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for:
 
 ### Code owners
 
-Triagers:
+#### Maintainers
 
-- [Gregor Zeitlinger](https://github.com/zeitlinger), Grafana Labs
+- [Jack Berg](https://github.com/jack-berg), New Relic
+- [John Watson](https://github.com/jkwatson), Verta.ai
 
-*Find more about the triager role in [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#triager).*
+For more information about the maintainer role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#maintainer).
 
-Approvers ([@open-telemetry/java-approvers](https://github.com/orgs/open-telemetry/teams/java-approvers)):
+#### Approvers
 
 - [Jason Plumb](https://github.com/breedx-splk), Splunk
 - [Josh Suereth](https://github.com/jsuereth), Google
 - [Lauri Tulmin](https://github.com/laurit), Splunk
 - [Trask Stalnaker](https://github.com/trask), Microsoft
 
-*Find more about the approver role in [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver).*
+For more information about the approver role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#approver).
 
-Maintainers ([@open-telemetry/java-maintainers](https://github.com/orgs/open-telemetry/teams/java-maintainers)):
+#### Triagers
 
-- [Jack Berg](https://github.com/jack-berg), New Relic
-- [John Watson](https://github.com/jkwatson), Verta.ai
+- [Gregor Zeitlinger](https://github.com/zeitlinger), Grafana Labs
 
-Emeritus:
+For more information about the triager role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#triager).
+
+#### Emeritus
 
 - Maintainer [Bogdan Drutu](https://github.com/BogdanDrutu)
 - Maintainer [Carlos Alberto](https://github.com/carlosalberto)
 - Approver [Mateusz Rzeszutek](https://github.com/mateuszrzeszutek)
 
-*Find more about the maintainer role in [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#maintainer).*
+For more information about the emeritus role, see the [community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#emeritus-maintainerapprovertriager).
 
 ### Help wanted
 
@@ -293,14 +295,12 @@ We are currently resource constrained and are actively seeking new contributors
 - Issues labeled [help wanted](https://github.com/open-telemetry/opentelemetry-java/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) are project priorities. Code contributions (or pull request reviews when a PR is linked) for these issues are particularly important.
 - Triaging / responding to new issues and discussions is a great way to engage with the project.
 
-### Thanks to all the people who have contributed
+### Thanks to all of our contributors!
 
 <a href="https://github.com/open-telemetry/opentelemetry-java/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=open-telemetry/opentelemetry-java" />
+  <img alt="Repo contributors" src="https://contrib.rocks/image?repo=open-telemetry/opentelemetry-java" />
 </a>
 
-Made with [contrib.rocks](https://contrib.rocks).
-
 [codecov-image]: https://codecov.io/gh/open-telemetry/opentelemetry-java/branch/main/graph/badge.svg
 [codecov-url]: https://app.codecov.io/gh/open-telemetry/opentelemetry-java/branch/main/
 [dependencies-and-boms]: https://opentelemetry.io/docs/languages/java/intro/#dependencies-and-boms

buildSrc/build.gradle.kts

@@ -62,7 +62,7 @@ dependencies {
   implementation("gradle.plugin.io.morethan.jmhreport:gradle-jmh-report:0.9.6")
   implementation("me.champeau.gradle:japicmp-gradle-plugin:0.4.6")
   implementation("me.champeau.jmh:jmh-gradle-plugin:0.7.3")
-  implementation("net.ltgt.gradle:gradle-errorprone-plugin:4.2.0")
+  implementation("net.ltgt.gradle:gradle-errorprone-plugin:4.3.0")
   implementation("net.ltgt.gradle:gradle-nullaway-plugin:2.2.0")
   implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.21")
   implementation("org.owasp:dependency-check-gradle:12.1.3")

exporters/common/src/main/java/io/opentelemetry/exporter/internal/compression/CompressorUtil.java

@@ -24,7 +24,9 @@
  */
 public final class CompressorUtil {
 
-  private static final Map<String, Compressor> compressorRegistry = buildCompressorRegistry();
+  private static final Map<String, Compressor> compressorRegistry =
+      buildCompressorRegistry(
+          ComponentLoader.forClassLoader(CompressorUtil.class.getClassLoader()));
 
   private CompressorUtil() {}
 
@@ -36,20 +38,36 @@ private CompressorUtil() {}
    */
   @Nullable
   public static Compressor validateAndResolveCompressor(String compressionMethod) {
-    Set<String> 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 componentLoader the component 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 ComponentLoader componentLoader) {
+    Map<String, Compressor> registry =
+        componentLoader == null ? compressorRegistry : buildCompressorRegistry(componentLoader);
+
+    Set<String> supportedEncodings = registry.keySet();
+    Compressor compressor = registry.get(compressionMethod);
     checkArgument(
         "none".equals(compressionMethod) || compressor != null,
         "Unsupported compressionMethod. Compression method must be \"none\" or one of: "
             + supportedEncodings.stream().collect(joining(",", "[", "]")));
     return compressor;
   }
 
-  private static Map<String, Compressor> buildCompressorRegistry() {
+  private static Map<String, Compressor> buildCompressorRegistry(ComponentLoader componentLoader) {
     Map<String, Compressor> compressors = new HashMap<>();
-    for (CompressorProvider spi :
-        ComponentLoader.forClassLoader(CompressorUtil.class.getClassLoader())
-            .load(CompressorProvider.class)) {
+    for (CompressorProvider spi : componentLoader.load(CompressorProvider.class)) {
       Compressor compressor = spi.getInstance();
       compressors.put(compressor.getEncoding(), compressor);
     }

exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java

@@ -14,6 +14,8 @@
 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.CompressorProvider;
+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;
@@ -116,6 +118,17 @@ public GrpcExporterBuilder<T> 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<T> setCompression(String compressionMethod) {
+    Compressor compressor =
+        CompressorUtil.validateAndResolveCompressor(compressionMethod, componentLoader);
+    return setCompression(compressor);
+  }
+
   public GrpcExporterBuilder<T> setTrustManagerFromCerts(byte[] trustedCertificatesPem) {
     tlsConfigHelper.setTrustManagerFromCerts(trustedCertificatesPem);
     return this;

exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java

@@ -12,6 +12,8 @@
 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.CompressorProvider;
+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;
@@ -96,6 +98,17 @@ public HttpExporterBuilder<T> 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<T> setCompression(String compressionMethod) {
+    Compressor compressor =
+        CompressorUtil.validateAndResolveCompressor(compressionMethod, componentLoader);
+    return setCompression(compressor);
+  }
+
   public HttpExporterBuilder<T> addConstantHeaders(String key, String value) {
     constantHeaders.put(key, value);
     return this;

exporters/common/src/test/java/io/opentelemetry/exporter/internal/compression/CompressorUtilTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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 io.opentelemetry.context.ComponentLoader;
+import java.net.URL;
+import java.net.URLClassLoader;
+import org.junit.jupiter.api.Test;
+
+class CompressorUtilTest {
+
+  private final ComponentLoader componentLoader =
+      ComponentLoader.forClassLoader(CompressorUtilTest.class.getClassLoader());
+
+  @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() {
+    assertThat(CompressorUtil.validateAndResolveCompressor("none", componentLoader)).isNull();
+  }
+
+  @Test
+  void validateAndResolveCompressor_withClassLoader_gzip() {
+    assertThat(CompressorUtil.validateAndResolveCompressor("gzip", componentLoader))
+        .isEqualTo(GzipCompressor.getInstance());
+  }
+
+  @Test
+  void validateAndResolveCompressor_withClassLoader_invalid() {
+    assertThatThrownBy(
+            () -> CompressorUtil.validateAndResolveCompressor("invalid", componentLoader))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Unsupported compressionMethod");
+  }
+
+  @Test
+  void validateAndResolveCompressor_emptyClassLoader() {
+    // Create a class loader that cannot load CompressorProvider services
+    ComponentLoader emptyComponentLoader =
+        ComponentLoader.forClassLoader(new URLClassLoader(new URL[0], null));
+
+    // Gzip should still work because it's hardcoded
+    assertThat(CompressorUtil.validateAndResolveCompressor("gzip", emptyComponentLoader))
+        .isEqualTo(GzipCompressor.getInstance());
+
+    // None should still work because it doesn't require loading services
+    assertThat(CompressorUtil.validateAndResolveCompressor("none", emptyComponentLoader)).isNull();
+
+    // Any SPI-based compressor should not be available
+    assertThatThrownBy(
+            () -> CompressorUtil.validateAndResolveCompressor("base64", emptyComponentLoader))
+        .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", componentLoader));
+
+    assertThat(CompressorUtil.validateAndResolveCompressor("none"))
+        .isEqualTo(CompressorUtil.validateAndResolveCompressor("none", componentLoader));
+  }
+}

exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java

@@ -6,11 +6,16 @@
 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.context.ComponentLoader;
+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 +41,7 @@ void compressionDefault() {
 
   @Test
   void compressionNone() {
-    builder.setCompression(null);
+    builder.setCompression((Compressor) null);
 
     assertThat(builder).extracting("compressor").isNull();
   }
@@ -50,8 +55,45 @@ 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
+    ComponentLoader emptyComponentLoader =
+        ComponentLoader.forClassLoader(new URLClassLoader(new URL[0], null));
+    builder.setComponentLoader(emptyComponentLoader);
+
+    // 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();
+  }
 }