changes to make Http clients work across various implementations

Author: Doug Hilpipre

README.md

@@ -23,7 +23,8 @@ Provides instrumentation of both the client and server sides of Ktor.  This incl
 
 ## Installation
 
-It is recommended to also use the instrumentation for Kotlin Coroutines: https://github.com/newrelic/newrelic-java-kotlin-coroutines  
+It is recommended to use version 8.25.1 or later of the Java Agent as those versions contain instrumentation for Kotlin Coroutines.  If you use an earlier version of the Java Agent then use the last set of instrumentation in the archived repo for Kotlin Coroutines (https://github.com/newrelic/newrelic-java-kotlin-coroutines/releases/tag/v1.0.8).   
+  
 Additionally it recommended to version 8.20.0 of the New Relic Java Agent in order to avoid problems with the retransformation of Kotlin classes.  This requires you to include a system property in the startup arguments of your application.  Include -Dnewrelic.config.class_transformer.clear_return_stacks=true   
 See 8.20.0 Release Notes for more details (https://docs.newrelic.com/docs/release-notes/agent-release-notes/java-release-notes/java-agent-8200/)   
 
@@ -40,9 +41,12 @@ After deployment, you should get route names for your web transactions instead o
 You should also see deeper visibiity into what is happening in your application via the enhanced transaction traces/distributed traces provided by this instrumentation.    
 
 ### Recommended Kotlin Coroutine Configuration   
-Ktor intiates a long running lazy Coroutine that will dominate the transaction times for your application unless it is ignored.  Please use this version or later (https://github.com/newrelic/newrelic-java-kotlin-coroutines/releases/tag/v1.0.4) to enable this feature and  add io.ktor.server.netty.cio.RequestBodyHandler to the scopes elemeent in the Coroutines stanza in newrelic.yml as shown here: https://github.com/newrelic/newrelic-java-kotlin-coroutines?tab=readme-ov-file#configuring-scopes-to-ignore    
+Ktor initiates a long running lazy Coroutine that will dominate the transaction times for your application unless it is ignored.  Please use this version or later (https://github.com/newrelic/newrelic-java-kotlin-coroutines/releases/tag/v1.0.4) to enable this feature and  add io.ktor.server.netty.cio.RequestBodyHandler to the scopes elemeent in the Coroutines stanza in newrelic.yml as shown here: https://github.com/newrelic/newrelic-java-kotlin-coroutines?tab=readme-ov-file#configuring-scopes-to-ignore    
 The Kotlin Coroutines instrumentation also will trace suspend functions so it recommended that you ignore internal Ktor suspend functions by adding the regular expression ".\*io\\.ktor\\..\*" to the list of suspends to ignore.   
 
+## Notes   
+If using the Ktor CIO Http Client, it currently splits into several different transactions.  Two of these are the major ones, the first will track the actual external call response time and the second will track the request timeout.  The others are typically of short duration.  
+This problem requires a change to the Kotlin Coroutine instrumentation that will be fixed in an upcoming Java Agent release.  After the release there will be a single transaction.   
 ## Support
 
 New Relic has open-sourced this project. This project is provided AS-IS WITHOUT WARRANTY OR DEDICATED SUPPORT. Issues and contributions should be reported to the project here on GitHub.
@@ -63,4 +67,3 @@ If you believe you have found a security vulnerability in this project or any of
 
 New Relic Java Instrumentation for Ktor is licensed under the [Apache 2.0](http://apache.org/licenses/LICENSE-2.0.txt) License.
 
->[If applicable: [Project Name] also uses source code from third-party libraries. You can find full details on which libraries are used and the terms under which they are licensed in the third-party notices document.]

ktor-client-core-2.0/build.gradle.kts

@@ -3,14 +3,14 @@
 apply(plugin = "java")
 
 dependencies {
-	implementation("io.ktor:ktor-client-core-jvm:2.0.0")
+    implementation("io.ktor:ktor-client-core-jvm:2.0.0")
 
-   // New Relic Java Agent dependencies
+    // New Relic Java Agent dependencies
     implementation("com.newrelic.agent.java:newrelic-api:9.1.0")
     implementation("com.newrelic.agent.java:newrelic-agent:9.1.0")
     implementation("com.newrelic.agent.java:newrelic-weaver-api:9.1.0")
     implementation("com.newrelic.agent.java:agent-bridge:9.1.0")
-    implementation(fileTree("../test-lib"){
+    implementation(fileTree("../test-lib") {
         include("*.jar")
     })
 }
@@ -28,7 +28,7 @@ tasks.jar {
 }
 
 verifyInstrumentation {
-    passesOnly("io.ktor:ktor-client-core-jvm:[2.0.0,)")
-   excludeRegex(".*beta.*")
-   excludeRegex(".*rc.*")
+    passesOnly("io.ktor:ktor-client-core-jvm:[2.0.0,3.0.0)")
+    excludeRegex(".*beta.*")
+    excludeRegex(".*rc.*")
 }

ktor-client-core-2.0/src/main/java/com/newrelic/instrumentation/labs/ktor/client/KtorClientUtils.java

@@ -0,0 +1,14 @@
+package com.newrelic.instrumentation.labs.ktor.client;
+
+import com.newrelic.api.agent.HttpParameters;
+import kotlin.coroutines.Continuation;
+
+public class KtorClientUtils {
+
+    public static <T> NRContinuationWrapper<T> getContinuationWrapper(Continuation<T> continuation, HttpParameters httpParameters) {
+        if(continuation instanceof NRContinuationWrapper) {
+            return null;
+        }
+        return new NRContinuationWrapper<>(continuation, httpParameters);
+    }
+}

ktor-client-core-2.0/src/main/java/com/newrelic/instrumentation/labs/ktor/client/NRContinuationWrapper.java

@@ -0,0 +1,43 @@
+package com.newrelic.instrumentation.labs.ktor.client;
+
+import com.newrelic.agent.bridge.AgentBridge;
+import com.newrelic.api.agent.HttpParameters;
+import com.newrelic.api.agent.NewRelic;
+import com.newrelic.api.agent.Segment;
+import com.newrelic.api.agent.Trace;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.CoroutineContext;
+import org.jetbrains.annotations.NotNull;
+
+public class NRContinuationWrapper<T> implements Continuation<T> {
+
+    private final Continuation<T> delegate;
+    private static boolean isTransformed = false;
+    private final Segment segment;
+
+    protected NRContinuationWrapper(Continuation<T> delegate, HttpParameters httpParameters) {
+        this.delegate = delegate;
+        segment = NewRelic.getAgent().getTransaction().startSegment("Ktor-HttpRequest");
+        if(httpParameters != null) {
+            segment.reportAsExternal(httpParameters);
+        }
+        if(!isTransformed) {
+            isTransformed = true;
+            AgentBridge.instrumentation.retransformUninstrumentedClass(getClass());
+        }
+    }
+
+    @Override
+    @Trace(dispatcher = true)
+    public void resumeWith(@NotNull Object o) {
+        if(segment != null) {
+            segment.end();
+        }
+        delegate.resumeWith(o);
+    }
+
+    @Override
+    public @NotNull CoroutineContext getContext() {
+        return delegate.getContext();
+    }
+}

ktor-client-core-2.0/src/main/java/com/newrelic/instrumentation/labs/ktor/client/NRFunction2Wrapper.java

@@ -0,0 +1,25 @@
+package com.newrelic.instrumentation.labs.ktor.client;
+
+import com.newrelic.agent.bridge.AgentBridge;
+import com.newrelic.api.agent.Trace;
+import kotlin.jvm.functions.Function2;
+
+public class NRFunction2Wrapper<R,S,T>  implements Function2<R,S,T> {
+
+    private final Function2<R,S,T> delegate;
+    private static boolean isTransformed = false;
+
+    public NRFunction2Wrapper(Function2<R,S,T> delegate) {
+        this.delegate = delegate;
+        if (!isTransformed) {
+            isTransformed = true;
+            AgentBridge.instrumentation.retransformUninstrumentedClass(getClass());
+        }
+    }
+
+    @Override
+    @Trace(dispatcher = true)
+    public T invoke(R r, S s) {
+        return delegate != null ? delegate.invoke(r, s) : null;
+    }
+}

ktor-client-core-2.0/src/main/java/io/ktor/client/HttpClient_Instrumentation.java

@@ -1,10 +1,14 @@
 package io.ktor.client;
 
+import com.newrelic.api.agent.NewRelic;
 import com.newrelic.api.agent.Trace;
 import com.newrelic.api.agent.weaver.Weave;
 import com.newrelic.api.agent.weaver.Weaver;
+import com.newrelic.instrumentation.labs.ktor.client.KtorHeaderWrapper;
 import io.ktor.client.call.HttpClientCall;
 import io.ktor.client.request.HttpRequestBuilder;
+import io.ktor.http.HeadersBuilder;
+import io.ktor.http.HttpHeaders;
 import kotlin.coroutines.Continuation;
 
 /*
@@ -16,6 +20,12 @@ public class HttpClient_Instrumentation {
 
     @Trace(dispatcher = true)
     public Object execute$ktor_client_core(HttpRequestBuilder requestBuilder, Continuation<? super HttpClientCall> continuation) {
+        if(requestBuilder != null) {
+            HeadersBuilder headers = requestBuilder.getHeaders();
+            if(headers != null) {
+                NewRelic.getAgent().getTransaction().insertDistributedTraceHeaders(new KtorHeaderWrapper(headers));
+            }
+        }
         return Weaver.callOriginal();
     }
 }

ktor-client-core-2.0/src/main/java/io/ktor/client/statement/HttpStatement_Instrumentation.java

@@ -0,0 +1,68 @@
+package io.ktor.client.statement;
+
+import com.newrelic.api.agent.HttpParameters;
+import com.newrelic.api.agent.NewRelic;
+import com.newrelic.api.agent.Trace;
+import com.newrelic.api.agent.weaver.NewField;
+import com.newrelic.api.agent.weaver.Weave;
+import com.newrelic.api.agent.weaver.Weaver;
+import com.newrelic.instrumentation.labs.ktor.client.KtorClientUtils;
+import com.newrelic.instrumentation.labs.ktor.client.KtorHeaderWrapper;
+import com.newrelic.instrumentation.labs.ktor.client.NRContinuationWrapper;
+import com.newrelic.instrumentation.labs.ktor.client.NRFunction2Wrapper;
+import io.ktor.client.HttpClient;
+import io.ktor.client.request.HttpRequestBuilder;
+import io.ktor.http.HeadersBuilder;
+import io.ktor.http.HttpMethod;
+import io.ktor.http.URLBuilder;
+import io.ktor.http.Url;
+
+import java.net.URI;
+
+@Weave(originalName = "io.ktor.client.statement.HttpStatement")
+public class HttpStatement_Instrumentation {
+
+    @NewField
+    private HttpParameters httpParameters = null;
+
+    public HttpStatement_Instrumentation(HttpRequestBuilder builder, HttpClient client) {
+        HeadersBuilder headersBuilder = builder.getHeaders();
+        if(headersBuilder != null) {
+            KtorHeaderWrapper headerWrapper = new KtorHeaderWrapper(headersBuilder);
+            NewRelic.getAgent().getTransaction().insertDistributedTraceHeaders(headerWrapper);
+        }
+        URLBuilder urlBuilder = builder.getUrl();
+        if(urlBuilder != null) {
+            Url url = urlBuilder.build();
+            String urlString = url.toString();
+            if(urlString != null) {
+                HttpMethod method = builder.getMethod();
+                URI uri = URI.create(urlString);
+                httpParameters = HttpParameters.library("Ktor-Client").uri(uri).procedure(method.getValue()).noInboundHeaders().build();
+            }
+        }
+    }
+
+    @Trace(dispatcher = true)
+    public <T> java.lang.Object execute(kotlin.jvm.functions.Function2<? super io.ktor.client.statement.HttpResponse, ? super kotlin.coroutines.Continuation<? super T>, ? extends java.lang.Object> function2, kotlin.coroutines.Continuation<? super T> continuation) {
+        if(!(function2 instanceof NRFunction2Wrapper)) {
+            function2 = new NRFunction2Wrapper<>(function2);
+        }
+        return Weaver.callOriginal();
+    }
+
+    @Trace(dispatcher = true)
+    public java.lang.Object execute(kotlin.coroutines.Continuation<? super io.ktor.client.statement.HttpResponse> continuation) {
+        NRContinuationWrapper<? super HttpResponse> wrapper = KtorClientUtils.getContinuationWrapper(continuation, httpParameters);
+        if(wrapper != null) {
+            continuation =  wrapper;
+        }
+        return Weaver.callOriginal();
+    }
+
+    @Trace(dispatcher = true)
+    public java.lang.Object executeUnsafe(kotlin.coroutines.Continuation<? super io.ktor.client.statement.HttpResponse> continuation) {
+        return Weaver.callOriginal();
+    }
+
+}

ktor-client-core-2.0/src/main/kotlin/io/ktor/client/statement/HttpStatement_Instrumentation.kt

@@ -0,0 +1,34 @@
+// Build.gradle generated for instrumentation module ktor-client-core
+
+apply(plugin = "java")
+
+dependencies {
+    implementation("io.ktor:ktor-client-core-jvm:3.0.0")
+
+    // New Relic Java Agent dependencies
+    implementation("com.newrelic.agent.java:newrelic-api:9.1.0")
+    implementation("com.newrelic.agent.java:newrelic-agent:9.1.0")
+    implementation("com.newrelic.agent.java:newrelic-weaver-api:9.1.0")
+    implementation("com.newrelic.agent.java:agent-bridge:9.1.0")
+    implementation(fileTree("../test-lib") {
+        include("*.jar")
+    })
+}
+
+
+tasks.jar {
+    manifest {
+        attributes(
+            "Implementation-Title" to "com.newrelic.instrumentation.labs.ktor-client-core-3.0",
+            "Implementation-Vendor" to "New Relic Labs",
+            "Implementation-Vendor-Id" to "com.newrelic.labs",
+            "Implementation-Version" to 1.0
+        )
+    }
+}
+
+verifyInstrumentation {
+    passesOnly("io.ktor:ktor-client-core-jvm:[3.0.0,)")
+    excludeRegex(".*beta.*")
+    excludeRegex(".*rc.*")
+}

ktor-client-core-3.0/build.gradle.kts

@@ -0,0 +1,14 @@
+package com.newrelic.instrumentation.labs.ktor.client;
+
+import com.newrelic.api.agent.HttpParameters;
+import kotlin.coroutines.Continuation;
+
+public class KtorClientUtils {
+
+    public static <T> NRContinuationWrapper<T> getContinuationWrapper(Continuation<T> continuation, HttpParameters httpParameters) {
+        if(continuation instanceof NRContinuationWrapper) {
+            return null;
+        }
+        return new NRContinuationWrapper<>(continuation, httpParameters);
+    }
+}