telemetry: Replace folly exception_tracer with backtrace-rs on Linux

Summary:
Replaces folly::exception_tracer with backtrace_ffi for throw-site stack trace capture on Linux. Hooks __cxa_throw via the --wrap linker flag, captures raw frames at throw time through onThrow() with a re-entrancy guard to prevent recursion, and symbolizes lazily when getThrowSiteStackTrace() is called. The folly dependency only supported Linux; this change is the first step toward cross-platform  support. On non-Linux platforms, getThrowSiteStackTrace() gracefully returns nullopt until platform hooks are added in subsequent commits.
library used: https://github.com/rust-lang/backtrace-rs internally in `eden/fs/rust/backtrace_ffi/src/lib.rs.h`

Reviewed By: vilatto

Differential Revision: D102215367

fbshipit-source-id: 64d69f563fef3eccf3e7deb9fef38a2d000f9c3a

Author: Chandhana Solainathan

eden/fs/telemetry/BUCK

@@ -148,11 +148,15 @@ cpp_library(
     headers = [
         "ThrowTraceCapture.h",
     ],
+    exported_linker_flags = select({
+        "DEFAULT": [],
+        "ovr_config//os:linux": [
+            "-Wl,--wrap=__cxa_throw",
+        ],
+    }),
     deps = [
-        "//folly/debugging/exception_tracer:exception_tracer_base",
-    ],
-    exported_deps = [
-        "//folly/debugging/exception_tracer:exception_tracer",  # @manual
+        "//eden/fs/rust/backtrace_ffi:backtrace-ffi",
+        "//eden/fs/rust/backtrace_ffi:backtrace-ffi@header",
     ],
 )
 

eden/fs/telemetry/ThrowTraceCapture.cpp

@@ -7,49 +7,56 @@
 
 #include "eden/fs/telemetry/ThrowTraceCapture.h"
 
-#ifdef __linux__
-// =============================================================================
-// Linux: folly::exception_tracer
-//
-// Uses __cxa_throw hook (via --wrap linker flag) to capture stack frames at
-// throw time. Frames are stored in thread-local StackTraceStack and symbolized
-// via folly's ELF/DWARF symbolizer.
-// =============================================================================
-
-#include <sstream>
+#include <cstdlib>
 
-#include <folly/debugging/exception_tracer/ExceptionTracer.h>
+#include "eden/fs/rust/backtrace_ffi/src/lib.rs.h"
 
-namespace facebook::eden {
+#if defined(__linux__)
 
-std::optional<std::string> getThrowSiteStackTrace() {
-  auto exceptions = folly::exception_tracer::getCurrentExceptions();
-  if (!exceptions.empty()) {
-    std::ostringstream ss;
-    for (const auto& info : exceptions) {
-      ss << info;
-    }
-    auto trace = ss.str();
-    if (!trace.empty()) {
-      return trace;
-    }
-  }
-  return std::nullopt;
+namespace {
+// Common: onThrow() captures a raw backtrace via Rust FFI.
+// Re-entrancy is handled by the Rust CapturingGuard in capture_backtrace().
+void onThrow() {
+  constexpr size_t kMaxStackDepth = 64;
+  facebook::eden::capture_backtrace(kMaxStackDepth);
 }
+} // namespace
 
-} // namespace facebook::eden
+// Linux throw hook using the GNU linker's --wrap mechanism.
+//
+// When -Wl,--wrap=__cxa_throw is passed (via exported_linker_flags in BUCK),
+// the linker redirects all calls to __cxa_throw to __wrap___cxa_throw, and
+// makes the original available as __real___cxa_throw. This lets us intercept
+// every C++ throw to capture a backtrace before the stack unwinds.
+//
+// Flow: throw expr → __wrap___cxa_throw → onThrow() → capture_backtrace()
+//       → __real___cxa_throw (original, performs the actual throw)
+
+extern "C" {
+void __real___cxa_throw(void*, void*, void (*)(void*))
+    __attribute__((__noreturn__));
+
+__attribute__((__noreturn__)) void __wrap___cxa_throw(
+    void* thrownException,
+    void* type,
+    void (*destructor)(void*)) {
+  onThrow();
+  __real___cxa_throw(thrownException, type, destructor);
+  __builtin_unreachable();
+}
+} // extern "C"
 
-#else
-// =============================================================================
-// Unsupported platform — no throw-site stack traces available.
-// =============================================================================
+#endif // defined(__linux__)
 
 namespace facebook::eden {
 
+// Lazy symbolization via Rust FFI — resolves captured frames on demand.
 std::optional<std::string> getThrowSiteStackTrace() {
-  return std::nullopt;
+  auto trace = symbolize_captured_trace();
+  if (trace.empty()) {
+    return std::nullopt;
+  }
+  return std::string(trace.data(), trace.size());
 }
 
 } // namespace facebook::eden
-
-#endif // __linux__

eden/fs/telemetry/ThrowTraceCapture.h

@@ -16,10 +16,12 @@ namespace facebook::eden {
  * Returns the throw-site stack trace for the current exception.
  * Must be called inside a catch block.
  *
- * Platform-specific implementations:
- *   Linux:   folly::exception_tracer (hooks __cxa_throw via --wrap)
- *   macOS:   Not yet implemented (returns std::nullopt)
- *   Windows: Not yet implemented (returns std::nullopt)
+ * Uses backtrace-rs via Rust FFI for cross-platform stack trace capture.
+ * Raw IP addresses are captured at throw time; symbolization is deferred
+ * until this function is called (lazy symbolization).
+ *
+ * Platform-specific hooks:
+ *   Linux:   __wrap___cxa_throw (via --wrap linker flag)
  */
 std::optional<std::string> getThrowSiteStackTrace();
 

eden/fs/telemetry/test/EdenErrorInfoBuilderTest.cpp

@@ -27,17 +27,6 @@ TEST(EdenErrorInfoTest, InitializeFuseEdenErrorInfoWithException) {
   try {
     throwRuntimeError();
   } catch (const std::exception& ex) {
-    // ErrorArg captures the throw-site stack trace inside a catch block.
-    ErrorArg error(ex);
-#ifdef __linux__
-    ASSERT_TRUE(error.stackTrace.has_value())
-        << "ErrorArg should capture a stack trace from a thrown exception";
-    EXPECT_NE(error.stackTrace->find("throwRuntimeError"), std::string::npos)
-        << "Stack trace should contain the throwing function, got: "
-        << *error.stackTrace;
-#endif
-
-    // create() stores the raw combined trace in info.stackTrace.
     auto info = EdenErrorInfo::fuse(ex, 42, "/mnt/repo").create();
 
     EXPECT_EQ(info.component, EdenComponent::Fuse);