Remove map based WeakCache implementation (#4846)

* Replace WeakCache usage with DDCaches.newFixedSizeWeakKeyCache
* Bump ClassLoaderMatchers and InstrumenterState caches based on tests with large modular web-apps
* Reduce seenDomains cache capacity based on tests with large modular web-apps
* Multiply identityHashCode by -127 to get a better spread

Author: mcculls

dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/WeakCache.java

@@ -41,9 +41,8 @@ public class AgentInstaller {
 
   static {
     addByteBuddyRawSetting();
-    // register weak map/cache suppliers as early as possible
+    // register weak map supplier as early as possible
     WeakMaps.registerAsSupplier();
-    WeakCaches.registerAsSupplier();
   }
 
   public static void installBytebuddyAgent(final Instrumentation inst) {

dd-java-agent/agent-builder/src/main/java/datadog/trace/agent/tooling/AgentInstaller.java

@@ -4,9 +4,9 @@
 import static datadog.trace.bootstrap.AgentClassLoading.LOCATING_CLASS;
 
 import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
-import datadog.trace.agent.tooling.WeakCaches;
 import datadog.trace.api.InstrumenterConfig;
-import datadog.trace.bootstrap.WeakCache;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import java.lang.ref.WeakReference;
 import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
@@ -74,8 +74,8 @@ public static void registerAsSupplier() {
    *   <li>Allow for quick fast path equivalence check of composite keys
    * </ul>
    */
-  final WeakCache<ClassLoader, WeakReference<ClassLoader>> loaderRefCache =
-      WeakCaches.newWeakCache(LOADER_CAPACITY);
+  final DDCache<ClassLoader, WeakReference<ClassLoader>> loaderRefCache =
+      DDCaches.newFixedSizeWeakKeyCache(LOADER_CAPACITY);
 
   /**
    * Single shared Type.Resolution cache -- uses a composite key -- conceptually of loader & name

dd-java-agent/agent-builder/src/main/java/datadog/trace/agent/tooling/bytebuddy/DDCachingPoolStrategy.java

@@ -1,6 +1,7 @@
 package datadog.trace.agent.tooling;
 
-import datadog.trace.bootstrap.WeakCache;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import datadog.trace.util.Strings;
 import java.util.Arrays;
 import java.util.concurrent.atomic.AtomicLongArray;
@@ -32,8 +33,8 @@ public interface Observer {
   private static long[] defaultState = {};
 
   /** Tracks which instrumentations were applied (per-class-loader) and which were blocked. */
-  private static final WeakCache<ClassLoader, AtomicLongArray> classLoaderStates =
-      WeakCaches.newWeakCache(64);
+  private static final DDCache<ClassLoader, AtomicLongArray> classLoaderStates =
+      DDCaches.newFixedSizeWeakKeyCache(512);
 
   private static Observer observer;
 

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/InstrumenterState.java

@@ -4,9 +4,9 @@
 import static datadog.trace.util.Strings.getResourceName;
 
 import datadog.trace.agent.tooling.Utils;
-import datadog.trace.agent.tooling.WeakCaches;
 import datadog.trace.api.InstrumenterConfig;
-import datadog.trace.bootstrap.WeakCache;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.ref.WeakReference;
@@ -22,8 +22,8 @@
  * cannot find the desired resource, check up the classloader hierarchy until a resource is found.
  */
 public final class ClassFileLocators {
-  private static final WeakCache<ClassLoader, DDClassFileLocator> classFileLocators =
-      WeakCaches.newWeakCache(64);
+  private static final DDCache<ClassLoader, DDClassFileLocator> classFileLocators =
+      DDCaches.newFixedSizeWeakKeyCache(64);
 
   private static final ClassFileLocator bootClassFileLocator =
       new ClassFileLocator() {

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/WeakCaches.java

@@ -1,8 +1,8 @@
 package datadog.trace.agent.tooling.bytebuddy;
 
 import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
-import datadog.trace.agent.tooling.WeakCaches;
-import datadog.trace.bootstrap.WeakCache;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import java.lang.ref.WeakReference;
 import java.net.URL;
 import java.util.Objects;
@@ -58,7 +58,8 @@ private static LoaderId loaderId(ClassLoader loader) {
   static final ClassLoader BOOTSTRAP_LOADER = null;
   static final LoaderId BOOTSTRAP_LOADER_ID = null;
 
-  private static final WeakCache<ClassLoader, LoaderId> loaderIds = WeakCaches.newWeakCache(64);
+  private static final DDCache<ClassLoader, LoaderId> loaderIds =
+      DDCaches.newFixedSizeWeakKeyCache(64);
 
   /** Supports classloader comparisons without strongly referencing the classloader. */
   private static final class LoaderId extends WeakReference<ClassLoader> {

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/ClassFileLocators.java

@@ -3,11 +3,11 @@
 import static datadog.trace.bootstrap.AgentClassLoading.PROBING_CLASSLOADER;
 import static net.bytebuddy.matcher.ElementMatchers.any;
 
-import datadog.trace.agent.tooling.WeakCaches;
 import datadog.trace.api.InstrumenterConfig;
 import datadog.trace.api.Tracer;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import datadog.trace.bootstrap.PatchLogger;
-import datadog.trace.bootstrap.WeakCache;
 import datadog.trace.util.Strings;
 import java.util.ArrayList;
 import java.util.BitSet;
@@ -128,7 +128,7 @@ private static boolean loadsExpectedClass(
   static final List<String> hasClassResourceNames = new ArrayList<>();
 
   /** Cache of classloader-instance -> has-class mask. */
-  static final WeakCache<ClassLoader, BitSet> hasClassCache = WeakCaches.newWeakCache(64);
+  static final DDCache<ClassLoader, BitSet> hasClassCache = DDCaches.newFixedSizeWeakKeyCache(512);
 
   /** Distinct result used to mark an incompatible classloader that the tracer should skip. */
   static final BitSet INCOMPATIBLE_CLASS_LOADER = new BitSet();

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/TypeInfoCache.java

@@ -139,7 +139,8 @@ static final class IdentityHash<K, V> extends FixedSizeCache<K, V> {
     }
 
     int hash(K key) {
-      return System.identityHashCode(key);
+      int hash = System.identityHashCode(key);
+      return hash - (hash << 7); // multiply by -127 to improve identityHashCode spread
     }
 
     boolean equals(K key, Pair<K, V> current) {

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/bytebuddy/matcher/ClassLoaderMatchers.java

@@ -64,7 +64,7 @@ public final V computeIfAbsent(K key, Function<K, ? extends V> producer) {
 
     int hash = System.identityHashCode(key);
 
-    int h = hash;
+    int h = hash - (hash << 7); // multiply by -127 to improve identityHashCode spread
     int firstPos = h & mask;
     V value;
 

dd-java-agent/agent-tooling/src/test/groovy/datadog/trace/agent/tooling/WeakCacheTest.groovy

@@ -1,7 +1,7 @@
 package datadog.telemetry.dependency;
 
-import datadog.trace.agent.tooling.WeakCaches;
-import datadog.trace.bootstrap.WeakCache;
+import datadog.trace.api.cache.DDCache;
+import datadog.trace.api.cache.DDCaches;
 import java.lang.instrument.ClassFileTransformer;
 import java.net.URL;
 import java.security.CodeSource;
@@ -12,14 +12,16 @@
 class LocationsCollectingTransformer implements ClassFileTransformer {
   private static final Logger log = LoggerFactory.getLogger(LocationsCollectingTransformer.class);
 
-  private static final int MAX_CACHED_JARS = 4096;
+  private static final int MAX_CACHED_JARS = 1024;
   private final DependencyServiceImpl dependencyService;
-  private final WeakCache<ProtectionDomain, Boolean> seenDomains =
-      WeakCaches.newWeakCache(MAX_CACHED_JARS);
+  private final DDCache<ProtectionDomain, Boolean> seenDomains =
+      DDCaches.newFixedSizeWeakKeyCache(MAX_CACHED_JARS);
+
+  private final ProtectionDomain tracerDomain =
+      LocationsCollectingTransformer.class.getProtectionDomain();
 
   public LocationsCollectingTransformer(DependencyServiceImpl dependencyService) {
     this.dependencyService = dependencyService;
-    seenDomains.put(LocationsCollectingTransformer.class.getProtectionDomain(), true);
   }
 
   @Override
@@ -29,7 +31,7 @@ public byte[] transform(
       Class<?> classBeingRedefined,
       ProtectionDomain protectionDomain,
       byte[] classfileBuffer) {
-    if (protectionDomain != null) {
+    if (protectionDomain != null && !protectionDomain.equals(tracerDomain)) {
       seenDomains.computeIfAbsent(protectionDomain, this::addDependency);
     }
     // returning 'null' is the best way to indicate that no transformation has been done.