@logbrew/react-native 0.1.13 → 0.1.15

package/index.cjs

@@ -10,12 +10,13 @@ const {
 } = require("@logbrew/sdk");
 const {
   runtimeReactNativeDebugIdMap,
+  sanitizeReactNativeIssueExceptionChain,
   sanitizeReactNativeIssueMetadata,
   sanitizeReactNativeIssueStackFrames
 } = require("./metadata.cjs");
 
 const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.0";
+const DEFAULT_SDK_VERSION = "0.1.15";
 const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
 const MAX_ACTION_NAME_LENGTH = 64;
 const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;
@@ -636,11 +637,13 @@ function createReactNativeErrorEvent(error, {
     trace: traceContext
   });
   const stackFrames = sanitizeReactNativeIssueStackFrames(attributes.stackFrames);
+  const exceptionChain = sanitizeReactNativeIssueExceptionChain(attributes.exceptionChain);
   return {
     id: id ?? idFactory({ error, message: details.message, screen }),
     timestamp: timestamp ?? now(),
     attributes: {
       ...attributes,
+      ...(exceptionChain ? { exceptionChain } : {}),
       ...(stackFrames ? { stackFrames } : {}),
       title: `React Native error: ${details.message}`,
       message: details.message,

package/index.js

@@ -10,12 +10,13 @@ import {
 } from "@logbrew/sdk";
 import {
   runtimeReactNativeDebugIdMap,
+  sanitizeReactNativeIssueExceptionChain,
   sanitizeReactNativeIssueMetadata,
   sanitizeReactNativeIssueStackFrames
 } from "./metadata.js";
 
 const DEFAULT_SDK_NAME = "logbrew-react-native";
-const DEFAULT_SDK_VERSION = "0.1.0";
+const DEFAULT_SDK_VERSION = "0.1.15";
 const DEFAULT_ENDPOINT = "https://api.logbrew.co/v1/events";
 const MAX_ACTION_NAME_LENGTH = 64;
 const MAX_PRODUCT_ANALYTICS_SURFACE_LENGTH = 256;
@@ -625,11 +626,13 @@ export function createReactNativeErrorEvent(error, {
     trace: traceContext
   });
   const stackFrames = sanitizeReactNativeIssueStackFrames(attributes.stackFrames);
+  const exceptionChain = sanitizeReactNativeIssueExceptionChain(attributes.exceptionChain);
   return {
     id: id ?? idFactory({ error, message: details.message, screen }),
     timestamp: timestamp ?? now(),
     attributes: {
       ...attributes,
+      ...(exceptionChain ? { exceptionChain } : {}),
       ...(stackFrames ? { stackFrames } : {}),
       title: `React Native error: ${details.message}`,
       message: details.message,

package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift

@@ -3,7 +3,7 @@ import Foundation
 @objc(LBRNAppleNativeDiagnostics)
 public final class LBRNAppleNativeDiagnostics: NSObject, @unchecked Sendable {
     private static let shared = LBRNAppleNativeDiagnostics()
-    private static let sdkVersion = "0.1.13"
+    private static let sdkVersion = "0.1.15"
 
     private let lock = NSLock()
     private let replayQueue = DispatchQueue(label: "co.logbrew.react-native.apple-diagnostics-replay")

package/ios/GeneratedAppleDiagnostics/LogBrew/IssueDiagnostics.swift

@@ -110,24 +110,30 @@ public extension IssueAttributes {
     ) -> IssueAttributes {
         let exceptionType = safeSwiftErrorType(error)
         let fileModule = fileID.split(separator: "/", maxSplits: 1).first.map(String.init)
+        let exceptionMechanism = IssueExceptionMechanism(type: mechanism, handled: handled)
+        let rootFrame = IssueStackFrame(
+            filename: fileID,
+            line: line,
+            column: column,
+            function: function,
+            module: fileModule,
+            inApp: true,
+        )
         return IssueAttributes(
             title: title ?? exceptionType,
             level: level,
             message: message,
             exception: IssueException(
                 type: exceptionType,
-                mechanism: IssueExceptionMechanism(type: mechanism, handled: handled),
+                mechanism: exceptionMechanism,
+            ),
+            exceptionChain: swiftExceptionChain(
+                from: error,
+                rootType: exceptionType,
+                rootMechanism: exceptionMechanism,
+                rootFrame: rootFrame,
             ),
-            stackFrames: [
-                IssueStackFrame(
-                    filename: fileID,
-                    line: line,
-                    column: column,
-                    function: function,
-                    module: fileModule,
-                    inApp: true,
-                ),
-            ],
+            stackFrames: [rootFrame],
             breadcrumbs: breadcrumbs,
             breadcrumbsTruncated: breadcrumbsTruncated,
             metadata: metadata,
@@ -171,6 +177,13 @@ let maximumIssueBreadcrumbs = 64
 func normalizeIssueAttributes(_ value: IssueAttributes) throws -> IssueAttributes {
     let exception = try value.exception.map(validateIssueException)
     let stackFrames = try normalizeIssueStackFrames(value.stackFrames)
+    let exceptionChain = try value.exceptionChain.map {
+        try normalizeIssueExceptionChain(
+            $0,
+            exception: exception,
+            stackFrames: stackFrames,
+        )
+    }
     let breadcrumbs = try normalizeIssueBreadcrumbs(value.breadcrumbs)
     let breadcrumbsWereCapped = (value.breadcrumbs?.count ?? 0) > maximumIssueBreadcrumbs
     let context = try value.context.map { try validateTelemetryContext($0) }
@@ -180,6 +193,7 @@ func normalizeIssueAttributes(_ value: IssueAttributes) throws -> IssueAttribute
         level: value.level,
         message: value.message,
         exception: exception,
+        exceptionChain: exceptionChain,
         stackFrames: stackFrames,
         breadcrumbs: breadcrumbs,
         breadcrumbsTruncated: breadcrumbsWereCapped ? true : value.breadcrumbsTruncated,
@@ -204,6 +218,7 @@ func issueAttributes(
         level: value.level,
         message: value.message,
         exception: value.exception,
+        exceptionChain: value.exceptionChain,
         stackFrames: value.stackFrames,
         breadcrumbs: capped,
         breadcrumbsTruncated: value.breadcrumbsTruncated == true
@@ -256,7 +271,7 @@ func validateIssueBreadcrumb(_ value: IssueBreadcrumb) throws -> IssueBreadcrumb
     )
 }
 
-private func normalizeIssueStackFrames(_ values: [IssueStackFrame]?) throws -> [IssueStackFrame]? {
+func normalizeIssueStackFrames(_ values: [IssueStackFrame]?) throws -> [IssueStackFrame]? {
     guard let values else {
         return nil
     }
@@ -355,7 +370,7 @@ private func sanitizedIssueFilename(_ value: String) throws -> String {
     )
 }
 
-private func issueText(
+func issueText(
     _ value: String,
     label: String,
     maximum: Int,
@@ -370,16 +385,6 @@ private func issueText(
     return normalized
 }
 
-private func safeSwiftErrorType(_ error: any Error) -> String {
-    let reflected = String(reflecting: Swift.type(of: error))
-    let normalized = reflected.trimmingCharacters(in: .whitespacesAndNewlines)
-    guard !normalized.isEmpty, !containsForbiddenControl(normalized) else {
-        return "Swift.Error"
-    }
-    let filtered = normalized.filter { $0 != "?" && $0 != "#" }
-    return String(filtered.prefix(256))
-}
-
-private func issueValidationError(_ message: String) -> SdkError {
+func issueValidationError(_ message: String) -> SdkError {
     SdkError(code: "validation_error", message: message)
 }

package/ios/GeneratedAppleDiagnostics/LogBrew/IssueExceptionChain.swift

@@ -0,0 +1,355 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+/// How one runtime exception relates to its earlier parent node.
+public enum IssueExceptionRelationship: String, Codable, Equatable, Sendable {
+    case reported
+    case cause
+    case context
+    case aggregateMember = "aggregate_member"
+    case suppressed
+}
+
+/// Explicit capture state for one exception message.
+public enum IssueExceptionMessageState: String, Codable, Equatable, Sendable {
+    case captured
+    case truncated
+    case redacted
+    case notCaptured = "not_captured"
+}
+
+/// Explicit capture state for one exception stack.
+public enum IssueExceptionStackFramesState: String, Codable, Equatable, Sendable {
+    case captured
+    case truncated
+    case notCaptured = "not_captured"
+}
+
+/// One parent-first runtime exception with its own bounded evidence states.
+public struct IssueExceptionChainEntry: Codable, Equatable, Sendable {
+    public let id: Int
+    public let parentId: Int?
+    public let relationship: IssueExceptionRelationship
+    public let type: String
+    public let message: String?
+    public let messageState: IssueExceptionMessageState
+    public let module: String?
+    public let mechanism: IssueExceptionMechanism?
+    public let stackFrames: [IssueStackFrame]?
+    public let stackFramesState: IssueExceptionStackFramesState
+
+    public init(
+        id: Int,
+        parentId: Int? = nil,
+        relationship: IssueExceptionRelationship,
+        type: String,
+        message: String? = nil,
+        messageState: IssueExceptionMessageState = .notCaptured,
+        module: String? = nil,
+        mechanism: IssueExceptionMechanism? = nil,
+        stackFrames: [IssueStackFrame]? = nil,
+        stackFramesState: IssueExceptionStackFramesState = .notCaptured,
+    ) {
+        self.id = id
+        self.parentId = parentId
+        self.relationship = relationship
+        self.type = type
+        self.message = message
+        self.messageState = messageState
+        self.module = module
+        self.mechanism = mechanism
+        self.stackFrames = stackFrames
+        self.stackFramesState = stackFramesState
+    }
+}
+
+/// At most eight parent-first runtime exceptions.
+public struct IssueExceptionChain: Codable, Equatable, Sendable {
+    public let entries: [IssueExceptionChainEntry]
+    public let truncated: Bool
+
+    public init(entries: [IssueExceptionChainEntry], truncated: Bool = false) {
+        self.entries = entries
+        self.truncated = truncated
+    }
+}
+
+private struct PendingSwiftException {
+    let error: any Error
+    let parentId: Int?
+    let relationship: IssueExceptionRelationship
+    let mechanism: IssueExceptionMechanism
+}
+
+private let maximumIssueExceptions = 8
+private let multipleUnderlyingErrorsKey = "NSMultipleUnderlyingErrors"
+
+func swiftExceptionChain(
+    from error: any Error,
+    rootType: String,
+    rootMechanism: IssueExceptionMechanism,
+    rootFrame: IssueStackFrame,
+) -> IssueExceptionChain {
+    var pending = [PendingSwiftException(
+        error: error,
+        parentId: nil,
+        relationship: .reported,
+        mechanism: rootMechanism,
+    )]
+    var entries: [IssueExceptionChainEntry] = []
+    var seenErrors: [NSError] = []
+    var truncated = false
+    while !pending.isEmpty {
+        let current = pending.removeFirst()
+        let nsError = current.error as NSError
+        if swiftErrorWasSeen(nsError, in: seenErrors) {
+            truncated = true
+            continue
+        }
+        guard entries.count < maximumIssueExceptions else {
+            truncated = true
+            break
+        }
+        seenErrors.append(nsError)
+        let id = entries.count
+        entries.append(swiftExceptionEntry(current, id: id, rootType: rootType, rootFrame: rootFrame))
+        pending.append(contentsOf: swiftPendingChildren(nsError, parentId: id))
+    }
+    return IssueExceptionChain(entries: entries, truncated: truncated || !pending.isEmpty)
+}
+
+private func swiftErrorWasSeen(_ error: NSError, in seenErrors: [NSError]) -> Bool {
+    let identity = ObjectIdentifier(error)
+    return seenErrors.contains { ObjectIdentifier($0) == identity }
+}
+
+private func swiftExceptionEntry(
+    _ current: PendingSwiftException,
+    id: Int,
+    rootType: String,
+    rootFrame: IssueStackFrame,
+) -> IssueExceptionChainEntry {
+    let type = id == 0 ? rootType : safeSwiftErrorType(current.error)
+    return IssueExceptionChainEntry(
+        id: id,
+        parentId: current.parentId,
+        relationship: current.relationship,
+        type: type,
+        messageState: .redacted,
+        module: swiftExceptionModule(type),
+        mechanism: current.mechanism,
+        stackFrames: id == 0 ? [rootFrame] : nil,
+        stackFramesState: id == 0 ? .captured : .notCaptured,
+    )
+}
+
+private func swiftPendingChildren(
+    _ error: NSError,
+    parentId: Int,
+) -> [PendingSwiftException] {
+    swiftUnderlyingErrors(error).map { child in
+        PendingSwiftException(
+            error: child.error,
+            parentId: parentId,
+            relationship: child.relationship,
+            mechanism: IssueExceptionMechanism(
+                type: child.relationship == .aggregateMember
+                    ? "swift.aggregate_member"
+                    : "swift.underlying_error",
+                handled: true,
+            ),
+        )
+    }
+}
+
+private func swiftUnderlyingErrors(
+    _ error: NSError,
+) -> [(error: any Error, relationship: IssueExceptionRelationship)] {
+    if let aggregate = error.userInfo[multipleUnderlyingErrorsKey] as? [any Error], !aggregate.isEmpty {
+        return aggregate.map { ($0, .aggregateMember) }
+    }
+    if let underlying = error.userInfo[NSUnderlyingErrorKey] as? any Error {
+        return [(underlying, .cause)]
+    }
+    return []
+}
+
+func safeSwiftErrorType(_ error: any Error) -> String {
+    let reflected = String(reflecting: Swift.type(of: error))
+    let normalized = reflected.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !normalized.isEmpty, !containsForbiddenControl(normalized) else {
+        return "Swift.Error"
+    }
+    let filtered = normalized.filter { $0 != "?" && $0 != "#" }
+    return String(filtered.prefix(256))
+}
+
+private func swiftExceptionModule(_ type: String) -> String? {
+    guard let delimiter = type.lastIndex(of: ".") else {
+        return nil
+    }
+    let value = String(type[..<delimiter])
+    return value.isEmpty ? nil : String(value.prefix(512))
+}
+
+func normalizeIssueExceptionChain(
+    _ value: IssueExceptionChain,
+    exception: IssueException?,
+    stackFrames: [IssueStackFrame]?,
+) throws -> IssueExceptionChain {
+    guard (1 ... maximumIssueExceptions).contains(value.entries.count) else {
+        throw issueValidationError("issue exceptionChain entries must contain 1-8 exceptions")
+    }
+    let entries = try value.entries.enumerated().map { index, entry in
+        try validateExceptionChainTopology(entry, at: index)
+        return try normalizeIssueExceptionChainEntry(entry)
+    }
+    try validateReportedException(entries[0], exception: exception, stackFrames: stackFrames)
+    return IssueExceptionChain(entries: entries, truncated: value.truncated)
+}
+
+private func validateExceptionChainTopology(
+    _ entry: IssueExceptionChainEntry,
+    at index: Int,
+) throws {
+    guard entry.id == index else {
+        throw issueValidationError(
+            "issue exceptionChain ids must be contiguous and match array order",
+        )
+    }
+    if index == 0 {
+        guard entry.relationship == .reported, entry.parentId == nil else {
+            throw issueValidationError(
+                "issue exceptionChain entry 0 must be the parentless reported exception",
+            )
+        }
+        return
+    }
+    guard entry.relationship != .reported,
+          let parentId = entry.parentId,
+          parentId >= 0,
+          parentId < index
+    else {
+        throw issueValidationError("issue exceptionChain parent relationship is invalid")
+    }
+}
+
+private func validateReportedException(
+    _ root: IssueExceptionChainEntry,
+    exception: IssueException?,
+    stackFrames: [IssueStackFrame]?,
+) throws {
+    guard let exception,
+          root.type == exception.type,
+          root.mechanism == exception.mechanism
+    else {
+        throw issueValidationError(
+            "issue exceptionChain reported exception must match exception",
+        )
+    }
+    let stackMatches = switch root.stackFramesState {
+    case .notCaptured:
+        stackFrames == nil
+    case .captured, .truncated:
+        root.stackFrames == stackFrames
+    }
+    guard stackMatches else {
+        throw issueValidationError(
+            "issue exceptionChain reported stack must match stackFrames",
+        )
+    }
+}
+
+private func normalizeIssueExceptionChainEntry(
+    _ value: IssueExceptionChainEntry,
+) throws -> IssueExceptionChainEntry {
+    let type = try issueText(
+        value.type,
+        label: "issue exceptionChain type",
+        maximum: 256,
+        disallowLocationDelimiters: true,
+    )
+    let message = try normalizedExceptionMessage(value)
+    let module = try value.module.map {
+        try issueText(
+            $0,
+            label: "issue exceptionChain module",
+            maximum: 512,
+            disallowLocationDelimiters: true,
+        )
+    }
+    let mechanism = try normalizedExceptionMechanism(value.mechanism, type: type)
+    let stack = try normalizedExceptionStack(value)
+    return IssueExceptionChainEntry(
+        id: value.id,
+        parentId: value.parentId,
+        relationship: value.relationship,
+        type: type,
+        message: message,
+        messageState: value.messageState,
+        module: module,
+        mechanism: mechanism,
+        stackFrames: stack.frames,
+        stackFramesState: stack.state,
+    )
+}
+
+private func normalizedExceptionMessage(
+    _ value: IssueExceptionChainEntry,
+) throws -> String? {
+    switch value.messageState {
+    case .captured, .truncated:
+        guard let message = value.message else {
+            throw issueValidationError("issue exceptionChain message must match messageState")
+        }
+        return try issueText(
+            message,
+            label: "issue exceptionChain message",
+            maximum: 1024,
+        )
+    case .redacted, .notCaptured:
+        guard value.message == nil else {
+            throw issueValidationError("issue exceptionChain message must match messageState")
+        }
+        return nil
+    }
+}
+
+private func normalizedExceptionMechanism(
+    _ mechanism: IssueExceptionMechanism?,
+    type: String,
+) throws -> IssueExceptionMechanism? {
+    guard let mechanism else {
+        return nil
+    }
+    let normalized = try validateIssueException(
+        IssueException(type: type, mechanism: mechanism),
+    )
+    guard let result = normalized.mechanism else {
+        throw issueValidationError("issue exception mechanism type is invalid")
+    }
+    return result
+}
+
+private func normalizedExceptionStack(
+    _ value: IssueExceptionChainEntry,
+) throws -> (frames: [IssueStackFrame]?, state: IssueExceptionStackFramesState) {
+    switch value.stackFramesState {
+    case .captured, .truncated:
+        guard let frames = value.stackFrames, !frames.isEmpty else {
+            throw issueValidationError(
+                "issue exceptionChain stackFrames must match stackFramesState",
+            )
+        }
+        let normalized = try normalizeIssueStackFrames(frames)
+        return (normalized, frames.count > 32 ? .truncated : value.stackFramesState)
+    case .notCaptured:
+        guard value.stackFrames == nil else {
+            throw issueValidationError(
+                "issue exceptionChain stackFrames must match stackFramesState",
+            )
+        }
+        return (nil, .notCaptured)
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/LogBrewClient.swift

@@ -205,6 +205,7 @@ private extension IssueAttributes {
             level: level,
             message: message,
             exception: exception,
+            exceptionChain: exceptionChain,
             stackFrames: stackFrames,
             breadcrumbs: breadcrumbs,
             breadcrumbsTruncated: breadcrumbsTruncated,
@@ -220,6 +221,7 @@ private extension IssueAttributes {
             level: level,
             message: message,
             exception: exception,
+            exceptionChain: exceptionChain,
             stackFrames: stackFrames,
             breadcrumbs: breadcrumbs,
             breadcrumbsTruncated: breadcrumbsTruncated,
@@ -277,6 +279,7 @@ private extension MetricAttributes {
             temporality: temporality,
             metadata: metadata,
             context: context,
+            description: description,
         )
     }
 
@@ -289,6 +292,7 @@ private extension MetricAttributes {
             temporality: temporality,
             metadata: correlationMetadata(metadata, context: context),
             context: context,
+            description: description,
         )
     }
 }

package/ios/GeneratedAppleDiagnostics/LogBrew/PublicTypes.swift

@@ -171,6 +171,7 @@ public struct IssueAttributes: Codable, Equatable, Sendable {
     public let level: IssueLevel
     public let message: String?
     public let exception: IssueException?
+    public let exceptionChain: IssueExceptionChain?
     public let stackFrames: [IssueStackFrame]?
     public let breadcrumbs: [IssueBreadcrumb]?
     public let breadcrumbsTruncated: Bool?
@@ -183,6 +184,7 @@ public struct IssueAttributes: Codable, Equatable, Sendable {
         level: IssueLevel,
         message: String? = nil,
         exception: IssueException? = nil,
+        exceptionChain: IssueExceptionChain? = nil,
         stackFrames: [IssueStackFrame]? = nil,
         breadcrumbs: [IssueBreadcrumb]? = nil,
         breadcrumbsTruncated: Bool? = nil,
@@ -193,6 +195,7 @@ public struct IssueAttributes: Codable, Equatable, Sendable {
         self.level = level
         self.message = message
         self.exception = exception
+        self.exceptionChain = exceptionChain
         self.stackFrames = stackFrames
         self.breadcrumbs = breadcrumbs
         self.breadcrumbsTruncated = breadcrumbsTruncated
@@ -207,6 +210,7 @@ public struct IssueAttributes: Codable, Equatable, Sendable {
         level: IssueLevel,
         message: String? = nil,
         exception: IssueException? = nil,
+        exceptionChain: IssueExceptionChain? = nil,
         stackFrames: [IssueStackFrame]? = nil,
         breadcrumbs: [IssueBreadcrumb]? = nil,
         breadcrumbsTruncated: Bool? = nil,
@@ -218,6 +222,7 @@ public struct IssueAttributes: Codable, Equatable, Sendable {
         self.level = level
         self.message = message
         self.exception = exception
+        self.exceptionChain = exceptionChain
         self.stackFrames = stackFrames
         self.breadcrumbs = breadcrumbs
         self.breadcrumbsTruncated = breadcrumbsTruncated
@@ -307,6 +312,7 @@ public struct ActionAttributes: Codable, Equatable, Sendable {
 
 public struct MetricAttributes: Codable, Equatable, Sendable {
     public let name: String
+    public let description: String?
     public let kind: MetricKind
     public let value: Double
     public let unit: String
@@ -322,8 +328,10 @@ public struct MetricAttributes: Codable, Equatable, Sendable {
         temporality: MetricTemporality,
         metadata: Metadata? = nil,
         context: TelemetryContext? = nil,
+        description: String? = nil,
     ) {
         self.name = name
+        self.description = description
         self.kind = kind
         self.value = value
         self.unit = unit

package/ios/GeneratedAppleDiagnostics/LogBrew/Validation.swift

@@ -121,6 +121,7 @@ func validateMetric(_ attributes: MetricAttributes) throws -> MetricAttributes {
         }
     }
     try validateMetadata(attributes.metadata, label: "metric metadata")
+    let description = try attributes.description.map(normalizeMetricDescription)
     return try MetricAttributes(
         name: attributes.name,
         kind: attributes.kind,
@@ -129,9 +130,27 @@ func validateMetric(_ attributes: MetricAttributes) throws -> MetricAttributes {
         temporality: attributes.temporality,
         metadata: attributes.metadata,
         context: attributes.context.map { try validateTelemetryContext($0) },
+        description: description,
     )
 }
 
+private func normalizeMetricDescription(_ value: String) throws -> String {
+    let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines)
+    let invalidCharacter = normalized.unicodeScalars.contains { scalar in
+        scalar.value <= 0x1F
+            || (0x7F ... 0x9F).contains(scalar.value)
+            || scalar.value == 0x2028
+            || scalar.value == 0x2029
+    }
+    guard !normalized.isEmpty, normalized.unicodeScalars.count <= 1024, !invalidCharacter else {
+        throw SdkError(
+            code: "validation_error",
+            message: "metric description must be a non-blank string of at most 1024 non-control characters",
+        )
+    }
+    return normalized
+}
+
 func requireNonEmpty(_ label: String, _ value: String) throws {
     if value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
         throw SdkError(code: "validation_error", message: "\(label) must be non-empty")

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashExceptionEvidence.swift

@@ -0,0 +1,44 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+func nativeCrashExceptionChain(for exception: IssueException) -> IssueExceptionChain {
+    IssueExceptionChain(entries: [
+        IssueExceptionChainEntry(
+            id: 0,
+            relationship: .reported,
+            type: exception.type,
+            messageState: .notCaptured,
+            mechanism: exception.mechanism,
+            stackFramesState: .notCaptured,
+        ),
+    ])
+}
+
+func nativeCrashExceptionChainMatches(
+    _ value: Any?,
+    expected exception: IssueException,
+) -> Bool {
+    guard let value else {
+        // Preserve retry identity for an event queued by an older SDK before chains existed.
+        return true
+    }
+    guard let chain = value as? [String: Any] else {
+        return false
+    }
+    guard let mechanism = exception.mechanism else {
+        return false
+    }
+    let expected = [
+        "entries": [[
+            "id": 0,
+            "relationship": "reported",
+            "type": exception.type,
+            "messageState": "not_captured",
+            "mechanism": ["type": mechanism.type, "handled": mechanism.handled],
+            "stackFramesState": "not_captured",
+        ]],
+        "truncated": false,
+    ] as NSDictionary
+    return chain as NSDictionary == expected
+}

package/ios/GeneratedAppleDiagnostics/LogBrewCrash/NativeCrashPublic.swift

@@ -234,13 +234,8 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         return IssueAttributes(
             title: hangState == nil ? "Native application crash" : "Native application hang",
             level: hangState == .recovered ? .error : .fatal,
-            exception: IssueException(
-                type: hangState == nil ? "AppleNativeCrash" : "AppleNativeHang",
-                mechanism: IssueExceptionMechanism(
-                    type: mechanism.name,
-                    handled: hangState == .recovered,
-                ),
-            ),
+            exception: issueException,
+            exceptionChain: nativeCrashExceptionChain(for: issueException),
             metadata: metadata,
             nativeStackFrames: nativeStackFrames,
         )
@@ -263,6 +258,10 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
               attributes["level"] as? String == issueAttributes.level.canonicalValue,
               attributes["message"] == nil,
               exceptionMatches(attributes["exception"]),
+              nativeCrashExceptionChainMatches(
+                  attributes["exceptionChain"],
+                  expected: issueException,
+              ),
               attributes["stackFrames"] == nil,
               attributes["breadcrumbs"] == nil,
               attributes["breadcrumbsTruncated"] == nil,
@@ -306,6 +305,16 @@ public final class NativeCrashRecord: NSObject, @unchecked Sendable {
         ] as NSDictionary
     }
 
+    private var issueException: IssueException {
+        IssueException(
+            type: hangState == nil ? "AppleNativeCrash" : "AppleNativeHang",
+            mechanism: IssueExceptionMechanism(
+                type: mechanism.name,
+                handled: hangState == .recovered,
+            ),
+        )
+    }
+
     private func exceptionMatches(_ value: Any?) -> Bool {
         guard let value else {
             // Preserve exact retry identity for an event queued by an older SDK before typed exceptions existed.

package/ios/GeneratedAppleDiagnostics/SOURCE-MANIFEST.json

@@ -10,28 +10,30 @@
     "swift/logbrew-swift/Sources/LogBrew/DurableDeliveryStore.swift": "2de6a08473722ebd99b2d1762ed3356fefc0181f5cd886367fbfd52c75c6644b",
     "swift/logbrew-swift/Sources/LogBrew/DurableDeliveryStoreRecovery.swift": "a843f784e7645f916bb0f401e88fa7d49fa8c4351dc2f26c1fbf32be3f4aaa40",
     "swift/logbrew-swift/Sources/LogBrew/EventEncoding.swift": "b88b6b2d17f7d0cee9ac1a1f34ef35b192cd33d213ef3c9e1c2d21cbcc304a97",
-    "swift/logbrew-swift/Sources/LogBrew/IssueDiagnostics.swift": "797e6e25f203930e85f827bf211b58c73e6b10938b9f0943f2fe6f6757186ba9",
+    "swift/logbrew-swift/Sources/LogBrew/IssueDiagnostics.swift": "fc805effd3da6084e8cac2bbfe8fdc098e07d45d6f3ce2e7df02ebe0e445591f",
+    "swift/logbrew-swift/Sources/LogBrew/IssueExceptionChain.swift": "10f81cbce95b47da0a44ef9e515b150e60d71dfcc8b04be24b037b1222a373a5",
     "swift/logbrew-swift/Sources/LogBrew/LifecycleTrace.swift": "738cd3f129fac821a892404d1d42ee92bd806b6583d3dbb5379e88b14ab23c16",
-    "swift/logbrew-swift/Sources/LogBrew/LogBrewClient.swift": "2e6dd7c9ef07f181a2798c36a820338e3f81369b1b9c7b85c5c3b6f44103732c",
+    "swift/logbrew-swift/Sources/LogBrew/LogBrewClient.swift": "0f7e23a21fd8f76af031205847cd0b8b2648a069abac8d0ddc8c16da017893b7",
     "swift/logbrew-swift/Sources/LogBrew/LogBrewLogger.swift": "d3266353a5f5139a2a1ca1a86bacce793518eb1489bf67ed9e3720b57b1c29b2",
     "swift/logbrew-swift/Sources/LogBrew/LogBrewTrace.swift": "f67edf4ca464e6a6eb1c7a22cd4997928cd27b6c2d07535855a18a053d8de924",
     "swift/logbrew-swift/Sources/LogBrew/Metadata.swift": "65840ebb3f3b79fbfc1f5faa3026c2583319e89ff26061676dc552c03ee15dbe",
     "swift/logbrew-swift/Sources/LogBrew/NativeStackFrame.swift": "ecbd418969ec4a31503d9916a8bf27f22e6863356c6fabe457c1e61027a8d805",
     "swift/logbrew-swift/Sources/LogBrew/ProductTimeline.swift": "209906aa0e8f096a347e35832840522710eadfb530053253cd73c748518e362d",
-    "swift/logbrew-swift/Sources/LogBrew/PublicTypes.swift": "d64de009cd9f8f43fc059cd8fefc2a282c781ba8543be2f56cb48cb757dbe924",
+    "swift/logbrew-swift/Sources/LogBrew/PublicTypes.swift": "1151d5402a9f5441f5d5d998fde57c8df88cb3180d2daa3e0fc49e883ab274f2",
     "swift/logbrew-swift/Sources/LogBrew/TelemetryContext.swift": "ce3ac93a62a345f8c9a8f4c69ce84efc991bf02a688f49bad5e68edcff2f6e08",
     "swift/logbrew-swift/Sources/LogBrew/TelemetryContextValidation.swift": "f631beef20a8a86f975787b4092a9798fedbe2c9e3f0d2740f81831b4adef287",
     "swift/logbrew-swift/Sources/LogBrew/TraceEvidence.swift": "40aaa42976164c53d9f4d9e9e30d236534238da43bbe90832a673c8809ad54b6",
     "swift/logbrew-swift/Sources/LogBrew/Transport.swift": "73eec81aaebec4bc922b2a372429c88fcd3e85606a7862cd08e1795eb2a8e6cd",
     "swift/logbrew-swift/Sources/LogBrew/URLSessionTrace.swift": "d0076c72671716c41bd7498d0509e453b8182c418156e169196fee9f26fc66b1",
     "swift/logbrew-swift/Sources/LogBrew/URLSessionTracer.swift": "0cdf08f92d6111c0dc2883b87837b81f69b5c2f9a8e5501780a114c23a741af7",
-    "swift/logbrew-swift/Sources/LogBrew/Validation.swift": "5551ee5237cbdf1c9ed4ee93025f95313e4dd84f31ce7cb774d1dc01175213c7",
+    "swift/logbrew-swift/Sources/LogBrew/Validation.swift": "07ff5c2daeb829b1df4f50edb0b79727f9a81b1c9b5cde5f995f5ad6ce660aa7",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashEngine.swift": "7a46035fcaa72dd7504b4e274a92070d73dd1c45fe20e008474340d6d7c44ede",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashReportSanitizer.swift": "a872ad63532999e74af1e9685a9382d0e02b93c6f9b942b371d47f56f8b961c0",
     "swift/logbrew-swift/Sources/LogBrewCrash/CrashStorageDirectory.swift": "7cd566703cbf704dc99155451ee93dcace12c35c805abc09a6dcf23975cf43f9",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeArtifactIdentity.swift": "3d785ad717dcf7302451531c18b5e1183983270a6cd78dd543a407e3facc6ae0",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashCapture.swift": "e9ab5f1850a096f40592a025d16c5ffa2fdff0222004a37056898cf1cb4b0dd9",
-    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "ee209aa25b1c6bcadf84604f145fc55c251c8697e745c87283703dbdd5bbf5ba",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashExceptionEvidence.swift": "08819652ce0796bee9f502de1202d236887afbcb7794d4db9adc5b6c2928ca2c",
+    "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashPublic.swift": "fe0db58c4ad348a2601d984cdf097147f0b2093baad64861aef48cc052697d9c",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeCrashReplay.swift": "3eb3d93b32cf14de416f56fa30d6d65e6f268b5ec9d1a67081d7525c4efd4f80",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeHangIncidentStore.swift": "02413ca7e003917faadcc9aa612b5d98897c75b39f67c3c845948dd9349a9d8f",
     "swift/logbrew-swift/Sources/LogBrewCrash/NativeHangWatchdog.swift": "37b25904cd6576e20c40500be2c153156403b57ad7b4186a1b6b35b414145ecb",

package/metadata.cjs

@@ -68,6 +68,22 @@ function sanitizeReactNativeIssueStackFrames(stackFrames) {
   }));
 }
 
+function sanitizeReactNativeIssueExceptionChain(exceptionChain) {
+  if (!exceptionChain || !Array.isArray(exceptionChain.entries)) {
+    return undefined;
+  }
+  return {
+    ...exceptionChain,
+    entries: exceptionChain.entries.map((entry) => {
+      const stackFrames = sanitizeReactNativeIssueStackFrames(entry.stackFrames);
+      return {
+        ...entry,
+        ...(stackFrames ? { stackFrames } : {})
+      };
+    })
+  };
+}
+
 function runtimeReactNativeDebugIdMap() {
   try {
     const registry = globalThis?.[REACT_NATIVE_DEBUG_ID_REGISTRY];
@@ -170,6 +186,7 @@ module.exports = {
   createSafeReactNativeMetadata,
   runtimeReactNativeDebugIdMap,
   safeReactNativeMetadataFactoryResult,
+  sanitizeReactNativeIssueExceptionChain,
   sanitizeReactNativeIssueMetadata,
   sanitizeReactNativeIssueStackFrames
 };

package/metadata.js

@@ -66,6 +66,22 @@ export function sanitizeReactNativeIssueStackFrames(stackFrames) {
   }));
 }
 
+export function sanitizeReactNativeIssueExceptionChain(exceptionChain) {
+  if (!exceptionChain || !Array.isArray(exceptionChain.entries)) {
+    return undefined;
+  }
+  return {
+    ...exceptionChain,
+    entries: exceptionChain.entries.map((entry) => {
+      const stackFrames = sanitizeReactNativeIssueStackFrames(entry.stackFrames);
+      return {
+        ...entry,
+        ...(stackFrames ? { stackFrames } : {})
+      };
+    })
+  };
+}
+
 export function runtimeReactNativeDebugIdMap() {
   try {
     const registry = globalThis?.[REACT_NATIVE_DEBUG_ID_REGISTRY];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logbrew/react-native",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "React Native offline delivery, Apple native diagnostics, screen, error, trace, action, and network timeline helpers for LogBrew.",
   "type": "module",
   "main": "./index.cjs",