Resilience4j 2.x

dd-java-agent/instrumentation/resilience4j/build.gradle

@@ -0,0 +1 @@
+apply from: "$rootDir/gradle/java.gradle"

dd-java-agent/instrumentation/resilience4j/resilience4j-2/build.gradle

@@ -0,0 +1,41 @@
+ext {
+  minJavaVersionForTests = JavaVersion.VERSION_17 // TODO -PtestJvm=17
+}
+
+apply from: "$rootDir/gradle/java.gradle"
+apply plugin: 'idea'
+
+muzzle {
+  pass {
+    group = 'io.github.resilience4j'
+    module = 'resilience4j-all'
+    versions = '[2.0.0,)'
+    assertInverse = true
+    javaVersion = "17"
+  }
+}
+
+idea {
+  module {
+    jdkName = '17'
+  }
+}
+
+// Set all compile tasks to use JDK17 but let instrumentation code target 1.8 compatibility
+project.tasks.withType(AbstractCompile).configureEach {
+  setJavaVersion(it, 17)
+}
+compileJava.configure {
+  sourceCompatibility = JavaVersion.VERSION_1_8
+  targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+addTestSuiteForDir('latestDepTest', 'test')
+
+dependencies {
+  compileOnly group: 'io.github.resilience4j', name: 'resilience4j-all', version: '2.0.0'
+
+  testImplementation group: 'io.github.resilience4j', name: 'resilience4j-all', version: '2.0.0'
+  latestDepTestImplementation group: 'io.github.resilience4j', name: 'resilience4j-all', version: '2.+'
+}
+

dd-java-agent/instrumentation/resilience4j/resilience4j-2/src/main/java/datadog/trace/instrumentation/resilience4j/CircuitBreakerDecorator.java

@@ -0,0 +1,36 @@
+package datadog.trace.instrumentation.resilience4j;
+
+import datadog.trace.bootstrap.instrumentation.api.AgentSpan;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+
+public final class CircuitBreakerDecorator extends Resilience4jSpanDecorator<CircuitBreaker> {
+  public static final CircuitBreakerDecorator DECORATE = new CircuitBreakerDecorator();
+
+  private CircuitBreakerDecorator() {
+    super();
+  }
+
+  @Override
+  public void decorate(AgentSpan span, CircuitBreaker data) {
+    span.setTag("resilience4j.circuit_breaker.name", data.getName());
+    span.setTag("resilience4j.circuit_breaker.state", data.getState().toString());
+
+    CircuitBreaker.Metrics ms = data.getMetrics();
+    span.setTag("resilience4j.circuit-breaker.metrics.failure_rate", ms.getFailureRate());
+    span.setTag("resilience4j.circuit-breaker.metrics.slow_call_rate", ms.getSlowCallRate());
+    span.setTag("resilience4j.circuit-breaker.metrics.slow_calls", ms.getNumberOfSlowCalls());
+    span.setTag(
+        "resilience4j.circuit-breaker.metrics.slow_successful_calls",
+        ms.getNumberOfSlowSuccessfulCalls());
+    span.setTag(
+        "resilience4j.circuit-breaker.metrics.slow_failed_calls", ms.getNumberOfSlowFailedCalls());
+    span.setTag(
+        "resilience4j.circuit-breaker.metrics.buffered_calls", ms.getNumberOfBufferedCalls());
+    span.setTag("resilience4j.circuit-breaker.metrics.failed_calls", ms.getNumberOfFailedCalls());
+    span.setTag(
+        "resilience4j.circuit-breaker.metrics.not_permitted_calls",
+        ms.getNumberOfNotPermittedCalls());
+    span.setTag(
+        "resilience4j.circuit-breaker.metrics.successful_calls", ms.getNumberOfSuccessfulCalls());
+  }
+}

dd-java-agent/instrumentation/resilience4j/resilience4j-2/src/main/java/datadog/trace/instrumentation/resilience4j/CircuitBreakerInstrumentation.java

@@ -0,0 +1,242 @@
+package datadog.trace.instrumentation.resilience4j;
+
+import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.isStatic;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+
+import com.google.auto.service.AutoService;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+import io.github.resilience4j.core.functions.CheckedConsumer;
+import io.github.resilience4j.core.functions.CheckedFunction;
+import io.github.resilience4j.core.functions.CheckedRunnable;
+import io.github.resilience4j.core.functions.CheckedSupplier;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import net.bytebuddy.asm.Advice;
+
+@AutoService(InstrumenterModule.class)
+public final class CircuitBreakerInstrumentation extends Resilience4jInstrumentation {
+
+  private static final String CIRCUIT_BREAKER_FQCN =
+      "io.github.resilience4j.circuitbreaker.CircuitBreaker";
+
+  private static final String THIS_CLASS = CircuitBreakerInstrumentation.class.getName();
+
+  public CircuitBreakerInstrumentation() {
+    super("resilience4j-circuitbreaker");
+  }
+
+  @Override
+  public String instrumentedType() {
+    return CIRCUIT_BREAKER_FQCN;
+  }
+
+  @Override
+  public void methodAdvice(MethodTransformer transformer) {
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCheckedSupplier"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CHECKED_SUPPLIER_FQCN))),
+        THIS_CLASS + "$CheckedSupplierAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCheckedFunction"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CHECKED_FUNCTION_FQCN))),
+        THIS_CLASS + "$CheckedFunctionAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCheckedConsumer"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CHECKED_CONSUMER_FQCN))),
+        THIS_CLASS + "$CheckedConsumerAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCompletionStage"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(SUPPLIER_FQCN))),
+        THIS_CLASS + "$CompletionStageAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateFuture"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(SUPPLIER_FQCN))),
+        THIS_CLASS + "$FutureAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateConsumer"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CONSUMER_FQCN))),
+        THIS_CLASS + "$ConsumerAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCheckedRunnable"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CHECKED_RUNNABLE_FQCN))),
+        THIS_CLASS + "$CheckedRunnableAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateCallable"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(CALLABLE_FQCN))),
+        THIS_CLASS + "$CallableAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateRunnable"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(RUNNABLE_FQCN))),
+        THIS_CLASS + "$RunnableAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateSupplier"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(SUPPLIER_FQCN))),
+        THIS_CLASS + "$SupplierAdvice");
+    transformer.applyAdvice(
+        isMethod()
+            .and(isStatic())
+            .and(named("decorateFunction"))
+            .and(takesArgument(0, named(CIRCUIT_BREAKER_FQCN)))
+            .and(returns(named(FUNCTION_FQCN))),
+        THIS_CLASS + "$FunctionAdvice");
+  }
+
+  public static class SupplierAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Supplier<?> outbound) {
+      outbound =
+          new WrapperWithContext.SupplierWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CallableAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Callable<?> outbound) {
+      outbound =
+          new WrapperWithContext.CallableWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class RunnableAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Runnable outbound) {
+      outbound =
+          new WrapperWithContext.RunnableWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class FunctionAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Function<?, ?> outbound) {
+      outbound =
+          new WrapperWithContext.FunctionWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CheckedSupplierAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) CheckedSupplier<?> outbound) {
+      outbound =
+          new WrapperWithContext.CheckedSupplierWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CheckedFunctionAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) CheckedFunction<?, ?> outbound) {
+      outbound =
+          new WrapperWithContext.CheckedFunctionWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CheckedConsumerAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) CheckedConsumer<?> outbound) {
+      outbound =
+          new WrapperWithContext.CheckedConsumerWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CheckedRunnableAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) CheckedRunnable outbound) {
+      outbound =
+          new WrapperWithContext.CheckedRunnableWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class ConsumerAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Consumer<?> outbound) {
+      outbound =
+          new WrapperWithContext.ConsumerWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class CompletionStageAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Supplier<CompletionStage<?>> outbound) {
+      outbound =
+          new WrapperWithContext.SupplierOfCompletionStageWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+
+  public static class FutureAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.Argument(value = 0) CircuitBreaker circuitBreaker,
+        @Advice.Return(readOnly = false) Supplier<Future<?>> outbound) {
+      outbound =
+          new WrapperWithContext.SupplierOfFutureWithContext<>(
+              outbound, CircuitBreakerDecorator.DECORATE, circuitBreaker);
+    }
+  }
+}

dd-java-agent/instrumentation/resilience4j/resilience4j-2/src/main/java/datadog/trace/instrumentation/resilience4j/FallbackCallableInstrumentation.java

@@ -0,0 +1,44 @@
+package datadog.trace.instrumentation.resilience4j;
+
+import static datadog.trace.agent.tooling.bytebuddy.matcher.NameMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+
+import com.google.auto.service.AutoService;
+import datadog.trace.agent.tooling.InstrumenterModule;
+import io.github.resilience4j.core.functions.CheckedSupplier;
+import java.util.concurrent.Callable;
+import net.bytebuddy.asm.Advice;
+
+@AutoService(InstrumenterModule.class)
+public class FallbackCallableInstrumentation extends Resilience4jInstrumentation {
+  public FallbackCallableInstrumentation() {
+    super("resilience4j-fallback");
+  }
+
+  @Override
+  public String instrumentedType() {
+    return "io.github.resilience4j.decorators.Decorators$DecorateCallable";
+  }
+
+  @Override
+  public void methodAdvice(MethodTransformer transformer) {
+    transformer.applyAdvice(
+        isMethod().and(named("withFallback")),
+        FallbackCallableInstrumentation.class.getName() + "$CallableAdvice");
+  }
+
+  public static class CallableAdvice {
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void afterExecute(
+        @Advice.FieldValue(value = "callable", readOnly = false) Callable<?> callable) {
+      callable =
+          new WrapperWithContext.CallableWithContext<>(
+              callable, Resilience4jSpanDecorator.DECORATE, null);
+    }
+
+    // 2.0.0+
+    public static void muzzleCheck(CheckedSupplier<?> cs) throws Throwable {
+      cs.get();
+    }
+  }
+}