Swift中保留原始堆栈追踪的错误抛出与捕获方案问询

核心解决方案 #

针对你提出的两个问题，核心思路是让自定义错误携带堆栈追踪信息，同时在捕获错误时分离用户提示与调试信息，既给用户友好提示，又能让Sentry拿到完整的错误上下文。

1. 自定义带堆栈的错误类型 #

首先定义一个能存储堆栈和底层错误的错误类型，同时实现LocalizedError方便给用户显示消息：

import Foundation
import Sentry

// 协议定义错误需携带堆栈和底层错误
protocol TraceableError: Error {
    var stackTrace: [String] { get }
    var underlyingError: Error? { get }
}

enum CustomError: LocalizedError, TraceableError {
    case validationError(message: String)
    case internalError(message: String, innerError: Error?)
    
    // 用户可见的错误提示
    var errorDescription: String? {
        switch self {
        case .validationError(let msg):
            return msg
        case .internalError(let msg, _):
            return msg
        }
    }
    
    // 捕获错误发生时的堆栈，过滤掉错误自身的栈帧
    var stackTrace: [String] {
        Thread.callStackSymbols.dropFirst(2)
    }
    
    // 存储原始错误
    var underlyingError: Error? {
        switch self {
        case .validationError:
            return nil
        case .internalError(_, let innerErr):
            return innerErr
        }
    }
}

2. 错误捕获与Sentry上报 #

修改按钮的错误处理逻辑，实现用户提示+完整堆栈上报：

struct ContentView: View {
    @State private var showAlert = false
    @State private var alertMessage = ""
    
    var body: some View {
        VStack(alignment: .leading) {
            Text("Error Handling Tests")
            
            Button("Test B (Fixed)") {
                do {
                    try throwingFunction()
                } catch {
                    // 给用户显示提示
                    alertMessage = error.localizedDescription
                    showAlert = true
                    
                    // 上报带完整堆栈的错误到Sentry
                    reportErrorToSentry(error: error)
                }
            }
            
            Button("Test C (Fixed)") {
                do {
                    try wrappedErrorThrowingFunction()
                } catch {
                    alertMessage = error.localizedDescription
                    showAlert = true
                    reportErrorToSentry(error: error)
                }
            }
        }
        .alert(isPresented: $showAlert) {
            Alert(title: Text("提示"), message: Text(alertMessage), dismissButton: .default(Text("确定")))
        }
    }
    
    func throwingFunction() throws {
        throw CustomError.validationError(message: "故意抛出的验证错误")
    }
    
    func wrappedErrorThrowingFunction() throws {
        do {
            try throwingFunction()
        } catch {
            throw CustomError.internalError(message: "发生了意外错误", innerError: error)
        }
    }
    
    // 封装Sentry上报逻辑
    private func reportErrorToSentry(error: Error) {
        let event = Event(level: .error)
        event.message = Message(formatted: error.localizedDescription)
        
        // 处理自定义带堆栈的错误
        if let traceableErr = error as? TraceableError {
            // 添加当前错误的堆栈
            let frames = traceableErr.stackTrace.map { StacktraceFrame(symbol: $0) }
            event.exceptions = [Exception(value: error.localizedDescription, type: String(describing: error), stacktrace: Stacktrace(frames: frames))]
            
            // 如果有底层错误，添加到错误链
            if let innerErr = traceableErr.underlyingError {
                if let innerTraceable = innerErr as? TraceableError {
                    let innerFrames = innerTraceable.stackTrace.map { StacktraceFrame(symbol: $0) }
                    event.exceptions?.append(Exception(value: innerErr.localizedDescription, type: String(describing: innerErr), stacktrace: Stacktrace(frames: innerFrames)))
                } else {
                    event.exceptions?.append(Exception(value: innerErr.localizedDescription, type: String(describing: innerErr)))
                }
            }
        } else {
            // 处理系统或其他第三方错误，手动捕获堆栈
            let stackTrace = Thread.callStackSymbols.dropFirst(3)
            let frames = stackTrace.map { StacktraceFrame(symbol: $0) }
            event.exceptions = [Exception(value: error.localizedDescription, type: String(describing: error), stacktrace: Stacktrace(frames: frames))]
        }
        
        SentrySDK.capture(event: event)
    }
}

问题解答 #

1. 无需崩溃获取完整堆栈追踪？ #

可以实现。Swift原生错误不会自动携带堆栈，所以需要：

• 在自定义错误初始化时，通过Thread.callStackSymbols捕获当前调用栈，过滤掉错误自身的栈帧，保留错误发生的真实路径。
• 上报到Sentry时，将堆栈信息手动添加到事件的stacktrace字段中，替代默认的上报栈帧。

这样应用不会崩溃，Sentry也能拿到错误源头的完整堆栈。

2. 保留原始堆栈的同时包装错误？ #

完全可以。通过自定义错误的underlyingError属性存储原始错误，同时保留原始错误的堆栈信息：

• 包装错误时，将原始错误传入自定义错误的关联值中。
• 上报时，将原始错误和包装错误的信息都添加到Sentry事件的exceptions数组，形成错误链，方便回溯问题根源。

内容的提问来源于stack exchange，提问作者Enric