From af5482fe8529ab4c340baaa73359f1ef9fdc1b7f Mon Sep 17 00:00:00 2001 From: Nidhi Nandwani Date: Wed, 18 Nov 2026 06:51:19 +0000 Subject: [PATCH 1/2] feat(storage): log effective gRPC transport configuration for DirectPath over Interconnect [Generated-by: AI] --- .../cloud/storage/GrpcChannelTelemetry.java | 276 +++++++++++++++ .../cloud/storage/GrpcStorageOptions.java | 17 +- .../storage/GrpcChannelTelemetryTest.java | 313 ++++++++++++++++++ 3 files changed, 604 insertions(+), 2 deletions(-) create mode 100644 java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java create mode 100644 java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java new file mode 100644 index 000000000000..6e141e849a80 --- /dev/null +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java @@ -0,0 +1,276 @@ +/* + * Copyright 2026 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 + * + * http://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.storage; + +import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider; +import com.google.common.annotations.VisibleForTesting; +import io.grpc.internal.GrpcUtil; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.checkerframework.checker.nullness.qual.Nullable; + +/** + * Package-private transport classification and startup configuration diagnostics for gRPC channels, + * supporting CloudPath, DirectPath, and DirectPath over Cloud Interconnect. + */ +final class GrpcChannelTelemetry { + + static final String C2P_PREFIX = "google-c2p:///"; + static final String C2P_EXPERIMENTAL_PREFIX = "google-c2p-experimental:///"; + static final String FORCE_XDS_PARAM = "force-xds"; + static final String DIRECT_PATH_INTERCONNECT_HOST = "storage-direct.googleapis.com"; + static final String DIRECT_PATH_INTERCONNECT_PREPROD_HOST = + "storage-preprod-direct.sandbox.googleapis.com"; + + @VisibleForTesting + static final Logger LOG = Logger.getLogger(GrpcChannelTelemetry.class.getName()); + + private static final String DIRECT_PATH_INTERCONNECT_INFIX = "-direct."; + private static final String ENV_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT = + "GOOGLE_CLOUD_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT"; + private static final boolean GRPC_FORCE_XDS_SUPPORTED = detectGrpcForceXdsSupport(); + + /** The transport used to reach the GCS service. */ + enum TransportType { + CLOUD_PATH("CloudPath"), + DIRECT_PATH("DirectPath"), + DIRECT_PATH_INTERCONNECT("DirectPathInterconnect"); + + private final String label; + + TransportType(String label) { + this.label = label; + } + + @Override + public String toString() { + return label; + } + } + + @VisibleForTesting + static boolean hasQueryParameter(@Nullable String uri, String key) { + if (uri == null || key == null) { + return false; + } + int fragmentPos = uri.indexOf('#'); + String addressable = fragmentPos >= 0 ? uri.substring(0, fragmentPos) : uri; + int queryPos = addressable.indexOf('?'); + if (queryPos < 0) { + return false; + } + String query = addressable.substring(queryPos + 1); + int start = 0; + while (start <= query.length()) { + int ampPos = query.indexOf('&', start); + String param = ampPos >= 0 ? query.substring(start, ampPos) : query.substring(start); + int eqPos = param.indexOf('='); + String paramName = eqPos >= 0 ? param.substring(0, eqPos) : param; + if (paramName.equals(key)) { + return true; + } + if (ampPos < 0) { + break; + } + start = ampPos + 1; + } + return false; + } + + @VisibleForTesting + static TransportType detectTransportType(@Nullable String endpoint) { + if (endpoint == null + || (!endpoint.startsWith(C2P_PREFIX) && !endpoint.startsWith(C2P_EXPERIMENTAL_PREFIX))) { + return TransportType.CLOUD_PATH; + } + if (hasQueryParameter(endpoint, FORCE_XDS_PARAM)) { + return TransportType.DIRECT_PATH_INTERCONNECT; + } + return TransportType.DIRECT_PATH; + } + + @VisibleForTesting + static String extractHost(@Nullable String endpointOrAuthority) { + if (endpointOrAuthority == null || endpointOrAuthority.isEmpty()) { + return ""; + } + String normalized = endpointOrAuthority; + if (normalized.startsWith(C2P_EXPERIMENTAL_PREFIX)) { + normalized = C2P_PREFIX + normalized.substring(C2P_EXPERIMENTAL_PREFIX.length()); + } + int queryIdx = normalized.indexOf('?'); + if (queryIdx >= 0) { + normalized = normalized.substring(0, queryIdx); + } + int fragmentIdx = normalized.indexOf('#'); + if (fragmentIdx >= 0) { + normalized = normalized.substring(0, fragmentIdx); + } + String extracted = OpenTelemetryBootstrappingUtils.extractServerAddress(normalized); + return extracted != null ? extracted : ""; + } + + @VisibleForTesting + static boolean isDirectPathInterconnectHost(@Nullable String host) { + String h = extractHost(host); + return DIRECT_PATH_INTERCONNECT_HOST.equals(h) + || DIRECT_PATH_INTERCONNECT_PREPROD_HOST.equals(h); + } + + @VisibleForTesting + static boolean grpcForceXdsIsSupported() { + return GRPC_FORCE_XDS_SUPPORTED; + } + + static boolean isDirectPathInterconnectEnabled(boolean attemptDirectPathXdsOverInterconnect) { + return isDirectPathInterconnectEnabled( + attemptDirectPathXdsOverInterconnect, + System.getenv(ENV_ENABLE_DIRECT_PATH_XDS_OVER_INTERCONNECT)); + } + + @VisibleForTesting + static boolean isDirectPathInterconnectEnabled( + boolean attemptDirectPathXdsOverInterconnect, @Nullable String envValue) { + if (envValue != null) { + String trimmed = envValue.trim(); + if ("true".equalsIgnoreCase(trimmed)) { + return true; + } + if ("false".equalsIgnoreCase(trimmed)) { + return false; + } + } + return attemptDirectPathXdsOverInterconnect; + } + + @VisibleForTesting + static String resolveEffectiveTarget( + InstantiatingGrpcChannelProvider provider, boolean attemptDirectPathXdsOverInterconnect) { + String endpoint = provider.getEndpoint(); + if (endpoint == null) { + return ""; + } + if (endpoint.startsWith(C2P_PREFIX) || endpoint.startsWith(C2P_EXPERIMENTAL_PREFIX)) { + return endpoint; + } + boolean interconnectEnabled = + isDirectPathInterconnectEnabled(attemptDirectPathXdsOverInterconnect); + if (!provider.needsCredentials() + && provider.canUseDirectPath() + && provider.isDirectPathXdsEnabled()) { + String serviceAddress = extractHost(endpoint); + if (interconnectEnabled) { + return C2P_PREFIX + + rewriteDirectPathInterconnectHost(serviceAddress) + + "?" + + FORCE_XDS_PARAM; + } + return C2P_PREFIX + serviceAddress; + } + return endpoint; + } + + @VisibleForTesting + static void logChannelConfiguration( + String effectiveEndpoint, + @Nullable String authority, + boolean interconnectEnabled, + boolean grpcSupportsForceXds) { + TransportType requestedTransport = detectTransportType(effectiveEndpoint); + String effectiveAuthority = + (authority == null || authority.isEmpty()) ? extractHost(effectiveEndpoint) : authority; + String grpcVersion = GrpcUtil.getGrpcBuildVersion().toString(); + + if (!grpcSupportsForceXds + && (interconnectEnabled || requestedTransport == TransportType.DIRECT_PATH_INTERCONNECT)) { + LOG.log( + Level.WARNING, + "DirectPath over Interconnect requires a gRPC version supporting force-xds (found " + + grpcVersion + + "). The force-xds query parameter will be ignored by the google-c2p resolver;" + + " outside GCE this channel will fall back to CloudPath, and on GCE it will use" + + " standard DirectPath. endpoint=" + + effectiveEndpoint); + return; + } + if (interconnectEnabled && requestedTransport != TransportType.DIRECT_PATH_INTERCONNECT) { + LOG.log( + Level.WARNING, + "DirectPath over Interconnect is enabled, but the effective endpoint does not request" + + " it. Check whether a custom endpoint, non-default universe domain, disabled" + + " DirectPath, or unauthenticated credentials overrode the DirectPath over" + + " Interconnect target. requested_transport_type=" + + requestedTransport + + ", endpoint=" + + effectiveEndpoint); + return; + } + if (requestedTransport == TransportType.DIRECT_PATH_INTERCONNECT + && !isDirectPathInterconnectHost(effectiveAuthority)) { + LOG.log( + Level.WARNING, + "DirectPath over Interconnect is active, but the channel authority is not a DirectPath" + + " over Interconnect host; the service will route RPCs as standard DirectPath. Use '" + + DIRECT_PATH_INTERCONNECT_HOST + + "' (or '" + + DIRECT_PATH_INTERCONNECT_PREPROD_HOST + + "' in preprod). requested_transport_type=" + + requestedTransport + + ", endpoint=" + + effectiveEndpoint + + ", authority=" + + effectiveAuthority + + ", grpc_version=" + + grpcVersion); + return; + } + LOG.log( + Level.INFO, + "Configured gRPC transport. requested_transport_type=" + + requestedTransport + + ", endpoint=" + + effectiveEndpoint + + ", authority=" + + effectiveAuthority + + ", grpc_version=" + + grpcVersion); + } + + private GrpcChannelTelemetry() {} + + private static boolean detectGrpcForceXdsSupport() { + try { + Class clazz = Class.forName("io.grpc.googleapis.GoogleCloudToProdNameResolver"); + clazz.getDeclaredField("forceXds"); + return true; + } catch (Throwable e) { + return false; + } + } + + private static String rewriteDirectPathInterconnectHost(String serviceAddress) { + if (!serviceAddress.contains(DIRECT_PATH_INTERCONNECT_INFIX)) { + int dotIndex = serviceAddress.indexOf('.'); + if (dotIndex > 0) { + return serviceAddress.substring(0, dotIndex) + + DIRECT_PATH_INTERCONNECT_INFIX + + serviceAddress.substring(dotIndex + 1); + } + } + return serviceAddress; + } +} diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java index da9623e44416..685a69ea3431 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java @@ -326,7 +326,7 @@ private Tuple> resolveSettingsAndOpts() throw InstantiatingGrpcChannelProvider.newBuilder() .setEndpoint(endpoint) .setAllowNonDefaultServiceAccount(true) - .setAttemptDirectPath(attemptDirectPath || attemptDirectPathXdsOverInterconnect) + .setAttemptDirectPath(attemptDirectPath) .setAttemptDirectPathXdsOverInterconnect(attemptDirectPathXdsOverInterconnect); if (!DIRECT_PATH_BOUND_TOKEN_DISABLED) { @@ -357,7 +357,20 @@ private Tuple> resolveSettingsAndOpts() throw channelProviderBuilder.setChannelConfigurator(channelConfigurator); } - builder.setTransportChannelProvider(channelProviderBuilder.build()); + InstantiatingGrpcChannelProvider baseProvider = channelProviderBuilder.build(); + InstantiatingGrpcChannelProvider telemetryProvider = + (credentials == null || credentials instanceof NoCredentials) + ? baseProvider + : (InstantiatingGrpcChannelProvider) baseProvider.withCredentials(credentials); + boolean interconnectEnabled = + GrpcChannelTelemetry.isDirectPathInterconnectEnabled(attemptDirectPathXdsOverInterconnect); + boolean grpcSupportsForceXds = GrpcChannelTelemetry.grpcForceXdsIsSupported(); + String effectiveTarget = + GrpcChannelTelemetry.resolveEffectiveTarget(telemetryProvider, interconnectEnabled); + GrpcChannelTelemetry.logChannelConfiguration( + effectiveTarget, null, interconnectEnabled, grpcSupportsForceXds); + + builder.setTransportChannelProvider(baseProvider); RetrySettings baseRetrySettings = getRetrySettings(); RetrySettings readRetrySettings = baseRetrySettings.toBuilder() diff --git a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java new file mode 100644 index 000000000000..a476e5d2d7e3 --- /dev/null +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java @@ -0,0 +1,313 @@ +/* + * Copyright 2026 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 + * + * http://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.storage; + +import static com.google.common.truth.Truth.assertThat; + +import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider; +import com.google.auth.oauth2.AccessToken; +import com.google.auth.oauth2.GoogleCredentials; +import com.google.cloud.NoCredentials; +import com.google.cloud.storage.GrpcChannelTelemetry.TransportType; +import com.google.storage.v2.StorageSettings; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.LogRecord; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +public final class GrpcChannelTelemetryTest { + + private CapturingLogHandler logHandler; + private Level previousLevel; + private boolean previousUseParentHandlers; + + @Before + public void setUp() { + logHandler = new CapturingLogHandler(); + previousLevel = GrpcChannelTelemetry.LOG.getLevel(); + previousUseParentHandlers = GrpcChannelTelemetry.LOG.getUseParentHandlers(); + GrpcChannelTelemetry.LOG.setLevel(Level.ALL); + GrpcChannelTelemetry.LOG.setUseParentHandlers(false); + GrpcChannelTelemetry.LOG.addHandler(logHandler); + } + + @After + public void tearDown() { + GrpcChannelTelemetry.LOG.removeHandler(logHandler); + GrpcChannelTelemetry.LOG.setLevel(previousLevel); + GrpcChannelTelemetry.LOG.setUseParentHandlers(previousUseParentHandlers); + } + + @Test + public void detectTransportType_allCases() { + assertThat(GrpcChannelTelemetry.detectTransportType(null)).isEqualTo(TransportType.CLOUD_PATH); + assertThat(GrpcChannelTelemetry.detectTransportType("")).isEqualTo(TransportType.CLOUD_PATH); + assertThat(GrpcChannelTelemetry.detectTransportType("storage.googleapis.com:443")) + .isEqualTo(TransportType.CLOUD_PATH); + assertThat(GrpcChannelTelemetry.detectTransportType("https://storage.googleapis.com")) + .isEqualTo(TransportType.CLOUD_PATH); + assertThat(GrpcChannelTelemetry.detectTransportType("google-c2p:///storage.googleapis.com")) + .isEqualTo(TransportType.DIRECT_PATH); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p-experimental:///storage.googleapis.com")) + .isEqualTo(TransportType.DIRECT_PATH); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage-direct.googleapis.com?force-xds")) + .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage-direct.googleapis.com?foo=1&force-xds=true")) + .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p-experimental:///storage-direct.googleapis.com?force-xds")) + .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage.googleapis.com?other=force-xds")) + .isEqualTo(TransportType.DIRECT_PATH); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage.googleapis.com#force-xds")) + .isEqualTo(TransportType.DIRECT_PATH); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage-direct.googleapis.com?force-xds#section")) + .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); + assertThat( + GrpcChannelTelemetry.detectTransportType( + "google-c2p:///storage.googleapis.com#frag?force-xds=1")) + .isEqualTo(TransportType.DIRECT_PATH); + } + + @Test + public void extractHost_and_isDirectPathInterconnectHost() { + assertThat( + GrpcChannelTelemetry.extractHost( + "google-c2p:///storage-direct.googleapis.com?force-xds")) + .isEqualTo("storage-direct.googleapis.com"); + assertThat( + GrpcChannelTelemetry.extractHost( + "google-c2p-experimental:///storage-preprod-direct.sandbox.googleapis.com:443?force-xds")) + .isEqualTo("storage-preprod-direct.sandbox.googleapis.com"); + assertThat(GrpcChannelTelemetry.extractHost("google-c2p:///storage.googleapis.com/path")) + .isEqualTo("storage.googleapis.com"); + assertThat(GrpcChannelTelemetry.extractHost("google-c2p:///storage.googleapis.com#frag")) + .isEqualTo("storage.googleapis.com"); + assertThat(GrpcChannelTelemetry.extractHost("storage-direct.googleapis.com:443")) + .isEqualTo("storage-direct.googleapis.com"); + assertThat(GrpcChannelTelemetry.extractHost("storage-direct.googleapis.com")) + .isEqualTo("storage-direct.googleapis.com"); + assertThat(GrpcChannelTelemetry.extractHost(null)).isEmpty(); + assertThat(GrpcChannelTelemetry.extractHost("")).isEmpty(); + + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("storage-direct.googleapis.com")) + .isTrue(); + assertThat( + GrpcChannelTelemetry.isDirectPathInterconnectHost("storage-direct.googleapis.com:443")) + .isTrue(); + assertThat( + GrpcChannelTelemetry.isDirectPathInterconnectHost( + "storage-preprod-direct.sandbox.googleapis.com")) + .isTrue(); + assertThat( + GrpcChannelTelemetry.isDirectPathInterconnectHost( + "storage-preprod-direct.sandbox.googleapis.com:443")) + .isTrue(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("storage.googleapis.com")) + .isFalse(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("custom.example.com")).isFalse(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost(null)).isFalse(); + } + + @Test + public void logChannelConfiguration_validConfigurations_logInfo() { + GrpcChannelTelemetry.logChannelConfiguration( + "storage.googleapis.com:443", "storage.googleapis.com", false, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); + assertThat(logHandler.records.get(0).getMessage()) + .contains("Configured gRPC transport. requested_transport_type=CloudPath"); + + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage.googleapis.com", "storage.googleapis.com", false, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); + assertThat(logHandler.records.get(0).getMessage()) + .contains("Configured gRPC transport. requested_transport_type=DirectPath"); + + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage-direct.googleapis.com?force-xds", null, true, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); + assertThat(logHandler.records.get(0).getMessage()) + .contains("Configured gRPC transport. requested_transport_type=DirectPathInterconnect"); + assertThat(logHandler.records.get(0).getMessage()) + .contains("authority=storage-direct.googleapis.com"); + + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds", null, true, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); + assertThat(logHandler.records.get(0).getMessage()) + .contains("authority=storage-preprod-direct.sandbox.googleapis.com"); + } + + @Test + public void logChannelConfiguration_warnings() { + // Priority 1: gRPC version does not support force-xds + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage-direct.googleapis.com?force-xds", null, true, false); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + assertThat(logHandler.records.get(0).getMessage()) + .contains("DirectPath over Interconnect requires a gRPC version supporting force-xds"); + + // Priority 2: interconnectEnabled = true, but effectiveEndpoint is CloudPath or DirectPath + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "storage.googleapis.com:443", "storage.googleapis.com", true, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + assertThat(logHandler.records.get(0).getMessage()) + .contains( + "DirectPath over Interconnect is enabled, but the effective endpoint does not request" + + " it."); + assertThat(logHandler.records.get(0).getMessage()) + .contains("requested_transport_type=CloudPath"); + + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage.googleapis.com", "storage.googleapis.com", true, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + assertThat(logHandler.records.get(0).getMessage()) + .contains("requested_transport_type=DirectPath"); + + // Priority 3: force-xds active, but authority is not a -direct host + logHandler.clear(); + GrpcChannelTelemetry.logChannelConfiguration( + "google-c2p:///storage.googleapis.com?force-xds", "storage.googleapis.com", true, true); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + assertThat(logHandler.records.get(0).getMessage()) + .contains( + "DirectPath over Interconnect is active, but the channel authority is not a DirectPath" + + " over Interconnect host"); + } + + @Test + public void isDirectPathInterconnectEnabled_envPrecedence() { + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, "true")).isTrue(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, " TRUE ")).isTrue(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, "false")).isFalse(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, " FALSE ")).isFalse(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, "invalid")).isTrue(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, "invalid")).isFalse(); + assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, null)).isTrue(); + } + + @Test + public void grpcStorageOptions_attemptDirectPathFalse_overridesDirectPathOverInterconnect() + throws Exception { + GrpcStorageOptions options = + StorageOptions.grpc() + .setAttemptDirectPath(false) + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) + .build(); + + StorageSettings settings = options.getStorageSettings(); + InstantiatingGrpcChannelProvider provider = + (InstantiatingGrpcChannelProvider) + settings.getTransportChannelProvider().withCredentials(options.getCredentials()); + + assertThat(provider.canUseDirectPath()).isFalse(); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(provider, true)) + .isEqualTo("storage.googleapis.com:443"); + + if (!Boolean.parseBoolean(System.getenv("GOOGLE_CLOUD_DISABLE_DIRECT_PATH"))) { + GrpcStorageOptions enabledOptions = + StorageOptions.grpc() + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) + .build(); + InstantiatingGrpcChannelProvider enabledProvider = + (InstantiatingGrpcChannelProvider) + enabledOptions + .getStorageSettings() + .getTransportChannelProvider() + .withCredentials(enabledOptions.getCredentials()); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(enabledProvider, true)) + .isEqualTo("google-c2p:///storage-direct.googleapis.com?force-xds"); + + GrpcStorageOptions preprodOptions = + StorageOptions.grpc() + .setHost("https://storage-preprod.sandbox.googleapis.com") + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) + .build(); + InstantiatingGrpcChannelProvider preprodProvider = + (InstantiatingGrpcChannelProvider) + preprodOptions + .getStorageSettings() + .getTransportChannelProvider() + .withCredentials(preprodOptions.getCredentials()); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(preprodProvider, true)) + .isEqualTo("google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds"); + + GrpcStorageOptions unauthenticatedOptions = + StorageOptions.grpc() + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(NoCredentials.getInstance()) + .build(); + InstantiatingGrpcChannelProvider unauthenticatedProvider = + (InstantiatingGrpcChannelProvider) + unauthenticatedOptions.getStorageSettings().getTransportChannelProvider(); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(unauthenticatedProvider, true)) + .isEqualTo("storage.googleapis.com:443"); + } + } + + private static final class CapturingLogHandler extends Handler { + private final List records = new ArrayList<>(); + + @Override + public void publish(LogRecord record) { + records.add(record); + } + + @Override + public void flush() {} + + @Override + public void close() {} + + void clear() { + records.clear(); + } + } +} From fa143681588216cca3c0002ba8d6e3a003961bf7 Mon Sep 17 00:00:00 2001 From: Nidhi Nandwani Date: Wed, 18 Nov 2026 08:27:02 +0000 Subject: [PATCH 2/2] refactor(storage): streamline GrpcChannelTelemetry configuration diagnostics and tests [Generated-by: AI] --- .../cloud/storage/GrpcChannelTelemetry.java | 37 +- .../cloud/storage/GrpcStorageOptions.java | 12 +- .../storage/GrpcChannelTelemetryTest.java | 363 ++++++++++-------- 3 files changed, 215 insertions(+), 197 deletions(-) diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java index 6e141e849a80..b9c949dbbba5 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java @@ -17,6 +17,8 @@ package com.google.cloud.storage; import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider; +import com.google.auth.Credentials; +import com.google.cloud.NoCredentials; import com.google.common.annotations.VisibleForTesting; import io.grpc.internal.GrpcUtil; import java.util.logging.Level; @@ -62,7 +64,6 @@ public String toString() { } } - @VisibleForTesting static boolean hasQueryParameter(@Nullable String uri, String key) { if (uri == null || key == null) { return false; @@ -91,7 +92,6 @@ static boolean hasQueryParameter(@Nullable String uri, String key) { return false; } - @VisibleForTesting static TransportType detectTransportType(@Nullable String endpoint) { if (endpoint == null || (!endpoint.startsWith(C2P_PREFIX) && !endpoint.startsWith(C2P_EXPERIMENTAL_PREFIX))) { @@ -103,7 +103,6 @@ static TransportType detectTransportType(@Nullable String endpoint) { return TransportType.DIRECT_PATH; } - @VisibleForTesting static String extractHost(@Nullable String endpointOrAuthority) { if (endpointOrAuthority == null || endpointOrAuthority.isEmpty()) { return ""; @@ -124,14 +123,12 @@ static String extractHost(@Nullable String endpointOrAuthority) { return extracted != null ? extracted : ""; } - @VisibleForTesting static boolean isDirectPathInterconnectHost(@Nullable String host) { String h = extractHost(host); return DIRECT_PATH_INTERCONNECT_HOST.equals(h) || DIRECT_PATH_INTERCONNECT_PREPROD_HOST.equals(h); } - @VisibleForTesting static boolean grpcForceXdsIsSupported() { return GRPC_FORCE_XDS_SUPPORTED; } @@ -157,9 +154,8 @@ static boolean isDirectPathInterconnectEnabled( return attemptDirectPathXdsOverInterconnect; } - @VisibleForTesting static String resolveEffectiveTarget( - InstantiatingGrpcChannelProvider provider, boolean attemptDirectPathXdsOverInterconnect) { + InstantiatingGrpcChannelProvider provider, boolean interconnectEnabled) { String endpoint = provider.getEndpoint(); if (endpoint == null) { return ""; @@ -167,8 +163,6 @@ static String resolveEffectiveTarget( if (endpoint.startsWith(C2P_PREFIX) || endpoint.startsWith(C2P_EXPERIMENTAL_PREFIX)) { return endpoint; } - boolean interconnectEnabled = - isDirectPathInterconnectEnabled(attemptDirectPathXdsOverInterconnect); if (!provider.needsCredentials() && provider.canUseDirectPath() && provider.isDirectPathXdsEnabled()) { @@ -184,15 +178,26 @@ static String resolveEffectiveTarget( return endpoint; } - @VisibleForTesting + static String logChannelConfiguration( + InstantiatingGrpcChannelProvider baseProvider, + @Nullable Credentials credentials, + boolean attemptDirectPathXdsOverInterconnect) { + InstantiatingGrpcChannelProvider telemetryProvider = + (credentials == null || credentials instanceof NoCredentials) + ? baseProvider + : (InstantiatingGrpcChannelProvider) baseProvider.withCredentials(credentials); + boolean interconnectEnabled = + isDirectPathInterconnectEnabled(attemptDirectPathXdsOverInterconnect); + boolean grpcSupportsForceXds = grpcForceXdsIsSupported(); + String effectiveTarget = resolveEffectiveTarget(telemetryProvider, interconnectEnabled); + logChannelConfiguration(effectiveTarget, interconnectEnabled, grpcSupportsForceXds); + return effectiveTarget; + } + static void logChannelConfiguration( - String effectiveEndpoint, - @Nullable String authority, - boolean interconnectEnabled, - boolean grpcSupportsForceXds) { + String effectiveEndpoint, boolean interconnectEnabled, boolean grpcSupportsForceXds) { TransportType requestedTransport = detectTransportType(effectiveEndpoint); - String effectiveAuthority = - (authority == null || authority.isEmpty()) ? extractHost(effectiveEndpoint) : authority; + String effectiveAuthority = extractHost(effectiveEndpoint); String grpcVersion = GrpcUtil.getGrpcBuildVersion().toString(); if (!grpcSupportsForceXds diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java index 685a69ea3431..9eb93c6ef9c1 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcStorageOptions.java @@ -358,18 +358,8 @@ private Tuple> resolveSettingsAndOpts() throw } InstantiatingGrpcChannelProvider baseProvider = channelProviderBuilder.build(); - InstantiatingGrpcChannelProvider telemetryProvider = - (credentials == null || credentials instanceof NoCredentials) - ? baseProvider - : (InstantiatingGrpcChannelProvider) baseProvider.withCredentials(credentials); - boolean interconnectEnabled = - GrpcChannelTelemetry.isDirectPathInterconnectEnabled(attemptDirectPathXdsOverInterconnect); - boolean grpcSupportsForceXds = GrpcChannelTelemetry.grpcForceXdsIsSupported(); - String effectiveTarget = - GrpcChannelTelemetry.resolveEffectiveTarget(telemetryProvider, interconnectEnabled); GrpcChannelTelemetry.logChannelConfiguration( - effectiveTarget, null, interconnectEnabled, grpcSupportsForceXds); - + baseProvider, credentials, attemptDirectPathXdsOverInterconnect); builder.setTransportChannelProvider(baseProvider); RetrySettings baseRetrySettings = getRetrySettings(); RetrySettings readRetrySettings = diff --git a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java index a476e5d2d7e3..a6fc9e998904 100644 --- a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java @@ -17,6 +17,8 @@ package com.google.cloud.storage; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth.assertWithMessage; +import static org.junit.Assume.assumeFalse; import com.google.api.gax.grpc.InstantiatingGrpcChannelProvider; import com.google.auth.oauth2.AccessToken; @@ -58,138 +60,132 @@ public void tearDown() { @Test public void detectTransportType_allCases() { - assertThat(GrpcChannelTelemetry.detectTransportType(null)).isEqualTo(TransportType.CLOUD_PATH); - assertThat(GrpcChannelTelemetry.detectTransportType("")).isEqualTo(TransportType.CLOUD_PATH); - assertThat(GrpcChannelTelemetry.detectTransportType("storage.googleapis.com:443")) - .isEqualTo(TransportType.CLOUD_PATH); - assertThat(GrpcChannelTelemetry.detectTransportType("https://storage.googleapis.com")) - .isEqualTo(TransportType.CLOUD_PATH); - assertThat(GrpcChannelTelemetry.detectTransportType("google-c2p:///storage.googleapis.com")) - .isEqualTo(TransportType.DIRECT_PATH); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p-experimental:///storage.googleapis.com")) - .isEqualTo(TransportType.DIRECT_PATH); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage-direct.googleapis.com?force-xds")) - .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage-direct.googleapis.com?foo=1&force-xds=true")) - .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p-experimental:///storage-direct.googleapis.com?force-xds")) - .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage.googleapis.com?other=force-xds")) - .isEqualTo(TransportType.DIRECT_PATH); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage.googleapis.com#force-xds")) - .isEqualTo(TransportType.DIRECT_PATH); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage-direct.googleapis.com?force-xds#section")) - .isEqualTo(TransportType.DIRECT_PATH_INTERCONNECT); - assertThat( - GrpcChannelTelemetry.detectTransportType( - "google-c2p:///storage.googleapis.com#frag?force-xds=1")) - .isEqualTo(TransportType.DIRECT_PATH); + Object[][] cases = { + {null, TransportType.CLOUD_PATH}, + {"", TransportType.CLOUD_PATH}, + {"storage.googleapis.com:443", TransportType.CLOUD_PATH}, + {"https://storage.googleapis.com", TransportType.CLOUD_PATH}, + {"google-c2p:///storage.googleapis.com", TransportType.DIRECT_PATH}, + {"google-c2p-experimental:///storage.googleapis.com", TransportType.DIRECT_PATH}, + { + "google-c2p:///storage-direct.googleapis.com?force-xds", + TransportType.DIRECT_PATH_INTERCONNECT + }, + { + "google-c2p:///storage-direct.googleapis.com?foo=1&force-xds=true", + TransportType.DIRECT_PATH_INTERCONNECT + }, + { + "google-c2p-experimental:///storage-direct.googleapis.com?force-xds", + TransportType.DIRECT_PATH_INTERCONNECT + }, + {"google-c2p:///storage.googleapis.com?other=force-xds", TransportType.DIRECT_PATH}, + {"google-c2p:///storage.googleapis.com#force-xds", TransportType.DIRECT_PATH}, + { + "google-c2p:///storage-direct.googleapis.com?force-xds#section", + TransportType.DIRECT_PATH_INTERCONNECT + }, + {"google-c2p:///storage.googleapis.com#frag?force-xds=1", TransportType.DIRECT_PATH} + }; + for (Object[] c : cases) { + String endpoint = (String) c[0]; + TransportType expected = (TransportType) c[1]; + assertWithMessage("endpoint=%s", endpoint) + .that(GrpcChannelTelemetry.detectTransportType(endpoint)) + .isEqualTo(expected); + } } @Test - public void extractHost_and_isDirectPathInterconnectHost() { - assertThat( - GrpcChannelTelemetry.extractHost( - "google-c2p:///storage-direct.googleapis.com?force-xds")) - .isEqualTo("storage-direct.googleapis.com"); - assertThat( - GrpcChannelTelemetry.extractHost( - "google-c2p-experimental:///storage-preprod-direct.sandbox.googleapis.com:443?force-xds")) - .isEqualTo("storage-preprod-direct.sandbox.googleapis.com"); - assertThat(GrpcChannelTelemetry.extractHost("google-c2p:///storage.googleapis.com/path")) - .isEqualTo("storage.googleapis.com"); - assertThat(GrpcChannelTelemetry.extractHost("google-c2p:///storage.googleapis.com#frag")) - .isEqualTo("storage.googleapis.com"); - assertThat(GrpcChannelTelemetry.extractHost("storage-direct.googleapis.com:443")) - .isEqualTo("storage-direct.googleapis.com"); - assertThat(GrpcChannelTelemetry.extractHost("storage-direct.googleapis.com")) - .isEqualTo("storage-direct.googleapis.com"); - assertThat(GrpcChannelTelemetry.extractHost(null)).isEmpty(); - assertThat(GrpcChannelTelemetry.extractHost("")).isEmpty(); + public void extractHost_extractsNormalizedServerAddress() { + String[][] cases = { + {"google-c2p:///storage-direct.googleapis.com?force-xds", "storage-direct.googleapis.com"}, + { + "google-c2p-experimental:///storage-preprod-direct.sandbox.googleapis.com:443?force-xds", + "storage-preprod-direct.sandbox.googleapis.com" + }, + {"google-c2p:///storage.googleapis.com/path", "storage.googleapis.com"}, + {"google-c2p:///storage.googleapis.com#frag", "storage.googleapis.com"}, + {"storage-direct.googleapis.com:443", "storage-direct.googleapis.com"}, + {"storage-direct.googleapis.com", "storage-direct.googleapis.com"}, + {null, ""}, + {"", ""} + }; + for (String[] c : cases) { + assertWithMessage("input=%s", c[0]) + .that(GrpcChannelTelemetry.extractHost(c[0])) + .isEqualTo(c[1]); + } + } - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("storage-direct.googleapis.com")) - .isTrue(); - assertThat( - GrpcChannelTelemetry.isDirectPathInterconnectHost("storage-direct.googleapis.com:443")) - .isTrue(); - assertThat( - GrpcChannelTelemetry.isDirectPathInterconnectHost( - "storage-preprod-direct.sandbox.googleapis.com")) - .isTrue(); - assertThat( - GrpcChannelTelemetry.isDirectPathInterconnectHost( - "storage-preprod-direct.sandbox.googleapis.com:443")) - .isTrue(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("storage.googleapis.com")) - .isFalse(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost("custom.example.com")).isFalse(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectHost(null)).isFalse(); + @Test + public void isDirectPathInterconnectHost_matchesDirectHostsOnly() { + Object[][] cases = { + {"storage-direct.googleapis.com", true}, + {"storage-direct.googleapis.com:443", true}, + {"storage-preprod-direct.sandbox.googleapis.com", true}, + {"storage-preprod-direct.sandbox.googleapis.com:443", true}, + {"storage.googleapis.com", false}, + {"custom.example.com", false}, + {null, false} + }; + for (Object[] c : cases) { + String host = (String) c[0]; + boolean expected = (Boolean) c[1]; + assertWithMessage("host=%s", host) + .that(GrpcChannelTelemetry.isDirectPathInterconnectHost(host)) + .isEqualTo(expected); + } } @Test public void logChannelConfiguration_validConfigurations_logInfo() { - GrpcChannelTelemetry.logChannelConfiguration( - "storage.googleapis.com:443", "storage.googleapis.com", false, true); - assertThat(logHandler.records).hasSize(1); - assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); - assertThat(logHandler.records.get(0).getMessage()) - .contains("Configured gRPC transport. requested_transport_type=CloudPath"); - - logHandler.clear(); - GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage.googleapis.com", "storage.googleapis.com", false, true); - assertThat(logHandler.records).hasSize(1); - assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); - assertThat(logHandler.records.get(0).getMessage()) - .contains("Configured gRPC transport. requested_transport_type=DirectPath"); - - logHandler.clear(); - GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage-direct.googleapis.com?force-xds", null, true, true); - assertThat(logHandler.records).hasSize(1); - assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); - assertThat(logHandler.records.get(0).getMessage()) - .contains("Configured gRPC transport. requested_transport_type=DirectPathInterconnect"); - assertThat(logHandler.records.get(0).getMessage()) - .contains("authority=storage-direct.googleapis.com"); - - logHandler.clear(); - GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds", null, true, true); - assertThat(logHandler.records).hasSize(1); - assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.INFO); - assertThat(logHandler.records.get(0).getMessage()) - .contains("authority=storage-preprod-direct.sandbox.googleapis.com"); + Object[][] cases = { + {"storage.googleapis.com:443", false, "CloudPath", "storage.googleapis.com"}, + {"google-c2p:///storage.googleapis.com", false, "DirectPath", "storage.googleapis.com"}, + { + "google-c2p:///storage-direct.googleapis.com?force-xds", + true, + "DirectPathInterconnect", + "storage-direct.googleapis.com" + }, + { + "google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds", + true, + "DirectPathInterconnect", + "storage-preprod-direct.sandbox.googleapis.com" + } + }; + for (int i = 0; i < cases.length; i++) { + String endpoint = (String) cases[i][0]; + boolean interconnectEnabled = (Boolean) cases[i][1]; + String expectedTransport = (String) cases[i][2]; + String expectedAuthority = (String) cases[i][3]; + GrpcChannelTelemetry.logChannelConfiguration(endpoint, interconnectEnabled, true); + LogRecord record = logHandler.records.get(i); + assertWithMessage(endpoint).that(record.getLevel()).isEqualTo(Level.INFO); + assertWithMessage(endpoint) + .that(record.getMessage()) + .contains("Configured gRPC transport. requested_transport_type=" + expectedTransport); + assertWithMessage(endpoint) + .that(record.getMessage()) + .contains("authority=" + expectedAuthority); + } } @Test - public void logChannelConfiguration_warnings() { - // Priority 1: gRPC version does not support force-xds + public void logChannelConfiguration_unsupportedGrpcForceXds_logsWarning() { GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage-direct.googleapis.com?force-xds", null, true, false); + "google-c2p:///storage-direct.googleapis.com?force-xds", true, false); assertThat(logHandler.records).hasSize(1); assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); assertThat(logHandler.records.get(0).getMessage()) .contains("DirectPath over Interconnect requires a gRPC version supporting force-xds"); + } - // Priority 2: interconnectEnabled = true, but effectiveEndpoint is CloudPath or DirectPath - logHandler.clear(); - GrpcChannelTelemetry.logChannelConfiguration( - "storage.googleapis.com:443", "storage.googleapis.com", true, true); + @Test + public void logChannelConfiguration_interconnectOverriddenByCloudPath_logsWarning() { + GrpcChannelTelemetry.logChannelConfiguration("storage.googleapis.com:443", true, true); assertThat(logHandler.records).hasSize(1); assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); assertThat(logHandler.records.get(0).getMessage()) @@ -198,19 +194,22 @@ public void logChannelConfiguration_warnings() { + " it."); assertThat(logHandler.records.get(0).getMessage()) .contains("requested_transport_type=CloudPath"); + } - logHandler.clear(); + @Test + public void logChannelConfiguration_interconnectOverriddenByDirectPath_logsWarning() { GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage.googleapis.com", "storage.googleapis.com", true, true); + "google-c2p:///storage.googleapis.com", true, true); assertThat(logHandler.records).hasSize(1); assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); assertThat(logHandler.records.get(0).getMessage()) .contains("requested_transport_type=DirectPath"); + } - // Priority 3: force-xds active, but authority is not a -direct host - logHandler.clear(); + @Test + public void logChannelConfiguration_nonDirectAuthorityWithForceXds_logsWarning() { GrpcChannelTelemetry.logChannelConfiguration( - "google-c2p:///storage.googleapis.com?force-xds", "storage.googleapis.com", true, true); + "google-c2p:///storage.googleapis.com?force-xds", true, true); assertThat(logHandler.records).hasSize(1); assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); assertThat(logHandler.records.get(0).getMessage()) @@ -221,13 +220,23 @@ public void logChannelConfiguration_warnings() { @Test public void isDirectPathInterconnectEnabled_envPrecedence() { - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, "true")).isTrue(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, " TRUE ")).isTrue(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, "false")).isFalse(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, " FALSE ")).isFalse(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, "invalid")).isTrue(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(false, "invalid")).isFalse(); - assertThat(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(true, null)).isTrue(); + Object[][] cases = { + {false, "true", true}, + {false, " TRUE ", true}, + {true, "false", false}, + {true, " FALSE ", false}, + {true, "invalid", true}, + {false, "invalid", false}, + {true, null, true} + }; + for (Object[] c : cases) { + boolean builderOption = (Boolean) c[0]; + String envValue = (String) c[1]; + boolean expected = (Boolean) c[2]; + assertWithMessage("builder=%s, env=%s", builderOption, envValue) + .that(GrpcChannelTelemetry.isDirectPathInterconnectEnabled(builderOption, envValue)) + .isEqualTo(expected); + } } @Test @@ -248,48 +257,66 @@ public void grpcStorageOptions_attemptDirectPathFalse_overridesDirectPathOverInt assertThat(provider.canUseDirectPath()).isFalse(); assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(provider, true)) .isEqualTo("storage.googleapis.com:443"); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + } - if (!Boolean.parseBoolean(System.getenv("GOOGLE_CLOUD_DISABLE_DIRECT_PATH"))) { - GrpcStorageOptions enabledOptions = - StorageOptions.grpc() - .setAttemptDirectPathXdsOverInterconnect(true) - .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) - .build(); - InstantiatingGrpcChannelProvider enabledProvider = - (InstantiatingGrpcChannelProvider) - enabledOptions - .getStorageSettings() - .getTransportChannelProvider() - .withCredentials(enabledOptions.getCredentials()); - assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(enabledProvider, true)) - .isEqualTo("google-c2p:///storage-direct.googleapis.com?force-xds"); + @Test + public void grpcStorageOptions_directPathOverInterconnect_resolvesProdDirectTarget() + throws Exception { + assumeDirectPathNotDisabledByEnv(); + GrpcStorageOptions options = + StorageOptions.grpc() + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) + .build(); + InstantiatingGrpcChannelProvider provider = + (InstantiatingGrpcChannelProvider) + options + .getStorageSettings() + .getTransportChannelProvider() + .withCredentials(options.getCredentials()); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(provider, true)) + .isEqualTo("google-c2p:///storage-direct.googleapis.com?force-xds"); + } + + @Test + public void grpcStorageOptions_directPathOverInterconnect_resolvesPreprodDirectTarget() + throws Exception { + assumeDirectPathNotDisabledByEnv(); + GrpcStorageOptions options = + StorageOptions.grpc() + .setHost("https://storage-preprod.sandbox.googleapis.com") + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) + .build(); + InstantiatingGrpcChannelProvider provider = + (InstantiatingGrpcChannelProvider) + options + .getStorageSettings() + .getTransportChannelProvider() + .withCredentials(options.getCredentials()); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(provider, true)) + .isEqualTo("google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds"); + } - GrpcStorageOptions preprodOptions = - StorageOptions.grpc() - .setHost("https://storage-preprod.sandbox.googleapis.com") - .setAttemptDirectPathXdsOverInterconnect(true) - .setCredentials(GoogleCredentials.create(new AccessToken("fake-token", null))) - .build(); - InstantiatingGrpcChannelProvider preprodProvider = - (InstantiatingGrpcChannelProvider) - preprodOptions - .getStorageSettings() - .getTransportChannelProvider() - .withCredentials(preprodOptions.getCredentials()); - assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(preprodProvider, true)) - .isEqualTo("google-c2p:///storage-preprod-direct.sandbox.googleapis.com?force-xds"); + @Test + public void grpcStorageOptions_noCredentials_fallsBackToCloudPath() throws Exception { + assumeDirectPathNotDisabledByEnv(); + GrpcStorageOptions options = + StorageOptions.grpc() + .setAttemptDirectPathXdsOverInterconnect(true) + .setCredentials(NoCredentials.getInstance()) + .build(); + InstantiatingGrpcChannelProvider provider = + (InstantiatingGrpcChannelProvider) + options.getStorageSettings().getTransportChannelProvider(); + assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(provider, true)) + .isEqualTo("storage.googleapis.com:443"); + } - GrpcStorageOptions unauthenticatedOptions = - StorageOptions.grpc() - .setAttemptDirectPathXdsOverInterconnect(true) - .setCredentials(NoCredentials.getInstance()) - .build(); - InstantiatingGrpcChannelProvider unauthenticatedProvider = - (InstantiatingGrpcChannelProvider) - unauthenticatedOptions.getStorageSettings().getTransportChannelProvider(); - assertThat(GrpcChannelTelemetry.resolveEffectiveTarget(unauthenticatedProvider, true)) - .isEqualTo("storage.googleapis.com:443"); - } + private static void assumeDirectPathNotDisabledByEnv() { + assumeFalse(Boolean.parseBoolean(System.getenv("GOOGLE_CLOUD_DISABLE_DIRECT_PATH"))); } private static final class CapturingLogHandler extends Handler { @@ -305,9 +332,5 @@ public void flush() {} @Override public void close() {} - - void clear() { - records.clear(); - } } }