Align Go driver with JDBC connector-service feature flag endpoint

Updated feature flag fetching to use the same connector-service endpoint
as the JDBC driver:
- Old: /api/2.0/feature-flags?flags=...
- New: /api/2.0/connector-service/feature-flags/OSS_GO_SQL/{version}

Changes:
- Updated endpoint format to include driver name and version in URL path
- Changed response parsing from map format to array of flag entries
- Thread driverVersion parameter through the call chain
- Updated all tests to match new connector-service response format
- Response format: {"flags": [{"name": "...", "value": "true"}]}

This aligns the Go driver with the JDBC driver's feature flag API,
ensuring consistent behavior across Databricks SQL drivers.

Signed-off-by: Samikshya Chand <samikshya.chand@databricks.com>
Signed-off-by: samikshya-chand_data <samikshya.chand@databricks.com>

Author: samikshya-db

telemetry/config.go

@@ -99,10 +99,11 @@ func ParseTelemetryConfig(params map[string]string) *Config {
 //   - cfg: Telemetry configuration
 //   - host: Databricks host to check feature flags against
 //   - httpClient: HTTP client for making feature flag requests
+//   - driverVersion: Driver version string for feature flag endpoint
 //
 // Returns:
 //   - bool: true if telemetry should be enabled, false otherwise
-func isTelemetryEnabled(ctx context.Context, cfg *Config, host string, httpClient *http.Client) bool {
+func isTelemetryEnabled(ctx context.Context, cfg *Config, host string, httpClient *http.Client, driverVersion string) bool {
 	// Priority 1: Client explicitly set (overrides server)
 	if cfg.EnableTelemetry.IsSet() {
 		val, _ := cfg.EnableTelemetry.Get()
@@ -111,7 +112,7 @@ func isTelemetryEnabled(ctx context.Context, cfg *Config, host string, httpClien
 
 	// Priority 2: Check server-side feature flag
 	flagCache := getFeatureFlagCache()
-	serverEnabled, err := flagCache.isTelemetryEnabled(ctx, host, httpClient)
+	serverEnabled, err := flagCache.isTelemetryEnabled(ctx, host, httpClient, driverVersion)
 	if err != nil {
 		// Priority 3: Fail-safe default (disabled)
 		return false

telemetry/config_test.go

@@ -2,7 +2,6 @@ package telemetry
 
 import (
 	"context"
-	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -206,12 +205,9 @@ func TestIsTelemetryEnabled_ClientOverrideEnabled(t *testing.T) {
 	// Setup: Create a server that returns disabled
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Server says disabled, but client override should win
-		resp := map[string]interface{}{
-			"flags": map[string]bool{
-				"databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver": false,
-			},
-		}
-		_ = json.NewEncoder(w).Encode(resp)
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"flags": [{"name": "databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver", "value": "false"}]}`))
 	}))
 	defer server.Close()
 
@@ -228,7 +224,7 @@ func TestIsTelemetryEnabled_ClientOverrideEnabled(t *testing.T) {
 	defer flagCache.releaseContext(server.URL)
 
 	// Client override should bypass server check
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	if !result {
 		t.Error("Expected telemetry to be enabled when client explicitly sets enableTelemetry=true, got disabled")
@@ -240,12 +236,9 @@ func TestIsTelemetryEnabled_ClientOverrideDisabled(t *testing.T) {
 	// Setup: Create a server that returns enabled
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Server says enabled, but client override should win
-		resp := map[string]interface{}{
-			"flags": map[string]bool{
-				"databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver": true,
-			},
-		}
-		_ = json.NewEncoder(w).Encode(resp)
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"flags": [{"name": "databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver", "value": "true"}]}`))
 	}))
 	defer server.Close()
 
@@ -261,7 +254,7 @@ func TestIsTelemetryEnabled_ClientOverrideDisabled(t *testing.T) {
 	flagCache.getOrCreateContext(server.URL)
 	defer flagCache.releaseContext(server.URL)
 
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	if result {
 		t.Error("Expected telemetry to be disabled when client explicitly sets enableTelemetry=false, got enabled")
@@ -272,12 +265,9 @@ func TestIsTelemetryEnabled_ClientOverrideDisabled(t *testing.T) {
 func TestIsTelemetryEnabled_ServerEnabled(t *testing.T) {
 	// Setup: Create a server that returns enabled
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		resp := map[string]interface{}{
-			"flags": map[string]bool{
-				"databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver": true,
-			},
-		}
-		_ = json.NewEncoder(w).Encode(resp)
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"flags": [{"name": "databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver", "value": "true"}]}`))
 	}))
 	defer server.Close()
 
@@ -293,7 +283,7 @@ func TestIsTelemetryEnabled_ServerEnabled(t *testing.T) {
 	flagCache.getOrCreateContext(server.URL)
 	defer flagCache.releaseContext(server.URL)
 
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	if !result {
 		t.Error("Expected telemetry to be enabled when server flag is true, got disabled")
@@ -304,12 +294,9 @@ func TestIsTelemetryEnabled_ServerEnabled(t *testing.T) {
 func TestIsTelemetryEnabled_ServerDisabled(t *testing.T) {
 	// Setup: Create a server that returns disabled
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		resp := map[string]interface{}{
-			"flags": map[string]bool{
-				"databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver": false,
-			},
-		}
-		_ = json.NewEncoder(w).Encode(resp)
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"flags": [{"name": "databricks.partnerplatform.clientConfigsFeatureFlags.enableTelemetryForGoDriver", "value": "false"}]}`))
 	}))
 	defer server.Close()
 
@@ -325,7 +312,7 @@ func TestIsTelemetryEnabled_ServerDisabled(t *testing.T) {
 	flagCache.getOrCreateContext(server.URL)
 	defer flagCache.releaseContext(server.URL)
 
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	if result {
 		t.Error("Expected telemetry to be disabled when server flag is false, got enabled")
@@ -340,7 +327,7 @@ func TestIsTelemetryEnabled_FailSafeDefault(t *testing.T) {
 	httpClient := &http.Client{Timeout: 5 * time.Second}
 
 	// No server available, should default to disabled (fail-safe)
-	result := isTelemetryEnabled(ctx, cfg, "nonexistent-host", httpClient)
+	result := isTelemetryEnabled(ctx, cfg, "nonexistent-host", httpClient, "1.0.0")
 
 	if result {
 		t.Error("Expected telemetry to be disabled when server unavailable (fail-safe), got enabled")
@@ -367,7 +354,7 @@ func TestIsTelemetryEnabled_ServerError(t *testing.T) {
 	flagCache.getOrCreateContext(server.URL)
 	defer flagCache.releaseContext(server.URL)
 
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	// On error, should default to disabled (fail-safe)
 	if result {
@@ -390,7 +377,7 @@ func TestIsTelemetryEnabled_ServerUnreachable(t *testing.T) {
 	flagCache.getOrCreateContext(unreachableHost)
 	defer flagCache.releaseContext(unreachableHost)
 
-	result := isTelemetryEnabled(ctx, cfg, unreachableHost, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, unreachableHost, httpClient, "1.0.0")
 
 	// On error, should default to disabled (fail-safe)
 	if result {
@@ -418,7 +405,7 @@ func TestIsTelemetryEnabled_ClientOverridesServerError(t *testing.T) {
 	flagCache.getOrCreateContext(server.URL)
 	defer flagCache.releaseContext(server.URL)
 
-	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient)
+	result := isTelemetryEnabled(ctx, cfg, server.URL, httpClient, "1.0.0")
 
 	// Client override should work even when server errors
 	if !result {

telemetry/driver_integration.go

@@ -37,7 +37,7 @@ func InitializeForConnection(
 	// else: leave unset (will check server feature flag)
 
 	// Check if telemetry should be enabled
-	if !isTelemetryEnabled(ctx, cfg, host, httpClient) {
+	if !isTelemetryEnabled(ctx, cfg, host, httpClient, driverVersion) {
 		return nil
 	}
 

telemetry/featureflag.go

@@ -90,7 +90,7 @@ func (c *featureFlagCache) releaseContext(host string) {
 // getFeatureFlag retrieves a specific feature flag value for the host.
 // This is the generic method that handles caching and fetching for any flag.
 // Uses cached value if available and not expired.
-func (c *featureFlagCache) getFeatureFlag(ctx context.Context, host string, httpClient *http.Client, flagName string) (bool, error) {
+func (c *featureFlagCache) getFeatureFlag(ctx context.Context, host string, httpClient *http.Client, flagName string, driverVersion string) (bool, error) {
 	c.mu.RLock()
 	flagCtx, exists := c.contexts[host]
 	c.mu.RUnlock()
@@ -111,7 +111,7 @@ func (c *featureFlagCache) getFeatureFlag(ctx context.Context, host string, http
 
 		// If we just created the context, make the initial blocking fetch
 		if !exists {
-			flags, err := fetchFeatureFlags(ctx, host, httpClient)
+			flags, err := fetchFeatureFlags(ctx, host, httpClient, driverVersion)
 
 			flagCtx.mu.Lock()
 			flagCtx.fetching = false
@@ -155,7 +155,7 @@ func (c *featureFlagCache) getFeatureFlag(ctx context.Context, host string, http
 	flagCtx.mu.RUnlock()
 
 	// Fetch fresh values for all flags
-	flags, err := fetchFeatureFlags(ctx, host, httpClient)
+	flags, err := fetchFeatureFlags(ctx, host, httpClient, driverVersion)
 
 	// Update cache (with proper locking)
 	flagCtx.mu.Lock()
@@ -184,8 +184,8 @@ func (c *featureFlagCache) getFeatureFlag(ctx context.Context, host string, http
 
 // isTelemetryEnabled checks if telemetry is enabled for the host.
 // Uses cached value if available and not expired.
-func (c *featureFlagCache) isTelemetryEnabled(ctx context.Context, host string, httpClient *http.Client) (bool, error) {
-	return c.getFeatureFlag(ctx, host, httpClient, flagEnableTelemetry)
+func (c *featureFlagCache) isTelemetryEnabled(ctx context.Context, host string, httpClient *http.Client, driverVersion string) (bool, error) {
+	return c.getFeatureFlag(ctx, host, httpClient, flagEnableTelemetry, driverVersion)
 }
 
 // isExpired returns true if the cache has expired.
@@ -203,36 +203,42 @@ func getAllFeatureFlags() []string {
 	}
 }
 
-// fetchFeatureFlags fetches multiple feature flag values from Databricks in a single request.
+// featureFlagEntry represents a single feature flag from the server response.
+type featureFlagEntry struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+// featureFlagsResponse represents the response from the connector-service feature flags endpoint.
+type featureFlagsResponse struct {
+	Flags      []featureFlagEntry `json:"flags"`
+	TTLSeconds *int               `json:"ttl_seconds,omitempty"`
+}
+
+// fetchFeatureFlags fetches multiple feature flag values from Databricks connector-service endpoint.
 // Returns a map of flag names to their boolean values.
-func fetchFeatureFlags(ctx context.Context, host string, httpClient *http.Client) (map[string]bool, error) {
+func fetchFeatureFlags(ctx context.Context, host string, httpClient *http.Client, driverVersion string) (map[string]bool, error) {
 	// Add timeout to context if it doesn't have a deadline
 	if _, hasDeadline := ctx.Deadline(); !hasDeadline {
 		var cancel context.CancelFunc
 		ctx, cancel = context.WithTimeout(ctx, featureFlagHTTPTimeout)
 		defer cancel()
 	}
 
-	// Construct endpoint URL, adding https:// if not already present
+	// Construct connector-service endpoint URL with driver name and version
+	// Format: /api/2.0/connector-service/feature-flags/OSS_GO_SQL/{version}
 	var endpoint string
 	if strings.HasPrefix(host, "http://") || strings.HasPrefix(host, "https://") {
-		endpoint = fmt.Sprintf("%s/api/2.0/feature-flags", host)
+		endpoint = fmt.Sprintf("%s/api/2.0/connector-service/feature-flags/OSS_GO_SQL/%s", host, driverVersion)
 	} else {
-		endpoint = fmt.Sprintf("https://%s/api/2.0/feature-flags", host)
+		endpoint = fmt.Sprintf("https://%s/api/2.0/connector-service/feature-flags/OSS_GO_SQL/%s", host, driverVersion)
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create feature flag request: %w", err)
 	}
 
-	// Add query parameter with comma-separated list of feature flags
-	// This fetches all flags in a single request for efficiency
-	allFlags := getAllFeatureFlags()
-	q := req.URL.Query()
-	q.Add("flags", strings.Join(allFlags, ","))
-	req.URL.RawQuery = q.Encode()
-
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch feature flags: %w", err)
@@ -245,18 +251,19 @@ func fetchFeatureFlags(ctx context.Context, host string, httpClient *http.Client
 		return nil, fmt.Errorf("feature flag check failed: %d", resp.StatusCode)
 	}
 
-	var result struct {
-		Flags map[string]bool `json:"flags"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+	var response featureFlagsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
 		return nil, fmt.Errorf("failed to decode feature flag response: %w", err)
 	}
 
-	// Return the full map of flags
-	// Flags not present in the response will have false value when accessed
-	if result.Flags == nil {
-		return make(map[string]bool), nil
+	// Convert array of flag entries to map
+	flags := make(map[string]bool)
+	if response.Flags != nil {
+		for _, flag := range response.Flags {
+			// Parse string value as boolean
+			flags[flag.Name] = flag.Value == "true"
+		}
 	}
 
-	return result.Flags, nil
+	return flags, nil
 }