Use SpringVersion to detect MethodParameters usage

Prefer using SpringVersion class to get the Spring version reliably
Use the specific class method as fallback

Author: jpbempel

dd-java-agent/agent-debugger/src/main/java/com/datadog/debugger/util/SpringHelper.java

@@ -1,10 +1,50 @@
 package com.datadog.debugger.util;
 
 import java.lang.instrument.Instrumentation;
+import java.lang.reflect.Method;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class SpringHelper {
+  private static final Logger LOGGER = LoggerFactory.getLogger(SpringHelper.class);
 
   public static boolean isSpringUsingOnlyMethodParameters(Instrumentation inst) {
+    try {
+      return isSpringUsingOnlyMethodParametersSpringVersion(inst);
+    } catch (Exception e) {
+      LOGGER.debug("isSpringUsingOnlyMethodParameters failed for SpringVersion", e);
+      // fallback to lookup for specific class
+      return isSpringUsingOnlyMethodParametersSpecificClass(inst);
+    }
+  }
+
+  private static boolean isSpringUsingOnlyMethodParametersSpringVersion(Instrumentation inst) {
+    try {
+      // scan for getting an already loaded class and get the classloader
+      ClassLoader springClassLoader = null;
+      for (Class<?> clazz : inst.getAllLoadedClasses()) {
+        if (clazz.getName().startsWith("org.springframework.core")) {
+          springClassLoader = clazz.getClassLoader();
+        }
+      }
+      if (springClassLoader == null) {
+        throw new IllegalStateException("Cannot find Spring classloader");
+      }
+      Class<?> springVersionClass =
+          Class.forName("org.springframework.core.SpringVersion", true, springClassLoader);
+      Method m = springVersionClass.getDeclaredMethod("getVersion");
+      String version = (String) m.invoke(null);
+      ParsedSpringVersion springVersion = new ParsedSpringVersion(version);
+      // if Spring version is 6.1+ only using MethodParameters
+      return springVersion.major > 6 || (springVersion.major == 6 && springVersion.minor >= 1);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static boolean isSpringUsingOnlyMethodParametersSpecificClass(Instrumentation inst) {
     for (Class<?> clazz : inst.getAllLoadedClasses()) {
       if ("org.springframework.web.client.RestClient".equals(clazz.getName())) {
         // If this class (coming from Spring web since version 6.1) is found loaded it means Spring
@@ -15,4 +55,23 @@ public static boolean isSpringUsingOnlyMethodParameters(Instrumentation inst) {
     // class not found, probably no Spring
     return false;
   }
+
+  private static class ParsedSpringVersion {
+    private static final Pattern VERSION_PATTERN = Pattern.compile("(\\d+)\\.(\\d+)\\.(\\d+)");
+
+    final int major;
+    final int minor;
+    final int patch;
+
+    public ParsedSpringVersion(String strVersion) {
+      Matcher matcher = VERSION_PATTERN.matcher(strVersion);
+      if (matcher.find()) {
+        major = Integer.parseInt(matcher.group(1));
+        minor = Integer.parseInt(matcher.group(2));
+        patch = Integer.parseInt(matcher.group(3));
+      } else {
+        throw new IllegalArgumentException("Cannot parse SpringVersion: " + strVersion);
+      }
+    }
+  }
 }

dd-java-agent/agent-debugger/src/test/java/com/datadog/debugger/util/SpringHelperTest.java

@@ -13,15 +13,24 @@ class SpringHelperTest {
 
   @Test
   @EnabledForJreRange(min = JRE.JAVA_17)
-  void isSpringUsingOnlyMethodParametersTrue() throws Exception {
+  void isSpringUsingOnlyMethodParametersTrueSpringVersion() throws Exception {
+    Class<?> clazz = Class.forName("org.springframework.core.SpringVersion");
+    Instrumentation inst = mock(Instrumentation.class);
+    when(inst.getAllLoadedClasses()).thenReturn(new Class[] {clazz});
+    assertTrue(SpringHelper.isSpringUsingOnlyMethodParameters(inst));
+  }
+
+  @Test
+  @EnabledForJreRange(min = JRE.JAVA_17)
+  void isSpringUsingOnlyMethodParametersTrueFallback() throws Exception {
     Class<?> clazz = Class.forName("org.springframework.web.client.RestClient");
     Instrumentation inst = mock(Instrumentation.class);
     when(inst.getAllLoadedClasses()).thenReturn(new Class[] {clazz});
     assertTrue(SpringHelper.isSpringUsingOnlyMethodParameters(inst));
   }
 
   @Test
-  void isSpringUsingOnlyMethodParametersFalse() throws Exception {
+  void isSpringUsingOnlyMethodParametersFalseFallback() throws Exception {
     Instrumentation inst = mock(Instrumentation.class);
     when(inst.getAllLoadedClasses()).thenReturn(new Class[0]);
     assertFalse(SpringHelper.isSpringUsingOnlyMethodParameters(inst));