@crumbsdk/react-native 0.0.1-rc.3 → 0.0.1-rc.5

package/native/ios/packages/ios/Sources/CrumbCore/CrumbJavaScriptCrashRecovery.swift

@@ -0,0 +1,136 @@
+import Foundation
+
+package enum CrumbJavaScriptCrashRecovery {
+    package static func recover(settings: CrumbReportSettings) async -> Bool {
+        let store = CrumbJavaScriptCrashStore.shared
+        let pending = store.records()
+        guard !pending.isEmpty else { return false }
+
+        var recovered = false
+        for crash in pending {
+            let reportID = recoveryReportID(for: crash.recordID)
+            if let queued = try? await CrumbReportQueue.shared.reports(),
+               queued.contains(where: { $0.reportID == reportID }) {
+                recovered = store.remove(recordID: crash.recordID) || recovered
+                continue
+            }
+            let input = recoveryInput(crash: crash, settings: settings)
+
+            do {
+                let envelope = try CrumbReportEnvelopeBuilder.build(settings: settings, input: input)
+                _ = try await CrumbReportQueue.shared.enqueue(envelope: envelope, artifacts: [])
+                if store.remove(recordID: crash.recordID) {
+                    recovered = true
+                }
+            } catch {
+                // Queue-full, corruption, or storage errors leave the crash
+                // occurrence pending for a later launch.
+            }
+        }
+        return recovered
+    }
+
+    package static func recoveryInput(crash: CrumbJavaScriptCrash, settings: CrumbReportSettings) -> CrumbReportBuildInput {
+        let release = CrumbRelease(
+            appVersion: crash.release.appVersion ?? settings.release.appVersion,
+            nativeBuild: crash.release.nativeBuild ?? settings.release.nativeBuild,
+            bundleVersion: crash.release.bundleVersion ?? settings.release.bundleVersion
+        )
+        let reportCrash = CrumbJavaScriptCrash(
+            recordID: crash.recordID,
+            fingerprint: crash.fingerprint,
+            source: crash.source,
+            kind: crash.kind,
+            type: crash.type,
+            message: crash.message,
+            stack: crash.stack,
+            occurredAt: crash.occurredAt,
+            release: CrumbJavaScriptCrashRelease(
+                appVersion: release.appVersion,
+                nativeBuild: release.nativeBuild,
+                bundleVersion: release.bundleVersion
+            ),
+            breadcrumbs: settings.diagnostics.logs.enabled && settings.evidence.contains(.logs) ? crash.breadcrumbs : [],
+            context: settings.evidence.contains(.customContext)
+                ? crash.context.filter { settings.customContext[$0.key] != nil }
+                : [:],
+            isFatal: crash.isFatal,
+            nativeTerminationWrapperObserved: crash.nativeTerminationWrapperObserved
+        )
+        let occurredAt = crash.occurredAt
+        let description = "JavaScript \(crash.kind): \(crash.message)"
+        return CrumbReportBuildInput(
+            reportID: recoveryReportID(for: crash.recordID),
+            trigger: .programmatic,
+            triggeredAt: occurredAt,
+            submittedAt: Date(),
+            runtime: recoveryRuntime(),
+            category: "Bug",
+            description: String(description.prefix(4_000)),
+            diagnostics: crash.failureContext?.diagnostics() ?? recoveryDiagnostics(),
+            screenshotCapture: .disabledByConfiguration,
+            screenshotMasking: .notApplicable,
+            customContext: settings.customContext,
+            policyStatus: settings.policyStatus,
+            workspacePolicyVersion: settings.workspacePolicyVersion,
+            javascriptCrash: reportCrash
+        )
+    }
+
+    private static func recoveryReportID(for recordID: String) -> String {
+        "rpt_" + String(recordID.dropFirst(4))
+    }
+
+    private static func recoveryRuntime() -> CrumbReportRuntime {
+        #if os(iOS)
+        let deviceFamily = "iOS"
+        #else
+        let deviceFamily = "Apple"
+        #endif
+        return CrumbReportRuntime(
+            osVersion: ProcessInfo.processInfo.operatingSystemVersionString.prefix(64).description,
+            deviceFamily: deviceFamily,
+            locale: Locale.current.identifier.prefix(64).description,
+            timezone: TimeZone.current.identifier.prefix(128).description
+        )
+    }
+
+    private static func recoveryDiagnostics() -> CrumbDiagnosticsSnapshot {
+        CrumbDiagnosticsSnapshot(
+            capturedAt: Date(),
+            location: "react_native_recovery",
+            processName: "react-native",
+            processID: ProcessInfo.processInfo.processIdentifier,
+            cpuUsagePercent: nil,
+            residentMemoryBytes: nil,
+            physicalFootprintBytes: nil,
+            thermalState: "unavailable",
+            threadCount: 0,
+            busiestThreads: [],
+            gpuStatus: "unavailable",
+            network: CrumbNetworkDiagnostic(
+                status: "unknown",
+                transport: "unknown",
+                cellularGeneration: nil,
+                isExpensive: false,
+                isConstrained: false,
+                healthCheck: nil
+            ),
+            logs: CrumbLogDiagnostic(
+                status: .unavailable,
+                sources: [],
+                entries: [],
+                truncated: false,
+                droppedEntryCount: 0,
+                failures: []
+            ),
+            stackTraces: CrumbStackTraceDiagnostic(
+                status: .unavailable,
+                scope: "none",
+                threads: [],
+                truncated: false,
+                unavailableReason: "unavailable_during_recovery"
+            )
+        )
+    }
+}

package/native/ios/packages/ios/Sources/CrumbCore/CrumbJavaScriptCrashStore.swift

@@ -0,0 +1,508 @@
+import Foundation
+
+package struct CrumbJavaScriptCrashRelease: Codable, Equatable, Sendable {
+    package let appVersion: String?
+    package let nativeBuild: String?
+    package let bundleVersion: String?
+}
+
+package struct CrumbJavaScriptBreadcrumb: Codable, Equatable, Sendable {
+    package let timestamp: Date
+    package let source: String
+    package let category: String
+    package let message: String
+}
+
+package struct CrumbJavaScriptCrash: Equatable, Sendable {
+    package let recordID: String
+    package let fingerprint: String
+    package let source: String
+    package let kind: String
+    package let type: String
+    package let message: String
+    package let stack: String?
+    package let occurredAt: Date
+    package var release: CrumbJavaScriptCrashRelease
+    package var breadcrumbs: [CrumbJavaScriptBreadcrumb]
+    package let context: [String: String]
+    package let isFatal: Bool
+    package let nativeTerminationWrapperObserved: Bool
+    package var failureContext: CrumbJavaScriptFailureContext? = nil
+}
+
+package struct CrumbJavaScriptCrashStoreLimits: Equatable, Sendable {
+    package let maximumRecords: Int
+    package let maximumTotalBytes: Int
+    package let maximumRecordBytes: Int
+    package let maximumBreadcrumbs: Int
+    package let maximumBreadcrumbBytes: Int
+
+    package init(
+        maximumRecords: Int = 50,
+        maximumTotalBytes: Int = 2_097_152,
+        maximumRecordBytes: Int = 32_768,
+        maximumBreadcrumbs: Int = 32,
+        maximumBreadcrumbBytes: Int = 16_384
+    ) {
+        self.maximumRecords = maximumRecords
+        self.maximumTotalBytes = maximumTotalBytes
+        self.maximumRecordBytes = maximumRecordBytes
+        self.maximumBreadcrumbs = maximumBreadcrumbs
+        self.maximumBreadcrumbBytes = maximumBreadcrumbBytes
+    }
+}
+
+/// A tiny synchronous store used by the React Native adapter's JavaScript
+/// exception handoff. It deliberately has no uncaught native exception hook.
+package final class CrumbJavaScriptCrashStore: @unchecked Sendable {
+    package static let shared = CrumbJavaScriptCrashStore(rootURL: defaultRootURL())
+
+    private let rootURL: URL
+    private let limits: CrumbJavaScriptCrashStoreLimits
+    private let fileManager: FileManager
+    private let encoder: JSONEncoder
+    private let decoder: JSONDecoder
+    private let lock = NSLock()
+
+    package init(
+        rootURL: URL,
+        limits: CrumbJavaScriptCrashStoreLimits = .init(),
+        fileManager: FileManager = .default
+    ) {
+        self.rootURL = rootURL
+        self.limits = limits
+        self.fileManager = fileManager
+        encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = [.sortedKeys]
+        decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+    }
+
+    @discardableResult
+    package func record(_ recordJSON: String, failureContext: CrumbJavaScriptFailureContext? = nil, includeBreadcrumbs: Bool = true, release: CrumbRelease? = nil) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard validLimits(),
+              let data = recordJSON.data(using: .utf8),
+              data.count <= limits.maximumRecordBytes,
+              let raw = try? decoder.decode(RawRecord.self, from: data),
+              var record = normalize(raw) else {
+            return false
+        }
+
+        // The JS payload cannot supply native context. Only the trusted capture argument can.
+        record.failureContext = failureContext?.validated()
+        // Freeze native defaults at failure time, before a later app update can change them.
+        record.release = CrumbJavaScriptCrashRelease(
+            appVersion: record.release.appVersion ?? release?.appVersion,
+            nativeBuild: record.release.nativeBuild ?? release?.nativeBuild,
+            bundleVersion: record.release.bundleVersion ?? release?.bundleVersion
+        )
+        if !includeBreadcrumbs { record.breadcrumbs = [] }
+
+        do {
+            try prepareRoot()
+            let existing = try readAllLocked()
+            if let match = existing.first(where: { $0.record.fingerprint == record.fingerprint }) {
+                let merged = merge(match.record, record)
+                let otherBytes = existing.reduce(0) { total, item in
+                    total + (item.url == match.url ? 0 : (try? item.url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+                }
+                guard let mergedData = try encoded(merged, fitting: limits.maximumTotalBytes - otherBytes) else { return false }
+                try write(mergedData, to: match.url)
+                return true
+            }
+
+            let total = existing.reduce(0) { total, item in
+                total + ((try? item.url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+            }
+            guard existing.count < limits.maximumRecords,
+                  let encoded = try encoded(record, fitting: limits.maximumTotalBytes - total) else {
+                return false
+            }
+            try write(encoded, to: url(for: record.recordID))
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    package func records() -> [CrumbJavaScriptCrash] {
+        lock.lock()
+        defer { lock.unlock() }
+        guard validLimits(), (try? prepareRoot()) != nil,
+              let entries = try? readAllLocked() else {
+            return []
+        }
+
+        var byFingerprint: [String: (url: URL, record: CrumbJavaScriptCrash)] = [:]
+        for entry in entries {
+            if let prior = byFingerprint[entry.record.fingerprint] {
+                let merged = merge(prior.record, entry.record)
+                byFingerprint[entry.record.fingerprint] = (prior.url, merged)
+                if let data = try? encoded(merged) {
+                    try? write(data, to: prior.url)
+                    try? fileManager.removeItem(at: entry.url)
+                }
+            } else {
+                byFingerprint[entry.record.fingerprint] = entry
+            }
+        }
+        return byFingerprint.values
+            .map(\.record)
+            .sorted { $0.occurredAt < $1.occurredAt }
+    }
+
+    @discardableResult
+    package func remove(recordID: String) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        guard validRecordID(recordID) else { return false }
+        do {
+            try prepareRoot()
+            let target = url(for: recordID)
+            guard fileManager.fileExists(atPath: target.path) else { return false }
+            try fileManager.removeItem(at: target)
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    private func normalize(_ raw: RawRecord) -> CrumbJavaScriptCrash? {
+        guard raw.schemaVersion == "1.0",
+              validRecordID(raw.recordID),
+              raw.fingerprint.range(of: "^[A-Fa-f0-9]{16}$", options: .regularExpression) != nil,
+              ["javascript", "native_termination_wrapper"].contains(raw.source),
+              ["exception", "unhandled_rejection", "native_termination_wrapper"].contains(raw.kind),
+              let occurredAt = parseDate(raw.occurredAt) else {
+            return nil
+        }
+
+        let type = bounded(CrumbLogSanitizer.sanitize(raw.type).trimmingCharacters(in: .whitespacesAndNewlines), maximumBytes: 128)
+        let message = bounded(CrumbLogSanitizer.sanitize(raw.message).trimmingCharacters(in: .whitespacesAndNewlines), maximumBytes: 4_000)
+        guard !type.isEmpty, !message.isEmpty else { return nil }
+
+        let stack = raw.stack.map {
+            bounded(
+                CrumbLogSanitizer.sanitize($0.replacingOccurrences(of: "\n", with: "\u{e000}"))
+                    .replacingOccurrences(of: "\u{e000}", with: "\n")
+                    .trimmingCharacters(in: .whitespacesAndNewlines),
+                maximumBytes: 16_384
+            )
+        }.flatMap { $0.isEmpty ? nil : $0 }
+
+        let breadcrumbs = boundedBreadcrumbs(raw.breadcrumbs)
+        let context = CrumbCustomContextSanitizer.sanitize(
+            CrumbCustomContextOptions(
+                values: raw.context,
+                allowedKeys: Set(raw.context.keys)
+            )
+        )
+        return CrumbJavaScriptCrash(
+            recordID: raw.recordID,
+            fingerprint: raw.fingerprint.lowercased(),
+            source: raw.source,
+            kind: raw.kind,
+            type: type,
+            message: message,
+            stack: stack,
+            occurredAt: occurredAt,
+            release: CrumbJavaScriptCrashRelease(
+                appVersion: raw.release?.appVersion.map { bounded($0, maximumBytes: 64) },
+                nativeBuild: raw.release?.nativeBuild.map { bounded($0, maximumBytes: 64) },
+                bundleVersion: raw.release?.bundleVersion.map { bounded($0, maximumBytes: 128) }
+            ),
+            breadcrumbs: breadcrumbs,
+            context: context,
+            isFatal: raw.isFatal || raw.source == "native_termination_wrapper",
+            nativeTerminationWrapperObserved: raw.nativeTerminationWrapperObserved
+                || raw.source == "native_termination_wrapper",
+            failureContext: raw.failureContext?.validated()
+        )
+    }
+
+    private func boundedBreadcrumbs(_ values: [RawBreadcrumb]) -> [CrumbJavaScriptBreadcrumb] {
+        var result: [CrumbJavaScriptBreadcrumb] = []
+        var bytes = 0
+        for raw in values.suffix(limits.maximumBreadcrumbs) {
+            guard let date = parseDate(raw.timestamp) else { continue }
+            let breadcrumb = CrumbJavaScriptBreadcrumb(
+                timestamp: date,
+                source: bounded(CrumbLogSanitizer.sanitize(raw.source), maximumBytes: 64),
+                category: bounded(CrumbLogSanitizer.sanitize(raw.category), maximumBytes: 256),
+                message: bounded(CrumbLogSanitizer.sanitize(raw.message), maximumBytes: 2_048)
+            )
+            guard !breadcrumb.source.isEmpty, !breadcrumb.category.isEmpty,
+                  !breadcrumb.message.isEmpty,
+                  let encoded = try? encoder.encode(breadcrumb),
+                  bytes + encoded.count <= limits.maximumBreadcrumbBytes else {
+                continue
+            }
+            result.append(breadcrumb)
+            bytes += encoded.count
+        }
+        return result
+    }
+
+    private func merge(
+        _ existing: CrumbJavaScriptCrash,
+        _ incoming: CrumbJavaScriptCrash
+    ) -> CrumbJavaScriptCrash {
+        let preferred = incoming.source == "javascript" && existing.source != "javascript"
+            ? incoming
+            : existing
+        let fallback = preferred.recordID == incoming.recordID ? existing : incoming
+        return CrumbJavaScriptCrash(
+            recordID: preferred.recordID,
+            fingerprint: preferred.fingerprint,
+            source: preferred.source,
+            kind: preferred.kind,
+            type: preferred.type,
+            message: preferred.message,
+            stack: preferred.stack ?? fallback.stack,
+            occurredAt: min(existing.occurredAt, incoming.occurredAt),
+            release: CrumbJavaScriptCrashRelease(
+                appVersion: preferred.release.appVersion ?? fallback.release.appVersion,
+                nativeBuild: preferred.release.nativeBuild ?? fallback.release.nativeBuild,
+                bundleVersion: preferred.release.bundleVersion ?? fallback.release.bundleVersion
+            ),
+            breadcrumbs: preferred.breadcrumbs.isEmpty ? fallback.breadcrumbs : preferred.breadcrumbs,
+            context: preferred.context.isEmpty ? fallback.context : preferred.context,
+            isFatal: existing.isFatal || incoming.isFatal,
+            nativeTerminationWrapperObserved: existing.nativeTerminationWrapperObserved
+                || incoming.nativeTerminationWrapperObserved,
+            failureContext: preferred.failureContext
+        )
+    }
+
+    private func readAllLocked() throws -> [(url: URL, record: CrumbJavaScriptCrash)] {
+        let urls = try fileManager.contentsOfDirectory(
+            at: rootURL,
+            includingPropertiesForKeys: [.isRegularFileKey, .fileSizeKey],
+            options: [.skipsHiddenFiles]
+        )
+        return urls.compactMap { url in
+            guard url.pathExtension == "json",
+                  (try? url.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true else {
+                return nil
+            }
+            do {
+                let data = try Data(contentsOf: url, options: [.mappedIfSafe])
+                guard data.count <= limits.maximumRecordBytes else { throw StoreError.corrupt }
+                let raw = try decoder.decode(RawRecord.self, from: data)
+                guard let record = normalize(raw) else { throw StoreError.corrupt }
+                return (url, record)
+            } catch {
+                try? fileManager.removeItem(at: url)
+                return nil
+            }
+        }
+    }
+
+    private func encoded(_ record: CrumbJavaScriptCrash) throws -> Data {
+        try encoder.encode(RawRecord(record))
+    }
+
+    private func encoded(_ record: CrumbJavaScriptCrash, fitting remainingBytes: Int) throws -> Data? {
+        let budget = min(limits.maximumRecordBytes, remainingBytes)
+        let full = try encoded(record)
+        if full.count <= budget { return full }
+        var core = record
+        core.failureContext?.stacks = nil
+        let metrics = try encoded(core)
+        if metrics.count <= budget { return metrics }
+        core.failureContext?.rendering = nil
+        let withoutRendering = try encoded(core)
+        if withoutRendering.count <= budget { return withoutRendering }
+        core.failureContext?.screenContext = nil
+        let withoutScreen = try encoded(core)
+        if withoutScreen.count <= budget { return withoutScreen }
+        core.failureContext = nil
+        let fallback = try encoded(core)
+        return fallback.count <= budget ? fallback : nil
+    }
+
+    private func prepareRoot() throws {
+        try fileManager.createDirectory(at: rootURL, withIntermediateDirectories: true)
+        let temporaryFiles = try? fileManager.contentsOfDirectory(
+            at: rootURL,
+            includingPropertiesForKeys: nil,
+            options: []
+        ).filter { $0.lastPathComponent.hasPrefix(".tmp-") }
+        temporaryFiles?.forEach { try? fileManager.removeItem(at: $0) }
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        var mutableRoot = rootURL
+        try? mutableRoot.setResourceValues(values)
+    }
+
+    private func write(_ data: Data, to url: URL) throws {
+        try data.write(to: url, options: [.atomic])
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        var mutableURL = url
+        try? mutableURL.setResourceValues(values)
+        #if os(iOS) || os(tvOS) || os(watchOS) || os(visionOS)
+        try? fileManager.setAttributes(
+            [.protectionKey: FileProtectionType.completeUntilFirstUserAuthentication],
+            ofItemAtPath: url.path
+        )
+        #endif
+    }
+
+    private func url(for recordID: String) -> URL {
+        rootURL.appendingPathComponent("\(recordID).json")
+    }
+
+    private func validLimits() -> Bool {
+        limits.maximumRecords > 0
+            && limits.maximumTotalBytes > 0
+            && limits.maximumRecordBytes > 0
+            && limits.maximumRecordBytes <= limits.maximumTotalBytes
+            && limits.maximumBreadcrumbs >= 0
+            && limits.maximumBreadcrumbBytes > 0
+    }
+
+    private func validRecordID(_ value: String) -> Bool {
+        value.range(of: "^jsc_[A-Za-z0-9_-]{16,80}$", options: .regularExpression) != nil
+    }
+
+    private func parseDate(_ value: String) -> Date? {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: value) { return date }
+        formatter.formatOptions = [.withInternetDateTime]
+        return formatter.date(from: value)
+    }
+
+    private func bounded(_ value: String, maximumBytes: Int) -> String {
+        guard value.utf8.count > maximumBytes else { return value }
+        var result = ""
+        for character in value {
+            let candidate = result + String(character)
+            guard candidate.utf8.count <= max(0, maximumBytes - 3) else { break }
+            result = candidate
+        }
+        return result + "…"
+    }
+
+    private static func defaultRootURL() -> URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        return base
+            .appendingPathComponent("dev.crumb", isDirectory: true)
+            .appendingPathComponent("javascript-crashes", isDirectory: true)
+    }
+
+    private enum StoreError: Error { case corrupt }
+
+    private struct RawRecord: Codable {
+        let schemaVersion: String
+        let recordID: String
+        let fingerprint: String
+        let source: String
+        let kind: String
+        let type: String
+        let message: String
+        let stack: String?
+        let occurredAt: String
+        let release: RawRelease?
+        let breadcrumbs: [RawBreadcrumb]
+        let context: [String: String]
+        let isFatal: Bool
+        let nativeTerminationWrapperObserved: Bool
+        let failureContext: CrumbJavaScriptFailureContext?
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            failureContext = try? container.decodeIfPresent(CrumbJavaScriptFailureContext.self, forKey: .failureContext)
+            schemaVersion = try container.decode(String.self, forKey: .schemaVersion)
+            recordID = try container.decode(String.self, forKey: .recordID)
+            fingerprint = try container.decode(String.self, forKey: .fingerprint)
+            source = try container.decode(String.self, forKey: .source)
+            kind = try container.decode(String.self, forKey: .kind)
+            type = try container.decode(String.self, forKey: .type)
+            message = try container.decode(String.self, forKey: .message)
+            stack = try container.decodeIfPresent(String.self, forKey: .stack)
+            occurredAt = try container.decode(String.self, forKey: .occurredAt)
+            release = try container.decodeIfPresent(RawRelease.self, forKey: .release)
+            breadcrumbs = try container.decodeIfPresent([RawBreadcrumb].self, forKey: .breadcrumbs) ?? []
+            context = try container.decodeIfPresent([String: String].self, forKey: .context) ?? [:]
+            isFatal = try container.decodeIfPresent(Bool.self, forKey: .isFatal) ?? false
+            nativeTerminationWrapperObserved = try container.decodeIfPresent(
+                Bool.self,
+                forKey: .nativeTerminationWrapperObserved
+            ) ?? false
+        }
+
+        init(_ record: CrumbJavaScriptCrash) {
+            failureContext = record.failureContext
+            schemaVersion = "1.0"
+            recordID = record.recordID
+            fingerprint = record.fingerprint
+            source = record.source
+            kind = record.kind
+            type = record.type
+            message = record.message
+            stack = record.stack
+            occurredAt = ISO8601DateFormatter().string(from: record.occurredAt)
+            release = RawRelease(record.release)
+            breadcrumbs = record.breadcrumbs.map(RawBreadcrumb.init)
+            context = record.context
+            isFatal = record.isFatal
+            nativeTerminationWrapperObserved = record.nativeTerminationWrapperObserved
+        }
+
+        private enum CodingKeys: String, CodingKey {
+            case failureContext = "failure_context"
+            case schemaVersion = "schema_version"
+            case recordID = "record_id"
+            case fingerprint
+            case source
+            case kind
+            case type
+            case message
+            case stack
+            case occurredAt = "occurred_at"
+            case release
+            case breadcrumbs
+            case context
+            case isFatal = "is_fatal"
+            case nativeTerminationWrapperObserved = "native_termination_wrapper_observed"
+        }
+    }
+
+    private struct RawRelease: Codable {
+        let appVersion: String?
+        let nativeBuild: String?
+        let bundleVersion: String?
+
+        init(_ release: CrumbJavaScriptCrashRelease) {
+            appVersion = release.appVersion
+            nativeBuild = release.nativeBuild
+            bundleVersion = release.bundleVersion
+        }
+
+        private enum CodingKeys: String, CodingKey {
+            case appVersion = "app_version"
+            case nativeBuild = "native_build"
+            case bundleVersion = "bundle_version"
+        }
+    }
+
+    private struct RawBreadcrumb: Codable {
+        let timestamp: String
+        let source: String
+        let category: String
+        let message: String
+
+        init(_ breadcrumb: CrumbJavaScriptBreadcrumb) {
+            timestamp = ISO8601DateFormatter().string(from: breadcrumb.timestamp)
+            source = breadcrumb.source
+            category = breadcrumb.category
+            message = breadcrumb.message
+        }
+    }
+}