diff --git a/core/src/main/java/tech/ydb/core/grpc/GrpcTransport.java b/core/src/main/java/tech/ydb/core/grpc/GrpcTransport.java index 96816601f..cb9c5c601 100644 --- a/core/src/main/java/tech/ydb/core/grpc/GrpcTransport.java +++ b/core/src/main/java/tech/ydb/core/grpc/GrpcTransport.java @@ -40,6 +40,14 @@ GrpcReadWriteStream readWriteStreamCall( String getDatabase(); + /** + * Returns the configured discovery endpoint as host:port, or an empty string if unavailable. + * @return configured discovery endpoint + */ + default String getEndpoint() { + return ""; + } + ScheduledExecutorService getScheduler(); default Tracer getTracer() { diff --git a/core/src/main/java/tech/ydb/core/impl/BaseGrpcTransport.java b/core/src/main/java/tech/ydb/core/impl/BaseGrpcTransport.java index e15eb5c5a..b8e624cbb 100644 --- a/core/src/main/java/tech/ydb/core/impl/BaseGrpcTransport.java +++ b/core/src/main/java/tech/ydb/core/impl/BaseGrpcTransport.java @@ -69,6 +69,11 @@ protected BaseGrpcTransport(EndpointRecord serverEndpoint, String buildInfo) { protected abstract AuthCallOptions getAuthCallOptions(); + @Override + public String getEndpoint() { + return serverEndpoint.getHostAndPort(); + } + protected abstract GrpcChannel getChannel(GrpcRequestSettings settings); protected void pessimizeEndpoint(EndpointRecord endpoint, String reason) { diff --git a/topic/src/main/java/tech/ydb/topic/TopicRpc.java b/topic/src/main/java/tech/ydb/topic/TopicRpc.java index f4bc48a37..2bfba6ef2 100644 --- a/topic/src/main/java/tech/ydb/topic/TopicRpc.java +++ b/topic/src/main/java/tech/ydb/topic/TopicRpc.java @@ -95,4 +95,12 @@ default GrpcReadWriteStream readSession(String traceId); ScheduledExecutorService getScheduler(); + + default String getEndpoint() { + return ""; + } + + default String getDatabase() { + return ""; + } } diff --git a/topic/src/main/java/tech/ydb/topic/impl/GrpcTopicRpc.java b/topic/src/main/java/tech/ydb/topic/impl/GrpcTopicRpc.java index 7aa1f518f..88f009b0c 100644 --- a/topic/src/main/java/tech/ydb/topic/impl/GrpcTopicRpc.java +++ b/topic/src/main/java/tech/ydb/topic/impl/GrpcTopicRpc.java @@ -130,4 +130,14 @@ public GrpcReadWriteStream COMMON = attributes("consumer", "consumer", "reader.name", "reader"); + private static final Map COMMON = attributes("endpoint", "reader.example:2135", + "database", "/reader-db", "consumer", "consumer", "reader.name", "reader"); private static final Map TOPIC = attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/topic"); private static final Map OTHER = attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/other-topic"); private final InMemoryMeter meter = new InMemoryMeter(); @Test public void readAndCommitMetrics() throws Exception { ReadStreamMock stream = new ReadStreamMock(true); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)).build()) { + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport).build()) { SyncReader reader = client.createSyncReader(ReaderSettings.newBuilder() .addTopic("/topic").addTopic("/other-topic").setConsumerName("consumer") .setMaxMemoryUsageBytes(100).setDecompressionExecutor(Runnable::run) @@ -94,9 +101,11 @@ public void readAndCommitMetrics() throws Exception { meter.assertCounter(PREFIX + "commit.acknowledged", 1, OTHER); meter.assertLongGauge(PREFIX + "commit_offset.lag.max", 0, COMMON); for (String name : Arrays.asList("compression.duration", "message.processing.duration")) { - meter.assertHistogram(PREFIX + name, "s", 2, attributes("consumer", "consumer", + meter.assertHistogram(PREFIX + name, "s", 2, attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/topic", "codec", "gzip", "outcome", "ok")); - meter.assertHistogram(PREFIX + name, "s", 1, attributes("consumer", "consumer", + meter.assertHistogram(PREFIX + name, "s", 1, attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/other-topic", "codec", "gzip", "outcome", "ok")); } meter.assertUnit(PREFIX + "received.bytes", "By"); @@ -114,9 +123,12 @@ public void readAndCommitMetrics() throws Exception { @Test public void readWithoutConsumerMetrics() throws Exception { ReadStreamMock stream = new ReadStreamMock(true); - Map common = attributes("reader.name", "without-consumer"); - Map topic = attributes("reader.name", "without-consumer", "topic", "/topic"); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)).build()) { + Map common = attributes("endpoint", "reader.example:2135", "database", "/reader-db", + "reader.name", "without-consumer"); + Map topic = attributes("endpoint", "reader.example:2135", "database", "/reader-db", + "reader.name", "without-consumer", "topic", "/topic"); + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport).build()) { SyncReader reader = client.createSyncReader(ReaderSettings.newBuilder().addTopic("/topic") .withoutConsumer().setDecompressionExecutor(Runnable::run) .withMeter(meter, "without-consumer").build()); @@ -135,7 +147,8 @@ public void readWithoutConsumerMetrics() throws Exception { meter.assertLongGauge(PREFIX + "partition_session.count", 1, common); meter.assertLongGauge(PREFIX + "local_buffer.messages", 0, common); for (String name : Arrays.asList("compression.duration", "message.processing.duration")) { - meter.assertHistogram(PREFIX + name, "s", 1, attributes("reader.name", "without-consumer", + meter.assertHistogram(PREFIX + name, "s", 1, attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "reader.name", "without-consumer", "topic", "/topic", "codec", "gzip", "outcome", "ok")); } } finally { @@ -152,11 +165,14 @@ public void sessionErrorsFollowRetriesAndStop() throws Exception { ReadStreamMock second = new ReadStreamMock(true); ReadStreamMock third = new ReadStreamMock(true); RetryConfig retries = status -> (number, elapsed) -> number < 2 ? 0 : -1; - Map retry = attributes("consumer", "consumer", "reader.name", "reader", + Map retry = attributes("endpoint", "reader.example:2135", "database", "/reader-db", + "consumer", "consumer", "reader.name", "reader", "retry_decision", "retry", "status_code", "TRANSPORT_UNAVAILABLE", "error.type", "transport_error"); - Map stop = attributes("consumer", "consumer", "reader.name", "reader", + Map stop = attributes("endpoint", "reader.example:2135", "database", "/reader-db", + "consumer", "consumer", "reader.name", "reader", "retry_decision", "stop", "status_code", "TRANSPORT_UNAVAILABLE", "error.type", "transport_error"); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(first, second, third)).build()) { + try (GrpcTransport transport = mockTransport(first, second, third); + TopicClient client = TopicClient.newClient(transport).build()) { SyncReader reader = client.createSyncReader(ReaderSettings.newBuilder().addTopic("/topic") .setConsumerName("consumer").setRetryConfig(retries).withMeter(meter, "reader").build()); try { @@ -185,7 +201,8 @@ public void decompressionFailureMetrics() throws Exception { Codec codec = Mockito.mock(Codec.class, Mockito.CALLS_REAL_METHODS); Mockito.when(codec.getId()).thenReturn(Codec.GZIP); Mockito.doThrow(problem).when(codec).decode(Mockito.any(InputStream.class)); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)).registerCodec(codec).build()) { + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport).registerCodec(codec).build()) { SyncReader reader = client.createSyncReader(ReaderSettings.newBuilder().addTopic("/topic") .setConsumerName("consumer").setDecompressionExecutor(Runnable::run) .withMeter(meter, "reader").build()); @@ -204,10 +221,12 @@ public void decompressionFailureMetrics() throws Exception { meter.assertCounter(PREFIX + "delivered.messages", 2, TOPIC); meter.assertNoCounterSamples(PREFIX + "commit.acknowledged"); for (String name : Arrays.asList("compression.duration", "message.processing.duration")) { - meter.assertHistogram(PREFIX + name, "s", 2, attributes("consumer", "consumer", + meter.assertHistogram(PREFIX + name, "s", 2, attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/topic", "codec", "gzip", "outcome", "error", "error.type", "java.io.IOException")); - meter.assertHistogram(PREFIX + name, "s", 0, attributes("consumer", "consumer", + meter.assertHistogram(PREFIX + name, "s", 0, attributes( + "endpoint", "reader.example:2135", "database", "/reader-db", "consumer", "consumer", "reader.name", "reader", "topic", "/topic", "codec", "gzip", "outcome", "ok")); } } finally { @@ -218,10 +237,58 @@ public void decompressionFailureMetrics() throws Exception { meter.assertNoGauges(); } - private static TopicRpc mockRpc(ReadStreamMock first, ReadStreamMock... rest) { - TopicRpc rpc = Mockito.mock(TopicRpc.class); - Mockito.when(rpc.getScheduler()).thenReturn(Mockito.mock(ScheduledExecutorService.class)); - Mockito.when(rpc.readSession(Mockito.anyString())).thenReturn(first, rest); - return rpc; + @Test + public void reusedSettingsKeepConnectionAttributes() throws Exception { + ReadStreamMock first = new ReadStreamMock(true); + ReadStreamMock second = new ReadStreamMock(true); + ReaderSettings settings = ReaderSettings.newBuilder().addTopic("/topic").setConsumerName("consumer") + .setDecompressionExecutor(Runnable::run).withMeter(meter, "reader").build(); + CompletableFuture delivered = new CompletableFuture<>(); + Map otherCommon = attributes("endpoint", "other-reader.example:2137", + "database", "/other-reader-db", "consumer", "consumer", "reader.name", "reader"); + try (GrpcTransport firstTransport = mockTransport(first); + GrpcTransport secondTransport = Mockito.spy(new SingleChannelTransport( + GrpcTransport.forHost("other-reader.example", 2137, "/other-reader-db") + .withScheduler(Mockito.mock(ScheduledExecutorService.class)))); + TopicClient firstClient = TopicClient.newClient(firstTransport).build(); + TopicClient secondClient = TopicClient.newClient(secondTransport).build()) { + Mockito.doReturn(second).when(secondTransport) + .readWriteStreamCall(Mockito.eq(TopicServiceGrpc.getStreamReadMethod()), Mockito.any()); + SyncReader sync = firstClient.createSyncReader(settings); + AsyncReader async = secondClient.createAsyncReader(settings, ReadEventHandlersSettings.newBuilder() + .setExecutor(Runnable::run).setEventHandler(event -> delivered.complete(event.getMessages().get(0))) + .build()); + try { + sync.init(); + async.init(); + first.responseInit("first"); + second.responseInit("second"); + first.responseStartPartition("/topic", 42, 0); + second.responseStartPartition("/topic", 43, 0); + first.responseData(12).partition(1, 0).batch(Codec.GZIP, MSG1).and().send(); + second.responseData(8).partition(1, 0).batch(Codec.GZIP, MSG2).and().send(); + Assert.assertArrayEquals(MSG1, sync.receive(0, TimeUnit.SECONDS).getData()); + Assert.assertArrayEquals(MSG2, delivered.get(1, TimeUnit.SECONDS).getData()); + meter.assertCounter(PREFIX + "received.bytes", 12, COMMON); + meter.assertCounter(PREFIX + "received.bytes", 8, otherCommon); + meter.assertLongGauge(PREFIX + "partition_session.count", 1, COMMON); + meter.assertLongGauge(PREFIX + "partition_session.count", 1, otherCommon); + meter.assertCounterSeries(PREFIX + "received.bytes", 2); + Assert.assertSame(meter, settings.getMeter()); + } finally { + sync.shutdown(); + async.shutdown().get(1, TimeUnit.SECONDS); + } + } + meter.assertNoGauges(); + } + + private static GrpcTransport mockTransport(ReadStreamMock first, ReadStreamMock... rest) { + GrpcTransport transport = Mockito.spy(new SingleChannelTransport( + GrpcTransport.forEndpoint("grpcs://reader.example:2135", "/reader-db") + .withScheduler(Mockito.mock(ScheduledExecutorService.class)))); + Mockito.doReturn(first, (Object[]) rest).when(transport) + .readWriteStreamCall(Mockito.eq(TopicServiceGrpc.getStreamReadMethod()), Mockito.any()); + return transport; } } diff --git a/topic/src/test/java/tech/ydb/topic/write/impl/WriterMetricsTest.java b/topic/src/test/java/tech/ydb/topic/write/impl/WriterMetricsTest.java index db38dfebc..054402fb5 100644 --- a/topic/src/test/java/tech/ydb/topic/write/impl/WriterMetricsTest.java +++ b/topic/src/test/java/tech/ydb/topic/write/impl/WriterMetricsTest.java @@ -16,10 +16,11 @@ import tech.ydb.common.retry.RetryConfig; import tech.ydb.core.Status; import tech.ydb.core.StatusCode; +import tech.ydb.core.grpc.GrpcTransport; +import tech.ydb.core.impl.SingleChannelTransport; +import tech.ydb.proto.topic.v1.TopicServiceGrpc; import tech.ydb.topic.TopicClient; -import tech.ydb.topic.TopicRpc; import tech.ydb.topic.description.Codec; -import tech.ydb.topic.impl.TopicClientImpl; import tech.ydb.topic.settings.WriterSettings; import tech.ydb.topic.utils.InMemoryMeter; import tech.ydb.topic.write.AsyncWriter; @@ -31,13 +32,15 @@ public class WriterMetricsTest { private static final String PREFIX = "ydb.topic.writer."; - private static final Map COMMON = attributes("topic", "/test/topic", "writer.name", "writer"); + private static final Map COMMON = attributes("endpoint", "writer.example:2136", + "database", "/writer-db", "topic", "/test/topic", "writer.name", "writer"); private final InMemoryMeter meter = new InMemoryMeter(); @Test public void sendAndAcknowledgeMetrics() throws Exception { WriteStreamMock stream = new WriteStreamMock(); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)) + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport) .setCompressionExecutor(Runnable::run).build()) { AsyncWriter writer = client.createAsyncWriter(WriterSettings.newBuilder().setTopicPath("/test/topic") .setCodec(Codec.RAW).setMaxSendBufferMemorySize(100).withMeter(meter, "writer").build()); @@ -62,6 +65,7 @@ public void sendAndAcknowledgeMetrics() throws Exception { meter.assertDoubleGauge(PREFIX + "sending.oldest_age", 0, COMMON); meter.assertHistogram(PREFIX + "message.ack.duration", "s", 2, COMMON); meter.assertHistogram(PREFIX + "message.processing.duration", "s", 2, attributes( + "endpoint", "writer.example:2136", "database", "/writer-db", "topic", "/test/topic", "writer.name", "writer", "codec", "raw", "outcome", "ok")); meter.assertNoHistogramSamples(PREFIX + "buffer.wait.duration"); meter.assertNoHistogramSamples(PREFIX + "compression.duration"); @@ -84,7 +88,8 @@ public void compressedSyncSendMetrics() throws Exception { stream.close(Status.SUCCESS); return null; }).when(stream).close(); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)) + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport) .setCompressionExecutor(Runnable::run).build()) { SyncWriter writer = client.createSyncWriter(WriterSettings.newBuilder().setTopicPath("/test/topic") .setCodec(Codec.GZIP).setMaxSendBufferMemorySize(100).withMeter(meter, "writer").build()); @@ -103,6 +108,7 @@ public void compressedSyncSendMetrics() throws Exception { meter.assertLongGauge(PREFIX + "buffer.used.bytes", 0, COMMON); for (String name : Arrays.asList("compression.duration", "message.processing.duration")) { meter.assertHistogram(PREFIX + name, "s", 2, attributes( + "endpoint", "writer.example:2136", "database", "/writer-db", "topic", "/test/topic", "writer.name", "writer", "codec", "gzip", "outcome", "ok")); } for (String name : Arrays.asList("buffer.wait.duration", "message.ack.duration")) { @@ -122,11 +128,14 @@ public void sessionErrorsFollowRetriesAndStop() throws Exception { WriteStreamMock second = new WriteStreamMock(); WriteStreamMock third = new WriteStreamMock(); RetryConfig retries = status -> (number, elapsed) -> number < 2 ? 0 : -1; - Map retry = attributes("topic", "/test/topic", "writer.name", "writer", + Map retry = attributes("endpoint", "writer.example:2136", "database", "/writer-db", + "topic", "/test/topic", "writer.name", "writer", "retry_decision", "retry", "status_code", "TRANSPORT_UNAVAILABLE", "error.type", "transport_error"); - Map stop = attributes("topic", "/test/topic", "writer.name", "writer", + Map stop = attributes("endpoint", "writer.example:2136", "database", "/writer-db", + "topic", "/test/topic", "writer.name", "writer", "retry_decision", "stop", "status_code", "TRANSPORT_UNAVAILABLE", "error.type", "transport_error"); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(first, second, third)) + try (GrpcTransport transport = mockTransport(first, second, third); + TopicClient client = TopicClient.newClient(transport) .setCompressionExecutor(Runnable::run).build()) { AsyncWriter writer = client.createAsyncWriter(WriterSettings.newBuilder().setTopicPath("/test/topic") .setRetryConfig(retries).withMeter(meter, "writer").build()); @@ -159,7 +168,8 @@ public void compressionFailureMetrics() throws Exception { Codec codec = Mockito.mock(Codec.class, Mockito.CALLS_REAL_METHODS); Mockito.when(codec.getId()).thenReturn(Codec.GZIP); Mockito.doThrow(problem).when(codec).encode(Mockito.any(OutputStream.class)); - try (TopicClient client = TopicClientImpl.newClient(mockRpc(stream)).registerCodec(codec) + try (GrpcTransport transport = mockTransport(stream); + TopicClient client = TopicClient.newClient(transport).registerCodec(codec) .setCompressionExecutor(Runnable::run).build()) { AsyncWriter writer = client.createAsyncWriter(WriterSettings.newBuilder().setTopicPath("/test/topic") .setCodec(Codec.GZIP).withMeter(meter, "writer").build()); @@ -178,10 +188,12 @@ public void compressionFailureMetrics() throws Exception { meter.assertNoHistogramSamples(PREFIX + "message.ack.duration"); meter.assertLongGauge(PREFIX + "buffer.used.bytes", 0, COMMON); for (String name : Arrays.asList("compression.duration", "message.processing.duration")) { - meter.assertHistogram(PREFIX + name, "s", 2, attributes("topic", "/test/topic", + meter.assertHistogram(PREFIX + name, "s", 2, attributes( + "endpoint", "writer.example:2136", "database", "/writer-db", "topic", "/test/topic", "writer.name", "writer", "codec", "gzip", "outcome", "error", "error.type", "java.io.IOException")); - meter.assertHistogram(PREFIX + name, "s", 0, attributes("topic", "/test/topic", + meter.assertHistogram(PREFIX + name, "s", 0, attributes( + "endpoint", "writer.example:2136", "database", "/writer-db", "topic", "/test/topic", "writer.name", "writer", "codec", "gzip", "outcome", "ok")); } } finally { @@ -194,10 +206,61 @@ public void compressionFailureMetrics() throws Exception { meter.assertNoGauges(); } - private static TopicRpc mockRpc(WriteStreamMock first, WriteStreamMock... rest) { - TopicRpc rpc = Mockito.mock(TopicRpc.class); - Mockito.when(rpc.getScheduler()).thenReturn(Mockito.mock(ScheduledExecutorService.class)); - Mockito.when(rpc.writeSession(Mockito.anyString())).thenReturn(first, rest); - return rpc; + @Test + public void reusedSettingsKeepConnectionAttributes() throws Exception { + WriteStreamMock first = new WriteStreamMock(); + WriteStreamMock second = new WriteStreamMock(); + WriterSettings settings = WriterSettings.newBuilder().setTopicPath("/test/topic").setCodec(Codec.RAW) + .withMeter(meter, "writer").build(); + Map otherCommon = attributes("endpoint", "other-writer.example:2137", + "database", "/other-writer-db", "topic", "/test/topic", "writer.name", "writer"); + try (GrpcTransport firstTransport = mockTransport(first); + GrpcTransport secondTransport = Mockito.spy(new SingleChannelTransport( + GrpcTransport.forHost("other-writer.example", 2137, "/other-writer-db") + .withScheduler(Mockito.mock(ScheduledExecutorService.class)))); + TopicClient firstClient = TopicClient.newClient(firstTransport) + .setCompressionExecutor(Runnable::run).build(); + TopicClient secondClient = TopicClient.newClient(secondTransport) + .setCompressionExecutor(Runnable::run).build()) { + Mockito.doReturn(second).when(secondTransport) + .readWriteStreamCall(Mockito.eq(TopicServiceGrpc.getStreamWriteMethod()), Mockito.any()); + AsyncWriter firstWriter = firstClient.createAsyncWriter(settings); + AsyncWriter secondWriter = secondClient.createAsyncWriter(settings); + try { + firstWriter.init(); + secondWriter.init(); + first.sendInitResponse(0); + second.sendInitResponse(0); + CompletableFuture firstAck = firstWriter.send(Message.of(new byte[]{1, 2})); + CompletableFuture secondAck = secondWriter.send(Message.of(new byte[]{3, 4, 5})); + meter.assertCounter(PREFIX + "sending.bytes", 2, COMMON); + meter.assertCounter(PREFIX + "sending.bytes", 3, otherCommon); + meter.assertLongGauge(PREFIX + "buffer.used.bytes", 2, COMMON); + meter.assertLongGauge(PREFIX + "buffer.used.bytes", 3, otherCommon); + meter.assertCounterSeries(PREFIX + "sending.bytes", 2); + first.sendAckResponse(1, 10); + second.sendAckResponse(1, 20); + firstAck.get(1, TimeUnit.SECONDS); + secondAck.get(1, TimeUnit.SECONDS); + Assert.assertSame(meter, settings.getMeter()); + } finally { + CompletableFuture firstClosed = firstWriter.shutdown(); + CompletableFuture secondClosed = secondWriter.shutdown(); + first.close(Status.SUCCESS); + second.close(Status.SUCCESS); + firstClosed.get(1, TimeUnit.SECONDS); + secondClosed.get(1, TimeUnit.SECONDS); + } + } + meter.assertNoGauges(); + } + + private static GrpcTransport mockTransport(WriteStreamMock first, WriteStreamMock... rest) { + GrpcTransport transport = Mockito.spy(new SingleChannelTransport( + GrpcTransport.forEndpoint("grpc://writer.example:2136", "/writer-db") + .withScheduler(Mockito.mock(ScheduledExecutorService.class)))); + Mockito.doReturn(first, (Object[]) rest).when(transport) + .readWriteStreamCall(Mockito.eq(TopicServiceGrpc.getStreamWriteMethod()), Mockito.any()); + return transport; } }