Merge pull request #4 from newrelic-experimental/support-7.x

updates to support version 7.x

Author: dhilpipre

settings.gradle

@@ -1,3 +1,4 @@
 rootProject.name = 'spring-async-instrumentation'
 include 'spring-async'
+include 'spring-async-7.0'
 include 'spring-web-async'

spring-async-7.0/build.gradle

@@ -0,0 +1,32 @@
+
+// Build.gradle generated for instrumentation module spring-web-async
+
+apply plugin: 'java'
+
+targetCompatibility = JavaVersion.VERSION_17
+
+dependencies {
+    implementation 'org.springframework:spring-core:7.0.0'
+
+    // New Relic Java Agent dependencies
+    implementation 'com.newrelic.agent.java:newrelic-agent:8.4.0'
+    implementation 'com.newrelic.agent.java:newrelic-api:8.4.0'
+    implementation 'com.newrelic.agent.java:agent-bridge:8.4.0'
+    implementation fileTree(include: ['*.jar'], dir: '../test-lib')
+}
+
+jar {
+  manifest {
+    attributes 'Implementation-Title': 'com.newrelic.instrumentation.spring-async'
+    attributes 'Implementation-Vendor': 'New Relic'
+    attributes 'Implementation-Vendor-Id': 'com.newrelic'
+    attributes 'Implementation-Version': 1.0
+  }
+}
+
+verifyInstrumentation {
+	passesOnly 'org.springframework:spring-core:[7.0.0,)'
+        excludeRegex '.*M.*'
+    excludeRegex '.*RC.*'
+
+}

spring-async-7.0/src/main/java/com/newrelic/instrumentation/spring/async/NRCallableWrapper.java

@@ -0,0 +1,36 @@
+package com.newrelic.instrumentation.spring.async;
+
+import java.util.concurrent.Callable;
+
+import com.newrelic.agent.bridge.AgentBridge;
+import com.newrelic.api.agent.NewRelic;
+import com.newrelic.api.agent.Token;
+import com.newrelic.api.agent.Trace;
+
+public class NRCallableWrapper<V> implements Callable<V> {
+	
+	private Callable<V> delegate = null;
+	private Token token = null;
+	private static boolean isTransformed = false;
+	
+	public NRCallableWrapper(Callable<V> d, Token t) {
+		delegate = d;
+		token = t;
+		if(!isTransformed) {
+			AgentBridge.instrumentation.retransformUninstrumentedClass(getClass());
+			isTransformed = true;
+		}
+	}
+
+	@Override
+	@Trace(async = true)
+	public V call() throws Exception {
+		if(token != null) {
+			NewRelic.getAgent().getTracedMethod().setMetricName("Custom","SpringAsync","Callable");
+			token.linkAndExpire();
+			token = null;
+		}
+		return delegate.call();
+	}
+
+}

spring-async-7.0/src/main/java/com/newrelic/instrumentation/spring/async/NRRunnableWrapper.java

@@ -0,0 +1,34 @@
+package com.newrelic.instrumentation.spring.async;
+
+import com.newrelic.agent.bridge.AgentBridge;
+import com.newrelic.api.agent.NewRelic;
+import com.newrelic.api.agent.Token;
+import com.newrelic.api.agent.Trace;
+
+public class NRRunnableWrapper implements Runnable {
+	
+	private static boolean isTransformed = false;
+	private Runnable delegate = null;
+	private Token token = null;
+	
+	public NRRunnableWrapper(Runnable r, Token t) {
+		delegate = r;
+		token = t;
+		if(!isTransformed) {
+			isTransformed = true;
+			AgentBridge.instrumentation.retransformUninstrumentedClass(getClass());
+		}
+	}
+	
+	@Override
+	@Trace(async = true)
+	public void run() {
+		if(token != null) {
+			NewRelic.getAgent().getTracedMethod().setMetricName("Custom","SpringAsync","Runnable");
+			token.linkAndExpire();
+			token = null;
+		}
+		delegate.run();
+	}
+
+}

spring-async-7.0/src/main/java/com/newrelic/instrumentation/spring/async/Utils.java

@@ -0,0 +1,44 @@
+package com.newrelic.instrumentation.spring.async;
+
+import java.util.concurrent.Callable;
+
+import com.newrelic.api.agent.NewRelic;
+import com.newrelic.api.agent.Token;
+
+public class Utils {
+
+	public static Runnable getWrappedRunnable(Runnable r) {
+		
+		if(r instanceof NRRunnableWrapper) return null;
+		
+		String packageName = r.getClass().getPackage().getName();
+		if(packageName.startsWith("com.newrelic") || packageName.startsWith("com.nr")) return null;
+		
+		Token token = NewRelic.getAgent().getTransaction().getToken();
+		if(token != null && token.isActive()) {
+			return new NRRunnableWrapper(r, token);
+		} else if(token != null) {
+			token.expire();
+			token = null;
+		}
+		return null;
+	}
+	
+	public static <V> Callable<V> getWrappedCallable(Callable<V> c) {
+		
+		if(c instanceof NRCallableWrapper) return null;
+		
+		String packageName = c.getClass().getPackage().getName();
+		if(packageName.startsWith("com.newrelic") || packageName.startsWith("com.nr")) return null;
+		
+		Token token = NewRelic.getAgent().getTransaction().getToken();
+		if(token != null && token.isActive()) {
+			return new NRCallableWrapper<V>(c, token);
+		} else if(token != null) {
+			token.expire();
+			token = null;
+		}
+		return null;
+	}
+	
+}

spring-async-7.0/src/main/java/org/springframework/core/task/AsyncTaskExecutor_Instrumentation.java

@@ -0,0 +1,37 @@
+package org.springframework.core.task;
+
+import com.newrelic.api.agent.weaver.MatchType;
+import com.newrelic.api.agent.weaver.Weave;
+import com.newrelic.api.agent.weaver.Weaver;
+import com.newrelic.instrumentation.spring.async.Utils;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+@Weave(originalName = "org.springframework.core.task.AsyncTaskExecutor", type = MatchType.Interface)
+public class AsyncTaskExecutor_Instrumentation {
+
+    public void execute(Runnable task, long startTimeout) {
+        Runnable wrapper = Utils.getWrappedRunnable(task);
+        if(wrapper != null) {
+            task = wrapper;
+        }
+        Weaver.callOriginal();
+    }
+
+    public Future<?> submit(Runnable task) {
+        Runnable wrapper = Utils.getWrappedRunnable(task);
+        if(wrapper != null) {
+            task = wrapper;
+        }
+        return Weaver.callOriginal();
+    }
+
+    public <V> Future<V> submit(Callable<V> task) {
+        Callable<V> wrapper = Utils.getWrappedCallable(task);
+        if(wrapper != null) {
+            task = wrapper;
+        }
+        return Weaver.callOriginal();
+    }
+}

spring-async-7.0/src/main/java/org/springframework/core/task/SyncTaskExecutor_Instrumentation.java

@@ -0,0 +1,14 @@
+package org.springframework.core.task;
+
+import com.newrelic.api.agent.Trace;
+import com.newrelic.api.agent.weaver.Weave;
+import com.newrelic.api.agent.weaver.Weaver;
+
+@Weave(originalName = "org.springframework.core.task.SyncTaskExecutor")
+public class SyncTaskExecutor_Instrumentation {
+
+    @Trace
+    public <V, E extends Exception> V execute(TaskCallback<V, E> task) {
+        return Weaver.callOriginal();
+    }
+}

spring-async-7.0/src/main/java/org/springframework/core/task/TaskCallback_Instrumentation.java

@@ -0,0 +1,15 @@
+package org.springframework.core.task;
+
+import com.newrelic.api.agent.Trace;
+import com.newrelic.api.agent.weaver.MatchType;
+import com.newrelic.api.agent.weaver.Weave;
+import com.newrelic.api.agent.weaver.Weaver;
+
+@Weave(originalName = "org.springframework.core.task.TaskCallback", type = MatchType.Interface)
+public class TaskCallback_Instrumentation<V, E extends Exception> {
+
+    @Trace
+    public V call() throws E {
+        return Weaver.callOriginal();
+    }
+}

spring-async-7.0/src/main/java/org/springframework/core/task/TaskExecutor_Instrumentation.java

@@ -0,0 +1,18 @@
+package org.springframework.core.task;
+
+import com.newrelic.api.agent.weaver.MatchType;
+import com.newrelic.api.agent.weaver.Weave;
+import com.newrelic.api.agent.weaver.Weaver;
+import com.newrelic.instrumentation.spring.async.Utils;
+
+@Weave(originalName = "org.springframework.core.task.TaskExecutor", type = MatchType.Interface)
+public class TaskExecutor_Instrumentation {
+
+    public void execute(Runnable task) {
+        Runnable wrapper = Utils.getWrappedRunnable(task);
+        if(wrapper != null) {
+            task = wrapper;
+        }
+        Weaver.callOriginal();
+    }
+}

spring-async/build.gradle

@@ -23,7 +23,7 @@ jar {
 }
 
 verifyInstrumentation {
-	passesOnly 'org.springframework:spring-core:[4.0.0.RELEASE,)'
+	passesOnly 'org.springframework:spring-core:[4.0.0.RELEASE,7.0.0)'
         excludeRegex '.*M.*'
     excludeRegex '.*RC.*'