[telemetry improvement]: emit sql_operation, auth_type, driver_connection_params - ship even if null

lib/DBSQLClient.ts

@@ -112,6 +112,8 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
 
   private authType?: string;
 
+  private useProxy?: boolean;
+
   private telemetryClient?: TelemetryClient;
 
   private telemetryEmitter?: TelemetryEventEmitter;
@@ -415,6 +417,7 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
       // Connection parameters
       httpPath: this.httpPath,
       enableMetricViewMetadata: this.config.enableMetricViewMetadata,
+      useProxy: this.useProxy,
     };
   }
 
@@ -594,6 +597,7 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
     this.host = options.host;
     this.httpPath = options.path;
     this.authType = this.mapAuthType(options);
+    this.useProxy = Boolean(options.proxy);
 
     // Store enableMetricViewMetadata configuration
     if (options.enableMetricViewMetadata !== undefined) {

lib/telemetry/DatabricksTelemetryExporter.ts

@@ -60,9 +60,24 @@ interface DatabricksTelemetryLog {
         char_set_encoding?: string;
         process_name?: string;
       };
+      auth_type?: string;
+      driver_connection_params?: {
+        host_info?: { host_url?: string };
+        http_path?: string;
+        mode?: string;
+        use_proxy?: boolean;
+        enable_arrow?: boolean;
+        enable_direct_results?: boolean;
+        socket_timeout?: number;
+        enable_metric_view_metadata?: boolean;
+      };
       operation_latency_ms?: number;
       sql_operation?: {
         execution_result?: string;
+        is_compressed?: boolean;
+        operation_detail?: {
+          operation_type?: string;
+        };
         chunk_details?: {
           total_chunks_present?: number;
           total_chunks_iterated?: number;
@@ -368,6 +383,11 @@ export default class DatabricksTelemetryExporter {
       if (metric.latencyMs !== undefined) {
         log.entry.sql_driver_log.operation_latency_ms = metric.latencyMs;
       }
+      if (metric.operationType) {
+        log.entry.sql_driver_log.sql_operation = {
+          operation_detail: { operation_type: metric.operationType },
+        };
+      }
       if (metric.driverConfig && includeCorrelation) {
         // system_configuration is a high-entropy client fingerprint (OS, arch,
         // locale, process, runtime). Only ship on the authenticated path.
@@ -384,15 +404,47 @@ export default class DatabricksTelemetryExporter {
           char_set_encoding: metric.driverConfig.charSetEncoding,
           process_name: sanitizeProcessName(metric.driverConfig.processName) || undefined,
         };
+
+        // auth_type and host/http-path are workspace-correlated, so they ride
+        // the same auth-only path as system_configuration.
+        if (metric.driverConfig.authType) {
+          log.entry.sql_driver_log.auth_type = metric.driverConfig.authType;
+        }
+        log.entry.sql_driver_log.driver_connection_params = {
+          host_info: { host_url: this.host },
+          http_path: metric.driverConfig.httpPath,
+          mode: 'THRIFT',
+          use_proxy: metric.driverConfig.useProxy,
+          enable_arrow: metric.driverConfig.arrowEnabled,
+          enable_direct_results: metric.driverConfig.directResultsEnabled,
+          // The proto `socket_timeout` field is defined in seconds, but the driver
+          // tracks socketTimeout in milliseconds — convert so the receiver records
+          // the correct unit (e.g. 900000ms -> 900s) instead of treating ms as seconds.
+          socket_timeout:
+            typeof metric.driverConfig.socketTimeout === 'number'
+              ? Math.round(metric.driverConfig.socketTimeout / 1000)
+              : metric.driverConfig.socketTimeout,
+          enable_metric_view_metadata: metric.driverConfig.enableMetricViewMetadata,
+        };
       }
     } else if (metric.metricType === 'statement') {
       log.entry.sql_driver_log.operation_latency_ms = metric.latencyMs;
 
-      if (metric.resultFormat || metric.chunkCount) {
+      if (metric.resultFormat || metric.chunkCount || metric.operationType || metric.compressed !== undefined) {
         log.entry.sql_driver_log.sql_operation = {
           execution_result: metric.resultFormat,
         };
 
+        if (metric.compressed !== undefined) {
+          log.entry.sql_driver_log.sql_operation.is_compressed = metric.compressed;
+        }
+
+        if (metric.operationType) {
+          log.entry.sql_driver_log.sql_operation.operation_detail = {
+            operation_type: metric.operationType,
+          };
+        }
+
         if ((metric.chunkCount ?? 0) > 0) {
           log.entry.sql_driver_log.sql_operation.chunk_details = {
             total_chunks_present: metric.chunkCount,

lib/telemetry/telemetryTypeMappers.ts

@@ -51,9 +51,9 @@ export function mapOperationTypeToTelemetryType(operationType?: TOperationType):
 /**
  * Map Thrift TSparkRowSetType to telemetry ExecutionResult.Format enum string.
  */
-export function mapResultFormatToTelemetryType(resultFormat?: TSparkRowSetType): string | undefined {
+export function mapResultFormatToTelemetryType(resultFormat?: TSparkRowSetType): string {
   if (resultFormat === undefined) {
-    return undefined;
+    return 'FORMAT_UNSPECIFIED';
   }
 
   switch (resultFormat) {

lib/telemetry/types.ts

@@ -319,6 +319,9 @@ export interface DriverConfiguration {
 
   /** Whether metric view metadata is enabled */
   enableMetricViewMetadata?: boolean;
+
+  /** Whether an HTTP/SOCKS proxy is configured on the connection */
+  useProxy?: boolean;
 }
 
 /**

tests/unit/telemetry/DatabricksTelemetryExporter.test.ts

@@ -162,6 +162,51 @@ describe('DatabricksTelemetryExporter', () => {
     });
   });
 
+  describe('export() - driver_connection_params', () => {
+    // The driver tracks socketTimeout in milliseconds, but the receiver proto
+    // defines `socket_timeout` in seconds. Lock in the ms -> s conversion so a
+    // 15-minute (900000ms) timeout is reported as 900s, not 900000s.
+    function getConnectionParams(sendRequestStub: sinon.SinonStub): any {
+      const init = sendRequestStub.firstCall.args[1] as { body: string };
+      const body = JSON.parse(init.body);
+      const log = JSON.parse(body.protoLogs[0]);
+      return log.entry.sql_driver_log.driver_connection_params;
+    }
+
+    function makeConnectionMetric(socketTimeout: number): TelemetryMetric {
+      return makeMetric({
+        metricType: 'connection',
+        driverConfig: {
+          driverName: 'nodejs-sql-driver',
+          driverVersion: '1.14.0',
+          socketTimeout,
+        } as any,
+      });
+    }
+
+    it('converts socketTimeout from milliseconds to seconds', async () => {
+      const context = new ClientContextStub({ telemetryAuthenticatedExport: true } as any);
+      const registry = new CircuitBreakerRegistry(context);
+      const exporter = new DatabricksTelemetryExporter(context, 'host.example.com', registry, fakeAuthProvider);
+      const sendRequestStub = sinon.stub(exporter as any, 'sendRequest').returns(makeOkResponse());
+
+      await exporter.export([makeConnectionMetric(900000)]);
+
+      expect(getConnectionParams(sendRequestStub).socket_timeout).to.equal(900);
+    });
+
+    it('rounds sub-second socketTimeout values', async () => {
+      const context = new ClientContextStub({ telemetryAuthenticatedExport: true } as any);
+      const registry = new CircuitBreakerRegistry(context);
+      const exporter = new DatabricksTelemetryExporter(context, 'host.example.com', registry, fakeAuthProvider);
+      const sendRequestStub = sinon.stub(exporter as any, 'sendRequest').returns(makeOkResponse());
+
+      await exporter.export([makeConnectionMetric(1500)]);
+
+      expect(getConnectionParams(sendRequestStub).socket_timeout).to.equal(2);
+    });
+  });
+
   describe('export() - retry logic', () => {
     it('should retry on retryable HTTP errors (503)', async () => {
       const context = new ClientContextStub({ telemetryMaxRetries: 2 } as any);