diff --git a/dd-java-agent/agent-installer/src/main/java/datadog/trace/agent/tooling/CombiningTransformerBuilder.java b/dd-java-agent/agent-installer/src/main/java/datadog/trace/agent/tooling/CombiningTransformerBuilder.java index 5a7e4b9c3df..71e7f454286 100644 --- a/dd-java-agent/agent-installer/src/main/java/datadog/trace/agent/tooling/CombiningTransformerBuilder.java +++ b/dd-java-agent/agent-installer/src/main/java/datadog/trace/agent/tooling/CombiningTransformerBuilder.java @@ -130,7 +130,13 @@ private void prepareInstrumentation(InstrumenterModule module, int instrumentati adviceShader = AdviceShader.with(module); - String[] helperClassNames = module.helperClassNames(); + // Resolve helper names eagerly at install. Only the resolved String[] is captured. + String[] helperClassNames = + InstrumenterModule.loadStaticMuzzleHelperClassNames( + Utils.getExtendedClassLoader(), module.getClass().getName()); + if (null == helperClassNames) { + helperClassNames = module.helperClassNames(); + } if (module.injectHelperDependencies()) { helperClassNames = HelperScanner.withClassDependencies(helperClassNames); } diff --git a/dd-java-agent/agent-tooling/build.gradle b/dd-java-agent/agent-tooling/build.gradle index 3b60e25d281..71e950f5d0e 100644 --- a/dd-java-agent/agent-tooling/build.gradle +++ b/dd-java-agent/agent-tooling/build.gradle @@ -49,6 +49,7 @@ dependencies { testImplementation project(':dd-java-agent:testing') testImplementation libs.bytebuddy + testImplementation libs.bundles.junit5 testImplementation group: 'com.google.guava', name: 'guava-testlib', version: '20.0' jmhImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.3.5.RELEASE' diff --git a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/HelperScanner.java b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/HelperScanner.java index 3ec0fe7c82e..66536a2ddba 100644 --- a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/HelperScanner.java +++ b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/HelperScanner.java @@ -24,8 +24,7 @@ public final class HelperScanner extends ClassVisitor { static final int READER_OPTIONS = ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES; - static final ClassFileLocator locator = - ClassFileLocator.ForClassLoader.of(Utils.getAgentClassLoader()); + final ClassFileLocator locator; final MethodScanner methodScanner = new MethodScanner(); @@ -41,14 +40,30 @@ public final class HelperScanner extends ClassVisitor { Set uses; HelperScanner() { + this(ClassFileLocator.ForClassLoader.of(Utils.getAgentClassLoader())); + } + + HelperScanner(ClassFileLocator locator) { super(Opcodes.ASM7, null); + this.locator = locator; } - /** Expands helper class names to include any non-bootstrap classes they depend on. */ + /** + * Expands helper class names with their non-bootstrap dependencies, via the agent class loader. + */ public static String[] withClassDependencies(String... helperClassNames) { return new HelperScanner().simulateClassLoading(helperClassNames); } + /** + * Same as above, but reads bytecode via the given locator (e.g. during build time where the agent + * loader is absent). + */ + public static String[] withClassDependencies( + ClassFileLocator locator, String... helperClassNames) { + return new HelperScanner(locator).simulateClassLoading(helperClassNames); + } + /** * Simulates class-loading by finding all classes required to load the helper classes as well as * optional classes used in method instructions that may be needed later when invoking the method. diff --git a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/InstrumenterModule.java b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/InstrumenterModule.java index d2abbc265e5..833d573cfde 100644 --- a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/InstrumenterModule.java +++ b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/InstrumenterModule.java @@ -113,13 +113,23 @@ public static ReferenceMatcher loadStaticMuzzleReferences( } /** - * @return Class names of helpers to inject into the user's classloader. - *

NOTE: The order of the returned helper classes matters. If a muzzle check fails - * with a NoClassDefFoundError, as logged in build/reports/muzzle-*.txt, it is likely that one - * helper class depends on another that appears later in the list. In this case, the returned - * list must be reordered so that the referred helper class appears before the one that refers - * to it. + * @return the build-time inferred and manually-declared helper class names captured by {@code + * $Muzzle}, or {@code null} when none are available and fall back to {@link + * #helperClassNames()}. */ + public static String[] loadStaticMuzzleHelperClassNames( + ClassLoader classLoader, String instrumentationClass) { + String muzzleClass = instrumentationClass + "$Muzzle"; + try { + // helper class names captured at build-time; see MuzzleGenerator + return (String[]) + classLoader.loadClass(muzzleClass).getMethod("helperClassNames").invoke(null); + } catch (Throwable e) { + return null; + } + } + + /** Optional manual additions to the injected helper set. */ public String[] helperClassNames() { return NO_HELPERS; } diff --git a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicate.java b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicate.java new file mode 100644 index 00000000000..713bd3f9c83 --- /dev/null +++ b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicate.java @@ -0,0 +1,65 @@ +package datadog.trace.agent.tooling.muzzle; + +import datadog.trace.bootstrap.Constants; +import java.util.function.Predicate; + +/** + * Classifies a referenced class as an injectable tracer helper, a bootstrap class, or a library + * class — similar to OpenTelemetry's {@code HelperClassPredicate#isHelperClass}; however, the main + * signal here is whether the class was compiled from the instrumentation subproject's own output + * ({@code ownOutput}). {@link #HELPER_PREFIXES} additionally covers helpers that live in other + * tracer subprojects. + */ +public final class HelperClassPredicate { + + static final String[] HELPER_PREFIXES = { + "datadog.trace.instrumentation.", + "datadog.opentelemetry.shim.", + "datadog.trace.agent.tooling.iast.", + "datadog.trace.agent.tooling.nativeimage.", + }; + + private final Predicate ownOutput; + + /** + * @param ownOutput whether a dotted class name was compiled from the instrumentation subproject's + * own output; injected because agent-tooling cannot resolve build directories itself. + */ + public HelperClassPredicate(final Predicate ownOutput) { + this.ownOutput = ownOutput; + } + + public boolean isHelperClass(final String className) { + return !isBootstrap(className) && (ownOutput.test(className) || matchesHelperPrefix(className)); + } + + private static boolean matchesHelperPrefix(final String className) { + for (final String prefix : HELPER_PREFIXES) { + if (className.startsWith(prefix)) { + return true; + } + } + return false; + } + + /** + * Whether the class is on the bootstrap class-path (or a JDK/SLF4J type) and so never injected. + */ + public static boolean isBootstrap(final String className) { + if (className.startsWith("java.") + || className.startsWith("javax.") + || className.startsWith("jdk.") + || className.startsWith("com.sun.") + || className.startsWith("sun.") + || className.startsWith("org.slf4j.") + || className.startsWith("datadog.slf4j.")) { + return true; + } + for (final String prefix : Constants.BOOTSTRAP_PACKAGE_PREFIXES) { + if (className.startsWith(prefix)) { + return true; + } + } + return false; + } +} diff --git a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleGenerator.java b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleGenerator.java index 69421f6d16a..31c36014a5e 100644 --- a/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleGenerator.java +++ b/dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/muzzle/MuzzleGenerator.java @@ -3,15 +3,18 @@ import static java.util.Arrays.asList; import datadog.trace.agent.tooling.AdviceShader; +import datadog.trace.agent.tooling.HelperScanner; import datadog.trace.agent.tooling.Instrumenter; import datadog.trace.agent.tooling.InstrumenterModule; import java.io.File; import java.io.IOException; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -20,6 +23,7 @@ import net.bytebuddy.description.field.FieldList; import net.bytebuddy.description.method.MethodList; import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.dynamic.ClassFileLocator; import net.bytebuddy.implementation.Implementation; import net.bytebuddy.jar.asm.ClassVisitor; import net.bytebuddy.jar.asm.ClassWriter; @@ -81,7 +85,9 @@ public ClassVisitor wrap( } private static Reference[] generateReferences( - Instrumenter.HasMethodAdvice instrumenter, AdviceShader adviceShader) { + Instrumenter.HasMethodAdvice instrumenter, + AdviceShader adviceShader, + Set allAdviceClasses) { // track sources we've generated references from to avoid recursion final Set referenceSources = new HashSet<>(); final Map references = new LinkedHashMap<>(); @@ -93,6 +99,8 @@ private static Reference[] generateReferences( adviceClasses.addAll(asList(additionalClasses)); } }); + // remember the advice roots so callers can exclude them from the injected helper set + allAdviceClasses.addAll(adviceClasses); ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); for (String adviceClass : adviceClasses) { if (referenceSources.add(adviceClass)) { @@ -112,21 +120,59 @@ private static Reference[] generateReferences( } /** This code is generated in a separate side-class. */ - private static byte[] generateMuzzleClass(InstrumenterModule module) { + private byte[] generateMuzzleClass(InstrumenterModule module) { - Set ignoredClassNames = new HashSet<>(asList(module.muzzleIgnoredClassNames())); AdviceShader adviceShader = AdviceShader.with(module.adviceShading()); + HelperClassPredicate helperPredicate = new HelperClassPredicate(this::isOwnOutput); - List references = new ArrayList<>(); + // Crawl advice for muzzle references (only recursing into the instrumentation package). + Set adviceClasses = new HashSet<>(); + List allReferences = new ArrayList<>(); for (Instrumenter instrumenter : module.typeInstrumentations()) { if (instrumenter instanceof Instrumenter.HasMethodAdvice) { - for (Reference reference : - generateReferences((Instrumenter.HasMethodAdvice) instrumenter, adviceShader)) { - // ignore helper classes, they will be injected by the instrumentation's HelperInjector. - if (!ignoredClassNames.contains(reference.className)) { - references.add(reference); - } - } + Collections.addAll( + allReferences, + generateReferences( + (Instrumenter.HasMethodAdvice) instrumenter, adviceShader, adviceClasses)); + } + } + + // Inferred helpers = our classes referenced from the advice minus the advice roots. + Set inferredHelpers = new LinkedHashSet<>(); + for (Reference reference : allReferences) { + if (!adviceClasses.contains(reference.className) + && helperPredicate.isHelperClass(reference.className)) { + inferredHelpers.add(reference.className); + } + } + + // Manual additions cover helpers the crawl can't see. + Set manualHelpers = new LinkedHashSet<>(asList(module.helperClassNames())); + Set seedHelpers = new LinkedHashSet<>(inferredHelpers); + seedHelpers.addAll(manualHelpers); + for (String helper : new ArrayList<>(seedHelpers)) { + if (isOwnOutput(helper)) { + addNestedClasses(helper, seedHelpers); + } + } + + String[] orderedHelpers = + discoverAndOrderHelpers( + seedHelpers, + manualHelpers, + helperPredicate, + Thread.currentThread().getContextClassLoader()); + + writeInferenceReport(module, adviceClasses.isEmpty(), inferredHelpers, orderedHelpers); + + // Injected helpers are our own classes, so they don't need to be asserted as library + // references. + Set ignoredClassNames = new HashSet<>(asList(orderedHelpers)); + Collections.addAll(ignoredClassNames, module.muzzleIgnoredClassNames()); + List references = new ArrayList<>(); + for (Reference reference : allReferences) { + if (!ignoredClassNames.contains(reference.className)) { + references.add(reference); } } Reference[] additionalReferences = module.additionalMuzzleReferences(); @@ -179,9 +225,135 @@ private static byte[] generateMuzzleClass(InstrumenterModule module) { mv.visitMaxs(0, 0); mv.visitEnd(); + // Generated: public static String[] helperClassNames() — omitted for helper-less modules. + if (orderedHelpers.length > 0) { + MethodVisitor hv = + cw.visitMethod( + Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, + "helperClassNames", + "()[Ljava/lang/String;", + null, + null); + hv.visitCode(); + writeStrings(hv, orderedHelpers); + hv.visitInsn(Opcodes.ARETURN); + hv.visitMaxs(0, 0); + hv.visitEnd(); + } + return cw.toByteArray(); } + /** {@code true} if the class was compiled from this instrumentation subproject's own output. */ + private boolean isOwnOutput(String className) { + return new File(targetDir, className.replace('.', '/') + ".class").isFile(); + } + + /** Adds the nested classes ({@code Foo$Bar}, {@code Foo$1}, ...) of an own-output helper. */ + private void addNestedClasses(String className, Set helperClasses) { + File classFile = new File(targetDir, className.replace('.', '/') + ".class"); + File dir = classFile.getParentFile(); + if (dir == null || !dir.isDirectory()) { + return; + } + int lastDot = className.lastIndexOf('.'); + String pkg = lastDot < 0 ? "" : className.substring(0, lastDot + 1); + String prefix = (lastDot < 0 ? className : className.substring(lastDot + 1)) + "$"; + File[] siblings = dir.listFiles(); + if (siblings == null) { + return; + } + for (File sibling : siblings) { + String fileName = sibling.getName(); + if (fileName.startsWith(prefix) && fileName.endsWith(".class")) { + helperClasses.add(pkg + fileName.substring(0, fileName.length() - ".class".length())); + } + } + } + + /** + * Runs {@link HelperScanner} over the seed helpers to both discover their transitive helper + * dependencies and load-order the result (dependencies first). Keeps only our own helpers (plus + * manual additions), dropping library classes the scanner pulls in, and retains every seed even + * if it could not be located. + */ + private static String[] discoverAndOrderHelpers( + Set seedHelpers, + Set manualHelpers, + HelperClassPredicate helperPredicate, + ClassLoader loader) { + if (seedHelpers.isEmpty()) { + return new String[0]; + } + List ordered = new ArrayList<>(); + try { + for (String name : + HelperScanner.withClassDependencies( + ClassFileLocator.ForClassLoader.of(loader), seedHelpers.toArray(new String[0]))) { + if ((helperPredicate.isHelperClass(name) || manualHelpers.contains(name)) + && !ordered.contains(name)) { + ordered.add(name); + } + } + } catch (Throwable ignore) { + // best-effort ordering; unordered seeds are appended below + } + for (String seed : seedHelpers) { + if (!ordered.contains(seed)) { + ordered.add(seed); + } + } + return ordered.toArray(new String[0]); + } + + /** + * Writes an advisory report classifying each declared helper as inferred vs. manual-only, to + * guide migration. Best-effort — never fails the build. + */ + private void writeInferenceReport( + InstrumenterModule module, + boolean adviceLess, + Set inferredHelpers, + String[] injectedHelpers) { + try { + Set declared = new LinkedHashSet<>(asList(module.helperClassNames())); + if (declared.isEmpty() && inferredHelpers.isEmpty()) { + return; + } + File buildDir = targetDir; + while (buildDir != null && !"build".equals(buildDir.getName())) { + buildDir = buildDir.getParentFile(); + } + if (buildDir == null) { + return; + } + File reportDir = new File(buildDir, "reports/helper-inference"); + reportDir.mkdirs(); + StringBuilder sb = new StringBuilder(); + sb.append("module: ").append(module.getClass().getName()).append('\n'); + sb.append("has-advice: ").append(!adviceLess).append('\n'); + sb.append("injected-helpers: ").append(injectedHelpers.length).append('\n'); + if (adviceLess && !declared.isEmpty()) { + sb.append("crawl-cannot-cover: advice-less module; declared helpers are all manual-only\n"); + } + for (String name : declared) { + sb.append(inferredHelpers.contains(name) ? " inferred " : " manual-only ") + .append(name) + .append('\n'); + } + for (String name : inferredHelpers) { + if (!declared.contains(name)) { + sb.append(" inferred-only ").append(name).append('\n'); + } + } + Files.write( + new File(reportDir, module.getClass().getName() + ".txt").toPath(), + sb.toString().getBytes(StandardCharsets.UTF_8)); + } catch (Throwable ignore) { + // report is advisory; never fail the build over it + } + } + private static void writeReference(MethodVisitor mv, Reference reference) { if (reference instanceof OrReference) { mv.visitTypeInsn(Opcodes.NEW, "datadog/trace/agent/tooling/muzzle/OrReference"); diff --git a/dd-java-agent/agent-tooling/src/test/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicateTest.java b/dd-java-agent/agent-tooling/src/test/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicateTest.java new file mode 100644 index 00000000000..42d49fb21b7 --- /dev/null +++ b/dd-java-agent/agent-tooling/src/test/java/datadog/trace/agent/tooling/muzzle/HelperClassPredicateTest.java @@ -0,0 +1,78 @@ +package datadog.trace.agent.tooling.muzzle; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.HashSet; +import java.util.Set; +import org.junit.jupiter.api.Test; + +class HelperClassPredicateTest { + + private static HelperClassPredicate predicateWithOwnOutput(String... ownOutput) { + Set own = new HashSet<>(); + for (String className : ownOutput) { + own.add(className); + } + return new HelperClassPredicate(own::contains); + } + + @Test + void instrumentationPackageIsHelperEvenWithoutOwnOutput() { + // classes under the instrumentation package are ours regardless of where they were compiled + HelperClassPredicate predicate = predicateWithOwnOutput(); + assertTrue(predicate.isHelperClass("datadog.trace.instrumentation.foo.FooDecorator")); + } + + @Test + void allowlistedSharedSubprojectsAreHelpers() { + // helpers that live in other dd-owned tracer subprojects + HelperClassPredicate predicate = predicateWithOwnOutput(); + assertTrue(predicate.isHelperClass("datadog.opentelemetry.shim.context.OtelContext")); + assertTrue(predicate.isHelperClass("datadog.trace.agent.tooling.iast.TaintableEnumeration")); + assertTrue(predicate.isHelperClass("datadog.trace.agent.tooling.nativeimage.TracerActivation")); + } + + @Test + void ownOutputInLibraryPackageIsHelper() { + // helpers deliberately placed in a library's package are detected via ownOutput + HelperClassPredicate predicate = + predicateWithOwnOutput("redis.clients.jedis.JedisClientDecorator"); + assertTrue(predicate.isHelperClass("redis.clients.jedis.JedisClientDecorator")); + // the real library class in the same package is not ours and must remain a library reference + assertFalse(predicate.isHelperClass("redis.clients.jedis.Jedis")); + } + + @Test + void bootstrapAndJdkAreNeverHelpers() { + // bootstrap wins even if a class is reported as ownOutput + HelperClassPredicate predicate = + predicateWithOwnOutput("datadog.trace.bootstrap.InstrumentationContext"); + assertFalse(predicate.isHelperClass("datadog.trace.bootstrap.InstrumentationContext")); + assertFalse(predicate.isHelperClass("datadog.trace.api.Config")); + // datadog.trace.instrumentation.api is a bootstrap sub-package, not an injectable helper + assertFalse(predicate.isHelperClass("datadog.trace.instrumentation.api.SomeApi")); + assertFalse(predicate.isHelperClass("java.lang.String")); + assertFalse(predicate.isHelperClass("javax.servlet.http.HttpServletRequest")); + assertFalse(predicate.isHelperClass("org.slf4j.Logger")); + assertFalse(predicate.isHelperClass("datadog.slf4j.Logger")); + } + + @Test + void plainLibraryClassIsNotHelper() { + HelperClassPredicate predicate = predicateWithOwnOutput(); + assertFalse(predicate.isHelperClass("org.apache.http.HttpRequest")); + assertFalse(predicate.isHelperClass("com.datastax.oss.driver.api.core.CqlSession")); + } + + @Test + void isBootstrapMatchesBootstrapPrefixesAndJdk() { + assertTrue(HelperClassPredicate.isBootstrap("datadog.trace.instrumentation.api.X")); + assertTrue(HelperClassPredicate.isBootstrap("datadog.trace.bootstrap.Y")); + assertTrue(HelperClassPredicate.isBootstrap("datadog.trace.api.Z")); + assertTrue(HelperClassPredicate.isBootstrap("java.util.List")); + assertTrue(HelperClassPredicate.isBootstrap("jdk.internal.Foo")); + assertFalse(HelperClassPredicate.isBootstrap("datadog.trace.instrumentation.foo.Bar")); + assertFalse(HelperClassPredicate.isBootstrap("com.example.Lib")); + } +} diff --git a/dd-java-agent/instrumentation/datastax-cassandra/datastax-cassandra-4.0/src/main/java/datadog/trace/instrumentation/datastax/cassandra4/CassandraClientInstrumentation.java b/dd-java-agent/instrumentation/datastax-cassandra/datastax-cassandra-4.0/src/main/java/datadog/trace/instrumentation/datastax/cassandra4/CassandraClientInstrumentation.java index 963ee8c5439..f9e0f865ad3 100644 --- a/dd-java-agent/instrumentation/datastax-cassandra/datastax-cassandra-4.0/src/main/java/datadog/trace/instrumentation/datastax/cassandra4/CassandraClientInstrumentation.java +++ b/dd-java-agent/instrumentation/datastax-cassandra/datastax-cassandra-4.0/src/main/java/datadog/trace/instrumentation/datastax/cassandra4/CassandraClientInstrumentation.java @@ -24,15 +24,6 @@ public String instrumentedType() { return "com.datastax.oss.driver.internal.core.session.DefaultSession"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".CassandraClientDecorator", - packageName + ".TracingSession", - packageName + ".ContactPointsUtil", - }; - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/google-http-client-1.19/src/main/java/datadog/trace/instrumentation/googlehttpclient/GoogleHttpClientInstrumentation.java b/dd-java-agent/instrumentation/google-http-client-1.19/src/main/java/datadog/trace/instrumentation/googlehttpclient/GoogleHttpClientInstrumentation.java index 769976bfc7a..84c8196b787 100644 --- a/dd-java-agent/instrumentation/google-http-client-1.19/src/main/java/datadog/trace/instrumentation/googlehttpclient/GoogleHttpClientInstrumentation.java +++ b/dd-java-agent/instrumentation/google-http-client-1.19/src/main/java/datadog/trace/instrumentation/googlehttpclient/GoogleHttpClientInstrumentation.java @@ -39,13 +39,6 @@ public String instrumentedType() { return "com.google.api.client.http.HttpRequest"; } - @Override - public String[] helperClassNames() { - return new String[] { - packageName + ".GoogleHttpClientDecorator", packageName + ".HeadersInjectAdapter" - }; - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvices( diff --git a/dd-java-agent/instrumentation/jedis/jedis-4.0/src/main/java/datadog/trace/instrumentation/jedis40/JedisInstrumentation.java b/dd-java-agent/instrumentation/jedis/jedis-4.0/src/main/java/datadog/trace/instrumentation/jedis40/JedisInstrumentation.java index 24350a6a3a6..6c525ebb6ab 100644 --- a/dd-java-agent/instrumentation/jedis/jedis-4.0/src/main/java/datadog/trace/instrumentation/jedis40/JedisInstrumentation.java +++ b/dd-java-agent/instrumentation/jedis/jedis-4.0/src/main/java/datadog/trace/instrumentation/jedis40/JedisInstrumentation.java @@ -33,13 +33,6 @@ public String instrumentedType() { return "redis.clients.jedis.Connection"; } - @Override - public String[] helperClassNames() { - return new String[] { - "redis.clients.jedis.JedisClientDecorator", - }; - } - @Override public void methodAdvice(MethodTransformer transformer) { transformer.applyAdvice( diff --git a/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletInstrumentation.java b/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletInstrumentation.java index b1af9e2ea13..d409628ca29 100644 --- a/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletInstrumentation.java +++ b/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletInstrumentation.java @@ -45,13 +45,6 @@ public ElementMatcher hierarchyMatcher() { return extendsClass(named(hierarchyMarkerType())); } - @Override - public String[] helperClassNames() { - return new String[] { - "datadog.trace.instrumentation.servlet.SpanNameCache", packageName + ".HttpServletDecorator", - }; - } - /** * Here we are instrumenting the protected method for HttpServlet. This should ensure that this * advice is always called after Servlet3Instrumentation which is instrumenting the public method. diff --git a/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletResponseInstrumentation.java b/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletResponseInstrumentation.java index 10e6c530212..e708d76e79a 100644 --- a/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletResponseInstrumentation.java +++ b/dd-java-agent/instrumentation/servlet/javax-servlet/javax-servlet-common/src/main/java/datadog/trace/instrumentation/servlet/http/HttpServletResponseInstrumentation.java @@ -42,7 +42,6 @@ public ElementMatcher hierarchyMatcher() { public String[] helperClassNames() { return new String[] { "datadog.trace.instrumentation.servlet.ServletRequestSetter", - packageName + ".HttpServletResponseDecorator", }; } diff --git a/metadata/agent-jar-checks.properties b/metadata/agent-jar-checks.properties index d2565d0f6fd..adf796715c9 100644 --- a/metadata/agent-jar-checks.properties +++ b/metadata/agent-jar-checks.properties @@ -1,7 +1,7 @@ # Agent jar structural invariants — edit intentionally, commit with the change that justified it. -# Max agent jar size in bytes. Raise only when the size growth is intentional (~33.02 MiB). -jar.size.budget = 34619392 +# Max agent jar size in bytes. Raise only when the size growth is intentional (~33.07 MiB). +jar.size.budget = 34676408 # Minimum combined class + classdata count in the assembled agent jar. # Set to ~98% of the actual count at the time of the last intentional change.