Feature Flags im großen Maßstab

// ❌ Hard-coded flag — requires redeployment to change
const NEW_CHECKOUT = true;
 
if (NEW_CHECKOUT) {
  renderNewCheckout();
} else {
  renderLegacyCheckout();
}
 
// ✅ Runtime flag — changeable without deployment
const flags = await getFeatureFlags(userId);
 
if (flags.isEnabled("new-checkout")) {
  renderNewCheckout();
} else {
  renderLegacyCheckout();
}

interface FeatureFlag {
  key: string;
  enabled: boolean;
  rolloutPercentage: number;
  allowedUserIds: string[];
  rules: FlagRule[];
}
 
interface FlagRule {
  attribute: string;
  operator: "eq" | "in" | "gt" | "lt";
  value: unknown;
}
 
class FeatureFlagService {
  private flags: Map<string, FeatureFlag>;
 
  constructor(flags: FeatureFlag[]) {
    this.flags = new Map(flags.map((f) => [f.key, f]));
  }
 
  isEnabled(key: string, context: FlagContext): boolean {
    const flag = this.flags.get(key);
    if (!flag) return false;
    if (!flag.enabled) return false;
 
    // Explicit allow list
    if (flag.allowedUserIds.includes(context.userId)) return true;
 
    // Rule-based targeting
    if (flag.rules.length > 0) {
      return flag.rules.every((rule) => this.evaluateRule(rule, context));
    }
 
    // Percentage rollout — deterministic per user
    if (flag.rolloutPercentage < 100) {
      const hash = this.hashUserForFlag(context.userId, key);
      return hash < flag.rolloutPercentage;
    }
 
    return true;
  }
 
  private hashUserForFlag(userId: string, flagKey: string): number {
    // Deterministic hash — same user always gets same result
    let hash = 0;
    const input = `${userId}:${flagKey}`;
    for (let i = 0; i < input.length; i++) {
      hash = (hash * 31 + input.charCodeAt(i)) | 0;
    }
    return Math.abs(hash) % 100;
  }
 
  private evaluateRule(rule: FlagRule, context: FlagContext): boolean {
    const value = context[rule.attribute];
    switch (rule.operator) {
      case "eq": return value === rule.value;
      case "in": return (rule.value as unknown[]).includes(value);
      case "gt": return (value as number) > (rule.value as number);
      case "lt": return (value as number) < (rule.value as number);
      default: return false;
    }
  }
}

// Rollout strategy for a major feature
const rolloutStages = [
  { percentage: 0, allowList: ["internal-team-ids"], duration: "2 days" },
  { percentage: 5, allowList: [], duration: "3 days" },
  { percentage: 25, allowList: [], duration: "2 days" },
  { percentage: 50, allowList: [], duration: "2 days" },
  { percentage: 100, allowList: [], duration: "permanent" },
];

// Monitor error rates at each stage
function shouldProceedToNextStage(metrics: StageMetrics): boolean {
  const errorRateThreshold = 0.01; // 1%
  const latencyP99Threshold = 500; // ms
 
  return (
    metrics.errorRate < errorRateThreshold &&
    metrics.latencyP99 < latencyP99Threshold &&
    metrics.userComplaints === 0
  );
}

// ❌ Stale flags — nobody knows if these are still needed
if (flags.isEnabled("new-checkout")) {
  if (flags.isEnabled("checkout-v2-variant-b")) {
    if (flags.isEnabled("express-checkout")) {
      // How many code paths is this? 2^3 = 8 combinations to test
    }
  }
}
 
// ✅ Clean up flags after full rollout
// 1. Roll out to 100%
// 2. Monitor for 1 week
// 3. Remove the flag check, keep only the new code path
// 4. Delete the flag from the configuration

describe("checkout", () => {
  it("renders new checkout when flag is enabled", () => {
    const flags = new FeatureFlagService([
      { key: "new-checkout", enabled: true, rolloutPercentage: 100, allowedUserIds: [], rules: [] },
    ]);
 
    const result = renderCheckout(flags, testContext);
    expect(result).toContain("Express Checkout");
  });
 
  it("renders legacy checkout when flag is disabled", () => {
    const flags = new FeatureFlagService([
      { key: "new-checkout", enabled: false, rolloutPercentage: 0, allowedUserIds: [], rules: [] },
    ]);
 
    const result = renderCheckout(flags, testContext);
    expect(result).toContain("Standard Checkout");
  });
});