expo-observe 56.0.7 → 56.0.9

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

@@ -191,7 +191,8 @@ private val metricNameMap = mapOf(
   (MetricCategory.Updates.categoryName to "updateDownloadTime") to "expo.updates.download_time",
 
   // Navigation
-  (MetricCategory.Navigation.categoryName to "ttr") to "expo.navigation.ttr",
+  (MetricCategory.Navigation.categoryName to "cold_ttr") to "expo.navigation.cold_ttr",
+  (MetricCategory.Navigation.categoryName to "warm_ttr") to "expo.navigation.warm_ttr",
   (MetricCategory.Navigation.categoryName to "tti") to "expo.navigation.tti"
 )
 

package/build/integrations/expo-router/ObserveRouterIntegrationProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObserveRouterIntegrationProvider.d.ts","sourceRoot":"","sources":["../../../src/integrations/expo-router/ObserveRouterIntegrationProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAA+B,MAAM,OAAO,CAAC;AAI3F,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE1F,eAAO,MAAM,+BAA+B,0DAAuD,CAAC;AAEpG,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAsB/E"}
+{"version":3,"file":"ObserveRouterIntegrationProvider.d.ts","sourceRoot":"","sources":["../../../src/integrations/expo-router/ObserveRouterIntegrationProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAA+B,MAAM,OAAO,CAAC;AAI3F,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE1F,eAAO,MAAM,+BAA+B,0DAAuD,CAAC;AAEpG,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAuB/E"}

package/build/integrations/expo-router/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/integrations/expo-router/init.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAS1D,eAAO,MAAM,aAAa,eAAoB,CAAC;AAE/C,wBAAgB,qBAAqB,SAGpC;AAED,KAAK,gBAAgB,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,2BAA2B,CAAC,CAAC;AAExF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,wBAAwB,EACjC,gBAAgB,EAAE,gBAAgB,GACjC,MAAM,IAAI,CAyEZ"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/integrations/expo-router/init.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAS1D,eAAO,MAAM,aAAa,eAAoB,CAAC;AAE/C,wBAAgB,qBAAqB,SAGpC;AAED,KAAK,gBAAgB,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC,2BAA2B,CAAC,CAAC;AAExF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,wBAAwB,EACjC,gBAAgB,EAAE,gBAAgB,GACjC,MAAM,IAAI,CAgFZ"}

package/expo-module.config.json

@@ -9,7 +9,7 @@
     "publication": {
       "groupId": "expo.modules.observe",
       "artifactId": "expo.modules.observe",
-      "version": "56.0.7",
+      "version": "56.0.9",
       "repository": "local-maven-repo"
     }
   }

package/ios/CursorRepair.swift

@@ -0,0 +1,55 @@
+// Copyright 2025-present 650 Industries. All rights reserved.
+
+import ExpoAppMetrics
+
+/**
+ Resets a dispatch cursor to `-1` if it has fallen past the largest id currently in its source
+ table. The cursors live in UserDefaults; their source tables can be wiped from underneath them
+ (notably on a schema-version mismatch in `expo-app-metrics`). Without this check the cursor would
+ skip every new row until enough accumulated to pass the stale value.
+
+ - `signalName`: short human-readable label ("metric" / "log") for log messages.
+ - `readCursor`: returns the persisted cursor value.
+ - `writeCursor`: persists a new cursor value.
+ - `readMaxId`: returns the largest id in the source table, or nil when empty.
+ */
+@AppMetricsActor
+internal func repairCursorIfStale(
+  signalName: String,
+  readCursor: () -> Int64,
+  writeCursor: (Int64) -> Void,
+  readMaxId: () throws -> Int64?
+) {
+  let cursor = readCursor()
+  let maxId: Int64?
+  do {
+    maxId = try readMaxId()
+  } catch {
+    observeLogger.warn("[Observe] Failed to read max \(signalName) id while repairing cursor: \(error.localizedDescription)")
+    return
+  }
+  if cursor > (maxId ?? -1) {
+    observeLogger.info("[Observe] Resetting stale \(signalName) dispatch cursor (was \(cursor), max id is \(maxId.map(String.init) ?? "<empty>"))")
+    writeCursor(-1)
+  }
+}
+
+@AppMetricsActor
+internal func repairMetricCursorIfStale() {
+  repairCursorIfStale(
+    signalName: "metric",
+    readCursor: { ObserveUserDefaults.lastDispatchedMetricId },
+    writeCursor: { ObserveUserDefaults.lastDispatchedMetricId = $0 },
+    readMaxId: { try AppMetrics.getMaxMetricId() }
+  )
+}
+
+@AppMetricsActor
+internal func repairLogCursorIfStale() {
+  repairCursorIfStale(
+    signalName: "log",
+    readCursor: { ObserveUserDefaults.lastDispatchedLogId },
+    writeCursor: { ObserveUserDefaults.lastDispatchedLogId = $0 },
+    readMaxId: { try AppMetrics.getMaxLogId() }
+  )
+}

package/ios/Event.swift

@@ -1,4 +1,6 @@
 import ExpoAppMetrics
+import ExpoModulesCore
+import Foundation
 
 /**
  An object representing an event providing some app metrics and the information about the app and the device.
@@ -64,58 +66,72 @@ struct Event: Codable, Sendable {
   }
 
   /**
-   Creates a new event for EAS, based on the objects from `expo-app-metrics` package.
+   Builds an `Event` from a session row plus its metric/log batch. The session row carries all the
+   metadata that used to live on `Entry`/`AppInfo`/`DeviceInfo`; metrics and logs are passed
+   separately so a partial dispatch (only the rows past a cursor) can still produce a valid event.
    */
-  static func create(app: AppInfo, device: DeviceInfo, sessions: [Session], environment: String? = nil) -> Event {
+  static func from(session: SessionRow, metrics: [MetricRow], logs: [LogRow]) -> Event {
+    let updatesInfo = AppInfo.UpdatesInfo(
+      updateId: session.appUpdateId,
+      runtimeVersion: session.appUpdateRuntimeVersion,
+      requestHeaders: decodeRequestHeaders(session.appUpdateRequestHeaders)
+    )
     return Event(
       metadata: Metadata(
-        appName: app.appName,
-        appIdentifier: app.appId,
-        appVersion: app.appVersion,
-        appBuildNumber: app.buildNumber,
-        appEasBuildId: app.easBuildId,
-        appUpdatesInfo: app.updatesInfo,
-
-        deviceName: device.modelName,
-        deviceModel: device.modelIdentifier,
-        deviceOs: device.systemName,
-        deviceOsVersion: device.systemVersion,
-
-        reactNativeVersion: app.reactNativeVersion,
-        expoSdkVersion: app.expoSdkVersion,
+        appName: session.appName,
+        appIdentifier: session.appIdentifier,
+        appVersion: session.appVersion,
+        appBuildNumber: session.appBuildNumber,
+        appEasBuildId: session.appEasBuildId,
+        appUpdatesInfo: updatesInfo.isEmpty ? nil : updatesInfo,
+        deviceName: session.deviceName ?? "",
+        deviceModel: session.deviceModel ?? "",
+        deviceOs: session.deviceOs ?? "",
+        deviceOsVersion: session.deviceOsVersion ?? "",
+        reactNativeVersion: session.reactNativeVersion ?? "",
+        expoSdkVersion: session.expoSdkVersion ?? "",
         clientVersion: ObserveVersions.clientVersion,
-
-        languageTag: Locale.preferredLanguages.first ?? "en-US",
-        environment: environment
+        languageTag: session.languageTag ?? Locale.preferredLanguages.first ?? "en-US",
+        environment: session.environment
       ),
-      metrics: sessions.flatMap { session in
-        return session.metrics.map { metric in
-          return Metric(
-            category: metric.category?.rawValue,
-            name: metric.name,
-            value: metric.value,
-            timestamp: metric.timestamp,
-            sessionId: session.id,
-            parentSessionId: nil,
-            routeName: metric.routeName,
-            updateId: metric.updateId,
-            customParams: metric.params
-          )
-        }
+      metrics: metrics.map { metric in
+        return Metric(
+          category: metric.category,
+          name: metric.name,
+          value: metric.value,
+          timestamp: metric.timestamp,
+          sessionId: metric.sessionId,
+          parentSessionId: nil,
+          routeName: metric.routeName,
+          updateId: metric.updateId,
+          customParams: decodeCustomParams(metric.params)
+        )
       },
-      logs: sessions.flatMap { session in
-        return session.logs.map { log in
-          return Log(
-            name: log.name,
-            body: log.body,
-            timestamp: log.timestamp,
-            severity: log.severity,
-            attributes: log.attributes,
-            droppedAttributesCount: log.droppedAttributesCount,
-            sessionId: session.id
-          )
-        }
+      logs: logs.map { log in
+        return Log(
+          name: log.name,
+          body: log.body,
+          timestamp: log.timestamp,
+          severity: Severity(rawValue: log.severity) ?? .info,
+          attributes: decodeCustomParams(log.attributes),
+          droppedAttributesCount: log.droppedAttributesCount,
+          sessionId: log.sessionId
+        )
       }
     )
   }
 }
+
+private func decodeRequestHeaders(_ json: String?) -> [String: String]? {
+  guard let json, let data = json.data(using: .utf8) else {
+    return nil
+  }
+  return try? JSONSerialization.jsonObject(with: data) as? [String: String]
+}
+
+private func decodeCustomParams(_ json: String?) -> AnyCodable? {
+  guard let json, let data = json.data(using: .utf8) else {
+    return nil
+  }
+  return try? JSONDecoder().decode(AnyCodable.self, from: data)
+}

package/ios/Observability.swift

@@ -10,155 +10,156 @@ internal struct ObservabilityManager {
   private static var projectId: String? = nil
   private static var useOpenTelemetry = false
 
-  /**
-   Returns entries from AppMetrics storage whose id is newer than the supplied
-   cursor.
-
-   The first (current) entry may have a lower id than the cursor when storage
-   was wiped, empty, or failed to decode — ids restart from 0 in that case.
-   We return all entries so the cursor can be repaired on the next dispatch.
-   */
-  private static func entriesNewerThan(cursor: Int) -> [MetricsStorage.Entry] {
-    let entries = AppMetrics.storage.getAllEntries()
-    if let firstEntry = entries.first, firstEntry.id < cursor {
-      return entries
-    }
-    return entries.filter { $0.id > cursor }
-  }
-
-  /**
-   Entries whose metrics have not been dispatched yet.
-   */
-  internal static func getEntriesToDispatch() -> [MetricsStorage.Entry] {
-    return entriesNewerThan(cursor: ObserveUserDefaults.lastDispatchedEntryId)
-  }
-
-  /**
-   Entries whose logs have not been dispatched yet. Tracked independently from
-   metrics so the two signals can advance in isolation.
-   */
-  internal static func getLogEntriesToDispatch() -> [MetricsStorage.Entry] {
-    return entriesNewerThan(cursor: ObserveUserDefaults.lastDispatchedLogEntryId)
-  }
-
   internal static func dispatch() async {
-    // Compute once and reuse for both signals — `shouldDispatch()` reads the
-    // persisted config, the bundle defaults, and computes a sample-rate hash.
-    // Both halves of dispatch want the same answer.
+    // Compute once and reuse for both signals — `shouldDispatch()` reads the persisted config, the
+    // bundle defaults, and computes a sample-rate hash. Both halves of dispatch want the same answer.
     let shouldDispatch = Self.shouldDispatch()
 
-    // Snapshot every entry as an `Event` once. Both metrics and logs project
-    // out of the same snapshot, so building it twice would duplicate the
-    // `Event.create` work for sessions that have both signals pending.
-    let allEntries = AppMetrics.storage.getAllEntries()
-    let eventsByEntryId: [Int: Event] = Dictionary(
-      uniqueKeysWithValues: allEntries.map { entry in
-        (
-          entry.id,
-          Event.create(
-            app: entry.app, device: entry.device, sessions: entry.sessions,
-            environment: entry.environment
-          )
-        )
-      }
-    )
-
-    await dispatchMetrics(eventsByEntryId: eventsByEntryId, shouldDispatch: shouldDispatch)
-    await dispatchLogs(eventsByEntryId: eventsByEntryId, shouldDispatch: shouldDispatch)
+    await dispatchMetrics(shouldDispatch: shouldDispatch)
+    await dispatchLogs(shouldDispatch: shouldDispatch)
   }
 
-  private static func dispatchMetrics(
-    eventsByEntryId: [Int: Event],
-    shouldDispatch: Bool
-  ) async {
-    let entries = getEntriesToDispatch()
+  private static func dispatchMetrics(shouldDispatch: Bool) async {
+    repairMetricCursorIfStale()
 
-    guard !entries.isEmpty, let endpointUrl = metricsEndpointUrl else {
-      // Nothing to dispatch
-      observeLogger.debug("[EAS Observe] No new entries to dispatch")
+    let cursor = ObserveUserDefaults.lastDispatchedMetricId
+    let pendingMetrics: [MetricRow]
+    do {
+      pendingMetrics = try AppMetrics.getMetrics(afterId: cursor)
+    } catch {
+      observeLogger.warn("[EAS Observe] Failed to read pending metrics: \(error.localizedDescription)")
+      return
+    }
+    guard !pendingMetrics.isEmpty, let endpointUrl = metricsEndpointUrl else {
+      observeLogger.debug("[EAS Observe] No new metrics to dispatch")
       return
     }
+    let highestId = pendingMetrics.last?.id ?? cursor
     if !shouldDispatch {
-      ObserveUserDefaults.lastDispatchedEntryId = entries.first?.id ?? -1
+      ObserveUserDefaults.lastDispatchedMetricId = highestId
+      return
+    }
+    let events: [Event]
+    do {
+      events = try buildEvents(forMetrics: pendingMetrics)
+    } catch {
+      observeLogger.warn("[EAS Observe] Failed to assemble metric events: \(error.localizedDescription)")
+      return
+    }
+    if events.isEmpty {
+      ObserveUserDefaults.lastDispatchedMetricId = highestId
       return
     }
     do {
-      let events = entries.compactMap { eventsByEntryId[$0.id] }
-
-      if events.isEmpty {
-        ObserveUserDefaults.lastDispatchedEntryId = entries.first?.id ?? -1
-        return
-      }
-
       let body: any Encodable
       if useOpenTelemetry {
-        body = OTRequestBody(resourceMetrics: events.map { $0.toOTEvent(easClientId)})
+        body = OTRequestBody(resourceMetrics: events.map { $0.toOTEvent(easClientId) })
       } else {
         body = RequestBody(easClientId: easClientId, events: events)
       }
-
       let success = try await sendRequest(to: endpointUrl, body: body)
       if success {
         ObserveUserDefaults.lastDispatchDate = Date.now
-        ObserveUserDefaults.lastDispatchedEntryId = entries.first?.id ?? -1
+        ObserveUserDefaults.lastDispatchedMetricId = highestId
       }
     } catch {
       observeLogger.warn("[EAS Observe] Dispatching the metrics has thrown an error: \(error)")
     }
   }
 
-  private static func dispatchLogs(
-    eventsByEntryId: [Int: Event],
-    shouldDispatch: Bool
-  ) async {
+  private static func dispatchLogs(shouldDispatch: Bool) async {
     // Logs are only sent in OpenTelemetry mode — there is no legacy logs endpoint.
     guard useOpenTelemetry else {
       return
     }
+    repairLogCursorIfStale()
 
-    let entries = getLogEntriesToDispatch()
-
-    guard !entries.isEmpty, let endpointUrl = logsEndpointUrl else {
-      observeLogger.debug("[EAS Observe] No new log entries to dispatch")
+    let cursor = ObserveUserDefaults.lastDispatchedLogId
+    let pendingLogs: [LogRow]
+    do {
+      pendingLogs = try AppMetrics.getLogs(afterId: cursor)
+    } catch {
+      observeLogger.warn("[EAS Observe] Failed to read pending logs: \(error.localizedDescription)")
+      return
+    }
+    guard !pendingLogs.isEmpty, let endpointUrl = logsEndpointUrl else {
+      observeLogger.debug("[EAS Observe] No new logs to dispatch")
       return
     }
+    let highestId = pendingLogs.last?.id ?? cursor
     if !shouldDispatch {
-      ObserveUserDefaults.lastDispatchedLogEntryId = entries.first?.id ?? -1
+      ObserveUserDefaults.lastDispatchedLogId = highestId
       return
     }
+    let events: [Event]
     do {
-      // Skip the request when there's nothing to send, but still advance the cursor so we
-      // don't keep re-checking the same entries.
-      let resourceLogs = entries.compactMap { entry -> OTResourceLogs? in
-        guard let event = eventsByEntryId[entry.id], !event.logs.isEmpty else {
-          return nil
-        }
-        return event.toOTResourceLogs(easClientId)
-      }
-      if resourceLogs.isEmpty {
-        ObserveUserDefaults.lastDispatchedLogEntryId = entries.first?.id ?? -1
-        return
+      events = try buildEvents(forLogs: pendingLogs)
+    } catch {
+      observeLogger.warn("[EAS Observe] Failed to assemble log events: \(error.localizedDescription)")
+      return
+    }
+    let resourceLogs = events.compactMap { event -> OTResourceLogs? in
+      guard !event.logs.isEmpty else {
+        return nil
       }
-
+      return event.toOTResourceLogs(easClientId)
+    }
+    if resourceLogs.isEmpty {
+      ObserveUserDefaults.lastDispatchedLogId = highestId
+      return
+    }
+    do {
       let body = OTLogsRequestBody(resourceLogs: resourceLogs)
       let success = try await sendRequest(to: endpointUrl, body: body)
       if success {
-        ObserveUserDefaults.lastDispatchedLogEntryId = entries.first?.id ?? -1
+        ObserveUserDefaults.lastDispatchedLogId = highestId
       }
     } catch {
       observeLogger.warn("[EAS Observe] Dispatching the logs has thrown an error: \(error)")
     }
   }
 
+  /**
+   Groups `metrics` by `sessionId`, hydrates the matching session rows, and emits one `Event` per
+   session in the same shape Android dispatches: each event carries the session's metadata and only
+   the metrics that belong to it.
+   */
+  private static func buildEvents(forMetrics metrics: [MetricRow]) throws -> [Event] {
+    let metricsBySession = Dictionary(grouping: metrics, by: \.sessionId)
+    let sessionIds = Array(metricsBySession.keys)
+    let sessions = try AppMetrics.getSessions(ids: sessionIds)
+    return sessions.compactMap { session in
+      guard let sessionMetrics = metricsBySession[session.id] else {
+        return nil
+      }
+      return Event.from(session: session, metrics: sessionMetrics, logs: [])
+    }
+  }
+
+  private static func buildEvents(forLogs logs: [LogRow]) throws -> [Event] {
+    let logsBySession = Dictionary(grouping: logs, by: \.sessionId)
+    let sessionIds = Array(logsBySession.keys)
+    let sessions = try AppMetrics.getSessions(ids: sessionIds)
+    return sessions.compactMap { session in
+      guard let sessionLogs = logsBySession[session.id] else {
+        return nil
+      }
+      return Event.from(session: session, metrics: [], logs: sessionLogs)
+    }
+  }
+
   private static func sendRequest(to endpointUrl: URL, body: any Encodable) async throws -> Bool {
     var request = URLRequest(url: endpointUrl)
     request.httpMethod = "POST"
     request.allHTTPHeaderFields = ["Content-Type": "application/json"]
     request.httpBody = try body.toJSONData([])
 
+    #if DEBUG
     observeLogger.debug("[EAS Observe] Sending the request to \(endpointUrl) with body:")
-    // Use `print` so the JSON can be copied without including the log level emojis.
+    // Use `print` so the JSON can be copied without including the log level emojis. Wrapped in
+    // `#if DEBUG` so release builds don't pay for a second pretty-printed encode of the payload.
     print(try body.toJSONString(.prettyPrinted))
+    #endif
 
     let (responseData, urlResponse) = try await URLSession.shared.data(for: request)
 
@@ -224,3 +225,4 @@ internal struct ObservabilityManager {
     return EASClientID.deterministicUniformValue(EASClientID.uuid()) < clamped
   }
 }
+

package/ios/ObserveUserDefaults.swift

@@ -35,8 +35,8 @@ internal final class ObserveUserDefaults: UserDefaults {
    Enum with keys used within this user defaults database.
    */
   private enum Keys: String {
-    case lastDispatchedEntryId
-    case lastDispatchedLogEntryId
+    case lastDispatchedMetricId
+    case lastDispatchedLogId
     case lastDispatchDate
     case config
     case bundleDefaults
@@ -65,29 +65,29 @@ internal final class ObserveUserDefaults: UserDefaults {
   }
 
   /**
-   Id of the last dispatched entry. It is used to prevent dispatching entries multiple times. The ids reflect the order of creation.
-   Using the creation date is not the best idea as the device's date can be changed by the user or shift along with the timezone.
+   Id of the last metric row dispatched. Each successful dispatch advances this past the largest id
+   in the batch so the next dispatch reads only newer rows. Auto-increment ids are monotonic in
+   SQLite, so a date-independent cursor avoids drift when the device clock changes.
    */
-  static var lastDispatchedEntryId: Int {
+  static var lastDispatchedMetricId: Int64 {
     get {
-      return defaults.object(forKey: Keys.lastDispatchedEntryId.rawValue) as? Int ?? -1
+      return (defaults.object(forKey: Keys.lastDispatchedMetricId.rawValue) as? Int64) ?? -1
     }
     set {
-      defaults.set(newValue, forKey: Keys.lastDispatchedEntryId.rawValue)
+      defaults.set(newValue, forKey: Keys.lastDispatchedMetricId.rawValue)
     }
   }
 
   /**
-   Id of the last entry whose logs were dispatched. Tracked separately from `lastDispatchedEntryId`
-   so that a logs request failure does not block metrics dispatch (and vice versa) — both signals
-   move forward independently.
+   Id of the last log row dispatched. Tracked separately from the metric cursor so a logs request
+   failure does not block metrics dispatch (and vice versa) — both signals move forward independently.
    */
-  static var lastDispatchedLogEntryId: Int {
+  static var lastDispatchedLogId: Int64 {
     get {
-      return defaults.object(forKey: Keys.lastDispatchedLogEntryId.rawValue) as? Int ?? -1
+      return (defaults.object(forKey: Keys.lastDispatchedLogId.rawValue) as? Int64) ?? -1
     }
     set {
-      defaults.set(newValue, forKey: Keys.lastDispatchedLogEntryId.rawValue)
+      defaults.set(newValue, forKey: Keys.lastDispatchedLogId.rawValue)
     }
   }
 

package/ios/OpenTelemetry.swift

@@ -11,10 +11,6 @@ struct OTStringValue: Codable, Sendable {
  Tagged union mirroring the OTLP `AnyValue` shape — encodes as an object with
  exactly one of `stringValue` / `intValue` / `doubleValue` / `boolValue` /
  `arrayValue` / `kvlistValue`, depending on the variant.
-
- OTLP encodes 64-bit integers as JSON strings to avoid precision loss; we follow
- that convention so collectors that rely on the protobuf-JSON mapping accept the
- payload.
  */
 enum OTAnyValue: Codable, Sendable {
   case string(String)
@@ -34,7 +30,10 @@ enum OTAnyValue: Codable, Sendable {
     case .string(let value):
       try container.encode(value, forKey: .stringValue)
     case .int(let value):
-      try container.encode(String(value), forKey: .intValue)
+      // OTLP/JSON spec encodes int64 as a stringified number to avoid loss in JS-style number
+      // handling, but the EAS observability backend (ClickHouse) rejects strings here and requires
+      // a JSON number. Emit as a number to match the server contract.
+      try container.encode(value, forKey: .intValue)
     case .double(let value):
       try container.encode(value, forKey: .doubleValue)
     case .bool(let value):
@@ -50,8 +49,8 @@ enum OTAnyValue: Codable, Sendable {
     let container = try decoder.container(keyedBy: CodingKeys.self)
     if let value = try container.decodeIfPresent(String.self, forKey: .stringValue) {
       self = .string(value)
-    } else if let value = try container.decodeIfPresent(String.self, forKey: .intValue), let parsed = Int64(value) {
-      self = .int(parsed)
+    } else if let value = try container.decodeIfPresent(Int64.self, forKey: .intValue) {
+      self = .int(value)
     } else if let value = try container.decodeIfPresent(Double.self, forKey: .doubleValue) {
       self = .double(value)
     } else if let value = try container.decodeIfPresent(Bool.self, forKey: .boolValue) {
@@ -180,19 +179,27 @@ private let semConvSchemaUrl = "https://opentelemetry.io/schemas/1.27.0"
 
 // This must be kept in sync with the INTERNAL_TO_OTEL map in universe
 // https://github.com/expo/universe/blob/main/server/www/src/middleware/easObserveRoutes.ts#L209
+// Keyed by "<category>/<name>" — mirrors the (category, name) pair used by the
+// Android port so the same metric name under a different category never silently
+// collides.
 let metricNameMap = [
-  "timeToInteractive": "expo.app_startup.tti",
-  "timeToFirstRender": "expo.app_startup.ttr",
-  "coldLaunchTime": "expo.app_startup.cold_launch_time",
-  "warmLaunchTime": "expo.app_startup.warm_launch_time",
-  "bundleLoadTime": "expo.app_startup.bundle_load_time",
+  // App startup
+  "appStartup/timeToInteractive": "expo.app_startup.tti",
+  "appStartup/timeToFirstRender": "expo.app_startup.ttr",
+  "appStartup/coldLaunchTime": "expo.app_startup.cold_launch_time",
+  "appStartup/warmLaunchTime": "expo.app_startup.warm_launch_time",
+  "appStartup/bundleLoadTime": "expo.app_startup.bundle_load_time",
 
-  // Legacy metrics - will be removed in a future release
-  "loadTime": "expo.app_startup.load_time",
-  "launchTime": "expo.app_startup.launch_time",
+  // Legacy app startup metrics - will be removed in a future release
+  "appStartup/loadTime": "expo.app_startup.load_time",
+  "appStartup/launchTime": "expo.app_startup.launch_time",
 
   // Updates
-  "updateDownloadTime": "expo.updates.download_time"
+  "updates/updateDownloadTime": "expo.updates.download_time",
+
+  // Navigation
+  "navigation/cold_ttr": "expo.navigation.cold_ttr",
+  "navigation/warm_ttr": "expo.navigation.warm_ttr"
 ]
 
 nonisolated(unsafe) let formatter = ISO8601DateFormatter()
@@ -224,9 +231,10 @@ extension Event.Metric {
       attributes.append(OTAttribute(key: "expo.custom_params", rawValue: customParamsString))
     }
 
+    let lookupKey = "\(self.category ?? "unknown")/\(self.name)"
     return OTMetric(
       unit: "s",
-      name: metricNameMap[self.name] ?? "expo.app_startup.\(self.name)",
+      name: metricNameMap[lookupKey] ?? "expo.unknown.\(self.name)",
       gauge: OTGauge(dataPoints: [
         OTDataPoint(
           timeUnixNano: nsFromISODateString(),
@@ -294,7 +302,10 @@ func otAttributesFromUserDict(_ dict: [String: Any]) -> (attributes: [OTAttribut
  and would otherwise be matched as `Int` first.
  */
 func otAnyValue(from value: Any) -> OTAnyValue? {
-  if let bool = value as? Bool {
+  // `as? Bool` succeeds for any NSNumber holding 0 or 1 — including `Int(0)` / `Int(1)` from JS,
+  // which would otherwise quietly emit as `boolValue` instead of `intValue`. Distinguish real
+  // booleans by checking against `CFBoolean`'s type id, which only the actual boxed Bool matches.
+  if CFGetTypeID(value as CFTypeRef) == CFBooleanGetTypeID(), let bool = value as? Bool {
     return .bool(bool)
   }
   if let int = value as? Int64 {