如何保存原调用方的call stack，以供后续异常排查使用？

Great question! This is a common pain point when dealing with async API calls where the error stack only shows the worker thread context, not where the request was originally initiated. Here's how you can solve this by capturing and preserving the original caller's stack trace at the time of the request:

Core Idea #

The key is to capture the caller's stack trace in the original thread (where the request is first made) and attach it to the request object. Later, when an exception occurs in the worker thread, you can output both the worker's exception stack and the saved original caller stack to pinpoint exactly where the problematic request started.

Step 1: Capture the Original Stack Trace #

When creating your API request, capture the current thread's stack trace. We'll trim the stack to exclude the utility methods used to capture it, so we only keep the actual business code context.

import java.util.Arrays;

public class ApiRequest {
    private String requestId;
    // Add other request parameters as needed
    private StackTraceElement[] originalCallerStack;

    public ApiRequest(String requestId) {
        this.requestId = requestId;
        // Capture stack trace, skip the first 2 elements (this constructor and the API client method)
        StackTraceElement[] fullStack = new Exception().getStackTrace();
        this.originalCallerStack = Arrays.copyOfRange(fullStack, 2, fullStack.length);
    }

    public StackTraceElement[] getOriginalCallerStack() {
        return originalCallerStack;
    }
}

Step 2: Pass the Request with Saved Stack to the Worker Thread #

When sending the async request, ensure the ApiRequest (with the saved stack) is passed along to the worker thread's processing logic.

import java.util.concurrent.Executors;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

public class ApiClient {
    public void sendAsyncRequest(ApiRequest request, 
                                 Consumer<ApiResponse> successHandler,
                                 BiConsumer<Throwable, ApiRequest> failureHandler) {
        Executors.newCachedThreadPool().submit(() -> {
            try {
                // Simulate API call and response processing
                ApiResponse response = fetchDataFromServer(request);
                
                // Simulate a variable-not-found error for testing
                if (response.getTargetVariable() == null) {
                    throw new IllegalStateException("Requested variable does not exist");
                }
                
                successHandler.accept(response);
            } catch (Exception e) {
                // Pass both the exception and the request (with original stack) to the handler
                failureHandler.accept(e, request);
            }
        });
    }

    private ApiResponse fetchDataFromServer(ApiRequest request) {
        // Simulate server response (return null to trigger error)
        return new ApiResponse(null);
    }
}

Step 3: Output Both Stacks on Exception #

In your failure handler (called by the worker thread), print both the original caller stack and the worker's exception stack to get full context.

public class BusinessService {
    private final ApiClient apiClient = new ApiClient();

    public void processUserRequest(String userId) {
        // Create request with original caller stack
        ApiRequest request = new ApiRequest("req-" + userId);
        apiClient.sendAsyncRequest(request,
            this::handleSuccess,
            this::handleFailure);
    }

    private void handleSuccess(ApiResponse response) {
        // Handle successful response
        System.out.println("Received data: " + response.getTargetVariable());
    }

    private void handleFailure(Throwable error, ApiRequest request) {
        // Print original caller stack first to show where the request started
        System.err.println("=== Original Caller Stack (Request Origin) ===");
        for (StackTraceElement elem : request.getOriginalCallerStack()) {
            System.err.println("\tat " + elem);
        }

        // Then print the worker thread's exception stack
        System.err.println("\n=== Worker Thread Exception Stack ===");
        error.printStackTrace();
    }
}

Key Optimizations & Notes #

• Performance: Capturing stack traces has a small overhead. If you're in a high-throughput system, consider adding a toggle (e.g., a system property) to only capture stacks when debugging or when an error is anticipated.
• Stack Trimming: Adjust the Arrays.copyOfRange index based on your code structure—make sure you're skipping only the utility methods that create/capture the request, not actual business logic.
• Alternative: MDC for Distributed Tracing: If you're using logging frameworks like Logback or SLF4J, you can store the stack trace (or a condensed version) in the MDC (Mapped Diagnostic Context). Just remember to copy the MDC context from the original thread to the worker thread, since MDC is thread-local by default.

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