otel: jsonrpc: implement instrumentation

- fix lifecycle of request
- add tracing

Author: jknack

modules/jooby-jsonrpc/pom.xml

@@ -19,5 +19,11 @@
       <version>${jooby.version}</version>
     </dependency>
 
+    <dependency>
+      <groupId>io.opentelemetry</groupId>
+      <artifactId>opentelemetry-api</artifactId>
+      <version>${opentelemetry.version}</version>
+      <optional>true</optional>
+    </dependency>
   </dependencies>
 </project>

modules/jooby-jsonrpc/src/main/java/io/jooby/internal/jsonrpc/DefaultJsonRpcInvoker.java

@@ -0,0 +1,52 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.jsonrpc;
+
+import java.util.Map;
+import java.util.Optional;
+
+import io.jooby.Reified;
+import io.jooby.Router;
+import io.jooby.jsonrpc.JsonRpcErrorCode;
+import io.jooby.jsonrpc.JsonRpcResponse;
+
+public class JsonRpcExceptionTranslator {
+  private final Router router;
+
+  public JsonRpcExceptionTranslator(Router router) {
+    this.router = router;
+  }
+
+  public JsonRpcErrorCode toErrorCode(Throwable cause) {
+    // Attempt to look up any user-defined exception mappings from the registry
+    Map<Class<?>, JsonRpcErrorCode> customMapping =
+        router.require(Reified.map(Class.class, JsonRpcErrorCode.class));
+    return errorCode(customMapping, cause)
+        .orElseGet(() -> JsonRpcErrorCode.of(router.errorCode(cause)));
+  }
+
+  public JsonRpcResponse.ErrorDetail toErrorDetail(Throwable cause) {
+    return new JsonRpcResponse.ErrorDetail(toErrorCode(cause), cause);
+  }
+
+  /**
+   * Evaluates the given exception against the registered custom exception mappings.
+   *
+   * @param mappings A map of Exception classes to specific tRPC error codes.
+   * @param cause The exception to evaluate.
+   * @return An {@code Optional} containing the matched {@code TrpcErrorCode}, or empty if no match
+   *     is found.
+   */
+  private Optional<JsonRpcErrorCode> errorCode(
+      Map<Class<?>, JsonRpcErrorCode> mappings, Throwable cause) {
+    for (var mapping : mappings.entrySet()) {
+      if (mapping.getKey().isInstance(cause)) {
+        return Optional.of(mapping.getValue());
+      }
+    }
+    return Optional.empty();
+  }
+}

modules/jooby-jsonrpc/src/main/java/io/jooby/internal/jsonrpc/JsonRpcExceptionTranslator.java

@@ -0,0 +1,48 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.internal.jsonrpc;
+
+import java.util.Map;
+import java.util.Optional;
+
+import io.jooby.Context;
+import io.jooby.SneakyThrows;
+import io.jooby.jsonrpc.JsonRpcErrorCode;
+import io.jooby.jsonrpc.JsonRpcRequest;
+import io.jooby.jsonrpc.JsonRpcResponse;
+import io.jooby.jsonrpc.JsonRpcService;
+
+public class JsonRpcExecutor implements SneakyThrows.Supplier<Optional<JsonRpcResponse>> {
+  private final Map<String, JsonRpcService> services;
+  private final Context ctx;
+  private final JsonRpcRequest request;
+
+  public JsonRpcExecutor(
+      Map<String, JsonRpcService> services, Context ctx, JsonRpcRequest request) {
+    this.services = services;
+    this.ctx = ctx;
+    this.request = request;
+  }
+
+  @Override
+  public Optional<JsonRpcResponse> tryGet() throws Exception {
+    var fullMethod = request.getMethod();
+    if (fullMethod == null) {
+      return Optional.of(
+          JsonRpcResponse.error(request.getId(), JsonRpcErrorCode.INVALID_REQUEST, null));
+    }
+    var targetService = services.get(fullMethod);
+    if (targetService != null) {
+      var result = targetService.execute(ctx, request);
+      return request.getId() != null
+          ? Optional.of(JsonRpcResponse.success(request.getId(), result))
+          : Optional.empty();
+    }
+    return Optional.of(
+        JsonRpcResponse.error(
+            request.getId(), JsonRpcErrorCode.METHOD_NOT_FOUND, "Method not found: " + fullMethod));
+  }
+}

modules/jooby-jsonrpc/src/main/java/io/jooby/internal/jsonrpc/JsonRpcExecutor.java

@@ -5,6 +5,10 @@
  */
 package io.jooby.jsonrpc;
 
+import java.util.Optional;
+
+import org.jspecify.annotations.Nullable;
+
 /**
  * Exception thrown when a JSON-RPC error occurs during routing, parsing, or execution.
  *
@@ -14,7 +18,7 @@
 public class JsonRpcException extends RuntimeException {
   private final JsonRpcErrorCode code;
 
-  private final Object data;
+  private final @Nullable Object data;
 
   /**
    * Constructs a new JSON-RPC exception.
@@ -68,7 +72,12 @@ public JsonRpcErrorCode getCode() {
    *
    * @return Additional data regarding the error, or null if none was provided.
    */
-  public Object getData() {
+  public @Nullable Object getData() {
     return data;
   }
+
+  public JsonRpcResponse.ErrorDetail toErrorDetail() {
+    return new JsonRpcResponse.ErrorDetail(
+        code, getMessage(), Optional.ofNullable(data).orElse(getCause()));
+  }
 }

modules/jooby-jsonrpc/src/main/java/io/jooby/jsonrpc/JsonRpcException.java

@@ -6,24 +6,20 @@
 package io.jooby.jsonrpc;
 
 import java.util.Objects;
+import java.util.Optional;
 
 import io.jooby.Context;
 import io.jooby.SneakyThrows;
 
 public interface JsonRpcInvoker {
 
-  Object invoke(Context ctx, JsonRpcRequest request, SneakyThrows.Supplier<Object> action)
+  Optional<JsonRpcResponse> invoke(
+      Context ctx, JsonRpcRequest request, SneakyThrows.Supplier<Optional<JsonRpcResponse>> action)
       throws Exception;
 
   default JsonRpcInvoker then(JsonRpcInvoker next) {
     Objects.requireNonNull(next, "next invoker is required");
-    return new JsonRpcInvoker() {
-      @Override
-      public Object invoke(
-          Context ctx, JsonRpcRequest request, SneakyThrows.Supplier<Object> action)
-          throws Exception {
-        return JsonRpcInvoker.this.invoke(ctx, request, () -> next.invoke(ctx, request, action));
-      }
-    };
+    return (ctx, request, action) ->
+        JsonRpcInvoker.this.invoke(ctx, request, () -> next.invoke(ctx, request, action));
   }
 }

modules/jooby-jsonrpc/src/main/java/io/jooby/jsonrpc/JsonRpcInvoker.java

@@ -14,6 +14,9 @@
 import io.jooby.*;
 import io.jooby.exception.MissingValueException;
 import io.jooby.exception.TypeMismatchException;
+import io.jooby.internal.jsonrpc.JsonRpcExceptionTranslator;
+import io.jooby.internal.jsonrpc.JsonRpcExecutor;
+import io.jooby.jsonrpc.instrumentation.OtelJsonRcpTracing;
 
 /**
  * Global Tier 1 Dispatcher for JSON-RPC 2.0 requests.
@@ -52,6 +55,8 @@ public class JsonRpcModule implements Extension {
   private final Map<String, JsonRpcService> services = new HashMap<>();
   private final String path;
   private @Nullable JsonRpcInvoker invoker;
+  private @Nullable OtelJsonRcpTracing head;
+  private JsonRpcExceptionTranslator exceptionTranslator;
 
   public JsonRpcModule(String path, JsonRpcService service, JsonRpcService... services) {
     this.path = path;
@@ -64,10 +69,15 @@ public JsonRpcModule(JsonRpcService service, JsonRpcService... services) {
   }
 
   public JsonRpcModule invoker(JsonRpcInvoker invoker) {
-    if (this.invoker != null) {
-      this.invoker = invoker.then(this.invoker);
+    if (invoker instanceof OtelJsonRcpTracing otel) {
+      // otel goes first:
+      this.head = otel;
     } else {
-      this.invoker = invoker;
+      if (this.invoker != null) {
+        this.invoker = invoker.then(this.invoker);
+      } else {
+        this.invoker = invoker;
+      }
     }
     return this;
   }
@@ -86,8 +96,13 @@ private void registry(JsonRpcService service) {
    */
   @Override
   public void install(Jooby app) throws Exception {
+    if (head != null) {
+      invoker = invoker == null ? head : head.then(invoker);
+    }
     app.post(path, this::handle);
 
+    exceptionTranslator = new JsonRpcExceptionTranslator(app);
+    app.getServices().put(JsonRpcExceptionTranslator.class, exceptionTranslator);
     // Initialize the custom exception mapping registry
     app.getServices()
         .mapOf(Class.class, JsonRpcErrorCode.class)
@@ -106,64 +121,43 @@ public void install(Jooby app) throws Exception {
    * @return A single {@link JsonRpcResponse}, a {@code List} of responses for batches, or an empty
    *     string for notifications.
    */
-  private Object handle(Context ctx) {
+  private Object handle(Context ctx) throws Exception {
     JsonRpcRequest input;
     try {
       input = ctx.body(JsonRpcRequest.class);
-    } catch (Exception e) {
-      // Spec: -32700 Parse error if the JSON is physically malformed.
-      return JsonRpcResponse.error(null, JsonRpcErrorCode.PARSE_ERROR, e);
+    } catch (Exception cause) {
+      var badRequest = new JsonRpcRequest();
+      badRequest.setMethod(JsonRpcRequest.UNKNOWN_METHOD);
+      var parseError = JsonRpcResponse.error(null, JsonRpcErrorCode.PARSE_ERROR, cause);
+      if (head != null) {
+        // Manually handle bad request for otel
+        return head.invoke(ctx, badRequest, () -> Optional.of(parseError));
+      }
+      log(badRequest, cause);
+      return parseError;
     }
 
     List<JsonRpcResponse> responses = new ArrayList<>();
 
     // Look up all generated *Rpc classes registered in the service registry
-
     for (var request : input) {
-      var fullMethod = request.getMethod();
-
-      // Spec: -32600 Invalid Request if the method member is missing or null
-      if (fullMethod == null) {
-        responses.add(
-            JsonRpcResponse.error(request.getId(), JsonRpcErrorCode.INVALID_REQUEST, null));
-        continue;
-      }
-
       try {
-        var targetService = services.get(fullMethod);
-        if (targetService != null) {
-          var result =
-              invoker == null
-                  ? targetService.execute(ctx, request)
-                  : invoker.invoke(ctx, request, () -> targetService.execute(ctx, request));
-          // Spec: If the "id" is missing, it is a notification and no response is returned.
-          if (request.getId() != null) {
-            if (result instanceof JsonRpcResponse jsonRpcResponse) {
-              responses.add(jsonRpcResponse);
-            } else {
-              responses.add(JsonRpcResponse.success(request.getId(), result));
-            }
-          }
-        } else {
-          // Spec: -32601 Method not found
-          responses.add(
-              JsonRpcResponse.error(
-                  request.getId(),
-                  JsonRpcErrorCode.METHOD_NOT_FOUND,
-                  "Method not found: " + fullMethod));
-        }
+        var target = new JsonRpcExecutor(services, ctx, request);
+        var response = invoker == null ? target.get() : invoker.invoke(ctx, request, target);
+        response.ifPresent(responses::add);
       } catch (JsonRpcException cause) {
-        log(ctx, request, cause);
+        log(request, cause);
         // Domain-specific or protocol-level exceptions (e.g., -32602 Invalid Params)
         if (request.getId() != null) {
           responses.add(JsonRpcResponse.error(request.getId(), cause.getCode(), cause.getCause()));
         }
       } catch (Exception cause) {
-        log(ctx, request, cause);
+        log(request, cause);
         // Spec: -32603 Internal error for unhandled application exceptions
         if (request.getId() != null) {
           responses.add(
-              JsonRpcResponse.error(request.getId(), computeErrorCode(ctx, cause), cause));
+              JsonRpcResponse.error(
+                  request.getId(), exceptionTranslator.toErrorCode(cause), cause));
         }
       }
     }
@@ -178,14 +172,14 @@ private Object handle(Context ctx) {
     return input.isBatch() ? responses : responses.getFirst();
   }
 
-  private void log(Context ctx, JsonRpcRequest request, Throwable cause) {
+  private void log(JsonRpcRequest request, Throwable cause) {
     JsonRpcErrorCode code;
     boolean hasCause = true;
     if (cause instanceof JsonRpcException rpcException) {
       code = rpcException.getCode();
       hasCause = false;
     } else {
-      code = computeErrorCode(ctx, cause);
+      code = exceptionTranslator.toErrorCode(cause);
     }
     var type = code == JsonRpcErrorCode.INTERNAL_ERROR ? "server" : "client";
     var message = "JSON-RPC {} error [{} {}] on method '{}' (id: {})";
@@ -230,33 +224,4 @@ private void log(Context ctx, JsonRpcRequest request, Throwable cause) {
       }
     }
   }
-
-  private JsonRpcErrorCode computeErrorCode(Context ctx, Throwable cause) {
-    JsonRpcErrorCode code;
-    // Attempt to look up any user-defined exception mappings from the registry
-    Map<Class<?>, JsonRpcErrorCode> customMapping =
-        ctx.require(Reified.map(Class.class, JsonRpcErrorCode.class));
-    code =
-        errorCode(customMapping, cause)
-            .orElseGet(() -> JsonRpcErrorCode.of(ctx.getRouter().errorCode(cause)));
-    return code;
-  }
-
-  /**
-   * Evaluates the given exception against the registered custom exception mappings.
-   *
-   * @param mappings A map of Exception classes to specific tRPC error codes.
-   * @param x The exception to evaluate.
-   * @return An {@code Optional} containing the matched {@code TrpcErrorCode}, or empty if no match
-   *     is found.
-   */
-  private Optional<JsonRpcErrorCode> errorCode(
-      Map<Class<?>, JsonRpcErrorCode> mappings, Throwable x) {
-    for (var mapping : mappings.entrySet()) {
-      if (mapping.getKey().isInstance(x)) {
-        return Optional.of(mapping.getValue());
-      }
-    }
-    return Optional.empty();
-  }
 }

modules/jooby-jsonrpc/src/main/java/io/jooby/jsonrpc/JsonRpcModule.java

@@ -33,6 +33,7 @@
  * generic structure (e.g., a List or a Map) and populating the batch state.
  */
 public class JsonRpcRequest implements Iterable<JsonRpcRequest> {
+  public static final String UNKNOWN_METHOD = "unknown_method";
 
   /** A String specifying the version of the JSON-RPC protocol. MUST be exactly "2.0". */
   private String jsonrpc = "2.0";