gRPC: allow to customize server and channel

- fix  #3912

Author: jknack

docs/asciidoc/modules/gRPC.adoc

@@ -44,6 +44,52 @@ import io.jooby.kt.Kooby
 <1> Enable HTTP/2 on your server.
 <2> Install the module and explicitly register your services.
 
+=== Configuration
+
+You can customize the underlying `InProcessServerBuilder` and `InProcessChannelBuilder` used by the module to apply advanced gRPC configurations. This is particularly useful for registering global interceptors (like OpenTelemetry traces), adjusting payload limits, or tweaking executor settings.
+
+Use the `withServer` and `withChannel` callbacks to hook directly into the builders before the server starts:
+
+[source, java, role="primary"]
+.Java
+----
+import io.jooby.Jooby;
+import io.jooby.grpc.GrpcModule;
+
+{
+  install(new GrpcModule(new GreeterService())
+      .withServer(server -> {                 // <1>
+        server.maxInboundMessageSize(1024 * 1024 * 20); // 20MB limit
+      })
+      .withChannel(channel -> {               // <2>
+        channel.intercept(new MyCustomClientInterceptor());
+      })
+  );
+}
+----
+
+[source, kotlin, role="secondary"]
+.Kotlin
+----
+import io.jooby.grpc.GrpcModule
+import io.jooby.kt.Kooby
+
+{
+  install(GrpcModule(GreeterService())
+      .withServer { server ->                 // <1>
+        server.maxInboundMessageSize(1024 * 1024 * 20) // 20MB limit
+      }
+      .withChannel { channel ->               // <2>
+        channel.intercept(MyCustomClientInterceptor())
+      }
+  )
+}
+----
+<1> Customize the internal gRPC server (e.g., adjust max message sizes, add server-side interceptors).
+<2> Customize the internal loopback channel (e.g., add client-side interceptors for context propagation).
+
+NOTE: **Size Limits:** By default, Jooby automatically sets the gRPC server's `maxInboundMessageSize` and `maxInboundMetadataSize` to match your web server's `server.maxRequestSize` property (which defaults to `10mb`). If you manually increase these limits on the gRPC server builder, you **must** also increase `server.maxRequestSize`. If an incoming gRPC payload or metadata exceeds the configured web server limit, the request will be rejected before it ever reaches the gRPC layer.
+
 === Dependency Injection
 
 If your gRPC services require external dependencies (like database repositories), you can register the service classes instead of pre-instantiated objects. The module will automatically provision them using your active Dependency Injection framework (e.g., Guice, Spring).

modules/jooby-grpc/src/main/java/io/jooby/grpc/GrpcModule.java

@@ -73,6 +73,8 @@
 public class GrpcModule implements Extension {
   private final List<BindableService> services = new ArrayList<>();
   private final List<Class<? extends BindableService>> serviceClasses = new ArrayList<>();
+  private SneakyThrows.Consumer<InProcessServerBuilder> serverCustomizer;
+  private SneakyThrows.Consumer<InProcessChannelBuilder> channelCustomizer;
 
   static {
     // Optionally remove existing handlers attached to the j.u.l root logger
@@ -111,6 +113,30 @@ public final GrpcModule bind(Class<? extends BindableService>... serviceClasses)
     return this;
   }
 
+  /**
+   * Customizes the in-process gRPC server using the provided server customizer. This method accepts
+   * a consumer that applies custom settings to an {@code InProcessServerBuilder} instance.
+   *
+   * @param serverCustomizer a consumer to customize the {@code InProcessServerBuilder}.
+   * @return this {@code GrpcModule} instance for method chaining.
+   */
+  public GrpcModule withServer(SneakyThrows.Consumer<InProcessServerBuilder> serverCustomizer) {
+    this.serverCustomizer = serverCustomizer;
+    return this;
+  }
+
+  /**
+   * Configures the gRPC channel using a consumer that applies custom settings to an {@code
+   * InProcessChannelBuilder} instance.
+   *
+   * @param channelConsumer a consumer to customize the {@code InProcessChannelBuilder}.
+   * @return this {@code GrpcModule} instance for method chaining.
+   */
+  public GrpcModule withChannel(SneakyThrows.Consumer<InProcessChannelBuilder> channelConsumer) {
+    this.channelCustomizer = channelConsumer;
+    return this;
+  }
+
   /**
    * Installs the gRPC extension into the Jooby application. *
    *
@@ -142,12 +168,22 @@ public void install(Jooby app) throws Exception {
             var service = app.require(serviceClass);
             bindService(app, builder, registry, service);
           }
+          // Sync both
+          builder.maxInboundMessageSize(app.getServerOptions().getMaxRequestSize());
+          builder.maxInboundMetadataSize(app.getServerOptions().getMaxRequestSize());
+          if (serverCustomizer != null) {
+            serverCustomizer.accept(builder);
+          }
           var grpcServer = builder.build().start();
 
           // KEEP .directExecutor() here!
           // This ensures that when the background gRPC worker finishes, it instantly pushes
           // the response back to Undertow/Netty without wasting time on another thread hop.
-          var channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+          var channelBuilder = InProcessChannelBuilder.forName(serverName).directExecutor();
+          if (channelCustomizer != null) {
+            channelCustomizer.accept(channelBuilder);
+          }
+          var channel = channelBuilder.build();
           processor.setChannel(channel);
 
           app.onStop(channel::shutdownNow);