Add connection open latency tracking and enable telemetry by default

Changes:
- Track and export connection open latency (session creation time)
- Enable telemetry by default (was false), gated by feature flag
- Update design doc to document connection latency

Implementation:
- DBSQLClient.openSession(): Track start time and calculate latency
- TelemetryEventEmitter: Accept latencyMs in connection event
- MetricsAggregator: Include latency in connection metrics
- DatabricksTelemetryExporter: Export operation_latency_ms for connections

Config changes:
- telemetryEnabled: true by default (in DBSQLClient and types.ts)
- Feature flag check still gates initialization for safe rollout

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: samikshya-chand_data <samikshya.chand@databricks.com>

Author: samikshya-db

lib/DBSQLClient.ts

@@ -118,7 +118,7 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
       useLZ4Compression: true,
 
       // Telemetry defaults
-      telemetryEnabled: false, // Initially disabled for safe rollout
+      telemetryEnabled: true, // Enabled by default, gated by feature flag
       telemetryBatchSize: 100,
       telemetryFlushIntervalMs: 5000,
       telemetryMaxRetries: 3,
@@ -447,6 +447,9 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
    * const session = await client.openSession();
    */
   public async openSession(request: OpenSessionRequest = {}): Promise<IDBSQLSession> {
+    // Track connection open latency
+    const startTime = Date.now();
+
     // Prepare session configuration
     const configuration = request.configuration ? { ...request.configuration } : {};
 
@@ -473,12 +476,14 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
     // Emit connection.open telemetry event
     if (this.telemetryEmitter && this.host) {
       try {
+        const latencyMs = Date.now() - startTime;
         const workspaceId = this.extractWorkspaceId(this.host);
         const driverConfig = this.buildDriverConfiguration();
         this.telemetryEmitter.emitConnectionOpen({
           sessionId: session.id,
           workspaceId,
           driverConfig,
+          latencyMs,
         });
       } catch (error: any) {
         // CRITICAL: All telemetry exceptions swallowed

lib/telemetry/DatabricksTelemetryExporter.ts

@@ -289,6 +289,10 @@ export default class DatabricksTelemetryExporter {
         char_set_encoding: metric.driverConfig.charSetEncoding,
         process_name: metric.driverConfig.processName,
       };
+      // Include connection open latency
+      if (metric.latencyMs !== undefined) {
+        log.entry.sql_driver_log.operation_latency_ms = metric.latencyMs;
+      }
     } else if (metric.metricType === 'statement') {
       log.entry.sql_driver_log.operation_latency_ms = metric.latencyMs;
 

lib/telemetry/MetricsAggregator.ts

@@ -124,6 +124,7 @@ export default class MetricsAggregator {
       sessionId: event.sessionId,
       workspaceId: event.workspaceId,
       driverConfig: event.driverConfig,
+      latencyMs: event.latencyMs,
     };
 
     this.addPendingMetric(metric);

lib/telemetry/TelemetryEventEmitter.ts

@@ -45,7 +45,12 @@ export default class TelemetryEventEmitter extends EventEmitter {
    *
    * @param data Connection event data including sessionId, workspaceId, and driverConfig
    */
-  emitConnectionOpen(data: { sessionId: string; workspaceId: string; driverConfig: DriverConfiguration }): void {
+  emitConnectionOpen(data: {
+    sessionId: string;
+    workspaceId: string;
+    driverConfig: DriverConfiguration;
+    latencyMs: number;
+  }): void {
     if (!this.enabled) return;
 
     const logger = this.context.getLogger();
@@ -56,6 +61,7 @@ export default class TelemetryEventEmitter extends EventEmitter {
         sessionId: data.sessionId,
         workspaceId: data.workspaceId,
         driverConfig: data.driverConfig,
+        latencyMs: data.latencyMs,
       };
       this.emit(TelemetryEventType.CONNECTION_OPEN, event);
     } catch (error: any) {

lib/telemetry/types.ts

@@ -65,7 +65,7 @@ export interface TelemetryConfiguration {
  * Default telemetry configuration values
  */
 export const DEFAULT_TELEMETRY_CONFIG: Required<TelemetryConfiguration> = {
-  enabled: false, // Initially disabled for safe rollout
+  enabled: true, // Enabled by default, gated by feature flag
   batchSize: 100,
   flushIntervalMs: 5000,
   maxRetries: 3,

spec/telemetry-design.md

@@ -1212,7 +1212,7 @@ The driver emits events at key operations:
 
 | Event | When | Data Collected |
 |-------|------|----------------|
-| `connection.open` | Connection established | session_id, workspace_id, driver config |
+| `connection.open` | Session opened | session_id, workspace_id, driver config, latency_ms |
 | `statement.start` | Statement execution begins | statement_id, session_id, operation_type |
 | `statement.complete` | Statement execution ends | statement_id, latency, result_format, poll_count |
 | `cloudfetch.chunk` | CloudFetch chunk downloaded | statement_id, chunk_index, latency, bytes |