Datadog: vad är det, applikationsövervakning och observerbarhet

Vad är Datadog?

Datadog är en molnplattform för övervakning och observerbarhet, lanserad 2010 av Olivier Pomel och Alexis Le-Quioc. Plattformen erbjuder en enda panel för att samla in mätvärden, loggar och spårningar från infrastruktur, applikationer och användarenheter. Till skillnad från punktlösningar kombinerar Datadog APM, loggar, infrastruktursövervakning, Synthetic Monitoring och RUM i en enda produkt.

Arkitekturen i Datadog är uppbyggd kring agenter – lätta program som installeras på servrar eller bäddas in i applikationer. Agenten samlar in data och skickar den till Datadogs molninfrastruktur via en krypterad anslutning. För mobila plattformar erbjuder Datadog inbyggda SDK:er som fungerar på Android (Kotlin, Java) och iOS (Swift, Objective-C).

Enligt rapporten Gartner Magic Quadrant for APM and Observability (2024) har Datadog erkänts som ledare inom kategorin observerbarhet med den bredaste uppsättningen integrerade funktioner. Plattformen används av företag som Samsung, Adidas och Peloton för daglig övervakning av miljontals enheter.

För mobila team är Datadog särskilt värdefullt eftersom det gör det möjligt att koppla backend-prestanda till användarupplevelsen på enheten. Om ett API börjar svara långsammare visar Datadog inte bara serverns svarstid utan också hur detta påverkade starttiden eller skärmrenderingen på en specifik telefonmodell.

Viktiga komponenter i plattformen

Infrastructure Monitoring spårar CPU-, minnes-, disk- och nätverksmätvärden för servrar, containrar och Kubernetes-kluster. APM (Application Performance Monitoring) samlar in spårningar för varje begäran som passerar genom ett distribuerat system och visar fördröjningar i varje steg. Log Management centraliserar alla loggar – från system till applikation – med möjlighet till fulltextsökning och skapande av mätvärden baserat på loggar. Synthetic Monitoring simulerar användarscenarier från olika geografiska platser. Real User Monitoring (RUM) samlar in data från verkliga användarenheter, inklusive telefoner och surfplattor.

Prismodell

Datadog använder en pay-as-you-go-modell med uppdelning per produkt: infrastrukturservrar, APM-servrar, loggar (volym i gigabyte), RUM-sessioner och Synthetic-tester. Varje produkt faktureras separat, vilket gör att du bara betalar för de funktioner du använder. Priset börjar från 15 dollar per server per månad för infrastruktursövervakning och från 1 dollar för 10 000 RUM-sessioner. För startups finns programmet Datadog for Startups med krediter upp till 100 000 dollar.

Datadog APM och Distributed Tracing

Application Performance Monitoring (APM) i Datadog är ett distributed tracing-system som spårar varje begäran från det ögonblick det kommer in i systemet tills alla kapslade operationer är slutförda. APM instrumenterar automatiskt populära ramverk och bibliotek: Spring Boot, Django, Express.js, ASP.NET Core och andra. För varje begäran skapar APM en flame graph – en visuell representation av exekveringstiden för alla koddelar.

Flame grafen visar hur lång tid varje funktionsanrop eller begäran till en extern tjänst tog. Om en databasmetod körs på 2 sekunder istället för förväntade 200 millisekunder syns detta omedelbart i grafen. Datadog APM stöder OpenTelemetry – en öppen standard för insamling av telemetri, vilket gör det möjligt att ansluta instrumentering från alla kompatibla leverantörer.

Enligt Benchling Engineering Blog (2024) gjorde migreringen till Datadog APM det möjligt för teamet att minska tiden för incidentdiagnos från 45 minuter till 8 minuter tack vare automatisk korrelation av spårningar med loggar och mätvärden. Nyckelscenariot är trace-to-log correlation: med ett enda trace-ID kan alla loggar som rör en specifik begäran hittas utan manuell sökning.

Service Map och beroenden

Service Map är ett automatiskt byggt grafiskt diagram över alla tjänster i systemet och deras inbördes förbindelser. Varje tjänst visas som en nod och förbindelserna mellan noderna visar vilka anrop som görs mellan tjänster. Färgen på noden reflekterar hälsotillståndet: grön – normal drift, gul – ökad fördröjning, röd – fel. Service Map hjälper till att snabbt identifiera vilken tjänst som är en flaskhals, även utan förstudie av arkitekturen.

import datadog.trace.api.Trace;
import io.opentelemetry.api.trace.Span;

public class PaymentService {

    @Trace(resourceName = "PaymentService.processPayment")
    public PaymentResult processPayment(Order order) {
        Span span = Tracer.buildSpan("validate.payment").start();
        try {
            PaymentGateway gateway = new PaymentGateway();
            PaymentResult result = gateway.charge(order.getAmount());
            span.setTag("payment.provider", "stripe");
            return result;
        } finally {
            span.close();
        }
    }
}

Real User Monitoring för mobila appar

Real User Monitoring (RUM) i Datadog samlar in data från verkliga användarenheter – skärmladdningstid, svar på tryckningar, minnesförbrukning, ANR-frekvens (Application Not Responding) och kraschfrekvens. RUM SDK för Android och iOS bäddas in i appen och skapar automatiskt sessioner som grupperar alla händelser inom en användarinteraktion.

Varje RUM-session innehåller en sekvens av händelser: skärmöppning, knapptryckning, nätverksbegäran, rullning. För varje händelse registrerar Datadog en tidsstämpel, varaktighet och tekniska egenskaper för enheten: modell, operativsystem, appversion, anslutningstyp. Detta gör det möjligt att filtrera mätvärden efter specifika versioner och enheter. Till exempel kan man se att starttiden ökade på Android 14 vid användning av en specifik Samsung-modell.

RUM är nära integrerat med APM: om en användarsession slutar med ett fel på betalningsskärmen visar Datadog automatiskt motsvarande spårning från backend. Detta snabbar upp diagnosen med 5-7 gånger jämfört med manuell matchning av frontend- och backendloggar. För mobila team erbjuder RUM även watchlist-rapporter – en veckovis sammanfattning av försämring av nyckeltal.

Konfigurera RUM-övervakning av fel

Datadog RUM samlar automatiskt in kraschrapporter med fullständig stacktrace, inklusive radnummer i källkod. För Android fungerar detta via integration med ACRA eller Firebase Crashlytics, för iOS – via PLCrashReporter. Varje krasch kopplas till användarsessionen, vilket gör det möjligt att återskapa sekvensen av åtgärder som ledde till kraschen. RUM spårar även ANR – en av de mest kritiska händelserna för Android-appar. Om appen inte svarar på mer än 5 sekunder registrerar Datadog ANR och visar en fullständig tråddump vid tidpunkten för UI-blockeringen.

Loggning och infrastrukturmätvärden

Log Management i Datadog centraliserar alla applikations- och infrastruktursloggar i ett enda lager med fulltextsökning. Mobila loggar (analytiska händelser, API-fel, telemetri) skickas från enheten via SDK och kombineras med serverloggar via en gemensam identifierare. Datadog tolkar automatiskt loggarna till strukturerade fält: nivå (INFO, WARN, ERROR), tjänst, värd, tidsstämpel, meddelande.

För filtrering av loggar används ett eget frågespråk med stöd för wildcard, reguljära uttryck och aspekter. Loggar kan grupperas efter mallar – Datadog upptäcker automatiskt återkommande mönster och visar dem som ett enda kluster. Detta är särskilt användbart vid analys av tusentals loggar från mobila enheter: identiska fel grupperas och utvecklaren ser inte 10 000 rader utan 10 kluster med förekomstfrekvens.

Metrics är numeriska tidsserier som samlas in med intervall från 1 sekund. Datadog stöder tre typer av mätvärden: gauge (aktuellt värde), count (summa för intervallet) och rate (förändringshastighet). För mobila appar kan anpassade mätvärden spåra antalet skärmöppningar, exekveringstiden för ett viktigt affärsscenario eller användningsfrekvensen för en specifik funktion. Anpassade mätvärden skickas via DogStatsD – ett protokoll som är kompatibelt med StatsD med Datadog-tillägg.

import com.datadog.android.Datadog
import com.datadog.android.log.Logger

class PaymentAnalytics {

    private val logger = Logger.Builder()
        .setDatadogLogsEnabled(true)
        .setNetworkInfoEnabled(true)
        .setBundleWithTraceEnabled(true)
        .build()

    fun trackCheckout(orderId: String, amount: Double) {
        logger.info(
            "Checkout initiated for order {orderId}",
            mapOf(
                "order.id" to orderId,
                "order.amount" to amount,
                "payment.method" to "credit_card"
            )
        )
    }
}

Integrera Datadog SDK i ett mobilt projekt

Datadog SDK för Android och iOS erbjuder en enhetlig uppsättning moduler: Core (initiering), RUM (övervakning av användarupplevelse), Logs (sändning av loggar), Trace (spårning av begäran). För Android läggs SDK till via Gradle, för iOS – via CocoaPods eller Swift Package Manager. Efter installation initieras SDK i Application.onCreate (Android) eller AppDelegate (iOS) med överföring av client token, environment och applikationsnamn.

För automatisk spårning av nätverksbegäran på Android används OkHttp Interceptor, på iOS – NSURLProtocol eller URLSession delegate. Datadog stöder även integration med populära HTTP-klienter: Retrofit, Apollo GraphQL, Ktor, Alamofire. Efter anslutning av Interceptor kopplas varje HTTP-begäran automatiskt till RUM-sessionen och APM-spårningen, vilket bildar en enda kedja från klient till server.

Konfiguration via Gradle (Android)

dependencies {
    // Huvud-SDK och RUM-modul
    implementation "com.datadoghq:dd-sdk-android-core:2.15.0"
    implementation "com.datadoghq:dd-sdk-android-rum:2.15.0"
    // Integration med OkHttp för automatisk spårning
    implementation "com.datadoghq:dd-sdk-android-okhttp:2.15.0"
    // NDK crash reporting
    implementation "com.datadoghq:dd-sdk-android-ndk:2.15.0"
}

Initiering på iOS (Swift)

import DatadogCore
import DatadogRUM
import DatadogLogs

@main class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Datadog.initialize(
            with: DatadogConfiguration.builder(
                clientToken: "your_client_token",
                environment: "production"
            ).build()
        )
        RUM.enable(
            with: RUMConfiguration(applicationID: "your_rum_app_id")
        )
        return true
    }
}

Datadog instrumentpaneler och aviseringar

Datadog erbjuder en grafisk instrumentpanelsredigerare där du kan kombinera mätvärdesgrafer, loggtabeller, trädkarta över felfördelning och SLO-widgetar. Instrumentpaneler stöder mallvariabler – till exempel kan du skapa en instrumentpanel för alla tjänster och växla kontext via en rullgardinslista med tjänstens namn. Varje instrumentpanel kan publiceras i skrivskyddat läge för externa intressenter via en offentlig länk.

Systemet Monitors (aviseringar) gör det möjligt att ställa in tröskelvillkor för alla mätvärden: om latensen överskrider 500 ms under mer än 5 minuter – skicka en avisering till Slack, PagerDuty eller e-post. Datadog stöder sammansatta villkor: “Om 5xx-fel > 1% och antalet begäran > 1000/min, öka prioriteten till kritisk”. För mobila team är regressionsdetekteringsmonitorn särskilt användbar – Datadog jämför automatiskt det aktuella mätvärdet med den historiska baslinjen och varnar vid statistiskt signifikant försämring.

Enligt Gartner Peer Insights (2024) minskar den genomsnittliga tiden för att lösa en alert (MTTR) i team som använder Datadog-monitorer med automatisk korrelation med 35% under första månaden efter implementering. Detta uppnås genom att varje avisering inte bara innehåller utlösarvillkoret utan även länkar till relaterade instrumentpaneler, loggar och spårningar – utvecklaren behöver inte växla mellan verktyg.