Populate driver_connection_params in telemetry

Added comprehensive connection parameters to telemetry exports:
- host and port
- http_path (warehouse/cluster identifier)
- enable_arrow (Arrow batches setting)
- socket_timeout (client timeout in seconds)
- rows_fetched_per_block (MaxRows setting)
- enable_metric_view_metadata

Updated initialization chain to pass connection parameters
through exporter -> client -> manager -> driver integration.

All telemetry tests passing with enriched connection metadata.

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

Author: samikshya-db

connector.go

@@ -89,12 +89,26 @@ func (c *connector) Connect(ctx context.Context) (driver.Conn, error) {
 	}
 	// else: leave nil to check server feature flag
 
+	// Build connection parameters for telemetry
+	connParams := &telemetry.DriverConnectionParameters{
+		Host:                     c.cfg.Host,
+		Port:                     c.cfg.Port,
+		HTTPPath:                 c.cfg.HTTPPath,
+		EnableArrow:              c.cfg.UseArrowBatches,
+		EnableMetricViewMetadata: c.cfg.EnableMetricViewMetadata,
+		SocketTimeoutSeconds:     int64(c.cfg.ClientTimeout.Seconds()),
+		RowsFetchedPerBlock:      int64(c.cfg.MaxRows),
+	}
+
 	conn.telemetry = telemetry.InitializeForConnection(
 		ctx,
 		c.cfg.Host,
+		c.cfg.Port,
+		c.cfg.HTTPPath,
 		c.cfg.DriverVersion,
 		c.client,
 		enableTelemetry,
+		connParams,
 	)
 	if conn.telemetry != nil {
 		log.Debug().Msg("telemetry initialized for connection")

telemetry/benchmark_test.go

@@ -20,7 +20,7 @@ func BenchmarkInterceptor_Overhead_Enabled(b *testing.B) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -48,7 +48,7 @@ func BenchmarkInterceptor_Overhead_Disabled(b *testing.B) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -75,7 +75,7 @@ func BenchmarkAggregator_RecordMetric(b *testing.B) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -105,7 +105,7 @@ func BenchmarkExporter_Export(b *testing.B) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	ctx := context.Background()
 	metrics := []*telemetryMetric{
@@ -141,7 +141,7 @@ func BenchmarkConcurrentConnections_PerHostSharing(b *testing.B) {
 		for pb.Next() {
 			// Simulate getting a client (should share per host)
 			mgr := getClientManager()
-			client := mgr.getOrCreateClient(host, "test-version", httpClient, cfg)
+			client := mgr.getOrCreateClient(host, 443, "", "test-version", httpClient, cfg, nil)
 			_ = client
 
 			// Release client
@@ -198,7 +198,7 @@ func TestLoadTesting_ConcurrentConnections(t *testing.T) {
 			defer wg.Done()
 
 			// Get client (should share)
-			client := mgr.getOrCreateClient(host, "test-version", httpClient, cfg)
+			client := mgr.getOrCreateClient(host, 443, "", "test-version", httpClient, cfg, nil)
 			interceptor := client.GetInterceptor(true)
 
 			// Simulate some operations
@@ -237,8 +237,8 @@ func TestGracefulShutdown_ReferenceCountingCleanup(t *testing.T) {
 	mgr := getClientManager()
 
 	// Create multiple references
-	client1 := mgr.getOrCreateClient(host, "test-version", httpClient, cfg)
-	client2 := mgr.getOrCreateClient(host, "test-version", httpClient, cfg)
+	client1 := mgr.getOrCreateClient(host, 443, "", "test-version", httpClient, cfg, nil)
+	client2 := mgr.getOrCreateClient(host, 443, "", "test-version", httpClient, cfg, nil)
 
 	if client1 != client2 {
 		t.Error("Expected same client instance for same host")
@@ -292,7 +292,7 @@ func TestGracefulShutdown_FinalFlush(t *testing.T) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 
 	// Record a metric

telemetry/client.go

@@ -31,9 +31,9 @@ type telemetryClient struct {
 }
 
 // newTelemetryClient creates a new telemetry client for the given host.
-func newTelemetryClient(host string, driverVersion string, httpClient *http.Client, cfg *Config) *telemetryClient {
+func newTelemetryClient(host string, port int, httpPath string, driverVersion string, httpClient *http.Client, cfg *Config, connParams *DriverConnectionParameters) *telemetryClient {
 	// Create exporter
-	exporter := newTelemetryExporter(host, driverVersion, httpClient, cfg)
+	exporter := newTelemetryExporter(host, port, httpPath, driverVersion, httpClient, cfg, connParams)
 
 	// Create aggregator with exporter
 	aggregator := newMetricsAggregator(exporter, cfg)

telemetry/driver_integration.go

@@ -23,9 +23,12 @@ import (
 func InitializeForConnection(
 	ctx context.Context,
 	host string,
+	port int,
+	httpPath string,
 	driverVersion string,
 	httpClient *http.Client,
 	enableTelemetry *bool,
+	connParams *DriverConnectionParameters,
 ) *Interceptor {
 	// Create telemetry config
 	cfg := DefaultConfig()
@@ -43,7 +46,7 @@ func InitializeForConnection(
 
 	// Get or create telemetry client for this host
 	clientMgr := getClientManager()
-	telemetryClient := clientMgr.getOrCreateClient(host, driverVersion, httpClient, cfg)
+	telemetryClient := clientMgr.getOrCreateClient(host, port, httpPath, driverVersion, httpClient, cfg, connParams)
 	if telemetryClient == nil {
 		return nil
 	}

telemetry/exporter.go

@@ -13,10 +13,14 @@ import (
 // telemetryExporter exports metrics to Databricks telemetry service.
 type telemetryExporter struct {
 	host           string
+	port           int
+	httpPath       string
 	driverVersion  string
 	httpClient     *http.Client
 	circuitBreaker *circuitBreaker
 	cfg            *Config
+	// Connection parameters for telemetry
+	connParams *DriverConnectionParameters
 }
 
 // telemetryMetric represents a metric to export.
@@ -32,13 +36,25 @@ type telemetryMetric struct {
 }
 
 // newTelemetryExporter creates a new exporter.
-func newTelemetryExporter(host string, driverVersion string, httpClient *http.Client, cfg *Config) *telemetryExporter {
+func newTelemetryExporter(host string, port int, httpPath string, driverVersion string, httpClient *http.Client, cfg *Config, connParams *DriverConnectionParameters) *telemetryExporter {
+	// Build connection parameters if not provided
+	if connParams == nil {
+		connParams = &DriverConnectionParameters{
+			Host:     host,
+			Port:     port,
+			HTTPPath: httpPath,
+		}
+	}
+
 	return &telemetryExporter{
 		host:           host,
+		port:           port,
+		httpPath:       httpPath,
 		driverVersion:  driverVersion,
 		httpClient:     httpClient,
 		circuitBreaker: getCircuitBreakerManager().getCircuitBreaker(host),
 		cfg:            cfg,
+		connParams:     connParams,
 	}
 }
 
@@ -72,7 +88,7 @@ func (e *telemetryExporter) export(ctx context.Context, metrics []*telemetryMetr
 // doExport performs the actual export with retries and exponential backoff.
 func (e *telemetryExporter) doExport(ctx context.Context, metrics []*telemetryMetric) error {
 	// Create telemetry request with protoLogs format (matches JDBC/Node.js)
-	payload, err := createTelemetryRequest(metrics, e.driverVersion)
+	payload, err := createTelemetryRequest(metrics, e.driverVersion, e.connParams)
 	if err != nil {
 		return fmt.Errorf("failed to create telemetry request: %w", err)
 	}

telemetry/exporter_test.go

@@ -16,7 +16,7 @@ func TestNewTelemetryExporter(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 	host := "test-host"
 
-	exporter := newTelemetryExporter(host, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(host, 443, "", "test-version", httpClient, cfg, nil)
 
 	if exporter.host != host {
 		t.Errorf("Expected host %s, got %s", host, exporter.host)
@@ -73,7 +73,7 @@ func TestExport_Success(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -113,7 +113,7 @@ func TestExport_RetryOn5xx(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -145,7 +145,7 @@ func TestExport_NonRetryable4xx(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -181,7 +181,7 @@ func TestExport_Retry429(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -211,7 +211,7 @@ func TestExport_CircuitBreakerOpen(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	// Open the circuit breaker by recording failures
 	cb := exporter.circuitBreaker
@@ -260,7 +260,7 @@ func TestCreateTelemetryRequest_TagFiltering(t *testing.T) {
 		},
 	}
 
-	req, err := createTelemetryRequest([]*telemetryMetric{metric}, "1.0.0")
+	req, err := createTelemetryRequest([]*telemetryMetric{metric}, "1.0.0", &DriverConnectionParameters{Host: "test-host", Port: 443})
 	if err != nil {
 		t.Fatalf("Failed to create telemetry request: %v", err)
 	}
@@ -329,7 +329,7 @@ func TestExport_ErrorSwallowing(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -365,7 +365,7 @@ func TestExport_ContextCancellation(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{
@@ -398,7 +398,7 @@ func TestExport_ExponentialBackoff(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// Use full server URL for testing
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	metrics := []*telemetryMetric{
 		{

telemetry/integration_test.go

@@ -48,7 +48,7 @@ func TestIntegration_EndToEnd_WithCircuitBreaker(t *testing.T) {
 	defer server.Close()
 
 	// Create telemetry client
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -95,7 +95,7 @@ func TestIntegration_CircuitBreakerOpening(t *testing.T) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -212,7 +212,7 @@ func TestIntegration_PrivacyCompliance_NoQueryText(t *testing.T) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 	aggregator := newMetricsAggregator(exporter, cfg)
 	defer aggregator.close(context.Background())
 
@@ -274,7 +274,7 @@ func TestIntegration_TagFiltering(t *testing.T) {
 	}))
 	defer server.Close()
 
-	exporter := newTelemetryExporter(server.URL, "test-version", httpClient, cfg)
+	exporter := newTelemetryExporter(server.URL, 443, "", "test-version", httpClient, cfg, nil)
 
 	// Test metric with mixed tags
 	metric := &telemetryMetric{

telemetry/manager.go

@@ -45,13 +45,13 @@ func getClientManager() *clientManager {
 
 // getOrCreateClient gets or creates a telemetry client for the host.
 // Increments reference count.
-func (m *clientManager) getOrCreateClient(host string, driverVersion string, httpClient *http.Client, cfg *Config) *telemetryClient {
+func (m *clientManager) getOrCreateClient(host string, port int, httpPath string, driverVersion string, httpClient *http.Client, cfg *Config, connParams *DriverConnectionParameters) *telemetryClient {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
 	holder, exists := m.clients[host]
 	if !exists {
-		client := newTelemetryClient(host, driverVersion, httpClient, cfg)
+		client := newTelemetryClient(host, port, httpPath, driverVersion, httpClient, cfg, connParams)
 		if err := client.start(); err != nil {
 			// Failed to start client, don't add to map
 			logger.Logger.Debug().Str("host", host).Err(err).Msg("failed to start telemetry client")