feat(bigtable): classic direct access checker and it's implementation

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/csm/Metrics.java

@@ -18,6 +18,7 @@
 import com.google.api.gax.tracing.ApiTracerFactory;
 import com.google.cloud.bigtable.data.v2.internal.csm.attributes.ClientInfo;
 import com.google.cloud.bigtable.data.v2.internal.csm.tracers.ChannelPoolMetricsTracer;
+import com.google.cloud.bigtable.data.v2.internal.csm.tracers.DirectPathCompatibleTracer;
 import io.grpc.ManagedChannelBuilder;
 import java.io.Closeable;
 import java.io.IOException;
@@ -31,6 +32,8 @@ public interface Metrics extends Closeable {
   @Nullable
   ChannelPoolMetricsTracer getChannelPoolMetricsTracer();
 
+  DirectPathCompatibleTracer getDirectPathCompatibleTracer();
+
   void start();
 
   @Override

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/csm/MetricsImpl.java

@@ -31,6 +31,9 @@
 import com.google.cloud.bigtable.data.v2.internal.csm.tracers.BuiltinMetricsTracerFactory;
 import com.google.cloud.bigtable.data.v2.internal.csm.tracers.ChannelPoolMetricsTracer;
 import com.google.cloud.bigtable.data.v2.internal.csm.tracers.CompositeTracerFactory;
+import com.google.cloud.bigtable.data.v2.internal.csm.tracers.DefaultDirectPathCompatibleTracer;
+import com.google.cloud.bigtable.data.v2.internal.csm.tracers.DirectPathCompatibleTracer;
+import com.google.cloud.bigtable.data.v2.internal.csm.tracers.NoopDirectPathCompatibleTracer;
 import com.google.cloud.bigtable.data.v2.internal.csm.tracers.Pacemaker;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
@@ -67,6 +70,7 @@ public class MetricsImpl implements Metrics, Closeable {
 
   @Nullable private final GrpcOpenTelemetry grpcOtel;
   @Nullable private final ChannelPoolMetricsTracer channelPoolMetricsTracer;
+  private final DirectPathCompatibleTracer directPathCompatibleTracer;
   @Nullable private final Pacemaker pacemaker;
   private final List<ScheduledFuture<?>> tasks = new ArrayList<>();
 
@@ -94,6 +98,8 @@ public MetricsImpl(
       this.internalRecorder = metricRegistry.newRecorderRegistry(internalOtel.getMeterProvider());
       this.pacemaker = new Pacemaker(internalRecorder, clientInfo, "background");
       this.channelPoolMetricsTracer = new ChannelPoolMetricsTracer(internalRecorder, clientInfo);
+      this.directPathCompatibleTracer =
+          new DefaultDirectPathCompatibleTracer(clientInfo, internalRecorder);
       this.grpcOtel =
           GrpcOpenTelemetry.newBuilder()
               .sdk(internalOtel)
@@ -109,6 +115,7 @@ public MetricsImpl(
       this.grpcOtel = null;
       this.pacemaker = null;
       this.channelPoolMetricsTracer = null;
+      this.directPathCompatibleTracer = NoopDirectPathCompatibleTracer.INSTANCE;
     }
 
     if (userOtel != null) {
@@ -171,6 +178,11 @@ public ChannelPoolMetricsTracer getChannelPoolMetricsTracer() {
     return channelPoolMetricsTracer;
   }
 
+  @Override
+  public DirectPathCompatibleTracer getDirectPathCompatibleTracer() {
+    return directPathCompatibleTracer;
+  }
+
   public static OpenTelemetrySdk createBuiltinOtel(
       MetricRegistry metricRegistry,
       ClientInfo clientInfo,

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/DefaultDirectPathCompatibleTracer.java

@@ -0,0 +1,42 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.internal.csm.tracers;
+
+import com.google.api.core.InternalApi;
+import com.google.cloud.bigtable.data.v2.internal.csm.MetricRegistry;
+import com.google.cloud.bigtable.data.v2.internal.csm.attributes.ClientInfo;
+
+@InternalApi
+public class DefaultDirectPathCompatibleTracer implements DirectPathCompatibleTracer {
+  private final ClientInfo clientInfo;
+  private final MetricRegistry.RecorderRegistry recorder;
+
+  public DefaultDirectPathCompatibleTracer(
+      ClientInfo clientInfo, MetricRegistry.RecorderRegistry recorder) {
+    this.clientInfo = clientInfo;
+    this.recorder = recorder;
+  }
+
+  @Override
+  public void recordSuccess(String ipPreference) {
+    recorder.dpCompatGuage.recordSuccess(clientInfo, ipPreference);
+  }
+
+  @Override
+  public void recordFailure(String reason) {
+    recorder.dpCompatGuage.recordFailure(clientInfo, reason);
+  }
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/DirectPathCompatibleTracer.java

@@ -0,0 +1,37 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.internal.csm.tracers;
+
+import com.google.api.core.InternalApi;
+
+/** Interface for recording DirectPath/DirectAccess eligibility metrics. */
+@InternalApi
+public interface DirectPathCompatibleTracer {
+
+  /**
+   * Records that the environment is eligible and successfully connected via DirectPath.
+   *
+   * @param ipPreference The IP preference used (e.g., "ipv6").
+   */
+  void recordSuccess(String ipPreference);
+
+  /**
+   * Records that the environment is not eligible or failed to connect via DirectPath.
+   *
+   * @param reason The reason for the failure (e.g., "routing_check_failed").
+   */
+  void recordFailure(String reason);
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/csm/tracers/NoopDirectPathCompatibleTracer.java

@@ -0,0 +1,37 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.internal.csm.tracers;
+
+import com.google.api.core.InternalApi;
+
+@InternalApi
+public class NoopDirectPathCompatibleTracer implements DirectPathCompatibleTracer {
+
+  public static final NoopDirectPathCompatibleTracer INSTANCE =
+      new NoopDirectPathCompatibleTracer();
+
+  private NoopDirectPathCompatibleTracer() {}
+
+  @Override
+  public void recordSuccess(String ipPreference) {
+    // No-op
+  }
+
+  @Override
+  public void recordFailure(String reason) {
+    // No-op
+  }
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/dp/ClassicDirectAccessChecker.java

@@ -0,0 +1,91 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.internal.dp;
+
+import com.google.api.core.InternalApi;
+import com.google.bigtable.v2.PeerInfo;
+import com.google.cloud.bigtable.data.v2.internal.csm.tracers.DirectPathCompatibleTracer;
+import com.google.cloud.bigtable.data.v2.stub.MetadataExtractorInterceptor;
+import com.google.cloud.bigtable.gaxx.grpc.ChannelPrimer;
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptors;
+import io.grpc.ManagedChannel;
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Evaluates whether a given channel has Direct Access (DirectPath) routing by executing a RPC and
+ * inspecting the response headers.
+ */
+@InternalApi
+public class ClassicDirectAccessChecker implements DirectAccessChecker {
+  private static final Logger LOG = Logger.getLogger(ClassicDirectAccessChecker.class.getName());
+  private final DirectPathCompatibleTracer tracer;
+  private final ChannelPrimer channelPrimer;
+
+  public ClassicDirectAccessChecker(
+      DirectPathCompatibleTracer tracer, ChannelPrimer channelPrimer) {
+    this.tracer = tracer;
+    this.channelPrimer = channelPrimer;
+  }
+
+  @VisibleForTesting
+  MetadataExtractorInterceptor createInterceptor() {
+    return new MetadataExtractorInterceptor();
+  }
+
+  @Override
+  public boolean check(Supplier<ManagedChannel> supplier) {
+    ManagedChannel channel = null;
+    try {
+      channel = supplier.get();
+      MetadataExtractorInterceptor interceptor = createInterceptor();
+      Channel interceptedChannel = ClientInterceptors.intercept(channel, interceptor);
+      channelPrimer.primeChannel(interceptedChannel);
+
+      // Extract the sideband data populated by the interceptor
+      MetadataExtractorInterceptor.SidebandData sidebandData = interceptor.getSidebandData();
+
+      boolean isEligible =
+          Optional.ofNullable(sidebandData)
+              .map(MetadataExtractorInterceptor.SidebandData::getPeerInfo)
+              .map(PeerInfo::getTransportType)
+              .map(type -> type == PeerInfo.TransportType.TRANSPORT_TYPE_DIRECT_ACCESS)
+              .orElse(false);
+
+      if (isEligible) {
+        String ipProtocolStr =
+            sidebandData.getIpProtocol() != null
+                ? sidebandData.getIpProtocol().toString().toLowerCase()
+                : "unknown";
+        tracer.recordSuccess(ipProtocolStr);
+      }
+
+      return isEligible;
+
+    } catch (Exception e) {
+      LOG.log(Level.FINE, "Failed to evaluate direct access eligibility.", e);
+      return false;
+    } finally {
+      if (channel != null) {
+        channel.shutdownNow();
+      }
+    }
+  }
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/internal/dp/DirectAccessChecker.java

@@ -0,0 +1,32 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.internal.dp;
+
+import com.google.api.core.InternalApi;
+import io.grpc.ManagedChannel;
+import java.util.function.Supplier;
+
+@InternalApi
+/* Evaluates whether a given channel supports Direct Access. */
+public interface DirectAccessChecker {
+  /**
+   * Evaluates if Direct Access is available by creating a test channel.
+   *
+   * @param supplier A supplier to create maybe direct access channel
+   * @return true if the channel is eligible for Direct Access
+   */
+  boolean check(Supplier<ManagedChannel> supplier);
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/stub/BigtableChannelPrimer.java

@@ -26,9 +26,9 @@
 import com.google.cloud.bigtable.gaxx.grpc.ChannelPrimer;
 import io.grpc.CallCredentials;
 import io.grpc.CallOptions;
+import io.grpc.Channel;
 import io.grpc.ClientCall;
 import io.grpc.Deadline;
-import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.auth.MoreCallCredentials;
@@ -88,21 +88,21 @@ static BigtableChannelPrimer create(
   }
 
   @Override
-  public void primeChannel(ManagedChannel managedChannel) {
+  public void primeChannel(Channel channel) {
     try {
-      primeChannelUnsafe(managedChannel);
+      primeChannelUnsafe(channel);
     } catch (IOException | RuntimeException e) {
       LOG.log(Level.WARNING, "Unexpected error while trying to prime a channel", e);
     }
   }
 
-  private void primeChannelUnsafe(ManagedChannel managedChannel) throws IOException {
-    sendPrimeRequestsBlocking(managedChannel);
+  private void primeChannelUnsafe(Channel channel) throws IOException {
+    sendPrimeRequestsBlocking(channel);
   }
 
-  private void sendPrimeRequestsBlocking(ManagedChannel managedChannel) {
+  private void sendPrimeRequestsBlocking(Channel channel) {
     try {
-      sendPrimeRequestsAsync(managedChannel).get(1, TimeUnit.MINUTES);
+      sendPrimeRequestsAsync(channel).get(1, TimeUnit.MINUTES);
     } catch (Throwable e) {
       // TODO: Not sure if we should swallow the error here. We are pre-emptively swapping
       // channels if the new
@@ -112,7 +112,7 @@ private void sendPrimeRequestsBlocking(ManagedChannel managedChannel) {
   }
 
   @Override
-  public ApiFuture<PingAndWarmResponse> sendPrimeRequestsAsync(ManagedChannel managedChannel) {
+  public ApiFuture<PingAndWarmResponse> sendPrimeRequestsAsync(Channel managedChannel) {
     ClientCall<PingAndWarmRequest, PingAndWarmResponse> clientCall =
         managedChannel.newCall(
             BigtableGrpc.getPingAndWarmMethod(),

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/stub/BigtableChannelSupplier.java

@@ -0,0 +1,23 @@
+/*
+ * 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
+ *
+ *     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.bigtable.data.v2.stub;
+
+import com.google.api.core.InternalApi;
+import io.grpc.ManagedChannel;
+import java.util.function.Supplier;
+
+@InternalApi
+public interface BigtableChannelSupplier extends Supplier<ManagedChannel> {}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/data/v2/stub/BigtableClientContext.java

@@ -160,13 +160,14 @@ public static BigtableClientContext create(
                 credentials,
                 builder.getHeaderProvider().getHeaders());
       }
-
       BigtableTransportChannelProvider btTransportProvider =
           BigtableTransportChannelProvider.create(
               transportProvider.build(),
               channelPrimer,
               metrics.getChannelPoolMetricsTracer(),
-              backgroundExecutor);
+              backgroundExecutor,
+              metrics.getDirectPathCompatibleTracer(),
+              builder.isDirectPathEnabledByDefault());
 
       builder.setTransportChannelProvider(btTransportProvider);
     }