perf(spanner): disable gRPC channelz by default

handwritten/spanner/src/index.ts

@@ -155,6 +155,8 @@
  * DirectedReadOptions won't be set for readWrite transactions"
  * @property {ObservabilityOptions} [observabilityOptions] Sets the observability options to be used for OpenTelemetry tracing
  * @property {boolean} [disableBuiltInMetrics=True] If set to true, built-in metrics will be disabled.
+ * @property {number} ['grpc.enable_channelz'=0] Whether to enable gRPC Channelz service tracking.
+ * Defaults to 0 (disabled) to eliminate per-RPC tracking and allocation overhead. Set to 1 to enable.
  */
 export interface SpannerOptions extends GrpcClientOptions {
   apiEndpoint?: string;
@@ -169,7 +171,7 @@
   >;
   observabilityOptions?: ObservabilityOptions;
   disableBuiltInMetrics?: boolean;
   interceptors?: any[];
   sessionLabels?: {[key: string]: string};
   /**
    * The Trusted Cloud Domain (TPC) DNS of the service used to make requests.
@@ -182,6 +184,12 @@
    */
   universe_domain?: string;
   universeDomain?: string;
+  /**
+   * Whether to enable gRPC Channelz service tracking.
+   * Defaults to `0` (disabled) to eliminate per-RPC allocation and tracking overhead.
+   * Set to `1` if live connection introspection via gRPC Channelz (e.g. grpcdebug) is required.
+   */
+  'grpc.enable_channelz'?: number;
 }
 export interface RequestConfig {
   client: string;
@@ -423,6 +431,8 @@
         scopes,
         // Add grpc keep alive setting
         'grpc.keepalive_time_ms': 120000,
+        // Disable Channelz by default to reduce per-RPC tracking and allocation overhead
+        'grpc.enable_channelz': 0,
         // Enable grpc-gcp support
         'grpc.callInvocationTransformer': grpcGcp.gcpCallInvocationTransformer,
         'grpc.channelFactoryOverride': grpcGcp.gcpChannelFactoryOverride,
@@ -534,7 +544,7 @@
     if (!this.clients_.has(clientName)) {
       this.clients_.set(
         clientName,
-        new v1[clientName](this.options as ClientOptions),
+        new v1.InstanceAdminClient(this.options as ClientOptions),
       );
     }
     return this.clients_.get(clientName)! as v1.InstanceAdminClient;
@@ -558,7 +568,7 @@
     if (!this.clients_.has(clientName)) {
       this.clients_.set(
         clientName,
-        new v1[clientName](this.options as ClientOptions),
+        new v1.DatabaseAdminClient(this.options as ClientOptions),
       );
     }
     return this.clients_.get(clientName)! as v1.DatabaseAdminClient;
@@ -615,10 +625,9 @@
 
     if (callback) {
       // process.nextTick prevents Unhandled Promise Rejections if callback throws
-      res.then(
-        () => process.nextTick(() => callback(null)),
-        err => process.nextTick(() => callback(err)),
-      );
+      res
+        .then(() => process.nextTick(() => callback(null)))
+        .catch(err => process.nextTick(() => callback(err)));
     } else {
       return res;
     }
@@ -1727,7 +1736,10 @@
       const clientName = config.client;
       try {
         if (!this.clients_.has(clientName)) {
-          this.clients_.set(clientName, new v1[clientName](this.options));
+          this.clients_.set(
+            clientName,
+            new (v1 as Record<string, any>)[clientName](this.options),
+          );
         }
       } catch (err) {
         callback(err, null);
@@ -1773,7 +1785,7 @@
         // Attach the x-goog-spanner-request-id to the currently active span.
         attributeXGoogSpannerRequestIdToActiveSpan(config);
       }
       const interceptors: any[] = [];
       if (this._metricsEnabled) {
         interceptors.push(MetricInterceptor);
       }
@@ -1828,7 +1840,7 @@
             }
 
             return new Promise((resolve, reject) => {
               requestFn(...args)
                 .then(resolve)
                 .catch(err => {
                   injectRequestIDIntoError(config, err as Error);
@@ -1892,10 +1904,11 @@
           } else {
             const result = requestFn();
             if (result && typeof result.then === 'function') {
               result
                 .then(val => {
                   metricsTracer?.recordOperationCompletion();
                   resolve(val);
+                  return val;
                 })
                 .catch(error => {
                   metricsTracer?.recordOperationCompletion();

handwritten/spanner/test/index.ts

@@ -230,6 +230,7 @@
       scopes: [],
       grpc,
       'grpc.keepalive_time_ms': 120000,
+      'grpc.enable_channelz': 0,
       'grpc.callInvocationTransformer':
         fakeGrpcGcp().gcpCallInvocationTransformer,
       'grpc.channelFactoryOverride': fakeGrpcGcp().gcpChannelFactoryOverride,
@@ -295,6 +296,22 @@
       );
     });
 
+    it('should disable channelz by default and allow overriding it', () => {
+      const spannerDefault = new Spanner(OPTIONS);
+      assert.strictEqual(
+        (spannerDefault.options as any)['grpc.enable_channelz'],
+        0,
+      );
+
+      const spannerEnabled = new Spanner(
+        Object.assign({}, OPTIONS, {'grpc.enable_channelz': 1}),
+      );
+      assert.strictEqual(
+        (spannerEnabled.options as any)['grpc.enable_channelz'],
+        1,
+      );
+    });
+
     it('should inherit from GrpcService', () => {
       assert(spanner instanceof FakeGrpcService);
 
@@ -2314,6 +2331,7 @@
 
         return spanner.request(CONFIG).then(result => {
           assert.strictEqual(result, gapicRequestFnResult);
+          return result;
         });
       });
     });

handwritten/spanner/test/spanner.ts

@@ -30,6 +30,7 @@ import {
   Snapshot,
   Spanner,
   Transaction,
+  v1 as gapicV1,
 } from '../src';
 import * as mock from './mockserver/mockspanner';
 import {
@@ -386,6 +387,49 @@ describe('Spanner with mock server', () => {
       assert.notStrictEqual(dbWithDefaultOptions, dbWithWriteSessions);
     });
 
+    it('should disable channelz by default and allow overriding it', async () => {
+      assert.strictEqual((spanner.options as any)['grpc.enable_channelz'], 0);
+
+      const client = new gapicV1.SpannerClient(spanner.options as any);
+      await client.initialize();
+      const stub = (await (client as any).spannerStub) as any;
+      const channel = stub.getChannel();
+      const pooledChannel = channel.channelRefs?.[0]?.channel as any;
+      assert.ok(pooledChannel, 'Expected pooledChannel to be initialized');
+      assert.strictEqual(pooledChannel.internalChannel?.channelzEnabled, false);
+
+      const customSpanner = new Spanner({
+        servicePath: 'localhost',
+        port,
+        sslCreds: grpc.credentials.createInsecure(),
+        'grpc.enable_channelz': 1,
+      });
+      try {
+        assert.strictEqual(
+          (customSpanner.options as any)['grpc.enable_channelz'],
+          1,
+        );
+        const customClient = new gapicV1.SpannerClient(
+          customSpanner.options as any,
+        );
+        await customClient.initialize();
+        const customStub = (await (customClient as any).spannerStub) as any;
+        const customChannel = customStub.getChannel();
+        const customPooledChannel = customChannel.channelRefs?.[0]
+          ?.channel as any;
+        assert.ok(
+          customPooledChannel,
+          'Expected customPooledChannel to be initialized',
+        );
+        assert.strictEqual(
+          customPooledChannel.internalChannel?.channelzEnabled,
+          true,
+        );
+      } finally {
+        await customSpanner.close();
+      }
+    });
+
     it('should execute query', async () => {
       // The query to execute
       const query = {