Update codebase to follow style guide conventions

azure-resources/src/main/java/io/opentelemetry/contrib/azure/resource/AzureResourceDetector.java

@@ -11,7 +11,7 @@
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.resources.ResourceBuilder;
 
-public class AzureResourceDetector implements ComponentProvider<Resource> {
+public final class AzureResourceDetector implements ComponentProvider<Resource> {
 
   @Override
   public Class<Resource> getType() {

baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageProcessorCustomizer.java

@@ -12,7 +12,7 @@
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
 import java.util.List;
 
-public class BaggageProcessorCustomizer implements AutoConfigurationCustomizerProvider {
+public final class BaggageProcessorCustomizer implements AutoConfigurationCustomizerProvider {
   @Override
   public void customize(AutoConfigurationCustomizer autoConfigurationCustomizer) {
     autoConfigurationCustomizer

baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageSpanProcessor.java

@@ -16,7 +16,7 @@
  * This span processor copies attributes stored in {@link Baggage} into each newly created {@link
  * io.opentelemetry.api.trace.Span}.
  */
-public class BaggageSpanProcessor implements SpanProcessor {
+public final class BaggageSpanProcessor implements SpanProcessor {
   private final Predicate<String> baggageKeyPredicate;
 
   /**

cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceDetector.java

@@ -9,7 +9,7 @@
 import io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider;
 import io.opentelemetry.sdk.resources.Resource;
 
-public class CloudFoundryResourceDetector implements ComponentProvider<Resource> {
+public final class CloudFoundryResourceDetector implements ComponentProvider<Resource> {
 
   @Override
   public Class<Resource> getType() {

cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceProvider.java

@@ -9,7 +9,7 @@
 import io.opentelemetry.sdk.autoconfigure.spi.ResourceProvider;
 import io.opentelemetry.sdk.resources.Resource;
 
-public class CloudFoundryResourceProvider implements ResourceProvider {
+public final class CloudFoundryResourceProvider implements ResourceProvider {
 
   @Override
   public Resource createResource(ConfigProperties configProperties) {

consistent-sampling/build.gradle.kts

@@ -7,6 +7,8 @@ description = "Sampler and exporter implementations for consistent sampling"
 otelJava.moduleName.set("io.opentelemetry.contrib.sampler")
 
 dependencies {
+  annotationProcessor("com.google.auto.service:auto-service")
+  compileOnly("com.google.auto.service:auto-service-annotations")
   api("io.opentelemetry:opentelemetry-sdk-trace")
   api("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi")
   testImplementation("org.hipparchus:hipparchus-core:4.0.1")

consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent/ParentBasedConsistentProbabilitySamplerProvider.java

@@ -5,10 +5,12 @@
 
 package io.opentelemetry.contrib.sampler.consistent;
 
+import com.google.auto.service.AutoService;
 import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
 import io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSamplerProvider;
 import io.opentelemetry.sdk.trace.samplers.Sampler;
 
+@AutoService(ConfigurableSamplerProvider.class)
 public final class ParentBasedConsistentProbabilitySamplerProvider
     implements ConfigurableSamplerProvider {
 

consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentProbabilityBasedSamplerTest.java

@@ -6,7 +6,6 @@
 package io.opentelemetry.contrib.sampler.consistent;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanKind;
@@ -63,8 +62,8 @@ private void test(SplittableRandom rng, double samplingProbability) {
                 .getUpdatedTraceState(TraceState.getDefault())
                 .get(OtelTraceState.TRACE_STATE_KEY);
         OtelTraceState traceState = OtelTraceState.parse(traceStateString);
-        assertTrue(traceState.hasValidR());
-        assertTrue(traceState.hasValidP());
+        assertThat(traceState.hasValidR()).isTrue();
+        assertThat(traceState.hasValidP()).isTrue();
         observedPvalues.merge(traceState.getP(), 1L, Long::sum);
       }
     }

consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentSamplerTest.java

@@ -8,9 +8,7 @@
 import static io.opentelemetry.contrib.sampler.consistent.OtelTraceState.getInvalidP;
 import static io.opentelemetry.contrib.sampler.consistent.OtelTraceState.getInvalidR;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Span;
@@ -32,45 +30,45 @@ class ConsistentSamplerTest {
 
   @Test
   void testGetSamplingRate() {
-    assertThrows(
-        IllegalArgumentException.class, () -> ConsistentSampler.getSamplingProbability(-1));
+    assertThatThrownBy(() -> ConsistentSampler.getSamplingProbability(-1))
+        .isInstanceOf(IllegalArgumentException.class);
     for (int i = 0; i < OtelTraceState.getMaxP() - 1; i += 1) {
-      assertEquals(Math.pow(0.5, i), ConsistentSampler.getSamplingProbability(i));
+      assertThat(ConsistentSampler.getSamplingProbability(i)).isEqualTo(Math.pow(0.5, i));
     }
-    assertEquals(0., ConsistentSampler.getSamplingProbability(OtelTraceState.getMaxP()));
-    assertThrows(
-        IllegalArgumentException.class,
-        () -> ConsistentSampler.getSamplingProbability(OtelTraceState.getMaxP() + 1));
+    assertThat(ConsistentSampler.getSamplingProbability(OtelTraceState.getMaxP())).isEqualTo(0.);
+    assertThatThrownBy(
+        () -> ConsistentSampler.getSamplingProbability(OtelTraceState.getMaxP() + 1))
+        .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void testGetLowerBoundP() {
-    assertEquals(0, ConsistentSampler.getLowerBoundP(1.0));
-    assertEquals(0, ConsistentSampler.getLowerBoundP(Math.nextDown(1.0)));
+    assertThat(ConsistentSampler.getLowerBoundP(1.0)).isEqualTo(0);
+    assertThat(ConsistentSampler.getLowerBoundP(Math.nextDown(1.0))).isEqualTo(0);
     for (int i = 1; i < OtelTraceState.getMaxP() - 1; i += 1) {
       double samplingProbability = Math.pow(0.5, i);
-      assertEquals(i, ConsistentSampler.getLowerBoundP(samplingProbability));
-      assertEquals(i - 1, ConsistentSampler.getLowerBoundP(Math.nextUp(samplingProbability)));
-      assertEquals(i, ConsistentSampler.getLowerBoundP(Math.nextDown(samplingProbability)));
+      assertThat(ConsistentSampler.getLowerBoundP(samplingProbability)).isEqualTo(i);
+      assertThat(ConsistentSampler.getLowerBoundP(Math.nextUp(samplingProbability))).isEqualTo(i - 1);
+      assertThat(ConsistentSampler.getLowerBoundP(Math.nextDown(samplingProbability))).isEqualTo(i);
     }
-    assertEquals(OtelTraceState.getMaxP() - 1, ConsistentSampler.getLowerBoundP(Double.MIN_NORMAL));
-    assertEquals(OtelTraceState.getMaxP() - 1, ConsistentSampler.getLowerBoundP(Double.MIN_VALUE));
-    assertEquals(OtelTraceState.getMaxP(), ConsistentSampler.getLowerBoundP(0.0));
+    assertThat(ConsistentSampler.getLowerBoundP(Double.MIN_NORMAL)).isEqualTo(OtelTraceState.getMaxP() - 1);
+    assertThat(ConsistentSampler.getLowerBoundP(Double.MIN_VALUE)).isEqualTo(OtelTraceState.getMaxP() - 1);
+    assertThat(ConsistentSampler.getLowerBoundP(0.0)).isEqualTo(OtelTraceState.getMaxP());
   }
 
   @Test
   void testGetUpperBoundP() {
-    assertEquals(0, ConsistentSampler.getUpperBoundP(1.0));
-    assertEquals(1, ConsistentSampler.getUpperBoundP(Math.nextDown(1.0)));
+    assertThat(ConsistentSampler.getUpperBoundP(1.0)).isEqualTo(0);
+    assertThat(ConsistentSampler.getUpperBoundP(Math.nextDown(1.0))).isEqualTo(1);
     for (int i = 1; i < OtelTraceState.getMaxP() - 1; i += 1) {
       double samplingProbability = Math.pow(0.5, i);
-      assertEquals(i, ConsistentSampler.getUpperBoundP(samplingProbability));
-      assertEquals(i, ConsistentSampler.getUpperBoundP(Math.nextUp(samplingProbability)));
-      assertEquals(i + 1, ConsistentSampler.getUpperBoundP(Math.nextDown(samplingProbability)));
+      assertThat(ConsistentSampler.getUpperBoundP(samplingProbability)).isEqualTo(i);
+      assertThat(ConsistentSampler.getUpperBoundP(Math.nextUp(samplingProbability))).isEqualTo(i);
+      assertThat(ConsistentSampler.getUpperBoundP(Math.nextDown(samplingProbability))).isEqualTo(i + 1);
     }
-    assertEquals(OtelTraceState.getMaxP(), ConsistentSampler.getUpperBoundP(Double.MIN_NORMAL));
-    assertEquals(OtelTraceState.getMaxP(), ConsistentSampler.getUpperBoundP(Double.MIN_VALUE));
-    assertEquals(OtelTraceState.getMaxP(), ConsistentSampler.getUpperBoundP(0.0));
+    assertThat(ConsistentSampler.getUpperBoundP(Double.MIN_NORMAL)).isEqualTo(OtelTraceState.getMaxP());
+    assertThat(ConsistentSampler.getUpperBoundP(Double.MIN_VALUE)).isEqualTo(OtelTraceState.getMaxP());
+    assertThat(ConsistentSampler.getUpperBoundP(0.0)).isEqualTo(OtelTraceState.getMaxP());
   }
 
   @Test
@@ -168,18 +166,18 @@ private static void assertConsistentSampling(
     SamplingResult samplingResult =
         sampler.shouldSample(parentContext, traceId, name, spanKind, attributes, parentLinks);
 
-    assertEquals(expectSampled, getSampledFlag(samplingResult));
+    assertThat(getSampledFlag(samplingResult)).isEqualTo(expectSampled);
     OptionalInt p = getP(samplingResult, parentContext);
     if (OtelTraceState.isValidP(expectedP)) {
-      assertEquals(expectedP, p.getAsInt());
+      assertThat(p.getAsInt()).isEqualTo(expectedP);
     } else {
-      assertFalse(p.isPresent());
+      assertThat(p.isPresent()).isFalse();
     }
     OptionalInt r = getR(samplingResult, parentContext);
     if (OtelTraceState.isValidR(expectedR)) {
-      assertEquals(expectedR, r.getAsInt());
+      assertThat(r.getAsInt()).isEqualTo(expectedR);
     } else {
-      assertFalse(r.isPresent());
+      assertThat(r.isPresent()).isFalse();
     }
   }
 

consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent56/OtelTraceStateTest.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.contrib.sampler.consistent56;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -20,56 +20,54 @@ private static String getXString(int len) {
   @Test
   public void test() {
 
-    assertEquals("", OtelTraceState.parse("").serialize());
-    assertEquals("", OtelTraceState.parse("").serialize());
+    assertThat(OtelTraceState.parse("").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("").serialize()).isEqualTo("");
 
-    assertEquals("", OtelTraceState.parse("a").serialize());
-    assertEquals("", OtelTraceState.parse("#").serialize());
-    assertEquals("", OtelTraceState.parse(" ").serialize());
+    assertThat(OtelTraceState.parse("a").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("#").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse(" ").serialize()).isEqualTo("");
 
-    assertEquals("rv:1234567890abcd", OtelTraceState.parse("rv:1234567890abcd").serialize());
-    assertEquals("rv:01020304050607", OtelTraceState.parse("rv:01020304050607").serialize());
-    assertEquals("", OtelTraceState.parse("rv:1234567890abcde").serialize());
+    assertThat(OtelTraceState.parse("rv:1234567890abcd").serialize()).isEqualTo("rv:1234567890abcd");
+    assertThat(OtelTraceState.parse("rv:01020304050607").serialize()).isEqualTo("rv:01020304050607");
+    assertThat(OtelTraceState.parse("rv:1234567890abcde").serialize()).isEqualTo("");
 
-    assertEquals("th:1234567890abcd", OtelTraceState.parse("th:1234567890abcd").serialize());
-    assertEquals("th:01020304050607", OtelTraceState.parse("th:01020304050607").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10000000000000").serialize());
-    assertEquals("th:12345", OtelTraceState.parse("th:1234500000000").serialize());
-    assertEquals("th:0", OtelTraceState.parse("th:0").serialize()); // TODO
-    assertEquals("", OtelTraceState.parse("th:100000000000000").serialize());
-    assertEquals("", OtelTraceState.parse("th:1234567890abcde").serialize());
+    assertThat(OtelTraceState.parse("th:1234567890abcd").serialize()).isEqualTo("th:1234567890abcd");
+    assertThat(OtelTraceState.parse("th:01020304050607").serialize()).isEqualTo("th:01020304050607");
+    assertThat(OtelTraceState.parse("th:10000000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1234500000000").serialize()).isEqualTo("th:12345");
+    assertThat(OtelTraceState.parse("th:0").serialize()).isEqualTo("th:0"); // TODO
+    assertThat(OtelTraceState.parse("th:100000000000000").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("th:1234567890abcde").serialize()).isEqualTo("");
 
-    assertEquals(
-        "th:1234567890abcd;rv:1234567890abcd;a:" + getXString(214) + ";x:3",
+    assertThat(
         OtelTraceState.parse("a:" + getXString(214) + ";rv:1234567890abcd;th:1234567890abcd;x:3")
-            .serialize());
-    assertEquals(
-        "",
+            .serialize()).isEqualTo("th:1234567890abcd;rv:1234567890abcd;a:" + getXString(214) + ";x:3");
+    assertThat(
         OtelTraceState.parse("a:" + getXString(215) + ";rv:1234567890abcd;th:1234567890abcd;x:3")
-            .serialize());
+            .serialize()).isEqualTo("");
 
-    assertEquals("", OtelTraceState.parse("th:x").serialize());
-    assertEquals("", OtelTraceState.parse("th:100000000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10000000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:1000000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:100000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:1000000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:100000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:1000000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:100000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:1000").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:100").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:10").serialize());
-    assertEquals("th:1", OtelTraceState.parse("th:1").serialize());
+    assertThat(OtelTraceState.parse("th:x").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("th:100000000000000").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("th:10000000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1000000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:100000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:10000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1000000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:100000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:10000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1000000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:100000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:10000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1000").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:100").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:10").serialize()).isEqualTo("th:1");
+    assertThat(OtelTraceState.parse("th:1").serialize()).isEqualTo("th:1");
 
-    assertEquals("th:10000000000001", OtelTraceState.parse("th:10000000000001").serialize());
-    assertEquals("th:1000000000001", OtelTraceState.parse("th:10000000000010").serialize());
-    assertEquals("", OtelTraceState.parse("rv:x").serialize());
-    assertEquals("", OtelTraceState.parse("rv:100000000000000").serialize());
-    assertEquals("rv:10000000000000", OtelTraceState.parse("rv:10000000000000").serialize());
-    assertEquals("", OtelTraceState.parse("rv:1000000000000").serialize());
+    assertThat(OtelTraceState.parse("th:10000000000001").serialize()).isEqualTo("th:10000000000001");
+    assertThat(OtelTraceState.parse("th:10000000000010").serialize()).isEqualTo("th:1000000000001");
+    assertThat(OtelTraceState.parse("rv:x").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("rv:100000000000000").serialize()).isEqualTo("");
+    assertThat(OtelTraceState.parse("rv:10000000000000").serialize()).isEqualTo("rv:10000000000000");
+    assertThat(OtelTraceState.parse("rv:1000000000000").serialize()).isEqualTo("");
   }
 }

gcp-resources/build.gradle.kts

@@ -8,6 +8,8 @@ description = "OpenTelemetry GCP Resources Support"
 otelJava.moduleName.set("io.opentelemetry.contrib.gcp.resource")
 
 dependencies {
+  annotationProcessor("com.google.auto.service:auto-service")
+  compileOnly("com.google.auto.service:auto-service-annotations")
   api("io.opentelemetry:opentelemetry-api")
   compileOnly("io.opentelemetry:opentelemetry-api-incubator")
   api("io.opentelemetry:opentelemetry-sdk")

gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/GCPResourceProvider.java

@@ -50,6 +50,7 @@
 import static io.opentelemetry.contrib.gcp.resource.IncubatingAttributes.HOST_TYPE;
 import static io.opentelemetry.contrib.gcp.resource.IncubatingAttributes.K8S_CLUSTER_NAME;
 
+import com.google.auto.service.AutoService;
 import com.google.cloud.opentelemetry.detection.DetectedPlatform;
 import com.google.cloud.opentelemetry.detection.GCPPlatformDetector;
 import io.opentelemetry.api.common.Attributes;
@@ -61,8 +62,9 @@
 import java.util.Optional;
 import java.util.logging.Logger;
 
+@AutoService(ConditionalResourceProvider.class)
 @SuppressWarnings("MemberName")
-public class GCPResourceProvider implements ConditionalResourceProvider {
+public final class GCPResourceProvider implements ConditionalResourceProvider {
 
   private static final Logger LOGGER = Logger.getLogger(GCPResourceProvider.class.getSimpleName());
   private final GCPPlatformDetector detector;

gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/internal/GcpResourceDetector.java

@@ -5,13 +5,16 @@
 
 package io.opentelemetry.contrib.gcp.resource.internal;
 
+import com.google.auto.service.AutoService;
 import io.opentelemetry.api.incubator.config.DeclarativeConfigProperties;
 import io.opentelemetry.contrib.gcp.resource.GCPResourceProvider;
 import io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider;
 import io.opentelemetry.sdk.resources.Resource;
 import io.opentelemetry.sdk.resources.ResourceBuilder;
 
-public class GcpResourceDetector implements ComponentProvider<Resource> {
+@AutoService(ComponentProvider.class)
+@SuppressWarnings("rawtypes")
+public final class GcpResourceDetector implements ComponentProvider<Resource> {
 
   @Override
   public Class<Resource> getType() {