Spring boot 4 support for RestClient

instrumentation/spring/spring-boot-autoconfigure/build.gradle.kts

@@ -134,6 +134,7 @@ dependencies {
   add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-kafka-2.7:library"))
   add("javaSpring4CompileOnly", project(":instrumentation:mongo:mongo-3.1:library"))
   add("javaSpring4CompileOnly", project(":instrumentation:micrometer:micrometer-1.5:library"))
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-web:spring-web-3.1:library"))
 }
 
 val latestDepTest = findProperty("testLatestDeps") as Boolean
@@ -221,6 +222,7 @@ testing {
         implementation(project(":instrumentation:spring:spring-webmvc:spring-webmvc-6.0:library"))
         implementation("jakarta.servlet:jakarta.servlet-api:5.0.0")
         implementation("org.springframework.boot:spring-boot-starter-test:$version")
+        implementation(project(":instrumentation:spring:spring-boot-autoconfigure:testing"))
       }
     }
 

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/web/RestClientBeanPostProcessorSpring4.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.InstrumentationConfigUtil;
+import io.opentelemetry.instrumentation.spring.web.v3_1.SpringWebTelemetry;
+import io.opentelemetry.instrumentation.spring.web.v3_1.internal.WebTelemetryUtil;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.web.client.RestClient;
+
+final class RestClientBeanPostProcessorSpring4 implements BeanPostProcessor {
+
+  private final ObjectProvider<OpenTelemetry> openTelemetryProvider;
+  private final ObjectProvider<InstrumentationConfig> configProvider;
+
+  public RestClientBeanPostProcessorSpring4(
+      ObjectProvider<OpenTelemetry> openTelemetryProvider,
+      ObjectProvider<InstrumentationConfig> configProvider) {
+    this.openTelemetryProvider = openTelemetryProvider;
+    this.configProvider = configProvider;
+  }
+
+  @Override
+  public Object postProcessAfterInitialization(Object bean, String beanName) {
+    if (bean instanceof RestClient restClient) {
+      return addRestClientInterceptorIfNotPresent(
+          restClient, openTelemetryProvider.getObject(), configProvider.getObject());
+    }
+    return bean;
+  }
+
+  private static RestClient addRestClientInterceptorIfNotPresent(
+      RestClient restClient, OpenTelemetry openTelemetry, InstrumentationConfig config) {
+    ClientHttpRequestInterceptor instrumentationInterceptor = getInterceptor(openTelemetry, config);
+
+    AtomicBoolean interceptorAdded = new AtomicBoolean(false);
+    RestClient.Builder result =
+        restClient
+            .mutate()
+            .requestInterceptors(
+                interceptors -> {
+                  if (isInterceptorNotPresent(interceptors, instrumentationInterceptor)) {
+                    interceptors.add(0, instrumentationInterceptor);
+                    interceptorAdded.set(true);
+                  }
+                });
+
+    return interceptorAdded.get() ? result.build() : restClient;
+  }
+
+  private static boolean isInterceptorNotPresent(
+      List<ClientHttpRequestInterceptor> interceptors,
+      ClientHttpRequestInterceptor instrumentationInterceptor) {
+    return interceptors.stream()
+        .noneMatch(interceptor -> interceptor.getClass() == instrumentationInterceptor.getClass());
+  }
+
+  static ClientHttpRequestInterceptor getInterceptor(
+      OpenTelemetry openTelemetry, InstrumentationConfig config) {
+    return InstrumentationConfigUtil.configureClientBuilder(
+            config,
+            SpringWebTelemetry.builder(openTelemetry),
+            WebTelemetryUtil.getBuilderExtractor())
+        .build()
+        .newInterceptor();
+  }
+}

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/web/RestClientInstrumentationSpringBoot4AutoConfiguration.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.restclient.RestClientCustomizer;
+import org.springframework.boot.restclient.autoconfigure.RestClientAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestClient;
+
+/**
+ * Configures {@link RestClient} for tracing.
+ *
+ * <p>Adds OpenTelemetry instrumentation to {@link RestClient} beans after initialization.
+ *
+ * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
+ * at any time.
+ */
+@ConditionalOnEnabledInstrumentation(module = "spring-web")
+@ConditionalOnClass({RestClient.class, RestClientCustomizer.class})
+@AutoConfiguration(after = RestClientAutoConfiguration.class)
+@Configuration
+public class RestClientInstrumentationSpringBoot4AutoConfiguration {
+
+  @Bean
+  static RestClientBeanPostProcessorSpring4 otelRestClientBeanPostProcessor(
+      ObjectProvider<OpenTelemetry> openTelemetryProvider,
+      ObjectProvider<InstrumentationConfig> configProvider) {
+    return new RestClientBeanPostProcessorSpring4(openTelemetryProvider, configProvider);
+  }
+
+  @Bean
+  RestClientCustomizer otelRestClientCustomizer(
+      ObjectProvider<OpenTelemetry> openTelemetryProvider,
+      ObjectProvider<InstrumentationConfig> configProvider) {
+    return builder ->
+        builder.requestInterceptor(
+            RestClientBeanPostProcessorSpring4.getInterceptor(
+                openTelemetryProvider.getObject(), configProvider.getObject()));
+  }
+}

instrumentation/spring/spring-boot-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -15,6 +15,7 @@ io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.w
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web.SpringWebInstrumentationSpringBoot4AutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.webflux.SpringWebfluxInstrumentationAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web.RestClientInstrumentationAutoConfiguration
+io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web.RestClientInstrumentationSpringBoot4AutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.webmvc.SpringWebMvc6InstrumentationAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.scheduling.SpringSchedulingInstrumentationAutoConfiguration
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.runtimemetrics.RuntimeMetricsAutoConfiguration

instrumentation/spring/spring-boot-autoconfigure/src/testSpring3/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/web/RestClientInstrumentationAutoConfigurationTest.java

@@ -5,86 +5,19 @@
 
 package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import io.opentelemetry.api.OpenTelemetry;
-import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
-import io.opentelemetry.instrumentation.spring.autoconfigure.internal.properties.ConfigPropertiesBridge;
-import io.opentelemetry.sdk.autoconfigure.spi.internal.DefaultConfigProperties;
-import java.util.Collections;
-import org.junit.jupiter.api.Test;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.AbstractRestClientInstrumentationAutoConfigurationTest;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.web.client.RestClient;
-
-class RestClientInstrumentationAutoConfigurationTest {
-
-  private final ApplicationContextRunner contextRunner =
-      new ApplicationContextRunner()
-          .withBean(OpenTelemetry.class, OpenTelemetry::noop)
-          .withBean(
-              InstrumentationConfig.class,
-              () ->
-                  new ConfigPropertiesBridge(
-                      DefaultConfigProperties.createFromMap(Collections.emptyMap())))
-          .withBean(RestClient.class, RestClient::create)
-          .withConfiguration(
-              AutoConfigurations.of(RestClientInstrumentationAutoConfiguration.class));
 
-  /**
-   * Tests the case that users create a {@link RestClient} bean themselves.
-   *
-   * <pre>{@code
-   * @Bean public RestClient restClient() {
-   *     return new RestClient();
-   * }
-   * }</pre>
-   */
-  @Test
-  void instrumentationEnabled() {
-    contextRunner
-        .withPropertyValues("otel.instrumentation.spring-web.enabled=true")
-        .run(
-            context -> {
-              assertThat(
-                      context.getBean(
-                          "otelRestClientBeanPostProcessor", RestClientBeanPostProcessor.class))
-                  .isNotNull();
-
-              context
-                  .getBean(RestClient.class)
-                  .mutate()
-                  .requestInterceptors(
-                      interceptors -> {
-                        long count =
-                            interceptors.stream()
-                                .filter(
-                                    rti ->
-                                        rti.getClass()
-                                            .getName()
-                                            .startsWith("io.opentelemetry.instrumentation"))
-                                .count();
-                        assertThat(count).isEqualTo(1);
-                      });
-            });
-  }
+class RestClientInstrumentationAutoConfigurationTest
+    extends AbstractRestClientInstrumentationAutoConfigurationTest {
 
-  @Test
-  void instrumentationDisabled() {
-    contextRunner
-        .withPropertyValues("otel.instrumentation.spring-web.enabled=false")
-        .run(
-            context ->
-                assertThat(context.containsBean("otelRestClientBeanPostProcessor")).isFalse());
+  @Override
+  protected AutoConfigurations autoConfigurations() {
+    return AutoConfigurations.of(RestClientInstrumentationAutoConfiguration.class);
   }
 
-  @Test
-  void defaultConfiguration() {
-    contextRunner.run(
-        context ->
-            assertThat(
-                    context.getBean(
-                        "otelRestClientBeanPostProcessor", RestClientBeanPostProcessor.class))
-                .isNotNull());
+  @Override
+  protected Class<?> postProcessorClass() {
+    return RestClientBeanPostProcessor.class;
   }
 }

instrumentation/spring/spring-boot-autoconfigure/src/testSpring4/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/web/RestClientInstrumentationSpringBoot4AutoConfigurationTest.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.AbstractRestClientInstrumentationAutoConfigurationTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.web.client.RestClient;
+
+class RestClientInstrumentationSpringBoot4AutoConfigurationTest
+    extends AbstractRestClientInstrumentationAutoConfigurationTest {
+
+  @Override
+  protected AutoConfigurations autoConfigurations() {
+    return AutoConfigurations.of(RestClientInstrumentationSpringBoot4AutoConfiguration.class);
+  }
+
+  @Override
+  protected Class<?> postProcessorClass() {
+    return RestClientBeanPostProcessorSpring4.class;
+  }
+
+  @Test
+  void shouldNotCreateNewBeanWhenInterceptorAlreadyPresent() {
+    contextRunner
+        .withPropertyValues("otel.instrumentation.spring-web.enabled=true")
+        .run(
+            context -> {
+              RestClientBeanPostProcessorSpring4 beanPostProcessor =
+                  context.getBean(
+                      "otelRestClientBeanPostProcessor", RestClientBeanPostProcessorSpring4.class);
+
+              RestClient restClientWithInterceptor =
+                  RestClient.builder()
+                      .requestInterceptor(
+                          RestClientBeanPostProcessor.getInterceptor(
+                              context.getBean(OpenTelemetry.class),
+                              context.getBean(InstrumentationConfig.class)))
+                      .build();
+
+              RestClient processed =
+                  (RestClient)
+                      beanPostProcessor.postProcessAfterInitialization(
+                          restClientWithInterceptor, "testBean");
+
+              // Should return the same instance when interceptor is already present
+              assertThat(processed).isSameAs(restClientWithInterceptor);
+
+              // Verify only one interceptor exists
+              processed
+                  .mutate()
+                  .requestInterceptors(
+                      interceptors -> {
+                        long count =
+                            interceptors.stream()
+                                .filter(
+                                    rti ->
+                                        rti.getClass()
+                                            .getName()
+                                            .startsWith("io.opentelemetry.instrumentation"))
+                                .count();
+                        assertThat(count).isEqualTo(1);
+                      });
+            });
+  }
+}