Datadog: what it is, application monitoring and observability

What is Datadog?

Datadog is a cloud monitoring and observability platform launched in 2010 by Olivier Pomel and Alexis Lê-Quôc. The platform provides a unified dashboard for collecting metrics, logs, and traces from infrastructure, applications, and user devices. Unlike point solutions, Datadog combines APM, logging, infrastructure monitoring, Synthetic Monitoring, and RUM in a single product.

Datadog’s architecture is built on agents — lightweight programs that install on servers or embed into applications. The agent collects data and sends it to the Datadog cloud infrastructure over an encrypted connection. For mobile platforms, Datadog provides native SDKs that work on Android (Kotlin, Java) and iOS (Swift, Objective-C).

According to the Gartner Magic Quadrant for APM and Observability (2024) report, Datadog is recognized as a leader in the observability category with the broadest set of integrated capabilities. The platform is used by companies such as Samsung, Adidas, and Peloton to monitor millions of devices daily.

For mobile teams, Datadog is especially valuable because it links backend performance to the user experience on the device. If an API starts responding slower, Datadog shows not only the server response time but also how it affected launch time or screen rendering on a specific phone model.

Key Platform Components

Infrastructure Monitoring tracks CPU, memory, disk, and network metrics for servers, containers, and Kubernetes clusters. APM (Application Performance Monitoring) collects traces for each request passing through a distributed system and shows latency at each hop. Log Management centralizes all logs — from system to application — with full-text search and the ability to create metrics from logs. Synthetic Monitoring simulates user scenarios from different geographic locations. Real User Monitoring (RUM) collects data from real user devices, including mobile phones and tablets.

Pricing Model

Datadog uses a pay-as-you-go model with per-product pricing: infrastructure hosts, APM hosts, logs (volume in gigabytes), RUM sessions, and Synthetic tests. Each product is billed separately, allowing you to pay only for the features you use. Pricing starts at $15 per host per month for infrastructure monitoring and $1 per 10,000 RUM sessions. Startups can apply for the Datadog for Startups program with up to $100,000 in credits.

Datadog APM and Distributed Tracing

Application Performance Monitoring (APM) in Datadog is a distributed tracing system that tracks each request from entry to completion of all nested operations. APM automatically instruments popular frameworks and libraries: Spring Boot, Django, Express.js, ASP.NET Core, and others. For each request, APM builds a flame graph — a visual representation of execution time across all code paths.

A flame graph shows how long each function call or external service request took. If a database method takes 2 seconds instead of the expected 200 milliseconds, it is immediately visible on the graph. Datadog APM supports OpenTelemetry — an open standard for telemetry collection — allowing you to connect instrumentation from any compatible provider.

According to the Benchling Engineering Blog (2024), migrating to Datadog APM reduced the team’s incident diagnosis time from 45 minutes to 8 minutes through automatic correlation of traces with logs and metrics. The key scenario is trace-to-log correlation: with a single trace ID, you can find all logs related to a specific request without manual searching.

Service Map and Dependencies

Service Map is an automatically built graph of all system services and their interconnections. Each service is displayed as a node, and connections between nodes show which calls occur between services. The node color reflects health status: green — normal operation, yellow — increased latency, red — errors. Service Map helps quickly identify which service is the bottleneck, even without prior knowledge of the architecture.

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 for Mobile Applications

Real User Monitoring (RUM) in Datadog collects data from real user devices — screen load times, touch responsiveness, memory consumption, ANR (Application Not Responding) frequency, and crash rates. The RUM SDK for Android and iOS integrates into the application and automatically creates sessions, grouping all events within a single user interaction.

Each RUM session contains a sequence of events: screen open, button tap, network request, scroll. For each event, Datadog records a timestamp, duration, and device technical characteristics: model, OS, app version, connection type. This allows filtering metrics by specific versions and devices. For example, you can see that launch time increased on Android 14 with a specific Samsung model.

RUM is tightly integrated with APM: if a user session ends with an error on the payment screen, Datadog automatically shows the corresponding backend trace. This speeds up diagnosis by 5-7 times compared to manually matching frontend and backend logs. For mobile teams, RUM also provides watchlist reports — a weekly summary of key metric degradations.

Setting Up RUM Error Monitoring

Datadog RUM automatically collects crash reports with full stacktraces, including source code line numbers. For Android, this works through integration with ACRA or Firebase Crashlytics; for iOS — through PLCrashReporter. Each crash is tied to a user session, allowing you to replay the sequence of actions leading to the crash. RUM also tracks ANR — one of the most critical events for Android applications. If the app is unresponsive for more than 5 seconds, Datadog records the ANR and shows the full thread dump at the time of UI blockage.

Logging and Infrastructure Metrics

Log Management in Datadog centralizes all application and infrastructure logs in a single repository with full-text search. Mobile logs (analytics events, API errors, telemetry) are sent from the device via the SDK and merged with server logs using a common identifier. Datadog automatically parses logs into structured fields: level (INFO, WARN, ERROR), service, host, timestamp, message.

For log filtering, Datadog uses its own query language supporting wildcards, regular expressions, and facets. Logs can be grouped by patterns — Datadog automatically detects recurring patterns and displays them as a single cluster. This is especially useful when parsing thousands of logs from mobile devices: identical errors are grouped, and the developer sees not 10,000 lines but 10 clusters with occurrence frequency.

Metrics are numerical time series collected at intervals from 1 second. Datadog supports three metric types: gauge (current value), count (sum over interval), and rate (rate of change). For mobile applications, custom metrics can track screen open count, key business scenario execution time, or feature usage frequency. Custom metrics are sent via DogStatsD — a StatsD-compatible protocol with Datadog extensions.

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"
            )
        )
    }
}

Integrating Datadog SDK into a Mobile Project

Datadog SDK for Android and iOS provides a unified set of modules: Core (initialization), RUM (user experience monitoring), Logs (log sending), Trace (request tracing). For Android, the SDK is added via Gradle; for iOS — via CocoaPods or Swift Package Manager. After installation, the SDK is initialized in Application.onCreate (Android) or AppDelegate (iOS) by passing a client token, environment, and application name.

For automatic tracing of network requests on Android, OkHttp Interceptor is used; on iOS — NSURLProtocol or URLSession delegate. Datadog also supports integration with popular HTTP clients: Retrofit, Apollo GraphQL, Ktor, Alamofire. After connecting the Interceptor, each HTTP request is automatically linked to a RUM session and APM trace, forming a single chain from client to server.

Gradle Configuration (Android)

dependencies {
    // Main SDK and RUM module
    implementation "com.datadoghq:dd-sdk-android-core:2.15.0"
    implementation "com.datadoghq:dd-sdk-android-rum:2.15.0"
    // OkHttp integration for auto-tracing
    implementation "com.datadoghq:dd-sdk-android-okhttp:2.15.0"
    // NDK crash reporting
    implementation "com.datadoghq:dd-sdk-android-ndk:2.15.0"
}

iOS Initialization (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 Dashboards and Alerts

Datadog provides a graphical dashboard editor where you can combine metric charts, log tables, error distribution treemaps, and SLO widgets. Dashboards support template variables — for example, you can create one dashboard for all services and switch context using a dropdown with the service name. Each dashboard can be published in read-only mode for external stakeholders via a public link.

The Monitors (alerting) system allows setting threshold conditions for any metric: if latency exceeds 500 ms for more than 5 minutes — send a notification to Slack, PagerDuty, or email. Datadog supports composite conditions: “If 5xx errors > 1% and request count > 1000/min, escalate priority to critical.” For mobile teams, the regression detection monitor is especially useful — Datadog automatically compares the current metric with a historical baseline and alerts on statistically significant degradation.

According to Gartner Peer Insights (2024), the mean time to resolve (MTTR) for teams using Datadog monitors with automatic correlation decreases by 35% in the first month after adoption. This is achieved because each alert contains not only the trigger condition but also links to related dashboards, logs, and traces — developers don’t need to switch between tools.