Fix feature flag endpoint and telemetry export

- Use NODEJS client type instead of OSS_NODEJS for feature flags
- Use /telemetry-ext and /telemetry-unauth (not /api/2.0/sql/...)
- Update payload to match proto: system_configuration with snake_case
- Add URL utility to handle protocol correctly

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

Author: samikshya-db

lib/telemetry/DatabricksTelemetryExporter.ts

@@ -20,6 +20,7 @@ import { LogLevel } from '../contracts/IDBSQLLogger';
 import { TelemetryMetric, DEFAULT_TELEMETRY_CONFIG } from './types';
 import { CircuitBreakerRegistry } from './CircuitBreaker';
 import ExceptionClassifier from './ExceptionClassifier';
+import { buildUrl } from './urlUtils';
 
 /**
  * Databricks telemetry log format for export.
@@ -37,19 +38,33 @@ interface DatabricksTelemetryLog {
     sql_driver_log: {
       session_id?: string;
       sql_statement_id?: string;
+      system_configuration?: {
+        driver_version?: string;
+        runtime_name?: string;
+        runtime_version?: string;
+        runtime_vendor?: string;
+        os_name?: string;
+        os_version?: string;
+        os_arch?: string;
+        driver_name?: string;
+        client_app_name?: string;
+      };
+      driver_connection_params?: any;
       operation_latency_ms?: number;
       sql_operation?: {
-        execution_result_format?: string;
+        execution_result?: string;
         chunk_details?: {
-          chunk_count: number;
-          total_bytes?: number;
+          total_chunks_present?: number;
+          total_chunks_iterated?: number;
+          initial_chunk_latency_millis?: number;
+          slowest_chunk_latency_millis?: number;
+          sum_chunks_download_time_millis?: number;
         };
       };
       error_info?: {
         error_name: string;
         stack_trace: string;
       };
-      driver_config?: any;
     };
   };
 }
@@ -190,8 +205,8 @@ export default class DatabricksTelemetryExporter {
     const authenticatedExport =
       config.telemetryAuthenticatedExport ?? DEFAULT_TELEMETRY_CONFIG.authenticatedExport;
     const endpoint = authenticatedExport
-      ? `https://${this.host}/api/2.0/sql/telemetry-ext`
-      : `https://${this.host}/api/2.0/sql/telemetry-unauth`;
+      ? buildUrl(this.host, '/telemetry-ext')
+      : buildUrl(this.host, '/telemetry-unauth');
 
     // Format payload
     const payload: DatabricksTelemetryPayload = {
@@ -206,7 +221,7 @@ export default class DatabricksTelemetryExporter {
     // Get authentication headers if using authenticated endpoint
     const authHeaders = authenticatedExport ? await this.context.getAuthHeaders() : {};
 
-    // Make HTTP POST request
+    // Make HTTP POST request with authentication
     const response: Response = await this.fetchFn(endpoint, {
       method: 'POST',
       headers: {
@@ -231,7 +246,7 @@ export default class DatabricksTelemetryExporter {
    */
   private toTelemetryLog(metric: TelemetryMetric): DatabricksTelemetryLog {
     const log: DatabricksTelemetryLog = {
-      workspace_id: metric.workspaceId,
+      // workspace_id: metric.workspaceId, // TODO: Determine if this should be numeric or omitted
       frontend_log_event_id: this.generateUUID(),
       context: {
         client_context: {
@@ -247,21 +262,29 @@ export default class DatabricksTelemetryExporter {
       },
     };
 
-    // Add metric-specific fields
+    // Add metric-specific fields based on proto definition
     if (metric.metricType === 'connection' && metric.driverConfig) {
-      log.entry.sql_driver_log.driver_config = metric.driverConfig;
+      // Map driverConfig to system_configuration (snake_case as per proto)
+      log.entry.sql_driver_log.system_configuration = {
+        driver_version: metric.driverConfig.driverVersion,
+        driver_name: metric.driverConfig.driverName,
+        runtime_name: 'Node.js',
+        runtime_version: metric.driverConfig.nodeVersion,
+        os_name: metric.driverConfig.platform,
+        os_version: metric.driverConfig.osVersion,
+      };
     } else if (metric.metricType === 'statement') {
       log.entry.sql_driver_log.operation_latency_ms = metric.latencyMs;
 
       if (metric.resultFormat || metric.chunkCount) {
         log.entry.sql_driver_log.sql_operation = {
-          execution_result_format: metric.resultFormat,
+          execution_result: metric.resultFormat,
         };
 
         if (metric.chunkCount && metric.chunkCount > 0) {
           log.entry.sql_driver_log.sql_operation.chunk_details = {
-            chunk_count: metric.chunkCount,
-            total_bytes: metric.bytesDownloaded,
+            total_chunks_present: metric.chunkCount,
+            total_chunks_iterated: metric.chunkCount,
           };
         }
       }

lib/telemetry/FeatureFlagCache.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-import fetch from 'node-fetch';
 import IClientContext from '../contracts/IClientContext';
 import { LogLevel } from '../contracts/IDBSQLLogger';
+import fetch from 'node-fetch';
+import { buildUrl } from './urlUtils';
 
 /**
  * Context holding feature flag state for a specific host.
@@ -105,35 +106,28 @@ export default class FeatureFlagCache {
   }
 
   /**
-   * Gets the driver version from package.json.
-   * Used for version-specific feature flag requests.
-   */
-  private getDriverVersion(): string {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const packageJson = require('../../package.json');
-      return packageJson.version || 'unknown';
-    } catch {
-      return 'unknown';
-    }
-  }
-
-  /**
-   * Fetches feature flag from server REST API.
-   * Makes authenticated call to connector-service endpoint.
+   * Fetches feature flag from server using connector-service API.
+   * Calls GET /api/2.0/connector-service/feature-flags/OSS_NODEJS/{version}
+   *
    * @param host The host to fetch feature flag for
+   * @returns true if feature flag is enabled, false otherwise
    */
   private async fetchFeatureFlag(host: string): Promise<boolean> {
     const logger = this.context.getLogger();
+
     try {
+      // Get driver version for endpoint
       const driverVersion = this.getDriverVersion();
-      const endpoint = `https://${host}/api/2.0/connector-service/feature-flags/OSS_NODEJS/${driverVersion}`;
+
+      // Build feature flags endpoint for Node.js driver
+      const endpoint = buildUrl(host, `/api/2.0/connector-service/feature-flags/NODEJS/${driverVersion}`);
 
       // Get authentication headers
       const authHeaders = await this.context.getAuthHeaders();
 
-      logger.log(LogLevel.debug, `Fetching feature flag from ${endpoint}`);
+      logger.log(LogLevel.debug, `Fetching feature flags from ${endpoint}`);
 
+      // Make HTTP GET request with authentication
       const response = await fetch(endpoint, {
         method: 'GET',
         headers: {
@@ -144,36 +138,63 @@ export default class FeatureFlagCache {
       });
 
       if (!response.ok) {
-        logger.log(LogLevel.debug, `Feature flag fetch returned status ${response.status}`);
+        logger.log(
+          LogLevel.debug,
+          `Feature flag fetch failed: ${response.status} ${response.statusText}`
+        );
         return false;
       }
 
+      // Parse response JSON
       const data: any = await response.json();
 
-      // Update cache duration from ttl_seconds if provided
-      if (data && data.ttl_seconds) {
+      // Response format: { flags: [{ name: string, value: string }], ttl_seconds?: number }
+      if (data && data.flags && Array.isArray(data.flags)) {
+        // Update cache duration if TTL provided
         const ctx = this.contexts.get(host);
-        if (ctx) {
-          ctx.cacheDuration = data.ttl_seconds * 1000;
+        if (ctx && data.ttl_seconds) {
+          ctx.cacheDuration = data.ttl_seconds * 1000; // Convert to milliseconds
           logger.log(LogLevel.debug, `Updated cache duration to ${data.ttl_seconds} seconds`);
         }
-      }
 
-      // Find the telemetry flag
-      if (data && data.flags && Array.isArray(data.flags)) {
+        // Look for our specific feature flag
         const flag = data.flags.find((f: any) => f.name === this.FEATURE_FLAG_NAME);
+
         if (flag) {
-          const enabled = String(flag.value).toLowerCase() === 'true';
-          logger.log(LogLevel.debug, `Feature flag ${this.FEATURE_FLAG_NAME} = ${enabled}`);
+          // Parse boolean value (can be string "true"/"false")
+          const value = String(flag.value).toLowerCase();
+          const enabled = value === 'true';
+          logger.log(
+            LogLevel.debug,
+            `Feature flag ${this.FEATURE_FLAG_NAME}: ${enabled}`
+          );
           return enabled;
         }
       }
 
+      // Feature flag not found in response, default to false
       logger.log(LogLevel.debug, `Feature flag ${this.FEATURE_FLAG_NAME} not found in response`);
       return false;
     } catch (error: any) {
+      // Log at debug level only, never propagate exceptions
       logger.log(LogLevel.debug, `Error fetching feature flag from ${host}: ${error.message}`);
       return false;
     }
   }
+
+  /**
+   * Gets the driver version without -oss suffix for API calls.
+   * Format: "1.12.0" from "1.12.0-oss"
+   */
+  private getDriverVersion(): string {
+    try {
+      // Import version from lib/version.ts
+      const version = require('../version').default;
+      // Remove -oss suffix if present
+      return version.replace(/-oss$/, '');
+    } catch (error) {
+      // Fallback to a default version if import fails
+      return '1.0.0';
+    }
+  }
 }

lib/telemetry/urlUtils.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 Databricks Contributors
+ *
+ * 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
+ *
+ *     http://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.
+ */
+
+/**
+ * Build full URL from host and path, handling protocol correctly.
+ * @param host The hostname (with or without protocol)
+ * @param path The path to append (should start with /)
+ * @returns Full URL with protocol
+ */
+export function buildUrl(host: string, path: string): string {
+  // Check if host already has protocol
+  if (host.startsWith('http://') || host.startsWith('https://')) {
+    return `${host}${path}`;
+  }
+  // Add https:// if no protocol present
+  return `https://${host}${path}`;
+}