Make telemetry logging silent by default

Remove verbose telemetry logs to minimize noise in customer logs.
Only log essential startup/shutdown messages and errors:

Kept (LogLevel.debug):
- "Telemetry: enabled" - on successful initialization
- "Telemetry: disabled" - when feature flag disables it
- "Telemetry: closed" - on graceful shutdown
- Error messages only when failures occur

Removed:
- Individual metric flushing logs
- Export operation logs ("Exporting N metrics")
- Success confirmations ("Successfully exported")
- Client lifecycle logs (creation, ref counting)
- All intermediate operational logs

Updated spec/telemetry-design.md to document the silent logging policy.

Telemetry still functions correctly - exports happen silently in the
background without cluttering customer logs.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: samikshya-db

lib/DBSQLClient.ts

@@ -321,7 +321,7 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
       const enabled = await this.featureFlagCache.isTelemetryEnabled(this.host);
 
       if (!enabled) {
-        this.logger.log(LogLevel.debug, 'Telemetry disabled via feature flag');
+        this.logger.log(LogLevel.debug, 'Telemetry: disabled');
         return;
       }
 
@@ -386,10 +386,10 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient, I
         }
       });
 
-      this.logger.log(LogLevel.debug, 'Telemetry initialized successfully');
+      this.logger.log(LogLevel.debug, 'Telemetry: enabled');
     } catch (error: any) {
       // Swallow all telemetry initialization errors
-      this.logger.log(LogLevel.debug, `Telemetry initialization failed: ${error.message}`);
+      this.logger.log(LogLevel.debug, `Telemetry initialization error: ${error.message}`);
     }
   }
 

lib/telemetry/DatabricksTelemetryExporter.ts

@@ -214,7 +214,6 @@ export default class DatabricksTelemetryExporter {
    */
   private async exportInternal(metrics: TelemetryMetric[]): Promise<void> {
     const config = this.context.getConfig();
-    const logger = this.context.getLogger();
 
     // Determine endpoint based on authentication mode
     const authenticatedExport = config.telemetryAuthenticatedExport ?? DEFAULT_TELEMETRY_CONFIG.authenticatedExport;
@@ -232,13 +231,6 @@ export default class DatabricksTelemetryExporter {
       protoLogs,
     };
 
-    logger.log(
-      LogLevel.debug,
-      `Exporting ${metrics.length} telemetry metrics to ${
-        authenticatedExport ? 'authenticated' : 'unauthenticated'
-      } endpoint`,
-    );
-
     // Get authentication headers if using authenticated endpoint
     const authHeaders = authenticatedExport ? await this.context.getAuthHeaders() : {};
 
@@ -258,8 +250,6 @@ export default class DatabricksTelemetryExporter {
       error.statusCode = response.status;
       throw error;
     }
-
-    logger.log(LogLevel.debug, `Successfully exported ${metrics.length} telemetry metrics`);
   }
 
   /**

lib/telemetry/MetricsAggregator.ts

@@ -347,8 +347,6 @@ export default class MetricsAggregator {
       const metricsToExport = [...this.pendingMetrics];
       this.pendingMetrics = [];
 
-      logger.log(LogLevel.debug, `Flushing ${metricsToExport.length} telemetry metrics`);
-
       // Export metrics (exporter.export never throws)
       this.exporter.export(metricsToExport);
     } catch (error: any) {

lib/telemetry/TelemetryClient.ts

@@ -26,8 +26,7 @@ class TelemetryClient {
   private closed: boolean = false;
 
   constructor(private context: IClientContext, private host: string) {
-    const logger = context.getLogger();
-    logger.log(LogLevel.debug, `Created TelemetryClient for host: ${host}`);
+    // Client created silently
   }
 
   /**
@@ -54,15 +53,13 @@ class TelemetryClient {
     }
 
     try {
-      const logger = this.context.getLogger();
-      logger.log(LogLevel.debug, `Closing TelemetryClient for host: ${this.host}`);
       this.closed = true;
     } catch (error: any) {
       // Swallow all exceptions per requirement
       this.closed = true;
       try {
         const logger = this.context.getLogger();
-        logger.log(LogLevel.debug, `Error closing TelemetryClient: ${error.message}`);
+        logger.log(LogLevel.debug, `Telemetry close error: ${error.message}`);
       } catch (logError: any) {
         // If even logging fails, silently swallow
       }

lib/telemetry/TelemetryClientProvider.ts

@@ -40,8 +40,6 @@ class TelemetryClientProvider {
 
   constructor(private context: IClientContext) {
     this.clients = new Map();
-    const logger = context.getLogger();
-    logger.log(LogLevel.debug, 'Created TelemetryClientProvider');
   }
 
   /**
@@ -52,7 +50,6 @@ class TelemetryClientProvider {
    * @returns The telemetry client for the host
    */
   getOrCreateClient(host: string): TelemetryClient {
-    const logger = this.context.getLogger();
     let holder = this.clients.get(host);
 
     if (!holder) {
@@ -63,12 +60,10 @@ class TelemetryClientProvider {
         refCount: 0,
       };
       this.clients.set(host, holder);
-      logger.log(LogLevel.debug, `Created new TelemetryClient for host: ${host}`);
     }
 
     // Increment reference count
     holder.refCount += 1;
-    logger.log(LogLevel.debug, `TelemetryClient reference count for ${host}: ${holder.refCount}`);
 
     return holder.client;
   }
@@ -84,23 +79,21 @@ class TelemetryClientProvider {
     const holder = this.clients.get(host);
 
     if (!holder) {
-      logger.log(LogLevel.debug, `No TelemetryClient found for host: ${host}`);
       return;
     }
 
     // Decrement reference count
     holder.refCount -= 1;
-    logger.log(LogLevel.debug, `TelemetryClient reference count for ${host}: ${holder.refCount}`);
 
     // Close and remove client when reference count reaches zero
     if (holder.refCount <= 0) {
       try {
         await holder.client.close();
         this.clients.delete(host);
-        logger.log(LogLevel.debug, `Closed and removed TelemetryClient for host: ${host}`);
+        logger.log(LogLevel.debug, 'Telemetry: closed');
       } catch (error: any) {
         // Swallow all exceptions per requirement
-        logger.log(LogLevel.debug, `Error releasing TelemetryClient: ${error.message}`);
+        logger.log(LogLevel.debug, `Telemetry close error: ${error.message}`);
       }
     }
   }

spec/telemetry-design.md

@@ -1843,11 +1843,38 @@ process.on('SIGTERM', async () => {
 - Telemetry failures should never impact the driver's core functionality
 - **Critical**: Circuit breaker must catch errors **before** swallowing
 
+#### Logging Policy - Silent by Default
+
+**Telemetry logging is kept as silent as possible** to avoid noise in customer logs:
+
+**Startup Messages** (LogLevel.debug):
+
+- `Telemetry: enabled` - When telemetry is successfully initialized
+- `Telemetry: disabled` - When feature flag disables telemetry
+
+**Shutdown Messages** (LogLevel.debug):
+
+- `Telemetry: closed` - When telemetry client is closed
+
+**Error Messages** (LogLevel.debug):
+
+- `Telemetry initialization error: <message>` - Only on initialization failures
+- `Telemetry close error: <message>` - Only on cleanup failures
+- `Telemetry export error: <message>` - Only on export failures
+- `Circuit breaker OPEN - dropping telemetry` - Only when circuit breaker opens
+
+**Never Logged**:
+
+- Individual event emissions (connection.open, statement.start, etc.)
+- Metric flushing operations
+- Successful exports
+- Reference counting changes
+- Client creation/lifecycle events
+
 #### Logging Levels
 
-- **TRACE** (console.debug): Use for most telemetry errors (default)
-- **DEBUG** (console.debug): Use only for circuit breaker state changes
-- **WARN/ERROR**: Never use for telemetry errors
+- **DEBUG** (LogLevel.debug): All telemetry messages use this level
+- **WARN/ERROR**: Never used for telemetry - avoids customer anxiety
 
 #### Exception Handling Pattern
 
@@ -1858,8 +1885,8 @@ try {
   // Telemetry operation
   this.telemetryEmitter.emitStatementComplete({ ... });
 } catch (error) {
-  // Swallow ALL exceptions
-  console.debug('[TRACE] Telemetry error:', error);
+  // Swallow ALL exceptions - no logging unless critical
+  logger.log(LogLevel.debug, `Telemetry export error: ${error.message}`);
 }
 ```