Improve bytebuddy reliability with improved advice loading

pimterry · pimterry · commit 2c7245b936b8 · 2021-03-11T18:33:43.000+01:00
Based on raphw/byte-buddy#218 (comment) this ensures that the advice class can be inlined without being loaded (and thus its dependencies being loaded) from the bytebuddy classloader. In some cases that can cause problems (akka SBT demo) and this resolves those.
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/AgentMain.kt b/src/main/kotlin/tech/httptoolkit/javaagent/AgentMain.kt
@@ -4,16 +4,18 @@ package tech.httptoolkit.javaagent
 
 import net.bytebuddy.ByteBuddy
 import net.bytebuddy.agent.builder.AgentBuilder
+import net.bytebuddy.asm.Advice
 import net.bytebuddy.description.type.TypeDescription
+import net.bytebuddy.dynamic.ClassFileLocator
 import net.bytebuddy.dynamic.DynamicType
 import net.bytebuddy.dynamic.scaffold.TypeValidation
 import net.bytebuddy.matcher.ElementMatchers.none
+import net.bytebuddy.pool.TypePool
 import net.bytebuddy.utility.JavaModule
 import java.lang.instrument.Instrumentation
 import javax.net.ssl.SSLContext
 import java.net.*
 import javax.net.ssl.HttpsURLConnection
-import javax.net.ssl.SSLSocketFactory
 import javax.net.ssl.TrustManagerFactory
 
 
@@ -119,7 +121,7 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
 
 abstract class MatchingAgentTransformer(private val logger: TransformationLogger) : AgentBuilder.Transformer {
     abstract fun register(builder: AgentBuilder): AgentBuilder
-    abstract fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*>
+    abstract fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*>
 
     override fun transform(
         builder: DynamicType.Builder<*>,
@@ -128,7 +130,18 @@ abstract class MatchingAgentTransformer(private val logger: TransformationLogger
         module: JavaModule?
     ): DynamicType.Builder<*> {
         logger.beforeTransformation(typeDescription)
-        return transform(builder)
+
+        return transform(builder) { adviceName ->
+            val locator = if (classLoader != null) {
+                ClassFileLocator.Compound(
+                    ClassFileLocator.ForClassLoader.of(classLoader),
+                    ClassFileLocator.ForClassLoader.of(ByteBuddy::class.java.classLoader)
+                )
+            } else {
+                ClassFileLocator.ForClassLoader.of(ByteBuddy::class.java.classLoader)
+            }
+            Advice.to(TypePool.Default.of(locator).describe(adviceName).resolve(), locator)
+        }
     }
 }
 
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/AkkaClientTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/AkkaClientTransformers.kt
@@ -1,9 +1,12 @@
 package tech.httptoolkit.javaagent
 
+import net.bytebuddy.ByteBuddy
 import net.bytebuddy.agent.builder.AgentBuilder
 import net.bytebuddy.asm.Advice
+import net.bytebuddy.dynamic.ClassFileLocator
 import net.bytebuddy.dynamic.DynamicType
 import net.bytebuddy.matcher.ElementMatchers.*
+import net.bytebuddy.pool.TypePool
 import tech.httptoolkit.javaagent.advice.akka.*
 
 // First, we hook outgoing connection creation, and ensure that new connections always go via the proxy & trust us:
@@ -14,10 +17,10 @@ class AkkaHttpTransformer(logger: TransformationLogger) : MatchingAgentTransform
             .transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(OverrideHttpSettingsAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.akka.OverrideHttpSettingsAdvice")
                     .on(hasMethodName("_outgoingConnection"))
             )
     }
@@ -33,10 +36,10 @@ class AkkaPoolSettingsTransformer(logger: TransformationLogger) : MatchingAgentT
             .transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(ResetPoolSetupAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetPoolSetupAdvice")
                     .on(isConstructor())
             )
     }
@@ -51,10 +54,10 @@ class AkkaPoolTransformer(logger: TransformationLogger) : MatchingAgentTransform
             .transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(ResetOldPoolsAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetOldPoolsAdvice")
                     .on(hasMethodName("dispatchRequest"))
             )
     }
@@ -68,10 +71,10 @@ class AkkaGatewayTransformer(logger: TransformationLogger) : MatchingAgentTransf
             .transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(ResetOldGatewaysAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetOldGatewaysAdvice")
                     .on(hasMethodName("apply"))
             )
     }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/ApacheAsyncClientTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/ApacheAsyncClientTransformer.kt
@@ -37,10 +37,10 @@ class ApacheClientTlsStrategyTransformer(logger: TransformationLogger) : Matchin
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(OverrideSslContextFieldAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.OverrideSslContextFieldAdvice")
                     .on(hasMethodName("upgrade"))
             )
     }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/ApacheClientTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/ApacheClientTransformers.kt
@@ -19,9 +19,9 @@ class ApacheClientRoutingV4Transformer(logger: TransformationLogger) : MatchingA
         ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder.visit(
-            Advice.to(ApacheV4ReturnProxyRouteAdvice::class.java)
+            loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheV4ReturnProxyRouteAdvice")
                 .on(hasMethodName("determineRoute"))
         )
     }
@@ -36,9 +36,9 @@ class ApacheClientRoutingV5Transformer(logger: TransformationLogger) : MatchingA
         ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder.visit(
-            Advice.to(ApacheV5ReturnProxyRouteAdvice::class.java)
+            loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheV5ReturnProxyRouteAdvice")
                 .on(hasMethodName("determineRoute"))
         )
     }
@@ -59,11 +59,11 @@ class ApacheSslSocketFactoryTransformer(logger: TransformationLogger) : Matching
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-            Advice.to(ApacheSetSslSocketFactoryAdvice::class.java)
-                .on(hasMethodName("createLayeredSocket"))
+                loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheSetSslSocketFactoryAdvice")
+                    .on(hasMethodName("createLayeredSocket"))
         );
     }
 }
@@ -80,13 +80,13 @@ class ApacheHostConfigurationTransformer(logger: TransformationLogger) : Matchin
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             // Override the proxy field value for all new configurations, and for any attempts to call
             // setProxy/ProxyHost. We don't no-op these, because we want to call them ourselves later on
             // existing configs to reset them - we don't just want to ignore this.
             .visit(
-                Advice.to(ApacheOverrideProxyHostFieldAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheOverrideProxyHostFieldAdvice")
                     .on(isConstructor<MethodDescription>()
                         .or(hasMethodName("setProxy"))
                         .or(hasMethodName("setProxyHost"))
@@ -107,10 +107,10 @@ class ApacheHttpMethodDirectorTransformer(logger: TransformationLogger) : Matchi
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(ApacheSetConfigProxyHostAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheSetConfigProxyHostAdvice")
                     .on(hasMethodName("executeMethod"))
             )
     }
@@ -127,10 +127,10 @@ class ApacheProtocolTransformer(logger: TransformationLogger) : MatchingAgentTra
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             .visit(
-                Advice.to(ApacheReturnCustomSslProtocolSocketFactoryAdvice::class.java)
+                loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheReturnCustomSslProtocolSocketFactoryAdvice")
                     .on(hasMethodName("getSocketFactory"))
             )
     }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/AsyncHttpClientConfigTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/AsyncHttpClientConfigTransformers.kt
@@ -20,12 +20,14 @@ class AsyncHttpClientConfigTransformer(logger: TransformationLogger) : MatchingA
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(AsyncHttpClientReturnSslContextAdvice::class.java)
-                .on(hasMethodName("getSslContext")))
-            .visit(Advice.to(AsyncHttpClientReturnProxySelectorAdvice::class.java)
-                .on(hasMethodName("getProxyServerSelector")))
+            .visit(
+                loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpClientReturnSslContextAdvice")
+                    .on(hasMethodName("getSslContext")))
+            .visit(
+                loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpClientReturnProxySelectorAdvice")
+                    .on(hasMethodName("getProxyServerSelector")))
     }
 }
 
@@ -39,9 +41,10 @@ class AsyncHttpChannelManagerTransformer(logger: TransformationLogger) : Matchin
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(AsyncHttpResetSslEngineFactoryAdvice::class.java)
-                .on(hasMethodName("createSslHandler")))
+            .visit(
+                loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpResetSslEngineFactoryAdvice")
+                    .on(hasMethodName("createSslHandler")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/HttpsUrlConnectionTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/HttpsUrlConnectionTransformer.kt
@@ -18,9 +18,9 @@ class HttpsUrlConnectionTransformer(logger: TransformationLogger): MatchingAgent
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")
                 .on(hasMethodName("getSSLSocketFactory")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/JavaClientTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/JavaClientTransformer.kt
@@ -18,13 +18,13 @@ class JavaClientTransformer(logger: TransformationLogger): MatchingAgentTransfor
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(ReturnProxySelectorAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxySelectorAdvice")
                 .on(hasMethodName("proxy")))
-            .visit(Advice.to(ReturnSslContextAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslContextAdvice")
                 .on(hasMethodName("sslContext")))
-            .visit(Advice.to(ReturnSslContextAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslContextAdvice")
                 .on(hasMethodName("theSSLContext")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/JettyClientTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/JettyClientTransformer.kt
@@ -30,19 +30,19 @@ class JettyClientTransformer(logger: TransformationLogger): MatchingAgentTransfo
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(JettyReturnProxyConfigurationAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.jettyclient.JettyReturnProxyConfigurationAdvice")
                 .on(hasMethodName("getProxyConfiguration")))
-            .visit(Advice.to(JettyReturnSslContextFactoryV10Advice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.jettyclient.JettyReturnSslContextFactoryV10Advice")
                 .on(hasMethodName<MethodDescription>("getSslContextFactory").and(
                     returns(SslContextFactory.Client::class.java)
                 )))
-            .visit(Advice.to(JettyReturnSslContextFactoryV9Advice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.jettyclient.JettyReturnSslContextFactoryV9Advice")
                 .on(hasMethodName<MethodDescription>("getSslContextFactory").and(
                     returns(SslContextFactory::class.java)
                 )))
-            .visit(Advice.to(JettyResetDestinationsAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.jettyclient.JettyResetDestinationsAdvice")
                 .on(hasMethodName("resolveDestination")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/KtorCioTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/KtorCioTransformers.kt
@@ -20,9 +20,9 @@ class KtorClientTlsTransformer(logger: TransformationLogger) : MatchingAgentTran
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(KtorResetTlsClientTrustAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ktor.KtorResetTlsClientTrustAdvice")
                 .on(hasMethodName<MethodDescription>("openTLSSession")
                     .and(takesArgument(3, named("io.ktor.network.tls.TLSConfig")))))
     }
@@ -38,9 +38,9 @@ class KtorClientEngineConfigTransformer(logger: TransformationLogger) : Matching
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(ReturnProxyAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")
                 .on(hasMethodName("getProxy")))
         }
 }
@@ -57,9 +57,9 @@ class KtorCioEngineTransformer(logger: TransformationLogger) : MatchingAgentTran
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
-            .visit(Advice.to(KtorResetProxyFieldAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ktor.KtorResetProxyFieldAdvice")
                 .on(hasMethodName("execute")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/OkHttpClientTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/OkHttpClientTransformers.kt
@@ -25,14 +25,14 @@ class OkHttpClientV3Transformer(logger: TransformationLogger): MatchingAgentTran
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             // v3 uses proxy() functions, while v4 uses Kotlin getters that compile to the same thing
-            .visit(Advice.to(ReturnProxyAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")
                 .on(hasMethodName("proxy")))
             // This means we ignore client certs, but that's fine: we can't pass them through the proxy anyway. That
             // needs to be configured separately in the proxy's configuration.
-            .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")
                 .on(hasMethodName("sslSocketFactory")))
     }
 }
@@ -55,12 +55,12 @@ class OkHttpClientV2Transformer(logger: TransformationLogger): MatchingAgentTran
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             // v2 uses getX methods:
-            .visit(Advice.to(ReturnProxyAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")
                 .on(hasMethodName("getProxy")))
-            .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")
                 .on(hasMethodName("getSslSocketFactory")))
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/ProxySelectorTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/ProxySelectorTransformer.kt
@@ -22,18 +22,18 @@ class ProxySelectorTransformer(logger: TransformationLogger): MatchingAgentTrans
             ).transform(this)
     }
 
-    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>, loadAdvice: (String) -> Advice): DynamicType.Builder<*> {
         return builder
             // We patch *all* proxy selectors, so that even code which doesn't use the default
             // still returns our proxy regardless.
-            .visit(Advice.to(OverrideAllProxySelectionAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.OverrideAllProxySelectionAdvice")
                 .on(
                     hasMethodName<MethodDescription>("select")
                     .and(takesArguments(1))
                     .and(takesArgument(0, named("java.net.URI")))))
             // We already set the default ProxySelector on startup, before we intercept anything.
             // Here we patch ProxySelector so nobody can overwrite that later.
-            .visit(Advice.to(SkipMethodAdvice::class.java)
+            .visit(loadAdvice("tech.httptoolkit.javaagent.advice.SkipMethodAdvice")
                 .on(hasMethodName("setDefault")));
     }
 }
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/ReactorNettyTransformers.kt b/src/main/kotlin/tech/httptoolkit/javaagent/ReactorNettyTransformers.kt
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/SslContextTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/SslContextTransformer.kt
diff --git a/src/main/kotlin/tech/httptoolkit/javaagent/UrlConnectionTransformer.kt b/src/main/kotlin/tech/httptoolkit/javaagent/UrlConnectionTransformer.kt

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,12 @@`
`1`	`1`	`package tech.httptoolkit.javaagent`
`2`	`2`
	`3`	`+import net.bytebuddy.ByteBuddy`
`3`	`4`	`import net.bytebuddy.agent.builder.AgentBuilder`
`4`	`5`	`import net.bytebuddy.asm.Advice`
	`6`	`+import net.bytebuddy.dynamic.ClassFileLocator`
`5`	`7`	`import net.bytebuddy.dynamic.DynamicType`
`6`	`8`	`import net.bytebuddy.matcher.ElementMatchers.*`
	`9`	`+import net.bytebuddy.pool.TypePool`
`7`	`10`	`import tech.httptoolkit.javaagent.advice.akka.*`
`8`	`11`
`9`	`12`	`// First, we hook outgoing connection creation, and ensure that new connections always go via the proxy & trust us:`
`@@ -14,10 +17,10 @@ class AkkaHttpTransformer(logger: TransformationLogger) : MatchingAgentTransform`
`14`	`17`	`.transform(this)`
`15`	`18`	`}`
`16`	`19`
`17`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`20`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`18`	`21`	`return builder`
`19`	`22`	`.visit(`
`20`		`- Advice.to(OverrideHttpSettingsAdvice::class.java)`
	`23`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.akka.OverrideHttpSettingsAdvice")`
`21`	`24`	`.on(hasMethodName("_outgoingConnection"))`
`22`	`25`	`)`
`23`	`26`	`}`
`@@ -33,10 +36,10 @@ class AkkaPoolSettingsTransformer(logger: TransformationLogger) : MatchingAgentT`
`33`	`36`	`.transform(this)`
`34`	`37`	`}`
`35`	`38`
`36`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`39`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`37`	`40`	`return builder`
`38`	`41`	`.visit(`
`39`		`- Advice.to(ResetPoolSetupAdvice::class.java)`
	`42`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetPoolSetupAdvice")`
`40`	`43`	`.on(isConstructor())`
`41`	`44`	`)`
`42`	`45`	`}`
`@@ -51,10 +54,10 @@ class AkkaPoolTransformer(logger: TransformationLogger) : MatchingAgentTransform`
`51`	`54`	`.transform(this)`
`52`	`55`	`}`
`53`	`56`
`54`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`57`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`55`	`58`	`return builder`
`56`	`59`	`.visit(`
`57`		`- Advice.to(ResetOldPoolsAdvice::class.java)`
	`60`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetOldPoolsAdvice")`
`58`	`61`	`.on(hasMethodName("dispatchRequest"))`
`59`	`62`	`)`
`60`	`63`	`}`
`@@ -68,10 +71,10 @@ class AkkaGatewayTransformer(logger: TransformationLogger) : MatchingAgentTransf`
`68`	`71`	`.transform(this)`
`69`	`72`	`}`
`70`	`73`
`71`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`74`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`72`	`75`	`return builder`
`73`	`76`	`.visit(`
`74`		`- Advice.to(ResetOldGatewaysAdvice::class.java)`
	`77`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.akka.ResetOldGatewaysAdvice")`
`75`	`78`	`.on(hasMethodName("apply"))`
`76`	`79`	`)`
`77`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,10 +37,10 @@ class ApacheClientTlsStrategyTransformer(logger: TransformationLogger) : Matchin`
`37`	`37`	`).transform(this)`
`38`	`38`	`}`
`39`	`39`
`40`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`40`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`41`	`41`	`return builder`
`42`	`42`	`.visit(`
`43`		`- Advice.to(OverrideSslContextFieldAdvice::class.java)`
	`43`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.OverrideSslContextFieldAdvice")`
`44`	`44`	`.on(hasMethodName("upgrade"))`
`45`	`45`	`)`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,9 @@ class ApacheClientRoutingV4Transformer(logger: TransformationLogger) : MatchingA`
`19`	`19`	`).transform(this)`
`20`	`20`	`}`
`21`	`21`
`22`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`22`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`23`	`23`	`return builder.visit(`
`24`		`- Advice.to(ApacheV4ReturnProxyRouteAdvice::class.java)`
	`24`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheV4ReturnProxyRouteAdvice")`
`25`	`25`	`.on(hasMethodName("determineRoute"))`
`26`	`26`	`)`
`27`	`27`	`}`
`@@ -36,9 +36,9 @@ class ApacheClientRoutingV5Transformer(logger: TransformationLogger) : MatchingA`
`36`	`36`	`).transform(this)`
`37`	`37`	`}`
`38`	`38`
`39`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`39`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`40`	`40`	`return builder.visit(`
`41`		`- Advice.to(ApacheV5ReturnProxyRouteAdvice::class.java)`
	`41`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheV5ReturnProxyRouteAdvice")`
`42`	`42`	`.on(hasMethodName("determineRoute"))`
`43`	`43`	`)`
`44`	`44`	`}`
`@@ -59,11 +59,11 @@ class ApacheSslSocketFactoryTransformer(logger: TransformationLogger) : Matching`
`59`	`59`	`).transform(this)`
`60`	`60`	`}`
`61`	`61`
`62`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`62`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`63`	`63`	`return builder`
`64`	`64`	`.visit(`
`65`		`- Advice.to(ApacheSetSslSocketFactoryAdvice::class.java)`
`66`		`- .on(hasMethodName("createLayeredSocket"))`
	`65`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheSetSslSocketFactoryAdvice")`
	`66`	`+ .on(hasMethodName("createLayeredSocket"))`
`67`	`67`	`);`
`68`	`68`	`}`
`69`	`69`	`}`
`@@ -80,13 +80,13 @@ class ApacheHostConfigurationTransformer(logger: TransformationLogger) : Matchin`
`80`	`80`	`).transform(this)`
`81`	`81`	`}`
`82`	`82`
`83`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`83`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`84`	`84`	`return builder`
`85`	`85`	`// Override the proxy field value for all new configurations, and for any attempts to call`
`86`	`86`	`// setProxy/ProxyHost. We don't no-op these, because we want to call them ourselves later on`
`87`	`87`	`// existing configs to reset them - we don't just want to ignore this.`
`88`	`88`	`.visit(`
`89`		`- Advice.to(ApacheOverrideProxyHostFieldAdvice::class.java)`
	`89`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheOverrideProxyHostFieldAdvice")`
`90`	`90`	`.on(isConstructor<MethodDescription>()`
`91`	`91`	`.or(hasMethodName("setProxy"))`
`92`	`92`	`.or(hasMethodName("setProxyHost"))`
`@@ -107,10 +107,10 @@ class ApacheHttpMethodDirectorTransformer(logger: TransformationLogger) : Matchi`
`107`	`107`	`).transform(this)`
`108`	`108`	`}`
`109`	`109`
`110`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`110`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`111`	`111`	`return builder`
`112`	`112`	`.visit(`
`113`		`- Advice.to(ApacheSetConfigProxyHostAdvice::class.java)`
	`113`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheSetConfigProxyHostAdvice")`
`114`	`114`	`.on(hasMethodName("executeMethod"))`
`115`	`115`	`)`
`116`	`116`	`}`
`@@ -127,10 +127,10 @@ class ApacheProtocolTransformer(logger: TransformationLogger) : MatchingAgentTra`
`127`	`127`	`).transform(this)`
`128`	`128`	`}`
`129`	`129`
`130`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`130`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`131`	`131`	`return builder`
`132`	`132`	`.visit(`
`133`		`- Advice.to(ApacheReturnCustomSslProtocolSocketFactoryAdvice::class.java)`
	`133`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.apacheclient.ApacheReturnCustomSslProtocolSocketFactoryAdvice")`
`134`	`134`	`.on(hasMethodName("getSocketFactory"))`
`135`	`135`	`)`
`136`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,14 @@ class AsyncHttpClientConfigTransformer(logger: TransformationLogger) : MatchingA`
`20`	`20`	`).transform(this)`
`21`	`21`	`}`
`22`	`22`
`23`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`23`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`24`	`24`	`return builder`
`25`		`- .visit(Advice.to(AsyncHttpClientReturnSslContextAdvice::class.java)`
`26`		`- .on(hasMethodName("getSslContext")))`
`27`		`- .visit(Advice.to(AsyncHttpClientReturnProxySelectorAdvice::class.java)`
`28`		`- .on(hasMethodName("getProxyServerSelector")))`
	`25`	`+ .visit(`
	`26`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpClientReturnSslContextAdvice")`
	`27`	`+ .on(hasMethodName("getSslContext")))`
	`28`	`+ .visit(`
	`29`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpClientReturnProxySelectorAdvice")`
	`30`	`+ .on(hasMethodName("getProxyServerSelector")))`
`29`	`31`	`}`
`30`	`32`	`}`
`31`	`33`
`@@ -39,9 +41,10 @@ class AsyncHttpChannelManagerTransformer(logger: TransformationLogger) : Matchin`
`39`	`41`	`).transform(this)`
`40`	`42`	`}`
`41`	`43`
`42`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`44`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`43`	`45`	`return builder`
`44`		`- .visit(Advice.to(AsyncHttpResetSslEngineFactoryAdvice::class.java)`
`45`		`- .on(hasMethodName("createSslHandler")))`
	`46`	`+ .visit(`
	`47`	`+ loadAdvice("tech.httptoolkit.javaagent.advice.asynchttpclient.AsyncHttpResetSslEngineFactoryAdvice")`
	`48`	`+ .on(hasMethodName("createSslHandler")))`
`46`	`49`	`}`
`47`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,9 +18,9 @@ class HttpsUrlConnectionTransformer(logger: TransformationLogger): MatchingAgent`
`18`	`18`	`).transform(this)`
`19`	`19`	`}`
`20`	`20`
`21`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`21`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`22`	`22`	`return builder`
`23`		`- .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)`
	`23`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")`
`24`	`24`	`.on(hasMethodName("getSSLSocketFactory")))`
`25`	`25`	`}`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,13 +18,13 @@ class JavaClientTransformer(logger: TransformationLogger): MatchingAgentTransfor`
`18`	`18`	`).transform(this)`
`19`	`19`	`}`
`20`	`20`
`21`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`21`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`22`	`22`	`return builder`
`23`		`- .visit(Advice.to(ReturnProxySelectorAdvice::class.java)`
	`23`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxySelectorAdvice")`
`24`	`24`	`.on(hasMethodName("proxy")))`
`25`		`- .visit(Advice.to(ReturnSslContextAdvice::class.java)`
	`25`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslContextAdvice")`
`26`	`26`	`.on(hasMethodName("sslContext")))`
`27`		`- .visit(Advice.to(ReturnSslContextAdvice::class.java)`
	`27`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslContextAdvice")`
`28`	`28`	`.on(hasMethodName("theSSLContext")))`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@ class KtorClientTlsTransformer(logger: TransformationLogger) : MatchingAgentTran`
`20`	`20`	`).transform(this)`
`21`	`21`	`}`
`22`	`22`
`23`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`23`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`24`	`24`	`return builder`
`25`		`- .visit(Advice.to(KtorResetTlsClientTrustAdvice::class.java)`
	`25`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ktor.KtorResetTlsClientTrustAdvice")`
`26`	`26`	`.on(hasMethodName<MethodDescription>("openTLSSession")`
`27`	`27`	`.and(takesArgument(3, named("io.ktor.network.tls.TLSConfig")))))`
`28`	`28`	`}`
`@@ -38,9 +38,9 @@ class KtorClientEngineConfigTransformer(logger: TransformationLogger) : Matching`
`38`	`38`	`).transform(this)`
`39`	`39`	`}`
`40`	`40`
`41`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`41`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`42`	`42`	`return builder`
`43`		`- .visit(Advice.to(ReturnProxyAdvice::class.java)`
	`43`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")`
`44`	`44`	`.on(hasMethodName("getProxy")))`
`45`	`45`	`}`
`46`	`46`	`}`
`@@ -57,9 +57,9 @@ class KtorCioEngineTransformer(logger: TransformationLogger) : MatchingAgentTran`
`57`	`57`	`).transform(this)`
`58`	`58`	`}`
`59`	`59`
`60`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`60`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`61`	`61`	`return builder`
`62`		`- .visit(Advice.to(KtorResetProxyFieldAdvice::class.java)`
	`62`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ktor.KtorResetProxyFieldAdvice")`
`63`	`63`	`.on(hasMethodName("execute")))`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ class OkHttpClientV3Transformer(logger: TransformationLogger): MatchingAgentTran`
`25`	`25`	`).transform(this)`
`26`	`26`	`}`
`27`	`27`
`28`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`28`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`29`	`29`	`return builder`
`30`	`30`	`// v3 uses proxy() functions, while v4 uses Kotlin getters that compile to the same thing`
`31`		`- .visit(Advice.to(ReturnProxyAdvice::class.java)`
	`31`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")`
`32`	`32`	`.on(hasMethodName("proxy")))`
`33`	`33`	`// This means we ignore client certs, but that's fine: we can't pass them through the proxy anyway. That`
`34`	`34`	`// needs to be configured separately in the proxy's configuration.`
`35`		`- .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)`
	`35`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")`
`36`	`36`	`.on(hasMethodName("sslSocketFactory")))`
`37`	`37`	`}`
`38`	`38`	`}`
`@@ -55,12 +55,12 @@ class OkHttpClientV2Transformer(logger: TransformationLogger): MatchingAgentTran`
`55`	`55`	`).transform(this)`
`56`	`56`	`}`
`57`	`57`
`58`		`- override fun transform(builder: DynamicType.Builder<>): DynamicType.Builder<> {`
	`58`	`+ override fun transform(builder: DynamicType.Builder<>, loadAdvice: (String) -> Advice): DynamicType.Builder<> {`
`59`	`59`	`return builder`
`60`	`60`	`// v2 uses getX methods:`
`61`		`- .visit(Advice.to(ReturnProxyAdvice::class.java)`
	`61`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnProxyAdvice")`
`62`	`62`	`.on(hasMethodName("getProxy")))`
`63`		`- .visit(Advice.to(ReturnSslSocketFactoryAdvice::class.java)`
	`63`	`+ .visit(loadAdvice("tech.httptoolkit.javaagent.advice.ReturnSslSocketFactoryAdvice")`
`64`	`64`	`.on(hasMethodName("getSslSocketFactory")))`
`65`	`65`	`}`
`66`	`66`	`}`