Exclude uri from otel tracing

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/tracing/DropApplicationUrisBuildItem.java

@@ -0,0 +1,19 @@
+package io.quarkus.opentelemetry.deployment.tracing;
+
+import io.quarkus.builder.item.MultiBuildItem;
+
+/**
+ * Represents an application uri that must be ignored for tracing.
+ */
+public final class DropApplicationUrisBuildItem extends MultiBuildItem {
+
+ private final String uri;
+
+ public DropApplicationUrisBuildItem(String uri) {
+ this.uri = uri;
+ }
+
+ public String uri() {
+ return uri;
+ }
+}

extensions/opentelemetry/deployment/src/main/java/io/quarkus/opentelemetry/deployment/tracing/TracerProcessor.java

@@ -10,15 +10,18 @@
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BooleanSupplier;
 
 import jakarta.enterprise.inject.spi.EventContext;
 import jakarta.inject.Singleton;
 
+import org.eclipse.microprofile.config.ConfigProvider;
 import org.jboss.jandex.AnnotationInstance;
 import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.ClassInfo;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.FieldInfo;
 import org.jboss.jandex.IndexView;
@@ -53,6 +56,7 @@
 import io.quarkus.opentelemetry.runtime.config.build.OTelBuildConfig;
 import io.quarkus.opentelemetry.runtime.config.build.OTelBuildConfig.SecurityEvents.SecurityEventType;
 import io.quarkus.opentelemetry.runtime.tracing.DelayedAttributes;
+import io.quarkus.opentelemetry.runtime.tracing.Traceless;
 import io.quarkus.opentelemetry.runtime.tracing.TracerRecorder;
 import io.quarkus.opentelemetry.runtime.tracing.cdi.TracerProducer;
 import io.quarkus.opentelemetry.runtime.tracing.security.EndUserSpanProcessor;
@@ -69,6 +73,8 @@ public class TracerProcessor {
  private static final DotName SPAN_EXPORTER = DotName.createSimple(SpanExporter.class.getName());
  private static final DotName SPAN_PROCESSOR = DotName.createSimple(SpanProcessor.class.getName());
  private static final DotName TEXT_MAP_PROPAGATOR = DotName.createSimple(TextMapPropagator.class.getName());
+ private static final DotName TRACELESS = DotName.createSimple(Traceless.class.getName());
+ private static final DotName PATH = DotName.createSimple("jakarta.ws.rs.Path");
 
  @BuildStep
  UnremovableBeanBuildItem ensureProducersAreRetained(
@@ -131,15 +137,31 @@ UnremovableBeanBuildItem ensureProducersAreRetained(
  return new UnremovableBeanBuildItem(new UnremovableBeanBuildItem.BeanClassNamesExclusion(retainProducers));
  }
 
+ @BuildStep
+ void dropApplicationUris(
+ CombinedIndexBuildItem combinedIndexBuildItem,
+ BuildProducer<DropApplicationUrisBuildItem> uris) {
+ String rootPath = ConfigProvider.getConfig().getOptionalValue("quarkus.http.root-path", String.class).orElse("/");
+ IndexView index = combinedIndexBuildItem.getIndex();
+ Collection<AnnotationInstance> annotations = index.getAnnotations(TRACELESS);
+ Set<String> tracelessUris = generateTracelessUris(annotations.stream().toList(), rootPath);
+ for (String uri : tracelessUris) {
+ uris.produce(new DropApplicationUrisBuildItem(uri));
+ }
+ }
+
  @BuildStep
  void dropNames(
  Optional<FrameworkEndpointsBuildItem> frameworkEndpoints,
  Optional<StaticResourcesBuildItem> staticResources,
  BuildProducer<DropNonApplicationUrisBuildItem> dropNonApplicationUris,
- BuildProducer<DropStaticResourcesBuildItem> dropStaticResources) {
+ BuildProducer<DropStaticResourcesBuildItem> dropStaticResources,
+ List<DropApplicationUrisBuildItem> applicationUris) {
+
+ List<String> nonApplicationUris = new ArrayList<>(
+ applicationUris.stream().map(DropApplicationUrisBuildItem::uri).toList());
 
  // Drop framework paths
- List<String> nonApplicationUris = new ArrayList<>();
  frameworkEndpoints.ifPresent(
  frameworkEndpointsBuildItem -> {
  for (String endpoint : frameworkEndpointsBuildItem.getEndpoints()) {
@@ -170,6 +192,67 @@ void dropNames(
  dropStaticResources.produce(new DropStaticResourcesBuildItem(resources));
  }
 
+ private Set<String> generateTracelessUris(final List<AnnotationInstance> annotations, final String rootPath) {
+ final Set<String> applicationUris = new HashSet<>();
+ for (AnnotationInstance annotation : annotations) {
+ AnnotationTarget.Kind kind = annotation.target().kind();
+
+ switch (kind) {
+ case CLASS -> {
+ AnnotationInstance classAnnotated = annotation.target().asClass().annotations()
+ .stream().filter(TracerProcessor::isClassAnnotatedWithPath).findFirst().orElse(null);
+
+ if (Objects.isNull(classAnnotated)) {
+ continue;
+ }
+
+ String classPath = classAnnotated.value().asString();
+ String finalPath = combinePaths(rootPath, classPath);
+
+ if (containsPathExpression(finalPath)) {
+ applicationUris.add(sanitizeForTraceless(finalPath) + "*");
+ continue;
+ }
+
+ applicationUris.add(finalPath + "*");
+ applicationUris.add(finalPath);
+ }
+ case METHOD -> {
+ ClassInfo classInfo = annotation.target().asMethod().declaringClass();
+
+ AnnotationInstance possibleClassAnnotatedWithPath = classInfo.asClass()
+ .annotations()
+ .stream()
+ .filter(TracerProcessor::isClassAnnotatedWithPath)
+ .findFirst()
+ .orElse(null);
+
+ if (Objects.isNull(possibleClassAnnotatedWithPath)) {
+ continue;
+ }
+
+ String finalPath;
+ String classPath = possibleClassAnnotatedWithPath.value().asString();
+ AnnotationInstance possibleMethodAnnotatedWithPath = annotation.target().annotation(PATH);
+ if (possibleMethodAnnotatedWithPath != null) {
+ String methodValue = possibleMethodAnnotatedWithPath.value().asString();
+ finalPath = combinePaths(rootPath, combinePaths(classPath, methodValue));
+ } else {
+ finalPath = combinePaths(rootPath, classPath);
+ }
+
+ if (containsPathExpression(finalPath)) {
+ applicationUris.add(sanitizeForTraceless(finalPath) + "*");
+ continue;
+ }
+
+ applicationUris.add(finalPath);
+ }
+ }
+ }
+ return applicationUris;
+ }
+
  @BuildStep
  @Record(ExecutionTime.STATIC_INIT)
  SyntheticBeanBuildItem setupDelayedAttribute(TracerRecorder recorder, ApplicationInfoBuildItem appInfo) {
@@ -256,6 +339,37 @@ private static ObserverConfiguratorBuildItem createEventObserver(
  }));
  }
 
+ private static boolean containsPathExpression(String value) {
+ return value.indexOf('{') != -1;
+ }
+
+ private static String sanitizeForTraceless(final String path) {
+ int braceIndex = path.indexOf('{');
+ if (braceIndex == -1) {
+ return path;
+ }
+ if (braceIndex > 0 && path.charAt(braceIndex - 1) == '/') {
+ return path.substring(0, braceIndex - 1);
+ } else {
+ return path.substring(0, braceIndex);
+ }
+ }
+
+ private static boolean isClassAnnotatedWithPath(AnnotationInstance annotation) {
+ return annotation.target().kind().equals(AnnotationTarget.Kind.CLASS) &&
+ annotation.name().equals(PATH);
+ }
+
+ private String combinePaths(String basePath, String relativePath) {
+ if (!basePath.endsWith("/")) {
+ basePath += "/";
+ }
+ if (relativePath.startsWith("/")) {
+ relativePath = relativePath.substring(1);
+ }
+ return basePath + relativePath;
+ }
+
  static final class SecurityEventsEnabled implements BooleanSupplier {
 
  private final boolean enabled;

extensions/opentelemetry/deployment/src/test/java/io/quarkus/opentelemetry/deployment/OpenTelemetryTracelessTest.java

@@ -0,0 +1,128 @@
+package io.quarkus.opentelemetry.deployment;
+
+import static org.hamcrest.Matchers.is;
+
+import jakarta.inject.Inject;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.opentelemetry.deployment.common.exporter.InMemoryExporter;
+import io.quarkus.opentelemetry.deployment.common.exporter.InMemoryMetricExporterProvider;
+import io.quarkus.opentelemetry.deployment.common.traces.TraceMeResource;
+import io.quarkus.opentelemetry.deployment.common.traces.TracelessClassLevelResource;
+import io.quarkus.opentelemetry.deployment.common.traces.TracelessHelloResource;
+import io.quarkus.test.QuarkusUnitTest;
+import io.restassured.RestAssured;
+
+public class OpenTelemetryTracelessTest {
+ @RegisterExtension
+ static final QuarkusUnitTest TEST = new QuarkusUnitTest().setArchiveProducer(
+ () -> ShrinkWrap.create(JavaArchive.class)
+ .addPackage(InMemoryExporter.class.getPackage())
+ .addAsResource("resource-config/application.properties", "application.properties")
+ .addAsResource(
+ "META-INF/services-config/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider",
+ "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider")
+ .addAsResource(new StringAsset(InMemoryMetricExporterProvider.class.getCanonicalName()),
+ "META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider")
+ .addClasses(TracelessHelloResource.class, TracelessClassLevelResource.class, TraceMeResource.class));
+
+ @Inject
+ InMemoryExporter exporter;
+
+ @BeforeEach
+ void setup() {
+ exporter.reset();
+ }
+
+ @Test
+ @DisplayName("Should not trace when the method @Path uses @PathParam")
+ void testingWithPathParam() {
+ RestAssured.when()
+ .get("/hello/mask/1").then()
+ .statusCode(200)
+ .body(is("mask-1"));
+
+ RestAssured.when()
+ .get("/trace-me").then()
+ .statusCode(200)
+ .body(is("trace-me"));
+
+ exporter.getSpanExporter().getFinishedSpanItems(1);
+
+ }
+
+ @Test
+ @DisplayName("Should not trace when the annotation @Traceless is at method level")
+ void testingTracelessHelloHi() {
+
+ RestAssured.when()
+ .get("/hello").then()
+ .statusCode(200)
+ .body(is("hello"));
+
+ RestAssured.when()
+ .get("/hello/hi").then()
+ .statusCode(200)
+ .body(is("hi"));
+
+ RestAssured.when()
+ .get("/trace-me").then()
+ .statusCode(200)
+ .body(is("trace-me"));
+
+ // should have only one
+ exporter.getSpanExporter().getFinishedSpanItems(1);
+ }
+
+ @Test
+ @DisplayName("Should not trace when the method @Path is without '/'")
+ void testingHelloNoSlash() {
+ RestAssured.when()
+ .get("/hello/no-slash").then()
+ .statusCode(200)
+ .body(is("no-slash"));
+
+ RestAssured.when()
+ .get("/trace-me").then()
+ .statusCode(200)
+ .body(is("trace-me"));
+
+ // should have only one
+ exporter.getSpanExporter().getFinishedSpanItems(1);
+ }
+
+ @Test
+ @DisplayName("Should not trace when the annotation is at class level")
+ void testingTracelessAtClassLevel() {
+
+ RestAssured.when()
+ .get("class-level").then()
+ .statusCode(200)
+ .body(is("class-level"));
+
+ RestAssured.when()
+ .get("/class-level/first-method").then()
+ .statusCode(200)
+ .body(is("first-method"));
+
+ RestAssured.when()
+ .get("/class-level/second-method").then()
+ .statusCode(200)
+ .body(is("second-method"));
+
+ RestAssured.when()
+ .get("/trace-me").then()
+ .statusCode(200)
+ .body(is("trace-me"));
+
+ // should have only one
+ exporter.getSpanExporter().getFinishedSpanItems(1);
+ }
+}