Drop instrumentation-api-caching module and move weak cache implementation to instrumentation-api

conventions/src/main/kotlin/otel.javaagent-bootstrap.gradle.kts

@@ -12,8 +12,4 @@ dependencies {
   compileOnly("io.opentelemetry:opentelemetry-api")
   compileOnly(project(":instrumentation-api"))
   compileOnly(project(":javaagent-instrumentation-api"))
-
-  // this only exists to make Intellij happy since it doesn't (currently at least) understand our
-  // inclusion of this artifact inside of :instrumentation-api
-  compileOnly(project(":instrumentation-api-caching"))
 }

conventions/src/main/kotlin/otel.javaagent-instrumentation.gradle.kts

@@ -7,10 +7,4 @@ plugins {
 
 extra["mavenGroupId"] = "io.opentelemetry.javaagent.instrumentation"
 
-base.archivesName.set(projectDir.parentFile.name)
-
-dependencies {
-  // this only exists to make Intellij happy since it doesn't (currently at least) understand our
-  // inclusion of this artifact inside of :instrumentation-api
-  compileOnly(project(":instrumentation-api-caching"))
-}
+base.archivesName.set(projectDir.parentFile.name)

conventions/src/main/kotlin/otel.library-instrumentation.gradle.kts

@@ -8,10 +8,4 @@ plugins {
 
 extra["mavenGroupId"] = "io.opentelemetry.instrumentation"
 
-base.archivesName.set(projectDir.parentFile.name)
-
-dependencies {
-  // this only exists to make Intellij happy since it doesn't (currently at least) understand our
-  // inclusion of this artifact inside of :instrumentation-api
-  compileOnly(project(":instrumentation-api-caching"))
-}
+base.archivesName.set(projectDir.parentFile.name)

instrumentation-api-annotation-support/build.gradle.kts

@@ -10,11 +10,6 @@ group = "io.opentelemetry.instrumentation"
 dependencies {
   implementation(project(":instrumentation-api"))
 
-  // this only exists to make Intellij happy since it doesn't (currently at least) understand our
-  // inclusion of this artifact inside of :instrumentation-api
-  compileOnly(project(":instrumentation-api-caching"))
-  testCompileOnly(project(":instrumentation-api-caching"))
-
   api("io.opentelemetry:opentelemetry-api")
   api("io.opentelemetry:opentelemetry-semconv")
 

instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodCache.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.instrumentation.api.annotation.support;
 
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

instrumentation-api-annotation-support/src/main/java/io/opentelemetry/instrumentation/api/annotation/support/MethodSpanAttributesExtractor.java

@@ -6,7 +6,7 @@
 package io.opentelemetry.instrumentation.api.annotation.support;
 
 import io.opentelemetry.api.common.AttributesBuilder;
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor;
 import io.opentelemetry.instrumentation.api.tracer.AttributeSetter;
 import java.lang.reflect.Method;

instrumentation-api-annotation-support/src/test/groovy/io/opentelemetry/instrumentation/api/annotation/support/MethodSpanAttributesExtractorTest.groovy

@@ -6,7 +6,7 @@
 package io.opentelemetry.instrumentation.api.annotation.support
 
 import io.opentelemetry.api.common.AttributesBuilder
-import io.opentelemetry.instrumentation.api.caching.Cache
+import io.opentelemetry.instrumentation.api.cache.Cache
 import spock.lang.Specification
 
 import java.lang.reflect.Method

instrumentation-api-annotation-support/src/test/java/io/opentelemetry/instrumentation/api/annotation/support/MethodCacheTest.java

@@ -11,7 +11,7 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import java.lang.reflect.Method;
 import java.util.function.Function;
 import org.junit.jupiter.api.Test;

instrumentation-api-caching/src/main/java/io/opentelemetry/instrumentation/api/caching/Cache.java

@@ -9,7 +9,7 @@
 import javax.annotation.Nullable;
 
 /** A cache from keys to values. */
-public interface Cache<K, V> {
+interface Cache<K, V> {
 
   /** Returns a new {@link CacheBuilder} to configure a {@link Cache}. */
   static CacheBuilder builder() {

instrumentation-api/build.gradle.kts

@@ -14,27 +14,23 @@ sourceSets {
       // set to generate into. By default it would be the src/main directory itself.
       srcDir("$buildDir/generated/sources/jflex")
     }
-
-    val cachingShadedDeps = project(":instrumentation-api-caching")
-    output.dir(cachingShadedDeps.file("build/extracted/shadow"), "builtBy" to ":instrumentation-api-caching:extractShadowJar")
   }
 }
 
 group = "io.opentelemetry.instrumentation"
 
 dependencies {
-  compileOnly(project(":instrumentation-api-caching"))
-
   api("io.opentelemetry:opentelemetry-api")
   api("io.opentelemetry:opentelemetry-semconv")
 
   implementation("io.opentelemetry:opentelemetry-api-metrics")
   implementation("org.slf4j:slf4j-api")
+  implementation("com.blogspot.mydailyjava:weak-lock-free")
+  implementation("com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2")
 
   compileOnly("com.google.auto.value:auto-value-annotations")
   annotationProcessor("com.google.auto.value:auto-value")
 
-  testCompileOnly(project(":instrumentation-api-caching"))
   testImplementation(project(":testing-common"))
   testImplementation("org.mockito:mockito-core")
   testImplementation("org.mockito:mockito-junit-jupiter")

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/cache/BoundedCache.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.api.cache;
+
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+final class BoundedCache<K, V> implements Cache<K, V> {
+
+  private final ConcurrentMap<K, V> delegate;
+
+  BoundedCache(ConcurrentMap<K, V> delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
+    return delegate.computeIfAbsent(key, mappingFunction);
+  }
+
+  @Nullable
+  @Override
+  public V get(K key) {
+    return delegate.get(key);
+  }
+
+  @Override
+  public void put(K key, V value) {
+    delegate.put(key, value);
+  }
+
+  @Override
+  public void remove(K key) {
+    delegate.remove(key);
+  }
+
+  // Visible for tests
+  int size() {
+    return delegate.size();
+  }
+}

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/cache/Cache.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.instrumentation.api.cache;
+
+import com.googlecode.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+/**
+ * A cache from keys to values.
+ *
+ * <p>Keys are always referenced weakly and are compared using identity comparison, not {@link
+ * Object#equals(Object)}.
+ */
+public interface Cache<K, V> {
+
+  /**
+   * Returns new unbounded cache
+   *
+   * <p>Keys are referenced weakly and compared using identity comparison, not {@link
+   * Object#equals(Object)}.
+   */
+  static <K, V> Cache<K, V> weak() {
+    return new WeakLockFreeCache<>();
+  }
+
+  /**
+   * Returns new bounded cache.
+   *
+   * <p>Both keys and values are strongly referenced.
+   */
+  static <K, V> Cache<K, V> bounded(int capacity) {
+    ConcurrentLinkedHashMap<K, V> map =
+        new ConcurrentLinkedHashMap.Builder<K, V>().maximumWeightedCapacity(capacity).build();
+    return new BoundedCache<>(map);
+  }
+
+  /**
+   * Returns the cached value associated with the provided {@code key}. If no value is cached yet,
+   * computes the value using {@code mappingFunction}, stores the result, and returns it.
+   */
+  V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction);
+
+  /**
+   * Returns the cached value associated with the provided {@code key} if present, or {@code null}
+   * otherwise.
+   */
+  @Nullable
+  V get(K key);
+
+  /** Puts the {@code value} into the cache for the {@code key}. */
+  void put(K key, V value);
+
+  /** Removes a value for {@code key} if present. */
+  void remove(K key);
+}

instrumentation-api-caching/src/main/java/io/opentelemetry/instrumentation/api/caching/WeakLockFreeCache.java → instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/cache/WeakLockFreeCache.java

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-package io.opentelemetry.instrumentation.api.caching;
+package io.opentelemetry.instrumentation.api.cache;
 
 import com.blogspot.mydailyjava.weaklockfree.WeakConcurrentMap;
 import java.util.function.Function;

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/db/SqlStatementSanitizer.java

@@ -9,7 +9,7 @@
 import static io.opentelemetry.instrumentation.api.internal.SupportabilityMetrics.CounterNames.SQL_STATEMENT_SANITIZER_CACHE_MISS;
 
 import com.google.auto.value.AutoValue;
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import io.opentelemetry.instrumentation.api.internal.SupportabilityMetrics;
 import javax.annotation.Nullable;
 
@@ -21,7 +21,7 @@ public final class SqlStatementSanitizer {
   private static final SupportabilityMetrics supportability = SupportabilityMetrics.instance();
 
   private static final Cache<CacheKey, SqlStatementInfo> sqlToStatementInfoCache =
-      Cache.builder().setMaximumSize(1000).build();
+      Cache.bounded(1000);
 
   public static SqlStatementInfo sanitize(@Nullable String statement) {
     return sanitize(statement, SqlDialect.DEFAULT);

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/instrumenter/http/HttpHeaderAttributes.java

@@ -6,15 +6,19 @@
 package io.opentelemetry.instrumentation.api.instrumenter.http;
 
 import io.opentelemetry.api.common.AttributeKey;
-import io.opentelemetry.instrumentation.api.caching.Cache;
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 final class HttpHeaderAttributes {
 
-  private static final Cache<String, AttributeKey<List<String>>> requestKeysCache =
-      Cache.builder().setMaximumSize(32).build();
-  private static final Cache<String, AttributeKey<List<String>>> responseKeysCache =
-      Cache.builder().setMaximumSize(32).build();
+  // these are naturally bounded because they only store keys listed in
+  // otel.instrumentation.http.capture-headers.server.request and
+  // otel.instrumentation.http.capture-headers.server.response
+  private static final ConcurrentMap<String, AttributeKey<List<String>>> requestKeysCache =
+      new ConcurrentHashMap<>();
+  private static final ConcurrentMap<String, AttributeKey<List<String>>> responseKeysCache =
+      new ConcurrentHashMap<>();
 
   static AttributeKey<List<String>> requestAttributeKey(String headerName) {
     return requestKeysCache.computeIfAbsent(headerName, n -> createKey("request", n));

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/internal/RuntimeVirtualFieldSupplier.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.instrumentation.api.internal;
 
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import io.opentelemetry.instrumentation.api.field.VirtualField;
 import javax.annotation.Nullable;
 import org.slf4j.Logger;
@@ -40,19 +40,19 @@ public static VirtualFieldSupplier get() {
   private static final class CacheBasedVirtualFieldSupplier implements VirtualFieldSupplier {
 
     private final Cache<Class<?>, Cache<Class<?>, VirtualField<?, ?>>>
-        ownerToFieldToImplementationMap = Cache.builder().setWeakKeys().build();
+        ownerToFieldToImplementationMap = Cache.weak();
 
     @Override
     public <U extends T, T, F> VirtualField<U, F> find(Class<T> type, Class<F> fieldType) {
       return (VirtualField<U, F>)
           ownerToFieldToImplementationMap
-              .computeIfAbsent(type, c -> Cache.builder().setWeakKeys().build())
+              .computeIfAbsent(type, c -> Cache.weak())
               .computeIfAbsent(fieldType, c -> new CacheBasedVirtualField<>());
     }
   }
 
   private static final class CacheBasedVirtualField<T, F> extends VirtualField<T, F> {
-    private final Cache<T, F> cache = Cache.builder().setWeakKeys().build();
+    private final Cache<T, F> cache = Cache.weak();
 
     @Override
     @Nullable

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/tracer/ClassNames.java

@@ -5,11 +5,11 @@
 
 package io.opentelemetry.instrumentation.api.tracer;
 
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 
 public final class ClassNames {
 
-  private static final Cache<Class<?>, String> simpleNames = Cache.builder().setWeakKeys().build();
+  private static final Cache<Class<?>, String> simpleNames = Cache.weak();
 
   /**
    * This method is used to generate a simple name based on a given class reference, e.g. for use in

instrumentation-api/src/main/java/io/opentelemetry/instrumentation/api/tracer/SpanNames.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.instrumentation.api.tracer;
 
-import io.opentelemetry.instrumentation.api.caching.Cache;
+import io.opentelemetry.instrumentation.api.cache.Cache;
 import io.opentelemetry.instrumentation.api.util.ClassAndMethod;
 import java.lang.reflect.Method;
 import java.util.Map;
@@ -14,8 +14,7 @@
 
 public final class SpanNames {
 
-  private static final Cache<Class<?>, Map<String, String>> spanNameCaches =
-      Cache.builder().setWeakKeys().build();
+  private static final Cache<Class<?>, Map<String, String>> spanNameCaches = Cache.weak();
 
   /**
    * This method is used to generate a span name based on a method. Anonymous classes are named