Android SDK observability reference

Overview

This topic documents how to get started with the LaunchDarkly observability plugin for the Android SDK.

The Android SDK supports the observability plugin for error monitoring, logging, tracing, and session replay.

Prerequisites and dependencies

This reference guide assumes that you are somewhat familiar with the LaunchDarkly Android SDK.

The observability plugin is compatible with the Android SDK, version 5.9.0 and later.

The LaunchDarkly Android SDK is compatible with Android SDK versions 21 and higher (Android 5.0, Lollipop).

Get started

Follow these steps to get started:

• Install the plugin
• Initialize the Android SDK client
• Configure the plugin options
• Configure additional instrumentations
• Configure session replay
• Explore supported features
• Review observability data in LaunchDarkly

Install the plugin

LaunchDarkly uses a plugin to the Android SDK to provide observability.

The first step is to make both the SDK and the observability plugin available as dependencies.

Here’s how:

1
implementation 'com.launchdarkly:launchdarkly-android-client-sdk:5.+'
2
implementation 'com.launchdarkly:launchdarkly-observability-android:0.5.0'

Then, import the plugin into your code:

1
import com.launchdarkly.sdk.*;
2
import com.launchdarkly.sdk.android.*;
3
import com.launchdarkly.observability.plugin.Observability
4
import com.launchdarkly.sdk.android.integrations.Plugin

Initialize the client

Next, initialize the SDK and the plugin.

To initialize, you need your LaunchDarkly environment’s mobile key and the context for which you want to evaluate flags. This authorizes your application to connect to a particular environment within LaunchDarkly. To learn more, read Initialize the client in the Android SDK reference guide.

Here’s how to initialize the SDK and plugin:

1
LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
2
    .mobileKey("mobile-key-123abc")
3
    .plugins(Components.plugins().setPlugins(
4
      Collections.singletonList<Plugin>(Observability(this.getApplication()))
5
    ))
6
    // other options
7
    .build();
8
9
// You'll need this context later, but you can ignore it for now.
10
LDContext context = LDContext.create("context-key-123abc");
11
12
LDClient client = LDClient.init(this.getApplication(), ldConfig, context, 0);

Configure the plugin options

You can configure options for the observability plugin when you initialize the SDK. The plugin constructor takes an optional object with the configuration details.

Here is an example:

1
val ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
2
    .mobileKey("mobile-key-123abc")
3
    .plugins(
4
      Components.plugins().setPlugins(
5
        Collections.singletonList<Plugin>(
6
          Observability(
7
            this@BaseApplication,
8
            Options(
9
              resourceAttributes = Attributes.of(
10
                AttributeKey.stringKey("serviceName"), "example-service"
11
              )
12
            )
13
          )
14
        )
15
      )
16
    )
17
    .build();

For more information on plugin options, read Configuration for client-side observability.

Configure additional instrumentations

To enable HTTP request instrumentation and user interaction instrumentation, add the following plugin and dependencies to your top level application’s Gradle file.

1
plugins {
2
    id 'net.bytebuddy.byte-buddy-gradle-plugin' version '1.+'
3
}
4
5
dependencies {
6
    // Android HTTP Url instrumentation
7
    implementation 'io.opentelemetry.android.instrumentation:httpurlconnection-library:0.11.0-alpha'
8
    byteBuddy 'io.opentelemetry.android.instrumentation:httpurlconnection-agent:0.11.0-alpha'
9
10
    // OkHTTP instrumentation
11
    implementation 'io.opentelemetry.android.instrumentation:okhttp3-library:0.11.0-alpha'
12
    byteBuddy 'io.opentelemetry.android.instrumentation:okhttp3-agent:0.11.0-alpha'
13
}

Configure session replay

The Android SDK supports session replay, which captures snapshots of your app’s UI at regular intervals. This allows you to visually review user sessions in LaunchDarkly to better understand user behavior and diagnose issues.

To enable session replay, add the ReplayInstrumentation to the instrumentations list when configuring the observability plugin.

Here’s how:

1
import com.launchdarkly.observability.replay.ReplayInstrumentation
2
import com.launchdarkly.observability.replay.ReplayOptions
3
import com.launchdarkly.observability.replay.PrivacyProfile
4
5
val ldConfig = LDConfig.Builder(AutoEnvAttributes.Enabled)
6
    .mobileKey("mobile-key-123abc")
7
    .plugins(
8
      Components.plugins().setPlugins(
9
        listOf(
10
          Observability(
11
            this@BaseApplication,
12
            Options(
13
              resourceAttributes = Attributes.of(
14
                AttributeKey.stringKey("serviceName"), "example-service"
15
              ),
16
              instrumentations = listOf(
17
                ReplayInstrumentation()
18
              )
19
            )
20
          )
21
        )
22
      )
23
    )
24
    .build()

Session replay configuration options

You can customize session replay behavior by passing a ReplayOptions object to the ReplayInstrumentation constructor:

1
val ldConfig = LDConfig.Builder(AutoEnvAttributes.Enabled)
2
    .mobileKey("mobile-key-123abc")
3
    .plugins(
4
      Components.plugins().setPlugins(
5
        listOf(
6
          Observability(
7
            this@BaseApplication,
8
            Options(
9
              instrumentations = listOf(
10
                ReplayInstrumentation(
11
                  options = ReplayOptions(
12
                    privacyProfile = PrivacyProfile.STRICT,
13
                    capturePeriodMillis = 1000,
14
                    serviceName = "example-service",
15
                    serviceVersion = "1.0.0",
16
                    debug = false
17
                  )
18
                )
19
              )
20
            )
21
          )
22
        )
23
      )
24
    )
25
    .build()

The available configuration options are:

• privacyProfile: Controls how UI elements are masked in the replay. Options are:
  • PrivacyProfile.STRICT (default): Masks all UI elements to protect user privacy.
  • PrivacyProfile.NO_MASK: Captures UI elements without masking. Use with caution as this may expose sensitive user information.
• capturePeriodMillis: The interval in milliseconds between UI snapshots. Defaults to 1000ms (1 second).
• serviceName: A name for your service. Defaults to “observability-android”.
• serviceVersion: Version of your service. Defaults to the SDK version.
• backendUrl: The backend URL for sending replay data. Defaults to LaunchDarkly’s backend.
• debug: Enables verbose logging when set to true. Defaults to false.

For more information on session replay configuration, read Configuration for session replay.

Explore supported features

The observability plugins supports the following features. After the SDK and plugins are initialized, you can access these from within your application:

• Configuration for client-side observability
• Configuration for session replay
• Errors
• Logs
• Metrics
• Tracing

Review observability data in LaunchDarkly

After you initialize the SDK and observability plugin, your application automatically starts sending observability data back to LaunchDarkly, including errors and logs. You can review this information in the LaunchDarkly user interface. To learn how, read Observability.