expo-observe 56.0.4 → 56.0.6

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

@@ -1,5 +1,6 @@
 package expo.modules.observe
 
+import expo.modules.appmetrics.storage.LogRecord
 import expo.modules.appmetrics.storage.Metric
 import expo.modules.appmetrics.storage.Session
 import kotlinx.serialization.Serializable
@@ -104,8 +105,43 @@ data class EASMetric(
   }
 }
 
+/**
+ * Wire shape of a log event ready for dispatch. Distinct from the storage-side
+ * `LogRecord`: this form has the JSON `attributes` blob already parsed back
+ * into a structured object (so the OTel encoder can map values to typed
+ * `OTAnyValue`s) and drops storage-only columns like `logId`.
+ */
+@Serializable
+data class LogEvent(
+  val sessionId: String,
+  val timestamp: String,
+  val name: String,
+  val body: String? = null,
+  val severity: String,
+  val attributes: JsonObject? = null,
+  val droppedAttributesCount: Int = 0
+) {
+  companion object {
+    fun fromLogRecord(log: LogRecord): LogEvent =
+      LogEvent(
+        sessionId = log.sessionId,
+        timestamp = log.timestamp,
+        name = log.name,
+        body = log.body,
+        severity = log.severity,
+        // Stored as a JSON string; parse defensively, falling back to no
+        // attributes if the blob is somehow malformed.
+        attributes = log.attributes?.let {
+          runCatching { Json.decodeFromString<JsonObject>(it) }.getOrNull()
+        },
+        droppedAttributesCount = log.droppedAttributesCount
+      )
+  }
+}
+
 @Serializable
 data class Event(
   val metadata: Metadata,
-  val metrics: List<EASMetric>
+  val metrics: List<EASMetric>,
+  val logs: List<LogEvent> = emptyList()
 )

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

@@ -21,15 +21,18 @@ class EventDispatcher(
   private val useOpenTelemetry: Boolean = false,
   private val httpClient: OkHttpClient = OkHttpClient()
 ) {
-  private fun endpointUrl(): String {
-    val base = when (baseUrl.endsWith("/")) {
+  private val baseProjectUrl: String
+    get() = when (baseUrl.endsWith("/")) {
       true -> "${baseUrl}$projectId"
       else -> "$baseUrl/$projectId"
     }
-    return if (useOpenTelemetry) "$base/v1/metrics" else base
-  }
 
-  suspend fun dispatch(events: List<Event>) =
+  private fun metricsEndpointUrl(): String =
+    if (useOpenTelemetry) "$baseProjectUrl/v1/metrics" else baseProjectUrl
+
+  private fun logsEndpointUrl(): String = "$baseProjectUrl/v1/logs"
+
+  suspend fun dispatch(events: List<Event>): Boolean =
     suspendCancellableCoroutine { continuation ->
       if (events.isEmpty()) {
         continuation.resume(false)
@@ -54,28 +57,7 @@ class EventDispatcher(
           json.encodeToString(Payload.serializer(), payload)
         }
 
-        val endpointUrl = endpointUrl()
-
-        Log.d(TAG, "Sending events to $endpointUrl")
-
-        val request = Request
-          .Builder()
-          .url(endpointUrl)
-          .post(body.toRequestBody("application/json".toMediaType()))
-          .build()
-
-        Log.d(TAG, body)
-
-        val call = httpClient.newCall(request)
-
-        continuation.invokeOnCancellation {
-          call.cancel()
-        }
-
-        val response = call.execute()
-        Log.d(TAG, "Server responded with: ${response.body?.string()}")
-
-        continuation.resume(response.code in 200..299)
+        executePost(continuation, metricsEndpointUrl(), body)
       } catch (e: Exception) {
         Log.w(
           TAG,
@@ -85,6 +67,59 @@ class EventDispatcher(
       }
     }
 
+  /**
+   * 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 =
+    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)
+        return@suspendCancellableCoroutine Unit
+      }
+      try {
+        val body = OTLogsRequestBody(resourceLogs = resourceLogs).toJson(prettyPrint = true)
+        executePost(continuation, logsEndpointUrl(), body)
+      } catch (e: Exception) {
+        Log.w(
+          TAG,
+          "Dispatching the logs has thrown an error: ${e.message}"
+        )
+        continuation.resumeWithException(e)
+      }
+    }
+
+  private fun executePost(
+    continuation: kotlinx.coroutines.CancellableContinuation<Boolean>,
+    endpointUrl: String,
+    body: String
+  ) {
+    Log.d(TAG, "Sending events to $endpointUrl")
+
+    val request = Request
+      .Builder()
+      .url(endpointUrl)
+      .post(body.toRequestBody("application/json".toMediaType()))
+      .build()
+
+    Log.d(TAG, body)
+
+    val call = httpClient.newCall(request)
+
+    continuation.invokeOnCancellation {
+      call.cancel()
+    }
+
+    val response = call.execute()
+    Log.d(TAG, "Server responded with: ${response.body?.string()}")
+
+    continuation.resume(response.code in 200..299)
+  }
+
   companion object {
     private const val TAG = "EasObserve"
   }

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

@@ -0,0 +1,111 @@
+package expo.modules.observe
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonDecoder
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonEncoder
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.boolean
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.doubleOrNull
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+/**
+ * Custom serializer that emits the OTLP-correct wire shape for `OTAnyValue`.
+ * Each variant becomes a single-key JSON object:
+ *   - Str   -> {"stringValue": "..."}
+ *   - Int64 -> {"intValue": "42"}        (string per OTLP int64 mapping)
+ *   - Dbl   -> {"doubleValue": 3.14}
+ *   - Bln   -> {"boolValue": true}
+ *   - Arr   -> {"arrayValue": {"values": [...]}}
+ *   - KvList -> {"kvlistValue": {"values": [{"key": "...", "value": ...}]}}
+ */
+internal object OTAnyValueSerializer : KSerializer<OTAnyValue> {
+  override val descriptor: SerialDescriptor =
+    buildClassSerialDescriptor("expo.modules.observe.OTAnyValue")
+
+  override fun serialize(encoder: Encoder, value: OTAnyValue) {
+    val jsonEncoder = encoder as? JsonEncoder
+      ?: error("OTAnyValue is only serializable to JSON (got ${encoder::class}).")
+
+    val element: JsonElement = when (value) {
+      is OTAnyValue.Str -> buildJsonObject { put("stringValue", JsonPrimitive(value.value)) }
+      is OTAnyValue.Int64 -> buildJsonObject { put("intValue", JsonPrimitive(value.value.toString())) }
+      is OTAnyValue.Dbl -> buildJsonObject { put("doubleValue", JsonPrimitive(value.value)) }
+      is OTAnyValue.Bln -> buildJsonObject { put("boolValue", JsonPrimitive(value.value)) }
+      is OTAnyValue.Arr -> buildJsonObject {
+        put(
+          "arrayValue",
+          buildJsonObject {
+            put(
+              "values",
+              jsonEncoder.json.encodeToJsonElement(
+                ListSerializer(OTAnyValueSerializer),
+                value.values
+              )
+            )
+          }
+        )
+      }
+      is OTAnyValue.KvList -> buildJsonObject {
+        put(
+          "kvlistValue",
+          buildJsonObject {
+            put(
+              "values",
+              jsonEncoder.json.encodeToJsonElement(
+                ListSerializer(OTKeyValue.serializer()),
+                value.values
+              )
+            )
+          }
+        )
+      }
+    }
+
+    jsonEncoder.encodeJsonElement(element)
+  }
+
+  override fun deserialize(decoder: Decoder): OTAnyValue {
+    val jsonDecoder = decoder as? JsonDecoder
+      ?: error("OTAnyValue is only deserializable from JSON (got ${decoder::class}).")
+    val obj = jsonDecoder.decodeJsonElement().jsonObject
+
+    obj["stringValue"]?.let {
+      return OTAnyValue.Str(it.jsonPrimitive.contentOrNull ?: "")
+    }
+    obj["intValue"]?.let {
+      val parsed = it.jsonPrimitive.contentOrNull?.toLongOrNull()
+        ?: it.jsonPrimitive.longOrNull
+        ?: error("OTAnyValue.intValue could not be parsed as Long: $it")
+      return OTAnyValue.Int64(parsed)
+    }
+    obj["doubleValue"]?.let {
+      return OTAnyValue.Dbl(it.jsonPrimitive.doubleOrNull ?: error("OTAnyValue.doubleValue not a number: $it"))
+    }
+    obj["boolValue"]?.let {
+      return OTAnyValue.Bln(it.jsonPrimitive.booleanOrNull ?: it.jsonPrimitive.boolean)
+    }
+    obj["arrayValue"]?.let { arr ->
+      val values = arr.jsonObject["values"]?.jsonArray
+        ?: error("OTAnyValue.arrayValue is missing `values`")
+      return OTAnyValue.Arr(values.map { jsonDecoder.json.decodeFromJsonElement(OTAnyValueSerializer, it) })
+    }
+    obj["kvlistValue"]?.let { kv ->
+      val values = kv.jsonObject["values"]?.jsonArray
+        ?: error("OTAnyValue.kvlistValue is missing `values`")
+      return OTAnyValue.KvList(values.map { jsonDecoder.json.decodeFromJsonElement(OTKeyValue.serializer(), it) })
+    }
+    error("OTAnyValue has no recognized variant: $obj")
+  }
+}

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

@@ -15,6 +15,7 @@ import androidx.work.OneTimeWorkRequestBuilder
 import androidx.work.WorkManager
 import androidx.work.WorkerParameters
 import androidx.work.workDataOf
+import expo.modules.observe.storage.PendingLogsManager
 import expo.modules.observe.storage.PendingMetricsManager
 import expo.modules.appmetrics.storage.SessionManager
 
@@ -43,12 +44,14 @@ class ObservabilityBackgroundWorker(
     )
 
     val pendingMetricsManager = PendingMetricsManager(context)
+    val pendingLogsManager = PendingLogsManager(context)
 
     BaseObservabilityManager(
       context = context,
       projectId = projectId,
       sessionManager = sessionManager,
       pendingMetricsManager = pendingMetricsManager,
+      pendingLogsManager = pendingLogsManager,
       baseUrl = baseUrl,
       isDebugBuild = BuildConfig.DEBUG,
       useOpenTelemetry = useOpenTelemetry
@@ -81,7 +84,8 @@ class ObservabilityBackgroundWorker(
       // This also adds a side benefit of cleaning up even if dispatch fails
       observabilityManager.cleanup()
       observabilityManager.dispatchUnsentMetrics()
-      Log.d(OBSERVE_TAG, "Successfully dispatched unsent metrics")
+      observabilityManager.dispatchUnsentLogs()
+      Log.d(OBSERVE_TAG, "Successfully dispatched unsent metrics and logs")
       Result.success()
     } catch (e: Exception) {
       Log.e(OBSERVE_TAG, "Failed to dispatch metrics", e)

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

@@ -2,6 +2,7 @@ package expo.modules.observe
 
 import android.content.Context
 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.interfaces.constants.ConstantsInterface
@@ -30,11 +31,13 @@ class ObservabilityManager(
     useOpenTelemetry = manifest.useOpenTelemetry
 
     val pendingMetricsManager = PendingMetricsManager(context)
+    val pendingLogsManager = PendingLogsManager(context)
 
     baseManager = BaseObservabilityManager(
       context = context,
       sessionManager = sessionManager,
       pendingMetricsManager = pendingMetricsManager,
+      pendingLogsManager = pendingLogsManager,
       projectId = projectId,
       baseUrl = baseUrl,
       isDebugBuild = BuildConfig.DEBUG,
@@ -44,12 +47,19 @@ class ObservabilityManager(
     sessionManager.addMetricsInsertListener { metricIds ->
       pendingMetricsManager.addPendingMetrics(metricIds)
     }
+    sessionManager.addLogsInsertListener { logIds ->
+      pendingLogsManager.addPendingLogs(logIds)
+    }
   }
 
   suspend fun dispatchUnsentMetrics() {
     baseManager.dispatchUnsentMetrics()
   }
 
+  suspend fun dispatchUnsentLogs() {
+    baseManager.dispatchUnsentLogs()
+  }
+
   fun scheduleBackgroundDispatch() {
     ObservabilityBackgroundWorker.scheduleBackgroundDispatch(
       context = context,
@@ -64,6 +74,7 @@ class BaseObservabilityManager(
   private val context: Context,
   private val sessionManager: SessionManager,
   private val pendingMetricsManager: PendingMetricsManager,
+  private val pendingLogsManager: PendingLogsManager,
   val projectId: String,
   val baseUrl: String,
   private val isDebugBuild: Boolean = false,
@@ -116,6 +127,49 @@ class BaseObservabilityManager(
     }
   }
 
+  /**
+   * 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() {
+    val pendingIds = pendingLogsManager.getAllPendingLogIds()
+    if (pendingIds.isEmpty()) {
+      return
+    }
+
+    if (!shouldDispatch()) {
+      pendingLogsManager.removePendingLogs(pendingIds)
+      return
+    }
+
+    val sessionsWithPendingLogs = sessionManager.getSessionsWithLogs(pendingIds)
+
+    // Clean up orphaned pending IDs (logs deleted from the `logs` table but
+    // still tracked in `pending_logs`).
+    val resolvedLogIds = sessionsWithPendingLogs.flatMap { it.logs }.map { it.logId }.toSet()
+    val orphanedIds = pendingIds.filter { it !in resolvedLogIds }
+    if (orphanedIds.isNotEmpty()) {
+      pendingLogsManager.removePendingLogs(orphanedIds)
+    }
+
+    if (sessionsWithPendingLogs.isEmpty()) {
+      return
+    }
+
+    val events = sessionsWithPendingLogs.map { sessionWithLogs ->
+      Event(
+        metadata = Metadata.fromSessionMetadata(sessionWithLogs.session),
+        metrics = emptyList(),
+        logs = sessionWithLogs.logs.map { LogEvent.fromLogRecord(it) }
+      )
+    }
+
+    if (eventDispatcher.dispatchLogs(events)) {
+      val dispatchedLogIds = sessionsWithPendingLogs.flatMap { it.logs }.map { it.logId }
+      pendingLogsManager.removePendingLogs(dispatchedLogIds)
+    }
+  }
+
   private fun isInSample(): Boolean {
     val rate = ObservePreferences.getConfig(context)?.sampleRate ?: return true
     val clamped = rate.coerceIn(0.0, 1.0)
@@ -136,7 +190,9 @@ class BaseObservabilityManager(
 
   suspend fun cleanup() {
     pendingMetricsManager.cleanupOldPendingMetrics()
-    // TODO(@ubax): Move sessionManager.cleanupOldMetrics() out of eas observe
-    sessionManager.cleanupOldMetrics()
+    pendingLogsManager.cleanupOldPendingLogs()
+    // TODO(@ubax): Move sessionManager.cleanupOldSessions out of eas observe
+    sessionManager.cleanupOldSessions()
+    sessionManager.cleanupOldLogs()
   }
 }

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

@@ -50,7 +50,10 @@ class ObserveModule : Module() {
         observabilityManager.scheduleBackgroundDispatch()
       }
 
-      AsyncFunction("dispatchEvents") Coroutine { -> observabilityManager.dispatchUnsentMetrics() }
+      AsyncFunction("dispatchEvents") Coroutine { ->
+        observabilityManager.dispatchUnsentMetrics()
+        observabilityManager.dispatchUnsentLogs()
+      }
 
       Function("configure") { config: Config ->
         ObservePreferences.setConfig(