diff --git a/azure-resources/src/main/java/io/opentelemetry/contrib/azure/resource/AzureResourceDetector.java b/azure-resources/src/main/java/io/opentelemetry/contrib/azure/resource/AzureResourceDetector.java index 556e1d60c..27da91c4c 100644 --- a/azure-resources/src/main/java/io/opentelemetry/contrib/azure/resource/AzureResourceDetector.java +++ b/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 { +public final class AzureResourceDetector implements ComponentProvider { @Override public Class getType() { diff --git a/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageProcessorCustomizer.java b/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageProcessorCustomizer.java index da35512a3..2471aaa6d 100644 --- a/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageProcessorCustomizer.java +++ b/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 diff --git a/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageSpanProcessor.java b/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageSpanProcessor.java index 5f0f53d03..1ba62b19d 100644 --- a/baggage-processor/src/main/java/io/opentelemetry/contrib/baggage/processor/BaggageSpanProcessor.java +++ b/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 baggageKeyPredicate; /** diff --git a/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceDetector.java b/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceDetector.java index 02b9a6b09..357d83533 100644 --- a/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceDetector.java +++ b/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 { +public final class CloudFoundryResourceDetector implements ComponentProvider { @Override public Class getType() { diff --git a/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceProvider.java b/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceProvider.java index e3f3e3c64..992eb93dc 100644 --- a/cloudfoundry-resources/src/main/java/io/opentelemetry/contrib/cloudfoundry/resources/CloudFoundryResourceProvider.java +++ b/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) { diff --git a/consistent-sampling/build.gradle.kts b/consistent-sampling/build.gradle.kts index 66fca90c9..a3de972f6 100644 --- a/consistent-sampling/build.gradle.kts +++ b/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") diff --git a/consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent/ParentBasedConsistentProbabilitySamplerProvider.java b/consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent/ParentBasedConsistentProbabilitySamplerProvider.java index 0ca7e17a9..12363b27f 100644 --- a/consistent-sampling/src/main/java/io/opentelemetry/contrib/sampler/consistent/ParentBasedConsistentProbabilitySamplerProvider.java +++ b/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 { diff --git a/consistent-sampling/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSamplerProvider b/consistent-sampling/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSamplerProvider deleted file mode 100644 index 948fcc325..000000000 --- a/consistent-sampling/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSamplerProvider +++ /dev/null @@ -1 +0,0 @@ -io.opentelemetry.contrib.sampler.consistent.ParentBasedConsistentProbabilitySamplerProvider diff --git a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentProbabilityBasedSamplerTest.java b/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentProbabilityBasedSamplerTest.java index 4b9d3e425..a3da51ec5 100644 --- a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentProbabilityBasedSamplerTest.java +++ b/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); } } diff --git a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentSamplerTest.java b/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentSamplerTest.java index 082ac3068..3ba859142 100644 --- a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent/ConsistentSamplerTest.java +++ b/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(); } } diff --git a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent56/OtelTraceStateTest.java b/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent56/OtelTraceStateTest.java index a131e9b78..1d3a1b864 100644 --- a/consistent-sampling/src/test/java/io/opentelemetry/contrib/sampler/consistent56/OtelTraceStateTest.java +++ b/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(""); } } diff --git a/gcp-resources/build.gradle.kts b/gcp-resources/build.gradle.kts index cc227ed6e..f30e6d053 100644 --- a/gcp-resources/build.gradle.kts +++ b/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") diff --git a/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/GCPResourceProvider.java b/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/GCPResourceProvider.java index b7e49c1a9..5334af9de 100644 --- a/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/GCPResourceProvider.java +++ b/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; diff --git a/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/internal/GcpResourceDetector.java b/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/internal/GcpResourceDetector.java index 35adbeded..14614270f 100644 --- a/gcp-resources/src/main/java/io/opentelemetry/contrib/gcp/resource/internal/GcpResourceDetector.java +++ b/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 { +@AutoService(ComponentProvider.class) +@SuppressWarnings("rawtypes") +public final class GcpResourceDetector implements ComponentProvider { @Override public Class getType() { diff --git a/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ResourceProvider b/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ResourceProvider deleted file mode 100644 index d65134276..000000000 --- a/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ResourceProvider +++ /dev/null @@ -1 +0,0 @@ -io.opentelemetry.contrib.gcp.resource.GCPResourceProvider diff --git a/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider b/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider deleted file mode 100644 index e65bbc840..000000000 --- a/gcp-resources/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider +++ /dev/null @@ -1 +0,0 @@ -io.opentelemetry.contrib.gcp.resource.internal.GcpResourceDetector diff --git a/jmx-metrics/src/main/groovy/io/opentelemetry/contrib/jmxmetrics/GroovyRunner.java b/jmx-metrics/src/main/groovy/io/opentelemetry/contrib/jmxmetrics/GroovyRunner.java index ab0a8045e..b9dd1306a 100644 --- a/jmx-metrics/src/main/groovy/io/opentelemetry/contrib/jmxmetrics/GroovyRunner.java +++ b/jmx-metrics/src/main/groovy/io/opentelemetry/contrib/jmxmetrics/GroovyRunner.java @@ -44,7 +44,7 @@ public class GroovyRunner { List scriptSources = new ArrayList<>(); try { if (config.targetSystems.size() != 0) { - for (final String target : config.targetSystems) { + for (String target : config.targetSystems) { String systemResourcePath = "target-systems/" + target + ".groovy"; scriptSources.add(getTargetSystemResourceAsString(systemResourcePath)); } @@ -59,7 +59,7 @@ public class GroovyRunner { this.scripts = new ArrayList<>(); try { - for (final String source : scriptSources) { + for (String source : scriptSources) { this.scripts.add(new GroovyShell().parse(source)); } } catch (CompilationFailedException e) { @@ -74,18 +74,18 @@ public class GroovyRunner { new OtelHelper(jmxClient, this.groovyMetricEnvironment, config.aggregateAcrossMBeans); binding.setVariable("otel", otelHelper); - for (final Script script : scripts) { + for (Script script : scripts) { script.setBinding(binding); } } - private static String getFileAsString(final String fileName) throws IOException { + private static String getFileAsString(String fileName) throws IOException { try (InputStream is = new FileInputStream(fileName)) { return getFileFromInputStream(is); } } - private String getTargetSystemResourceAsString(final String targetSystem) throws IOException { + private String getTargetSystemResourceAsString(String targetSystem) throws IOException { URL res = getClass().getClassLoader().getResource(targetSystem); if (res == null) { throw new ConfigurationException("Failed to load " + targetSystem);