From df543431ef75bd09ec1b484123a6ecba4c19ff0f Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Mon, 3 Jun 2024 08:16:26 +0000 Subject: [PATCH 01/18] feat(spanner): Add x-goog-spanner-end-to-end-tracing header for requests to SpanFE --- .../google/cloud/spanner/SpannerOptions.java | 21 +++++ .../cloud/spanner/spi/v1/GapicSpannerRpc.java | 5 ++ .../spi/v1/SpannerMetadataProvider.java | 7 ++ .../cloud/spanner/SpannerOptionsTest.java | 18 +++++ .../spanner/spi/v1/GapicSpannerRpcTest.java | 80 +++++++++++++++++++ .../spi/v1/SpannerMetadataProviderTest.java | 11 +++ 6 files changed, 142 insertions(+) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 639943d9970..67577f591c0 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -150,6 +150,7 @@ public class SpannerOptions extends ServiceOptions { private final boolean useVirtualThreads; private final OpenTelemetry openTelemetry; private final boolean enableExtendedTracing; + private final boolean enableEndToEndTracing; enum TracingFramework { OPEN_CENSUS, @@ -655,6 +656,7 @@ protected SpannerOptions(Builder builder) { useVirtualThreads = builder.useVirtualThreads; openTelemetry = builder.openTelemetry; enableExtendedTracing = builder.enableExtendedTracing; + enableEndToEndTracing = builder.enableEndToEndTracing; } /** @@ -779,6 +781,7 @@ public static class Builder private boolean useVirtualThreads = false; private OpenTelemetry openTelemetry; private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); + private boolean enableEndToEndTracing = false; private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -843,6 +846,7 @@ protected Builder() { this.directedReadOptions = options.directedReadOptions; this.useVirtualThreads = options.useVirtualThreads; this.enableExtendedTracing = options.enableExtendedTracing; + this.enableEndToEndTracing = options.enableEndToEndTracing; } @Override @@ -1352,6 +1356,15 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { return this; } + /** + * Sets whether to enable end to end tracing. Enabling this option will create the + * trace spans at the Spanner layer. + */ + public Builder setEnableEndToEndTracing(boolean enableEndToEndTracing) { + this.enableEndToEndTracing = enableEndToEndTracing; + return this; + } + @SuppressWarnings("rawtypes") @Override public SpannerOptions build() { @@ -1606,6 +1619,14 @@ public boolean isEnableExtendedTracing() { return enableExtendedTracing; } + /** + * Returns whether end to end tracing is enabled. If this option is enabled then trace spans + * will be created at the Spanner layer. + */ + public boolean isEndToEndTracingEnabled() { + return enableEndToEndTracing; + } + /** Returns the default query options to use for the specific database. */ public QueryOptions getDefaultQueryOptions(DatabaseId databaseId) { // Use the specific query options for the database if any have been specified. These have diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java index 53e360b801b..f796a7cf185 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java @@ -266,6 +266,7 @@ public class GapicSpannerRpc implements SpannerRpc { private static final ConcurrentMap ADMINISTRATIVE_REQUESTS_RATE_LIMITERS = new ConcurrentHashMap<>(); private final boolean leaderAwareRoutingEnabled; + private final boolean endToEndTracingEnabled; public static GapicSpannerRpc create(SpannerOptions options) { return new GapicSpannerRpc(options); @@ -317,6 +318,7 @@ public GapicSpannerRpc(final SpannerOptions options) { this.callCredentialsProvider = options.getCallCredentialsProvider(); this.compressorName = options.getCompressorName(); this.leaderAwareRoutingEnabled = options.isLeaderAwareRoutingEnabled(); + this.endToEndTracingEnabled = options.isEndToEndTracingEnabled(); if (initializeStubs) { // First check if SpannerOptions provides a TransportChannelProvider. Create one @@ -1956,6 +1958,9 @@ GrpcCallContext newCallContext( if (routeToLeader && leaderAwareRoutingEnabled) { context = context.withExtraHeaders(metadataProvider.newRouteToLeaderHeader()); } + if (endToEndTracingEnabled) { + context = context.withExtraHeaders(metadataProvider.newEndToEndTracingHeader()); + } if (callCredentialsProvider != null) { CallCredentials callCredentials = callCredentialsProvider.getCallCredentials(); if (callCredentials != null) { diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java index 0b8d76d52df..2ebc4925788 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java @@ -37,6 +37,7 @@ class SpannerMetadataProvider { private final Map, String> headers; private final String resourceHeaderKey; private static final String ROUTE_TO_LEADER_HEADER_KEY = "x-goog-spanner-route-to-leader"; + private static final String END_TO_END_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; private static final Pattern[] RESOURCE_TOKEN_PATTERNS = { Pattern.compile("^(?projects/[^/]*/instances/[^/]*/databases/[^/]*)(.*)?"), Pattern.compile("^(?projects/[^/]*/instances/[^/]*)(.*)?") @@ -44,6 +45,8 @@ class SpannerMetadataProvider { private static final Map> ROUTE_TO_LEADER_HEADER_MAP = ImmutableMap.of(ROUTE_TO_LEADER_HEADER_KEY, Collections.singletonList("true")); + private static final Map> END_TO_END_TRACING_HEADER_MAP = + ImmutableMap.of(END_TO_END_TRACING_HEADER_KEY, Collections.singletonList("true")); private SpannerMetadataProvider(Map headers, String resourceHeaderKey) { this.resourceHeaderKey = resourceHeaderKey; @@ -89,6 +92,10 @@ Map> newRouteToLeaderHeader() { return ROUTE_TO_LEADER_HEADER_MAP; } + Map> newEndToEndTracingHeader() { + return END_TO_END_TRACING_HEADER_MAP; + } + private Map, String> constructHeadersAsMetadata( Map headers) { ImmutableMap.Builder, String> headersAsMetadataBuilder = diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index 522cd0147a3..fef8d41eac1 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -731,6 +731,24 @@ public void testLeaderAwareRoutingEnablement() { .isLeaderAwareRoutingEnabled()); } + @Test + public void testEndToEndTracingEnablement() { + // Test that end to end tracing is disabled by default. + assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isEndToEndTracingEnabled()); + assertTrue( + SpannerOptions.newBuilder() + .setProjectId("p") + .setEnableEndToEndTracing(true) + .build() + .isEndToEndTracingEnabled()); + assertFalse( + SpannerOptions.newBuilder() + .setProjectId("p") + .setEnableEndToEndTracing(false) + .build() + .isEndToEndTracingEnabled()); + } + @Test public void testSetDirectedReadOptions() { final DirectedReadOptions directedReadOptions = diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 42a07ed9ea6..9473faa3a9f 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -148,6 +148,7 @@ public class GapicSpannerRpcTest { private static String defaultUserAgent; private static Spanner spanner; private static boolean isRouteToLeader; + private static boolean isEndToEndTracing; @Parameter public Dialect dialect; @@ -199,8 +200,15 @@ public ServerCall.Listener interceptCall( Key.of( "x-goog-spanner-route-to-leader", Metadata.ASCII_STRING_MARSHALLER)); + String endToEndTracingHeader = + headers.get( + Key.of( + "x-goog-spanner-end-to-end-tracing", + Metadata.ASCII_STRING_MARSHALLER)); isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); + isEndToEndTracing = + (endToEndTracingHeader != null && endToEndTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); } @@ -224,6 +232,7 @@ public void reset() throws InterruptedException { server.awaitTermination(); } isRouteToLeader = false; + isEndToEndTracing = false; } @Test @@ -464,6 +473,77 @@ public void testNewCallContextWithRouteToLeaderHeaderAndLarDisabled() { rpc.shutdown(); } + @Test + public void testNewCallContextWithEndToEndTracingHeader() { + SpannerOptions options = + SpannerOptions.newBuilder().setProjectId("some-project").setEnableEndToEndTracing(true).build(); + GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); + GrpcCallContext callContext = + rpc.newCallContext( + optionsMap, + "/some/resource", + ExecuteSqlRequest.getDefaultInstance(), + SpannerGrpc.getExecuteSqlMethod()); + assertNotNull(callContext); + assertEquals( + ImmutableList.of("true"), + callContext.getExtraHeaders().get("x-goog-spanner-end-to-end-tracing")); + assertEquals( + ImmutableList.of("projects/some-project"), + callContext.getExtraHeaders().get(ApiClientHeaderProvider.getDefaultResourceHeaderKey())); + rpc.shutdown(); + } + + @Test + public void testNewCallContextWithoutEndToEndTracingHeader() { + SpannerOptions options = + SpannerOptions.newBuilder().setProjectId("some-project").setEnableEndToEndTracing(false).build(); + GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); + GrpcCallContext callContext = + rpc.newCallContext( + optionsMap, + "/some/resource", + ExecuteSqlRequest.getDefaultInstance(), + SpannerGrpc.getExecuteSqlMethod()); + assertNotNull(callContext); + assertNull(callContext.getExtraHeaders().get("x-goog-spanner-end-to-end-tracing")); + rpc.shutdown(); + } + + @Test + public void testEndToEndTracingHeaderWithEnabledTracing() { + final SpannerOptions options = + createSpannerOptions().toBuilder().setEnableEndToEndTracing(true).build(); + try (Spanner spanner = options.getService()) { + final DatabaseClient databaseClient = + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + TransactionRunner runner = databaseClient.readWriteTransaction(); + runner.run( + transaction -> { + transaction.executeUpdate(UPDATE_FOO_STATEMENT); + return null; + }); + } + assertTrue(isEndToEndTracing); + } + + @Test + public void testEndToEndTracingHeaderWithDisabledTracing() { + final SpannerOptions options = + createSpannerOptions().toBuilder().setEnableEndToEndTracing(false).build(); + try (Spanner spanner = options.getService()) { + final DatabaseClient databaseClient = + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + TransactionRunner runner = databaseClient.readWriteTransaction(); + runner.run( + transaction -> { + transaction.executeUpdate(UPDATE_FOO_STATEMENT); + return null; + }); + } + assertFalse(isEndToEndTracing); + } + @Test public void testAdminRequestsLimitExceededRetryAlgorithm() { AdminRequestsLimitExceededRetryAlgorithm alg = diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java index cc43e2dc334..c4fdd6200af 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java @@ -94,6 +94,17 @@ public void testNewRouteToLeaderHeader() { assertTrue(Maps.difference(extraHeaders, expectedHeaders).areEqual()); } + @Test + public void testNewEndToEndTracingHeader() { + SpannerMetadataProvider metadataProvider = + SpannerMetadataProvider.create(ImmutableMap.of(), "header1"); + Map> extraHeaders = metadataProvider.newEndToEndTracingHeader(); + Map> expectedHeaders = + ImmutableMap.>of( + "x-goog-spanner-end-to-end-tracing", ImmutableList.of("true")); + assertTrue(Maps.difference(extraHeaders, expectedHeaders).areEqual()); + } + private String getResourceHeaderValue( SpannerMetadataProvider headerProvider, String resourceTokenTemplate) { Metadata metadata = headerProvider.newMetadata(resourceTokenTemplate, "projects/p"); From 290f01e7785d4a8f802b0ec13872abaea9a0eadb Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Mon, 17 Jun 2024 11:29:24 +0000 Subject: [PATCH 02/18] Add Grpc Telemetry client interceptor for trace context propagation --- google-cloud-spanner/pom.xml | 5 +++++ .../cloud/spanner/spi/v1/SpannerInterceptorProvider.java | 3 +++ 2 files changed, 8 insertions(+) diff --git a/google-cloud-spanner/pom.xml b/google-cloud-spanner/pom.xml index 220102eec97..cfa80c8b0af 100644 --- a/google-cloud-spanner/pom.xml +++ b/google-cloud-spanner/pom.xml @@ -255,6 +255,11 @@ io.opentelemetry opentelemetry-context + + io.opentelemetry.instrumentation + opentelemetry-grpc-1.6 + 2.1.0-alpha + com.google.auth google-auth-library-oauth2-http diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index 9b1a2fd3c1f..3fa87e738fc 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -23,6 +23,7 @@ import io.grpc.ClientInterceptor; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.instrumentation.grpc.v1_6.GrpcTelemetry; import java.util.ArrayList; import java.util.List; import java.util.logging.Level; @@ -51,6 +52,8 @@ public static SpannerInterceptorProvider createDefault(OpenTelemetry openTelemet defaultInterceptorList.add( new LoggingInterceptor(Logger.getLogger(GapicSpannerRpc.class.getName()), Level.FINER)); defaultInterceptorList.add(new HeaderInterceptor(new SpannerRpcMetrics(openTelemetry))); + defaultInterceptorList.add(GrpcTelemetry.create(openTelemetry).newClientInterceptor()); + System.out.println("setting the client interceptor"); return new SpannerInterceptorProvider(ImmutableList.copyOf(defaultInterceptorList)); } From 3c92b2696a2eb9cff9c4fbc1bd74c5339905606a Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Mon, 17 Jun 2024 11:32:54 +0000 Subject: [PATCH 03/18] Remove print statement --- .../google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java | 1 - 1 file changed, 1 deletion(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index 3fa87e738fc..a185837aeb6 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -53,7 +53,6 @@ public static SpannerInterceptorProvider createDefault(OpenTelemetry openTelemet new LoggingInterceptor(Logger.getLogger(GapicSpannerRpc.class.getName()), Level.FINER)); defaultInterceptorList.add(new HeaderInterceptor(new SpannerRpcMetrics(openTelemetry))); defaultInterceptorList.add(GrpcTelemetry.create(openTelemetry).newClientInterceptor()); - System.out.println("setting the client interceptor"); return new SpannerInterceptorProvider(ImmutableList.copyOf(defaultInterceptorList)); } From 5033b1bee165810a46d0bfe8611133f1dcb6cfac Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 10 Jul 2024 06:03:29 +0000 Subject: [PATCH 04/18] copy grpc telemetry client interceptor code --- google-cloud-spanner/pom.xml | 9 ++- .../spi/v1/SpannerInterceptorProvider.java | 4 +- .../spi/v1/TraceContextInterceptor.java | 74 +++++++++++++++++++ 3 files changed, 82 insertions(+), 5 deletions(-) create mode 100644 google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java diff --git a/google-cloud-spanner/pom.xml b/google-cloud-spanner/pom.xml index cfa80c8b0af..3011a728947 100644 --- a/google-cloud-spanner/pom.xml +++ b/google-cloud-spanner/pom.xml @@ -256,9 +256,12 @@ opentelemetry-context - io.opentelemetry.instrumentation - opentelemetry-grpc-1.6 - 2.1.0-alpha + io.opentelemetry + opentelemetry-sdk-common + + + io.opentelemetry + opentelemetry-sdk-metrics com.google.auth diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index a185837aeb6..f730aeaed23 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -23,7 +23,7 @@ import io.grpc.ClientInterceptor; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.instrumentation.grpc.v1_6.GrpcTelemetry; + import java.util.ArrayList; import java.util.List; import java.util.logging.Level; @@ -52,7 +52,7 @@ public static SpannerInterceptorProvider createDefault(OpenTelemetry openTelemet defaultInterceptorList.add( new LoggingInterceptor(Logger.getLogger(GapicSpannerRpc.class.getName()), Level.FINER)); defaultInterceptorList.add(new HeaderInterceptor(new SpannerRpcMetrics(openTelemetry))); - defaultInterceptorList.add(GrpcTelemetry.create(openTelemetry).newClientInterceptor()); + defaultInterceptorList.add(new TraceContextInterceptor(openTelemetry)); return new SpannerInterceptorProvider(ImmutableList.copyOf(defaultInterceptorList)); } diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java new file mode 100644 index 00000000000..6a21f56dfdc --- /dev/null +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java @@ -0,0 +1,74 @@ +/* + * Copyright 2021 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.google.cloud.spanner.spi.v1; + +import io.grpc.CallOptions; +import io.grpc.Channel; +import io.grpc.ClientCall; +import io.grpc.ClientInterceptor; +import io.grpc.ForwardingClientCall.SimpleForwardingClientCall; +import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener; +import io.grpc.Metadata; +import io.grpc.MethodDescriptor; +import io.grpc.Status; +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.context.propagation.TextMapSetter; + +public class TraceContextInterceptor implements ClientInterceptor { + + private final ContextPropagators propagators; + + TraceContextInterceptor(OpenTelemetry openTelemetry) { + this.propagators = openTelemetry.getPropagators(); + } + + enum MetadataSetter implements TextMapSetter { + INSTANCE; + + @SuppressWarnings("null") + @Override + public void set(Metadata carrier, String key, String value) { + carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value); + } + } + + @Override + public ClientCall interceptCall(MethodDescriptor method, + CallOptions callOptions, Channel next) { + return new SimpleForwardingClientCall(next.newCall(method, callOptions)) { + @Override + public void start(Listener responseListener, Metadata headers) { + Context parentContext = Context.current(); + + propagators.getTextMapPropagator().inject(parentContext, headers, MetadataSetter.INSTANCE); + + super.start(new SimpleForwardingClientCallListener(responseListener) { + @Override + public void onHeaders(Metadata headers) { + super.onHeaders(headers); + } + + @Override + public void onClose(Status status, Metadata trailers) { + super.onClose(status, trailers); + } + }, headers); + } + }; + } +} From 7c39b82956a3ed56eb385fe5408876f604761573 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Thu, 11 Jul 2024 04:23:33 +0000 Subject: [PATCH 05/18] rename spanner option for end to end tracing --- .../google/cloud/spanner/SpannerOptions.java | 31 ++++++++++++------- .../cloud/spanner/spi/v1/GapicSpannerRpc.java | 8 ++--- .../spi/v1/SpannerMetadataProvider.java | 10 +++--- .../cloud/spanner/SpannerOptionsTest.java | 12 +++---- .../spanner/spi/v1/GapicSpannerRpcTest.java | 30 +++++++++--------- .../spi/v1/SpannerMetadataProviderTest.java | 2 +- 6 files changed, 51 insertions(+), 42 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index bb21ff6f944..cc3eea0d9f0 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -158,7 +158,7 @@ public class SpannerOptions extends ServiceOptions { private final OpenTelemetry openTelemetry; private final boolean enableApiTracing; private final boolean enableExtendedTracing; - private final boolean enableEndToEndTracing; + private final boolean enableServerSideTracing; enum TracingFramework { OPEN_CENSUS, @@ -665,7 +665,7 @@ protected SpannerOptions(Builder builder) { openTelemetry = builder.openTelemetry; enableApiTracing = builder.enableApiTracing; enableExtendedTracing = builder.enableExtendedTracing; - enableEndToEndTracing = builder.enableEndToEndTracing; + enableServerSideTracing = builder.enableServerSideTracing; } /** @@ -801,7 +801,7 @@ public static class Builder private OpenTelemetry openTelemetry; private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); - private boolean enableEndToEndTracing = false; + private boolean enableServerSideTracing = false; private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -867,7 +867,7 @@ protected Builder() { this.useVirtualThreads = options.useVirtualThreads; this.enableApiTracing = options.enableApiTracing; this.enableExtendedTracing = options.enableExtendedTracing; - this.enableEndToEndTracing = options.enableEndToEndTracing; + this.enableServerSideTracing = options.enableServerSideTracing; } @Override @@ -1396,11 +1396,20 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Sets whether to enable end to end tracing. Enabling this option will create the - * trace spans at the Spanner layer. + * Enable spanner server side tracing. Enabling this option will create the trace + * spans at the Spanner layer. By default, server side tracing is disabled. */ - public Builder setEnableEndToEndTracing(boolean enableEndToEndTracing) { - this.enableEndToEndTracing = enableEndToEndTracing; + public Builder enableServerSideTracing() { + this.enableServerSideTracing = true; + return this; + } + + /** + * Disable spanner server side tracing. If server side is disabled, trace + * spans won't be created at the Spanner layer. + */ + public Builder disableServerSideTracing() { + this.enableServerSideTracing = false; return this; } @@ -1695,11 +1704,11 @@ public boolean isEnableExtendedTracing() { } /** - * Returns whether end to end tracing is enabled. If this option is enabled then trace spans + * Returns whether Spanner server side tracing is enabled. If this option is enabled then trace spans * will be created at the Spanner layer. */ - public boolean isEndToEndTracingEnabled() { - return enableEndToEndTracing; + public boolean isServerSideTracingEnabled() { + return enableServerSideTracing; } /** Returns the default query options to use for the specific database. */ diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java index 3b6a2f39d9e..74244e88dfa 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java @@ -266,7 +266,7 @@ public class GapicSpannerRpc implements SpannerRpc { private static final ConcurrentMap ADMINISTRATIVE_REQUESTS_RATE_LIMITERS = new ConcurrentHashMap<>(); private final boolean leaderAwareRoutingEnabled; - private final boolean endToEndTracingEnabled; + private final boolean serverSideTracingEnabled; public static GapicSpannerRpc create(SpannerOptions options) { return new GapicSpannerRpc(options); @@ -318,7 +318,7 @@ public GapicSpannerRpc(final SpannerOptions options) { this.callCredentialsProvider = options.getCallCredentialsProvider(); this.compressorName = options.getCompressorName(); this.leaderAwareRoutingEnabled = options.isLeaderAwareRoutingEnabled(); - this.endToEndTracingEnabled = options.isEndToEndTracingEnabled(); + this.serverSideTracingEnabled = options.isServerSideTracingEnabled(); if (initializeStubs) { // First check if SpannerOptions provides a TransportChannelProvider. Create one @@ -1962,8 +1962,8 @@ GrpcCallContext newCallContext( if (routeToLeader && leaderAwareRoutingEnabled) { context = context.withExtraHeaders(metadataProvider.newRouteToLeaderHeader()); } - if (endToEndTracingEnabled) { - context = context.withExtraHeaders(metadataProvider.newEndToEndTracingHeader()); + if (serverSideTracingEnabled) { + context = context.withExtraHeaders(metadataProvider.newServerSideTracingHeader()); } if (callCredentialsProvider != null) { CallCredentials callCredentials = callCredentialsProvider.getCallCredentials(); diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java index 2ebc4925788..611383942ca 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java @@ -37,7 +37,7 @@ class SpannerMetadataProvider { private final Map, String> headers; private final String resourceHeaderKey; private static final String ROUTE_TO_LEADER_HEADER_KEY = "x-goog-spanner-route-to-leader"; - private static final String END_TO_END_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; + private static final String SERVER_SIDE_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; private static final Pattern[] RESOURCE_TOKEN_PATTERNS = { Pattern.compile("^(?projects/[^/]*/instances/[^/]*/databases/[^/]*)(.*)?"), Pattern.compile("^(?projects/[^/]*/instances/[^/]*)(.*)?") @@ -45,8 +45,8 @@ class SpannerMetadataProvider { private static final Map> ROUTE_TO_LEADER_HEADER_MAP = ImmutableMap.of(ROUTE_TO_LEADER_HEADER_KEY, Collections.singletonList("true")); - private static final Map> END_TO_END_TRACING_HEADER_MAP = - ImmutableMap.of(END_TO_END_TRACING_HEADER_KEY, Collections.singletonList("true")); + private static final Map> SERVER_SIDE_TRACING_HEADER_MAP = + ImmutableMap.of(SERVER_SIDE_TRACING_HEADER_KEY, Collections.singletonList("true")); private SpannerMetadataProvider(Map headers, String resourceHeaderKey) { this.resourceHeaderKey = resourceHeaderKey; @@ -92,8 +92,8 @@ Map> newRouteToLeaderHeader() { return ROUTE_TO_LEADER_HEADER_MAP; } - Map> newEndToEndTracingHeader() { - return END_TO_END_TRACING_HEADER_MAP; + Map> newServerSideTracingHeader() { + return SERVER_SIDE_TRACING_HEADER_MAP; } private Map, String> constructHeadersAsMetadata( diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index fef8d41eac1..21381f4a778 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -732,21 +732,21 @@ public void testLeaderAwareRoutingEnablement() { } @Test - public void testEndToEndTracingEnablement() { + public void testServerSideTracingEnablement() { // Test that end to end tracing is disabled by default. - assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isEndToEndTracingEnabled()); + assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isServerSideTracingEnabled()); assertTrue( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableEndToEndTracing(true) + .enableServerSideTracing() .build() - .isEndToEndTracingEnabled()); + .isServerSideTracingEnabled()); assertFalse( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableEndToEndTracing(false) + .disableServerSideTracing() .build() - .isEndToEndTracingEnabled()); + .isServerSideTracingEnabled()); } @Test diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 9473faa3a9f..ebc2c77ee62 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -148,7 +148,7 @@ public class GapicSpannerRpcTest { private static String defaultUserAgent; private static Spanner spanner; private static boolean isRouteToLeader; - private static boolean isEndToEndTracing; + private static boolean isServerSideTracing; @Parameter public Dialect dialect; @@ -200,15 +200,15 @@ public ServerCall.Listener interceptCall( Key.of( "x-goog-spanner-route-to-leader", Metadata.ASCII_STRING_MARSHALLER)); - String endToEndTracingHeader = + String serverSideTracingHeader = headers.get( Key.of( "x-goog-spanner-end-to-end-tracing", Metadata.ASCII_STRING_MARSHALLER)); isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); - isEndToEndTracing = - (endToEndTracingHeader != null && endToEndTracingHeader.equals("true")); + isServerSideTracing = + (serverSideTracingHeader != null && serverSideTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); } @@ -232,7 +232,7 @@ public void reset() throws InterruptedException { server.awaitTermination(); } isRouteToLeader = false; - isEndToEndTracing = false; + isServerSideTracing = false; } @Test @@ -474,9 +474,9 @@ public void testNewCallContextWithRouteToLeaderHeaderAndLarDisabled() { } @Test - public void testNewCallContextWithEndToEndTracingHeader() { + public void testNewCallContextWithServerSideTracingHeader() { SpannerOptions options = - SpannerOptions.newBuilder().setProjectId("some-project").setEnableEndToEndTracing(true).build(); + SpannerOptions.newBuilder().setProjectId("some-project").enableServerSideTracing().build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = rpc.newCallContext( @@ -495,9 +495,9 @@ public void testNewCallContextWithEndToEndTracingHeader() { } @Test - public void testNewCallContextWithoutEndToEndTracingHeader() { + public void testNewCallContextWithoutServerSideTracingHeader() { SpannerOptions options = - SpannerOptions.newBuilder().setProjectId("some-project").setEnableEndToEndTracing(false).build(); + SpannerOptions.newBuilder().setProjectId("some-project").disableServerSideTracing().build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = rpc.newCallContext( @@ -511,9 +511,9 @@ public void testNewCallContextWithoutEndToEndTracingHeader() { } @Test - public void testEndToEndTracingHeaderWithEnabledTracing() { + public void testServerSideTracingHeaderWithEnabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableEndToEndTracing(true).build(); + createSpannerOptions().toBuilder().enableServerSideTracing().build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -524,13 +524,13 @@ public void testEndToEndTracingHeaderWithEnabledTracing() { return null; }); } - assertTrue(isEndToEndTracing); + assertTrue(isServerSideTracing); } @Test - public void testEndToEndTracingHeaderWithDisabledTracing() { + public void testServerSideTracingHeaderWithDisabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableEndToEndTracing(false).build(); + createSpannerOptions().toBuilder().disableServerSideTracing().build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -541,7 +541,7 @@ public void testEndToEndTracingHeaderWithDisabledTracing() { return null; }); } - assertFalse(isEndToEndTracing); + assertFalse(isServerSideTracing); } @Test diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java index c4fdd6200af..010f16bc4cc 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java @@ -98,7 +98,7 @@ public void testNewRouteToLeaderHeader() { public void testNewEndToEndTracingHeader() { SpannerMetadataProvider metadataProvider = SpannerMetadataProvider.create(ImmutableMap.of(), "header1"); - Map> extraHeaders = metadataProvider.newEndToEndTracingHeader(); + Map> extraHeaders = metadataProvider.newServerSideTracingHeader(); Map> expectedHeaders = ImmutableMap.>of( "x-goog-spanner-end-to-end-tracing", ImmutableList.of("true")); From d2ac8b492d6d1bc708396e36d970225f4d2ed6d1 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Mon, 15 Jul 2024 11:38:29 +0000 Subject: [PATCH 06/18] add test for custom client interceptor code --- .../spi/v1/TraceContextInterceptor.java | 2 +- .../spanner/spi/v1/GapicSpannerRpcTest.java | 50 +++++++++++++++++++ 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java index 6a21f56dfdc..7ab817606db 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java @@ -56,7 +56,7 @@ public void start(Listener responseListener, Metadata headers) { Context parentContext = Context.current(); propagators.getTextMapPropagator().inject(parentContext, headers, MetadataSetter.INSTANCE); - + super.start(new SimpleForwardingClientCallListener(responseListener) { @Override public void onHeaders(Metadata headers) { diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 42a07ed9ea6..3d2033bdd9a 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -76,6 +76,13 @@ import io.grpc.auth.MoreCallCredentials; import io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder; import io.grpc.protobuf.lite.ProtoLiteUtils; +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; +import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.sdk.OpenTelemetrySdk; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.sdk.trace.samplers.Sampler; + import java.io.IOException; import java.net.InetSocketAddress; import java.util.HashMap; @@ -148,6 +155,7 @@ public class GapicSpannerRpcTest { private static String defaultUserAgent; private static Spanner spanner; private static boolean isRouteToLeader; + private static boolean isTraceContextPresent; @Parameter public Dialect dialect; @@ -158,6 +166,9 @@ public static Object[] data() { @Before public void startServer() throws IOException { + // Enable OpenTelemetry tracing. + SpannerOptions.enableOpenTelemetryTraces(); + assumeTrue( "Skip tests when emulator is enabled as this test interferes with the check whether the emulator is running", System.getenv("SPANNER_EMULATOR_HOST") == null); @@ -194,6 +205,9 @@ public ServerCall.Listener interceptCall( if (call.getMethodDescriptor() .equals(SpannerGrpc.getExecuteStreamingSqlMethod()) || call.getMethodDescriptor().equals(SpannerGrpc.getExecuteSqlMethod())) { + String traceParentHeader = + headers.get(Key.of("traceparent", Metadata.ASCII_STRING_MARSHALLER)); + isTraceContextPresent = (traceParentHeader != null); String routeToLeaderHeader = headers.get( Key.of( @@ -224,6 +238,7 @@ public void reset() throws InterruptedException { server.awaitTermination(); } isRouteToLeader = false; + isTraceContextPresent = false; } @Test @@ -535,6 +550,41 @@ public void testCustomUserAgent() { } } + @Test + public void testTraceContextHeaderWithOpenTelemetry() { + OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .setTracerProvider(SdkTracerProvider.builder().setSampler(Sampler.alwaysOn()).build()) + .build(); + + final SpannerOptions options = createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).build(); + try (Spanner spanner = options.getService()) { + final DatabaseClient databaseClient = + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + + try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { + rs.next(); + } + + assertTrue(isTraceContextPresent); + } + } + + @Test + public void testTraceContextHeaderWithoutOpenTelemetry() { + final SpannerOptions options = createSpannerOptions(); + try (Spanner spanner = options.getService()) { + final DatabaseClient databaseClient = + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + + try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { + rs.next(); + } + + assertFalse(isTraceContextPresent); + } + } + @Test public void testRouteToLeaderHeaderForReadOnly() { final SpannerOptions options = From 233acd2db4e38746db0afb8ae1ab70c2dfa8d903 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 17 Jul 2024 13:04:00 +0000 Subject: [PATCH 07/18] resolve comments --- .../google/cloud/spanner/SpannerOptions.java | 2 +- .../spi/v1/SpannerInterceptorProvider.java | 1 - .../spi/v1/TraceContextInterceptor.java | 75 +++++++++---------- .../spanner/spi/v1/GapicSpannerRpcTest.java | 36 ++++----- 4 files changed, 57 insertions(+), 57 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index e6f60090acb..d35bbe962b3 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -1480,7 +1480,7 @@ public static void enableOpenCensusTraces() { */ @ObsoleteApi( "The OpenCensus project is deprecated. Use enableOpenTelemetryTraces to switch to OpenTelemetry traces") - static void resetActiveTracingFramework() { + public static void resetActiveTracingFramework() { activeTracingFramework = null; } diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index f730aeaed23..c676f465a59 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -23,7 +23,6 @@ import io.grpc.ClientInterceptor; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.OpenTelemetry; - import java.util.ArrayList; import java.util.List; import java.util.logging.Level; diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java index 7ab817606db..3b46ba4f880 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/TraceContextInterceptor.java @@ -1,5 +1,5 @@ /* - * Copyright 2021 Google LLC + * Copyright 2024 Google LLC * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,52 +23,51 @@ import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener; import io.grpc.Metadata; import io.grpc.MethodDescriptor; -import io.grpc.Status; import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.context.Context; -import io.opentelemetry.context.propagation.ContextPropagators; +import io.opentelemetry.context.propagation.TextMapPropagator; import io.opentelemetry.context.propagation.TextMapSetter; -public class TraceContextInterceptor implements ClientInterceptor { - - private final ContextPropagators propagators; +/** + * Intercepts all gRPC calls and injects trace context related headers to propagate trace context to + * Spanner. This class takes reference from OpenTelemetry's JAVA instrumentation library for gRPC. + * https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/9ecf7965aa455d41ea8cc0761b6c6b6eeb106324/instrumentation/grpc-1.6/library/src/main/java/io/opentelemetry/instrumentation/grpc/v1_6/TracingClientInterceptor.java#L27 + */ +class TraceContextInterceptor implements ClientInterceptor { - TraceContextInterceptor(OpenTelemetry openTelemetry) { - this.propagators = openTelemetry.getPropagators(); - } + private final TextMapPropagator textMapPropagator; - enum MetadataSetter implements TextMapSetter { - INSTANCE; + TraceContextInterceptor(OpenTelemetry openTelemetry) { + this.textMapPropagator = openTelemetry.getPropagators().getTextMapPropagator(); + } - @SuppressWarnings("null") - @Override - public void set(Metadata carrier, String key, String value) { - carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value); - } - } + enum MetadataSetter implements TextMapSetter { + INSTANCE; + @SuppressWarnings("null") @Override - public ClientCall interceptCall(MethodDescriptor method, - CallOptions callOptions, Channel next) { - return new SimpleForwardingClientCall(next.newCall(method, callOptions)) { - @Override - public void start(Listener responseListener, Metadata headers) { - Context parentContext = Context.current(); - - propagators.getTextMapPropagator().inject(parentContext, headers, MetadataSetter.INSTANCE); - - super.start(new SimpleForwardingClientCallListener(responseListener) { - @Override - public void onHeaders(Metadata headers) { - super.onHeaders(headers); - } + public void set(Metadata carrier, String key, String value) { + carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value); + } + } - @Override - public void onClose(Status status, Metadata trailers) { - super.onClose(status, trailers); - } - }, headers); - } - }; + private static final class NoopSimpleForwardingClientCallListener + extends SimpleForwardingClientCallListener { + public NoopSimpleForwardingClientCallListener(ClientCall.Listener responseListener) { + super(responseListener); } + } + + @Override + public ClientCall interceptCall( + MethodDescriptor method, CallOptions callOptions, Channel next) { + return new SimpleForwardingClientCall(next.newCall(method, callOptions)) { + @Override + public void start(Listener responseListener, Metadata headers) { + Context parentContext = Context.current(); + textMapPropagator.inject(parentContext, headers, MetadataSetter.INSTANCE); + super.start(new NoopSimpleForwardingClientCallListener(responseListener), headers); + } + }; + } } diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 3d2033bdd9a..8ad6c5995e2 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -82,7 +82,6 @@ import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.samplers.Sampler; - import java.io.IOException; import java.net.InetSocketAddress; import java.util.HashMap; @@ -167,6 +166,7 @@ public static Object[] data() { @Before public void startServer() throws IOException { // Enable OpenTelemetry tracing. + SpannerOptions.resetActiveTracingFramework(); SpannerOptions.enableOpenTelemetryTraces(); assumeTrue( @@ -552,22 +552,24 @@ public void testCustomUserAgent() { @Test public void testTraceContextHeaderWithOpenTelemetry() { - OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() - .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) - .setTracerProvider(SdkTracerProvider.builder().setSampler(Sampler.alwaysOn()).build()) - .build(); + OpenTelemetry openTelemetry = + OpenTelemetrySdk.builder() + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .setTracerProvider(SdkTracerProvider.builder().setSampler(Sampler.alwaysOn()).build()) + .build(); - final SpannerOptions options = createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).build(); + final SpannerOptions options = + createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = - spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); - try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { - rs.next(); - } + try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { + rs.next(); + } - assertTrue(isTraceContextPresent); - } + assertTrue(isTraceContextPresent); + } } @Test @@ -575,13 +577,13 @@ public void testTraceContextHeaderWithoutOpenTelemetry() { final SpannerOptions options = createSpannerOptions(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = - spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); - try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { - rs.next(); - } + try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { + rs.next(); + } - assertFalse(isTraceContextPresent); + assertFalse(isTraceContextPresent); } } From ab717452d3d9e28c582c1506c2aac53cdba9c74f Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Fri, 9 Aug 2024 07:33:44 +0000 Subject: [PATCH 08/18] Make trace context interceptor conditional based on client opt-in --- .../cloud/spanner/spi/v1/GapicSpannerRpc.java | 2 ++ .../spi/v1/SpannerInterceptorProvider.java | 8 +++++- .../spanner/spi/v1/GapicSpannerRpcTest.java | 26 +++++++++++++++++-- 3 files changed, 33 insertions(+), 3 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java index 2b92283799c..6ed78757a5c 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java @@ -348,6 +348,8 @@ public GapicSpannerRpc(final SpannerOptions options) { MoreObjects.firstNonNull( options.getInterceptorProvider(), SpannerInterceptorProvider.createDefault(options.getOpenTelemetry()))) + // This sets the trace context headers. + .withTraceContext(serverSideTracingEnabled, options.getOpenTelemetry()) // This sets the response compressor (Server -> Client). .withEncoding(compressorName)) .setHeaderProvider(headerProviderWithUserAgent) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index c676f465a59..b4f7daa25d9 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -51,7 +51,6 @@ public static SpannerInterceptorProvider createDefault(OpenTelemetry openTelemet defaultInterceptorList.add( new LoggingInterceptor(Logger.getLogger(GapicSpannerRpc.class.getName()), Level.FINER)); defaultInterceptorList.add(new HeaderInterceptor(new SpannerRpcMetrics(openTelemetry))); - defaultInterceptorList.add(new TraceContextInterceptor(openTelemetry)); return new SpannerInterceptorProvider(ImmutableList.copyOf(defaultInterceptorList)); } @@ -75,6 +74,13 @@ SpannerInterceptorProvider withEncoding(String encoding) { return this; } + SpannerInterceptorProvider withTraceContext(boolean serverSideTracingEnabled, OpenTelemetry openTelemetry) { + if (serverSideTracingEnabled) { + return with(new TraceContextInterceptor(openTelemetry)); + } + return this; + } + @Override public List getInterceptors() { return clientInterceptors; diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index a4f1dc7aefb..4aae050e3fe 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -631,7 +631,7 @@ public void testCustomUserAgent() { } @Test - public void testTraceContextHeaderWithOpenTelemetry() { + public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() { OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) @@ -639,7 +639,7 @@ public void testTraceContextHeaderWithOpenTelemetry() { .build(); final SpannerOptions options = - createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).build(); + createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).enableServerSideTracing().build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -652,6 +652,28 @@ public void testTraceContextHeaderWithOpenTelemetry() { } } + @Test + public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingDisabled() { + OpenTelemetry openTelemetry = + OpenTelemetrySdk.builder() + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .setTracerProvider(SdkTracerProvider.builder().setSampler(Sampler.alwaysOn()).build()) + .build(); + + final SpannerOptions options = + createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).disableServerSideTracing().build(); + try (Spanner spanner = options.getService()) { + final DatabaseClient databaseClient = + spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); + + try (final ResultSet rs = databaseClient.singleUse().executeQuery(SELECT1AND2)) { + rs.next(); + } + + assertFalse(isTraceContextPresent); + } + } + @Test public void testTraceContextHeaderWithoutOpenTelemetry() { final SpannerOptions options = createSpannerOptions(); From 2035d5939170c3d879be4e0cc65d81afab9bf1bf Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Fri, 9 Aug 2024 10:43:49 +0000 Subject: [PATCH 09/18] resolve comments --- .../com/google/cloud/spanner/SpannerOptions.java | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 39f8786fd27..4b9e9628383 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -698,6 +698,10 @@ default boolean isEnableExtendedTracing() { default boolean isEnableApiTracing() { return false; } + + default boolean isEnableServerSideTracing() { + return false; + } } /** @@ -711,6 +715,7 @@ private static class SpannerEnvironmentImpl implements SpannerEnvironment { "SPANNER_OPTIMIZER_STATISTICS_PACKAGE"; private static final String SPANNER_ENABLE_EXTENDED_TRACING = "SPANNER_ENABLE_EXTENDED_TRACING"; private static final String SPANNER_ENABLE_API_TRACING = "SPANNER_ENABLE_API_TRACING"; + private static final String SPANNER_ENABLE_SERVER_SIDE_TRACING = "SPANNER_ENABLE_SERVER_SIDE_TRACING"; private SpannerEnvironmentImpl() {} @@ -736,6 +741,11 @@ public boolean isEnableExtendedTracing() { public boolean isEnableApiTracing() { return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_API_TRACING)); } + + @Override + public boolean isEnableServerSideTracing() { + return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_SERVER_SIDE_TRACING)); + } } /** Builder for {@link SpannerOptions} instances. */ @@ -801,7 +811,7 @@ public static class Builder private OpenTelemetry openTelemetry; private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); - private boolean enableServerSideTracing = false; + private boolean enableServerSideTracing = SpannerOptions.environment.isEnableServerSideTracing(); private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -1502,6 +1512,7 @@ public static void enableOpenCensusTraces() { */ @ObsoleteApi( "The OpenCensus project is deprecated. Use enableOpenTelemetryTraces to switch to OpenTelemetry traces") + @VisibleForTesting public static void resetActiveTracingFramework() { activeTracingFramework = null; } From 6af5e04df8dd30e1cfe762686417019c4142fb6d Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Tue, 13 Aug 2024 03:58:54 +0000 Subject: [PATCH 10/18] reformat code --- .../google/cloud/spanner/SpannerOptions.java | 20 ++++++++++--------- .../spi/v1/SpannerInterceptorProvider.java | 3 ++- .../spanner/spi/v1/GapicSpannerRpcTest.java | 15 +++++++++++--- 3 files changed, 25 insertions(+), 13 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 4b9e9628383..9f3f3bd86b2 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -715,7 +715,8 @@ private static class SpannerEnvironmentImpl implements SpannerEnvironment { "SPANNER_OPTIMIZER_STATISTICS_PACKAGE"; private static final String SPANNER_ENABLE_EXTENDED_TRACING = "SPANNER_ENABLE_EXTENDED_TRACING"; private static final String SPANNER_ENABLE_API_TRACING = "SPANNER_ENABLE_API_TRACING"; - private static final String SPANNER_ENABLE_SERVER_SIDE_TRACING = "SPANNER_ENABLE_SERVER_SIDE_TRACING"; + private static final String SPANNER_ENABLE_SERVER_SIDE_TRACING = + "SPANNER_ENABLE_SERVER_SIDE_TRACING"; private SpannerEnvironmentImpl() {} @@ -811,7 +812,8 @@ public static class Builder private OpenTelemetry openTelemetry; private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); - private boolean enableServerSideTracing = SpannerOptions.environment.isEnableServerSideTracing(); + private boolean enableServerSideTracing = + SpannerOptions.environment.isEnableServerSideTracing(); private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -1406,8 +1408,8 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Enable spanner server side tracing. Enabling this option will create the trace - * spans at the Spanner layer. By default, server side tracing is disabled. + * Enable spanner server side tracing. Enabling this option will create the trace spans at the + * Spanner layer. By default, server side tracing is disabled. */ public Builder enableServerSideTracing() { this.enableServerSideTracing = true; @@ -1415,14 +1417,14 @@ public Builder enableServerSideTracing() { } /** - * Disable spanner server side tracing. If server side is disabled, trace - * spans won't be created at the Spanner layer. + * Disable spanner server side tracing. If server side is disabled, trace spans won't be created + * at the Spanner layer. */ public Builder disableServerSideTracing() { this.enableServerSideTracing = false; return this; } - + @SuppressWarnings("rawtypes") @Override public SpannerOptions build() { @@ -1715,8 +1717,8 @@ public boolean isEnableExtendedTracing() { } /** - * Returns whether Spanner server side tracing is enabled. If this option is enabled then trace spans - * will be created at the Spanner layer. + * Returns whether Spanner server side tracing is enabled. If this option is enabled then trace + * spans will be created at the Spanner layer. */ public boolean isServerSideTracingEnabled() { return enableServerSideTracing; diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index b4f7daa25d9..bc20e815e95 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -74,7 +74,8 @@ SpannerInterceptorProvider withEncoding(String encoding) { return this; } - SpannerInterceptorProvider withTraceContext(boolean serverSideTracingEnabled, OpenTelemetry openTelemetry) { + SpannerInterceptorProvider withTraceContext( + boolean serverSideTracingEnabled, OpenTelemetry openTelemetry) { if (serverSideTracingEnabled) { return with(new TraceContextInterceptor(openTelemetry)); } diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 4aae050e3fe..2676614162f 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -222,7 +222,8 @@ public ServerCall.Listener interceptCall( isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); isServerSideTracing = - (serverSideTracingHeader != null && serverSideTracingHeader.equals("true")); + (serverSideTracingHeader != null + && serverSideTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); } @@ -639,7 +640,11 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() .build(); final SpannerOptions options = - createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).enableServerSideTracing().build(); + createSpannerOptions() + .toBuilder() + .setOpenTelemetry(openTelemetry) + .enableServerSideTracing() + .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -661,7 +666,11 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingDisabled( .build(); final SpannerOptions options = - createSpannerOptions().toBuilder().setOpenTelemetry(openTelemetry).disableServerSideTracing().build(); + createSpannerOptions() + .toBuilder() + .setOpenTelemetry(openTelemetry) + .disableServerSideTracing() + .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); From 0aa51fff3e7646bf2408ed140bd213a6253dfab8 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 14 Aug 2024 10:06:46 +0000 Subject: [PATCH 11/18] resolve comments --- .../google/cloud/spanner/SpannerOptions.java | 6 ++-- .../cloud/spanner/SpannerOptionsHelper.java | 29 +++++++++++++++++++ .../spanner/spi/v1/GapicSpannerRpcTest.java | 3 +- 3 files changed, 35 insertions(+), 3 deletions(-) create mode 100644 google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 9f3f3bd86b2..79a518c359e 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -1409,7 +1409,9 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { /** * Enable spanner server side tracing. Enabling this option will create the trace spans at the - * Spanner layer. By default, server side tracing is disabled. + * Spanner layer. By default, server side tracing is disabled. Enabling server side tracing + * requires OpenTelemetry to be set up properly. Simply enabling this option won't generate + * server side traces. */ public Builder enableServerSideTracing() { this.enableServerSideTracing = true; @@ -1515,7 +1517,7 @@ public static void enableOpenCensusTraces() { @ObsoleteApi( "The OpenCensus project is deprecated. Use enableOpenTelemetryTraces to switch to OpenTelemetry traces") @VisibleForTesting - public static void resetActiveTracingFramework() { + static void resetActiveTracingFramework() { activeTracingFramework = null; } diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java new file mode 100644 index 00000000000..1269b65f642 --- /dev/null +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java @@ -0,0 +1,29 @@ +/* + * Copyright 2024 Google LLC + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.cloud.spanner; + +/** Helper to configure SpannerOptions for tests. */ +public class SpannerOptionsHelper { + + /** + * Resets the activeTracingFramework. This variable is used for internal testing, and is + * not a valid production scenario. + */ + public static void resetActiveTracingFramework() { + SpannerOptions.resetActiveTracingFramework(); + } +} diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 2676614162f..99b2bedcb60 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -46,6 +46,7 @@ import com.google.cloud.spanner.SpannerException; import com.google.cloud.spanner.SpannerExceptionFactory; import com.google.cloud.spanner.SpannerOptions; +import com.google.cloud.spanner.SpannerOptionsHelper; import com.google.cloud.spanner.SpannerOptions.CallContextConfigurator; import com.google.cloud.spanner.Statement; import com.google.cloud.spanner.TransactionRunner; @@ -167,7 +168,7 @@ public static Object[] data() { @Before public void startServer() throws IOException { // Enable OpenTelemetry tracing. - SpannerOptions.resetActiveTracingFramework(); + SpannerOptionsHelper.resetActiveTracingFramework(); SpannerOptions.enableOpenTelemetryTraces(); assumeTrue( From 39269c0a6d4a18afef80f5724e4aa1969f057e80 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 14 Aug 2024 10:19:53 +0000 Subject: [PATCH 12/18] fix clirr build failure --- google-cloud-spanner/clirr-ignored-differences.xml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/google-cloud-spanner/clirr-ignored-differences.xml b/google-cloud-spanner/clirr-ignored-differences.xml index 9433fcba5ad..863afe6a3d8 100644 --- a/google-cloud-spanner/clirr-ignored-differences.xml +++ b/google-cloud-spanner/clirr-ignored-differences.xml @@ -695,6 +695,13 @@ boolean isEnableApiTracing() + + + 7012 + com/google/cloud/spanner/SpannerOptions$SpannerEnvironment + boolean isEnableServerSideTracing() + + 7012 From d2fd1c8818c616e11d5a21d47d4c644504b17115 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 14 Aug 2024 10:53:23 +0000 Subject: [PATCH 13/18] fix lint errors --- .../java/com/google/cloud/spanner/SpannerOptionsHelper.java | 4 ++-- .../com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java index 1269b65f642..db02c625099 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsHelper.java @@ -20,8 +20,8 @@ public class SpannerOptionsHelper { /** - * Resets the activeTracingFramework. This variable is used for internal testing, and is - * not a valid production scenario. + * Resets the activeTracingFramework. This variable is used for internal testing, and is not a + * valid production scenario. */ public static void resetActiveTracingFramework() { SpannerOptions.resetActiveTracingFramework(); diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 99b2bedcb60..285efb9259e 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -46,8 +46,8 @@ import com.google.cloud.spanner.SpannerException; import com.google.cloud.spanner.SpannerExceptionFactory; import com.google.cloud.spanner.SpannerOptions; -import com.google.cloud.spanner.SpannerOptionsHelper; import com.google.cloud.spanner.SpannerOptions.CallContextConfigurator; +import com.google.cloud.spanner.SpannerOptionsHelper; import com.google.cloud.spanner.Statement; import com.google.cloud.spanner.TransactionRunner; import com.google.cloud.spanner.spi.v1.GapicSpannerRpc.AdminRequestsLimitExceededRetryAlgorithm; From 2b9409be8470a3c5907dbdde229d4f4e0ced3516 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Mon, 19 Aug 2024 09:01:26 +0000 Subject: [PATCH 14/18] combine enable/disable fn into single fn --- .../google/cloud/spanner/SpannerOptions.java | 21 ++++++------------- .../cloud/spanner/SpannerOptionsTest.java | 4 ++-- .../spanner/spi/v1/GapicSpannerRpcTest.java | 18 ++++++++++------ 3 files changed, 20 insertions(+), 23 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 79a518c359e..e87bca31c05 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -1408,22 +1408,13 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Enable spanner server side tracing. Enabling this option will create the trace spans at the - * Spanner layer. By default, server side tracing is disabled. Enabling server side tracing - * requires OpenTelemetry to be set up properly. Simply enabling this option won't generate - * server side traces. + * Sets whether to enable Spanner server side tracing. Enabling this option will create the + * trace spans at the Spanner layer. By default, server side tracing is disabled. Enabling + * server side tracing requires OpenTelemetry to be set up properly. Simply enabling this option + * won't generate server side traces. */ - public Builder enableServerSideTracing() { - this.enableServerSideTracing = true; - return this; - } - - /** - * Disable spanner server side tracing. If server side is disabled, trace spans won't be created - * at the Spanner layer. - */ - public Builder disableServerSideTracing() { - this.enableServerSideTracing = false; + public Builder setEnableServerSideTracing(boolean enableServerSideTracing) { + this.enableServerSideTracing = enableServerSideTracing; return this; } diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index 21381f4a778..977fd5645c5 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -738,13 +738,13 @@ public void testServerSideTracingEnablement() { assertTrue( SpannerOptions.newBuilder() .setProjectId("p") - .enableServerSideTracing() + .setEnableServerSideTracing(true) .build() .isServerSideTracingEnabled()); assertFalse( SpannerOptions.newBuilder() .setProjectId("p") - .disableServerSideTracing() + .setEnableServerSideTracing(false) .build() .isServerSideTracingEnabled()); } diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 285efb9259e..6b91f1f6cd5 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -493,7 +493,10 @@ public void testNewCallContextWithRouteToLeaderHeaderAndLarDisabled() { @Test public void testNewCallContextWithServerSideTracingHeader() { SpannerOptions options = - SpannerOptions.newBuilder().setProjectId("some-project").enableServerSideTracing().build(); + SpannerOptions.newBuilder() + .setProjectId("some-project") + .setEnableServerSideTracing(true) + .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = rpc.newCallContext( @@ -514,7 +517,10 @@ public void testNewCallContextWithServerSideTracingHeader() { @Test public void testNewCallContextWithoutServerSideTracingHeader() { SpannerOptions options = - SpannerOptions.newBuilder().setProjectId("some-project").disableServerSideTracing().build(); + SpannerOptions.newBuilder() + .setProjectId("some-project") + .setEnableServerSideTracing(false) + .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = rpc.newCallContext( @@ -530,7 +536,7 @@ public void testNewCallContextWithoutServerSideTracingHeader() { @Test public void testServerSideTracingHeaderWithEnabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().enableServerSideTracing().build(); + createSpannerOptions().toBuilder().setEnableServerSideTracing(true).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -547,7 +553,7 @@ public void testServerSideTracingHeaderWithEnabledTracing() { @Test public void testServerSideTracingHeaderWithDisabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().disableServerSideTracing().build(); + createSpannerOptions().toBuilder().setEnableServerSideTracing(false).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -644,7 +650,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .enableServerSideTracing() + .setEnableServerSideTracing(true) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = @@ -670,7 +676,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingDisabled( createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .disableServerSideTracing() + .setEnableServerSideTracing(false) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = From b3a6d311a873fb38c186315a26dc8ec62f0e6d9c Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Wed, 25 Sep 2024 19:49:25 +0000 Subject: [PATCH 15/18] Rename server side tracing to spanner tracing --- .../clirr-ignored-differences.xml | 4 +- .../google/cloud/spanner/SpannerOptions.java | 40 +++++++++---------- .../cloud/spanner/spi/v1/GapicSpannerRpc.java | 10 ++--- .../spi/v1/SpannerInterceptorProvider.java | 4 +- .../spi/v1/SpannerMetadataProvider.java | 10 ++--- .../cloud/spanner/SpannerOptionsTest.java | 12 +++--- .../spanner/spi/v1/GapicSpannerRpcTest.java | 40 +++++++++---------- .../spi/v1/SpannerMetadataProviderTest.java | 2 +- 8 files changed, 61 insertions(+), 61 deletions(-) diff --git a/google-cloud-spanner/clirr-ignored-differences.xml b/google-cloud-spanner/clirr-ignored-differences.xml index db60e3adbd4..549eefaca6e 100644 --- a/google-cloud-spanner/clirr-ignored-differences.xml +++ b/google-cloud-spanner/clirr-ignored-differences.xml @@ -695,11 +695,11 @@ boolean isEnableApiTracing() - + 7012 com/google/cloud/spanner/SpannerOptions$SpannerEnvironment - boolean isEnableServerSideTracing() + boolean isEnableSpannerTracing() diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 626b5fdefc3..767b617435a 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -163,7 +163,7 @@ public class SpannerOptions extends ServiceOptions { private final boolean enableApiTracing; private final boolean enableBuiltInMetrics; private final boolean enableExtendedTracing; - private final boolean enableServerSideTracing; + private final boolean enableSpannerTracing; enum TracingFramework { OPEN_CENSUS, @@ -671,7 +671,7 @@ protected SpannerOptions(Builder builder) { enableApiTracing = builder.enableApiTracing; enableExtendedTracing = builder.enableExtendedTracing; enableBuiltInMetrics = builder.enableBuiltInMetrics; - enableServerSideTracing = builder.enableServerSideTracing; + enableSpannerTracing = builder.enableSpannerTracing; } /** @@ -709,7 +709,7 @@ default boolean isEnableBuiltInMetrics() { return false; } - default boolean isEnableServerSideTracing() { + default boolean isEnableSpannerTracing() { return false; } } @@ -726,8 +726,8 @@ private static class SpannerEnvironmentImpl implements SpannerEnvironment { private static final String SPANNER_ENABLE_EXTENDED_TRACING = "SPANNER_ENABLE_EXTENDED_TRACING"; private static final String SPANNER_ENABLE_API_TRACING = "SPANNER_ENABLE_API_TRACING"; private static final String SPANNER_ENABLE_BUILTIN_METRICS = "SPANNER_ENABLE_BUILTIN_METRICS"; - private static final String SPANNER_ENABLE_SERVER_SIDE_TRACING = - "SPANNER_ENABLE_SERVER_SIDE_TRACING"; + private static final String SPANNER_ENABLE_SPANNER_TRACING = + "SPANNER_ENABLE_SPANNER_TRACING"; private SpannerEnvironmentImpl() {} @@ -762,8 +762,8 @@ public boolean isEnableBuiltInMetrics() { } @Override - public boolean isEnableServerSideTracing() { - return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_SERVER_SIDE_TRACING)); + public boolean isEnableSpannerTracing() { + return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_SPANNER_TRACING)); } } @@ -829,8 +829,8 @@ public static class Builder private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); private boolean enableBuiltInMetrics = SpannerOptions.environment.isEnableBuiltInMetrics(); - private boolean enableServerSideTracing = - SpannerOptions.environment.isEnableServerSideTracing(); + private boolean enableSpannerTracing = + SpannerOptions.environment.isEnableSpannerTracing(); private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -897,7 +897,7 @@ protected Builder() { this.enableApiTracing = options.enableApiTracing; this.enableExtendedTracing = options.enableExtendedTracing; this.enableBuiltInMetrics = options.enableBuiltInMetrics; - this.enableServerSideTracing = options.enableServerSideTracing; + this.enableSpannerTracing = options.enableSpannerTracing; } @Override @@ -1432,13 +1432,13 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Sets whether to enable Spanner server side tracing. Enabling this option will create the - * trace spans at the Spanner layer. By default, server side tracing is disabled. Enabling - * server side tracing requires OpenTelemetry to be set up properly. Simply enabling this option - * won't generate server side traces. + * Sets whether to enable Spanner tracing. Enabling this option will create the trace + * spans at the Spanner layer. By default, spanner tracing is disabled. Enabling spanner + * tracing requires OpenTelemetry to be set up properly. Simply enabling this option + * won't generate spanner traces. */ - public Builder setEnableServerSideTracing(boolean enableServerSideTracing) { - this.enableServerSideTracing = enableServerSideTracing; + public Builder setEnableSpannerTracing(boolean enableSpannerTracing) { + this.enableSpannerTracing = enableSpannerTracing; return this; } @@ -1774,11 +1774,11 @@ public boolean isEnableExtendedTracing() { } /** - * Returns whether Spanner server side tracing is enabled. If this option is enabled then trace - * spans will be created at the Spanner layer. + * Returns whether Spanner tracing is enabled. If this option is enabled then trace spans + * will be created at the Spanner layer. */ - public boolean isServerSideTracingEnabled() { - return enableServerSideTracing; + public boolean isSpannerTracingEnabled() { + return enableSpannerTracing; } /** Returns the default query options to use for the specific database. */ diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java index cc6ec6ca214..1db93fadf9d 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java @@ -272,7 +272,7 @@ public class GapicSpannerRpc implements SpannerRpc { private static final ConcurrentMap ADMINISTRATIVE_REQUESTS_RATE_LIMITERS = new ConcurrentHashMap<>(); private final boolean leaderAwareRoutingEnabled; - private final boolean serverSideTracingEnabled; + private final boolean spannerTracingEnabled; private final int numChannels; private final boolean isGrpcGcpExtensionEnabled; @@ -326,7 +326,7 @@ public GapicSpannerRpc(final SpannerOptions options) { this.callCredentialsProvider = options.getCallCredentialsProvider(); this.compressorName = options.getCompressorName(); this.leaderAwareRoutingEnabled = options.isLeaderAwareRoutingEnabled(); - this.serverSideTracingEnabled = options.isServerSideTracingEnabled(); + this.spannerTracingEnabled = options.isSpannerTracingEnabled(); this.numChannels = options.getNumChannels(); this.isGrpcGcpExtensionEnabled = options.isGrpcGcpExtensionEnabled(); @@ -353,7 +353,7 @@ public GapicSpannerRpc(final SpannerOptions options) { options.getInterceptorProvider(), SpannerInterceptorProvider.createDefault(options.getOpenTelemetry()))) // This sets the trace context headers. - .withTraceContext(serverSideTracingEnabled, options.getOpenTelemetry()) + .withTraceContext(spannerTracingEnabled, options.getOpenTelemetry()) // This sets the response compressor (Server -> Client). .withEncoding(compressorName)) .setHeaderProvider(headerProviderWithUserAgent) @@ -2011,8 +2011,8 @@ GrpcCallContext newCallContext( if (routeToLeader && leaderAwareRoutingEnabled) { context = context.withExtraHeaders(metadataProvider.newRouteToLeaderHeader()); } - if (serverSideTracingEnabled) { - context = context.withExtraHeaders(metadataProvider.newServerSideTracingHeader()); + if (spannerTracingEnabled) { + context = context.withExtraHeaders(metadataProvider.newSpannerTracingHeader()); } if (callCredentialsProvider != null) { CallCredentials callCredentials = callCredentialsProvider.getCallCredentials(); diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index bc20e815e95..ee8ac7237b9 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -75,8 +75,8 @@ SpannerInterceptorProvider withEncoding(String encoding) { } SpannerInterceptorProvider withTraceContext( - boolean serverSideTracingEnabled, OpenTelemetry openTelemetry) { - if (serverSideTracingEnabled) { + boolean spannerTracingEnabled, OpenTelemetry openTelemetry) { + if (spannerTracingEnabled) { return with(new TraceContextInterceptor(openTelemetry)); } return this; diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java index 611383942ca..7dc2e5ab154 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java @@ -37,7 +37,7 @@ class SpannerMetadataProvider { private final Map, String> headers; private final String resourceHeaderKey; private static final String ROUTE_TO_LEADER_HEADER_KEY = "x-goog-spanner-route-to-leader"; - private static final String SERVER_SIDE_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; + private static final String SPANNER_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; private static final Pattern[] RESOURCE_TOKEN_PATTERNS = { Pattern.compile("^(?projects/[^/]*/instances/[^/]*/databases/[^/]*)(.*)?"), Pattern.compile("^(?projects/[^/]*/instances/[^/]*)(.*)?") @@ -45,8 +45,8 @@ class SpannerMetadataProvider { private static final Map> ROUTE_TO_LEADER_HEADER_MAP = ImmutableMap.of(ROUTE_TO_LEADER_HEADER_KEY, Collections.singletonList("true")); - private static final Map> SERVER_SIDE_TRACING_HEADER_MAP = - ImmutableMap.of(SERVER_SIDE_TRACING_HEADER_KEY, Collections.singletonList("true")); + private static final Map> SPANNER_TRACING_HEADER_MAP = + ImmutableMap.of(SPANNER_TRACING_HEADER_KEY, Collections.singletonList("true")); private SpannerMetadataProvider(Map headers, String resourceHeaderKey) { this.resourceHeaderKey = resourceHeaderKey; @@ -92,8 +92,8 @@ Map> newRouteToLeaderHeader() { return ROUTE_TO_LEADER_HEADER_MAP; } - Map> newServerSideTracingHeader() { - return SERVER_SIDE_TRACING_HEADER_MAP; + Map> newSpannerTracingHeader() { + return SPANNER_TRACING_HEADER_MAP; } private Map, String> constructHeadersAsMetadata( diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index 7f893b0499a..4d9776fe6ec 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -737,21 +737,21 @@ public void testLeaderAwareRoutingEnablement() { } @Test - public void testServerSideTracingEnablement() { + public void testSpannerTracingEnablement() { // Test that end to end tracing is disabled by default. - assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isServerSideTracingEnabled()); + assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isSpannerTracingEnabled()); assertTrue( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableServerSideTracing(true) + .setEnableSpannerTracing(true) .build() - .isServerSideTracingEnabled()); + .isSpannerTracingEnabled()); assertFalse( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableServerSideTracing(false) + .setEnableSpannerTracing(false) .build() - .isServerSideTracingEnabled()); + .isSpannerTracingEnabled()); } @Test diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index 6b91f1f6cd5..d2760e012be 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -155,7 +155,7 @@ public class GapicSpannerRpcTest { private static String defaultUserAgent; private static Spanner spanner; private static boolean isRouteToLeader; - private static boolean isServerSideTracing; + private static boolean isSpannerTracing; private static boolean isTraceContextPresent; @Parameter public Dialect dialect; @@ -215,16 +215,16 @@ public ServerCall.Listener interceptCall( Key.of( "x-goog-spanner-route-to-leader", Metadata.ASCII_STRING_MARSHALLER)); - String serverSideTracingHeader = + String spannerTracingHeader = headers.get( Key.of( "x-goog-spanner-end-to-end-tracing", Metadata.ASCII_STRING_MARSHALLER)); isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); - isServerSideTracing = - (serverSideTracingHeader != null - && serverSideTracingHeader.equals("true")); + isSpannerTracing = + (spannerTracingHeader != null + && spannerTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); } @@ -248,7 +248,7 @@ public void reset() throws InterruptedException { server.awaitTermination(); } isRouteToLeader = false; - isServerSideTracing = false; + isSpannerTracing = false; isTraceContextPresent = false; } @@ -491,11 +491,11 @@ public void testNewCallContextWithRouteToLeaderHeaderAndLarDisabled() { } @Test - public void testNewCallContextWithServerSideTracingHeader() { + public void testNewCallContextWithSpannerTracingHeader() { SpannerOptions options = SpannerOptions.newBuilder() .setProjectId("some-project") - .setEnableServerSideTracing(true) + .setEnableSpannerTracing(true) .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = @@ -515,11 +515,11 @@ public void testNewCallContextWithServerSideTracingHeader() { } @Test - public void testNewCallContextWithoutServerSideTracingHeader() { + public void testNewCallContextWithoutSpannerTracingHeader() { SpannerOptions options = SpannerOptions.newBuilder() .setProjectId("some-project") - .setEnableServerSideTracing(false) + .setEnableSpannerTracing(false) .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = @@ -534,9 +534,9 @@ public void testNewCallContextWithoutServerSideTracingHeader() { } @Test - public void testServerSideTracingHeaderWithEnabledTracing() { + public void testSpannerTracingHeaderWithEnabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableServerSideTracing(true).build(); + createSpannerOptions().toBuilder().setEnableSpannerTracing(true).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -547,13 +547,13 @@ public void testServerSideTracingHeaderWithEnabledTracing() { return null; }); } - assertTrue(isServerSideTracing); + assertTrue(isSpannerTracing); } @Test - public void testServerSideTracingHeaderWithDisabledTracing() { + public void testSpannerTracingHeaderWithDisabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableServerSideTracing(false).build(); + createSpannerOptions().toBuilder().setEnableSpannerTracing(false).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -564,7 +564,7 @@ public void testServerSideTracingHeaderWithDisabledTracing() { return null; }); } - assertFalse(isServerSideTracing); + assertFalse(isSpannerTracing); } @Test @@ -639,7 +639,7 @@ public void testCustomUserAgent() { } @Test - public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() { + public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingEnabled() { OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) @@ -650,7 +650,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .setEnableServerSideTracing(true) + .setEnableSpannerTracing(true) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = @@ -665,7 +665,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingEnabled() } @Test - public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingDisabled() { + public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingDisabled() { OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) @@ -676,7 +676,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndServerSideTracingDisabled( createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .setEnableServerSideTracing(false) + .setEnableSpannerTracing(false) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java index 010f16bc4cc..36cbbe2d1c4 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java @@ -98,7 +98,7 @@ public void testNewRouteToLeaderHeader() { public void testNewEndToEndTracingHeader() { SpannerMetadataProvider metadataProvider = SpannerMetadataProvider.create(ImmutableMap.of(), "header1"); - Map> extraHeaders = metadataProvider.newServerSideTracingHeader(); + Map> extraHeaders = metadataProvider.newSpannerTracingHeader(); Map> expectedHeaders = ImmutableMap.>of( "x-goog-spanner-end-to-end-tracing", ImmutableList.of("true")); From 117c279a59890163c6895a8ef6b4900cd64e2a26 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Thu, 26 Sep 2024 12:58:23 +0000 Subject: [PATCH 16/18] Rename spanner tracing to end to end tracing --- .../clirr-ignored-differences.xml | 4 +- .../google/cloud/spanner/SpannerOptions.java | 38 +++++++++--------- .../cloud/spanner/spi/v1/GapicSpannerRpc.java | 10 ++--- .../spi/v1/SpannerInterceptorProvider.java | 4 +- .../spi/v1/SpannerMetadataProvider.java | 10 ++--- .../cloud/spanner/SpannerOptionsTest.java | 12 +++--- .../spanner/spi/v1/GapicSpannerRpcTest.java | 40 +++++++++---------- .../spi/v1/SpannerMetadataProviderTest.java | 2 +- 8 files changed, 60 insertions(+), 60 deletions(-) diff --git a/google-cloud-spanner/clirr-ignored-differences.xml b/google-cloud-spanner/clirr-ignored-differences.xml index 549eefaca6e..8e7a392302a 100644 --- a/google-cloud-spanner/clirr-ignored-differences.xml +++ b/google-cloud-spanner/clirr-ignored-differences.xml @@ -695,11 +695,11 @@ boolean isEnableApiTracing() - + 7012 com/google/cloud/spanner/SpannerOptions$SpannerEnvironment - boolean isEnableSpannerTracing() + boolean isEnableEndToEndTracing() diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 767b617435a..b4631243e4d 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -163,7 +163,7 @@ public class SpannerOptions extends ServiceOptions { private final boolean enableApiTracing; private final boolean enableBuiltInMetrics; private final boolean enableExtendedTracing; - private final boolean enableSpannerTracing; + private final boolean enableEndToEndTracing; enum TracingFramework { OPEN_CENSUS, @@ -671,7 +671,7 @@ protected SpannerOptions(Builder builder) { enableApiTracing = builder.enableApiTracing; enableExtendedTracing = builder.enableExtendedTracing; enableBuiltInMetrics = builder.enableBuiltInMetrics; - enableSpannerTracing = builder.enableSpannerTracing; + enableEndToEndTracing = builder.enableEndToEndTracing; } /** @@ -709,7 +709,7 @@ default boolean isEnableBuiltInMetrics() { return false; } - default boolean isEnableSpannerTracing() { + default boolean isEnableEndToEndTracing() { return false; } } @@ -726,8 +726,8 @@ private static class SpannerEnvironmentImpl implements SpannerEnvironment { private static final String SPANNER_ENABLE_EXTENDED_TRACING = "SPANNER_ENABLE_EXTENDED_TRACING"; private static final String SPANNER_ENABLE_API_TRACING = "SPANNER_ENABLE_API_TRACING"; private static final String SPANNER_ENABLE_BUILTIN_METRICS = "SPANNER_ENABLE_BUILTIN_METRICS"; - private static final String SPANNER_ENABLE_SPANNER_TRACING = - "SPANNER_ENABLE_SPANNER_TRACING"; + private static final String SPANNER_ENABLE_END_TO_END_TRACING = + "SPANNER_ENABLE_END_TO_END_TRACING"; private SpannerEnvironmentImpl() {} @@ -762,8 +762,8 @@ public boolean isEnableBuiltInMetrics() { } @Override - public boolean isEnableSpannerTracing() { - return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_SPANNER_TRACING)); + public boolean isEnableEndToEndTracing() { + return Boolean.parseBoolean(System.getenv(SPANNER_ENABLE_END_TO_END_TRACING)); } } @@ -829,8 +829,8 @@ public static class Builder private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); private boolean enableBuiltInMetrics = SpannerOptions.environment.isEnableBuiltInMetrics(); - private boolean enableSpannerTracing = - SpannerOptions.environment.isEnableSpannerTracing(); + private boolean enableEndToEndTracing = + SpannerOptions.environment.isEnableEndToEndTracing(); private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -897,7 +897,7 @@ protected Builder() { this.enableApiTracing = options.enableApiTracing; this.enableExtendedTracing = options.enableExtendedTracing; this.enableBuiltInMetrics = options.enableBuiltInMetrics; - this.enableSpannerTracing = options.enableSpannerTracing; + this.enableEndToEndTracing = options.enableEndToEndTracing; } @Override @@ -1432,13 +1432,13 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Sets whether to enable Spanner tracing. Enabling this option will create the trace - * spans at the Spanner layer. By default, spanner tracing is disabled. Enabling spanner - * tracing requires OpenTelemetry to be set up properly. Simply enabling this option - * won't generate spanner traces. + * Sets whether to enable end to end tracing. Enabling this option will create the + * trace spans at the Spanner layer. By default, end to end tracing is disabled. + * Enabling end to end tracing requires OpenTelemetry to be set up properly. Simply + * enabling this option won't generate traces at Spanner layer. */ - public Builder setEnableSpannerTracing(boolean enableSpannerTracing) { - this.enableSpannerTracing = enableSpannerTracing; + public Builder setEnableEndToEndTracing(boolean enableEndToEndTracing) { + this.enableEndToEndTracing = enableEndToEndTracing; return this; } @@ -1774,11 +1774,11 @@ public boolean isEnableExtendedTracing() { } /** - * Returns whether Spanner tracing is enabled. If this option is enabled then trace spans + * Returns whether end to end tracing is enabled. If this option is enabled then trace spans * will be created at the Spanner layer. */ - public boolean isSpannerTracingEnabled() { - return enableSpannerTracing; + public boolean isEndToEndTracingEnabled() { + return enableEndToEndTracing; } /** Returns the default query options to use for the specific database. */ diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java index 1db93fadf9d..2360b5d5173 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpc.java @@ -272,7 +272,7 @@ public class GapicSpannerRpc implements SpannerRpc { private static final ConcurrentMap ADMINISTRATIVE_REQUESTS_RATE_LIMITERS = new ConcurrentHashMap<>(); private final boolean leaderAwareRoutingEnabled; - private final boolean spannerTracingEnabled; + private final boolean endToEndTracingEnabled; private final int numChannels; private final boolean isGrpcGcpExtensionEnabled; @@ -326,7 +326,7 @@ public GapicSpannerRpc(final SpannerOptions options) { this.callCredentialsProvider = options.getCallCredentialsProvider(); this.compressorName = options.getCompressorName(); this.leaderAwareRoutingEnabled = options.isLeaderAwareRoutingEnabled(); - this.spannerTracingEnabled = options.isSpannerTracingEnabled(); + this.endToEndTracingEnabled = options.isEndToEndTracingEnabled(); this.numChannels = options.getNumChannels(); this.isGrpcGcpExtensionEnabled = options.isGrpcGcpExtensionEnabled(); @@ -353,7 +353,7 @@ public GapicSpannerRpc(final SpannerOptions options) { options.getInterceptorProvider(), SpannerInterceptorProvider.createDefault(options.getOpenTelemetry()))) // This sets the trace context headers. - .withTraceContext(spannerTracingEnabled, options.getOpenTelemetry()) + .withTraceContext(endToEndTracingEnabled, options.getOpenTelemetry()) // This sets the response compressor (Server -> Client). .withEncoding(compressorName)) .setHeaderProvider(headerProviderWithUserAgent) @@ -2011,8 +2011,8 @@ GrpcCallContext newCallContext( if (routeToLeader && leaderAwareRoutingEnabled) { context = context.withExtraHeaders(metadataProvider.newRouteToLeaderHeader()); } - if (spannerTracingEnabled) { - context = context.withExtraHeaders(metadataProvider.newSpannerTracingHeader()); + if (endToEndTracingEnabled) { + context = context.withExtraHeaders(metadataProvider.newEndToEndTracingHeader()); } if (callCredentialsProvider != null) { CallCredentials callCredentials = callCredentialsProvider.getCallCredentials(); diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java index ee8ac7237b9..b4d28ef0789 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerInterceptorProvider.java @@ -75,8 +75,8 @@ SpannerInterceptorProvider withEncoding(String encoding) { } SpannerInterceptorProvider withTraceContext( - boolean spannerTracingEnabled, OpenTelemetry openTelemetry) { - if (spannerTracingEnabled) { + boolean endToEndTracingEnabled, OpenTelemetry openTelemetry) { + if (endToEndTracingEnabled) { return with(new TraceContextInterceptor(openTelemetry)); } return this; diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java index 7dc2e5ab154..2ebc4925788 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProvider.java @@ -37,7 +37,7 @@ class SpannerMetadataProvider { private final Map, String> headers; private final String resourceHeaderKey; private static final String ROUTE_TO_LEADER_HEADER_KEY = "x-goog-spanner-route-to-leader"; - private static final String SPANNER_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; + private static final String END_TO_END_TRACING_HEADER_KEY = "x-goog-spanner-end-to-end-tracing"; private static final Pattern[] RESOURCE_TOKEN_PATTERNS = { Pattern.compile("^(?projects/[^/]*/instances/[^/]*/databases/[^/]*)(.*)?"), Pattern.compile("^(?projects/[^/]*/instances/[^/]*)(.*)?") @@ -45,8 +45,8 @@ class SpannerMetadataProvider { private static final Map> ROUTE_TO_LEADER_HEADER_MAP = ImmutableMap.of(ROUTE_TO_LEADER_HEADER_KEY, Collections.singletonList("true")); - private static final Map> SPANNER_TRACING_HEADER_MAP = - ImmutableMap.of(SPANNER_TRACING_HEADER_KEY, Collections.singletonList("true")); + private static final Map> END_TO_END_TRACING_HEADER_MAP = + ImmutableMap.of(END_TO_END_TRACING_HEADER_KEY, Collections.singletonList("true")); private SpannerMetadataProvider(Map headers, String resourceHeaderKey) { this.resourceHeaderKey = resourceHeaderKey; @@ -92,8 +92,8 @@ Map> newRouteToLeaderHeader() { return ROUTE_TO_LEADER_HEADER_MAP; } - Map> newSpannerTracingHeader() { - return SPANNER_TRACING_HEADER_MAP; + Map> newEndToEndTracingHeader() { + return END_TO_END_TRACING_HEADER_MAP; } private Map, String> constructHeadersAsMetadata( diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java index 4d9776fe6ec..e8421cd235c 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/SpannerOptionsTest.java @@ -737,21 +737,21 @@ public void testLeaderAwareRoutingEnablement() { } @Test - public void testSpannerTracingEnablement() { + public void testEndToEndTracingEnablement() { // Test that end to end tracing is disabled by default. - assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isSpannerTracingEnabled()); + assertFalse(SpannerOptions.newBuilder().setProjectId("p").build().isEndToEndTracingEnabled()); assertTrue( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableSpannerTracing(true) + .setEnableEndToEndTracing(true) .build() - .isSpannerTracingEnabled()); + .isEndToEndTracingEnabled()); assertFalse( SpannerOptions.newBuilder() .setProjectId("p") - .setEnableSpannerTracing(false) + .setEnableEndToEndTracing(false) .build() - .isSpannerTracingEnabled()); + .isEndToEndTracingEnabled()); } @Test diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index d2760e012be..af459a44e21 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -155,7 +155,7 @@ public class GapicSpannerRpcTest { private static String defaultUserAgent; private static Spanner spanner; private static boolean isRouteToLeader; - private static boolean isSpannerTracing; + private static boolean isEndToEndTracing; private static boolean isTraceContextPresent; @Parameter public Dialect dialect; @@ -215,16 +215,16 @@ public ServerCall.Listener interceptCall( Key.of( "x-goog-spanner-route-to-leader", Metadata.ASCII_STRING_MARSHALLER)); - String spannerTracingHeader = + String endToEndTracingHeader = headers.get( Key.of( "x-goog-spanner-end-to-end-tracing", Metadata.ASCII_STRING_MARSHALLER)); isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); - isSpannerTracing = - (spannerTracingHeader != null - && spannerTracingHeader.equals("true")); + isEndToEndTracing = + (endToEndTracingHeader != null + && endToEndTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); } @@ -248,7 +248,7 @@ public void reset() throws InterruptedException { server.awaitTermination(); } isRouteToLeader = false; - isSpannerTracing = false; + isEndToEndTracing = false; isTraceContextPresent = false; } @@ -491,11 +491,11 @@ public void testNewCallContextWithRouteToLeaderHeaderAndLarDisabled() { } @Test - public void testNewCallContextWithSpannerTracingHeader() { + public void testNewCallContextWithEndToEndTracingHeader() { SpannerOptions options = SpannerOptions.newBuilder() .setProjectId("some-project") - .setEnableSpannerTracing(true) + .setEnableEndToEndTracing(true) .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = @@ -515,11 +515,11 @@ public void testNewCallContextWithSpannerTracingHeader() { } @Test - public void testNewCallContextWithoutSpannerTracingHeader() { + public void testNewCallContextWithoutEndToEndTracingHeader() { SpannerOptions options = SpannerOptions.newBuilder() .setProjectId("some-project") - .setEnableSpannerTracing(false) + .setEnableEndToEndTracing(false) .build(); GapicSpannerRpc rpc = new GapicSpannerRpc(options, false); GrpcCallContext callContext = @@ -534,9 +534,9 @@ public void testNewCallContextWithoutSpannerTracingHeader() { } @Test - public void testSpannerTracingHeaderWithEnabledTracing() { + public void testEndToEndTracingHeaderWithEnabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableSpannerTracing(true).build(); + createSpannerOptions().toBuilder().setEnableEndToEndTracing(true).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -547,13 +547,13 @@ public void testSpannerTracingHeaderWithEnabledTracing() { return null; }); } - assertTrue(isSpannerTracing); + assertTrue(isEndToEndTracing); } @Test - public void testSpannerTracingHeaderWithDisabledTracing() { + public void testEndToEndTracingHeaderWithDisabledTracing() { final SpannerOptions options = - createSpannerOptions().toBuilder().setEnableSpannerTracing(false).build(); + createSpannerOptions().toBuilder().setEnableEndToEndTracing(false).build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = spanner.getDatabaseClient(DatabaseId.of("[PROJECT]", "[INSTANCE]", "[DATABASE]")); @@ -564,7 +564,7 @@ public void testSpannerTracingHeaderWithDisabledTracing() { return null; }); } - assertFalse(isSpannerTracing); + assertFalse(isEndToEndTracing); } @Test @@ -639,7 +639,7 @@ public void testCustomUserAgent() { } @Test - public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingEnabled() { + public void testTraceContextHeaderWithOpenTelemetryAndEndToEndTracingEnabled() { OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) @@ -650,7 +650,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingEnabled() { createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .setEnableSpannerTracing(true) + .setEnableEndToEndTracing(true) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = @@ -665,7 +665,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingEnabled() { } @Test - public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingDisabled() { + public void testTraceContextHeaderWithOpenTelemetryAndEndToEndTracingDisabled() { OpenTelemetry openTelemetry = OpenTelemetrySdk.builder() .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) @@ -676,7 +676,7 @@ public void testTraceContextHeaderWithOpenTelemetryAndSpannerTracingDisabled() { createSpannerOptions() .toBuilder() .setOpenTelemetry(openTelemetry) - .setEnableSpannerTracing(false) + .setEnableEndToEndTracing(false) .build(); try (Spanner spanner = options.getService()) { final DatabaseClient databaseClient = diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java index 36cbbe2d1c4..c4fdd6200af 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/SpannerMetadataProviderTest.java @@ -98,7 +98,7 @@ public void testNewRouteToLeaderHeader() { public void testNewEndToEndTracingHeader() { SpannerMetadataProvider metadataProvider = SpannerMetadataProvider.create(ImmutableMap.of(), "header1"); - Map> extraHeaders = metadataProvider.newSpannerTracingHeader(); + Map> extraHeaders = metadataProvider.newEndToEndTracingHeader(); Map> expectedHeaders = ImmutableMap.>of( "x-goog-spanner-end-to-end-tracing", ImmutableList.of("true")); From a982c690d6d4a2863bf9fb224e846347003a3ad0 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Fri, 27 Sep 2024 06:22:57 +0000 Subject: [PATCH 17/18] fix comments --- .../main/java/com/google/cloud/spanner/SpannerOptions.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index b4631243e4d..25a0689728a 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -1434,8 +1434,8 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { /** * Sets whether to enable end to end tracing. Enabling this option will create the * trace spans at the Spanner layer. By default, end to end tracing is disabled. - * Enabling end to end tracing requires OpenTelemetry to be set up properly. Simply - * enabling this option won't generate traces at Spanner layer. + * Enabling end to end tracing requires OpenTelemetry to be set up. Simply enabling + * this option won't generate traces at Spanner layer. */ public Builder setEnableEndToEndTracing(boolean enableEndToEndTracing) { this.enableEndToEndTracing = enableEndToEndTracing; From 0a2622d0f10e6fb0ac13188b03f3e74036b245f0 Mon Sep 17 00:00:00 2001 From: Naresh Chaudhary Date: Fri, 27 Sep 2024 10:15:06 +0000 Subject: [PATCH 18/18] Fix lint error --- .../com/google/cloud/spanner/SpannerOptions.java | 15 +++++++-------- .../cloud/spanner/spi/v1/GapicSpannerRpcTest.java | 3 +-- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java index 25a0689728a..5756ff64b89 100644 --- a/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java +++ b/google-cloud-spanner/src/main/java/com/google/cloud/spanner/SpannerOptions.java @@ -829,8 +829,7 @@ public static class Builder private boolean enableApiTracing = SpannerOptions.environment.isEnableApiTracing(); private boolean enableExtendedTracing = SpannerOptions.environment.isEnableExtendedTracing(); private boolean enableBuiltInMetrics = SpannerOptions.environment.isEnableBuiltInMetrics(); - private boolean enableEndToEndTracing = - SpannerOptions.environment.isEnableEndToEndTracing(); + private boolean enableEndToEndTracing = SpannerOptions.environment.isEnableEndToEndTracing(); private static String createCustomClientLibToken(String token) { return token + " " + ServiceOptions.getGoogApiClientLibName(); @@ -1432,10 +1431,10 @@ public Builder setEnableExtendedTracing(boolean enableExtendedTracing) { } /** - * Sets whether to enable end to end tracing. Enabling this option will create the - * trace spans at the Spanner layer. By default, end to end tracing is disabled. - * Enabling end to end tracing requires OpenTelemetry to be set up. Simply enabling - * this option won't generate traces at Spanner layer. + * Sets whether to enable end to end tracing. Enabling this option will create the trace spans + * at the Spanner layer. By default, end to end tracing is disabled. Enabling end to end tracing + * requires OpenTelemetry to be set up. Simply enabling this option won't generate traces at + * Spanner layer. */ public Builder setEnableEndToEndTracing(boolean enableEndToEndTracing) { this.enableEndToEndTracing = enableEndToEndTracing; @@ -1774,8 +1773,8 @@ public boolean isEnableExtendedTracing() { } /** - * Returns whether end to end tracing is enabled. If this option is enabled then trace spans - * will be created at the Spanner layer. + * Returns whether end to end tracing is enabled. If this option is enabled then trace spans will + * be created at the Spanner layer. */ public boolean isEndToEndTracingEnabled() { return enableEndToEndTracing; diff --git a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java index af459a44e21..b3ff3b8f1c2 100644 --- a/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java +++ b/google-cloud-spanner/src/test/java/com/google/cloud/spanner/spi/v1/GapicSpannerRpcTest.java @@ -223,8 +223,7 @@ public ServerCall.Listener interceptCall( isRouteToLeader = (routeToLeaderHeader != null && routeToLeaderHeader.equals("true")); isEndToEndTracing = - (endToEndTracingHeader != null - && endToEndTracingHeader.equals("true")); + (endToEndTracingHeader != null && endToEndTracingHeader.equals("true")); } return Contexts.interceptCall(Context.current(), call, headers, next); }