Refactor telemetry config to use config overlay approach

Address PR review comments by implementing config overlay pattern:

**Changes:**
- Remove ForceEnableTelemetry flag (no longer needed)
- Change EnableTelemetry from bool to *bool pointer
  - nil = use server feature flag (default)
  - true = client forces enabled (overrides server)
  - false = client forces disabled (overrides server)
- Simplify priority logic to 3 clear layers:
  1. Client Config (explicit) - highest priority
  2. Server Config (feature flag) - when client doesn't set
  3. Fail-Safe Default (disabled) - when server unavailable

**Benefits:**
- Simpler mental model: client > server > default
- Client config naturally has priority (no special bypass flag)
- Foundation for general config overlay system
- All 89 telemetry tests passing

Addresses review comments:
- "if we take the config overlay approach that client side config take
  priority? we won't need the concept of force enablement?"
- Sets foundation for extending to all driver configs (not just telemetry)

Author: samikshya-db

telemetry/config.go

@@ -12,13 +12,12 @@ type Config struct {
 	// Enabled controls whether telemetry is active
 	Enabled bool
 
-	// ForceEnableTelemetry bypasses server-side feature flag checks
-	// When true, telemetry is always enabled regardless of server flags
-	ForceEnableTelemetry bool
-
-	// EnableTelemetry indicates user wants telemetry enabled if server allows
-	// Respects server-side feature flags and rollout percentage
-	EnableTelemetry bool
+	// EnableTelemetry is the client-side telemetry preference
+	// - nil: not set by client, use server feature flag (default behavior)
+	// - true: client wants telemetry enabled (overrides server)
+	// - false: client wants telemetry disabled (overrides server)
+	// This implements config overlay: client > server > default
+	EnableTelemetry *bool
 
 	// BatchSize is the number of metrics to batch before flushing
 	BatchSize int
@@ -43,12 +42,12 @@ type Config struct {
 }
 
 // DefaultConfig returns default telemetry configuration.
-// Note: Telemetry is disabled by default and requires explicit opt-in.
+// Note: Telemetry uses config overlay - enabled by default, controlled by server feature flags.
+// Clients can override by explicitly setting enableTelemetry=true/false.
 func DefaultConfig() *Config {
 	return &Config{
-		Enabled:                 false, // Disabled by default, requires explicit opt-in
-		ForceEnableTelemetry:    false,
-		EnableTelemetry:         false,
+		Enabled:                 false, // Will be set based on overlay logic
+		EnableTelemetry:         nil,   // nil = use server feature flag (config overlay)
 		BatchSize:               100,
 		FlushInterval:           5 * time.Second,
 		MaxRetries:              3,
@@ -63,22 +62,16 @@ func DefaultConfig() *Config {
 func ParseTelemetryConfig(params map[string]string) *Config {
 	cfg := DefaultConfig()
 
-	// Check for forceEnableTelemetry flag (bypasses server feature flags)
-	if v, ok := params["forceEnableTelemetry"]; ok {
-		if v == "true" || v == "1" {
-			cfg.ForceEnableTelemetry = true
-			cfg.Enabled = true // Also set Enabled for backward compatibility
-		}
-	}
-
-	// Check for enableTelemetry flag (respects server feature flags)
+	// Config overlay approach: client setting overrides server feature flag
+	// Priority:
+	//   1. Client explicit setting (enableTelemetry=true/false) - overrides server
+	//   2. Server feature flag (when client doesn't set) - server controls
+	//   3. Default disabled (when server flag unavailable) - fail-safe
 	if v, ok := params["enableTelemetry"]; ok {
-		if v == "true" || v == "1" {
-			cfg.EnableTelemetry = true
-		} else if v == "false" || v == "0" {
-			cfg.EnableTelemetry = false
-		}
+		enabled := (v == "true" || v == "1")
+		cfg.EnableTelemetry = &enabled
 	}
+	// Note: If not present in params, stays nil (use server feature flag)
 
 	if v, ok := params["telemetry_batch_size"]; ok {
 		if size, err := strconv.Atoi(v); err == nil && size > 0 {
@@ -96,14 +89,12 @@ func ParseTelemetryConfig(params map[string]string) *Config {
 }
 
 // isTelemetryEnabled checks if telemetry should be enabled for this connection.
-// Implements the priority-based decision tree for telemetry enablement.
+// Implements config overlay approach with clear priority order.
 //
-// Priority (highest to lowest):
-// 1. forceEnableTelemetry=true - Bypasses all server checks (testing/internal)
-// 2. enableTelemetry=false - Explicit opt-out (always disabled)
-// 3. enableTelemetry=true + Server Feature Flag - User opt-in with server control
-// 4. Server Feature Flag Only - Default behavior (Databricks-controlled)
-// 5. Default - Disabled (false)
+// Config Overlay Priority (highest to lowest):
+// 1. Client Config - enableTelemetry explicitly set (true/false) - overrides server
+// 2. Server Config - feature flag controls when client doesn't specify
+// 3. Fail-Safe Default - disabled when server flag unavailable/errors
 //
 // Parameters:
 //   - ctx: Context for the request
@@ -114,26 +105,17 @@ func ParseTelemetryConfig(params map[string]string) *Config {
 // Returns:
 //   - bool: true if telemetry should be enabled, false otherwise
 func isTelemetryEnabled(ctx context.Context, cfg *Config, host string, httpClient *http.Client) bool {
-	// Priority 1: Force enable bypasses all server checks
-	if cfg.ForceEnableTelemetry {
-		return true
-	}
-
-	// Priority 2: Explicit opt-out always disables
-	// When enableTelemetry is explicitly set to false, respect that
-	if !cfg.EnableTelemetry {
-		return false
+	// Priority 1: Client explicitly set enableTelemetry (overrides server)
+	if cfg.EnableTelemetry != nil {
+		return *cfg.EnableTelemetry
 	}
 
-	// Priority 3 & 4: Check server-side feature flag
-	// This handles both:
-	// - User explicitly opted in (enableTelemetry=true) - respect server decision
-	// - Default behavior (no explicit setting) - server controls enablement
+	// Priority 2: Check server-side feature flag
 	flagCache := getFeatureFlagCache()
 	serverEnabled, err := flagCache.isTelemetryEnabled(ctx, host, httpClient)
 	if err != nil {
-		// On error, respect default (disabled)
-		// This ensures telemetry failures don't impact driver operation
+		// Priority 3: Fail-safe default (disabled)
+		// On error, default to disabled to ensure telemetry failures don't impact driver
 		return false
 	}