Added grpc calls metrics

Author: alex268

jdbc/ydb-token-app/src/main/java/tech/ydb/apps/Application.java

@@ -57,6 +57,8 @@ public static void main(String[] args) {
     private volatile boolean isStopped = false;
 
     public Application(Config config, SchemeService schemeService, TokenService tokenService, MeterRegistry registry) {
+        GrpcMetrics.init(registry);
+
         this.config = config;
         this.schemeService = schemeService;
         this.tokenService = tokenService;

jdbc/ydb-token-app/src/main/java/tech/ydb/apps/GrpcMetrics.java

@@ -0,0 +1,133 @@
+package tech.ydb.apps;
+
+import java.util.function.Consumer;
+
+import javax.annotation.Nullable;
+
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.MeterRegistry;
+
+/**
+ *
+ * @author Aleksandr Gorshenin
+ */
+public class GrpcMetrics implements Consumer<ManagedChannelBuilder<?>>, ClientInterceptor {
+    private static final Counter.Builder REQUEST = Counter.builder("grpc.request");
+    private static final Counter.Builder RESPONSE = Counter.builder("grpc.response");
+
+    private static MeterRegistry REGISTRY = null;
+
+    public static void init(MeterRegistry registry) {
+        REGISTRY = registry;
+    }
+
+    @Override
+    public void accept(ManagedChannelBuilder<?> t) {
+        t.intercept(this);
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        if (REGISTRY != null) {
+            return new ProxyClientCall<>(REGISTRY, next, method, callOptions);
+        }
+        return next.newCall(method, callOptions);
+    }
+
+    private static class ProxyClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+        private final MeterRegistry registry;
+        private final String method;
+        private final String authority;
+        private final ClientCall<ReqT, RespT> delegate;
+
+        private ProxyClientCall(MeterRegistry registry, Channel channel, MethodDescriptor<ReqT, RespT> method,
+                CallOptions callOptions) {
+            this.registry = registry;
+            this.method = method.getBareMethodName();
+            this.authority = channel.authority();
+            this.delegate = channel.newCall(method, callOptions);
+        }
+
+        @Override
+        public void request(int numMessages) {
+            delegate.request(numMessages);
+        }
+
+        @Override
+        public void cancel(@Nullable String message, @Nullable Throwable cause) {
+            delegate.cancel(message, cause);
+        }
+
+        @Override
+        public void halfClose() {
+            delegate.halfClose();
+        }
+
+        @Override
+        public void setMessageCompression(boolean enabled) {
+            delegate.setMessageCompression(enabled);
+        }
+
+        @Override
+        public boolean isReady() {
+            return delegate.isReady();
+        }
+
+        @Override
+        public Attributes getAttributes() {
+            return delegate.getAttributes();
+        }
+
+        @Override
+        public void start(Listener<RespT> listener, Metadata headers) {
+            REQUEST.tag("method", method).tag("authority", authority).register(registry).increment();
+            delegate.start(new ProxyListener(listener), headers);
+        }
+
+        @Override
+        public void sendMessage(ReqT message) {
+            delegate.sendMessage(message);
+        }
+
+        private class ProxyListener extends Listener<RespT> {
+            private final Listener<RespT> delegate;
+
+            public ProxyListener(Listener<RespT> delegate) {
+                this.delegate = delegate;
+            }
+
+
+            @Override
+            public void onHeaders(Metadata headers) {
+                delegate.onHeaders(headers);
+            }
+
+            @Override
+            public void onMessage(RespT message) {
+                delegate.onMessage(message);
+            }
+
+            @Override
+            public void onClose(Status status, Metadata trailers) {
+                RESPONSE.tag("method", method).tag("authority", authority).tag("status", status.getCode().toString())
+                        .register(registry).increment();
+                delegate.onClose(status, trailers);
+            }
+
+            @Override
+            public void onReady() {
+                delegate.onReady();
+            }
+        }
+    }
+}

jdbc/ydb-token-app/src/main/resources/application.properties

@@ -13,6 +13,7 @@ spring.datasource.driver-class-name=tech.ydb.jdbc.YdbDriver
 
 spring.datasource.hikari.maximum-pool-size=200
 spring.datasource.hikari.data-source-properties.enableTxTracer=true
+spring.datasource.hikari.data-source-properties.channelInitializer=tech.ydb.apps.GrpcMetrics
 
 spring.jpa.properties.hibernate.jdbc.batch_size=1000
 spring.jpa.properties.hibernate.order_updates=true
@@ -23,6 +24,7 @@ spring.jpa.properties.hibernate.dialect=tech.ydb.hibernate.dialect.YdbDialect
 management.metrics.enable.all=false
 management.metrics.enable.jdbc=true
 management.metrics.enable.sdk=true
+management.metrics.enable.grpc=true
 management.metrics.distribution.percentiles-histogram.all=true
 management.metrics.export.prometheus.pushgateway.enabled=${app.pushMetrics}
 management.metrics.export.prometheus.pushgateway.push-rate=15s