Add spring boot 4 support for WebClientCustomizer

Signed-off-by: Lenin Jaganathan <lenin.jaganathan@gmail.com>

Author: lenin-jaganathan

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

@@ -128,13 +128,15 @@ dependencies {
   add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-jdbc:4.0.0")
   add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-jdbc:4.0.0")
   add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-restclient:4.0.0")
+  add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-webclient:4.0.0")
   add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-data-mongodb:4.0.0")
   add("javaSpring4CompileOnly", "org.springframework.boot:spring-boot-starter-micrometer-metrics:4.0.0")
   add("javaSpring4CompileOnly", project(":instrumentation:kafka:kafka-clients:kafka-clients-2.6:library"))
   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"))
+  add("javaSpring4CompileOnly", project(":instrumentation:spring:spring-webflux:spring-webflux-5.3:library"))
 }
 
 val latestDepTest = findProperty("testLatestDeps") as Boolean
@@ -233,6 +235,7 @@ testing {
         val version = if (latestDepTest) "latest.release" else "4.0.0"
         implementation("org.springframework.boot:spring-boot-starter-jdbc:$version")
         implementation("org.springframework.boot:spring-boot-restclient:$version")
+        implementation("org.springframework.boot:spring-boot-webclient:$version")
         implementation("org.springframework.boot:spring-boot-starter-kafka:$version")
         implementation("org.springframework.boot:spring-boot-starter-actuator:$version")
         implementation("org.springframework.boot:spring-boot-starter-data-r2dbc:$version")

instrumentation/spring/spring-boot-autoconfigure/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/webflux/SpringWebfluxInstrumentationAutoConfiguration.java

@@ -28,7 +28,7 @@
  * at any time.
  */
 @ConditionalOnEnabledInstrumentation(module = "spring-webflux")
-@ConditionalOnClass({WebClient.class, WebClientCustomizer.class})
+@ConditionalOnClass(WebClient.class)
 @Configuration
 public class SpringWebfluxInstrumentationAutoConfiguration {
 
@@ -42,18 +42,23 @@ static WebClientBeanPostProcessor otelWebClientBeanPostProcessor(
     return new WebClientBeanPostProcessor(openTelemetryProvider, configProvider);
   }
 
-  @Bean
-  @Order(Ordered.HIGHEST_PRECEDENCE + 10)
-  WebClientCustomizer otelWebClientCustomizer(
-      OpenTelemetry openTelemetry, InstrumentationConfig config) {
-    SpringWebfluxClientTelemetry webfluxClientTelemetry =
-        WebClientBeanPostProcessor.getWebfluxClientTelemetry(openTelemetry, config);
-    return builder -> builder.filters(webfluxClientTelemetry::addFilter);
-  }
-
   @Bean
   WebFilter telemetryFilter(OpenTelemetry openTelemetry, InstrumentationConfig config) {
     return WebClientBeanPostProcessor.getWebfluxServerTelemetry(openTelemetry, config)
         .createWebFilterAndRegisterReactorHook();
   }
+
+  @Configuration
+  @ConditionalOnClass(WebClientCustomizer.class)
+  static class OpentelemetryWebClientCustomizerConfiguration {
+
+    @Bean
+    @Order(Ordered.HIGHEST_PRECEDENCE + 10)
+    WebClientCustomizer otelWebClientCustomizer(
+        OpenTelemetry openTelemetry, InstrumentationConfig config) {
+      SpringWebfluxClientTelemetry webfluxClientTelemetry =
+          WebClientBeanPostProcessor.getWebfluxClientTelemetry(openTelemetry, config);
+      return builder -> builder.filters(webfluxClientTelemetry::addFilter);
+    }
+  }
 }

instrumentation/spring/spring-boot-autoconfigure/src/main/javaSpring4/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/webflux/SpringWebClientInstrumentationSpringBoot4AutoConfiguration.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.webflux;
+
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.instrumentation.api.incubator.config.internal.InstrumentationConfig;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.ConditionalOnEnabledInstrumentation;
+import io.opentelemetry.instrumentation.spring.webflux.v5_3.SpringWebfluxClientTelemetry;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.webclient.WebClientCustomizer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.web.reactive.function.client.WebClient;
+
+/**
+ * Configures {@link WebClient} for tracing.
+ *
+ * <p>Adds OpenTelemetry instrumentation via WebClientCustomizer for Spring boot 4.
+ *
+ * <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-webflux")
+@ConditionalOnClass({WebClient.class, WebClientCustomizer.class})
+@Configuration
+public class SpringWebClientInstrumentationSpringBoot4AutoConfiguration {
+
+  @Bean
+  @Order(Ordered.HIGHEST_PRECEDENCE + 10)
+  WebClientCustomizer otelWebClientCustomizer(
+      OpenTelemetry openTelemetry, InstrumentationConfig config) {
+    SpringWebfluxClientTelemetry webfluxClientTelemetry =
+        WebClientBeanPostProcessor.getWebfluxClientTelemetry(openTelemetry, config);
+    return builder -> builder.filters(webfluxClientTelemetry::addFilter);
+  }
+}

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

@@ -14,6 +14,7 @@ io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.r
 io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.web.SpringWebInstrumentationAutoConfiguration
 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.webflux.SpringWebClientInstrumentationSpringBoot4AutoConfiguration
 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

instrumentation/spring/spring-boot-autoconfigure/src/test/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/webflux/SpringWebfluxInstrumentationAutoConfigurationTest.java

@@ -7,87 +7,62 @@
 
 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 java.util.concurrent.atomic.AtomicLong;
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.AbstractWebClientCustomizerAutoConfigurationTest;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.boot.test.context.FilteredClassLoader;
 import org.springframework.boot.web.reactive.function.client.WebClientCustomizer;
 import org.springframework.web.reactive.function.client.WebClient;
 
-class SpringWebfluxInstrumentationAutoConfigurationTest {
+class SpringWebfluxInstrumentationAutoConfigurationTest
+    extends AbstractWebClientCustomizerAutoConfigurationTest {
 
-  private final ApplicationContextRunner contextRunner =
-      new ApplicationContextRunner()
-          .withBean(OpenTelemetry.class, OpenTelemetry::noop)
-          .withBean(
-              InstrumentationConfig.class,
-              () ->
-                  new ConfigPropertiesBridge(
-                      DefaultConfigProperties.createFromMap(Collections.emptyMap())))
-          .withConfiguration(
-              AutoConfigurations.of(SpringWebfluxInstrumentationAutoConfiguration.class));
+  @Override
+  protected AutoConfigurations autoConfigurations() {
+    return AutoConfigurations.of(SpringWebfluxInstrumentationAutoConfiguration.class);
+  }
+
+  @Override
+  protected Class<?> webClientCustomizerClass() {
+    return WebClientCustomizer.class;
+  }
+
+  @Override
+  protected void customizeWebClient(Object customizer, WebClient.Builder builder) {
+    ((WebClientCustomizer) customizer).customize(builder);
+  }
 
   @Test
-  void instrumentationEnabled() {
+  void shouldCreateBeanPostProcessorWhenEnabled() {
     contextRunner
         .withPropertyValues("otel.instrumentation.spring-webflux.enabled=true")
         .run(
             context ->
                 assertThat(context)
                     .hasBean("otelWebClientBeanPostProcessor")
-                    .hasBean("otelWebClientCustomizer"));
+                    .hasBean("telemetryFilter"));
   }
 
   @Test
-  void instrumentationDisabled() {
+  void shouldNotCreateBeanPostProcessorWhenDisabled() {
     contextRunner
         .withPropertyValues("otel.instrumentation.spring-webflux.enabled=false")
         .run(
             context ->
                 assertThat(context)
                     .doesNotHaveBean("otelWebClientBeanPostProcessor")
-                    .doesNotHaveBean("otelWebClientCustomizer"));
-  }
-
-  @Test
-  void defaultConfiguration() {
-    contextRunner.run(
-        context -> {
-          assertThat(context)
-              .hasBean("otelWebClientBeanPostProcessor")
-              .hasBean("otelWebClientCustomizer");
-        });
+                    .doesNotHaveBean("telemetryFilter"));
   }
 
   @Test
-  void shouldAddTracingFilterWhenCustomizerApplied() {
-    contextRunner.run(
-        context -> {
-          WebClientCustomizer customizer =
-              context.getBean("otelWebClientCustomizer", WebClientCustomizer.class);
-          WebClient.Builder builder = WebClient.builder();
-          customizer.customize(builder);
-
-          AtomicLong count = new AtomicLong(0);
-          builder
-              .build()
-              .mutate()
-              .filters(
-                  filters ->
-                      count.set(
-                          filters.stream()
-                              .filter(
-                                  f ->
-                                      f.getClass()
-                                          .getName()
-                                          .startsWith("io.opentelemetry.instrumentation"))
-                              .count()));
-          assertThat(count.get()).isEqualTo(1);
-        });
+  void shouldCreateBeanPostProcessorWhenWebClientCustomizerNotOnClasspath() {
+    contextRunner
+        .withClassLoader(new FilteredClassLoader(WebClientCustomizer.class))
+        .run(
+            context ->
+                assertThat(context)
+                    .hasBean("otelWebClientBeanPostProcessor")
+                    .hasBean("telemetryFilter")
+                    .doesNotHaveBean("otelWebClientCustomizer"));
   }
 }

instrumentation/spring/spring-boot-autoconfigure/src/testSpring4/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/instrumentation/webflux/SpringWebClientInstrumentationSpringBoot4AutoConfigurationTest.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal.instrumentation.webflux;
+
+import io.opentelemetry.instrumentation.spring.autoconfigure.internal.AbstractWebClientCustomizerAutoConfigurationTest;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.webclient.WebClientCustomizer;
+import org.springframework.web.reactive.function.client.WebClient;
+
+class SpringWebClientInstrumentationSpringBoot4AutoConfigurationTest
+    extends AbstractWebClientCustomizerAutoConfigurationTest {
+
+  @Override
+  protected AutoConfigurations autoConfigurations() {
+    return AutoConfigurations.of(SpringWebClientInstrumentationSpringBoot4AutoConfiguration.class);
+  }
+
+  @Override
+  protected Class<?> webClientCustomizerClass() {
+    return WebClientCustomizer.class;
+  }
+
+  @Override
+  protected void customizeWebClient(Object customizer, WebClient.Builder builder) {
+    ((WebClientCustomizer) customizer).customize(builder);
+  }
+}

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

@@ -6,6 +6,7 @@ val springBootVersion = "2.7.18"
 
 dependencies {
   compileOnly("org.springframework.boot:spring-boot-restclient:4.0.0")
+  compileOnly("org.springframework.boot:spring-boot-starter-webflux:$springBootVersion")
   compileOnly("org.springframework.kafka:spring-kafka:2.9.0")
 
   compileOnly("org.springframework.boot:spring-boot-starter-test:$springBootVersion")

instrumentation/spring/spring-boot-autoconfigure/testing/src/main/java/io/opentelemetry/instrumentation/spring/autoconfigure/internal/AbstractWebClientCustomizerAutoConfigurationTest.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.spring.autoconfigure.internal;
+
+import static java.util.Collections.emptyMap;
+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.concurrent.atomic.AtomicLong;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.test.context.FilteredClassLoader;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.web.reactive.function.client.WebClient;
+
+/**
+ * Abstract base test for WebClient customizer auto-configurations. Subclasses must provide the
+ * auto-configuration class and WebClientCustomizer class for their Spring Boot version.
+ */
+public abstract class AbstractWebClientCustomizerAutoConfigurationTest {
+
+  protected abstract AutoConfigurations autoConfigurations();
+
+  protected abstract Class<?> webClientCustomizerClass();
+
+  protected abstract void customizeWebClient(Object customizer, WebClient.Builder builder);
+
+  protected final ApplicationContextRunner contextRunner =
+      new ApplicationContextRunner()
+          .withBean(OpenTelemetry.class, OpenTelemetry::noop)
+          .withBean(
+              InstrumentationConfig.class,
+              () -> new ConfigPropertiesBridge(DefaultConfigProperties.createFromMap(emptyMap())))
+          .withConfiguration(autoConfigurations());
+
+  @Test
+  void shouldCreateCustomizerWhenEnabled() {
+    contextRunner
+        .withPropertyValues("otel.instrumentation.spring-webflux.enabled=true")
+        .run(
+            context ->
+                assertThat(context.getBean("otelWebClientCustomizer"))
+                    .isNotNull()
+                    .isInstanceOf(webClientCustomizerClass()));
+  }
+
+  @Test
+  void shouldNotCreateCustomizerWhenDisabled() {
+    contextRunner
+        .withPropertyValues("otel.instrumentation.spring-webflux.enabled=false")
+        .run(context -> assertThat(context).doesNotHaveBean("otelWebClientCustomizer"));
+  }
+
+  @Test
+  void shouldCreateCustomizerByDefault() {
+    contextRunner.run(
+        context ->
+            assertThat(context.getBean("otelWebClientCustomizer"))
+                .isNotNull()
+                .isInstanceOf(webClientCustomizerClass()));
+  }
+
+  @Test
+  void shouldAddTracingFilterWhenCustomizerApplied() {
+    contextRunner.run(
+        context -> {
+          Object customizer =
+              context.getBean("otelWebClientCustomizer", webClientCustomizerClass());
+          WebClient.Builder builder = WebClient.builder();
+          customizeWebClient(customizer, builder);
+
+          AtomicLong count = new AtomicLong(0);
+          builder
+              .build()
+              .mutate()
+              .filters(
+                  filters ->
+                      count.set(
+                          filters.stream()
+                              .filter(
+                                  f ->
+                                      f.getClass()
+                                          .getName()
+                                          .startsWith("io.opentelemetry.instrumentation"))
+                              .count()));
+          assertThat(count.get()).isEqualTo(1);
+        });
+  }
+
+  @Test
+  void shouldNotCreateCustomizerWhenWebClientCustomizerNotOnClasspath() {
+    contextRunner
+        .withClassLoader(new FilteredClassLoader(webClientCustomizerClass()))
+        .run(context -> assertThat(context).doesNotHaveBean("otelWebClientCustomizer"));
+  }
+
+  @Test
+  void shouldNotCreateCustomizerWhenWebClientNotOnClasspath() {
+    contextRunner
+        .withClassLoader(new FilteredClassLoader(WebClient.class))
+        .run(context -> assertThat(context).doesNotHaveBean("otelWebClientCustomizer"));
+  }
+}