Android SDK observability reference

implementation 'com.launchdarkly:launchdarkly-android-client-sdk:5.+'
implementation 'com.launchdarkly:launchdarkly-observability-android:0.21.0'

implementation("com.launchdarkly:launchdarkly-android-client-sdk:5.+")
implementation("com.launchdarkly:launchdarkly-observability-android:0.21.0")

import com.launchdarkly.sdk.*;
import com.launchdarkly.sdk.android.*;
import com.launchdarkly.observability.plugin.Observability;
import com.launchdarkly.sdk.android.integrations.Plugin;

import com.launchdarkly.sdk.*
import com.launchdarkly.sdk.android.*
import com.launchdarkly.observability.plugin.Observability
import com.launchdarkly.sdk.android.integrations.Plugin

String mobileKey = "example-mobile-key";

LDConfig ldConfig = new LDConfig.Builder(AutoEnvAttributes.Enabled)
  .mobileKey(mobileKey)
  .plugins(Components.plugins().setPlugins(
    Collections.singletonList<Plugin>(Observability(this.getApplication(), mobileKey))
  ))
  // other options
  .build();

// You'll need this context later, but you can ignore it for now.
LDContext context = LDContext.create("example-context-key");

LDClient client = LDClient.init(this.getApplication(), ldConfig, context, 0);

val mobileKey = "example-mobile-key"

val ldConfig = LDConfig.Builder(AutoEnvAttributes.Enabled)
  .mobileKey(mobileKey)
  .plugins(Components.plugins().setPlugins(
    listOf(Observability(this@BaseApplication, mobileKey))
  ))
  // other options
  .build()

// You'll need this context later, but you can ignore it for now.
val context = LDContext.create("example-context-key")

val client: LDClient = LDClient.init(this@BaseApplication, ldConfig, context, 0)

plugins {
    id 'net.bytebuddy.byte-buddy-gradle-plugin' version '1.+'
}

dependencies {
    // Android HTTP Url instrumentation
    implementation 'io.opentelemetry.android.instrumentation:httpurlconnection-library:0.11.0-alpha'
    byteBuddy 'io.opentelemetry.android.instrumentation:httpurlconnection-agent:0.11.0-alpha'

    // OkHTTP instrumentation
    implementation 'io.opentelemetry.android.instrumentation:okhttp3-library:0.11.0-alpha'
    byteBuddy 'io.opentelemetry.android.instrumentation:okhttp3-agent:0.11.0-alpha'
}

plugins {
    id("net.bytebuddy.byte-buddy-gradle-plugin") version "1.+"
}

dependencies {
    // Android HTTP Url instrumentation
    implementation("io.opentelemetry.android.instrumentation:httpurlconnection-library:0.11.0-alpha")
    byteBuddy("io.opentelemetry.android.instrumentation:httpurlconnection-agent:0.11.0-alpha")

    // OkHTTP instrumentation
    implementation("io.opentelemetry.android.instrumentation:okhttp3-library:0.11.0-alpha")
    byteBuddy("io.opentelemetry.android.instrumentation:okhttp3-agent:0.11.0-alpha")
}

ObservabilityOptions(
analytics = ObservabilityOptions.Analytics(
  taps = true,
  trackEvents = true,
  screenViews = true,
  appLifecycle = true,
  appLaunch = true,
)
)

import com.launchdarkly.observability.client.screen.LDScreenNameProvider

class CheckoutActivity : ComponentActivity(), LDScreenNameProvider {
  override val ldScreenName: String = "Checkout"
  override val ldScreenCategory: String = "Commerce"
}

import com.launchdarkly.observability.sdk.LDReplay

// Start recording after user consent or feature flag check
LDReplay.start()

import com.launchdarkly.observability.sdk.LDReplay

// Start recording based on a feature flag
val replayEnabled = LDClient.get().boolVariation("enable-session-replay", false)
if (replayEnabled) {
  LDReplay.start()
}

import com.launchdarkly.observability.sdk.LDReplay

LDReplay.stop()

import com.launchdarkly.observability.sdk.LDReplay

// Immediately export any queued replay events
LDReplay.flush()

privacyProfile = PrivacyProfile(
maskTextInputs = true,
maskText = true,
maskBySemanticsKeywords = true
)

privacyProfile = PrivacyProfile(
maskTextInputs = false,
maskText = false,
maskBySemanticsKeywords = false
)

privacyProfile = PrivacyProfile(
maskTextInputs = true,
maskText = false,
maskBySemanticsKeywords = true
)

import com.launchdarkly.observability.api.ldMask

class LoginActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_login)

      val password = findViewById<EditText>(R.id.password)
      password.ldMask() // mask this field in session replay
  }
}

import com.launchdarkly.observability.api.ldMask

@Composable
fun CreditCardField() {
  var number by remember { mutableStateOf("") }
  TextField(
      value = number,
      onValueChange = { number = it },
      modifier = Modifier
          .fillMaxWidth()
          .ldMask() // mask this composable in session replay
  )
}

import com.launchdarkly.observability.api.ldUnmask

@Composable
fun PublicInfoField() {
  var info by remember { mutableStateOf("") }
  TextField(
      value = info,
      onValueChange = { info = it },
      modifier = Modifier
          .fillMaxWidth()
          .ldUnmask() // explicitly unmask this field
  )
}

// Record a basic log message
LDObserve.recordLog(
  message = "User login successful",
  severity = Severity.INFO
)

// Record logs with custom properties
LDObserve.recordLog(
  message = "Authentication completed",
  severity = Severity.INFO,
  properties = mapOf(
      "user_id" to "12345",
      "action" to "login"
  )
)

// Use OTel-typed attributes when exact OpenTelemetry typing is required
LDObserve.recordLog(
  message = "Authentication completed",
  severity = Severity.INFO,
  attributes = Attributes.of(
      AttributeKey.stringKey("user_id"), "12345",
      AttributeKey.stringKey("action"), "login"
  )
)

import com.launchdarkly.observability.sdk.LDObserve
import io.opentelemetry.api.common.AttributeKey
import io.opentelemetry.api.common.Attributes

try {
  processPayment()
} catch (e: Exception) {
  LDObserve.recordError(
      e,
      Attributes.of(
          AttributeKey.stringKey("component"), "payment",
          AttributeKey.stringKey("error_code"), "PAYMENT_FAILED"
      )
  )
}

// Start a span with custom properties
val span = LDObserve.startSpan(
  name = "database_query",
  properties = mapOf(
      "table" to "users",
      "operation" to "select"
  )
)

// Perform your operation
performDatabaseQuery()

// Always end the span
span.end()

// Use OTel-typed attributes when exact OpenTelemetry typing is required
val span = LDObserve.startSpan(
  name = "database_query",
  attributes = Attributes.of(
      AttributeKey.stringKey("table"), "users",
      AttributeKey.stringKey("operation"), "select"
  )
)
performDatabaseQuery()
span.end()

// Track an event with properties and an optional metric value
LDObserve.track(
  key = "purchase_completed",
  properties = mapOf(
      "product_id" to "SKU-123",
      "price" to 29.99
  ),
  metricValue = 29.99
)

// Track an event with no properties
LDObserve.track(key = "button_tapped")

import io.opentelemetry.context.Context

val parentSpan = LDObserve.startSpan("parentSpan")

// Capture the current context, which includes the active span
val context = Context.current()

launch(Dispatchers.IO) {
  val span = LDObserve.startSpan(
      name = "log-context-demo",
      properties = mapOf("demo" to "log-with-context")
  )
  // Capture span context while still on the originating thread.
  val capturedContext = span.makeCurrent().use { span.spanContext }
  span.end()
  // Simulate a detached thread where OTel context is lost automatically.
  // Span.current() here returns INVALID, so we pass the captured context explicitly.
  Thread {
      Span.wrap(capturedContext).makeCurrent().use {
          val childSpan = LDObserve.startSpan("child of log-context-demo")
          childSpan.end()
      }
      LDObserve.recordLog(
          message = text,
          severity = Severity.WARN,
          properties = mapOf("source" to "detached-thread-demo"),
          spanContext = capturedContext
      )
  }.start()
}

parentSpan.end()

import io.opentelemetry.context.Context

// Capture the current context
val ctx = Context.current()

// Later, in another scope, restore the context
ctx.makeCurrent().use {
  val span = LDObserve.startSpan("nestedSpan")
  // do work
  span.end()
}

import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Context;
import okhttp3.Request;

W3CTraceContextPropagator propagator = W3CTraceContextPropagator.getInstance();
Request.Builder requestBuilder = new Request.Builder().url(url);

propagator.inject(
  Context.current(),
  requestBuilder,
  (carrier, key, value) -> carrier.addHeader(key, value)
);

Request request = requestBuilder.build();

import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator
import io.opentelemetry.context.Context
import okhttp3.Request

val propagator = W3CTraceContextPropagator.getInstance()
val requestBuilder = Request.Builder().url(url)

propagator.inject(
  Context.current(),
  requestBuilder
) { carrier, key, value -> carrier?.addHeader(key, value) }

val request = requestBuilder.build()

traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
tracestate: (optional vendor data)