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..b9c949dbbba5 --- /dev/null +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/GrpcChannelTelemetry.java @@ -0,0 +1,281 @@ +/* + * 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.auth.Credentials; +import com.google.cloud.NoCredentials; +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; + } + } + + 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; + } + + 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; + } + + 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 : ""; + } + + static boolean isDirectPathInterconnectHost(@Nullable String host) { + String h = extractHost(host); + return DIRECT_PATH_INTERCONNECT_HOST.equals(h) + || DIRECT_PATH_INTERCONNECT_PREPROD_HOST.equals(h); + } + + 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; + } + + static String resolveEffectiveTarget( + InstantiatingGrpcChannelProvider provider, boolean interconnectEnabled) { + String endpoint = provider.getEndpoint(); + if (endpoint == null) { + return ""; + } + if (endpoint.startsWith(C2P_PREFIX) || endpoint.startsWith(C2P_EXPERIMENTAL_PREFIX)) { + return endpoint; + } + 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; + } + + 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, boolean interconnectEnabled, boolean grpcSupportsForceXds) { + TransportType requestedTransport = detectTransportType(effectiveEndpoint); + String effectiveAuthority = extractHost(effectiveEndpoint); + 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..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 @@ -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,10 @@ private Tuple> resolveSettingsAndOpts() throw channelProviderBuilder.setChannelConfigurator(channelConfigurator); } - builder.setTransportChannelProvider(channelProviderBuilder.build()); + InstantiatingGrpcChannelProvider baseProvider = channelProviderBuilder.build(); + GrpcChannelTelemetry.logChannelConfiguration( + baseProvider, credentials, attemptDirectPathXdsOverInterconnect); + 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..a6fc9e998904 --- /dev/null +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/GrpcChannelTelemetryTest.java @@ -0,0 +1,336 @@ +/* + * 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 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; +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() { + 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_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]); + } + } + + @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() { + 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_unsupportedGrpcForceXds_logsWarning() { + GrpcChannelTelemetry.logChannelConfiguration( + "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"); + } + + @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()) + .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"); + } + + @Test + public void logChannelConfiguration_interconnectOverriddenByDirectPath_logsWarning() { + GrpcChannelTelemetry.logChannelConfiguration( + "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"); + } + + @Test + public void logChannelConfiguration_nonDirectAuthorityWithForceXds_logsWarning() { + GrpcChannelTelemetry.logChannelConfiguration( + "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()) + .contains( + "DirectPath over Interconnect is active, but the channel authority is not a DirectPath" + + " over Interconnect host"); + } + + @Test + public void isDirectPathInterconnectEnabled_envPrecedence() { + 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 + 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"); + assertThat(logHandler.records).hasSize(1); + assertThat(logHandler.records.get(0).getLevel()).isEqualTo(Level.WARNING); + } + + @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"); + } + + @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"); + } + + private static void assumeDirectPathNotDisabledByEnv() { + assumeFalse(Boolean.parseBoolean(System.getenv("GOOGLE_CLOUD_DISABLE_DIRECT_PATH"))); + } + + 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() {} + } +}