Log only relevant failures, unless $DEBUG_JVM_HTTP_PROXY_AGENT is set

Author: pimterry

src/main/java/tech/httptoolkit/javaagent/reactornetty/ReactorNettyResetAllConfigAdvice.java

@@ -27,7 +27,6 @@ public class ReactorNettyResetAllConfigAdvice {
     public static final Field proxyProviderField;
 
     static {
-        System.out.println("Running netty reset static initializer");
         try {
             // Initialize our intercepted SSL provider:
             agentSslProvider = SslProvider.builder()

src/main/kotlin/tech/httptoolkit/javaagent/AgentMain.kt

@@ -4,8 +4,11 @@ package tech.httptoolkit.javaagent
 
 import net.bytebuddy.ByteBuddy
 import net.bytebuddy.agent.builder.AgentBuilder
+import net.bytebuddy.description.type.TypeDescription
+import net.bytebuddy.dynamic.DynamicType
 import net.bytebuddy.dynamic.scaffold.TypeValidation
 import net.bytebuddy.matcher.ElementMatchers.none
+import net.bytebuddy.utility.JavaModule
 import java.lang.instrument.Instrumentation
 import javax.net.ssl.SSLContext
 import java.net.*
@@ -61,6 +64,9 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
     setDefaultProxy(proxyHost, proxyPort)
     setDefaultSslContext(InterceptedSslContext)
 
+    val debugMode = !System.getenv("DEBUG_JVM_HTTP_PROXY_AGENT").isNullOrEmpty()
+    val logger = TransformationLogger(debugMode)
+
     // Disabling type validation allows us to intercept non-Java types, e.g. Kotlin
     // in OkHttp. See https://github.com/raphw/byte-buddy/issues/764
     var agentBuilder = AgentBuilder.Default(
@@ -70,20 +76,20 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
         .with(AgentBuilder.TypeStrategy.Default.REDEFINE)
         .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
         .disableClassFormatChanges()
-        .with(AgentBuilder.Listener.StreamWriting.toSystemOut().withTransformationsOnly())
+        .with(logger)
 
     arrayOf(
-        OkHttpClientV3Transformer(),
-        OkHttpClientV2Transformer(),
-        ApacheClientRoutingV4Transformer(),
-        ApacheClientRoutingV5Transformer(),
-        ApacheSslSocketFactoryTransformer(),
-        ApacheClientTlsStrategyTransformer(),
-        JavaClientTransformer(),
-        JettyClientTransformer(),
-        AsyncHttpClientConfigTransformer(),
-        AsyncHttpChannelManagerTransformer(),
-        ReactorNettyClientConfigTransformer()
+        OkHttpClientV3Transformer(logger),
+        OkHttpClientV2Transformer(logger),
+        ApacheClientRoutingV4Transformer(logger),
+        ApacheClientRoutingV5Transformer(logger),
+        ApacheSslSocketFactoryTransformer(logger),
+        ApacheClientTlsStrategyTransformer(logger),
+        JavaClientTransformer(logger),
+        JettyClientTransformer(logger),
+        AsyncHttpClientConfigTransformer(logger),
+        AsyncHttpChannelManagerTransformer(logger),
+        ReactorNettyClientConfigTransformer(logger)
     ).forEach { matchingAgentTransformer ->
         agentBuilder = matchingAgentTransformer.register(agentBuilder)
     }
@@ -93,8 +99,19 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
     println("HTTP Toolkit interception active")
 }
 
-interface MatchingAgentTransformer : AgentBuilder.Transformer {
-    fun register(builder: AgentBuilder): AgentBuilder
+abstract class MatchingAgentTransformer(private val logger: TransformationLogger) : AgentBuilder.Transformer {
+    abstract fun register(builder: AgentBuilder): AgentBuilder
+    abstract fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*>
+
+    override fun transform(
+        builder: DynamicType.Builder<*>,
+        typeDescription: TypeDescription,
+        classLoader: ClassLoader?,
+        module: JavaModule?
+    ): DynamicType.Builder<*> {
+        logger.beforeTransformation(typeDescription)
+        return transform(builder)
+    }
 }
 
 private fun setDefaultProxy(proxyHost: String, proxyPort: Int) {

src/main/kotlin/tech/httptoolkit/javaagent/ApacheAsyncClientTransformers.kt renamed to src/main/kotlin/tech/httptoolkit/javaagent/ApacheAsyncClientTransformer.kt

@@ -19,7 +19,7 @@ import tech.httptoolkit.javaagent.apacheclient.ApacheV5ReturnProxyRouteAdvice
 // AbstractClientTlsStrategy, which does this, but there's other examples too. We hook upgrade(), so that that
 // field is reset to use our context before any client TLS upgrade happens.
 
-class ApacheClientTlsStrategyTransformer : MatchingAgentTransformer {
+class ApacheClientTlsStrategyTransformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             // For v5 we need to hook into every client TlsStrategy (of which there are many).
@@ -42,16 +42,11 @@ class ApacheClientTlsStrategyTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(
-            Advice.to(OverrideSslContextFieldAdvice::class.java)
-                .on(hasMethodName("upgrade"))
-        );
+                Advice.to(OverrideSslContextFieldAdvice::class.java)
+                    .on(hasMethodName("upgrade"))
+            )
     }
 }

src/main/kotlin/tech/httptoolkit/javaagent/ApacheClientTransformers.kt

@@ -2,18 +2,16 @@ package tech.httptoolkit.javaagent
 
 import net.bytebuddy.agent.builder.AgentBuilder
 import net.bytebuddy.asm.Advice
-import net.bytebuddy.description.type.TypeDescription
 import net.bytebuddy.dynamic.DynamicType
 import net.bytebuddy.matcher.ElementMatchers.*
-import net.bytebuddy.utility.JavaModule
 import tech.httptoolkit.javaagent.apacheclient.ApacheSetSslSocketFactoryAdvice
 import tech.httptoolkit.javaagent.apacheclient.ApacheV4ReturnProxyRouteAdvice
 import tech.httptoolkit.javaagent.apacheclient.ApacheV5ReturnProxyRouteAdvice
 
 // For both v4 & v5 we override all implementations of the RoutePlanner interface, and we redefine all routes
 // to go via our proxy instead of their existing configuration.
 
-class ApacheClientRoutingV4Transformer : MatchingAgentTransformer {
+class ApacheClientRoutingV4Transformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder.type(
             hasSuperType(named("org.apache.http.conn.routing.HttpRoutePlanner"))
@@ -22,20 +20,15 @@ class ApacheClientRoutingV4Transformer : MatchingAgentTransformer {
         ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder.visit(
             Advice.to(ApacheV4ReturnProxyRouteAdvice::class.java)
                 .on(hasMethodName("determineRoute"))
         )
     }
 }
 
-class ApacheClientRoutingV5Transformer : MatchingAgentTransformer {
+class ApacheClientRoutingV5Transformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder.type(
             hasSuperType(named("org.apache.hc.client5.http.routing.HttpRoutePlanner"))
@@ -44,12 +37,7 @@ class ApacheClientRoutingV5Transformer : MatchingAgentTransformer {
         ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder.visit(
             Advice.to(ApacheV5ReturnProxyRouteAdvice::class.java)
                 .on(hasMethodName("determineRoute"))
@@ -61,7 +49,7 @@ class ApacheClientRoutingV5Transformer : MatchingAgentTransformer {
 // socket is created, the SSL context is replaced with our configured SslSocketFactory that uses our configured
 // SSLContext, which trusts our certificate, straight after initialization.
 
-class ApacheSslSocketFactoryTransformer : MatchingAgentTransformer {
+class ApacheSslSocketFactoryTransformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
@@ -72,12 +60,7 @@ class ApacheSslSocketFactoryTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(
             Advice.to(ApacheSetSslSocketFactoryAdvice::class.java)

src/main/kotlin/tech/httptoolkit/javaagent/AsyncHttpClientConfigTransformers.kt

@@ -2,17 +2,15 @@ package tech.httptoolkit.javaagent
 
 import net.bytebuddy.agent.builder.AgentBuilder
 import net.bytebuddy.asm.Advice
-import net.bytebuddy.description.type.TypeDescription
 import net.bytebuddy.dynamic.DynamicType
-import net.bytebuddy.utility.JavaModule
 import net.bytebuddy.matcher.ElementMatchers.*
 import tech.httptoolkit.javaagent.asynchttpclient.AsyncHttpClientReturnProxySelectorAdvice
 import tech.httptoolkit.javaagent.asynchttpclient.AsyncHttpClientReturnSslContextAdvice
 import tech.httptoolkit.javaagent.asynchttpclient.AsyncHttpResetSslEngineFactoryAdvice
 
 // For new clients, we just need to override the properties on the convenient config
 // class that contains both proxy & SSL configuration.
-class AsyncHttpClientConfigTransformer : MatchingAgentTransformer {
+class AsyncHttpClientConfigTransformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
@@ -22,12 +20,7 @@ class AsyncHttpClientConfigTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(Advice.to(AsyncHttpClientReturnSslContextAdvice::class.java)
                 .on(hasMethodName("getSslContext")))
@@ -38,20 +31,15 @@ class AsyncHttpClientConfigTransformer : MatchingAgentTransformer {
 
 // For existing classes, we need to hook SSL Handler creation, called for
 // every new connection
-class AsyncHttpChannelManagerTransformer : MatchingAgentTransformer {
+class AsyncHttpChannelManagerTransformer(logger: TransformationLogger) : MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
                 named("org.asynchttpclient.netty.channel.ChannelManager")
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(Advice.to(AsyncHttpResetSslEngineFactoryAdvice::class.java)
                 .on(hasMethodName("createSslHandler")))

src/main/kotlin/tech/httptoolkit/javaagent/JavaClientTransformer.kt

@@ -8,7 +8,7 @@ import net.bytebuddy.utility.JavaModule
 import net.bytebuddy.matcher.ElementMatchers.*
 
 
-class JavaClientTransformer : MatchingAgentTransformer {
+class JavaClientTransformer(logger: TransformationLogger): MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
@@ -18,12 +18,7 @@ class JavaClientTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(Advice.to(ReturnProxySelectorAdvice::class.java)
                 .on(hasMethodName("proxy")))

src/main/kotlin/tech/httptoolkit/javaagent/JettyClientTransformer.kt

@@ -3,16 +3,13 @@ package tech.httptoolkit.javaagent
 import net.bytebuddy.agent.builder.AgentBuilder
 import net.bytebuddy.asm.Advice
 import net.bytebuddy.description.method.MethodDescription
-import net.bytebuddy.description.type.TypeDescription
 import net.bytebuddy.dynamic.DynamicType
-import net.bytebuddy.utility.JavaModule
 import net.bytebuddy.matcher.ElementMatchers.*
 import org.eclipse.jetty.util.ssl.SslContextFactory
 import tech.httptoolkit.javaagent.jettyclient.JettyResetDestinationsAdvice
 import tech.httptoolkit.javaagent.jettyclient.JettyReturnProxyConfigurationAdvice
 import tech.httptoolkit.javaagent.jettyclient.JettyReturnSslContextFactoryV10Advice
 import tech.httptoolkit.javaagent.jettyclient.JettyReturnSslContextFactoryV9Advice
-import java.util.*
 
 /**
  * Transforms the JettyClient to use our proxy & trust our certificate.
@@ -24,7 +21,7 @@ import java.util.*
  * (internal connection pools) when resolveDestination is first called
  * on each client.
  */
-class JettyClientTransformer : MatchingAgentTransformer {
+class JettyClientTransformer(logger: TransformationLogger): MatchingAgentTransformer(logger) {
 
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
@@ -33,12 +30,7 @@ class JettyClientTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(Advice.to(JettyReturnProxyConfigurationAdvice::class.java)
                 .on(hasMethodName("getProxyConfiguration")))

src/main/kotlin/tech/httptoolkit/javaagent/OkHttpClientTransformers.kt

@@ -17,20 +17,15 @@ import net.bytebuddy.matcher.ElementMatchers.*
  * Without this, proxy settings work by default, but certificates do not - OkHttp
  * only trusts the default built-in certificates, and refuses ours.
  */
-class OkHttpClientV3Transformer : MatchingAgentTransformer {
+class OkHttpClientV3Transformer(logger: TransformationLogger): MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
                 named("okhttp3.OkHttpClient")
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): 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)
@@ -52,20 +47,15 @@ class OkHttpClientV3Transformer : MatchingAgentTransformer {
  * Without this, proxy settings work by default, but certificates do not - OkHttp
  * only trusts the default built-in certificates, and refuses ours.
  */
-class OkHttpClientV2Transformer : MatchingAgentTransformer {
+class OkHttpClientV2Transformer(logger: TransformationLogger): MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
                 named("com.squareup.okhttp.OkHttpClient")
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*>? {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             // v2 uses getX methods:
             .visit(Advice.to(ReturnProxyAdvice::class.java)

src/main/kotlin/tech/httptoolkit/javaagent/ReactorNettyTransformers.kt

@@ -14,7 +14,7 @@ import tech.httptoolkit.javaagent.reactornetty.ReactorNettyResetAllConfigAdvice
 // that receives the config as part of every single HTTP request - we hook that to reset the relevant
 // config props every time they're used.
 
-class ReactorNettyClientConfigTransformer : MatchingAgentTransformer {
+class ReactorNettyClientConfigTransformer(logger: TransformationLogger): MatchingAgentTransformer(logger) {
     override fun register(builder: AgentBuilder): AgentBuilder {
         return builder
             .type(
@@ -24,12 +24,7 @@ class ReactorNettyClientConfigTransformer : MatchingAgentTransformer {
             ).transform(this)
     }
 
-    override fun transform(
-        builder: DynamicType.Builder<*>,
-        typeDescription: TypeDescription,
-        classLoader: ClassLoader?,
-        module: JavaModule?
-    ): DynamicType.Builder<*> {
+    override fun transform(builder: DynamicType.Builder<*>): DynamicType.Builder<*> {
         return builder
             .visit(Advice.to(ReactorNettyResetAllConfigAdvice::class.java)
                 .on(isConstructor<MethodDescription>().and(