Java agent insturmentation added for Failsafe 3.0

.fossa.yml

@@ -103,6 +103,9 @@ targets:
     - type: gradle
       path: ./
       target: ':instrumentation:external-annotations:javaagent'
+    - type: gradle
+      path: ./
+      target: ':instrumentation:failsafe-3.0:javaagent'
     - type: gradle
       path: ./
       target: ':instrumentation:failsafe-3.0:library'

instrumentation/failsafe-3.0/javaagent/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("dev.failsafe")
+    module.set("failsafe")
+    versions.set("[3.0.0,)")
+    assertInverse.set(true)
+  }
+}
+
+dependencies {
+  library("dev.failsafe:failsafe:3.0.1")
+
+  implementation(project(":instrumentation:failsafe-3.0:library"))
+
+  testImplementation(project(":instrumentation:failsafe-3.0:testing"))
+}
+
+tasks {
+  withType<Test>().configureEach {
+    jvmArgs("-Dotel.instrumentation.failsafe.enabled=true")
+  }
+}

instrumentation/failsafe-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/failsafe/v3_0/FailsafeInstrumentationModule.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.failsafe.v3_0;
+
+import static java.util.Collections.singletonList;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.internal.ExperimentalInstrumentationModule;
+import java.util.List;
+
+@AutoService(InstrumentationModule.class)
+public class FailsafeInstrumentationModule extends InstrumentationModule
+    implements ExperimentalInstrumentationModule {
+
+  public FailsafeInstrumentationModule() {
+    super("failsafe", "failsafe-3.0");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return singletonList(new RetryPolicyInstrumentation());
+  }
+
+  @Override
+  public boolean defaultEnabled() {
+    return false;
+  }
+
+  @Override
+  public boolean isIndyReady() {
+    return true;
+  }
+}

instrumentation/failsafe-3.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/failsafe/v3_0/RetryPolicyInstrumentation.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.failsafe.v3_0;
+
+import static io.opentelemetry.instrumentation.failsafe.v3_0.internal.RetryPolicyEventListenerBuilders.buildInstrumentedFailureListener;
+import static io.opentelemetry.instrumentation.failsafe.v3_0.internal.RetryPolicyEventListenerBuilders.buildInstrumentedSuccessListener;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.takesNoArguments;
+
+import dev.failsafe.PolicyConfig;
+import dev.failsafe.internal.RetryPolicyImpl;
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import java.lang.reflect.Field;
+import javax.annotation.Nullable;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public final class RetryPolicyInstrumentation implements TypeInstrumentation {
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("dev.failsafe.RetryPolicyBuilder");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        named("build").and(takesNoArguments()), this.getClass().getName() + "$BuildAdvice");
+  }
+
+  public static final class BuildAdvice {
+    @Nullable public static final Field FAILURE_LISTENER_FIELD;
+    @Nullable public static final Field SUCCESS_LISTENER_FIELD;
+
+    static {
+      Field failureListenerField = null;
+      Field successListenerField = null;
+      try {
+        failureListenerField = PolicyConfig.class.getDeclaredField("failureListener");
+        failureListenerField.setAccessible(true);
+
+        successListenerField = PolicyConfig.class.getDeclaredField("successListener");
+        successListenerField.setAccessible(true);
+      } catch (Exception e) {
+        // Ignored
+      }
+      FAILURE_LISTENER_FIELD = failureListenerField;
+      SUCCESS_LISTENER_FIELD = successListenerField;
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void onExit(@Advice.Return Object retryPolicyImpl) {
+      if (FAILURE_LISTENER_FIELD == null || SUCCESS_LISTENER_FIELD == null) {
+        return;
+      }
+
+      try {
+        RetryPolicyImpl<?> impl = (RetryPolicyImpl<?>) retryPolicyImpl;
+        FAILURE_LISTENER_FIELD.set(
+            impl.getConfig(),
+            buildInstrumentedFailureListener(
+                GlobalOpenTelemetry.get(), impl.getConfig(), impl.toString()));
+        SUCCESS_LISTENER_FIELD.set(
+            impl.getConfig(),
+            buildInstrumentedSuccessListener(
+                GlobalOpenTelemetry.get(), impl.getConfig(), impl.toString()));
+      } catch (IllegalAccessException ignored) {
+        // Ignored
+      }
+    }
+  }
+}

instrumentation/failsafe-3.0/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/failsafe/v3_0/FailsafeInstrumentationTest.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.failsafe.v3_0;
+
+import dev.failsafe.CircuitBreaker;
+import dev.failsafe.RetryPolicy;
+import io.opentelemetry.instrumentation.failsafe.AbstractFailsafeInstrumentationTest;
+import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
+import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+class FailsafeInstrumentationTest extends AbstractFailsafeInstrumentationTest {
+  @RegisterExtension
+  static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
+
+  @Override
+  protected InstrumentationExtension testing() {
+    return testing;
+  }
+
+  @Override
+  protected CircuitBreaker<Object> configure(CircuitBreaker<Object> userCircuitBreaker) {
+    return userCircuitBreaker;
+  }
+
+  @Override
+  protected RetryPolicy<Object> configure(RetryPolicy<Object> userRetryPolicy) {
+    return userRetryPolicy;
+  }
+
+  @Override
+  @Disabled
+  public void captureCircuitBreakerMetrics() {
+    // TODO: Will be enabled once Java agent CircuitBreaker instrumentation is added.
+  }
+
+  @Test
+  void captureRetryPolicyMetrics() {
+    captureRetryPolicyMetrics(null);
+  }
+}

instrumentation/failsafe-3.0/library/build.gradle.kts

@@ -4,6 +4,8 @@ plugins {
 
 dependencies {
   library("dev.failsafe:failsafe:3.0.1")
+
+  testImplementation(project(":instrumentation:failsafe-3.0:testing"))
 }
 
 tasks.test {

instrumentation/failsafe-3.0/library/src/main/java/io/opentelemetry/instrumentation/failsafe/v3_0/FailsafeTelemetry.java

@@ -10,7 +10,6 @@
 import static io.opentelemetry.instrumentation.failsafe.v3_0.CircuitBreakerEventListenerBuilders.buildInstrumentedHalfOpenListener;
 import static io.opentelemetry.instrumentation.failsafe.v3_0.CircuitBreakerEventListenerBuilders.buildInstrumentedOpenListener;
 import static io.opentelemetry.instrumentation.failsafe.v3_0.CircuitBreakerEventListenerBuilders.buildInstrumentedSuccessListener;
-import static java.util.Arrays.asList;
 
 import dev.failsafe.CircuitBreaker;
 import dev.failsafe.CircuitBreakerConfig;
@@ -20,16 +19,14 @@
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.metrics.LongCounter;
-import io.opentelemetry.api.metrics.LongHistogram;
 import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.instrumentation.failsafe.v3_0.internal.RetryPolicyEventListenerBuilders;
 
 /** Entrypoint for instrumenting Failsafe components. */
 public final class FailsafeTelemetry {
   private static final String INSTRUMENTATION_NAME = "io.opentelemetry.failsafe-3.0";
   private static final AttributeKey<String> CIRCUIT_BREAKER_NAME =
       AttributeKey.stringKey("failsafe.circuit_breaker.name");
-  private static final AttributeKey<String> RETRY_POLICY_NAME =
-      AttributeKey.stringKey("failsafe.retry_policy.name");
 
   private final OpenTelemetry openTelemetry;
 
@@ -86,31 +83,13 @@ public <R> CircuitBreaker<R> createCircuitBreaker(
    */
   public <R> RetryPolicy<R> createRetryPolicy(RetryPolicy<R> delegate, String retryPolicyName) {
     RetryPolicyConfig<R> userConfig = delegate.getConfig();
-    Meter meter = openTelemetry.getMeter(INSTRUMENTATION_NAME);
-    LongCounter executionCounter =
-        meter
-            .counterBuilder("failsafe.retry_policy.execution.count")
-            .setDescription(
-                "Count of execution attempts processed by the retry policy, "
-                    + "where one execution represents the total number of attempts.")
-            .setUnit("{execution}")
-            .build();
-    LongHistogram attemptsHistogram =
-        meter
-            .histogramBuilder("failsafe.retry_policy.attempts")
-            .setDescription("Number of attempts for each execution.")
-            .setUnit("{attempt}")
-            .ofLongs()
-            .setExplicitBucketBoundariesAdvice(asList(1L, 2L, 3L, 5L))
-            .build();
-    Attributes attributes = Attributes.of(RETRY_POLICY_NAME, retryPolicyName);
     return RetryPolicy.builder(userConfig)
         .onFailure(
             RetryPolicyEventListenerBuilders.buildInstrumentedFailureListener(
-                userConfig, executionCounter, attemptsHistogram, attributes))
+                openTelemetry, userConfig, retryPolicyName))
         .onSuccess(
             RetryPolicyEventListenerBuilders.buildInstrumentedSuccessListener(
-                userConfig, executionCounter, attemptsHistogram, attributes))
+                openTelemetry, userConfig, retryPolicyName))
         .build();
   }
 }