expo-observe 57.0.4 → 57.0.6

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 57.0.6 — 2026-07-15
+
+_This version does not introduce any user-facing changes._
+
+## 57.0.5 — 2026-07-15
+
+### 🎉 New features
+
+- Expose configure event ([#47388](https://github.com/expo/expo/pull/47388) by [@Ubax](https://github.com/Ubax))
+- Add `filteredParams` configuration option to navigation integrations ([#47488](https://github.com/expo/expo/pull/47488) by [@Ubax](https://github.com/Ubax))
+
+### 🐛 Bug fixes
+
+- Fix non-serializable route params issue ([#47497](https://github.com/expo/expo/pull/47497) by [@Ubax](https://github.com/Ubax))
+- [Android] Fix `logEvent` not being forwarded to the AppMetrics module through the native module proxy. ([@Ubax](https://github.com/Ubax)) ([#47766](https://github.com/expo/expo/pull/47766) by [@Ubax](https://github.com/Ubax))
+- [iOS] Adjust dispatch code to comply with OTLP retry spec. ([#47159](https://github.com/expo/expo/pull/47159) by [@douglowder](https://github.com/douglowder))
+- [Android] Adjust dispatch code to comply with OTLP retry spec. ([@douglowder](https://github.com/douglowder)) ([#47160](https://github.com/expo/expo/pull/47160) by [@douglowder](https://github.com/douglowder))
+
 ## 57.0.4 — 2026-07-07
 
 _This version does not introduce any user-facing changes._

package/android/src/main/java/expo/modules/observe/DispatchUtils.kt

@@ -0,0 +1,246 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+package expo.modules.observe
+
+import expo.modules.appmetrics.utils.TimeUtils
+import kotlinx.serialization.json.Json
+import java.text.SimpleDateFormat
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.math.pow
+import kotlin.random.Random
+
+/**
+ * Outcome of a single dispatch attempt to the OTLP endpoint. Four cases, modeled after the
+ * OTLP retry guidance (see https://opentelemetry.io/docs/specs/otlp/#otlphttp-response):
+ *
+ * - `Success` — server accepted the batch without rejections.
+ * - `PartialSuccess` — server accepted the batch but rejected some records (the OTLP
+ *   `partial_success` body with `rejectedCount > 0`). The rows DID land on the server, so
+ *   pending-ID removal and counter reset match `Success`; the case stays distinct so the
+ *   call site can log the rejected count and `errorMessage` clearly rather than describing
+ *   it as a drop.
+ * - `RetryableFailure` — transient failure (429/502/503/504 or transport error); retry
+ *   the same batch after `retryAfterMs` or a client-computed backoff.
+ * - `NonRetryableFailure` — permanent failure (4xx/5xx outside the retryable set, encoding
+ *   error); drop the batch so it can't wedge the queue.
+ *
+ * `RetryableFailure.retryAfterMs` carries the parsed `Retry-After` header value in
+ * milliseconds (or `null` when the server didn't supply one). `NonRetryableFailure.reason`
+ * carries a short diagnostic string for the warn log.
+ */
+sealed class DispatchResult {
+  object Success : DispatchResult()
+  data class PartialSuccess(val partial: OTPartialSuccess) : DispatchResult()
+  data class RetryableFailure(val retryAfterMs: Long? = null) : DispatchResult()
+  data class NonRetryableFailure(val reason: String) : DispatchResult()
+}
+
+/**
+ * HTTP response classification + Retry-After parsing for `EventDispatcher`. Lives in its own
+ * file mirroring `DispatchUtils.swift` on the iOS side. All functions are pure so they can be
+ * unit-tested without instantiating the dispatcher or hitting the network.
+ */
+object DispatchUtils {
+  /**
+   * Pure classifier that maps an HTTP response into one of three retry outcomes. Extracted
+   * from the dispatch call site so the OTLP-spec rules can be unit-tested without a real
+   * network call.
+   *
+   * `bodyExcerpt` is invoked lazily, only when the result is `NonRetryable` and the reason
+   * string benefits from including a peek at the response body. Lets the caller bound how
+   * much data we slurp into the log line.
+   */
+  fun classifyResponse(
+    statusCode: Int,
+    retryAfterHeader: String?,
+    responseBody: String?,
+    bodyExcerpt: () -> String = { "" }
+  ): DispatchResult {
+    val retryAfter = parseRetryAfter(retryAfterHeader)
+
+    if (statusCode in 200..299) {
+      // The OTLP spec allows `partial_success` to carry a warning-only payload —
+      // `rejectedCount == 0` with a non-empty `errorMessage`. Treat that as a successful send
+      // (the records DID land) so we don't double-drop. When `rejectedCount > 0`, the records
+      // still landed server-side but a subset was rejected; surface that as `PartialSuccess`
+      // so the caller can log the count and message clearly. Pending-ID removal and gate
+      // behavior for `PartialSuccess` match `Success`.
+      val partial = responseBody?.takeIf { it.isNotBlank() }?.let { body ->
+        runCatching {
+          responseJson.decodeFromString(OTServiceResponse.serializer(), body).partialSuccess
+        }.getOrNull()
+      }
+      if (partial != null && partial.rejectedCount > 0) {
+        return DispatchResult.PartialSuccess(partial)
+      }
+      return DispatchResult.Success
+    }
+
+    return when (statusCode) {
+      429, 502, 503, 504 -> DispatchResult.RetryableFailure(retryAfter)
+      else -> {
+        val excerpt = bodyExcerpt()
+        val suffix = if (excerpt.isEmpty()) "" else ": $excerpt"
+        DispatchResult.NonRetryableFailure(reason = "HTTP $statusCode$suffix")
+      }
+    }
+  }
+
+  /**
+   * Whether the dispatch caller should remove the just-sent pending IDs from the queue.
+   *
+   * - `Success` and `PartialSuccess` remove them — the rows have been accepted by the server
+   *   (partial success rejects a subset server-side, but the bytes still landed; re-sending
+   *   them would just re-trip the same rejection).
+   * - `NonRetryableFailure` ALSO removes them — the server has refused these rows
+   *   permanently, so retrying would produce the same answer; removing them drops the batch
+   *   so it can't wedge subsequent rounds. This is the acceptance-criterion behavior: a
+   *   400/403 must not be re-sent on the next cycle.
+   * - `RetryableFailure` keeps them so the next dispatch round picks the same rows up again.
+   */
+  fun shouldRemovePending(result: DispatchResult): Boolean = when (result) {
+    is DispatchResult.Success,
+    is DispatchResult.PartialSuccess,
+    is DispatchResult.NonRetryableFailure -> true
+    is DispatchResult.RetryableFailure -> false
+  }
+
+  /**
+   * Parses an HTTP `Retry-After` header into a delay in milliseconds from now. Accepts both
+   * formats permitted by RFC 7231: an integer delta-seconds, or an HTTP-date.
+   * Returns `null` if the header is absent or unparseable, so the caller can fall through to
+   * `computeBackoffDelay` for a client-driven delay.
+   *
+   * A successfully parsed value is clamped to `[base, cap]` so a misbehaving server can't
+   * drive us to either extreme: a value below `base` (including `0`, negatives, or HTTP-dates
+   * in the past) floors to `base` so we don't hammer; a value above `cap` (or a date far in
+   * the future) ceilings to `cap` so we don't snooze for hours. Non-finite floating-point
+   * values (`Infinity`, `NaN`) are treated as garbage and return `null`.
+   */
+  fun parseRetryAfter(
+    header: String?,
+    base: Long = backoffBaseMs,
+    cap: Long = backoffCapMs
+  ): Long? {
+    val raw = header?.trim() ?: return null
+    if (raw.isEmpty()) return null
+
+    raw.toLongOrNull()?.let { return clampToBounds(it * 1000L, base, cap) }
+    raw.toDoubleOrNull()?.let {
+      if (!it.isFinite()) return null
+      return clampToBounds((it * 1000L).toLong(), base, cap)
+    }
+
+    // IMF-fixdate only; others fall through to backoff
+    // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Date#syntax
+    val formatter = SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US)
+    formatter.timeZone = TimeZone.getTimeZone("GMT")
+    val parsed = runCatching { formatter.parse(raw) }.getOrNull()
+    if (parsed != null) {
+      return clampToBounds(TimeUtils.millisUntil(parsed), base, cap)
+    }
+    return null
+  }
+
+  /**
+   * Clamps a server-supplied retry delay into the client's `[base, cap]` window. Used by
+   * `parseRetryAfter` so the gate is bounded regardless of what the server sent.
+   */
+  private fun clampToBounds(ms: Long, base: Long, cap: Long): Long = ms.coerceIn(base, cap)
+
+  /**
+   * First `limit` bytes of the response body, for inclusion in error log lines. Bounded so a
+   * giant HTML error page doesn't flood the log; truncated mid-codepoint is acceptable for a
+   * diagnostic excerpt.
+   */
+  internal fun bodyExcerpt(body: String?, limit: Int = 512): String {
+    if (body.isNullOrEmpty()) return ""
+    return if (body.length <= limit) body else body.substring(0, limit)
+  }
+
+  private val responseJson = Json { ignoreUnknownKeys = true }
+
+  // MARK: -- Retry gate + exponential backoff
+
+  /**
+   * Base delay (in ms) for the exponential backoff when the server doesn't supply a
+   * `Retry-After`. The cap (`backoffCapMs`) bounds the worst-case wait so we don't end up
+   * snoozing for hours after a long string of failures.
+   */
+  const val backoffBaseMs: Long = 60_000L
+  const val backoffCapMs: Long = 900_000L
+
+  /**
+   * Computes a backoff delay (in ms) for the next dispatch attempt when the server didn't
+   * supply `Retry-After`. Exponential growth (base × 2^(attempt-1)), capped, with full jitter
+   * so a fleet of devices recovering from the same transient backend outage doesn't
+   * thunder-herd the recovery.
+   *
+   * https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+   *
+   * `attempt` is 1-based; the helper is defensive for `0` / negative inputs and returns 0
+   * rather than producing a negative exponent.
+   */
+  fun computeBackoffDelay(
+    attempt: Int,
+    base: Long = backoffBaseMs,
+    cap: Long = backoffCapMs,
+    random: () -> Double = { Random.nextDouble() }
+  ): Long {
+    if (attempt < 1) return 0L
+    val unjittered = minOf((base.toDouble() * 2.0.pow(attempt - 1)).toLong(), cap)
+    return (unjittered.toDouble() * random()).toLong()
+  }
+
+  /**
+   * Snapshot of the retry-gate state carried across dispatch rounds. `dispatchAfterMs` is the
+   * wall-clock deadline (ms since epoch) before which the dispatch entry point should
+   * short-circuit (set by a retryable response, naturally expires); `consecutiveRetryableFailures`
+   * is the counter that drives `computeBackoffDelay` when the server didn't supply a
+   * `Retry-After`.
+   */
+  data class RetryGateState(
+    val dispatchAfterMs: Long?,
+    val consecutiveRetryableFailures: Int
+  ) {
+    companion object {
+      val initial = RetryGateState(dispatchAfterMs = null, consecutiveRetryableFailures = 0)
+    }
+  }
+
+  /**
+   * Pure helper that computes the next `RetryGateState` after a single dispatch result.
+   *
+   * - `Success` and `PartialSuccess` reset the counter to 0 and leave the gate alone. The
+   *   gate either already expired (we wouldn't have dispatched otherwise) or was never set
+   *   — either way, a server response that ACCEPTED the bytes (even if it rejected a subset
+   *   server-side) doesn't introduce a new pause.
+   * - `NonRetryableFailure` also resets the counter. A permanent drop isn't a sign that the
+   *   server is unhealthy and shouldn't pause subsequent rounds.
+   * - `RetryableFailure` increments the counter and sets the gate to `now + delay`, where
+   *   `delay` is the server-supplied `retryAfterMs` if present, otherwise `backoff(nextCount)`.
+   *
+   * `backoff` is injected so tests can drive it deterministically without going through
+   * `computeBackoffDelay`'s random source.
+   */
+  fun nextRetryGateState(
+    result: DispatchResult,
+    currentState: RetryGateState,
+    now: Long,
+    backoff: (Int) -> Long
+  ): RetryGateState = when (result) {
+    is DispatchResult.Success,
+    is DispatchResult.PartialSuccess,
+    is DispatchResult.NonRetryableFailure ->
+      currentState.copy(consecutiveRetryableFailures = 0)
+    is DispatchResult.RetryableFailure -> {
+      val nextCount = currentState.consecutiveRetryableFailures + 1
+      val delay = result.retryAfterMs ?: backoff(nextCount)
+      RetryGateState(
+        dispatchAfterMs = now + delay,
+        consecutiveRetryableFailures = nextCount
+      )
+    }
+  }
+}

package/android/src/main/java/expo/modules/observe/EventDispatcher.kt

@@ -9,7 +9,6 @@ import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.RequestBody.Companion.toRequestBody
 import kotlin.coroutines.resume
-import kotlin.coroutines.resumeWithException
 
 // TODO: Make this safe for concurrent usage
 class EventDispatcher(
@@ -28,60 +27,61 @@ class EventDispatcher(
 
   private fun logsEndpointUrl(): String = "$baseProjectUrl/v1/logs"
 
-  suspend fun dispatch(events: List<Event>): Boolean =
+  /**
+   * POSTs `events` to the metrics endpoint and classifies the response per the OTLP retry
+   * spec. Non-throwing: payload-encoding errors collapse to `NonRetryable` (same bytes will
+   * fail again), transport errors collapse to `Retryable(null)` (transient by definition).
+   */
+  suspend fun dispatch(events: List<Event>): DispatchResult =
     suspendCancellableCoroutine { continuation ->
       if (events.isEmpty()) {
-        continuation.resume(false)
+        // Empty input isn't a server response - signal success.
+        continuation.resume(DispatchResult.Success)
         return@suspendCancellableCoroutine Unit
       }
       val easId = EASClientID(context).uuid.toString()
-      try {
-        val body = OTRequestBody(
+      val body = try {
+        OTRequestBody(
           resourceMetrics = events.map { it.toOTEvent(easId) }
         ).toJson(prettyPrint = true)
-
-        executePost(continuation, metricsEndpointUrl(), body)
       } catch (e: Exception) {
-        Log.w(
-          TAG,
-          "Dispatching the events has thrown an error: ${e.message}"
-        )
-        continuation.resumeWithException(e)
+        Log.w(OBSERVE_TAG, "Encoding metrics request body failed: ${e.message}")
+        continuation.resume(DispatchResult.NonRetryableFailure("encoding error: ${e.message}"))
+        return@suspendCancellableCoroutine Unit
       }
+      executePost(continuation, metricsEndpointUrl(), body)
     }
 
   /**
    * Dispatches log records to `{baseUrl}/{projectId}/v1/logs`. Always uses the
    * OTLP wire shape — there is no legacy logs endpoint.
    */
-  suspend fun dispatchLogs(events: List<Event>): Boolean =
+  suspend fun dispatchLogs(events: List<Event>): DispatchResult =
     suspendCancellableCoroutine { continuation ->
       val easId = EASClientID(context).uuid.toString()
       val resourceLogs = events
         .filter { it.logs.isNotEmpty() }
         .map { it.toOTResourceLogs(easId) }
       if (resourceLogs.isEmpty()) {
-        continuation.resume(false)
+        continuation.resume(DispatchResult.Success)
         return@suspendCancellableCoroutine Unit
       }
-      try {
-        val body = OTLogsRequestBody(resourceLogs = resourceLogs).toJson(prettyPrint = true)
-        executePost(continuation, logsEndpointUrl(), body)
+      val body = try {
+        OTLogsRequestBody(resourceLogs = resourceLogs).toJson(prettyPrint = true)
       } catch (e: Exception) {
-        Log.w(
-          TAG,
-          "Dispatching the logs has thrown an error: ${e.message}"
-        )
-        continuation.resumeWithException(e)
+        Log.w(OBSERVE_TAG, "Encoding logs request body failed: ${e.message}")
+        continuation.resume(DispatchResult.NonRetryableFailure("encoding error: ${e.message}"))
+        return@suspendCancellableCoroutine Unit
       }
+      executePost(continuation, logsEndpointUrl(), body)
     }
 
   private fun executePost(
-    continuation: kotlinx.coroutines.CancellableContinuation<Boolean>,
+    continuation: kotlinx.coroutines.CancellableContinuation<DispatchResult>,
     endpointUrl: String,
     body: String
   ) {
-    Log.d(TAG, "Sending events to $endpointUrl")
+    Log.d(OBSERVE_TAG, "Sending events to $endpointUrl")
 
     val request = Request
       .Builder()
@@ -96,7 +96,7 @@ class EventDispatcher(
       .post(body.toRequestBody("application/json".toMediaType()))
       .build()
 
-    Log.d(TAG, body)
+    Log.d(OBSERVE_TAG, body)
 
     val call = httpClient.newCall(request)
 
@@ -104,13 +104,41 @@ class EventDispatcher(
       call.cancel()
     }
 
-    val response = call.execute()
-    Log.d(TAG, "Server responded with: ${response.body?.string()}")
+    val response = try {
+      call.execute()
+    } catch (e: Exception) {
+      Log.w(OBSERVE_TAG, "Transport error talking to $endpointUrl: ${e.message}")
+      continuation.resume(DispatchResult.RetryableFailure(retryAfterMs = null))
+      return
+    }
 
-    continuation.resume(response.code in 200..299)
-  }
+    val responseBody = response.body?.string()
+    val retryAfterHeader = response.header("Retry-After")
+    val result = DispatchUtils.classifyResponse(
+      statusCode = response.code,
+      retryAfterHeader = retryAfterHeader,
+      responseBody = responseBody,
+      bodyExcerpt = { DispatchUtils.bodyExcerpt(responseBody) }
+    )
+
+    when (result) {
+      is DispatchResult.Success ->
+        Log.d(OBSERVE_TAG, "Server responded successfully with ${response.code} and data: $responseBody")
+      is DispatchResult.PartialSuccess ->
+        Log.w(
+          OBSERVE_TAG,
+          "Server responded with ${response.code} (partial success, rejected " +
+            "${result.partial.rejectedCount}: ${result.partial.errorMessage ?: "no error message"}) "
+        )
+      is DispatchResult.RetryableFailure ->
+        Log.w(OBSERVE_TAG, "Server responded with ${response.code} (retryable) and data: $responseBody")
+      is DispatchResult.NonRetryableFailure ->
+        Log.w(
+          OBSERVE_TAG,
+          "Server responded with ${response.code} (non-retryable, ${result.reason}) and data: $responseBody"
+        )
+    }
 
-  companion object {
-    private const val TAG = "EasObserve"
+    continuation.resume(result)
   }
 }

package/android/src/main/java/expo/modules/observe/ObservabilityManager.kt

@@ -1,11 +1,15 @@
 package expo.modules.observe
 
 import android.content.Context
+import android.util.Log
 import expo.modules.easclient.EASClientID
 import expo.modules.observe.storage.PendingLogsManager
 import expo.modules.observe.storage.PendingMetricsManager
 import expo.modules.appmetrics.storage.SessionManager
+import expo.modules.appmetrics.utils.TimeUtils
 import expo.modules.interfaces.constants.ConstantsInterface
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 
 class ObservabilityManager(
   // TODO(@lukmccall): Consider saving context as weak reference to avoid potential memory leaks
@@ -76,7 +80,8 @@ class BaseObservabilityManager(
   private val isDebugBuild: Boolean = false,
   private val deterministicUniformValueProvider: () -> Double = {
     EASClientID.deterministicUniformValue(EASClientID(context).uuid)
-  }
+  },
+  private val currentTimeMs: () -> Long = { TimeUtils.getWallClockMillis() }
 ) {
   private val eventDispatcher = EventDispatcher(
     context = context,
@@ -84,12 +89,75 @@ class BaseObservabilityManager(
     baseUrl = baseUrl
   )
 
-  suspend fun dispatchUnsentMetrics() {
+  /**
+   * In-memory retry-gate state, kept independently per OTLP endpoint. The `/v1/metrics` and
+   * `/v1/logs` endpoints fail independently in practice (one schema validation disagreement
+   * on the metrics side shouldn't suppress a healthy logs stream), so each signal carries
+   * its own consecutive-failure counter and dispatch-after deadline. A single shared field
+   * would conflate the two: a recovering signal would reset the other's counter on success,
+   * and a server's `Retry-After` on one endpoint would silently overwrite a longer backoff
+   * computed for the other.
+   *
+   * State is reset implicitly when the process restarts — a relaunch usually means enough
+   * time passed that the transient cause has cleared anyway, and persisting the gates would
+   * mean a disk write per retryable response.
+   */
+  private var metricsRetryGate: DispatchUtils.RetryGateState = DispatchUtils.RetryGateState.initial
+  private var logsRetryGate: DispatchUtils.RetryGateState = DispatchUtils.RetryGateState.initial
+
+  /**
+   * Per-signal mutexes that serialize same-signal dispatch calls. Two `dispatchEvents`
+   * invocations from JS can otherwise land on the same `BaseObservabilityManager` instance
+   * concurrently and race on the gate's read-modify-write (and double-POST the same pending
+   * rows). The metrics and logs paths take separate mutexes so they can still run in
+   * parallel — only same-signal calls serialize.
+   *
+   * Worst case without these would be benign (a dropped gate update or a duplicate dispatch),
+   * since the pending-ID stores are already DB-backed and telemetry is best-effort — but the
+   * gate is in-memory state with no other synchronization, so close the race explicitly.
+   */
+  private val metricsDispatchMutex = Mutex()
+  private val logsDispatchMutex = Mutex()
+
+  /**
+   * Returns true and logs when an active retry gate suppresses this dispatch round. Called
+   * inside each per-signal dispatch method rather than at a shared entry point, so a backoff
+   * on one endpoint doesn't suppress traffic on the other.
+   */
+  private fun retryGateBlocks(state: DispatchUtils.RetryGateState, signal: String): Boolean {
+    val until = state.dispatchAfterMs ?: return false
+    val now = currentTimeMs()
+    if (until <= now) return false
+    Log.d(OBSERVE_TAG, "$signal dispatch suppressed by retry gate until $until (now $now)")
+    return true
+  }
+
+  /**
+   * Computes the next gate state for a given current state and dispatch result. Each per-
+   * signal call site assigns the return value back to its own field — the manager doesn't
+   * share a single mutable state across signals, so the metrics and logs gates can't drift
+   * out of sync from cross-signal updates.
+   */
+  private fun nextGate(
+    current: DispatchUtils.RetryGateState,
+    result: DispatchResult
+  ): DispatchUtils.RetryGateState = DispatchUtils.nextRetryGateState(
+    result = result,
+    currentState = current,
+    now = currentTimeMs(),
+    backoff = { DispatchUtils.computeBackoffDelay(it) }
+  )
+
+  suspend fun dispatchUnsentMetrics(): Unit = metricsDispatchMutex.withLock {
     val pendingIds = pendingMetricsManager.getAllPendingMetricIds()
     if (pendingIds.isEmpty()) {
       return
     }
 
+    if (retryGateBlocks(metricsRetryGate, "metrics")) {
+      return
+    }
+
     if (!shouldDispatch()) {
       pendingMetricsManager.removePendingMetrics(pendingIds)
       return
@@ -115,22 +183,43 @@ class BaseObservabilityManager(
       )
     }
 
-    if (eventDispatcher.dispatch(events)) {
-      val dispatchedMetricIds = sessionsWithPendingMetrics.flatMap { it.metrics }.map { it.metricId }
+    val result = eventDispatcher.dispatch(events)
+    metricsRetryGate = nextGate(metricsRetryGate, result)
+    val dispatchedMetricIds = sessionsWithPendingMetrics.flatMap { it.metrics }.map { it.metricId }
+    if (DispatchUtils.shouldRemovePending(result)) {
       pendingMetricsManager.removePendingMetrics(dispatchedMetricIds)
     }
+    when (result) {
+      is DispatchResult.PartialSuccess ->
+        Log.w(
+          OBSERVE_TAG,
+          "Partial success on batch of ${dispatchedMetricIds.size} metric event(s): " +
+            "server rejected ${result.partial.rejectedCount} " +
+            "(${result.partial.errorMessage ?: "no error message"})"
+        )
+      is DispatchResult.NonRetryableFailure ->
+        Log.w(
+          OBSERVE_TAG,
+          "Dropping batch of ${dispatchedMetricIds.size} metric event(s): ${result.reason}"
+        )
+      is DispatchResult.Success, is DispatchResult.RetryableFailure -> Unit
+    }
   }
 
   /**
    * Dispatches log events to `/v1/logs`. Independent from the metrics path —
    * a logs failure doesn't affect the metrics pending table and vice versa.
    */
-  suspend fun dispatchUnsentLogs() {
+  suspend fun dispatchUnsentLogs(): Unit = logsDispatchMutex.withLock {
     val pendingIds = pendingLogsManager.getAllPendingLogIds()
     if (pendingIds.isEmpty()) {
       return
     }
 
+    if (retryGateBlocks(logsRetryGate, "logs")) {
+      return
+    }
+
     if (!shouldDispatch()) {
       pendingLogsManager.removePendingLogs(pendingIds)
       return
@@ -158,10 +247,27 @@ class BaseObservabilityManager(
       )
     }
 
-    if (eventDispatcher.dispatchLogs(events)) {
-      val dispatchedLogIds = sessionsWithPendingLogs.flatMap { it.logs }.map { it.logId }
+    val result = eventDispatcher.dispatchLogs(events)
+    logsRetryGate = nextGate(logsRetryGate, result)
+    val dispatchedLogIds = sessionsWithPendingLogs.flatMap { it.logs }.map { it.logId }
+    if (DispatchUtils.shouldRemovePending(result)) {
       pendingLogsManager.removePendingLogs(dispatchedLogIds)
     }
+    when (result) {
+      is DispatchResult.PartialSuccess ->
+        Log.w(
+          OBSERVE_TAG,
+          "Partial success on batch of ${dispatchedLogIds.size} log event(s): " +
+            "server rejected ${result.partial.rejectedCount} " +
+            "(${result.partial.errorMessage ?: "no error message"})"
+        )
+      is DispatchResult.NonRetryableFailure ->
+        Log.w(
+          OBSERVE_TAG,
+          "Dropping batch of ${dispatchedLogIds.size} log event(s): ${result.reason}"
+        )
+      is DispatchResult.Success, is DispatchResult.RetryableFailure -> Unit
+    }
   }
 
   private fun isInSample(): Boolean {

package/android/src/main/java/expo/modules/observe/ObserveModule.kt

@@ -17,7 +17,8 @@ class Config(
   @Field val environment: String? = null,
   @Field val dispatchingEnabled: Boolean? = null,
   @Field val dispatchInDebug: Boolean? = null,
-  @Field val sampleRate: Double? = null
+  @Field val sampleRate: Double? = null,
+  @Field val integrations: Map<String, Any?>? = null
 ) : Record
 
 @OptimizedRecord
@@ -33,10 +34,14 @@ class ObserveModule : Module() {
   private lateinit var observabilityManager: ObservabilityManager
   private lateinit var appMetricsModule: AppMetricsModule
 
+  private var lastIntegrations: Map<String, Any?> = emptyMap()
+
   override fun definition() =
     ModuleDefinition {
       Name("ExpoObserve")
 
+      Events("configure")
+
       OnCreate {
         appMetricsModule = checkNotNull(appContext.registry.getModule<AppMetricsModule>()) {
           "AppMetricsModule is required by ObserveModule. Make sure expo-app-metrics is installed."
@@ -72,6 +77,14 @@ class ObserveModule : Module() {
         val resolvedEnvironment = config.environment
           ?: ObservePreferences.getBundleDefaults(context)?.environment
         resolvedEnvironment?.let { appMetricsModule.setEnvironment(it) }
+
+        // Broadcast the integrations config so integration libraries (e.g. expo-image) can activate.
+        lastIntegrations = config.integrations ?: emptyMap()
+        this@ObserveModule.sendEvent("configure", mapOf("integrations" to lastIntegrations))
+      }
+
+      Function("getIntegrations") {
+        lastIntegrations
       }
 
       Function("setBundleDefaults") { defaults: BundleDefaults ->

package/android/src/main/java/expo/modules/observe/OpenTelemetry.kt

@@ -160,6 +160,34 @@ data class OTLogsRequestBody(
   }
 }
 
+// MARK: -- Response shapes
+
+/**
+ * `partial_success` body emitted by the collector when records were accepted but some were
+ * rejected. Mirrors the wire shape the server actually sends (camelCase keys; the metrics
+ * endpoint populates `rejectedDataPoints`, the logs endpoint populates `rejectedLogRecords`).
+ * The server only emits this block when at least one record was rejected — a fully successful
+ * dispatch returns no body.
+ *
+ * The OTLP spec also allows a warning-only variant where `rejectedCount == 0` and
+ * `errorMessage` carries an advisory note (e.g. deprecation warnings). The classifier handles
+ * that case as a success since the records did land.
+ */
+@Serializable
+data class OTPartialSuccess(
+  val rejectedDataPoints: Int? = null,
+  val rejectedLogRecords: Int? = null,
+  val errorMessage: String? = null
+) {
+  val rejectedCount: Int
+    get() = (rejectedDataPoints ?: 0) + (rejectedLogRecords ?: 0)
+}
+
+@Serializable
+data class OTServiceResponse(
+  val partialSuccess: OTPartialSuccess? = null
+)
+
 /**
  * OpenTelemetry Semantic Conventions schema URL referenced by the resource on
  * every dispatched payload. Bumping this constant signals that our attribute

package/build/index.d.ts

@@ -6,6 +6,6 @@ export { ObserveRoot } from './ObserveRoot';
 export { Observe };
 /** @deprecated Import the named `Observe` export instead. */
 export default Observe;
-export type { ObserveAttribute, ObserveAttributes, ObserveConfig, ObserveIntegrationsConfig, } from './types';
+export type { ObserveAttribute, ObserveAttributes, ObserveConfig, ObserveIntegrationsConfig, ObserveModule, ObserveModuleEvents, } from './types';
 export { useObserve } from './useObserve';
 //# sourceMappingURL=index.d.ts.map