Kill Switch Pattern

curl -X POST https://api.featuresignals.com/v1/projects/{projectID}/flags \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "killswitch-payment-provider",
    "name": "Payment Provider Kill Switch",
    "type": "boolean",
    "defaultValue": true,
    "toggleCategory": "ops",
    "description": "Emergency kill switch for the third-party payment provider. Flip OFF to disable and fall back to queued/cached payments."
  }'

import { FeatureSignalsClient } from '@featuresignals/node';


const client = new FeatureSignalsClient(process.env.FS_API_KEY!, {
  envKey: 'production',
});
await client.waitForReady();


interface PaymentRequest {
  userId: string;
  amount: number;
  currency: string;
  paymentMethodId: string;
}


async function processPayment(req: PaymentRequest) {
  // Check kill switch FIRST — before any payment processing
  const providerActive = client.boolVariation(
    'killswitch-payment-provider',
    { key: req.userId },
    true, // Default ON — if SDK is unreachable, keep the feature active
  );


  if (!providerActive) {
    // Kill switch is OFF — fall back to queued payment
    logger.warn('Payment provider kill switch active — queuing payment', {
      userId: req.userId,
      amount: req.amount,
    });
    return queuePaymentForLater(req);
  }


  // Normal path — call the third-party provider
  try {
    const result = await paymentProvider.charge(req);
    return result;
  } catch (error) {
    logger.error('Payment provider failed', { error, userId: req.userId });


    // Optionally check kill switch again — provider might have been disabled
    // during the request due to cascading failures
    const stillActive = client.boolVariation(
      'killswitch-payment-provider',
      { key: req.userId },
      true,
    );


    if (!stillActive) {
      return queuePaymentForLater(req);
    }


    throw error;
  }
}

package middleware


import (
    "net/http"
    fs "github.com/featuresignals/sdk-go"
)


// KillSwitchMiddleware wraps an HTTP handler with a kill switch check.
// If the kill switch flag is OFF, the handler returns a 503 with a
// Retry-After header instead of processing the request.
func KillSwitchMiddleware(
    client *fs.Client,
    flagKey string,
) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            userID := r.Header.Get("X-User-ID")


            // Check kill switch — default ON
            active := client.BoolVariation(
                flagKey,
                fs.NewContext(userID),
                true,
            )


            if !active {
                w.Header().Set("Retry-After", "60")
                http.Error(w, "Service temporarily unavailable", http.StatusServiceUnavailable)
                return
            }


            next.ServeHTTP(w, r)
        })
    }
}


// Usage in router setup:
// r := chi.NewRouter()
// r.Use(KillSwitchMiddleware(fsClient, "killswitch-payment-provider"))
// r.Post("/api/payments", paymentHandler)

from functools import wraps
from featuresignals import FeatureSignalsClient, EvalContext


client: FeatureSignalsClient = None  # Initialized at app startup


def kill_switch(flag_key: str):
    """Decorator that gates a function behind a kill switch flag."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Extract user context — adjust based on your framework
            user_id = kwargs.get("user_id", "unknown")


            active = client.bool_variation(
                flag_key,
                EvalContext(key=user_id),
                True,  # Default ON
            )


            if not active:
                raise ServiceUnavailableError(
                    f"Kill switch '{flag_key}' is active"
                )


            return func(*args, **kwargs)
        return wrapper
    return decorator




# Usage
@kill_switch("killswitch-payment-provider")
def process_payment(user_id: str, amount: int, currency: str):
    return payment_provider.charge(user_id, amount, currency)

#!/bin/bash
# killswitch-drill.sh — automated fire drill for a kill switch


FLAG_KEY="killswitch-payment-provider"
API_KEY="$FS_API_KEY"
BASE_URL="https://api.featuresignals.com"


echo "=== Kill Switch Fire Drill: $FLAG_KEY ==="
echo ""


# 1. Record start time
START=$(date +%s)


# 2. Flip kill switch OFF
echo "[1/4] Flipping kill switch OFF..."
curl -s -X PATCH \
  "$BASE_URL/v1/flags/by-key/$FLAG_KEY/environments/production" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": false}' > /dev/null


# 3. Wait for propagation and test
echo "[2/4] Waiting for propagation (30s)..."
sleep 30


# 4. Verify fallback
echo "[3/4] Verifying fallback behavior..."
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" \
  -X POST "https://api.example.com/payments" \
  -H "X-User-ID: drill-test-user" \
  -d '{"amount": 100, "currency": "USD"}')


if [ "$RESPONSE" = "202" ]; then
  echo "  ✓ Fallback working (HTTP $RESPONSE — payment queued)"
else
  echo "  ✗ Unexpected response: HTTP $RESPONSE"
fi


# 5. Re-enable kill switch
echo "[4/4] Re-enabling kill switch..."
curl -s -X PATCH \
  "$BASE_URL/v1/flags/by-key/$FLAG_KEY/environments/production" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true}' > /dev/null


END=$(date +%s)
DURATION=$((END - START))
echo ""
echo "=== Drill complete in ${DURATION}s ==="