fix(jcache): Make replace and getAndReplace passthrough (no span)

Like putIfAbsent, these are conditional writes that may be no-ops.
Emitting a cache.put span for them would be misleading.

Author: adinauer

sentry-jcache/src/main/java/io/sentry/jcache/SentryJCacheWrapper.java

@@ -154,61 +154,22 @@ public boolean putIfAbsent(final K key, final V value) {
     return delegate.putIfAbsent(key, value);
   }
 
+  // replace and getAndReplace are not instrumented — like putIfAbsent, they are conditional
+  // writes (only happen if the key exists / value matches). Emitting a cache.put span for a
+  // potential no-op would be misleading.
   @Override
   public boolean replace(final K key, final V oldValue, final V newValue) {
-    final ISpan span = startSpan("cache.put", key);
-    if (span == null) {
-      return delegate.replace(key, oldValue, newValue);
-    }
-    try {
-      final boolean result = delegate.replace(key, oldValue, newValue);
-      span.setStatus(SpanStatus.OK);
-      return result;
-    } catch (Throwable e) {
-      span.setStatus(SpanStatus.INTERNAL_ERROR);
-      span.setThrowable(e);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return delegate.replace(key, oldValue, newValue);
   }
 
   @Override
   public boolean replace(final K key, final V value) {
-    final ISpan span = startSpan("cache.put", key);
-    if (span == null) {
-      return delegate.replace(key, value);
-    }
-    try {
-      final boolean result = delegate.replace(key, value);
-      span.setStatus(SpanStatus.OK);
-      return result;
-    } catch (Throwable e) {
-      span.setStatus(SpanStatus.INTERNAL_ERROR);
-      span.setThrowable(e);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return delegate.replace(key, value);
   }
 
   @Override
   public V getAndReplace(final K key, final V value) {
-    final ISpan span = startSpan("cache.put", key);
-    if (span == null) {
-      return delegate.getAndReplace(key, value);
-    }
-    try {
-      final V result = delegate.getAndReplace(key, value);
-      span.setStatus(SpanStatus.OK);
-      return result;
-    } catch (Throwable e) {
-      span.setStatus(SpanStatus.INTERNAL_ERROR);
-      span.setThrowable(e);
-      throw e;
-    } finally {
-      span.finish();
-    }
+    return delegate.getAndReplace(key, value);
   }
 
   // -- remove operations --

sentry-jcache/src/test/kotlin/io/sentry/jcache/SentryJCacheWrapperTest.kt

@@ -178,49 +178,47 @@ class SentryJCacheWrapperTest {
     assertEquals(0, tx.spans.size)
   }
 
-  // -- replace(K, V, V) --
+  // -- replace (passthrough, no span — conditional write) --
 
   @Test
-  fun `replace with old value creates cache put span`() {
+  fun `replace with old value delegates without creating span`() {
     val tx = createTransaction()
     val wrapper = SentryJCacheWrapper(delegate, scopes)
     whenever(delegate.replace("myKey", "old", "new")).thenReturn(true)
 
     val result = wrapper.replace("myKey", "old", "new")
 
     assertTrue(result)
-    assertEquals(1, tx.spans.size)
-    assertEquals("cache.put", tx.spans.first().operation)
+    verify(delegate).replace("myKey", "old", "new")
+    assertEquals(0, tx.spans.size)
   }
 
-  // -- replace(K, V) --
-
   @Test
-  fun `replace creates cache put span`() {
+  fun `replace delegates without creating span`() {
     val tx = createTransaction()
     val wrapper = SentryJCacheWrapper(delegate, scopes)
     whenever(delegate.replace("myKey", "value")).thenReturn(true)
 
     val result = wrapper.replace("myKey", "value")
 
     assertTrue(result)
-    assertEquals(1, tx.spans.size)
-    assertEquals("cache.put", tx.spans.first().operation)
+    verify(delegate).replace("myKey", "value")
+    assertEquals(0, tx.spans.size)
   }
 
-  // -- getAndReplace --
+  // -- getAndReplace (passthrough, no span — conditional write) --
 
   @Test
-  fun `getAndReplace creates cache put span`() {
+  fun `getAndReplace delegates without creating span`() {
     val tx = createTransaction()
     val wrapper = SentryJCacheWrapper(delegate, scopes)
     whenever(delegate.getAndReplace("myKey", "newValue")).thenReturn("oldValue")
 
     val result = wrapper.getAndReplace("myKey", "newValue")
 
     assertEquals("oldValue", result)
-    assertEquals(1, tx.spans.size)
-    assertEquals("cache.put", tx.spans.first().operation)
+    verify(delegate).getAndReplace("myKey", "newValue")
+    assertEquals(0, tx.spans.size)
   }
 
   // -- remove(K) --