feat: support instrumentation for jsonrpc4j

docs/supported-libraries.md

@@ -90,6 +90,7 @@ These are the supported libraries and frameworks:
 | [Jedis](https://github.com/xetorthio/jedis)                                                                                                 | 1.4+                               | N/A                                                                                                                                                                                                                                                                                                                                                                                     | [Database Client Spans]                                                                                                                 |
 | [JMS](https://javaee.github.io/javaee-spec/javadocs/javax/jms/package-summary.html)                                                         | 1.1+                               | N/A                                                                                                                                                                                                                                                                                                                                                                                     | [Messaging Spans]                                                                                                                       |
 | [Jodd Http](https://http.jodd.org/)                                                                                                         | 4.2+                               | N/A                                                                                                                                                                                                                                                                                                                                                                                     | [HTTP Client Spans], [HTTP Client Metrics]                                                                                              |
+| [JSON-RPC](https://github.com/briandilley/jsonrpc4j)                                                                                        | 1.3.3+                             | N/A                                                                                                                                                                                                                                                                                                                                                                                     | [RPC Client Spans], [RPC Client Metrics], [RPC Server Spans], [RPC Server Metrics]                                                      |
 | [JSP](https://javaee.github.io/javaee-spec/javadocs/javax/servlet/jsp/package-summary.html)                                                 | 2.3.x only                         | N/A                                                                                                                                                                                                                                                                                                                                                                                     | Controller Spans [3]                                                                                                                    |
 | [Kotlin Coroutines](https://kotlinlang.org/docs/coroutines-overview.html)                                                                   | 1.0+                               | N/A                                                                                                                                                                                                                                                                                                                                                                                     | Context propagation                                                                                                                     |
 | [Ktor](https://github.com/ktorio/ktor)                                                                                                      | 1.0+                               | [opentelemetry-ktor-1.0](../instrumentation/ktor/ktor-1.0/library),<br>[opentelemetry-ktor-2.0](../instrumentation/ktor/ktor-2.0/library),<br>[opentelemetry-ktor-3.0](../instrumentation/ktor/ktor-3.0/library)                                                                                                                                                                        | [HTTP Client Spans], [HTTP Client Metrics], [HTTP Server Spans], [HTTP Server Metrics]                                                  |

instrumentation/jsonrpc4j-1.3/javaagent/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+  id("otel.javaagent-instrumentation")
+}
+
+muzzle {
+  pass {
+    group.set("com.github.briandilley.jsonrpc4j")
+    module.set("jsonrpc4j")
+    versions.set("[1.3.3,)")
+    assertInverse.set(true)
+  }
+}
+
+dependencies {
+  implementation(project(":instrumentation:jsonrpc4j-1.3:library"))
+
+  library("com.github.briandilley.jsonrpc4j:jsonrpc4j:1.3.3")
+
+  testImplementation(project(":instrumentation:jsonrpc4j-1.3:testing"))
+
+  testImplementation("com.fasterxml.jackson.core:jackson-databind:2.13.3")
+
+  testImplementation("org.eclipse.jetty:jetty-server:9.4.49.v20220914")
+
+  testImplementation("org.eclipse.jetty:jetty-servlet:9.4.49.v20220914")
+
+  testImplementation("javax.portlet:portlet-api:2.0")
+}
+
+tasks {
+  test {
+    jvmArgs("-Dotel.javaagent.experimental.thread-propagation-debugger.enabled=false")
+  }
+}

instrumentation/jsonrpc4j-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jsonrpc4j/v1_3/JsonRpcClientInstrumentation.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.implementsInterface;
+import static io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3.JsonRpcSingletons.CLIENT_INSTRUMENTER;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.returns;
+import static net.bytebuddy.matcher.ElementMatchers.takesArgument;
+import static net.bytebuddy.matcher.ElementMatchers.takesArguments;
+
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.instrumentation.jsonrpc4j.v1_3.JsonRpcClientRequest;
+import io.opentelemetry.instrumentation.jsonrpc4j.v1_3.JsonRpcClientResponse;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import java.util.Map;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class JsonRpcClientInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("com.googlecode.jsonrpc4j.IJsonRpcClient");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    // match JsonRpcHttpClient and JsonRpcRestClient
+    return implementsInterface(named("com.googlecode.jsonrpc4j.IJsonRpcClient"));
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        isMethod()
+            .and(named("invoke"))
+            .and(takesArguments(4))
+            .and(takesArgument(0, String.class))
+            .and(takesArgument(1, Object.class))
+            .and(takesArgument(2, named("java.lang.reflect.Type")))
+            .and(takesArgument(3, named("java.util.Map")))
+            .and(returns(Object.class)),
+        this.getClass().getName() + "$InvokeAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class InvokeAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    public static void onEnter(
+        @Advice.Argument(0) String methodName,
+        @Advice.Argument(1) Object argument,
+        @Advice.Argument(3) Map<String, String> extraHeaders,
+        @Advice.Local("otelContext") Context context,
+        @Advice.Local("otelScope") Scope scope) {
+      Context parentContext = Context.current();
+      JsonRpcClientRequest request = new JsonRpcClientRequest(methodName, argument);
+      if (!CLIENT_INSTRUMENTER.shouldStart(parentContext, request)) {
+        return;
+      }
+
+      context = CLIENT_INSTRUMENTER.start(parentContext, request);
+      scope = context.makeCurrent();
+    }
+
+    @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class)
+    public static void onExit(
+        @Advice.Argument(0) String methodName,
+        @Advice.Argument(1) Object argument,
+        @Advice.Argument(3) Map<String, String> extraHeaders,
+        @Advice.Return Object result,
+        @Advice.Thrown Throwable throwable,
+        @Advice.Local("otelContext") Context context,
+        @Advice.Local("otelScope") Scope scope) {
+      if (scope == null) {
+        return;
+      }
+
+      scope.close();
+      CLIENT_INSTRUMENTER.end(
+          context,
+          new JsonRpcClientRequest(methodName, argument),
+          new JsonRpcClientResponse(result),
+          throwable);
+    }
+  }
+}

instrumentation/jsonrpc4j-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jsonrpc4j/v1_3/JsonRpcInstrumentationModule.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3;
+
+import static java.util.Arrays.asList;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import java.util.List;
+
+@AutoService(InstrumentationModule.class)
+public class JsonRpcInstrumentationModule extends InstrumentationModule {
+  public JsonRpcInstrumentationModule() {
+    super("jsonrpc4j", "jsonrpc4j-1.3");
+  }
+
+  @Override
+  public List<TypeInstrumentation> typeInstrumentations() {
+    return asList(
+        new JsonRpcServerInstrumentation(),
+        new JsonRpcClientInstrumentation(),
+        new JsonRpcProxyInstrumentation());
+  }
+}

instrumentation/jsonrpc4j-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jsonrpc4j/v1_3/JsonRpcProxyInstrumentation.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3.JsonRpcSingletons.CLIENT_INSTRUMENTER;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.isPrivate;
+import static net.bytebuddy.matcher.ElementMatchers.isStatic;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+import com.googlecode.jsonrpc4j.IJsonRpcClient;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.instrumentation.jsonrpc4j.v1_3.JsonRpcClientRequest;
+import io.opentelemetry.instrumentation.jsonrpc4j.v1_3.JsonRpcClientResponse;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Map;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class JsonRpcProxyInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("com.googlecode.jsonrpc4j.ProxyUtil");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("com.googlecode.jsonrpc4j.ProxyUtil");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        isMethod().and(isStatic()).and(isPrivate()).and(named("createClientProxy")),
+        this.getClass().getName() + "$CreateClientProxyAdvice");
+  }
+
+  @SuppressWarnings({"unused"})
+  public static class CreateClientProxyAdvice {
+
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static <T> void onExit(
+        @Advice.Argument(0) ClassLoader classLoader,
+        @Advice.Argument(1) Class<T> proxyInterface,
+        @Advice.Argument(2) IJsonRpcClient client,
+        @Advice.Argument(3) Map<String, String> extraHeaders,
+        @Advice.Return(readOnly = false) Object proxy) {
+
+      proxy = instrumentCreateClientProxy(classLoader, proxyInterface, client, extraHeaders, proxy);
+    }
+
+    private static Object proxyObjectMethods(Method method, Object proxyObject, Object[] args) {
+      String name = method.getName();
+      switch (name) {
+        case "toString":
+          return proxyObject.getClass().getName() + "@" + System.identityHashCode(proxyObject);
+        case "hashCode":
+          return System.identityHashCode(proxyObject);
+        case "equals":
+          return proxyObject == args[0];
+        default:
+          throw new IllegalArgumentException(
+              method.getName() + " is not a member of java.lang.Object");
+      }
+    }
+
+    @SuppressWarnings({"unchecked"})
+    public static <T> T instrumentCreateClientProxy(
+        ClassLoader classLoader,
+        Class<T> proxyInterface,
+        IJsonRpcClient client,
+        Map<String, String> extraHeaders,
+        Object proxy) {
+
+      return (T)
+          Proxy.newProxyInstance(
+              classLoader,
+              new Class<?>[] {proxyInterface},
+              new InvocationHandler() {
+                @Override
+                public Object invoke(Object proxy1, Method method, Object[] args) throws Throwable {
+                  // before invoke
+                  Context parentContext = Context.current();
+                  JsonRpcClientRequest request = new JsonRpcClientRequest(method, args);
+                  if (!CLIENT_INSTRUMENTER.shouldStart(parentContext, request)) {
+                    return method.invoke(proxy, args);
+                  }
+
+                  Context context = CLIENT_INSTRUMENTER.start(parentContext, request);
+                  Scope scope = context.makeCurrent();
+                  try {
+                    Object result = method.invoke(proxy, args);
+                    // after invoke
+                    scope.close();
+                    CLIENT_INSTRUMENTER.end(
+                        context,
+                        new JsonRpcClientRequest(method, args),
+                        new JsonRpcClientResponse(result),
+                        null);
+                    return result;
+
+                  } catch (Throwable t) {
+                    // after invoke
+                    scope.close();
+                    CLIENT_INSTRUMENTER.end(context, request, null, t);
+                    throw t;
+                  }
+                }
+              });
+    }
+  }
+}

instrumentation/jsonrpc4j-1.3/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jsonrpc4j/v1_3/JsonRpcServerInstrumentation.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3;
+
+import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed;
+import static io.opentelemetry.javaagent.instrumentation.jsonrpc4j.v1_3.JsonRpcSingletons.SERVER_INVOCATION_LISTENER;
+import static net.bytebuddy.matcher.ElementMatchers.isConstructor;
+import static net.bytebuddy.matcher.ElementMatchers.isMethod;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+
+import com.googlecode.jsonrpc4j.InvocationListener;
+import com.googlecode.jsonrpc4j.JsonRpcBasicServer;
+import com.googlecode.jsonrpc4j.MultipleInvocationListener;
+import io.opentelemetry.instrumentation.api.util.VirtualField;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation;
+import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.implementation.bytecode.assign.Assigner;
+import net.bytebuddy.matcher.ElementMatcher;
+
+public class JsonRpcServerInstrumentation implements TypeInstrumentation {
+
+  @Override
+  public ElementMatcher<ClassLoader> classLoaderOptimization() {
+    return hasClassesNamed("com.googlecode.jsonrpc4j.JsonRpcBasicServer");
+  }
+
+  @Override
+  public ElementMatcher<TypeDescription> typeMatcher() {
+    return named("com.googlecode.jsonrpc4j.JsonRpcBasicServer");
+  }
+
+  @Override
+  public void transform(TypeTransformer transformer) {
+    transformer.applyAdviceToMethod(
+        isConstructor(), this.getClass().getName() + "$ConstructorAdvice");
+
+    transformer.applyAdviceToMethod(
+        isMethod().and(named("setInvocationListener")),
+        this.getClass().getName() + "$SetInvocationListenerAdvice");
+  }
+
+  @SuppressWarnings("unused")
+  public static class ConstructorAdvice {
+
+    @Advice.OnMethodExit(suppress = Throwable.class)
+    public static void setInvocationListener(
+        @Advice.This JsonRpcBasicServer jsonRpcServer,
+        @Advice.FieldValue(value = "invocationListener", readOnly = false)
+            InvocationListener invocationListener) {
+      invocationListener = SERVER_INVOCATION_LISTENER;
+    }
+  }
+
+  @SuppressWarnings("unused")
+  public static class SetInvocationListenerAdvice {
+
+    @Advice.OnMethodEnter(suppress = Throwable.class)
+    public static void setInvocationListener(
+        @Advice.This JsonRpcBasicServer jsonRpcServer,
+        @Advice.Argument(value = 0, readOnly = false, typing = Assigner.Typing.DYNAMIC)
+            InvocationListener invocationListener) {
+      VirtualField<JsonRpcBasicServer, Boolean> instrumented =
+          VirtualField.find(JsonRpcBasicServer.class, Boolean.class);
+      if (!Boolean.TRUE.equals(instrumented.get(jsonRpcServer))) {
+        if (invocationListener == null) {
+          invocationListener = SERVER_INVOCATION_LISTENER;
+        } else if (invocationListener instanceof MultipleInvocationListener) {
+          ((MultipleInvocationListener) invocationListener)
+              .addInvocationListener(SERVER_INVOCATION_LISTENER);
+        } else {
+          invocationListener =
+              new MultipleInvocationListener(invocationListener, SERVER_INVOCATION_LISTENER);
+        }
+
+        instrumented.set(jsonRpcServer, true);
+      }
+    }
+  }
+}