Contrarian View: Feature Flags Are Technical Debt – Use LaunchDarkly 2.0 and Flagsmith 8.0 Only When Necessary

// launchdarkly-eval.ts
// Demonstrates LaunchDarkly 2.0 Node SDK overhead in high-throughput services
import * as LaunchDarkly from '@launchdarkly/node-server-sdk';
import { Registry, Counter, Histogram } from 'prom-client';
import { createServer } from 'http';

// Initialize LaunchDarkly 2.0 client with production config
const ldClient = LaunchDarkly.init('YOUR_SDK_KEY', {
  timeout: 5, // 5s startup timeout per LD 2.0 docs
  capacity: 1000, // Event queue capacity, default 1000 in 2.0
  logger: console, // Basic logging for demo
});

// Prometheus metrics to track flag evaluation overhead
const register = new Registry();
const flagEvalDuration = new Histogram({
  name: 'ld_flag_eval_duration_ms',
  help: 'Duration of LaunchDarkly flag evaluations in milliseconds',
  labelNames: ['flag_key', 'user_segment'],
  registers: [register],
});
const flagEvalErrors = new Counter({
  name: 'ld_flag_eval_errors_total',
  help: 'Total LaunchDarkly flag evaluation errors',
  labelNames: ['flag_key', 'error_type'],
  registers: [register],
});
register.registerMetric(flagEvalDuration);
register.registerMetric(flagEvalErrors);

// Mock user context for evaluation (simplified for demo)
interface UserContext {
  key: string;
  email: string;
  custom: Record;
}

/**
 * Evaluate a feature flag with LaunchDarkly 2.0, including error handling and metrics
 * @param flagKey - Unique flag identifier
 * @param user - User context for targeting rules
 * @param defaultValue - Fallback value if evaluation fails
 */
async function evaluateFlag(
  flagKey: string,
  user: UserContext,
  defaultValue: boolean
): Promise {
  const timer = flagEvalDuration.startTimer({ flag_key: flagKey, user_segment: user.custom?.segment || 'unknown' });
  try {
    // LD 2.0 requires client to be ready before evaluation
    if (!ldClient.isInitialized()) {
      await ldClient.waitForInitialization({ timeout: 2000 });
    }
    // Evaluate flag with 1s timeout per LD 2.0 best practices
    const result = await Promise.race([
      ldClient.variation(flagKey, user, defaultValue),
      new Promise((_, reject) => setTimeout(() => reject(new Error('Flag eval timeout')), 1000)),
    ]);
    timer(); // Record successful evaluation
    return result;
  } catch (error) {
    timer(); // Still record duration for failed evals
    flagEvalErrors.inc({
      flag_key: flagKey,
      error_type: error instanceof Error ? error.message : 'unknown',
    });
    console.error(`LaunchDarkly 2.0 flag evaluation failed for ${flagKey}:`, error);
    return defaultValue; // Fallback to default on error
  }
}

// Example HTTP server to demonstrate flag usage in request path
const server = createServer(async (req, res) => {
  if (req.url === '/api/checkout') {
    const user: UserContext = {
      key: req.headers['x-user-id'] as string || 'anonymous',
      email: req.headers['x-user-email'] as string || 'unknown@example.com',
      custom: { segment: req.headers['x-user-segment'] as string || 'guest' },
    };
    // Evaluate the 'new-checkout-flow' flag (active in LD 2.0 dashboard)
    const useNewCheckout = await evaluateFlag('new-checkout-flow', user, false);
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ useNewCheckout }));
  } else {
    res.writeHead(404);
    res.end('Not found');
  }
});

// Start server and initialize LD client
server.listen(3000, async () => {
  console.log('Server running on port 3000');
  try {
    await ldClient.waitForInitialization({ timeout: 5000 });
    console.log('LaunchDarkly 2.0 client initialized successfully');
  } catch (error) {
    console.error('Failed to initialize LaunchDarkly client:', error);
    process.exit(1); // Exit if LD client can't start, per 2.0 error handling guidelines
  }
});

// Graceful shutdown to flush LD events
process.on('SIGTERM', async () => {
  console.log('Flushing LaunchDarkly events...');
  await ldClient.flush();
  await ldClient.close();
  server.close();
  process.exit(0);
});

# flagsmith_eval.py
# Demonstrates Flagsmith 8.0 Python SDK usage and self-hosted deployment overhead
import os
import time
from flask import Flask, request, jsonify
from flagsmith import Flagsmith, FlagsmithError, Segment, Trait
from prometheus_client import start_http_server, Histogram, Counter
import logging

# Configure logging for Flagsmith 8.0 (matches 8.0 logging config guidelines)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Initialize Flagsmith 8.0 client with self-hosted instance config
# Flagsmith 8.0 self-hosted requires explicit environment ID and API key
FLAGSMITH_ENVIRONMENT_ID = os.getenv('FLAGSMITH_ENV_ID', 'your_env_id')
FLAGSMITH_API_KEY = os.getenv('FLAGSMITH_API_KEY', 'your_api_key')
FLAGSMITH_API_URL = os.getenv('FLAGSMITH_API_URL', 'http://flagsmith-self-hosted:8000/api/v1/')

try:
    flagsmith = Flagsmith(
        environment_key=FLAGSMITH_API_KEY,
        api_url=FLAGSMITH_API_URL,
        # Flagsmith 8.0 adds connection pooling config, default 10 connections
        request_timeout=2,  # 2s timeout per 8.0 best practices
        retries=3,  # 3 retries for failed requests
    )
    # Verify connection to Flagsmith 8.0 instance
    flagsmith.get_environment_flags()  # Triggers a test request
    logger.info('Flagsmith 8.0 client initialized successfully')
except FlagsmithError as e:
    logger.error(f'Failed to initialize Flagsmith 8.0 client: {e}')
    raise SystemExit(1)

# Prometheus metrics for Flagsmith 8.0 evaluation overhead
FLAG_EVAL_DURATION = Histogram(
    'flagsmith_flag_eval_duration_seconds',
    'Duration of Flagsmith flag evaluations in seconds',
    ['flag_key', 'segment']
)
FLAG_EVAL_ERRORS = Counter(
    'flagsmith_flag_eval_errors_total',
    'Total Flagsmith flag evaluation errors',
    ['flag_key', 'error_type']
)

app = Flask(__name__)

def get_user_segment(user_id: str) -> str:
    """Mock segment lookup for demo (replace with real segment service in prod)"""
    return 'premium' if user_id.startswith('prem_') else 'free'

@app.route('/api/feature-access', methods=['GET'])
def check_feature_access():
    user_id = request.headers.get('X-User-ID', 'anonymous')
    segment = get_user_segment(user_id)
    flag_key = 'new-dashboard-access'

    # Start timer for evaluation duration
    start_time = time.time()
    try:
        # Flagsmith 8.0 requires traits to be passed explicitly for targeting
        traits = [Trait(key='segment', value=segment)]
        flags = flagsmith.get_flags_for_user(user_id, traits=traits)
        flag_value = flags.is_enabled(flag_key)
        # Record successful evaluation
        FLAG_EVAL_DURATION.labels(flag_key=flag_key, segment=segment).observe(time.time() - start_time)
        return jsonify({
            'user_id': user_id,
            'has_access': flag_value,
            'flag_key': flag_key
        }), 200
    except FlagsmithError as e:
        # Record error metrics
        FLAG_EVAL_ERRORS.labels(flag_key=flag_key, error_type=str(e)).inc()
        FLAG_EVAL_DURATION.labels(flag_key=flag_key, segment=segment).observe(time.time() - start_time)
        logger.error(f'Flagsmith 8.0 evaluation failed for {flag_key}: {e}')
        # Fallback to default (disabled) on error
        return jsonify({
            'user_id': user_id,
            'has_access': False,
            'flag_key': flag_key,
            'error': 'Fallback to default'
        }), 200
    except Exception as e:
        logger.error(f'Unexpected error during flag evaluation: {e}')
        return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    # Start Prometheus metrics server on port 9090
    start_http_server(9090)
    logger.info('Starting Flask app with Flagsmith 8.0 integration...')
    app.run(host='0.0.0.0', port=5000, debug=False)  # Debug=False for prod per 8.0 guidelines

// lightweight_flags.go
// Lightweight in-house feature flag system to avoid LaunchDarkly/Flagsmith overhead
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
)

// FlagConfig represents a single feature flag configuration
type FlagConfig struct {
    Key         string    `json:"key"`
    Enabled     bool      `json:"enabled"`
    RolloutPct  int       `json:"rollout_pct"` // 0-100 for percentage rollout
    Segments    []string  `json:"segments"`    // Allowed user segments
    LastUpdated time.Time `json:"last_updated"`
}

// LightweightFlagStore manages in-memory feature flags with periodic config reload
type LightweightFlagStore struct {
    flags      map[string]FlagConfig
    mu         sync.RWMutex
    configPath string
}

// NewLightweightFlagStore initializes a flag store with config file path
func NewLightweightFlagStore(configPath string) (*LightweightFlagStore, error) {
    store := &LightweightFlagStore{
        flags:      make(map[string]FlagConfig),
        configPath: configPath,
    }
    // Initial load of config
    if err := store.reloadConfig(); err != nil {
        return nil, fmt.Errorf("failed to load initial config: %w", err)
    }
    // Start periodic config reload every 30s (adjust based on needs)
    go store.periodicReload(30 * time.Second)
    return store, nil
}

// reloadConfig loads flag config from JSON file (replace with S3/Consul in prod)
func (s *LightweightFlagStore) reloadConfig() error {
    s.mu.Lock()
    defer s.mu.Unlock()

    data, err := os.ReadFile(s.configPath)
    if err != nil {
        return fmt.Errorf("failed to read config file: %w", err)
    }

    var configs []FlagConfig
    if err := json.Unmarshal(data, &configs); err != nil {
        return fmt.Errorf("failed to unmarshal config: %w", err)
    }

    // Update flags map
    newFlags := make(map[string]FlagConfig)
    for _, cfg := range configs {
        cfg.LastUpdated = time.Now()
        newFlags[cfg.Key] = cfg
    }
    s.flags = newFlags
    log.Printf("Reloaded %d feature flags from %s", len(newFlags), s.configPath)
    return nil
}

// periodicReload reloads config at the specified interval
func (s *LightweightFlagStore) periodicReload(interval time.Duration) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop()
    for range ticker.C {
        if err := s.reloadConfig(); err != nil {
            log.Printf("Failed to reload flag config: %v", err)
        }
    }
}

// IsEnabled evaluates if a flag is enabled for a given user context
func (s *LightweightFlagStore) IsEnabled(ctx context.Context, flagKey string, userSegment string, userID string) (bool, error) {
    s.mu.RLock()
    defer s.mu.RUnlock()

    cfg, exists := s.flags[flagKey]
    if !exists {
        log.Printf("Flag %s not found, returning default false", flagKey)
        return false, nil // Default to disabled for unknown flags
    }

    // Check segment allowlist first
    if len(cfg.Segments) > 0 {
        segmentAllowed := false
        for _, seg := range cfg.Segments {
            if seg == userSegment {
                segmentAllowed = true
                break
            }
        }
        if !segmentAllowed {
            return false, nil
        }
    }

    // Percentage rollout: hash user ID to consistent rollout
    if cfg.RolloutPct > 0 && cfg.RolloutPct < 100 {
        hash := (fnv32(userID) % 100) + 1 // 1-100 range
        return hash <= cfg.RolloutPct, nil
    }

    return cfg.Enabled, nil
}

// fnv32 is a simple FNV-1a 32-bit hash for consistent rollout
func fnv32(input string) uint32 {
    var hash uint32 = 2166136261
    for i := 0; i < len(input); i++ {
        hash ^= uint32(input[i])
        hash *= 16777619
    }
    return hash
}

// HTTP handler to check feature flags
func flagHandler(store *LightweightFlagStore) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        flagKey := r.URL.Query().Get("flag_key")
        userID := r.Header.Get("X-User-ID")
        userSegment := r.Header.Get("X-User-Segment")

        if flagKey == "" {
            http.Error(w, "flag_key query parameter required", http.StatusBadRequest)
            return
        }

        enabled, err := store.IsEnabled(r.Context(), flagKey, userSegment, userID)
        if err != nil {
            http.Error(w, fmt.Sprintf("evaluation error: %v", err), http.StatusInternalServerError)
            return
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]interface{}{
            "flag_key": flagKey,
            "enabled":  enabled,
            "user_id":  userID,
        })
    }
}

func main() {
    configPath := os.Getenv("FLAG_CONFIG_PATH")
    if configPath == "" {
        configPath = "flags.json"
    }

    store, err := NewLightweightFlagStore(configPath)
    if err != nil {
        log.Fatalf("Failed to initialize flag store: %v", err)
    }

    http.HandleFunc("/api/flag-check", flagHandler(store))
    log.Println("Starting lightweight flag server on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}

# .github/workflows/flag-ttl-check.yml
name: Check Feature Flag TTL
on: [push, pull_request]
jobs:
  check-flags:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      - name: Install LD CLI
        run: npm install -g @launchdarkly/cli@2.0
      - name: Verify flag TTL
        env:
          LD_API_KEY: ${{ secrets.LD_API_KEY }}
        run: |
          # List all active flags older than 30 days
          ld flags list --status active --format json | jq -r '.[] | select((now - .creationDate/1000) > 2592000) | .key' > stale_flags.txt
          if [ -s stale_flags.txt ]; then
            echo "Stale flags found (older than 30 days):"
            cat stale_flags.txt
            exit 1
          fi

// growthbook-experiment.ts
import { GrowthBook } from '@growthbook/growthbook';
import { getCookie } from 'next/headers';

export async function getExperimentVariant(experimentId: string) {
  const cookies = getCookie();
  const gb = new GrowthBook({
    apiHost: 'https://cdn.growthbook.io',
    clientKey: 'YOUR_GROWTHBOOK_KEY',
    enableDevMode: process.env.NODE_ENV === 'development',
  });

  // Set user context from cookies (consistent bucketing)
  gb.setAttributes({
    id: cookies.get('user_id')?.value || 'anonymous',
    segment: cookies.get('user_segment')?.value || 'guest',
  });

  // Run experiment
  const experiment = await gb.runExperiment({
    id: experimentId,
    variations: ['control', 'treatment'],
    weights: [0.5, 0.5], // 50/50 split
  });

  return experiment.result.value;
}

# docker-compose.flagsmith.yml
version: '3.8'
services:
  flagsmith:
    image: flagsmith/flagsmith:8.0
    ports:
      - "8000:8000"
    environment:
      - FLAGSMITH_INFRASTRUCTURE__DATABASE__URL=postgresql://flagsmith:flagsmith@postgres:5432/flagsmith
      - FLAGSMITH_INFRASTRUCTURE__REDIS__URL=redis://redis:6379/0
      - FLAGSMITH_FEATURES__ENABLE_REALTIME=true
    depends_on:
      - postgres
      - redis
  postgres:
    image: postgres:16
    environment:
      - POSTGRES_USER=flagsmith
      - POSTGRES_PASSWORD=flagsmith
      - POSTGRES_DB=flagsmith
    volumes:
      - postgres_data:/var/lib/postgresql/data
  redis:
    image: redis:7.2
    volumes:
      - redis_data:/data
volumes:
  postgres_data:
  redis_data: