feat: get route info in spring-cloud-gateway

instrumentation/spring/spring-cloud-gateway/README.md

@@ -0,0 +1,5 @@
+# Settings for the Spring Cloud Gateway instrumentation
+
+| System property                                                          | Type    | Default | Description                                                                                 |
+|--------------------------------------------------------------------------| ------- | ------- |---------------------------------------------------------------------------------------------|
+| `otel.instrumentation.spring-cloud-gateway.experimental-span-attributes` | Boolean | `false` | Enable the capture of experimental span attributes.                                         |

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/build.gradle.kts

@@ -0,0 +1,49 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("org.springframework.cloud")
+    module.set("spring-cloud-starter-gateway")
+    versions.set("[2.0.0.RELEASE,]")
+  }
+}
+
+dependencies {
+  library("org.springframework.cloud:spring-cloud-starter-gateway:2.0.0.RELEASE")
+
+  testInstrumentation(project(":instrumentation:netty:netty-4.1:javaagent"))
+  testInstrumentation(project(":instrumentation:reactor:reactor-3.1:javaagent"))
+  testInstrumentation(project(":instrumentation:reactor:reactor-netty:reactor-netty-1.0:javaagent"))
+  testInstrumentation(project(":instrumentation:spring:spring-webflux:spring-webflux-5.0:javaagent"))
+
+  testLibrary("org.springframework.boot:spring-boot-starter-test:2.0.0.RELEASE")
+}
+
+tasks.withType<Test>().configureEach {
+  jvmArgs("-Dotel.instrumentation.spring-cloud-gateway.experimental-span-attributes=true")
+
+  // required on jdk17
+  jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
+  jvmArgs("-XX:+IgnoreUnrecognizedVMOptions")
+
+  systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean)
+}
+
+val latestDepTest = findProperty("testLatestDeps") as Boolean
+
+if (latestDepTest) {
+  // spring 6 requires java 17
+  otelJava {
+    minJavaVersionSupported.set(JavaVersion.VERSION_17)
+  }
+} else {
+  // spring 5 requires old logback (and therefore also old slf4j)
+  configurations.testRuntimeClasspath {
+    resolutionStrategy {
+      force("ch.qos.logback:logback-classic:1.2.11")
+      force("org.slf4j:slf4j-api:1.7.36")
+    }
+  }
+}

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/gateway/v2_0/GatewayInstrumentationModule.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.spring.gateway.v2_0;
+
+import static java.util.Arrays.asList;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import java.util.List;
+
+@AutoService(InstrumentationModule.class)
+public class GatewayInstrumentationModule extends InstrumentationModule {
+
+  public GatewayInstrumentationModule() {
+    super("spring-cloud-gateway");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return asList(new HandlerAdapterInstrumentation());
+  }
+
+  @Override
+  public int order() {
+    // Later than Spring Webflux.
+    return 1;
+  }
+}

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/gateway/v2_0/GatewaySingletons.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.spring.gateway.v2_0;
+
+import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerRouteGetter;
+import org.springframework.web.server.ServerWebExchange;
+
+public final class GatewaySingletons {
+
+  private GatewaySingletons() {}
+
+  public static HttpServerRouteGetter<ServerWebExchange> httpRouteGetter() {
+    return (context, exchange) -> ServerWebExchangeHelper.extractServerRoute(exchange);
+  }
+}

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/gateway/v2_0/HandlerAdapterInstrumentation.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.spring.gateway.v2_0;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.implementsInterface;
+import static net.bytebuddy.matcher.ElementMatchers.isAbstract;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.isPublic;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.not;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerRoute;
+import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerRouteSource;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+import org.springframework.web.server.ServerWebExchange;
+
+public class HandlerAdapterInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("org.springframework.web.reactive.HandlerAdapter");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return not(isAbstract())
+        .and(implementsInterface(named("org.springframework.web.reactive.HandlerAdapter")));
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        isMethod()
+            .and(isPublic())
+            .and(named("handle"))
+            .and(takesArgument(0, named("org.springframework.web.server.ServerWebExchange")))
+            .and(takesArgument(1, Object.class))
+            .and(takesArguments(2)),
+        this.getClass().getName() + "$HandleAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class HandleAdvice {
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    public static void methodEnter(@Advice.Argument(0) ServerWebExchange exchange) {
+      Context context = Context.current();
+      // Update route info for server span.
+      HttpServerRoute.update(
+          context,
+          HttpServerRouteSource.NESTED_CONTROLLER,
+          GatewaySingletons.httpRouteGetter(),
+          exchange);
+      // Record route info in current span, should be webflux's span.
+      ServerWebExchangeHelper.extractAttributes(exchange, context);
+    }
+  }
+}

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/gateway/v2_0/ServerWebExchangeHelper.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.spring.gateway.v2_0;
+
+import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.internal.StringUtils;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.javaagent.bootstrap.internal.InstrumentationConfig;
+import java.util.regex.Pattern;
+import org.springframework.cloud.gateway.route.Route;
+import org.springframework.web.server.ServerWebExchange;
+
+public final class ServerWebExchangeHelper {
+
+  /** Route info key. */
+  private static final AttributeKey<String> ROUTE_INFO_ATTRIBUTES =
+      AttributeKey.stringKey("ROUTE_INFO");
+
+  private static final boolean CAPTURE_EXPERIMENTAL_SPAN_ATTRIBUTES;
+
+  static {
+    CAPTURE_EXPERIMENTAL_SPAN_ATTRIBUTES =
+        InstrumentationConfig.get()
+            .getBoolean(
+                "otel.instrumentation.spring-cloud-gateway.experimental-span-attributes", false);
+  }
+
+  /* Regex for UUID */
+  private static final Pattern UUID_REGEX =
+      Pattern.compile(
+          "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
+
+  private static final String INVALID_RANDOM_ROUTE_ID =
+      "org.springframework.util.AlternativeJdkIdGenerator@";
+
+  private ServerWebExchangeHelper() {}
+
+  public static void extractAttributes(ServerWebExchange exchange, Context context) {
+    // Record route info
+    Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
+    if (route != null && CAPTURE_EXPERIMENTAL_SPAN_ATTRIBUTES) {
+      Span currentSpan = Span.fromContext(context);
+      if (currentSpan == null) {
+        return;
+      }
+      currentSpan.setAttribute(ROUTE_INFO_ATTRIBUTES, summarizeRoute(route));
+    }
+  }
+
+  public static String extractServerRoute(ServerWebExchange exchange) {
+    Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
+    if (route != null) {
+      return convergeRouteId(route);
+    }
+    return null;
+  }
+
+  /**
+   * To avoid high cardinality, we ignore random UUID generated by Spring Cloud Gateway. Spring
+   * Cloud Gateway generate invalid random routeID, and it is fixed until 3.1.x
+   *
+   * @see <a
+   *     href="https://github.com/spring-cloud/spring-cloud-gateway/commit/5002fe2e0a2825ef47dd667cade37b844c276cf6"/>
+   */
+  private static String convergeRouteId(Route route) {
+    String routeId = route.getId();
+    if (StringUtils.isNullOrEmpty(routeId)) {
+      return null;
+    }
+    if (UUID_REGEX.matcher(routeId).matches()) {
+      return null;
+    }
+    if (routeId.startsWith(INVALID_RANDOM_ROUTE_ID)) {
+      return null;
+    }
+    return routeId;
+  }
+
+  private static String summarizeRoute(Route route) {
+    return "id='"
+        + route.getId()
+        + '\''
+        + ", uri="
+        + route.getUri()
+        + ", order="
+        + route.getOrder()
+        + ", filterSize="
+        + route.getFilters().size()
+        + '}';
+  }
+}

instrumentation/spring/spring-cloud-gateway/spring-cloud-gateway-2.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/spring/gateway/v2_0/GatewayRouteMappingTest.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.spring.gateway.v2_0;
+
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.SpanKind;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import io.opentelemetry.semconv.SemanticAttributes;
+import io.opentelemetry.testing.internal.armeria.client.WebClient;
+import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpResponse;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.boot.web.embedded.netty.NettyReactiveWebServerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+@ExtendWith(SpringExtension.class)
+@SpringBootTest(
+    webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
+    classes = {
+      GatewayTestApplication.class,
+      GatewayRouteMappingTest.ForceNettyAutoConfiguration.class
+    })
+class GatewayRouteMappingTest {
+
+  private static final AttributeKey<String> ROUTE_INFO_ATTRIBUTES =
+      AttributeKey.stringKey("ROUTE_INFO");
+
+  @TestConfiguration
+  static class ForceNettyAutoConfiguration {
+    @Bean
+    NettyReactiveWebServerFactory nettyFactory() {
+      return new NettyReactiveWebServerFactory();
+    }
+  }
+
+  @RegisterExtension
+  static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  @Value("${local.server.port}")
+  private int port;
+
+  private WebClient client;
+
+  @BeforeEach
+  void beforeEach() {
+    client = WebClient.builder("h1c://localhost:" + port).followRedirects().build();
+  }
+
+  @Test
+  void gatewayRouteMappingTest() {
+    String requestBody = "gateway";
+    AggregatedHttpResponse response = client.post("/gateway/echo", requestBody).aggregate().join();
+    assertThat(response.status().code()).isEqualTo(200);
+    assertThat(response.contentUtf8()).isEqualTo(requestBody);
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span ->
+                    span.hasName("POST path_route")
+                        .hasKind(SpanKind.SERVER)
+                        .hasAttribute(equalTo(SemanticAttributes.HTTP_ROUTE, "path_route")),
+                span ->
+                    span.hasAttributesSatisfying(
+                        satisfies(ROUTE_INFO_ATTRIBUTES, s -> s.contains("id='path_route'")),
+                        satisfies(
+                            ROUTE_INFO_ATTRIBUTES, s -> s.contains("uri=h1c://mock.response")))));
+  }
+
+  @Test
+  void gatewayRandomUuidRouteMappingTest() {
+    String requestBody = "gateway";
+    AggregatedHttpResponse response = client.post("/uuid/echo", requestBody).aggregate().join();
+    assertThat(response.status().code()).isEqualTo(200);
+    assertThat(response.contentUtf8()).isEqualTo(requestBody);
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span -> span.hasName("POST").hasKind(SpanKind.SERVER),
+                span ->
+                    span.hasAttributesSatisfying(
+                        satisfies(ROUTE_INFO_ATTRIBUTES, s -> s.contains("uri=h1c://mock.uuid")))));
+  }
+
+  @Test
+  void gatewayFakeUuidRouteMappingTest() {
+    String requestBody = "gateway";
+    String routeId = "ffffffff-ffff-ffff-ffff-ffff";
+    AggregatedHttpResponse response = client.post("/fake/echo", requestBody).aggregate().join();
+    assertThat(response.status().code()).isEqualTo(200);
+    assertThat(response.contentUtf8()).isEqualTo(requestBody);
+    testing.waitAndAssertTraces(
+        trace ->
+            trace.hasSpansSatisfyingExactly(
+                span ->
+                    span.hasName("POST " + routeId)
+                        .hasKind(SpanKind.SERVER)
+                        .hasAttribute(equalTo(SemanticAttributes.HTTP_ROUTE, routeId)),
+                span ->
+                    span.hasAttributesSatisfying(
+                        satisfies(ROUTE_INFO_ATTRIBUTES, s -> s.contains("uri=h1c://mock.fake")))));
+  }
+}