From 7f9a7651b75d33afe7c5f52421db0eb0af727529 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 14:13:15 +0200 Subject: [PATCH 01/20] Creating processors subproject --- processors/build.gradle.kts | 16 ++++++++++++++++ settings.gradle.kts | 1 + 2 files changed, 17 insertions(+) create mode 100644 processors/build.gradle.kts diff --git a/processors/build.gradle.kts b/processors/build.gradle.kts new file mode 100644 index 000000000..0030b610a --- /dev/null +++ b/processors/build.gradle.kts @@ -0,0 +1,16 @@ +plugins { + id("otel.java-conventions") + id("otel.publish-conventions") +} + +description = "Tools to intercept and process signals globally." +otelJava.moduleName.set("io.opentelemetry.contrib.processors") + +java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 +} + +dependencies { + api("io.opentelemetry:opentelemetry-sdk") +} diff --git a/settings.gradle.kts b/settings.gradle.kts index 8e312c449..5a86947e2 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -76,6 +76,7 @@ include(":jmx-metrics") include(":maven-extension") include(":micrometer-meter-provider") include(":noop-api") +include(":processors") include(":prometheus-client-bridge") include(":resource-providers") include(":runtime-attach:runtime-attach") From 27a8f2c7ff7c33219956314982bf8322507b2212 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 15:04:18 +0200 Subject: [PATCH 02/20] Creating the interceptor interface and interceptable base class --- .../contrib/interceptor/api/Interceptor.java | 18 ++++++++ .../interceptor/common/Interceptable.java | 41 +++++++++++++++++++ 2 files changed, 59 insertions(+) create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java new file mode 100644 index 000000000..3c39a3571 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java @@ -0,0 +1,18 @@ +package io.opentelemetry.contrib.interceptor.api; + +/** + * Intercepts a signal before it gets exported. The signal can get updated and/or filtered out based + * on each interceptor implementation. + */ +public interface Interceptor { + + /** + * Intercepts a signal. + * + * @param item The signal object. + * @return The received signal modified (or null for excluding this signal from getting exported). + * If there's no operation needed to be done for a specific signal, it should be returned as + * is. + */ + T intercept(T item); +} diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java new file mode 100644 index 000000000..ac85aba18 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java @@ -0,0 +1,41 @@ +package io.opentelemetry.contrib.interceptor.common; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** Base class to reuse the code related to intercepting signals. */ +public class Interceptable { + private final Set> interceptors = new HashSet<>(); + + public void addInterceptor(Interceptor interceptor) { + interceptors.add(interceptor); + } + + protected Collection interceptAll(Collection items) { + List result = new ArrayList<>(); + + for (T item : items) { + T intercepted = intercept(item); + if (intercepted != null) { + result.add(intercepted); + } + } + + return result; + } + + private T intercept(T item) { + T intercepted = item; + for (Interceptor interceptor : interceptors) { + intercepted = interceptor.intercept(intercepted); + if (intercepted == null) { + break; + } + } + return intercepted; + } +} From f86d71f4cf5499bee46f600c636630f949ead200 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 15:46:30 +0200 Subject: [PATCH 03/20] Created and interceptable exporter for spans --- processors/build.gradle.kts | 1 + .../InterceptableSpanExporter.java | 35 ++++++++ .../InterceptableSpanExporterTest.java | 86 +++++++++++++++++++ 3 files changed, 122 insertions(+) create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java create mode 100644 processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java diff --git a/processors/build.gradle.kts b/processors/build.gradle.kts index 0030b610a..c24118550 100644 --- a/processors/build.gradle.kts +++ b/processors/build.gradle.kts @@ -13,4 +13,5 @@ java { dependencies { api("io.opentelemetry:opentelemetry-sdk") + testImplementation("io.opentelemetry:opentelemetry-sdk-testing") } diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java new file mode 100644 index 000000000..4eada2ce8 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -0,0 +1,35 @@ +package io.opentelemetry.contrib.interceptor; + +import io.opentelemetry.contrib.interceptor.common.Interceptable; +import io.opentelemetry.sdk.common.CompletableResultCode; +import io.opentelemetry.sdk.trace.data.SpanData; +import io.opentelemetry.sdk.trace.export.SpanExporter; +import java.util.Collection; + +/** Intercepts spans before delegating them to the real exporter. */ +public class InterceptableSpanExporter extends Interceptable implements SpanExporter { + private final SpanExporter delegate; + + public static InterceptableSpanExporter create(SpanExporter delegate) { + return new InterceptableSpanExporter(delegate); + } + + private InterceptableSpanExporter(SpanExporter delegate) { + this.delegate = delegate; + } + + @Override + public CompletableResultCode export(Collection spans) { + return delegate.export(interceptAll(spans)); + } + + @Override + public CompletableResultCode flush() { + return delegate.flush(); + } + + @Override + public CompletableResultCode shutdown() { + return delegate.shutdown(); + } +} diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java new file mode 100644 index 000000000..cb6e95fbd --- /dev/null +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java @@ -0,0 +1,86 @@ +package io.opentelemetry.contrib.interceptor; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.data.DelegatingSpanData; +import io.opentelemetry.sdk.trace.data.SpanData; +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class InterceptableSpanExporterTest { + private InMemorySpanExporter memorySpanExporter; + private Tracer tracer; + private InterceptableSpanExporter interceptable; + + @BeforeEach + public void setUp() { + memorySpanExporter = InMemorySpanExporter.create(); + interceptable = InterceptableSpanExporter.create(memorySpanExporter); + tracer = + SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(interceptable)) + .build() + .get("TestScope"); + } + + @Test + public void verifySpanModification() { + interceptable.addInterceptor( + item -> { + ModifiableSpanData modified = new ModifiableSpanData(item); + modified.attributes.put("global.attr", "from interceptor"); + return modified; + }); + + tracer.spanBuilder("Test span").setAttribute("local.attr", 10).startSpan().end(); + + List finishedSpanItems = memorySpanExporter.getFinishedSpanItems(); + assertEquals(1, finishedSpanItems.size()); + SpanData spanData = finishedSpanItems.get(0); + assertEquals(2, spanData.getAttributes().size()); + assertEquals( + "from interceptor", spanData.getAttributes().get(AttributeKey.stringKey("global.attr"))); + assertEquals(10, spanData.getAttributes().get(AttributeKey.longKey("local.attr"))); + } + + @Test + public void verifySpanFiltering() { + interceptable.addInterceptor( + item -> { + if (item.getName().contains("deleted")) { + return null; + } + return item; + }); + + tracer.spanBuilder("One span").startSpan().end(); + tracer.spanBuilder("This will get deleted").startSpan().end(); + tracer.spanBuilder("Another span").startSpan().end(); + + List finishedSpanItems = memorySpanExporter.getFinishedSpanItems(); + assertEquals(2, finishedSpanItems.size()); + assertEquals("One span", finishedSpanItems.get(0).getName()); + assertEquals("Another span", finishedSpanItems.get(1).getName()); + } + + private static class ModifiableSpanData extends DelegatingSpanData { + private final AttributesBuilder attributes = Attributes.builder(); + + protected ModifiableSpanData(SpanData delegate) { + super(delegate); + } + + @Override + public Attributes getAttributes() { + return attributes.putAll(super.getAttributes()).build(); + } + } +} From 238080cb721d52c9bdf53befd72be2ef2b3f9372 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 16:05:51 +0200 Subject: [PATCH 04/20] Created and interceptable exporter for metrics --- .../InterceptableMetricExporter.java | 42 ++++++ .../InterceptableMetricExporterTest.java | 124 ++++++++++++++++++ 2 files changed, 166 insertions(+) create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java create mode 100644 processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java new file mode 100644 index 000000000..41fb91f6e --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -0,0 +1,42 @@ +package io.opentelemetry.contrib.interceptor; + +import io.opentelemetry.contrib.interceptor.common.Interceptable; +import io.opentelemetry.sdk.common.CompletableResultCode; +import io.opentelemetry.sdk.metrics.InstrumentType; +import io.opentelemetry.sdk.metrics.data.AggregationTemporality; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.metrics.export.MetricExporter; +import java.util.Collection; + +public class InterceptableMetricExporter extends Interceptable + implements MetricExporter { + private final MetricExporter delegate; + + public static InterceptableMetricExporter create(MetricExporter delegate) { + return new InterceptableMetricExporter(delegate); + } + + private InterceptableMetricExporter(MetricExporter delegate) { + this.delegate = delegate; + } + + @Override + public CompletableResultCode export(Collection metrics) { + return delegate.export(interceptAll(metrics)); + } + + @Override + public CompletableResultCode flush() { + return delegate.flush(); + } + + @Override + public CompletableResultCode shutdown() { + return delegate.shutdown(); + } + + @Override + public AggregationTemporality getAggregationTemporality(InstrumentType instrumentType) { + return delegate.getAggregationTemporality(instrumentType); + } +} diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java new file mode 100644 index 000000000..e8860c9e0 --- /dev/null +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java @@ -0,0 +1,124 @@ +package io.opentelemetry.contrib.interceptor; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.sdk.common.InstrumentationScopeInfo; +import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.metrics.data.Data; +import io.opentelemetry.sdk.metrics.data.MetricData; +import io.opentelemetry.sdk.metrics.data.MetricDataType; +import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.testing.exporter.InMemoryMetricExporter; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class InterceptableMetricExporterTest { + private InMemoryMetricExporter memoryMetricExporter; + private SdkMeterProvider meterProvider; + private Meter meter; + private InterceptableMetricExporter interceptable; + + @BeforeEach + public void setUp() { + memoryMetricExporter = InMemoryMetricExporter.create(); + interceptable = InterceptableMetricExporter.create(memoryMetricExporter); + meterProvider = + SdkMeterProvider.builder() + .registerMetricReader(PeriodicMetricReader.create(interceptable)) + .build(); + meter = meterProvider.get("TestScope"); + } + + @Test + public void verifyMetricModification() { + interceptable.addInterceptor( + item -> { + ModifiableMetricData modified = new ModifiableMetricData(item); + modified.name = "ModifiedName"; + return modified; + }); + + meter.counterBuilder("OneCounter").build().add(1); + meterProvider.forceFlush(); + + List finishedMetricItems = memoryMetricExporter.getFinishedMetricItems(); + assertEquals(1, finishedMetricItems.size()); + assertEquals("ModifiedName", finishedMetricItems.get(0).getName()); + } + + @Test + public void verifyMetricFiltering() { + interceptable.addInterceptor( + item -> { + if (item.getName().contains("Deleted")) { + return null; + } + return item; + }); + + meter.counterBuilder("OneCounter").build().add(1); + meter.counterBuilder("DeletedCounter").build().add(1); + meter.counterBuilder("AnotherCounter").build().add(1); + meterProvider.forceFlush(); + + List finishedMetricItems = memoryMetricExporter.getFinishedMetricItems(); + assertEquals(2, finishedMetricItems.size()); + List names = new ArrayList<>(); + for (MetricData item : finishedMetricItems) { + names.add(item.getName()); + } + assertThat(names).containsExactlyInAnyOrder("OneCounter", "AnotherCounter"); + } + + private static class ModifiableMetricData implements MetricData { + private final MetricData delegate; + private String name; + + private ModifiableMetricData(MetricData delegate) { + this.delegate = delegate; + } + + @Override + public Resource getResource() { + return delegate.getResource(); + } + + @Override + public InstrumentationScopeInfo getInstrumentationScopeInfo() { + return delegate.getInstrumentationScopeInfo(); + } + + @Override + public String getName() { + if (name != null) { + return name; + } + return delegate.getName(); + } + + @Override + public String getDescription() { + return delegate.getDescription(); + } + + @Override + public String getUnit() { + return delegate.getUnit(); + } + + @Override + public MetricDataType getType() { + return delegate.getType(); + } + + @Override + public Data getData() { + return delegate.getData(); + } + } +} From e6835796598c85706c8a95db30960a560489f039 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 16:22:18 +0200 Subject: [PATCH 05/20] Created and interceptable exporter for logs --- .../InterceptableLogRecordExporter.java | 32 ++++ .../InterceptableMetricExporter.java | 7 +- .../InterceptableSpanExporter.java | 6 +- .../InterceptableLogRecordExporterTest.java | 144 ++++++++++++++++++ .../InterceptableMetricExporterTest.java | 2 +- .../InterceptableSpanExporterTest.java | 2 +- 6 files changed, 181 insertions(+), 12 deletions(-) create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java create mode 100644 processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java new file mode 100644 index 000000000..0f4bb5495 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java @@ -0,0 +1,32 @@ +package io.opentelemetry.contrib.interceptor; + +import io.opentelemetry.contrib.interceptor.common.Interceptable; +import io.opentelemetry.sdk.common.CompletableResultCode; +import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.logs.export.LogRecordExporter; +import java.util.Collection; + +/** Intercepts logs before delegating them to the real exporter. */ +public class InterceptableLogRecordExporter extends Interceptable + implements LogRecordExporter { + private final LogRecordExporter delegate; + + public InterceptableLogRecordExporter(LogRecordExporter delegate) { + this.delegate = delegate; + } + + @Override + public CompletableResultCode export(Collection logs) { + return delegate.export(interceptAll(logs)); + } + + @Override + public CompletableResultCode flush() { + return delegate.flush(); + } + + @Override + public CompletableResultCode shutdown() { + return delegate.shutdown(); + } +} diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java index 41fb91f6e..0f74c6462 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -8,15 +8,12 @@ import io.opentelemetry.sdk.metrics.export.MetricExporter; import java.util.Collection; +/** Intercepts metrics before delegating them to the real exporter. */ public class InterceptableMetricExporter extends Interceptable implements MetricExporter { private final MetricExporter delegate; - public static InterceptableMetricExporter create(MetricExporter delegate) { - return new InterceptableMetricExporter(delegate); - } - - private InterceptableMetricExporter(MetricExporter delegate) { + public InterceptableMetricExporter(MetricExporter delegate) { this.delegate = delegate; } diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java index 4eada2ce8..5543e9e77 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -10,11 +10,7 @@ public class InterceptableSpanExporter extends Interceptable implements SpanExporter { private final SpanExporter delegate; - public static InterceptableSpanExporter create(SpanExporter delegate) { - return new InterceptableSpanExporter(delegate); - } - - private InterceptableSpanExporter(SpanExporter delegate) { + public InterceptableSpanExporter(SpanExporter delegate) { this.delegate = delegate; } diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java new file mode 100644 index 000000000..4a4ecebc4 --- /dev/null +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java @@ -0,0 +1,144 @@ +package io.opentelemetry.contrib.interceptor; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.common.AttributesBuilder; +import io.opentelemetry.api.logs.Logger; +import io.opentelemetry.api.logs.Severity; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.sdk.common.InstrumentationScopeInfo; +import io.opentelemetry.sdk.logs.SdkLoggerProvider; +import io.opentelemetry.sdk.logs.data.Body; +import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; +import java.util.List; +import javax.annotation.Nullable; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class InterceptableLogRecordExporterTest { + private InMemoryLogRecordExporter memoryLogRecordExporter; + private Logger logger; + private InterceptableLogRecordExporter interceptable; + + @BeforeEach + public void setUp() { + memoryLogRecordExporter = InMemoryLogRecordExporter.create(); + interceptable = new InterceptableLogRecordExporter(memoryLogRecordExporter); + logger = + SdkLoggerProvider.builder() + .addLogRecordProcessor(SimpleLogRecordProcessor.create(interceptable)) + .build() + .get("TestScope"); + } + + @Test + public void verifyLogModification() { + interceptable.addInterceptor( + item -> { + ModifiableLogRecordData modified = new ModifiableLogRecordData(item); + modified.attributes.put("global.attr", "from interceptor"); + return modified; + }); + + logger + .logRecordBuilder() + .setBody("One log") + .setAttribute(AttributeKey.stringKey("local.attr"), "local") + .emit(); + + List finishedLogRecordItems = + memoryLogRecordExporter.getFinishedLogRecordItems(); + assertEquals(1, finishedLogRecordItems.size()); + LogRecordData logRecordData = finishedLogRecordItems.get(0); + assertEquals(2, logRecordData.getAttributes().size()); + assertEquals( + "from interceptor", + logRecordData.getAttributes().get(AttributeKey.stringKey("global.attr"))); + assertEquals("local", logRecordData.getAttributes().get(AttributeKey.stringKey("local.attr"))); + } + + @Test + public void verifyLogFiltering() { + interceptable.addInterceptor( + item -> { + if (item.getBody().asString().contains("deleted")) { + return null; + } + return item; + }); + + logger.logRecordBuilder().setBody("One log").emit(); + logger.logRecordBuilder().setBody("This log will be deleted").emit(); + logger.logRecordBuilder().setBody("Another log").emit(); + + List finishedLogRecordItems = memoryLogRecordExporter.getFinishedLogRecordItems(); + assertEquals(2, finishedLogRecordItems.size()); + assertEquals("One log", finishedLogRecordItems.get(0).getBody().asString()); + assertEquals("Another log", finishedLogRecordItems.get(1).getBody().asString()); + } + + private static class ModifiableLogRecordData implements LogRecordData { + private final LogRecordData delegate; + private final AttributesBuilder attributes = Attributes.builder(); + + private ModifiableLogRecordData(LogRecordData delegate) { + this.delegate = delegate; + } + + @Override + public Resource getResource() { + return delegate.getResource(); + } + + @Override + public InstrumentationScopeInfo getInstrumentationScopeInfo() { + return delegate.getInstrumentationScopeInfo(); + } + + @Override + public long getTimestampEpochNanos() { + return delegate.getTimestampEpochNanos(); + } + + @Override + public long getObservedTimestampEpochNanos() { + return delegate.getObservedTimestampEpochNanos(); + } + + @Override + public SpanContext getSpanContext() { + return delegate.getSpanContext(); + } + + @Override + public Severity getSeverity() { + return delegate.getSeverity(); + } + + @Nullable + @Override + public String getSeverityText() { + return delegate.getSeverityText(); + } + + @Override + public Body getBody() { + return delegate.getBody(); + } + + @Override + public Attributes getAttributes() { + return attributes.putAll(delegate.getAttributes()).build(); + } + + @Override + public int getTotalAttributeCount() { + return delegate.getTotalAttributeCount(); + } + } +} diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java index e8860c9e0..9850db454 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java @@ -26,7 +26,7 @@ class InterceptableMetricExporterTest { @BeforeEach public void setUp() { memoryMetricExporter = InMemoryMetricExporter.create(); - interceptable = InterceptableMetricExporter.create(memoryMetricExporter); + interceptable = new InterceptableMetricExporter(memoryMetricExporter); meterProvider = SdkMeterProvider.builder() .registerMetricReader(PeriodicMetricReader.create(interceptable)) diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java index cb6e95fbd..ac079775a 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java @@ -23,7 +23,7 @@ class InterceptableSpanExporterTest { @BeforeEach public void setUp() { memorySpanExporter = InMemorySpanExporter.create(); - interceptable = InterceptableSpanExporter.create(memorySpanExporter); + interceptable = new InterceptableSpanExporter(memorySpanExporter); tracer = SdkTracerProvider.builder() .addSpanProcessor(SimpleSpanProcessor.create(interceptable)) From 91a3c250a70bc243bf185f57487ca2e910ae3309 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 18:03:38 +0200 Subject: [PATCH 06/20] Creating README file --- processors/README.md | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 processors/README.md diff --git a/processors/README.md b/processors/README.md new file mode 100644 index 000000000..d0d5742dd --- /dev/null +++ b/processors/README.md @@ -0,0 +1,3 @@ +# Processors + +This module provides tools to intercept and process signals globally. From 8a48848284cc81256f9e6f6395f7aec2872bbb0e Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 18:06:25 +0200 Subject: [PATCH 07/20] Updating component_owners.yml --- .github/component_owners.yml | 3 +++ processors/README.md | 7 +++++++ 2 files changed, 10 insertions(+) diff --git a/.github/component_owners.yml b/.github/component_owners.yml index 9c7e26c0e..6c4983c29 100644 --- a/.github/component_owners.yml +++ b/.github/component_owners.yml @@ -47,6 +47,9 @@ components: - HaloFour noop-api: - jack-berg + processors: + - LikeTheSalad + - ? prometheus-collector: - jkwatson resource-providers: diff --git a/processors/README.md b/processors/README.md index d0d5742dd..2d47ff693 100644 --- a/processors/README.md +++ b/processors/README.md @@ -1,3 +1,10 @@ # Processors This module provides tools to intercept and process signals globally. + +## Component owners + +- [Cesar Munoz](https://github.com/LikeTheSalad), Elastic +- ? + +Learn more about component owners in [component_owners.yml](../.github/component_owners.yml). From 1af38672644e4555390a352cb2b948f6a73ef745 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Wed, 23 Aug 2023 18:09:37 +0200 Subject: [PATCH 08/20] Running spotlessApply --- .../interceptor/InterceptableLogRecordExporter.java | 5 +++++ .../contrib/interceptor/InterceptableMetricExporter.java | 5 +++++ .../contrib/interceptor/InterceptableSpanExporter.java | 5 +++++ .../contrib/interceptor/api/Interceptor.java | 5 +++++ .../contrib/interceptor/common/Interceptable.java | 5 +++++ .../interceptor/InterceptableLogRecordExporterTest.java | 8 +++++++- .../interceptor/InterceptableMetricExporterTest.java | 5 +++++ .../interceptor/InterceptableSpanExporterTest.java | 5 +++++ 8 files changed, 42 insertions(+), 1 deletion(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java index 0f4bb5495..813507a5b 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import io.opentelemetry.contrib.interceptor.common.Interceptable; diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java index 0f74c6462..d2b1f19a5 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import io.opentelemetry.contrib.interceptor.common.Interceptable; diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java index 5543e9e77..c8f974629 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import io.opentelemetry.contrib.interceptor.common.Interceptable; diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java index 3c39a3571..0be9d1394 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor.api; /** diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java index ac85aba18..e20449de8 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor.common; import io.opentelemetry.contrib.interceptor.api.Interceptor; diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java index 4a4ecebc4..57731a245 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -76,7 +81,8 @@ public void verifyLogFiltering() { logger.logRecordBuilder().setBody("This log will be deleted").emit(); logger.logRecordBuilder().setBody("Another log").emit(); - List finishedLogRecordItems = memoryLogRecordExporter.getFinishedLogRecordItems(); + List finishedLogRecordItems = + memoryLogRecordExporter.getFinishedLogRecordItems(); assertEquals(2, finishedLogRecordItems.size()); assertEquals("One log", finishedLogRecordItems.get(0).getBody().asString()); assertEquals("Another log", finishedLogRecordItems.get(1).getBody().asString()); diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java index 9850db454..1a362a706 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import static org.assertj.core.api.Assertions.assertThat; diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java index ac079775a..9fdc0ecb5 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.contrib.interceptor; import static org.junit.jupiter.api.Assertions.assertEquals; From 68f84f834485a089cea1bdd8b367ba98c15e396d Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Thu, 24 Aug 2023 13:42:36 +0200 Subject: [PATCH 09/20] Removing inheritance for interceptable exporters --- .../InterceptableLogRecordExporter.java | 14 ++++-- .../InterceptableMetricExporter.java | 13 ++++-- .../InterceptableSpanExporter.java | 12 +++-- .../common/ComposableInterceptor.java | 33 +++++++++++++ .../interceptor/common/Interceptable.java | 46 ------------------- .../contrib/interceptor/common/Utilities.java | 30 ++++++++++++ .../InterceptableLogRecordExporterTest.java | 13 ++++-- .../InterceptableMetricExporterTest.java | 13 ++++-- .../InterceptableSpanExporterTest.java | 13 ++++-- 9 files changed, 112 insertions(+), 75 deletions(-) create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java delete mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java create mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java index 813507a5b..d3519f02a 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java @@ -5,24 +5,28 @@ package io.opentelemetry.contrib.interceptor; -import io.opentelemetry.contrib.interceptor.common.Interceptable; +import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogRecordData; import io.opentelemetry.sdk.logs.export.LogRecordExporter; import java.util.Collection; /** Intercepts logs before delegating them to the real exporter. */ -public class InterceptableLogRecordExporter extends Interceptable - implements LogRecordExporter { +public class InterceptableLogRecordExporter implements LogRecordExporter { private final LogRecordExporter delegate; + private final Interceptor interceptor; - public InterceptableLogRecordExporter(LogRecordExporter delegate) { + public InterceptableLogRecordExporter( + LogRecordExporter delegate, Interceptor interceptor) { this.delegate = delegate; + this.interceptor = interceptor; } @Override public CompletableResultCode export(Collection logs) { - return delegate.export(interceptAll(logs)); + return delegate.export(interceptAll(logs, interceptor)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java index d2b1f19a5..39058c316 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -5,7 +5,9 @@ package io.opentelemetry.contrib.interceptor; -import io.opentelemetry.contrib.interceptor.common.Interceptable; +import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.metrics.InstrumentType; import io.opentelemetry.sdk.metrics.data.AggregationTemporality; @@ -14,17 +16,18 @@ import java.util.Collection; /** Intercepts metrics before delegating them to the real exporter. */ -public class InterceptableMetricExporter extends Interceptable - implements MetricExporter { +public class InterceptableMetricExporter implements MetricExporter { private final MetricExporter delegate; + private final Interceptor interceptor; - public InterceptableMetricExporter(MetricExporter delegate) { + public InterceptableMetricExporter(MetricExporter delegate, Interceptor interceptor) { this.delegate = delegate; + this.interceptor = interceptor; } @Override public CompletableResultCode export(Collection metrics) { - return delegate.export(interceptAll(metrics)); + return delegate.export(interceptAll(metrics, interceptor)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java index c8f974629..444f35f46 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -5,23 +5,27 @@ package io.opentelemetry.contrib.interceptor; -import io.opentelemetry.contrib.interceptor.common.Interceptable; +import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.trace.data.SpanData; import io.opentelemetry.sdk.trace.export.SpanExporter; import java.util.Collection; /** Intercepts spans before delegating them to the real exporter. */ -public class InterceptableSpanExporter extends Interceptable implements SpanExporter { +public class InterceptableSpanExporter implements SpanExporter { private final SpanExporter delegate; + private final Interceptor interceptor; - public InterceptableSpanExporter(SpanExporter delegate) { + public InterceptableSpanExporter(SpanExporter delegate, Interceptor interceptor) { this.delegate = delegate; + this.interceptor = interceptor; } @Override public CompletableResultCode export(Collection spans) { - return delegate.export(interceptAll(spans)); + return delegate.export(interceptAll(spans, interceptor)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java new file mode 100644 index 000000000..6b751ae56 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java @@ -0,0 +1,33 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.contrib.interceptor.common; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; +import java.util.ArrayList; +import java.util.List; + +/** Allows to run an item through a list of interceptors in the order they were added. */ +public final class ComposableInterceptor implements Interceptor { + private final List> interceptors = new ArrayList<>(); + + public void add(Interceptor interceptor) { + if (!interceptors.contains(interceptor)) { + interceptors.add(interceptor); + } + } + + @Override + public T intercept(T item) { + T intercepted = item; + for (Interceptor interceptor : interceptors) { + intercepted = interceptor.intercept(intercepted); + if (intercepted == null) { + break; + } + } + return intercepted; + } +} diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java deleted file mode 100644 index e20449de8..000000000 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Interceptable.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.contrib.interceptor.common; - -import io.opentelemetry.contrib.interceptor.api.Interceptor; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -/** Base class to reuse the code related to intercepting signals. */ -public class Interceptable { - private final Set> interceptors = new HashSet<>(); - - public void addInterceptor(Interceptor interceptor) { - interceptors.add(interceptor); - } - - protected Collection interceptAll(Collection items) { - List result = new ArrayList<>(); - - for (T item : items) { - T intercepted = intercept(item); - if (intercepted != null) { - result.add(intercepted); - } - } - - return result; - } - - private T intercept(T item) { - T intercepted = item; - for (Interceptor interceptor : interceptors) { - intercepted = interceptor.intercept(intercepted); - if (intercepted == null) { - break; - } - } - return intercepted; - } -} diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java new file mode 100644 index 000000000..9ca6d6512 --- /dev/null +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.contrib.interceptor.common; + +import io.opentelemetry.contrib.interceptor.api.Interceptor; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public final class Utilities { + + private Utilities() {} + + @SuppressWarnings("PreferredInterfaceType") + public static Collection interceptAll(Collection items, Interceptor interceptor) { + List result = new ArrayList<>(); + + for (T item : items) { + T intercepted = interceptor.intercept(item); + if (intercepted != null) { + result.add(intercepted); + } + } + + return result; + } +} diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java index 57731a245..8c34becc3 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java @@ -13,6 +13,7 @@ import io.opentelemetry.api.logs.Logger; import io.opentelemetry.api.logs.Severity; import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.contrib.interceptor.common.ComposableInterceptor; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.logs.SdkLoggerProvider; import io.opentelemetry.sdk.logs.data.Body; @@ -28,22 +29,24 @@ class InterceptableLogRecordExporterTest { private InMemoryLogRecordExporter memoryLogRecordExporter; private Logger logger; - private InterceptableLogRecordExporter interceptable; + private ComposableInterceptor interceptor; @BeforeEach public void setUp() { memoryLogRecordExporter = InMemoryLogRecordExporter.create(); - interceptable = new InterceptableLogRecordExporter(memoryLogRecordExporter); + interceptor = new ComposableInterceptor<>(); logger = SdkLoggerProvider.builder() - .addLogRecordProcessor(SimpleLogRecordProcessor.create(interceptable)) + .addLogRecordProcessor( + SimpleLogRecordProcessor.create( + new InterceptableLogRecordExporter(memoryLogRecordExporter, interceptor))) .build() .get("TestScope"); } @Test public void verifyLogModification() { - interceptable.addInterceptor( + interceptor.add( item -> { ModifiableLogRecordData modified = new ModifiableLogRecordData(item); modified.attributes.put("global.attr", "from interceptor"); @@ -69,7 +72,7 @@ public void verifyLogModification() { @Test public void verifyLogFiltering() { - interceptable.addInterceptor( + interceptor.add( item -> { if (item.getBody().asString().contains("deleted")) { return null; diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java index 1a362a706..f0ade8adb 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java @@ -9,6 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import io.opentelemetry.api.metrics.Meter; +import io.opentelemetry.contrib.interceptor.common.ComposableInterceptor; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.data.Data; @@ -26,22 +27,24 @@ class InterceptableMetricExporterTest { private InMemoryMetricExporter memoryMetricExporter; private SdkMeterProvider meterProvider; private Meter meter; - private InterceptableMetricExporter interceptable; + private ComposableInterceptor interceptor; @BeforeEach public void setUp() { memoryMetricExporter = InMemoryMetricExporter.create(); - interceptable = new InterceptableMetricExporter(memoryMetricExporter); + interceptor = new ComposableInterceptor<>(); meterProvider = SdkMeterProvider.builder() - .registerMetricReader(PeriodicMetricReader.create(interceptable)) + .registerMetricReader( + PeriodicMetricReader.create( + new InterceptableMetricExporter(memoryMetricExporter, interceptor))) .build(); meter = meterProvider.get("TestScope"); } @Test public void verifyMetricModification() { - interceptable.addInterceptor( + interceptor.add( item -> { ModifiableMetricData modified = new ModifiableMetricData(item); modified.name = "ModifiedName"; @@ -58,7 +61,7 @@ public void verifyMetricModification() { @Test public void verifyMetricFiltering() { - interceptable.addInterceptor( + interceptor.add( item -> { if (item.getName().contains("Deleted")) { return null; diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java index 9fdc0ecb5..5e79202b1 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java @@ -11,6 +11,7 @@ import io.opentelemetry.api.common.Attributes; import io.opentelemetry.api.common.AttributesBuilder; import io.opentelemetry.api.trace.Tracer; +import io.opentelemetry.contrib.interceptor.common.ComposableInterceptor; import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter; import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.data.DelegatingSpanData; @@ -23,22 +24,24 @@ class InterceptableSpanExporterTest { private InMemorySpanExporter memorySpanExporter; private Tracer tracer; - private InterceptableSpanExporter interceptable; + private ComposableInterceptor interceptor; @BeforeEach public void setUp() { memorySpanExporter = InMemorySpanExporter.create(); - interceptable = new InterceptableSpanExporter(memorySpanExporter); + interceptor = new ComposableInterceptor<>(); tracer = SdkTracerProvider.builder() - .addSpanProcessor(SimpleSpanProcessor.create(interceptable)) + .addSpanProcessor( + SimpleSpanProcessor.create( + new InterceptableSpanExporter(memorySpanExporter, interceptor))) .build() .get("TestScope"); } @Test public void verifySpanModification() { - interceptable.addInterceptor( + interceptor.add( item -> { ModifiableSpanData modified = new ModifiableSpanData(item); modified.attributes.put("global.attr", "from interceptor"); @@ -58,7 +61,7 @@ public void verifySpanModification() { @Test public void verifySpanFiltering() { - interceptable.addInterceptor( + interceptor.add( item -> { if (item.getName().contains("deleted")) { return null; From 5d7aaff25eb556058f690aa064a284fdd830a160 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Thu, 24 Aug 2023 13:44:54 +0200 Subject: [PATCH 10/20] Adding breedx-splk as component owner --- .github/component_owners.yml | 2 +- processors/README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/component_owners.yml b/.github/component_owners.yml index 6c4983c29..b42a6ef5f 100644 --- a/.github/component_owners.yml +++ b/.github/component_owners.yml @@ -49,7 +49,7 @@ components: - jack-berg processors: - LikeTheSalad - - ? + - breedx-splk prometheus-collector: - jkwatson resource-providers: diff --git a/processors/README.md b/processors/README.md index 2d47ff693..eda5acee6 100644 --- a/processors/README.md +++ b/processors/README.md @@ -5,6 +5,6 @@ This module provides tools to intercept and process signals globally. ## Component owners - [Cesar Munoz](https://github.com/LikeTheSalad), Elastic -- ? +- [Jason Plumb](https://github.com/breedx-splk), Splunk Learn more about component owners in [component_owners.yml](../.github/component_owners.yml). From 4f1014e21f7cbf0df53a59d9b61f2ebac8be2671 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Thu, 24 Aug 2023 14:08:40 +0200 Subject: [PATCH 11/20] Adding "interceptAll" as Interceptor default method --- .../InterceptableLogRecordExporter.java | 4 +-- .../InterceptableMetricExporter.java | 4 +-- .../InterceptableSpanExporter.java | 4 +-- .../contrib/interceptor/api/Interceptor.java | 18 +++++++++++ .../contrib/interceptor/common/Utilities.java | 30 ------------------- 5 files changed, 21 insertions(+), 39 deletions(-) delete mode 100644 processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java index d3519f02a..f94bd06e8 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java @@ -5,8 +5,6 @@ package io.opentelemetry.contrib.interceptor; -import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; - import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.logs.data.LogRecordData; @@ -26,7 +24,7 @@ public InterceptableLogRecordExporter( @Override public CompletableResultCode export(Collection logs) { - return delegate.export(interceptAll(logs, interceptor)); + return delegate.export(interceptor.interceptAll(logs)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java index 39058c316..8e4e11aa1 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -5,8 +5,6 @@ package io.opentelemetry.contrib.interceptor; -import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; - import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.metrics.InstrumentType; @@ -27,7 +25,7 @@ public InterceptableMetricExporter(MetricExporter delegate, Interceptor metrics) { - return delegate.export(interceptAll(metrics, interceptor)); + return delegate.export(interceptor.interceptAll(metrics)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java index 444f35f46..2660ecdd2 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -5,8 +5,6 @@ package io.opentelemetry.contrib.interceptor; -import static io.opentelemetry.contrib.interceptor.common.Utilities.interceptAll; - import io.opentelemetry.contrib.interceptor.api.Interceptor; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.trace.data.SpanData; @@ -25,7 +23,7 @@ public InterceptableSpanExporter(SpanExporter delegate, Interceptor in @Override public CompletableResultCode export(Collection spans) { - return delegate.export(interceptAll(spans, interceptor)); + return delegate.export(interceptor.interceptAll(spans)); } @Override diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java index 0be9d1394..9ba978724 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java @@ -5,6 +5,10 @@ package io.opentelemetry.contrib.interceptor.api; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + /** * Intercepts a signal before it gets exported. The signal can get updated and/or filtered out based * on each interceptor implementation. @@ -20,4 +24,18 @@ public interface Interceptor { * is. */ T intercept(T item); + + /** Intercepts a collection of signals. */ + default Collection interceptAll(Collection items) { + List result = new ArrayList<>(); + + for (T item : items) { + T intercepted = intercept(item); + if (intercepted != null) { + result.add(intercepted); + } + } + + return result; + } } diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java deleted file mode 100644 index 9ca6d6512..000000000 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/Utilities.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.contrib.interceptor.common; - -import io.opentelemetry.contrib.interceptor.api.Interceptor; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -public final class Utilities { - - private Utilities() {} - - @SuppressWarnings("PreferredInterfaceType") - public static Collection interceptAll(Collection items, Interceptor interceptor) { - List result = new ArrayList<>(); - - for (T item : items) { - T intercepted = interceptor.intercept(item); - if (intercepted != null) { - result.add(intercepted); - } - } - - return result; - } -} From 9f5c6d93c64b2775b5c119354bb231681970d725 Mon Sep 17 00:00:00 2001 From: LikeTheSalad <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:09:03 +0200 Subject: [PATCH 12/20] Update processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java Co-authored-by: Mateusz Rzeszutek --- .../io/opentelemetry/contrib/interceptor/api/Interceptor.java | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java index 9ba978724..7bb281a99 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java @@ -23,6 +23,7 @@ public interface Interceptor { * If there's no operation needed to be done for a specific signal, it should be returned as * is. */ + @Nullable T intercept(T item); /** Intercepts a collection of signals. */ From 266472f3671514b283aec692ebbdae31da08bf32 Mon Sep 17 00:00:00 2001 From: LikeTheSalad <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:09:21 +0200 Subject: [PATCH 13/20] Update processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java Co-authored-by: Mateusz Rzeszutek --- .../contrib/interceptor/common/ComposableInterceptor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java index 6b751ae56..28d867a02 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java @@ -11,7 +11,7 @@ /** Allows to run an item through a list of interceptors in the order they were added. */ public final class ComposableInterceptor implements Interceptor { - private final List> interceptors = new ArrayList<>(); + private final List> interceptors = new CopyOnWriteArrayList<>(); public void add(Interceptor interceptor) { if (!interceptors.contains(interceptor)) { From 33443fe371b3579b9662e5f79738a4b257944ab4 Mon Sep 17 00:00:00 2001 From: LikeTheSalad <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:09:39 +0200 Subject: [PATCH 14/20] Update processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java Co-authored-by: Mateusz Rzeszutek --- .../contrib/interceptor/common/ComposableInterceptor.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java index 28d867a02..1092d9f6d 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java @@ -14,9 +14,7 @@ public final class ComposableInterceptor implements Interceptor { private final List> interceptors = new CopyOnWriteArrayList<>(); public void add(Interceptor interceptor) { - if (!interceptors.contains(interceptor)) { - interceptors.add(interceptor); - } + interceptors.addIfAbsent(interceptor); } @Override From 0d6edb3e4702e43b494adf45d633fed267204f5e Mon Sep 17 00:00:00 2001 From: LikeTheSalad <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:10:52 +0200 Subject: [PATCH 15/20] Update processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java Co-authored-by: Mateusz Rzeszutek --- .../contrib/interceptor/InterceptableLogRecordExporter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java index f94bd06e8..732316854 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporter.java @@ -12,7 +12,7 @@ import java.util.Collection; /** Intercepts logs before delegating them to the real exporter. */ -public class InterceptableLogRecordExporter implements LogRecordExporter { +public final class InterceptableLogRecordExporter implements LogRecordExporter { private final LogRecordExporter delegate; private final Interceptor interceptor; From 8f61209128698b035b4eedfc417bd9f7ff2f26f2 Mon Sep 17 00:00:00 2001 From: LikeTheSalad <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:11:13 +0200 Subject: [PATCH 16/20] Update processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java Co-authored-by: Mateusz Rzeszutek --- .../contrib/interceptor/InterceptableLogRecordExporterTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java index 8c34becc3..a2d597093 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java @@ -32,7 +32,7 @@ class InterceptableLogRecordExporterTest { private ComposableInterceptor interceptor; @BeforeEach - public void setUp() { + void setUp() { memoryLogRecordExporter = InMemoryLogRecordExporter.create(); interceptor = new ComposableInterceptor<>(); logger = From 1faffe9c301ca40f217c99d1537b37b41215041c Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:15:56 +0200 Subject: [PATCH 17/20] Using CopyOnWriteArrayList in ComposableInterceptor --- .../contrib/interceptor/common/ComposableInterceptor.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java index 1092d9f6d..01fd4c8f5 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/common/ComposableInterceptor.java @@ -6,17 +6,18 @@ package io.opentelemetry.contrib.interceptor.common; import io.opentelemetry.contrib.interceptor.api.Interceptor; -import java.util.ArrayList; -import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; +import javax.annotation.Nullable; /** Allows to run an item through a list of interceptors in the order they were added. */ public final class ComposableInterceptor implements Interceptor { - private final List> interceptors = new CopyOnWriteArrayList<>(); + private final CopyOnWriteArrayList> interceptors = new CopyOnWriteArrayList<>(); public void add(Interceptor interceptor) { interceptors.addIfAbsent(interceptor); } + @Nullable @Override public T intercept(T item) { T intercepted = item; From 90fbc9d6df2fbc428b0ee20ef75a554b79ee4e82 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:16:08 +0200 Subject: [PATCH 18/20] Making exporters final --- .../contrib/interceptor/InterceptableMetricExporter.java | 2 +- .../contrib/interceptor/InterceptableSpanExporter.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java index 8e4e11aa1..4422fde75 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporter.java @@ -14,7 +14,7 @@ import java.util.Collection; /** Intercepts metrics before delegating them to the real exporter. */ -public class InterceptableMetricExporter implements MetricExporter { +public final class InterceptableMetricExporter implements MetricExporter { private final MetricExporter delegate; private final Interceptor interceptor; diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java index 2660ecdd2..275393a99 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporter.java @@ -12,7 +12,7 @@ import java.util.Collection; /** Intercepts spans before delegating them to the real exporter. */ -public class InterceptableSpanExporter implements SpanExporter { +public final class InterceptableSpanExporter implements SpanExporter { private final SpanExporter delegate; private final Interceptor interceptor; From 8c93d6c9ec074897e1e65fdcb68f7f7ce9b4aa98 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:16:21 +0200 Subject: [PATCH 19/20] Adding nullable imports --- .../io/opentelemetry/contrib/interceptor/api/Interceptor.java | 1 + 1 file changed, 1 insertion(+) diff --git a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java index 7bb281a99..f15246c10 100644 --- a/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java +++ b/processors/src/main/java/io/opentelemetry/contrib/interceptor/api/Interceptor.java @@ -8,6 +8,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; +import javax.annotation.Nullable; /** * Intercepts a signal before it gets exported. The signal can get updated and/or filtered out based From e044d7c7df30f9dd50497ff630b0f09ffe529575 Mon Sep 17 00:00:00 2001 From: Cesar Munoz <56847527+LikeTheSalad@users.noreply.github.com> Date: Fri, 25 Aug 2023 10:18:09 +0200 Subject: [PATCH 20/20] Making test functions package private --- .../interceptor/InterceptableLogRecordExporterTest.java | 4 ++-- .../interceptor/InterceptableMetricExporterTest.java | 6 +++--- .../contrib/interceptor/InterceptableSpanExporterTest.java | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java index a2d597093..ff336b347 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableLogRecordExporterTest.java @@ -45,7 +45,7 @@ void setUp() { } @Test - public void verifyLogModification() { + void verifyLogModification() { interceptor.add( item -> { ModifiableLogRecordData modified = new ModifiableLogRecordData(item); @@ -71,7 +71,7 @@ public void verifyLogModification() { } @Test - public void verifyLogFiltering() { + void verifyLogFiltering() { interceptor.add( item -> { if (item.getBody().asString().contains("deleted")) { diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java index f0ade8adb..6b12d5f1a 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableMetricExporterTest.java @@ -30,7 +30,7 @@ class InterceptableMetricExporterTest { private ComposableInterceptor interceptor; @BeforeEach - public void setUp() { + void setUp() { memoryMetricExporter = InMemoryMetricExporter.create(); interceptor = new ComposableInterceptor<>(); meterProvider = @@ -43,7 +43,7 @@ public void setUp() { } @Test - public void verifyMetricModification() { + void verifyMetricModification() { interceptor.add( item -> { ModifiableMetricData modified = new ModifiableMetricData(item); @@ -60,7 +60,7 @@ public void verifyMetricModification() { } @Test - public void verifyMetricFiltering() { + void verifyMetricFiltering() { interceptor.add( item -> { if (item.getName().contains("Deleted")) { diff --git a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java index 5e79202b1..35c3afaaa 100644 --- a/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java +++ b/processors/src/test/java/io/opentelemetry/contrib/interceptor/InterceptableSpanExporterTest.java @@ -27,7 +27,7 @@ class InterceptableSpanExporterTest { private ComposableInterceptor interceptor; @BeforeEach - public void setUp() { + void setUp() { memorySpanExporter = InMemorySpanExporter.create(); interceptor = new ComposableInterceptor<>(); tracer = @@ -40,7 +40,7 @@ public void setUp() { } @Test - public void verifySpanModification() { + void verifySpanModification() { interceptor.add( item -> { ModifiableSpanData modified = new ModifiableSpanData(item); @@ -60,7 +60,7 @@ public void verifySpanModification() { } @Test - public void verifySpanFiltering() { + void verifySpanFiltering() { interceptor.add( item -> { if (item.getName().contains("deleted")) {