This page lists integrated libraries you can use for Android and Android TV applications.

Coil

If you use Coil to load images in your application, see Datadog's dedicated Coil library.

Fresco

If you use Fresco to load images in your application, see Datadog's dedicated Fresco library.

Glide

If you use Glide to load images in your application, see Datadog's dedicated Glide library.

Jetpack Compose

If you use Jetpack Compose in your application, see Datadog's dedicated Jetpack Compose library.

RxJava

If you use RxJava in your application, see Datadog's dedicated RxJava library.

Picasso

If you use Picasso, use it with the OkHttpClient that's been instrumented with the Datadog SDK for RUM and APM information about network requests made by Picasso.

val picasso = Picasso.Builder(context)
   .downloader(OkHttp3Downloader(okHttpClient))
   // …
   .build()
Picasso.setSingletonInstance(picasso)

final Picasso picasso = new Picasso.Builder(context)
   .downloader(new OkHttp3Downloader(okHttpClient))
   // …
   .build();
Picasso.setSingletonInstance(picasso);

Retrofit

If you use Retrofit, use it with the OkHttpClient that's been instrumented with the Datadog SDK for RUM and APM information about network requests made with Retrofit.

val retrofitClient = Retrofit.Builder()
   .client(okHttpClient)
   // …
   .build()

final Retrofit retrofitClient = new Retrofit.Builder()
   .client(okHttpClient)
   // …
   .build();

SQLDelight

If you use SQLDelight in your application, see Datadog's dedicated SQLDelight library.

SQLite

Following SQLiteOpenHelper's generated API documentation, you only have to provide the implementation of the DatabaseErrorHandler -> DatadogDatabaseErrorHandler in the constructor.

Doing this detects whenever a database is corrupted and sends a relevant RUM error event for it.

class <YourOwnSqliteOpenHelper>: SqliteOpenHelper(
                                 <Context>,
                                 <DATABASE_NAME>,
                                 <CursorFactory>,
                                 <DATABASE_VERSION>,
                                 DatadogDatabaseErrorHandler()) {
   // …

}

public class <YourOwnSqliteOpenHelper> extends SqliteOpenHelper {
   public <YourOwnSqliteOpenHelper>(){
         super(<Context>,
               <DATABASE_NAME>,
               <CursorFactory>,
               <DATABASE_VERSION>,
               new DatadogDatabaseErrorHandler());
   }
}

Apollo (GraphQL)

If you use Apollo (GraphQL) in your application, see Datadog's dedicated library with extensions for Apollo and Android advanced network configuration.

Android TV (Leanback)

If you use the Leanback API to add actions into your Android TV application, see Datadog's dedicated Android TV library.

Kotlin Coroutines

If you use Kotlin Coroutines, see Datadog's dedicated library with extensions for RUM and with extensions for Trace.

This page lists integrated libraries you can use for iOS and tvOS applications.

Alamofire

Starting from version 3.7.0, the RUM iOS SDK automatically tracks Alamofire requests after you enable RUM with urlSessionTracking configuration.

1. Configure RUM monitoring by following the Setup guide.
2. (Optional) For detailed timing breakdown (DNS resolution, SSL handshake, time to first byte, connection time, download duration), enable URLSessionInstrumentation for Alamofire.SessionDelegate:

import Alamofire
import DatadogRUM

URLSessionInstrumentation.enableDurationBreakdown(with: .init(delegateClass: Alamofire.SessionDelegate.self))

For additional information on sampling rate, distributed tracing, and adding custom attributes to tracked RUM resources, see Advanced Configuration > Automatically track network requests.

Apollo GraphQL

Starting from version 3.7.0, the RUM iOS SDK automatically tracks Apollo GraphQL requests after you enable RUM with urlSessionTracking configuration.

1. Configure RUM monitoring by following the Setup guide.
2. (Optional) For detailed timing breakdown (DNS resolution, SSL handshake, time to first byte, connection time, download duration), enable URLSessionInstrumentation for Apollo.URLSessionClient:

import Apollo
import DatadogRUM

URLSessionInstrumentation.enableDurationBreakdown(with: .init(delegateClass: Apollo.URLSessionClient.self))

For additional information on sampling rate, distributed tracing, and adding custom attributes to tracked RUM resources, see Advanced Configuration > Automatically track network requests.

For more advanced Apollo integration using the Datadog Apollo interceptor, see the Datadog Apollo interceptor package and Apollo instrumentation.

SDWebImage

Starting from version 3.7.0, the RUM iOS SDK automatically tracks SDWebImage requests after you enable RUM with urlSessionTracking configuration.

1. Configure RUM monitoring by following the Setup guide.
2. (Optional) For detailed timing breakdown (DNS resolution, SSL handshake, time to first byte, connection time, download duration), enable URLSessionInstrumentation for SDWebImageDownloader:

import SDWebImage
import DatadogRUM

URLSessionInstrumentation.enableDurationBreakdown(with: .init(delegateClass: SDWebImageDownloader.self as! URLSessionDataDelegate.Type))

For additional information on sampling rate, distributed tracing, and adding custom attributes to tracked RUM resources, see Advanced Configuration > Automatically track network requests.

OpenAPI Generator

Starting from version 3.7.0, the RUM iOS SDK automatically tracks OpenAPI Generator requests after you enable RUM with urlSessionTracking configuration.

For detailed timing breakdown (DNS resolution, SSL handshake, time to first byte, connection time, download duration), follow these steps:

1. Configure RUM monitoring by following the Setup guide.
2. Create a dummy URLSessionDataDelegate.
3. Enable URLSessionInstrumentation for EmptySessionDelegate.
4. Configure URLSession with your dummy URLSessionDataDelegate.
5. Create an OpenAPI client with .buffered processing mode.

import DatadogRUM
import OpenAPIRuntime
import OpenAPIURLSession

// Dummy delegate
class EmptySessionDelegate: NSObject, URLSessionDataDelegate {}

// Create `URLSession` with your delegate
let delegate = EmptySessionDelegate()
let urlSession = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)

// Enable instrumentation for your delegate class
URLSessionInstrumentation.enableDurationBreakdown(with: .init(delegateClass: EmptySessionDelegate.self))

// Create transport with `.buffered` processing mode (required for proper instrumentation)
let transport = URLSessionTransport(configuration: .init(
    session: urlSession,
    httpBodyProcessingMode: .buffered
))

// Create the OpenAPI client
bufferedClient = Client(
    serverURL: try! Servers.Server1.url(),
    transport: transport
)

For additional information on sampling rate, distributed tracing, and adding custom attributes to tracked RUM resources, see Advanced Configuration > Automatically track network requests.

This page lists integrated libraries you can use for Flutter applications.

Routing and automatic view tracking

If you are using Flutter Navigator v2.0, your setup for automatic view tracking differs depending on your routing middleware. This section explains how to integrate with the most popular routing packages.

go_router

Because go_router uses the same observer interface as Flutter Navigator v1, you can add DatadogNavigationObserver to other observers as a parameter to GoRouter.

final _router = GoRouter(
  routes: [
    // Your route information here
  ],
  observers: [
    DatadogNavigationObserver(datadogSdk: DatadogSdk.instance),
  ],
);
MaterialApp.router(
  routerConfig: _router,
  // Your remaining setup
);

If you are using ShellRoutes, you need to supply a separate observer to each ShellRoute, as shown below. See this bug for more information.

final _router = GoRouter(
  routes: [
    ShellRoute(build: shellBuilder),
    routes: [
      // Additional routes
    ],
    observers: [
      DatadogNavigationObserver(datadogSdk: DatadogSdk.instance),
    ],
  ],
  observers: [
    DatadogNavigationObserver(datadogSdk: DatadogSdk.instance),
  ],
);
MaterialApp.router(
  routerConfig: _router,
  // Your remaining setup
);

Additionally, if you are using GoRoute's pageBuilder parameter over its builder parameter, make sure you are passing on the state.pageKey value and the name value to your MaterialPage.

GoRoute(
  name: 'My Home',
  path: '/path',
  pageBuilder: (context, state) {
    return MaterialPage(
      key: state.pageKey,       // Necessary for GoRouter to call Observers
      name: name,               // Needed for Datadog to get the right route name
      child: _buildContent(),
    );
  },
),

AutoRoute

AutoRoute can use a DatadogNavigationObserver provided as one of the navigatorObservers as part of its config method.

return MaterialApp.router(
  routerConfig: _router.config(
    navigatorObservers: () => [
      DatadogNavigationObserver(
        datadogSdk: DatadogSdk.instance,
      ),
    ],
  ),
  // Your remaining setup
);

However, if you are using AutoRoute's tab routing, you need to extend Datadog's default observer with AutoRoute's AutoRouteObserver interface.

class DatadogAutoRouteObserver extends DatadogNavigationObserver
    implements AutoRouterObserver {
  DatadogAutoRouteObserver({required super.datadogSdk});

  // only override to observer tab routes
  @override
  void didInitTabRoute(TabPageRoute route, TabPageRoute? previousRoute) {
    datadogSdk.rum?.startView(route.path, route.name);
  }

  @override
  void didChangeTabRoute(TabPageRoute route, TabPageRoute previousRoute) {
    datadogSdk.rum?.startView(route.path, route.name);
  }
}

This new object replaces the simpler DatadogNavigationObserver.

Beamer

Beamer can use the DatadogNavigationObserver as an argument to BeamerDelegate:

final routerDelegate = BeamerDelegate(
  locationBuilder: RoutesLocationBuilder(
    routes: {
      // Your route config
    },
  ),
  navigatorObservers: [
    DatadogNavigationObserver(DatadogSdk.instance),
  ]
);

Web view tracking

Real User Monitoring allows you to monitor web views and eliminate blind spots in your hybrid mobile applications.

The Datadog Flutter SDK has packages for working with both webview_flutter and flutter_inappwebview. For more information, see the Web View Tracking documentation page.

gRPC

Datadog provides datadog_grpc_interceptor for use with the grpc Flutter package. The gRPC interceptor automatically tracks gRPC requests as RUM Resources and enables distributed tracing with APM.

Setup

Add datadog_grpc_interceptor to your pubspec.yaml or by running flutter pub add datadog_grpc_interceptor from your terminal:

dependencies:
  # Other dependencies
  datadog_grpc_interceptor: ^1.1.0

To use this plugin, create an instance of DatadogGrpcInterceptor, then pass it to your generated gRPC client:

import 'package:datadog_grpc_interceptor/datadog_grpc_interceptor.dart'

// Initialize Datadog - be sure to set the [DatadogConfiguration.firstPartyHosts] member
// Enable Datadog Distributed Tracing
final config = DatadogConfiguration(
  // ...
  firstPartyHosts = ['localhost']
)

// Create the gRPC channel
final channel = ClientChannel(
  'localhost',
  port: 50051,
  options: ChannelOptions(
    // ...
  ),
);

// Create the gRPC interceptor with the supported channel
final datadogInterceptor = DatadogGrpcInterceptor(DatadogSdk.instance, channel);

// Create the gRPC client, passing in the Datadog interceptor
final stub = GreeterClient(channel, interceptors: [datadogInterceptor]);

GraphQL (gql_link)

Datadog provides datadog_gql_link for use with most GraphQL Flutter libraries, including graphql_flutter and ferry. The link automatically tracks GraphQL requests as RUM resources, adds query names, mutation names, and variables as attributes of the Resource, and enables distributed tracing in APM.

Setup

Add datadog_gql_link to your pubspec.yaml or by running flutter pub add datadog_gql_link from your terminal:

dependencies:
  # Other dependencies
  datadog_gql_link: ^1.0.0

When creating your GraphQL link, add the DatadogGqlLink above your terminating link. For example:

final graphQlUrl = "https://example.com/graphql";

final link = Link.from([
  DatadogGqlLink(DatadogSdk.instance, Uri.parse(graphQlUrl)),
  HttpLink(graphQlUrl),
]);

If you are tracking non-GraphQL network calls with datadog_tracking_http_client, you need to configure the tracking plugin to ignore requests to your GraphQL endpoint. Otherwise, GraphQL resources are reported twice, and APM traces may be broken. Ignore your GraphQL endpoint by using the ignoreUrlPatterns parameter added to datadog_tracking_http_client version 2.1.0.

final datadogConfig = DatadogConfiguration(
    // Your configuration
  )..enableHttpTracking(
      ignoreUrlPatterns: [
        RegExp('example.com/graphql'),
      ],
    );

Dio

Datadog provides datadog_dio for use with the Dio Flutter package. The Dio interceptor automatically tracks requests from a given Dio client as RUM Resources and enables distributed tracing with APM.

Setup

Add datadog_dio to your pubspec.yaml or by running flutter pub add datadog_dio from your terminal:

dependencies:
  # Other dependencies
  datadog_dio: ^1.0.0

To use this plugin, call addDatadogInterceptor at the end of your Dio initialization:

import 'package:datadog_dio/datadog_dio.dart'

// Initialize Datadog - be sure to set the [DatadogConfiguration.firstPartyHosts] member
// Enable Datadog Distributed Tracing
final config = DatadogConfiguration(
  // ...
  firstPartyHosts = ['localhost']
)

// Create our Dio client
final dio = Dio()
  // Dio configuration...
  ..addDatadogInterceptor(DatadogSdk.instance);

Calling addDatadogInterceptor adds the Datadog interceptor as the first interceptor in your list, so all network requests from Dio are sent to Datadog, since other interceptors may not forward information down the chain. Call addDatadogInterceptor after completing all other Dio configuration.

Use with other Datadog network tracking

To track all network requests, including those made by dart:io and widgets like NetworkImage, use datadog_tracking_http_client to capture these requests. However, depending on your setup, the global override method used in enableHttpTracking may cause resources to be double reported (once by the global override and once by the Dio interceptor).

To avoid this, use the ignoreUrlPatterns parameter when calling enableHttpTracking to ignore requests made by your Dio client.

This page lists integrated libraries you can use for React Native applications.

React Navigation

Setup

Note: This package is an integration for react-navigation library. Make sure you first install and set up the core mobile-react-native SDK.

To install with npm, run:

npm install @datadog/mobile-react-navigation

To install with Yarn, run:

yarn add @datadog/mobile-react-navigation

Track view navigation

To track changes in navigation as RUM Views, set the onReady callback of your NavigationContainer component as follow. You can use the optional ViewNamePredicate parameter to replace the automatically detected View name with something more relevant to your use case.

Returning null in the ViewNamePredicate prevents the new RUM View from being created. The previous RUM View remains active.

import * as React from 'react';
import { DdRumReactNavigationTracking, ViewNamePredicate } from '@datadog/mobile-react-navigation';
import { Route } from "@react-navigation/native";

const viewNamePredicate: ViewNamePredicate = function customViewNamePredicate(route: Route<string, any | undefined>, trackedName: string) {
  return "My custom View Name"
}

function App() {
  const navigationRef = React.useRef(null);
  return (
    <View>
      <NavigationContainer ref={navigationRef} onReady={() => {
        DdRumReactNavigationTracking.startTrackingViews(navigationRef.current, viewNamePredicate)
      }}>
        // …
      </NavigationContainer>
    </View>
  );
}

Note: Only one NavigationContainer can be tracked at the time. If you need to track another container, stop tracking the previous one first, using DdRumReactNavigationTracking.stopTrackingViews().

React Native Navigation

Note: This package is an integration for react-native-navigation library. Make sure you first install and set up the core mobile-react-native SDK.

Setup

To install with npm, run:

npm install @datadog/mobile-react-native-navigation

To install with Yarn, run:

yarn add @datadog/mobile-react-native-navigation

Track view navigation

To start tracking your navigation events, add the following lines before setting up your navigation. You can use the optional ViewNamePredicate callback to replace the automatically detected View name with something more relevant to your use case, based on the ComponentDidAppearEvent.

Returning null in the ViewNamePredicate prevents the new RUM View from being created. The previous RUM View remains active.

import { DdRumReactNativeNavigationTracking, ViewNamePredicate }  from '@datadog/mobile-react-native-navigation';
import { ComponentDidAppearEvent } from 'react-native-navigation';

const viewNamePredicate: ViewNamePredicate = function customViewNamePredicate(event: ComponentDidAppearEvent, trackedName: string) {
  return "My custom View Name"
}

DdRumReactNativeNavigationTracking.startTracking(viewNamePredicate);

Apollo Client

Note: This package is an integration for the @apollo/client library. Make sure you first install and set up the core mobile-react-native SDK.

Setup

To install with npm, run:

npm install @datadog/mobile-react-native-apollo-client

To install with Yarn, run:

yarn add @datadog/mobile-react-native-apollo-client

Migrate to HttpLink

If you initialize your ApolloClient with the uri parameter, initialize it with a HttpLink:

import { ApolloClient, HttpLink } from '@apollo/client';

// before
const apolloClient = new ApolloClient({
    uri: 'https://my.api.com/graphql'
});

// after
const apolloClient = new ApolloClient({
    link: new HttpLink({ uri: 'https://my.api.com/graphql' })
});

Use the Datadog Apollo Client Link to collect information

Import DatadogLink from @datadog/mobile-react-native-apollo-client and use it in your ApolloClient initialization:

import { ApolloClient, from, HttpLink } from '@apollo/client';
import { DatadogLink } from '@datadog/mobile-react-native-apollo-client';

const apolloClient = new ApolloClient({
    link: from([
        new DatadogLink(),
        new HttpLink({ uri: 'https://my.api.com/graphql' }) // always in last position
    ])
});

For more information on Apollo Client Links, see the official documentation.

Removing GraphQL information

Use a resourceEventMapper in your Datadog RUM Configuration to remove sensitive data from GraphQL variables:

const datadogConfiguration = new DatadogProviderConfiguration(
    '<CLIENT_TOKEN>',
    '<ENVIRONMENT_NAME>',
    {
        rumConfiguration: {
            applicationId: '<APPLICATION_ID>', // RUM Application ID
            resourceEventMapper: (event) => {
              // Variables are stored in event.context['_dd.graphql.variables'] as a JSON string when present
              if (event.context['_dd.graphql.variables']) {
                  const variables = JSON.parse(event.context['_dd.graphql.variables']);
                  if (variables.password) {
                      variables.password = '***';
                  }
                  event.context['_dd.graphql.variables'] = JSON.stringify(variables);
              }

              return event;
          }
        },
        logsConfiguration: {}, // Enable Logs
        traceConfiguration: {} // Enable Traces
    }
);

This page lists integrated libraries you can use for Kotlin Multiplatform applications.

Ktor

If you use Ktor to make network requests in your application, you can integrate the Datadog Ktor plugin to collect RUM information about them:

1. Install the Datadog Kotlin Multiplatform SDK and enable RUM.
2. Add a common dependency to dd-sdk-kotlin-multiplatform-ktor if you're using Ktor 2.x, or dd-sdk-kotlin-multiplatform-ktor3 for Ktor 3.x:

kotlin {
    // ...
    sourceSets {
        // ...
        commonMain.dependencies {
            // Use this line if you are using Ktor 2.x
            implementation("com.datadoghq:dd-sdk-kotlin-multiplatform-ktor:x.x.x")
            // Use this line if you are using Ktor 3.x
            // implementation("com.datadoghq:dd-sdk-kotlin-multiplatform-ktor3:x.x.x")
        }
    }
}

3. Add the provided Datadog Ktor Plugin to your Ktor HttpClient:

val ktorClient = HttpClient {
    install(
        datadogKtorPlugin(
            tracedHosts = mapOf(
                "example.com" to setOf(TracingHeaderType.DATADOG),
                "example.eu" to setOf(TracingHeaderType.DATADOG)
            ),
            traceSampleRate = 100f
        )
    )
}