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

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

@@ -0,0 +1,212 @@
+import Foundation
+
+public struct CrumbConfiguration: Equatable, Sendable {
+    public let projectKey: String
+    public let environment: String
+    public let release: CrumbRelease
+    public let invocation: Set<CrumbInvocation>
+    public let capture: CrumbCaptureOptions
+    public let diagnostics: CrumbDiagnosticsOptions
+    public let privacy: CrumbPrivacyOptions
+    public let upload: CrumbUploadOptions
+    public let reporter: CrumbReporterOptions
+    public let evidence: Set<CrumbEvidenceCategory>
+    public let application: CrumbApplicationMetadata
+    public let customContext: CrumbCustomContextOptions
+    public let workspacePolicy: CrumbWorkspacePolicyOptions
+
+    public init(
+        projectKey: String,
+        environment: String,
+        release: CrumbRelease,
+        invocation: Set<CrumbInvocation> = [.shake, .programmatic],
+        capture: CrumbCaptureOptions = .init(),
+        diagnostics: CrumbDiagnosticsOptions = .init(),
+        privacy: CrumbPrivacyOptions = .init(),
+        upload: CrumbUploadOptions = .init(),
+        reporter: CrumbReporterOptions = .init(),
+        evidence: Set<CrumbEvidenceCategory> = Set(CrumbEvidenceCategory.allCases),
+        application: CrumbApplicationMetadata = .init(),
+        customContext: CrumbCustomContextOptions = .init(),
+        workspacePolicy: CrumbWorkspacePolicyOptions = .init()
+    ) {
+        self.projectKey = projectKey
+        self.environment = environment
+        self.release = release
+        self.invocation = invocation
+        self.capture = capture
+        self.diagnostics = diagnostics
+        self.privacy = privacy
+        self.upload = upload
+        self.reporter = reporter
+        self.evidence = evidence
+        self.application = application
+        self.customContext = customContext
+        self.workspacePolicy = workspacePolicy
+    }
+}
+
+public struct CrumbUploadOptions: Equatable, Sendable {
+    /// Base URL for the Crumb ingestion service. A nil URL keeps upload disabled.
+    public let ingestionURL: URL?
+
+    public init(ingestionURL: URL? = nil) {
+        self.ingestionURL = ingestionURL
+    }
+}
+
+public struct CrumbRelease: Equatable, Sendable {
+    public let appVersion: String
+    public let nativeBuild: String
+    public let bundleVersion: String?
+
+    public init(
+        appVersion: String,
+        nativeBuild: String,
+        bundleVersion: String? = nil
+    ) {
+        self.appVersion = appVersion
+        self.nativeBuild = nativeBuild
+        self.bundleVersion = bundleVersion
+    }
+}
+
+public enum CrumbInvocation: String, Hashable, Sendable {
+    case shake
+    case programmatic
+}
+
+public struct CrumbCaptureOptions: Equatable, Sendable {
+    public let screenshot: Bool
+    public let maximumScreenshotDimension: Int
+    public let maximumScreenshotBytes: Int
+
+    public init(
+        screenshot: Bool = true,
+        maximumScreenshotDimension: Int = 2_048,
+        maximumScreenshotBytes: Int = 5_242_880
+    ) {
+        self.screenshot = screenshot
+        self.maximumScreenshotDimension = maximumScreenshotDimension
+        self.maximumScreenshotBytes = maximumScreenshotBytes
+    }
+}
+
+public struct CrumbDiagnosticsOptions: Equatable, Sendable {
+    /// Optional public Crumb `/health` URL. A nil URL disables API probing.
+    public let healthCheckURL: URL?
+    public let timeout: TimeInterval
+    public let logs: CrumbLogOptions
+    public let renderingEnabled: Bool
+    package let javascriptCrashCaptureEnabled: Bool
+
+    public init(
+        healthCheckURL: URL? = nil,
+        timeout: TimeInterval = 2,
+        logs: CrumbLogOptions = .init(),
+        javascriptCrashCaptureEnabled: Bool = false,
+        renderingEnabled: Bool = false
+    ) {
+        self.healthCheckURL = healthCheckURL
+        self.timeout = timeout
+        self.logs = logs
+        self.javascriptCrashCaptureEnabled = javascriptCrashCaptureEnabled
+        self.renderingEnabled = renderingEnabled
+    }
+}
+
+public struct CrumbPrivacyOptions: Equatable, Sendable {
+    public let maskAllTextInputs: Bool
+    public let maskScreenshotsBeforeUpload: Bool
+
+    public init(
+        maskAllTextInputs: Bool = true,
+        maskScreenshotsBeforeUpload: Bool = true
+    ) {
+        self.maskAllTextInputs = maskAllTextInputs
+        self.maskScreenshotsBeforeUpload = maskScreenshotsBeforeUpload
+    }
+}
+
+/// Controls the reporter's appearance without allowing host applications to
+/// replace Crumb's layout, copy, or branding.
+public enum CrumbTheme: String, CaseIterable, Codable, Sendable {
+    case system
+    case light
+    case dark
+}
+
+/// The small set of fields rendered by the built-in reporter.
+public enum CrumbReporterField: String, CaseIterable, Hashable, Codable, Sendable {
+    case category
+    case description
+}
+
+/// Optional report-time evidence that can be disabled by the host or made
+/// stricter by a workspace policy. Release and runtime identity remain part of
+/// the required report envelope.
+public enum CrumbEvidenceCategory: String, CaseIterable, Hashable, Codable, Sendable {
+    case screenshot
+    case performance
+    case network
+    case logs
+    case threadStacks = "thread_stacks"
+    case healthCheck = "health_check"
+    case customContext = "custom_context"
+}
+
+public struct CrumbReporterOptions: Equatable, Sendable {
+    public let theme: CrumbTheme
+    public let visibleFields: Set<CrumbReporterField>
+
+    public init(
+        theme: CrumbTheme = .system,
+        visibleFields: Set<CrumbReporterField> = [.category, .description]
+    ) {
+        self.theme = theme
+        self.visibleFields = visibleFields
+    }
+}
+
+/// Application identity is separate from release identity so an integrator
+/// can provide a stable public name while keeping version/build fields in
+/// `CrumbRelease`.
+public struct CrumbApplicationMetadata: Equatable, Sendable {
+    public let name: String?
+
+    public init(name: String? = nil) {
+        self.name = name
+    }
+}
+
+/// Custom context is deliberately a string-only, explicitly allowlisted map.
+/// Values are bounded and sanitized again by the effective-policy evaluator
+/// before a report envelope is built.
+public struct CrumbCustomContextOptions: Equatable, Sendable {
+    public let values: [String: String]
+    public let allowedKeys: Set<String>
+
+    public init(
+        values: [String: String] = [:],
+        allowedKeys: Set<String> = []
+    ) {
+        self.values = values
+        self.allowedKeys = allowedKeys
+    }
+}
+
+/// Enables the optional workspace policy fetch. Omitting the URL preserves
+/// the current local-only behavior; when configured, optional evidence stays
+/// disabled until a valid policy is fetched or loaded from a still-valid cache.
+public struct CrumbWorkspacePolicyOptions: Equatable, Sendable {
+    public let url: URL?
+    public let timeout: TimeInterval
+
+    public init(
+        url: URL? = nil,
+        timeout: TimeInterval = 2
+    ) {
+        self.url = url
+        self.timeout = timeout
+    }
+}

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

@@ -0,0 +1,158 @@
+import Foundation
+
+public struct CrumbThreadDiagnostic: Equatable, Sendable {
+    public let id: UInt64
+    public let name: String
+    public let state: String
+    public let cpuUsagePercent: Double?
+
+    public init(id: UInt64, name: String, state: String, cpuUsagePercent: Double?) {
+        self.id = id
+        self.name = name
+        self.state = state
+        self.cpuUsagePercent = cpuUsagePercent
+    }
+}
+
+public enum CrumbStackTraceCaptureStatus: String, Equatable, Sendable {
+    case captured
+    case unavailable
+}
+
+public struct CrumbThreadStackDiagnostic: Equatable, Sendable {
+    public let id: UInt64
+    public let name: String
+    public let state: String
+    public let frames: [String]
+
+    public init(id: UInt64, name: String, state: String, frames: [String]) {
+        self.id = id
+        self.name = name
+        self.state = state
+        self.frames = frames
+    }
+}
+
+public struct CrumbStackTraceDiagnostic: Equatable, Sendable {
+    public let status: CrumbStackTraceCaptureStatus
+    public let scope: String
+    public let threads: [CrumbThreadStackDiagnostic]
+    public let truncated: Bool
+    public let unavailableReason: String?
+
+    public init(
+        status: CrumbStackTraceCaptureStatus,
+        scope: String,
+        threads: [CrumbThreadStackDiagnostic],
+        truncated: Bool,
+        unavailableReason: String?
+    ) {
+        self.status = status
+        self.scope = scope
+        self.threads = threads
+        self.truncated = truncated
+        self.unavailableReason = unavailableReason
+    }
+}
+
+public struct CrumbHealthCheckDiagnostic: Equatable, Sendable {
+    public let host: String
+    public let succeeded: Bool
+    public let statusCode: Int?
+    public let latencyMilliseconds: Int
+    public let failure: String?
+
+    public init(
+        host: String,
+        succeeded: Bool,
+        statusCode: Int?,
+        latencyMilliseconds: Int,
+        failure: String?
+    ) {
+        self.host = host
+        self.succeeded = succeeded
+        self.statusCode = statusCode
+        self.latencyMilliseconds = latencyMilliseconds
+        self.failure = failure
+    }
+}
+
+public struct CrumbNetworkDiagnostic: Equatable, Sendable {
+    public let status: String
+    public let transport: String
+    public let cellularGeneration: String?
+    public let isExpensive: Bool
+    public let isConstrained: Bool
+    public let healthCheck: CrumbHealthCheckDiagnostic?
+
+    public init(
+        status: String,
+        transport: String,
+        cellularGeneration: String?,
+        isExpensive: Bool,
+        isConstrained: Bool,
+        healthCheck: CrumbHealthCheckDiagnostic?
+    ) {
+        self.status = status
+        self.transport = transport
+        self.cellularGeneration = cellularGeneration
+        self.isExpensive = isExpensive
+        self.isConstrained = isConstrained
+        self.healthCheck = healthCheck
+    }
+}
+
+public struct CrumbDiagnosticsSnapshot: Equatable, Sendable {
+    public let capturedAt: Date
+    public let location: String
+    public let processName: String
+    public let processID: Int32
+    public let cpuUsagePercent: Double?
+    public let residentMemoryBytes: UInt64?
+    public let physicalFootprintBytes: UInt64?
+    public let thermalState: String
+    public let threadCount: Int
+    public let busiestThreads: [CrumbThreadDiagnostic]
+    public let screenContext: CrumbScreenContext?
+    public let rendering: CrumbRenderingSnapshot?
+    public let gpuStatus: String
+    public let network: CrumbNetworkDiagnostic
+    public let logs: CrumbLogDiagnostic
+    public let stackTraces: CrumbStackTraceDiagnostic
+
+    public init(
+        capturedAt: Date,
+        location: String,
+        processName: String,
+        processID: Int32,
+        cpuUsagePercent: Double?,
+        residentMemoryBytes: UInt64?,
+        physicalFootprintBytes: UInt64?,
+        thermalState: String,
+        threadCount: Int,
+        busiestThreads: [CrumbThreadDiagnostic],
+        gpuStatus: String,
+        network: CrumbNetworkDiagnostic,
+        logs: CrumbLogDiagnostic,
+        stackTraces: CrumbStackTraceDiagnostic,
+        rendering: CrumbRenderingSnapshot? = nil,
+        screenContext: CrumbScreenContext? = nil
+    ) {
+        self.capturedAt = capturedAt
+        self.location = location
+        self.processName = processName
+        self.processID = processID
+        self.cpuUsagePercent = cpuUsagePercent
+        self.residentMemoryBytes = residentMemoryBytes
+        self.physicalFootprintBytes = physicalFootprintBytes
+        self.thermalState = thermalState
+        self.threadCount = threadCount
+        self.busiestThreads = busiestThreads
+        self.gpuStatus = gpuStatus
+        self.network = network
+        self.logs = logs
+        self.stackTraces = stackTraces
+        self.rendering = rendering
+        self.screenContext = screenContext
+    }
+}

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

@@ -0,0 +1,94 @@
+import Foundation
+import CrashReporter
+#if canImport(Darwin)
+import Darwin
+#endif
+
+/// Local-only, independently discardable evidence. IDs are snapshot indexes, not Mach IDs.
+package struct CrumbFailureStacks: Codable, Equatable, Sendable {
+    package struct Thread: Codable, Equatable, Sendable {
+        let index: UInt64
+        let name: String
+        let state: String
+        let frames: [String]
+    }
+    package let threads: [Thread]
+    package let truncated: Bool
+    package static let maximumBytes = 12_288
+    private static let captureLock = NSLock()
+
+    package func validated() -> Self? {
+        guard threads.count <= 32, threads.allSatisfy({ thread in
+            thread.name.utf8.count <= 128 && thread.state.utf8.count <= 64 &&
+            thread.frames.count <= 16 && thread.frames.allSatisfy { $0.utf8.count <= 512 }
+        }), let data = try? JSONEncoder().encode(self), data.count <= Self.maximumBytes else { return nil }
+        return self
+    }
+
+    package var diagnostic: CrumbStackTraceDiagnostic {
+        CrumbStackTraceDiagnostic(status: threads.isEmpty ? .unavailable : .captured,
+            scope: "native_threads", threads: threads.map {
+                CrumbThreadStackDiagnostic(id: $0.index, name: CrumbLogSanitizer.sanitize($0.name),
+                    state: $0.state, frames: $0.frames.map(CrumbLogSanitizer.sanitize))
+            }, truncated: truncated, unavailableReason: threads.isEmpty ? "native_stack_capture_empty" : nil)
+    }
+
+    /// Called only during an opted-in JS handoff, never from a native signal handler.
+    /// Live reports temporarily suspend threads. PLCrashReporter resumes them before returning;
+    /// no crash handler is enabled and symbol lookup happens only after that return.
+    package static func capture() -> Self? {
+        guard captureLock.try() else { return nil }
+        defer { captureLock.unlock() }
+        let config = PLCrashReporterConfig(signalHandlerType: .BSD, symbolicationStrategy: [],
+            shouldRegisterUncaughtExceptionHandler: false, basePath: NSTemporaryDirectory(), maxReportBytes: 1_048_576)
+        guard let reporter = PLCrashReporter(configuration: config),
+              let data = reporter.generateLiveReport(), data.count <= 1_048_576,
+              let report = try? PLCrashReport(data: data),
+              let captured = report.threads as? [PLCrashReportThreadInfo] else { return nil }
+        let sorted = captured.sorted {
+            if $0.crashed != $1.crashed { return $0.crashed }
+            return $0.threadNumber < $1.threadNumber
+        }
+        var threads: [Thread] = []
+        var truncated = captured.count > 32
+        for thread in sorted.prefix(32) {
+            guard thread.threadNumber >= 0,
+                  let frames = thread.stackFrames as? [PLCrashReportStackFrameInfo] else { truncated = true; continue }
+            if frames.count > 16 { truncated = true }
+            let rawFrames = frames.prefix(16).map { frame in format(frame, report: report) }
+            if rawFrames.contains(where: { $0.utf8.count > 512 }) { truncated = true }
+            let formatted = rawFrames.map { value in
+                value.utf8.count <= 512 ? value : String(decoding: value.utf8.prefix(508), as: UTF8.self)
+            }
+            guard !formatted.isEmpty else { continue }
+            threads.append(Thread(index: UInt64(thread.threadNumber), name: "Thread \(thread.threadNumber)",
+                state: thread.crashed ? "capture_thread" : "unknown", frames: formatted))
+            while let encoded = try? JSONEncoder().encode(Self(threads: threads, truncated: true)), encoded.count > maximumBytes {
+                truncated = true
+                guard let last = threads.popLast() else { break }
+                guard last.frames.count > 1 else { break }
+                threads.append(Thread(index: last.index, name: last.name, state: last.state, frames: Array(last.frames.dropLast())))
+            }
+            if truncated && threads.last?.index != UInt64(thread.threadNumber) { break }
+        }
+        return Self(threads: threads, truncated: truncated).validated()
+    }
+
+    private static func format(_ frame: PLCrashReportStackFrameInfo, report: PLCrashReport) -> String {
+        let address = frame.instructionPointer
+        guard let image = report.image(forAddress: address), address >= image.imageBaseAddress else {
+            return "unknown image · 0x\(String(address, radix: 16))"
+        }
+        let module = URL(fileURLWithPath: image.imageName).lastPathComponent
+        let uuid = image.hasImageUUID ? image.imageUUID ?? "unknown" : "unknown"
+        var value = "\(module) + 0x\(String(address - image.imageBaseAddress, radix: 16)) [\(uuid)]"
+        #if canImport(Darwin)
+        var info = Dl_info()
+        if let pointer = UnsafeRawPointer(bitPattern: UInt(address)), dladdr(pointer, &info) != 0,
+           let symbol = info.dli_sname, let start = info.dli_saddr, address >= UInt64(UInt(bitPattern: start)) {
+            value += " · \(String(cString: symbol)) + \(address - UInt64(UInt(bitPattern: start)))"
+        }
+        #endif
+        return CrumbLogSanitizer.sanitize(value)
+    }
+}

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

@@ -0,0 +1,110 @@
+import Foundation
+
+package struct CrumbHealthHeadResult: Sendable {
+    package let statusCode: Int?
+    package let latencyMilliseconds: Int
+    package let failure: String?
+
+    package init(statusCode: Int?, latencyMilliseconds: Int, failure: String?) {
+        self.statusCode = statusCode
+        self.latencyMilliseconds = latencyMilliseconds
+        self.failure = failure
+    }
+}
+
+package enum CrumbInfrastructureHealthProbe {
+    package typealias HeadRequest = (URLRequest, TimeInterval) -> CrumbHealthHeadResult
+
+    package static func capture(
+        url: URL,
+        timeout: TimeInterval,
+        head: HeadRequest = performHead
+    ) -> CrumbHealthCheckDiagnostic {
+        var request = URLRequest(
+            url: url,
+            cachePolicy: .reloadIgnoringLocalCacheData,
+            timeoutInterval: timeout
+        )
+        request.httpMethod = "HEAD"
+        let result = head(request, timeout)
+        return CrumbHealthCheckDiagnostic(
+            host: url.host ?? "unknown",
+            succeeded: result.failure == nil &&
+                (result.statusCode.map { (200..<300).contains($0) } ?? false),
+            statusCode: result.statusCode,
+            latencyMilliseconds: min(max(result.latencyMilliseconds, 0), 30_000),
+            failure: result.failure.map { String($0.prefix(128)) }
+        )
+    }
+
+    private static func performHead(
+        request: URLRequest,
+        timeout: TimeInterval
+    ) -> CrumbHealthHeadResult {
+        let startedAt = DispatchTime.now()
+        let result = HealthProbeValue()
+        let semaphore = DispatchSemaphore(value: 0)
+        let task = URLSession.shared.dataTask(with: request) { _, response, error in
+            result.setIfEmpty(
+                CrumbHealthHeadResult(
+                    statusCode: (response as? HTTPURLResponse)?.statusCode,
+                    latencyMilliseconds: elapsedMilliseconds(since: startedAt),
+                    failure: error.map(failureName)
+                )
+            )
+            semaphore.signal()
+        }
+        task.resume()
+        if semaphore.wait(timeout: .now() + timeout) == .timedOut {
+            task.cancel()
+            return CrumbHealthHeadResult(
+                statusCode: nil,
+                latencyMilliseconds: Int(timeout * 1_000),
+                failure: "timeout"
+            )
+        }
+        return result.value ?? CrumbHealthHeadResult(
+            statusCode: nil,
+            latencyMilliseconds: elapsedMilliseconds(since: startedAt),
+            failure: "unavailable"
+        )
+    }
+}
+
+private func elapsedMilliseconds(since start: DispatchTime) -> Int {
+    let elapsed = DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds
+    return Int(elapsed / 1_000_000)
+}
+
+private func failureName(_ error: Error) -> String {
+    guard let error = error as? URLError else {
+        return String(String(describing: type(of: error)).prefix(128))
+    }
+    return switch error.code {
+    case .timedOut: "timeout"
+    case .notConnectedToInternet: "not_connected"
+    case .cannotFindHost, .dnsLookupFailed: "cannot_find_host"
+    case .cannotConnectToHost: "cannot_connect"
+    case .networkConnectionLost: "connection_lost"
+    case .secureConnectionFailed, .serverCertificateUntrusted: "tls_failed"
+    case .cancelled: "cancelled"
+    default: "transport_error"
+    }
+}
+
+private final class HealthProbeValue: @unchecked Sendable {
+    private let lock = NSLock()
+    private var storage: CrumbHealthHeadResult?
+
+    var value: CrumbHealthHeadResult? {
+        lock.lock()
+        defer { lock.unlock() }
+        return storage
+    }
+
+    func setIfEmpty(_ value: CrumbHealthHeadResult) {
+        lock.lock()
+        defer { lock.unlock() }
+        if storage == nil { storage = value }
+    }
+}