@logbrew/react-native 0.1.11 → 0.1.13

package/ios/GeneratedAppleDiagnostics/LogBrew/LogBrewTrace.swift

@@ -0,0 +1,357 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public struct LogBrewTraceContext: Equatable, Sendable {
+    public let traceId: String
+    public let spanId: String
+    public let parentSpanId: String?
+    public let traceFlags: String
+    public let sampled: Bool
+
+    public var traceparent: String {
+        "00-\(traceId)-\(spanId)-\(traceFlags)"
+    }
+
+    public init(
+        traceId: String,
+        spanId: String,
+        parentSpanId: String? = nil,
+        traceFlags: String = "01",
+    ) throws {
+        let normalizedTraceId = try Self.normalizedTraceId(traceId)
+        let normalizedSpanId = try Self.normalizedSpanId("spanId", spanId)
+        let normalizedParentSpanId = try parentSpanId.map { try Self.normalizedSpanId("parentSpanId", $0) }
+        let normalizedTraceFlags = try Self.normalizedTraceFlags(traceFlags)
+        self.init(
+            validatedTraceId: normalizedTraceId,
+            spanId: normalizedSpanId,
+            parentSpanId: normalizedParentSpanId,
+            traceFlags: normalizedTraceFlags,
+        )
+    }
+
+    static func createRoot(traceFlags: String = "01") throws -> LogBrewTraceContext {
+        let normalizedTraceFlags = try normalizedTraceFlags(traceFlags)
+        return LogBrewTraceContext(
+            validatedTraceId: randomTraceId(),
+            spanId: randomSpanId(),
+            parentSpanId: nil,
+            traceFlags: normalizedTraceFlags,
+        )
+    }
+
+    static func fallbackRoot() -> LogBrewTraceContext {
+        LogBrewTraceContext(
+            validatedTraceId: randomTraceId(),
+            spanId: randomSpanId(),
+            parentSpanId: nil,
+            traceFlags: "01",
+        )
+    }
+
+    static func child(of parent: LogBrewTraceContext) -> LogBrewTraceContext {
+        LogBrewTraceContext(
+            validatedTraceId: parent.traceId,
+            spanId: randomSpanId(),
+            parentSpanId: parent.spanId,
+            traceFlags: parent.traceFlags,
+        )
+    }
+
+    fileprivate static func child(
+        traceId: String,
+        parentSpanId: String,
+        traceFlags: String,
+    ) -> LogBrewTraceContext {
+        LogBrewTraceContext(
+            validatedTraceId: traceId,
+            spanId: randomSpanId(),
+            parentSpanId: parentSpanId,
+            traceFlags: traceFlags,
+        )
+    }
+
+    private init(validatedTraceId: String, spanId: String, parentSpanId: String?, traceFlags: String) {
+        traceId = validatedTraceId
+        self.spanId = spanId
+        self.parentSpanId = parentSpanId
+        self.traceFlags = traceFlags
+        sampled = (Int(traceFlags, radix: 16) ?? 0) & 1 == 1
+    }
+
+    private static func randomTraceId() -> String {
+        let value = UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased()
+        return value == zeroTraceId ? "00000000000000000000000000000001" : value
+    }
+
+    private static func randomSpanId() -> String {
+        let value = String(UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased().prefix(16))
+        return value == zeroSpanId ? "0000000000000001" : value
+    }
+
+    fileprivate static func normalizedTraceId(_ value: String) throws -> String {
+        let normalized = try normalizedHex("traceId", value, length: 32)
+        if normalized == zeroTraceId {
+            throw SdkError(code: "validation_error", message: "traceId must not be all zeros")
+        }
+        return normalized
+    }
+
+    fileprivate static func normalizedSpanId(_ label: String, _ value: String) throws -> String {
+        let normalized = try normalizedHex(label, value, length: 16)
+        if normalized == zeroSpanId {
+            throw SdkError(code: "validation_error", message: "\(label) must not be all zeros")
+        }
+        return normalized
+    }
+
+    fileprivate static func normalizedTraceFlags(_ value: String) throws -> String {
+        try normalizedHex("traceFlags", value, length: 2)
+    }
+
+    private static func normalizedHex(_ label: String, _ value: String, length: Int) throws -> String {
+        let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        guard normalized.count == length, normalized.allSatisfy(\.isHexDigit) else {
+            throw SdkError(
+                code: "validation_error",
+                message: "\(label) must be \(length) lowercase or uppercase hex characters",
+            )
+        }
+        return normalized
+    }
+}
+
+public struct LogBrewOpenTelemetrySpanContext: Equatable, Sendable {
+    public let traceId: String
+    public let spanId: String
+    public let traceFlags: String
+    public let sampled: Bool
+
+    public init(
+        traceId: String,
+        spanId: String,
+        traceFlags: String = "01",
+    ) throws {
+        let normalizedTraceId = try LogBrewTraceContext.normalizedTraceId(traceId)
+        let normalizedSpanId = try LogBrewTraceContext.normalizedSpanId("OpenTelemetry spanId", spanId)
+        let normalizedTraceFlags = try LogBrewTraceContext.normalizedTraceFlags(traceFlags)
+
+        self.traceId = normalizedTraceId
+        self.spanId = normalizedSpanId
+        self.traceFlags = normalizedTraceFlags
+        sampled = (Int(normalizedTraceFlags, radix: 16) ?? 0) & 1 == 1
+    }
+
+    public init(
+        traceId: String,
+        spanId: String,
+        sampled: Bool,
+    ) throws {
+        try self.init(traceId: traceId, spanId: spanId, traceFlags: sampled ? "01" : "00")
+    }
+}
+
+public protocol LogBrewOpenTelemetrySpanContextCarrier {
+    var logBrewOpenTelemetryTraceId: String { get }
+    var logBrewOpenTelemetrySpanId: String { get }
+    var logBrewOpenTelemetryTraceFlags: String { get }
+    var logBrewOpenTelemetryIsValid: Bool { get }
+}
+
+public enum LogBrewTrace {
+    @TaskLocal private static var activeContext: LogBrewTraceContext?
+
+    public static var current: LogBrewTraceContext? {
+        activeContext
+    }
+
+    public static func createContext(traceFlags: String = "01") throws -> LogBrewTraceContext {
+        try LogBrewTraceContext.createRoot(traceFlags: traceFlags)
+    }
+
+    public static func openTelemetrySpanContext(
+        traceId: String,
+        spanId: String,
+        traceFlags: String = "01",
+    ) throws -> LogBrewOpenTelemetrySpanContext {
+        try LogBrewOpenTelemetrySpanContext(traceId: traceId, spanId: spanId, traceFlags: traceFlags)
+    }
+
+    public static func openTelemetrySpanContext(
+        traceId: String,
+        spanId: String,
+        sampled: Bool,
+    ) throws -> LogBrewOpenTelemetrySpanContext {
+        try LogBrewOpenTelemetrySpanContext(traceId: traceId, spanId: spanId, sampled: sampled)
+    }
+
+    public static func openTelemetrySpanContext(
+        from carrier: some LogBrewOpenTelemetrySpanContextCarrier,
+    ) throws -> LogBrewOpenTelemetrySpanContext? {
+        guard carrier.logBrewOpenTelemetryIsValid else {
+            return nil
+        }
+        return try LogBrewOpenTelemetrySpanContext(
+            traceId: carrier.logBrewOpenTelemetryTraceId,
+            spanId: carrier.logBrewOpenTelemetrySpanId,
+            traceFlags: carrier.logBrewOpenTelemetryTraceFlags,
+        )
+    }
+
+    public static func childContext(of parent: LogBrewTraceContext) -> LogBrewTraceContext {
+        LogBrewTraceContext.child(of: parent)
+    }
+
+    public static func context(
+        fromOpenTelemetrySpanContext spanContext: LogBrewOpenTelemetrySpanContext,
+    ) -> LogBrewTraceContext {
+        LogBrewTraceContext.child(
+            traceId: spanContext.traceId,
+            parentSpanId: spanContext.spanId,
+            traceFlags: spanContext.traceFlags,
+        )
+    }
+
+    public static func context(
+        fromOpenTelemetrySpanContextCarrier carrier: some LogBrewOpenTelemetrySpanContextCarrier,
+    ) throws -> LogBrewTraceContext? {
+        guard let spanContext = try openTelemetrySpanContext(from: carrier) else {
+            return nil
+        }
+        return context(fromOpenTelemetrySpanContext: spanContext)
+    }
+
+    public static func continueOrCreateContext(fromTraceparent traceparent: String?) -> LogBrewTraceContext {
+        guard let traceparent, !traceparent.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return LogBrewTraceContext.fallbackRoot()
+        }
+
+        guard let remoteParent = try? parseTraceparent(traceparent) else {
+            return LogBrewTraceContext.fallbackRoot()
+        }
+
+        return childContext(of: remoteParent)
+    }
+
+    public static func parseTraceparent(_ traceparent: String) throws -> LogBrewTraceContext {
+        let parts = traceparent.trimmingCharacters(in: .whitespacesAndNewlines).split(
+            separator: "-",
+            omittingEmptySubsequences: false,
+        )
+        guard parts.count == 4 else {
+            throw SdkError(
+                code: "validation_error",
+                message: "traceparent must use W3C version-traceId-parentSpanId-traceFlags format",
+            )
+        }
+
+        let version = String(parts[0]).lowercased()
+        guard version.count == 2, version.allSatisfy(\.isHexDigit), version != "ff" else {
+            throw SdkError(code: "validation_error", message: "traceparent version must be 2 hex characters and not ff")
+        }
+
+        let traceId = try LogBrewTraceContext.normalizedTraceId(String(parts[1]))
+        let parentSpanId = try LogBrewTraceContext.normalizedSpanId("traceparent parent span id", String(parts[2]))
+        let traceFlags = try LogBrewTraceContext.normalizedTraceFlags(String(parts[3]))
+        return try LogBrewTraceContext(traceId: traceId, spanId: parentSpanId, traceFlags: traceFlags)
+    }
+
+    public static func withContext<T>(
+        _ context: LogBrewTraceContext,
+        operation: () throws -> T,
+    ) rethrows -> T {
+        try $activeContext.withValue(context) {
+            try operation()
+        }
+    }
+
+    public static func withContext<T>(
+        _ context: LogBrewTraceContext,
+        operation: () async throws -> T,
+    ) async rethrows -> T {
+        try await $activeContext.withValue(context) {
+            try await operation()
+        }
+    }
+
+    public static func metadata(_ context: LogBrewTraceContext? = current) -> Metadata {
+        guard let context else {
+            return [:]
+        }
+
+        var output: Metadata = [
+            "traceId": .string(context.traceId),
+            "spanId": .string(context.spanId),
+            "traceFlags": .string(context.traceFlags),
+            "traceSampled": .bool(context.sampled),
+        ]
+        if let parentSpanId = context.parentSpanId {
+            output["parentSpanId"] = .string(parentSpanId)
+        }
+        return output
+    }
+
+    public static func metadataWithCurrentTrace(_ metadata: Metadata? = nil) -> Metadata? {
+        mergeTraceMetadata(metadata, context: current)
+    }
+
+    public static func outgoingHeaders(_ context: LogBrewTraceContext? = current) -> [String: String] {
+        guard let context else {
+            return [:]
+        }
+        return ["traceparent": context.traceparent]
+    }
+
+    public static func spanAttributes(
+        name: String,
+        status: SpanStatus,
+        durationMs: Double? = nil,
+        metadata: Metadata? = nil,
+        context: LogBrewTraceContext? = current,
+    ) throws -> SpanAttributes {
+        guard let context else {
+            throw SdkError(code: "validation_error", message: "trace context is required for span attributes")
+        }
+
+        return SpanAttributes(
+            name: name,
+            traceId: context.traceId,
+            spanId: context.spanId,
+            parentSpanId: context.parentSpanId,
+            status: status,
+            durationMs: durationMs,
+            metadata: mergeTraceMetadata(metadata, context: context),
+        )
+    }
+
+    public static func spanAttributesFromOpenTelemetrySpanContext(
+        _ spanContext: LogBrewOpenTelemetrySpanContext,
+        name: String,
+        status: SpanStatus,
+        durationMs: Double? = nil,
+        metadata: Metadata? = nil,
+    ) -> SpanAttributes {
+        let context = context(fromOpenTelemetrySpanContext: spanContext)
+        return SpanAttributes(
+            name: name,
+            traceId: context.traceId,
+            spanId: context.spanId,
+            parentSpanId: context.parentSpanId,
+            status: status,
+            durationMs: durationMs,
+            metadata: mergeTraceMetadata(metadata, context: context),
+        )
+    }
+
+    static func mergeTraceMetadata(_ metadata: Metadata?, context: LogBrewTraceContext? = current) -> Metadata? {
+        var output = metadata ?? [:]
+        for (key, value) in self.metadata(context) {
+            output[key] = value
+        }
+        return output.isEmpty ? nil : output
+    }
+}
+
+private let zeroTraceId = "00000000000000000000000000000000"
+private let zeroSpanId = "0000000000000000"

package/ios/GeneratedAppleDiagnostics/LogBrew/Metadata.swift

@@ -0,0 +1,86 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+public typealias Metadata = [String: MetadataValue]
+
+public enum MetadataValue: Codable, Equatable, Sendable {
+    case string(String)
+    case int(Int)
+    case double(Double)
+    case bool(Bool)
+    case null
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if container.decodeNil() {
+            self = .null
+        } else if let value = try? container.decode(Bool.self) {
+            self = .bool(value)
+        } else if let value = try? container.decode(Int.self) {
+            self = .int(value)
+        } else if let value = try? container.decode(Double.self) {
+            self = .double(value)
+        } else {
+            self = try .string(container.decode(String.self))
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        switch self {
+        case let .string(value):
+            try container.encode(value)
+        case let .int(value):
+            try container.encode(value)
+        case let .double(value):
+            try container.encode(value)
+        case let .bool(value):
+            try container.encode(value)
+        case .null:
+            try container.encodeNil()
+        }
+    }
+}
+
+extension MetadataValue: ExpressibleByStringLiteral {
+    public init(stringLiteral value: String) {
+        self = .string(value)
+    }
+}
+
+extension MetadataValue: ExpressibleByIntegerLiteral {
+    public init(integerLiteral value: Int) {
+        self = .int(value)
+    }
+}
+
+extension MetadataValue: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: Double) {
+        self = .double(value)
+    }
+}
+
+extension MetadataValue: ExpressibleByBooleanLiteral {
+    public init(booleanLiteral value: Bool) {
+        self = .bool(value)
+    }
+}
+
+extension MetadataValue: ExpressibleByNilLiteral {
+    public init(nilLiteral _: ()) {
+        self = .null
+    }
+}
+
+func validateMetadata(_ metadata: Metadata?, label: String) throws {
+    guard let metadata else {
+        return
+    }
+    for (key, value) in metadata {
+        try requireNonEmpty("\(label) key", key)
+        if case let .double(number) = value, !number.isFinite {
+            throw SdkError(code: "validation_error", message: "\(label) numeric values must be finite")
+        }
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/NativeStackFrame.swift

@@ -0,0 +1,27 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+@_spi(CrashReplay)
+public enum NativeStackArchitecture: String, Codable, Equatable, Sendable {
+    case arm64
+    case arm64e
+    case x8664 = "x86_64"
+}
+
+@_spi(CrashReplay)
+public struct NativeStackFrame: Codable, Equatable, Sendable {
+    public let imageUuid: String
+    public let architecture: NativeStackArchitecture
+    public let instructionOffset: String
+
+    public init(
+        imageUuid: String,
+        architecture: NativeStackArchitecture,
+        instructionOffset: String,
+    ) {
+        self.imageUuid = imageUuid
+        self.architecture = architecture
+        self.instructionOffset = instructionOffset
+    }
+}

package/ios/GeneratedAppleDiagnostics/LogBrew/ProductTimeline.swift

@@ -0,0 +1,228 @@
+// Generated by scripts/sync-apple-native-sources.mjs.
+// Edit the canonical Swift source, then regenerate this package boundary.
+import Foundation
+
+private let productAnalyticsSchemaVersion = 1
+private let maxProductAnalyticsSurfaceLength = 256
+
+public struct ProductTimelineContext: Equatable, Sendable {
+    public let sessionId: String?
+    public let screen: String?
+    public let traceId: String?
+    public let funnel: String?
+    public let step: String?
+    public let metadata: Metadata?
+
+    public init(
+        sessionId: String? = nil,
+        screen: String? = nil,
+        traceId: String? = nil,
+        funnel: String? = nil,
+        step: String? = nil,
+        metadata: Metadata? = nil,
+    ) {
+        self.sessionId = sessionId
+        self.screen = screen
+        self.traceId = traceId
+        self.funnel = funnel
+        self.step = step
+        self.metadata = metadata
+    }
+}
+
+public extension LogBrewClient {
+    func captureProductAction(
+        _ id: String,
+        timestamp: String,
+        name: String,
+        status: ActionStatus = .success,
+        context: ProductTimelineContext = ProductTimelineContext(),
+        metadata: Metadata? = nil,
+    ) throws {
+        var eventMetadata = try productTimelineMetadata(
+            source: "swift.action",
+            context: context,
+            metadata: metadata,
+        )
+        eventMetadata["analyticsSchemaVersion"] = .int(productAnalyticsSchemaVersion)
+        eventMetadata["analyticsKind"] = .string("interaction")
+        if let surface = boundedProductAnalyticsSurface(context.screen) {
+            eventMetadata["analyticsSurface"] = .string(surface)
+        } else {
+            eventMetadata.removeValue(forKey: "analyticsSurface")
+        }
+        try action(
+            id,
+            timestamp: timestamp,
+            attributes: ActionAttributes(
+                name: name,
+                status: status,
+                metadata: eventMetadata,
+                context: timelineTelemetryContext(context),
+            ),
+        )
+    }
+
+    func captureNetworkMilestone(
+        _ id: String,
+        timestamp: String,
+        method: String,
+        routeTemplate: String,
+        statusCode: Int? = nil,
+        durationMs: Double? = nil,
+        status: ActionStatus? = nil,
+        context: ProductTimelineContext = ProductTimelineContext(),
+        metadata: Metadata? = nil,
+    ) throws {
+        let normalizedMethod = try normalizedNetworkMethod(method)
+        let normalizedRoute = try normalizedRouteTemplate(routeTemplate)
+        let checkedStatusCode = try validatedStatusCode(statusCode)
+        let checkedDurationMs = try validatedDurationMs(durationMs)
+        var eventMetadata = try productTimelineMetadata(
+            source: "swift.network",
+            context: context,
+            metadata: metadata,
+        )
+        eventMetadata["method"] = .string(normalizedMethod)
+        eventMetadata["routeTemplate"] = .string(normalizedRoute)
+        if let checkedStatusCode {
+            eventMetadata["statusCode"] = .int(checkedStatusCode)
+        }
+        if let checkedDurationMs {
+            eventMetadata["durationMs"] = .double(checkedDurationMs)
+        }
+
+        try action(
+            id,
+            timestamp: timestamp,
+            attributes: ActionAttributes(
+                name: "\(normalizedMethod) \(normalizedRoute)",
+                status: status ?? statusFromStatusCode(checkedStatusCode),
+                metadata: eventMetadata,
+                context: timelineTelemetryContext(context),
+            ),
+        )
+    }
+}
+
+private func timelineTelemetryContext(_ context: ProductTimelineContext) -> TelemetryContext? {
+    guard let sessionId = context.sessionId else {
+        return nil
+    }
+    return TelemetryContext(
+        session: TelemetrySessionContext(
+            id: sessionId.trimmingCharacters(in: .whitespacesAndNewlines),
+        ),
+    )
+}
+
+private func boundedProductAnalyticsSurface(_ surface: String?) -> String? {
+    guard let surface else {
+        return nil
+    }
+    let normalized = surface.trimmingCharacters(in: .whitespacesAndNewlines)
+    guard !normalized.isEmpty,
+          normalized.unicodeScalars.count <= maxProductAnalyticsSurfaceLength
+    else {
+        return nil
+    }
+    let hasControlCharacter = normalized.unicodeScalars.contains { scalar in
+        scalar.value <= 31 || (scalar.value >= 127 && scalar.value <= 159)
+    }
+    return hasControlCharacter ? nil : normalized
+}
+
+private func productTimelineMetadata(
+    source: String,
+    context: ProductTimelineContext,
+    metadata: Metadata?,
+) throws -> Metadata {
+    var output: Metadata = [:]
+    try copyOptionalString("sessionId", context.sessionId, into: &output)
+    try copyOptionalString("screen", context.screen, into: &output)
+    try copyOptionalString("traceId", context.traceId, into: &output)
+    try copyOptionalString("funnel", context.funnel, into: &output)
+    try copyOptionalString("step", context.step, into: &output)
+    try copyMetadata(context.metadata, into: &output)
+    try copyMetadata(metadata, into: &output)
+    output["source"] = .string(source)
+    return LogBrewTrace.mergeTraceMetadata(output) ?? output
+}
+
+private func copyOptionalString(_ key: String, _ value: String?, into output: inout Metadata) throws {
+    guard let value else {
+        return
+    }
+    let normalized = value.trimmingCharacters(in: .whitespacesAndNewlines)
+    try requireNonEmpty(key, normalized)
+    output[key] = .string(normalized)
+}
+
+func copyMetadata(_ metadata: Metadata?, into output: inout Metadata) throws {
+    guard let metadata else {
+        return
+    }
+    for (key, value) in metadata {
+        try requireNonEmpty("metadata key", key)
+        if case let .double(doubleValue) = value, !doubleValue.isFinite {
+            throw SdkError(code: "validation_error", message: "metadata value for \(key) must be finite")
+        }
+        output[key] = value
+    }
+}
+
+func normalizedNetworkMethod(_ method: String) throws -> String {
+    try requireNonEmpty("network method", method)
+    return method.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()
+}
+
+func normalizedRouteTemplate(_ routeTemplate: String) throws -> String {
+    try requireNonEmpty("network routeTemplate", routeTemplate)
+    let trimmed = routeTemplate.trimmingCharacters(in: .whitespacesAndNewlines)
+    if let components = URLComponents(string: trimmed), components.scheme == "http" || components.scheme == "https" {
+        let path = components.path.isEmpty ? "/" : components.path
+        return stripQueryAndHash(path)
+    }
+    if trimmed.contains("://") {
+        throw SdkError(
+            code: "validation_error",
+            message: "network routeTemplate must be a route template or HTTP(S) URL",
+        )
+    }
+    let sanitized = stripQueryAndHash(trimmed)
+    try requireNonEmpty("network routeTemplate", sanitized)
+    return sanitized
+}
+
+private func stripQueryAndHash(_ value: String) -> String {
+    let withoutQuery = value.split(separator: "?", maxSplits: 1, omittingEmptySubsequences: false).first ?? ""
+    let withoutHash = withoutQuery.split(separator: "#", maxSplits: 1, omittingEmptySubsequences: false).first ?? ""
+    return String(withoutHash)
+}
+
+func validatedStatusCode(_ statusCode: Int?) throws -> Int? {
+    guard let statusCode else {
+        return nil
+    }
+    guard (100 ... 599).contains(statusCode) else {
+        throw SdkError(code: "validation_error", message: "network statusCode must be between 100 and 599")
+    }
+    return statusCode
+}
+
+func validatedDurationMs(_ durationMs: Double?) throws -> Double? {
+    guard let durationMs else {
+        return nil
+    }
+    guard durationMs.isFinite, durationMs >= 0 else {
+        throw SdkError(code: "validation_error", message: "network durationMs must be finite and non-negative")
+    }
+    return durationMs
+}
+
+func statusFromStatusCode(_ statusCode: Int?) -> ActionStatus {
+    guard let statusCode else {
+        return .success
+    }
+    return statusCode >= 400 ? .failure : .success
+}