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

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

@@ -0,0 +1,304 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+package struct CrumbUploadHTTPResponse: Sendable {
+    package let statusCode: Int
+    package let data: Data
+
+    package init(statusCode: Int, data: Data = Data()) {
+        self.statusCode = statusCode
+        self.data = data
+    }
+}
+
+package protocol CrumbUploadTransport: Sendable {
+    func send(_ request: URLRequest) async throws -> CrumbUploadHTTPResponse
+}
+
+package struct CrumbURLSessionUploadTransport: CrumbUploadTransport {
+    private let session: URLSession
+
+    package init(session: URLSession = .shared) {
+        self.session = session
+    }
+
+    package func send(_ request: URLRequest) async throws -> CrumbUploadHTTPResponse {
+        let (data, response) = try await session.data(for: request)
+        guard data.count <= 1_048_576,
+              let response = response as? HTTPURLResponse else {
+            throw CrumbUploadFailure(reason: "transport.invalid_response", retryable: true)
+        }
+        return CrumbUploadHTTPResponse(statusCode: response.statusCode, data: data)
+    }
+}
+
+package struct CrumbUploadPassResult: Equatable, Sendable {
+    package let uploadedReportCount: Int
+    package let remainingReportCount: Int
+    package let shouldRetry: Bool
+    package let wasCancelled: Bool
+}
+
+/// Performs one bounded upload pass. Scheduling and connectivity live in CrumbUI.
+package actor CrumbReportUploadWorker {
+    private let queue: CrumbReportQueue
+    private let settings: CrumbUploadSettings
+    private let transport: any CrumbUploadTransport
+
+    package init(
+        queue: CrumbReportQueue = .shared,
+        settings: CrumbUploadSettings,
+        transport: any CrumbUploadTransport = CrumbURLSessionUploadTransport()
+    ) {
+        self.queue = queue
+        self.settings = settings
+        self.transport = transport
+    }
+
+    package func runPass() async -> CrumbUploadPassResult {
+        var uploadedReportCount = 0
+        var shouldRetry = false
+        var wasCancelled = false
+
+        do {
+            try await queue.recoverInterruptedUploads()
+            let reports = try await queue.reports()
+            for report in reports {
+                do {
+                    try Task.checkCancellation()
+                    try await queue.markUploading(reportID: report.reportID)
+                    let payload = try await queue.load(reportID: report.reportID)
+                    try await upload(payload)
+                    try Task.checkCancellation()
+                    try await queue.remove(reportID: report.reportID)
+                    uploadedReportCount += 1
+                } catch is CancellationError {
+                    try? await queue.markPending(reportID: report.reportID)
+                    wasCancelled = true
+                    break
+                } catch let failure as CrumbUploadFailure {
+                    try? await queue.markFailed(reportID: report.reportID, reason: failure.reason)
+                    if failure.retryable {
+                        shouldRetry = true
+                        break
+                    }
+                } catch {
+                    try? await queue.markFailed(
+                        reportID: report.reportID,
+                        reason: "uploader.local_failure"
+                    )
+                }
+            }
+        } catch is CancellationError {
+            wasCancelled = true
+        } catch {
+            shouldRetry = true
+        }
+
+        let remainingReports = try? await queue.reports()
+        return CrumbUploadPassResult(
+            uploadedReportCount: uploadedReportCount,
+            remainingReportCount: remainingReports?.count ?? 1,
+            shouldRetry: shouldRetry,
+            wasCancelled: wasCancelled
+        )
+    }
+
+    private func upload(_ payload: CrumbQueuedReportPayload) async throws {
+        let reportID = payload.summary.reportID
+        let initResponse = try await sendLifecycle(
+            path: ["sdk", "v1", "reports", "init"],
+            reportID: reportID,
+            operation: "init",
+            body: wrappedEnvelope(payload.envelope)
+        )
+        let initialized = try decodeInitialization(initResponse.data, reportID: reportID)
+
+        switch initialized.status {
+        case "accepted":
+            guard initialized.artifacts.isEmpty else {
+                throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+            }
+        case "initialized":
+            try validateTargets(initialized.artifacts, payload: payload)
+            for artifact in payload.artifacts {
+                try Task.checkCancellation()
+                guard let target = initialized.artifacts.first(where: {
+                    $0.id == artifact.manifest.id
+                }) else {
+                    throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+                }
+                try await put(artifact.data, target: target)
+            }
+        default:
+            throw CrumbUploadFailure(reason: "init.terminal_state", retryable: false)
+        }
+
+        _ = try await sendLifecycle(
+            path: ["sdk", "v1", "reports", reportID, "complete"],
+            reportID: reportID,
+            operation: "complete",
+            body: Data("{}".utf8)
+        )
+    }
+
+    private func sendLifecycle(
+        path: [String],
+        reportID: String,
+        operation: String,
+        body: Data?
+    ) async throws -> CrumbUploadHTTPResponse {
+        var request = URLRequest(url: endpoint(path))
+        request.httpMethod = "POST"
+        request.timeoutInterval = 15
+        request.setValue("Bearer \(settings.projectKey)", forHTTPHeaderField: "Authorization")
+        request.setValue("\(reportID):\(operation)", forHTTPHeaderField: "Idempotency-Key")
+        if let body {
+            request.httpBody = body
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        }
+        let response = try await send(request, operation: operation)
+        guard (200..<300).contains(response.statusCode) else {
+            throw httpFailure(operation: operation, statusCode: response.statusCode)
+        }
+        return response
+    }
+
+    private func put(_ data: Data, target: InitializationResponse.Artifact) async throws {
+        guard target.method == "PUT",
+              let url = URL(string: target.url),
+              validUploadURL(url) else {
+            throw CrumbUploadFailure(reason: "artifact.invalid_target", retryable: false)
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = "PUT"
+        request.timeoutInterval = 60
+        request.httpBody = data
+        for (name, value) in target.headers where validHeaderName(name) {
+            request.setValue(value, forHTTPHeaderField: name)
+        }
+        let response = try await send(request, operation: "artifact")
+        guard (200..<300).contains(response.statusCode) else {
+            throw httpFailure(operation: "artifact", statusCode: response.statusCode)
+        }
+    }
+
+    private func send(_ request: URLRequest, operation: String) async throws -> CrumbUploadHTTPResponse {
+        do {
+            return try await transport.send(request)
+        } catch is CancellationError {
+            throw CancellationError()
+        } catch let failure as CrumbUploadFailure {
+            throw failure
+        } catch {
+            if Task.isCancelled { throw CancellationError() }
+            throw CrumbUploadFailure(reason: "\(operation).network", retryable: true)
+        }
+    }
+
+    private func validateTargets(
+        _ targets: [InitializationResponse.Artifact],
+        payload: CrumbQueuedReportPayload
+    ) throws {
+        let targetIDs = targets.map(\.id)
+        guard targetIDs.count == Set(targetIDs).count,
+              Set(targetIDs) == Set(payload.artifacts.map(\.manifest.id)) else {
+            throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+        }
+        for target in targets {
+            guard let artifact = payload.artifacts.first(where: { $0.manifest.id == target.id }),
+                  target.uploadID == artifact.manifest.uploadID else {
+                throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+            }
+        }
+    }
+
+    private func decodeInitialization(_ data: Data, reportID: String) throws -> InitializationResponse {
+        do {
+            let response = try JSONDecoder().decode(InitializationResponse.self, from: data)
+            guard response.reportID == reportID else {
+                throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+            }
+            return response
+        } catch let failure as CrumbUploadFailure {
+            throw failure
+        } catch {
+            throw CrumbUploadFailure(reason: "init.invalid_response", retryable: false)
+        }
+    }
+
+    private func wrappedEnvelope(_ envelope: Data) -> Data {
+        var body = Data("{\"envelope\":".utf8)
+        body.append(envelope)
+        body.append(Data("}".utf8))
+        return body
+    }
+
+    private func endpoint(_ components: [String]) -> URL {
+        components.reduce(settings.ingestionURL) { url, component in
+            url.appendingPathComponent(component)
+        }
+    }
+
+    private func validUploadURL(_ url: URL) -> Bool {
+        let scheme = url.scheme?.lowercased()
+        let baseScheme = settings.ingestionURL.scheme?.lowercased()
+        return url.host != nil
+            && url.user == nil
+            && url.password == nil
+            && url.fragment == nil
+            && (scheme == "https" || (scheme == "http" && baseScheme == "http"))
+    }
+
+    private func validHeaderName(_ value: String) -> Bool {
+        let allowed = CharacterSet(
+            charactersIn: "!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+        )
+        return !value.isEmpty && value.unicodeScalars.allSatisfy(allowed.contains)
+    }
+
+    private func httpFailure(operation: String, statusCode: Int) -> CrumbUploadFailure {
+        let retryable = statusCode == 408 || statusCode == 425 || statusCode == 429
+            || (500...599).contains(statusCode)
+            || (operation == "artifact" && statusCode == 403)
+        return CrumbUploadFailure(
+            reason: "\(operation).http_\(statusCode)",
+            retryable: retryable
+        )
+    }
+
+    private struct InitializationResponse: Decodable, Sendable {
+        let reportID: String
+        let status: String
+        let artifacts: [Artifact]
+
+        enum CodingKeys: String, CodingKey {
+            case reportID = "report_id"
+            case status
+            case artifacts
+        }
+
+        struct Artifact: Decodable, Sendable {
+            let id: String
+            let uploadID: String
+            let method: String
+            let url: String
+            let headers: [String: String]
+
+            enum CodingKeys: String, CodingKey {
+                case id
+                case uploadID = "upload_id"
+                case method
+                case url
+                case headers
+            }
+        }
+    }
+}
+
+private struct CrumbUploadFailure: Error, Sendable {
+    let reason: String
+    let retryable: Bool
+}

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

@@ -0,0 +1,306 @@
+import Foundation
+import CryptoKit
+
+package struct CrumbReportSettings: Equatable, Sendable {
+    package let environment: String
+    package let release: CrumbRelease
+    package let invocation: Set<CrumbInvocation>
+    package let capture: CrumbCaptureOptions
+    package let diagnostics: CrumbDiagnosticsOptions
+    package let privacy: CrumbPrivacyOptions
+    package let reporter: CrumbReporterOptions
+    package let evidence: Set<CrumbEvidenceCategory>
+    package let application: CrumbApplicationMetadata
+    package let customContext: [String: String]
+    package let policyStatus: CrumbPolicyStatus
+    package let workspacePolicyVersion: Int?
+    package var screenContext: CrumbScreenContext? = nil
+}
+
+package struct CrumbUploadSettings: Equatable, Sendable {
+    package let projectKey: String
+    package let ingestionURL: URL
+}
+
+final class CrumbRuntime: @unchecked Sendable {
+    static let shared = CrumbRuntime()
+
+    private let lock = NSLock()
+    private var configuration: CrumbConfiguration?
+    private var screenContext: CrumbScreenContext?
+    private var workspacePolicy: CrumbWorkspacePolicy?
+    private var highestWorkspacePolicyVersionByScope: [String: Int] = [:]
+    private var policyStatus: CrumbPolicyStatus = .notFetched
+
+    private init() {}
+
+    func start(_ configuration: CrumbConfiguration) throws {
+        try Self.validate(configuration)
+
+        lock.lock()
+        defer { lock.unlock() }
+
+        if let existing = self.configuration {
+            guard existing == configuration else {
+                throw CrumbStartError.alreadyStartedWithDifferentConfiguration
+            }
+            return
+        }
+        self.configuration = configuration
+    }
+
+    func setScreenContext(_ json: String) {
+        let context = CrumbScreenContext.decode(json)
+        lock.lock()
+        defer { lock.unlock() }
+        screenContext = context
+    }
+
+    func reportSettings() throws -> CrumbReportSettings {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let configuration else { throw CrumbRuntimeError.notStarted }
+        let effective = effectiveSettings(for: configuration)
+        return CrumbReportSettings(
+            environment: configuration.environment,
+            release: configuration.release,
+            invocation: configuration.invocation,
+            capture: configuration.capture,
+            diagnostics: configuration.diagnostics,
+            privacy: configuration.privacy,
+            reporter: CrumbReporterOptions(
+                theme: configuration.reporter.theme,
+                visibleFields: effective.reporterFields
+            ),
+            evidence: effective.evidence,
+            application: configuration.application,
+            customContext: effective.customContext,
+            policyStatus: effective.status,
+            workspacePolicyVersion: effective.workspacePolicyVersion,
+            screenContext: effective.evidence.contains(.customContext) ? screenContext : nil
+        )
+    }
+
+    func workspacePolicyFetchSettings() throws -> CrumbPolicyFetchSettings? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let configuration else { throw CrumbRuntimeError.notStarted }
+        guard let url = configuration.workspacePolicy.url else { return nil }
+        return CrumbPolicyFetchSettings(
+            projectKey: configuration.projectKey,
+            url: url,
+            timeout: configuration.workspacePolicy.timeout
+        )
+    }
+
+    func workspacePolicyCacheKey() throws -> String {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let configuration else { throw CrumbRuntimeError.notStarted }
+        let scope = Self.workspacePolicyScopeKey(for: configuration)
+        let digest = SHA256.hash(data: Data(scope.utf8))
+            .map { String(format: "%02x", $0) }
+            .joined()
+        return "crumb.workspace-policy.\(digest)"
+    }
+
+    func beginWorkspacePolicyFetch() {
+        lock.lock()
+        defer { lock.unlock() }
+        guard configuration?.workspacePolicy.url != nil else { return }
+        policyStatus = workspacePolicy?.isValid(at: Date()) == true ? .cached : .fetching
+    }
+
+    @discardableResult
+    func applyWorkspacePolicy(_ policy: CrumbWorkspacePolicy, source: CrumbPolicySource) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let configuration,
+              configuration.workspacePolicy.url != nil,
+              policy.isValid(at: Date()) else {
+            return false
+        }
+        let scope = Self.workspacePolicyScopeKey(for: configuration)
+        if highestWorkspacePolicyVersionByScope[scope].map({ $0 > policy.version }) == true {
+            return false
+        }
+        workspacePolicy = policy
+        highestWorkspacePolicyVersionByScope[scope] = max(
+            highestWorkspacePolicyVersionByScope[scope] ?? 0,
+            policy.version
+        )
+        policyStatus = source == .fresh ? .fresh : .cached
+        return true
+    }
+
+    func markWorkspacePolicyUnavailable() {
+        lock.lock()
+        defer { lock.unlock() }
+        guard configuration?.workspacePolicy.url != nil else { return }
+        if workspacePolicy?.isValid(at: Date()) != true {
+            workspacePolicy = nil
+            policyStatus = .unavailable
+        }
+    }
+
+    func uploadSettings() throws -> CrumbUploadSettings? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let configuration else { throw CrumbRuntimeError.notStarted }
+        guard let ingestionURL = configuration.upload.ingestionURL else { return nil }
+        return CrumbUploadSettings(
+            projectKey: configuration.projectKey,
+            ingestionURL: ingestionURL
+        )
+    }
+
+    func resetForTesting() {
+        lock.lock()
+        defer { lock.unlock() }
+        configuration = nil
+        screenContext = nil
+        workspacePolicy = nil
+        highestWorkspacePolicyVersionByScope.removeAll()
+        policyStatus = .notFetched
+    }
+
+    private static func workspacePolicyScopeKey(for configuration: CrumbConfiguration) -> String {
+        [
+            configuration.projectKey,
+            configuration.environment,
+            configuration.workspacePolicy.url?.absoluteString ?? ""
+        ]
+        .map { "\($0.utf8.count):\($0)" }
+        .joined(separator: "|")
+    }
+
+    private static func validate(_ configuration: CrumbConfiguration) throws {
+        guard !configuration.projectKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw CrumbStartError.emptyProjectKey
+        }
+        guard hasPrintableLength(configuration.projectKey, maximum: 512) else {
+            throw CrumbStartError.invalidProjectKey
+        }
+        guard !configuration.environment.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            throw CrumbStartError.emptyEnvironment
+        }
+        guard hasPrintableLength(configuration.environment, maximum: 64) else {
+            throw CrumbStartError.invalidEnvironment
+        }
+        guard
+            hasPrintableLength(configuration.release.appVersion, maximum: 64),
+            hasPrintableLength(configuration.release.nativeBuild, maximum: 64),
+            configuration.release.bundleVersion.map({
+                hasPrintableLength($0, maximum: 128)
+            }) ?? true
+        else {
+            throw CrumbStartError.invalidRelease
+        }
+        guard configuration.reporter.visibleFields.contains(.description) else {
+            throw CrumbStartError.invalidReporterFields
+        }
+        guard Set(CrumbEvidenceCategory.allCases).isSuperset(of: configuration.evidence) else {
+            throw CrumbStartError.invalidEvidence
+        }
+        if let name = configuration.application.name,
+           !hasPrintableLength(name, maximum: 256) {
+            throw CrumbStartError.invalidApplicationMetadata
+        }
+        guard
+            configuration.customContext.values.count <= CrumbCustomContextSanitizer.maximumKeys,
+            configuration.customContext.allowedKeys.count <= CrumbCustomContextSanitizer.maximumKeys,
+            configuration.customContext.values.keys.allSatisfy({
+                CrumbCustomContextSanitizer.isValidKey($0)
+            }),
+            configuration.customContext.allowedKeys.allSatisfy({
+                CrumbCustomContextSanitizer.isValidKey($0)
+            })
+        else {
+            throw CrumbStartError.invalidCustomContext
+        }
+        guard configuration.workspacePolicy.timeout >= 0.25,
+              configuration.workspacePolicy.timeout <= 5 else {
+            throw CrumbStartError.invalidWorkspacePolicyTimeout
+        }
+        if let url = configuration.workspacePolicy.url,
+           !validHTTPURL(url) {
+            throw CrumbStartError.invalidWorkspacePolicyURL
+        }
+        guard (320...4_096).contains(configuration.capture.maximumScreenshotDimension) else {
+            throw CrumbStartError.invalidScreenshotDimension
+        }
+        guard (65_536...26_214_400).contains(configuration.capture.maximumScreenshotBytes) else {
+            throw CrumbStartError.invalidScreenshotByteLimit
+        }
+        guard (0.25...5).contains(configuration.diagnostics.timeout) else {
+            throw CrumbStartError.invalidDiagnosticsTimeout
+        }
+        if let url = configuration.diagnostics.healthCheckURL,
+           !validHTTPURL(url) {
+            throw CrumbStartError.invalidHealthCheckURL
+        }
+        guard (1...300).contains(configuration.diagnostics.logs.lookback) else {
+            throw CrumbStartError.invalidLogLookback
+        }
+        guard
+            (1...500).contains(configuration.diagnostics.logs.maximumEntries),
+            (1_024...262_144).contains(configuration.diagnostics.logs.maximumBytes)
+        else {
+            throw CrumbStartError.invalidLogLimits
+        }
+        if let url = configuration.upload.ingestionURL {
+            guard validHTTPURL(url) else {
+                throw CrumbStartError.invalidIngestionURL
+            }
+        }
+    }
+
+    private func effectiveSettings(
+        for configuration: CrumbConfiguration,
+        now: Date = Date()
+    ) -> CrumbEffectivePolicy {
+        let status: CrumbPolicyStatus
+        if configuration.workspacePolicy.url == nil {
+            status = .notConfigured
+        } else if let workspacePolicy,
+                  workspacePolicy.isValid(at: now),
+                  policyStatus == .fresh || policyStatus == .cached {
+            status = policyStatus
+        } else if workspacePolicy.map({ $0.expiresAt <= now }) == true {
+            status = .expired
+        } else {
+            status = policyStatus
+        }
+        return CrumbPolicyEvaluator.effective(
+            for: configuration,
+            workspacePolicy: workspacePolicy,
+            status: status,
+            now: now
+        )
+    }
+
+    private static func validHTTPURL(_ url: URL) -> Bool {
+        let scheme = url.scheme?.lowercased()
+        return (scheme == "https" || scheme == "http") &&
+            url.host != nil &&
+            url.user == nil &&
+            url.password == nil &&
+            url.query == nil &&
+            url.fragment == nil
+    }
+
+    private static func hasPrintableLength(_ value: String, maximum: Int) -> Bool {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        return !trimmed.isEmpty
+            && value.unicodeScalars.count <= maximum
+            && value.unicodeScalars.allSatisfy { !CharacterSet.controlCharacters.contains($0) }
+    }
+}
+
+package enum CrumbRuntimeError: Error, Equatable {
+    case notStarted
+}

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

@@ -0,0 +1,5 @@
+// Generated from the repository VERSION file. Do not edit by hand.
+
+public enum CrumbSDKVersion {
+    public static let current = "0.0.1-rc.5"
+}

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

@@ -0,0 +1,29 @@
+import Foundation
+
+/// An explicitly supplied static screen name and focused route hierarchy, never navigation history.
+public struct CrumbScreenContext: Codable, Equatable, Sendable {
+    public let name: String
+    public let route: [String]
+    public let source: String
+
+    package func validated() -> Self? {
+        func valid(_ value: String) -> Bool {
+            !value.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty &&
+                value.utf8.count <= 128 && !value.contains("://") &&
+                !value.contains("?") && !value.contains("#") &&
+                value.unicodeScalars.allSatisfy { !CharacterSet.controlCharacters.contains($0) }
+        }
+        guard ["manual", "react_navigation", "expo_router"].contains(source),
+              valid(name), !route.isEmpty, route.count <= 8, route.allSatisfy(valid) else { return nil }
+        let cleanName = CrumbLogSanitizer.sanitize(name)
+        let cleanRoute = route.map { CrumbLogSanitizer.sanitize($0) }
+        guard valid(cleanName), cleanRoute.allSatisfy(valid) else { return nil }
+        return Self(name: cleanName, route: cleanRoute, source: source)
+    }
+
+    package static func decode(_ json: String) -> Self? {
+        guard json.utf8.count <= 2048, let data = json.data(using: .utf8),
+              let value = try? JSONDecoder().decode(Self.self, from: data) else { return nil }
+        return value.validated()
+    }
+}