LaunchDarkly: vad är det, funktionella flaggor och hur det fungerar

Vad är LaunchDarkly?

LaunchDarkly är en plattform för hantering av funktionella flaggor, grundad 2014 av Catamorphic Corp. Tjänstens huvuduppgift är att ge utvecklingsteam möjlighet att aktivera, avaktivera och konfigurera applikationsfunktioner i realtid utan att distribuera ny kod.

Till skillnad från det traditionella tillvägagångssättet, där lansering av ny funktionalitet kräver publicering av en version i appbutiken, gör LaunchDarkly det möjligt att ändra beteende på distans. För mobil utveckling är detta särskilt viktigt — granskning i App Store och Google Play tar från några timmar till flera dagar, medan en flagga kan växlas på sekunder.

Hur LaunchDarkly-plattformen fungerar

Arkitekturen för LaunchDarkly bygger på tre komponenter: flagserver, klient-SDK och kontrollpanel. Servern lagrar flaggkonfigurationer, aktiveringsregler och användarsegment. SDK upprätthåller en permanent SSE-anslutning till servern för att ta emot uppdateringar i realtid.

När en flagga ändras i panelen skickar servern en uppdatering till alla anslutna SDK. Fördröjningen är 200–500 millisekunder. Vid förlorad anslutning använder SDK det senaste cachade tillståndet tills kanalen återställs. Detta garanterar att applikationen fortsätter att fungera med de inställningar som var aktuella vid avbrottstidpunkten.

LaunchDarklys kontrollpanel ger ett visuellt gränssnitt för att skapa och hantera flaggor. Panelen visar aktuell status för varje flagga, ändringshistorik med revision av vem och när som ändrade konfigurationen, samt användningsstatistik. För varje miljö kan separata regler konfigureras — en flagga i staging kan vara aktiverad till 100% och i production till 5%.

Nyckelbegrepp i LaunchDarkly

Feature flag är en namngiven omkopplare med regler och mål. Flaggor kan vara boolean, multivariata och JSON. Rules definierar aktiveringsvillkor: till exempel, “aktivera för 10% av Android 12-användare från Tyskland”. Segments grupperar användare efter OS-version, region, enhetsmodell och godtyckliga attribut.

Varje flagga har miljöer: development, staging och production. Detta gör det möjligt att testa en ny funktion i en isolerad miljö innan den aktiveras för riktiga användare. Miljöregler konfigureras oberoende — en flagga kan vara aktiverad i staging och avaktiverad i production.

SDK och integration med mobilapplikationer

LaunchDarkly tillhandahåller inbyggda SDK för Android, iOS, React Native och Flutter. Varje SDK kräver minimal konfiguration: SDK-nyckel och användaridentifierare. Biblioteket hanterar automatiskt anslutning, cachning och felhantering.

Initialisering av Android SDK

För anslutning skapas en LDClient-instans i Application.onCreate. Klienten accepterar konfiguration med mobilnyckel och användarkontext. Efter initialisering anropar applikationen flaggvariationen var som helst i koden med metoden boolVariation.

class MyApplication : Application() {
    private lateinit var ldClient: LDClient

    override fun onCreate() {
        super.onCreate()
        val config = LDConfig.Builder("mobile-key-abc123")
            .build()
        val user = LDUser.Builder("user-unique-id")
            .build()
        ldClient = LDClient.init(this, config, user)
    }
}

Läsning och prenumeration på flaggändringar

Efter initialisering utförs flaggkontroll med en metod. BoolVariation returnerar värdet enligt flaggreglerna. Standardvärdet används om SDK inte kunde hämta konfigurationen. Metoden boolVariationDetail returnerar dessutom orsaken till varför flaggan antog detta värde.

val ldClient = LDClient.get()
val showNewFeature = ldClient.boolVariation(
    "new-checkout-flow",
    false
)
if (showNewFeature) {
    showNewCheckoutScreen()
} else {
    showLegacyCheckoutScreen()
}

A/B-testning och stegvis utrullning via LaunchDarkly

A/B-testning i LaunchDarkly implementeras genom multivariata flaggor. Varje variant tilldelas en procentandel trafik — till exempel ser 50% av användarna den gamla skärmen (variant A) och 50% den nya (variant B). Plattformen registrerar användaren och garanterar att de alltid hamnar i samma grupp.

Stegvis utrullning ökar gradvis andelen användare med tillgång till funktionen. Typiskt schema: 1% — dag ett, 5% — dag två, 25% — dag tre, 100% — efter en vecka. Vid upptäckt av fel avaktiveras flaggan omedelbart för alla. LaunchDarkly integreras med Amplitude, Mixpanel och Google Analytics för att spåra statistik för varje variation.

Statistik och experiment

Plattformen tillhandahåller ett inbyggt experimentsystem som automatiskt beräknar statistisk signifikans av skillnader mellan varianter. Tillgänglig statistik: konvertering, retention, antal sessioner, fel och anpassade händelser. Resultaten visas i panelen med visualisering av konfidensintervall. Experiment kan köras både på produktionstrafik och på separata användarsegment.

Integration av LaunchDarkly med analysplattformar är en annan fördel. Data om flaggor skickas automatiskt till Amplitude, Mixpanel, Google Analytics eller egen datapipeline via Data Export API. Detta gör det möjligt att skapa rapporter om hur varje funktion påverkar viktiga applikationsmått. LaunchDarkly stöder också webhooks för att meddela externa system om ändringar i flaggstatus.

Exempel på LaunchDarkly SDK-integration i Android

Låt oss titta på hela cykeln: lägga till beroende, initialisera och kontrollera flaggan för kraschtelemetri. Funktionen bör endast vara aktiv för testare, inte för riktiga användare. LaunchDarkly SDK för Android är tillgänglig via Maven Central. Version 5.x stöder Kotlin Coroutines och Jetpack Compose för reaktiv mottagning av flagguppdateringar.

För iOS-applikationer tillhandahåller LaunchDarkly stöd för Swift Package Manager och CocoaPods. Swift SDK använder async/await för asynkron initialisering och Combine framework för prenumeration på ändringar. Båda SDK (Android och iOS) stöder bakgrundssynkronisering och cachning i lokal lagring för offline-drift.

Beroende i build.gradle

// app/build.gradle
dependencies {
    implementation "com.launchdarkly:launchdarkly-android-sdk:5.2.0"
}

Flaggkontroll i CrashReporter

I klassen CrashReporter kontrollerar vi flaggan crash-reporting-enabled. Om flaggan är aktiverad för den aktuella användaren — startar vi sändning av kraschrapporter. SDK kommer automatiskt att få den nya statusen när den ändras på servern, men för initialisering räcker en engångskontroll.

class CrashReporter {
    fun init() {
        val client = LDClient.get()
        if (client.boolVariation("crash-reporting-enabled", false)) {
            Crashlytics.start()
        }
    }
}

Typiska scenarier och antimönster

Framgångsrika scenarier: hantering av betalningsflöde med omedelbar avaktivering vid leverantörsstörningar, stegvis utrullning av UI-ändringar med övervakning av statistik, personalisering av innehåll per segment. Enligt den officiella bloggen för LaunchDarkly förkortar team återhämtningstiden efter fel från timmar till minuter.

Antimönster: användning av flaggor för permanent villkorslogik (flaggor är tillfälliga), lagring av hemligheter i flaggattribut, skapande av överlappande regler. Rekommendation: ta bort flaggan från koden efter slutförd utrullning — detta förhindrar teknisk skuld och komplicering av kodbasen. Ett annat vanligt misstag är att använda flaggor som långlivade omkopplare som aldrig tas bort från koden efter stabilisering av funktionen.

En korrekt strategi för flagghantering inkluderar en borttagningsplan för varje ny flagga. LaunchDarkly tillhandahåller inbyggda verktyg för att upptäcka oanvända flaggor — en flagga anses oanvänd om SDK inte har kontrollerat dess värde på mer än 30 dagar. Sådana flaggor markeras i panelen och kan säkert tas bort från koden.

När man bör avstå från LaunchDarkly

För små projekt med ett team kan LaunchDarkly vara överdrivet — en enkel villkorssats i koden eller Firebase Remote Config räcker. Välj plattformen när komplex segmentering, ändringsrevision, A/B-experiment eller flerteamshantering av flaggor krävs. För startups och MVP-projekt erbjuder LaunchDarkly en gratis Starter-plan med begränsning av antalet flaggor och MAU.

Kompatibilitet mellan LaunchDarkly och befintliga verktyg är ett viktigt urvalskriterium. Plattformen integreras med Jira, Slack, PagerDuty, Datadog och andra tjänster via webhooks och API. Team som redan använder dessa verktyg får sömlös integration utan ytterligare infrastruktur för övervakning och meddelanden vid ändring av flaggstatus. LaunchDarkly stöder också Terraform-leverantör för att hantera flaggor som kod (Flags as Code) — detta gör det möjligt att lagra flaggkonfiguration i Git och genomgå kodgranskning innan applicering.