Classify Redisson Redis server errors

instrumentation/redisson/redisson-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/v3_0/RedisCommandDataInstrumentation.java

@@ -13,6 +13,7 @@
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
 import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.CompletableFutureWrapper;
+import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedissonErrorCapture;
 import java.util.concurrent.CompletableFuture;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.asm.Advice.AssignReturned;
@@ -26,7 +27,9 @@ class RedisCommandDataInstrumentation implements TypeInstrumentation {
   @Override
   public ElementMatcher<TypeDescription> typeMatcher() {
     return namedOneOf(
-        "org.redisson.client.protocol.CommandData", "org.redisson.client.protocol.CommandsData");
+        "org.redisson.client.protocol.CommandData",
+        "org.redisson.client.protocol.CommandsData",
+        "org.redisson.client.protocol.BatchCommandData");
   }
 
   @Override
@@ -39,6 +42,9 @@ public void transform(TypeTransformer transformer) {
     transformer.applyAdviceToMethod(
         isConstructor().and(takesArgument(0, CompletableFuture.class)),
         getClass().getName() + "$WrapCompletableFutureAdvice");
+    transformer.applyAdviceToMethod(
+        named("tryFailure").and(takesArgument(0, Throwable.class)),
+        getClass().getName() + "$CaptureErrorAdvice");
   }
 
   @SuppressWarnings("unused")
@@ -61,4 +67,13 @@ public static CompletableFuture<?> onEnter(
       return CompletableFutureWrapper.wrap(completableFuture);
     }
   }
+
+  @SuppressWarnings("unused")
+  public static class CaptureErrorAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class, inline = false)
+    public static void onEnter(@Advice.Argument(0) Throwable error) {
+      RedissonErrorCapture.captureServerError(error);
+    }
+  }
 }

instrumentation/redisson/redisson-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/v3_0/RedissonInstrumentationModule.java

@@ -13,6 +13,7 @@
 import com.google.auto.service.AutoService;
 import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedisCommandDecoderInstrumentation;
 import java.util.List;
 import net.bytebuddy.matcher.ElementMatcher;
 
@@ -35,6 +36,7 @@ public List<TypeInstrumentation> typeInstrumentations() {
         new ConnectionManagerConnectionFutureInstrumentation(),
         new MasterSlaveConnectionManagerInstrumentation(),
         new RedisConnectionInstrumentation(),
+        new RedisCommandDecoderInstrumentation(),
         new RedisCommandDataInstrumentation());
   }
 

instrumentation/redisson/redisson-3.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/redisson/v3_0/RedissonAsyncClientTest.java

@@ -6,5 +6,12 @@
 package io.opentelemetry.javaagent.instrumentation.redisson.v3_0;
 
 import io.opentelemetry.javaagent.instrumentation.redisson.AbstractRedissonAsyncClientTest;
+import org.redisson.api.RBatch;
+import org.redisson.api.RedissonClient;
 
-class RedissonAsyncClientTest extends AbstractRedissonAsyncClientTest {}
+class RedissonAsyncClientTest extends AbstractRedissonAsyncClientTest {
+  @Override
+  protected RBatch createBatch(RedissonClient redisson) {
+    return redisson.createBatch();
+  }
+}

instrumentation/redisson/redisson-3.17/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/v3_17/RedisCommandDataInstrumentation.java

@@ -6,12 +6,14 @@
 package io.opentelemetry.javaagent.instrumentation.redisson.v3_17;
 
 import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
+import static net.bytebuddy.matcher.ElementMatchers.named;
 import static net.bytebuddy.matcher.ElementMatchers.namedOneOf;
 import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
 
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
 import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.CompletableFutureWrapper;
+import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedissonErrorCapture;
 import java.util.concurrent.CompletableFuture;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.asm.Advice.AssignReturned;
@@ -24,14 +26,19 @@ class RedisCommandDataInstrumentation implements TypeInstrumentation {
   @Override
   public ElementMatcher<TypeDescription> typeMatcher() {
     return namedOneOf(
-        "org.redisson.client.protocol.CommandData", "org.redisson.client.protocol.CommandsData");
+        "org.redisson.client.protocol.CommandData",
+        "org.redisson.client.protocol.CommandsData",
+        "org.redisson.client.protocol.BatchCommandData");
   }
 
   @Override
   public void transform(TypeTransformer transformer) {
     transformer.applyAdviceToMethod(
         isConstructor().and(takesArgument(0, CompletableFuture.class)),
         getClass().getName() + "$WrapCompletableFutureAdvice");
+    transformer.applyAdviceToMethod(
+        named("tryFailure").and(takesArgument(0, Throwable.class)),
+        getClass().getName() + "$CaptureErrorAdvice");
   }
 
   @SuppressWarnings("unused")
@@ -44,4 +51,13 @@ public static CompletableFuture<?> onEnter(
       return CompletableFutureWrapper.wrap(completableFuture);
     }
   }
+
+  @SuppressWarnings("unused")
+  public static class CaptureErrorAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class, inline = false)
+    public static void onEnter(@Advice.Argument(0) Throwable error) {
+      RedissonErrorCapture.captureServerError(error);
+    }
+  }
 }

instrumentation/redisson/redisson-3.17/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/v3_17/RedissonInstrumentationModule.java

@@ -12,6 +12,7 @@
 import com.google.auto.service.AutoService;
 import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
 import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedisCommandDecoderInstrumentation;
 import java.util.List;
 import net.bytebuddy.matcher.ElementMatcher;
 
@@ -34,6 +35,7 @@ public List<TypeInstrumentation> typeInstrumentations() {
         new MasterSlaveConnectionManagerInstrumentation(),
         new RedisExecutorConnectionFutureInstrumentation(),
         new RedisConnectionInstrumentation(),
+        new RedisCommandDecoderInstrumentation(),
         new RedisCommandDataInstrumentation());
   }
 

instrumentation/redisson/redisson-common-3.0/javaagent/build.gradle.kts

@@ -8,3 +8,21 @@ dependencies {
   compileOnly("com.google.auto.value:auto-value-annotations")
   annotationProcessor("com.google.auto.value:auto-value")
 }
+
+testing {
+  suites {
+    register<JvmTestSuite>("unitTests") {
+      dependencies {
+        implementation(project())
+        implementation(project(":instrumentation-api-incubator"))
+        implementation("org.redisson:redisson:3.0.0")
+      }
+    }
+  }
+}
+
+tasks {
+  check {
+    dependsOn(testing.suites)
+  }
+}

instrumentation/redisson/redisson-common-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/common/v3_0/EndOperationListener.java

@@ -24,6 +24,10 @@ public EndOperationListener(
 
   @Override
   public void accept(@Nullable T unused, @Nullable Throwable error) {
-    instrumenter.end(context, request, null, error);
+    try {
+      instrumenter.end(context, request, null, error);
+    } finally {
+      RedissonErrorCapture.clearServerError(error);
+    }
   }
 }

instrumentation/redisson/redisson-common-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/common/v3_0/RedisCommandDecoderInstrumentation.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0;
+
+import static io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedissonErrorCapture.currentServerErrorType;
+import static io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0.RedissonErrorCapture.parseServerErrorType;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+
+import io.netty.buffer.ByteBuf;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import javax.annotation.Nullable;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class RedisCommandDecoderInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("org.redisson.client.handler.CommandDecoder");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        named("decode")
+            .and(takesArgument(0, named("io.netty.buffer.ByteBuf")))
+            .and(takesArgument(1, named("org.redisson.client.protocol.CommandData"))),
+        getClass().getName() + "$DecodeAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class DecodeAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class, inline = false)
+    public static String onEnter(@Advice.Argument(0) ByteBuf input) {
+      return currentServerErrorType().set(parseServerErrorType(input));
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class, inline = false)
+    public static void onExit(@Advice.Enter @Nullable String previousErrorType) {
+      currentServerErrorType().restore(previousErrorType);
+    }
+  }
+}

instrumentation/redisson/redisson-common-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/common/v3_0/RedissonDbAttributesGetter.java

@@ -43,6 +43,13 @@ public Long getDbOperationBatchSize(RedissonRequest request) {
     return request.getOperationBatchSize();
   }
 
+  @Override
+  @Nullable
+  public String getErrorType(
+      RedissonRequest request, @Nullable Void response, @Nullable Throwable error) {
+    return RedissonErrorCapture.getServerErrorType(error);
+  }
+
   @Nullable
   @Override
   public String getServerAddress(RedissonRequest request) {

instrumentation/redisson/redisson-common-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/redisson/common/v3_0/RedissonErrorCapture.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.redisson.common.v3_0;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import io.netty.buffer.ByteBuf;
+import io.opentelemetry.instrumentation.api.incubator.semconv.db.internal.RedisErrorPrefix;
+import io.opentelemetry.instrumentation.api.internal.ScopedThreadValue;
+import io.opentelemetry.instrumentation.api.util.VirtualField;
+import javax.annotation.Nullable;
+import org.redisson.client.RedisException;
+
+/**
+ * Captures the first token from RESP error replies before Redisson completes the command promise.
+ *
+ * <p>Redisson's {@code CommandDecoder} calls {@code CommandData.tryFailure} while decoding a {@code
+ * -} reply, so the token is scoped to that decoder frame and attached to the resulting Redisson
+ * exception before completion callbacks can run. The operation listener clears it after extracting
+ * telemetry; all other errors use the shared exception-class fallback.
+ *
+ * @see <a
+ *     href="https://redis.io/docs/latest/develop/reference/protocol-spec/#resp-protocol-description">RESP
+ *     specification</a>
+ * @see <a
+ *     href="https://github.com/redisson/redisson/blob/3.52.0/redisson/src/main/java/org/redisson/client/handler/CommandDecoder.java">Redisson
+ *     CommandDecoder</a>
+ */
+public final class RedissonErrorCapture {
+
+  private static final ScopedThreadValue<String> currentServerErrorType = new ScopedThreadValue<>();
+
+  private static final VirtualField<RedisException, String> SERVER_ERROR =
+      VirtualField.find(RedisException.class, String.class, "redissonServerErrorType");
+
+  public static ScopedThreadValue<String> currentServerErrorType() {
+    return currentServerErrorType;
+  }
+
+  @Nullable
+  public static String parseServerErrorType(ByteBuf input) {
+    try {
+      int replyStart = input.readerIndex();
+      if (input.getByte(replyStart) != '-') {
+        return null;
+      }
+
+      int lineStart = replyStart + 1;
+      int lineEnd = findCrlf(input, lineStart);
+      if (lineEnd == -1) {
+        return null;
+      }
+
+      return RedisErrorPrefix.extract(input.toString(lineStart, lineEnd - lineStart, UTF_8));
+    } catch (Throwable ignored) {
+      // ReplayingDecoder retries incomplete replies; leave buffer handling to Redisson.
+      return null;
+    }
+  }
+
+  private static int findCrlf(ByteBuf input, int start) {
+    int end = input.writerIndex();
+    for (int i = start; i + 1 < end; i++) {
+      if (input.getByte(i) == '\r' && input.getByte(i + 1) == '\n') {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public static void captureServerError(@Nullable Throwable error) {
+    if (!(error instanceof RedisException)) {
+      return;
+    }
+
+    String errorType = currentServerErrorType.get();
+    if (errorType != null) {
+      SERVER_ERROR.set((RedisException) error, errorType);
+      // consume so completion callbacks run by tryFailure cannot attribute it to another command
+      currentServerErrorType.set(null);
+    }
+  }
+
+  @Nullable
+  public static String getServerErrorType(@Nullable Throwable error) {
+    if (!(error instanceof RedisException)) {
+      return null;
+    }
+
+    return SERVER_ERROR.get((RedisException) error);
+  }
+
+  public static void clearServerError(@Nullable Throwable error) {
+    if (error instanceof RedisException) {
+      SERVER_ERROR.set((RedisException) error, null);
+    }
+  }
+
+  private RedissonErrorCapture() {}
+}