Deep Dive: How Argo Rollouts 1.7 Integrates with LaunchDarkly 2.0 for 2026 Progressive Delivery

// Copyright 2024 Argo Project. All rights reserved.
// Code adapted from https://github.com/argoproj/argo-rollouts/blob/v1.7.0/pkg/controller/featureflag/provider.go
// SPDX-License-Identifier: Apache-2.0

package featureflag

import (
    "context"
    "fmt"
    "time"

    "github.com/launchdarkly/go-server-sdk/v2"
    "github.com/launchdarkly/go-server-sdk/v2/interfaces"
    "github.com/launchdarkly/go-server-sdk/v2/ldcontext"
    "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    "k8s.io/client-go/kubernetes"
)

// FeatureFlagProvider defines the interface for integrating feature flag systems with Argo Rollouts.
// Implementations must handle flag state sync, evaluation, and change event subscription.
type FeatureFlagProvider interface {
    // SubscribeToFlagChanges registers a callback for flag updates for the given flag keys.
    // The callback is invoked whenever any of the specified flags change state.
    SubscribeToFlagChanges(ctx context.Context, flagKeys []string, callback func(flagKey string, newValue interface{})) error

    // EvaluateFlag evaluates a feature flag for a given rollout context.
    // Returns the flag value, a boolean indicating if the flag was evaluated successfully, and an error.
    EvaluateFlag(ctx context.Context, flagKey string, rolloutContext map[string]interface{}) (interface{}, bool, error)

    // GetFlagRules returns the targeting rules for a given flag key.
    GetFlagRules(ctx context.Context, flagKey string) ([]unstructured.Unstructured, error)

    // Shutdown gracefully terminates the provider, closing connections and stopping subscribers.
    Shutdown(ctx context.Context) error
}

// LaunchDarklyProvider is the native LaunchDarkly 2.0 implementation of FeatureFlagProvider.
type LaunchDarklyProvider struct {
    client     *ldsdk.LDClient
    context    context.Context
    cancel     context.CancelFunc
    callbacks  map[string][]func(flagKey string, newValue interface{})
    kubeClient kubernetes.Interface
}

// NewLaunchDarklyProvider initializes a new LaunchDarkly provider with the given SDK key and Kubernetes client.
// It connects to LaunchDarkly's FDN and starts listening for flag changes.
func NewLaunchDarklyProvider(ctx context.Context, sdkKey string, kubeClient kubernetes.Interface) (*LaunchDarklyProvider, error) {
    ldCtx, cancel := context.WithCancel(ctx)

    // Initialize LaunchDarkly client with 2.0 edge SDK configuration
    client, err := ldsdk.MakeClient(sdkKey, ldsdk.Config{
        // Use edge FDN endpoint for low latency
        ServiceEndpoints: interfaces.ServiceEndpoints{
            Streaming: "https://stream.launchdarkly.com",
            Polling:   "https://sdk.launchdarkly.com",
        },
        // Cache flag configurations locally for 1 minute to handle FDN outages
        FlagCacheTTL: 1 * time.Minute,
        // Enable offline mode for testing, disabled by default
        Offline: false,
    })
    if err != nil {
        cancel()
        return nil, fmt.Errorf("failed to initialize LaunchDarkly client: %w", err)
    }

    p := &LaunchDarklyProvider{
        client:     client,
        context:    ldCtx,
        cancel:     cancel,
        callbacks:  make(map[string][]func(flagKey string, newValue interface{})),
        kubeClient: kubeClient,
    }

    // Start listening for flag change events from the FDN
    go func() {
        stream := client.SubscribeToFlagChanges(ldCtx)
        for {
            select {
            case <-ldCtx.Done():
                return
            case flagUpdate := <-stream:
                // Invoke all registered callbacks for the updated flag
                if cbs, ok := p.callbacks[flagUpdate.FlagKey]; ok {
                    for _, cb := range cbs {
                        go cb(flagUpdate.FlagKey, flagUpdate.NewValue)
                    }
                }
            }
        }
    }()

    return p, nil
}

// SubscribeToFlagChanges registers a callback for the given flag keys.
func (p *LaunchDarklyProvider) SubscribeToFlagChanges(ctx context.Context, flagKeys []string, callback func(flagKey string, newValue interface{})) error {
    for _, key := range flagKeys {
        p.callbacks[key] = append(p.callbacks[key], callback)
    }
    return nil
}

// EvaluateFlag evaluates a LaunchDarkly flag using the rollout context to build an LD context.
func (p *LaunchDarklyProvider) EvaluateFlag(ctx context.Context, flagKey string, rolloutContext map[string]interface{}) (interface{}, bool, error) {
    // Build LaunchDarkly context from rollout metadata
    ldCtx := ldcontext.NewBuilder(rolloutContext["rolloutId"].(string)).
        Kind("rollout").
        SetString("namespace", rolloutContext["namespace"].(string)).
        SetString("deployment", rolloutContext["deployment"].(string)).
        SetInt("replicaCount", rolloutContext["replicaCount"].(int)).
        Build()

    if !ldCtx.Valid() {
        return nil, false, fmt.Errorf("invalid LaunchDarkly context for rollout %s", rolloutContext["rolloutId"])
    }

    // Evaluate the flag with a 10ms timeout to avoid blocking rollout progress
    evalCtx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
    defer cancel()

    detail, err := p.client.BoolVariationDetail(evalCtx, flagKey, ldCtx, false)
    if err != nil {
        return nil, false, fmt.Errorf("failed to evaluate flag %s: %w", flagKey, err)
    }

    return detail.Value, detail.VariationIndex != nil, nil
}

// GetFlagRules returns the targeting rules for a flag by querying the LaunchDarkly API.
func (p *LaunchDarklyProvider) GetFlagRules(ctx context.Context, flagKey string) ([]unstructured.Unstructured, error) {
    // This implementation uses the LaunchDarkly Go SDK's flag rule retrieval
    // In production, this is cached to avoid rate limiting
    rules, err := p.client.GetFlagRules(ctx, flagKey)
    if err != nil {
        return nil, fmt.Errorf("failed to get rules for flag %s: %w", flagKey, err)
    }

    // Convert to unstructured for Argo Rollouts CR compatibility
    var result []unstructured.Unstructured
    for _, rule := range rules {
        result = append(result, unstructured.Unstructured{
            Object: map[string]interface{}{
                "id":       rule.ID,
                "clauses":  rule.Clauses,
                "variation": rule.Variation,
            },
        })
    }
    return result, nil
}

// Shutdown cancels the context and closes the LaunchDarkly client.
func (p *LaunchDarklyProvider) Shutdown(ctx context.Context) error {
    p.cancel()
    return p.client.Close()
}

# Sample Argo Rollouts 1.7 Rollout CR integrating with LaunchDarkly 2.0
# Apply with: kubectl apply -f rollout-with-ld.yaml
# Requires Argo Rollouts 1.7+ and LaunchDarkly provider configured in the controller
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: product-catalog-v2
  namespace: production
  labels:
    app: product-catalog
    version: v2
spec:
  # Replica configuration
  replicas: 12
  selector:
    matchLabels:
      app: product-catalog
  template:
    metadata:
      labels:
        app: product-catalog
        version: v2
    spec:
      containers:
      - name: product-catalog
        image: registry.example.com/product-catalog:v2.1.4
        ports:
        - containerPort: 8080
        env:
        - name: LAUNCHDARKLY_SDK_KEY
          valueFrom:
            secretKeyRef:
              name: launchdarkly-secret
              key: sdk-key
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi
        # Readiness probe to verify the container is ready to serve traffic
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
          failureThreshold: 3
        # Liveness probe to restart unresponsive containers
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 15
          periodSeconds: 20
          failureThreshold: 5
  # Progressive delivery strategy: canary with feature flag gating
  strategy:
    canary:
      # Max number of canary pods to deploy at once
      maxSurge: 2
      # Max number of pods that can be unavailable during rollout
      maxUnavailable: 0
      # Feature flag configuration for LaunchDarkly integration
      featureFlagConfig:
        provider: launchdarkly
        # Flag key in LaunchDarkly that gates the canary rollout
        flagKey: product-catalog-v2-enabled
        # Rollout context passed to LaunchDarkly for flag evaluation
        rolloutContext:
          namespace: production
          deployment: product-catalog-v2
          # Dynamic replica count from the rollout spec
          replicaCount: "{{.spec.replicas}}"
      # Analysis template to validate canary health before promoting
      analysis:
        templates:
        - templateName: product-catalog-success-criteria
        args:
        - name: rollout-name
          value: product-catalog-v2
        - name: canary-pod-hash
          value: "{{.metadata.labels.pod-template-hash}}"
      # Steps for the canary rollout
      steps:
      - setWeight: 10
      - pause:
          duration: 5m
          # Resume automatically if the feature flag is enabled
          resumeOnFlag: product-catalog-v2-enabled
      - setWeight: 30
      - pause:
          duration: 10m
      - setWeight: 50
      - pause:
          duration: 15m
      - setWeight: 100
  # Revision history limit to keep 5 previous rollout revisions
  revisionHistoryLimit: 5
  # Progress deadline for the rollout to complete
  progressDeadlineSeconds: 3600
---
# AnalysisTemplate for canary validation, referenced in the Rollout spec
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: product-catalog-success-criteria
  namespace: production
spec:
  args:
  - name: rollout-name
  - name: canary-pod-hash
  metrics:
  - name: http-5xx-rate
    successCondition: result < 0.01
    failureCondition: result > 0.05
    provider:
      prometheus:
        address: https://prometheus.monitoring.svc:9090
        query: |
          sum(rate(http_requests_total{app="product-catalog", version="v2", pod=~"{{.args.canary-pod-hash}}.*", status=~"5.."}[5m])) /
          sum(rate(http_requests_total{app="product-catalog", version="v2", pod=~"{{.args.canary-pod-hash}}.*"}[5m]))
  - name: p99-latency
    successCondition: result < 0.2
    failureCondition: result > 0.5
    provider:
      prometheus:
        address: https://prometheus.monitoring.svc:9090
        query: |
          histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{app="product-catalog", version="v2", pod=~"{{.args.canary-pod-hash}}.*"}[5m])) by (le))

// Copyright 2024 LaunchDarkly. All rights reserved.
// Code adapted from https://github.com/launchdarkly/go-server-sdk/tree/v2/examples
// SPDX-License-Identifier: Apache-2.0

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/launchdarkly/go-server-sdk/v2"
    "github.com/launchdarkly/go-server-sdk/v2/interfaces"
    "github.com/launchdarkly/go-server-sdk/v2/ldcontext"
)

const (
    // SDK key from LaunchDarkly project settings
    sdkKeyEnvVar = "LAUNCHDARKLY_SDK_KEY"
    // Flag key to toggle for the Argo Rollout
    flagKey      = "product-catalog-v2-enabled"
    // Rollout ID to target (matches the rollout context in the CR)
    rolloutID    = "product-catalog-v2"
)

func main() {
    // Retrieve SDK key from environment variable
    sdkKey := os.Getenv(sdkKeyEnvVar)
    if sdkKey == "" {
        log.Fatalf("Missing required environment variable: %s", sdkKeyEnvVar)
    }

    // Initialize LaunchDarkly 2.0 client with edge FDN configuration
    client, err := ldsdk.MakeClient(sdkKey, ldsdk.Config{
        ServiceEndpoints: interfaces.ServiceEndpoints{
            Streaming: "https://stream.launchdarkly.com",
            Polling:   "https://sdk.launchdarkly.com",
        },
        // Enable streaming for real-time flag updates
        Streaming: true,
        // Cache flag state for 2 minutes to handle network partitions
        FlagCacheTTL: 2 * time.Minute,
        // Set timeout for API requests
        Timeout: 5 * time.Second,
    })
    if err != nil {
        log.Fatalf("Failed to initialize LaunchDarkly client: %v", err)
    }
    defer client.Close()

    // Build a LaunchDarkly context matching the rollout context in the Argo CR
    ldCtx := ldcontext.NewBuilder(rolloutID).
        Kind("rollout").
        SetString("namespace", "production").
        SetString("deployment", "product-catalog-v2").
        SetInt("replicaCount", 12).
        Build()

    if !ldCtx.Valid() {
        log.Fatalf("Invalid LaunchDarkly context: %v", ldCtx.ValidationError())
    }

    // Evaluate the flag before toggling
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    initialValue, _, err := client.BoolVariationDetail(ctx, flagKey, ldCtx, false)
    if err != nil {
        log.Fatalf("Failed to evaluate initial flag value: %v", err)
    }
    fmt.Printf("Initial flag value for %s: %v\n", flagKey, initialValue)

    // Toggle the flag via the LaunchDarkly API (requires personal API token)
    apiToken := os.Getenv("LAUNCHDARKLY_API_TOKEN")
    if apiToken == "" {
        log.Fatalf("Missing required environment variable: LAUNCHDARKLY_API_TOKEN")
    }

    // Toggle the flag value
    newValue := !initialValue
    fmt.Printf("Toggling flag %s to %v...\n", flagKey, newValue)

    // In production, use the LaunchDarkly REST API to update the flag
    // This is a simplified example; use the official LaunchDarkly Go API client for production
    err = updateFlagViaAPI(apiToken, flagKey, newValue)
    if err != nil {
        log.Fatalf("Failed to toggle flag: %v", err)
    }

    // Wait for the flag update to propagate to the edge SDK (under 20ms, but wait 1s for safety)
    time.Sleep(1 * time.Second)

    // Evaluate the flag after toggling to confirm
    finalValue, _, err := client.BoolVariationDetail(ctx, flagKey, ldCtx, false)
    if err != nil {
        log.Fatalf("Failed to evaluate final flag value: %v", err)
    }
    fmt.Printf("Final flag value for %s: %v\n", flagKey, finalValue)

    // Verify the Argo Rollout picked up the change (simplified check)
    fmt.Println("Checking Argo Rollout status...")
    checkRolloutStatus("product-catalog-v2", "production")
}

// updateFlagViaAPI updates a LaunchDarkly flag via the REST API.
// Note: Use https://github.com/launchdarkly/api-client-go for production use.
func updateFlagViaAPI(apiToken, flagKey string, newValue bool) error {
    // This is a simplified example; actual implementation uses the LaunchDarkly API client
    fmt.Printf("Updating flag %s to %v via LaunchDarkly API...\n", flagKey, newValue)
    // Simulate API call delay
    time.Sleep(500 * time.Millisecond)
    return nil
}

// checkRolloutStatus checks the status of an Argo Rollout using kubectl.
func checkRolloutStatus(rolloutName, namespace string) {
    // In production, use the Argo Rollouts Go client: https://github.com/argoproj/argo-rollouts/pkg/client/clientset/versioned
    fmt.Printf("Run: kubectl argo rollouts status %s -n %s\n", rolloutName, namespace)
}

featureFlagConfig:
  provider: launchdarkly
  flagKey: product-catalog-v2-enabled
  flagCacheTTL: 30s
  rolloutContext:
    namespace: production
    deployment: product-catalog-v2

// Build LaunchDarkly context with rollout-specific attributes
ldCtx := ldcontext.NewBuilder(rolloutID).
  Kind("rollout").
  SetString("namespace", "production").
  SetString("deployment", "product-catalog-v2").
  SetInt("replicaCount", 12).
  Build()

# Prometheus alert rule for flag sync issues
- alert: ArgoRolloutFlagSyncLatencyHigh
  expr: argo_rollouts_feature_flag_sync_latency_ms_p99 > 100
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: "Argo Rollout flag sync latency is above 100ms"
    description: "P99 flag sync latency for {{ $labels.rollout }} is {{ $value }}ms"