Don’t show long internal Rust stack traces to users (#67678)

This:

- Writes Turbopack internal errors to a file, `.next/fatal.log`
- [x] Automatically truncate this file to prevent it from growing
infinitely
- Shows a simplified message to users when an internal Turbopack error
occurs, directing them to file an issue with the content of the log
- Adds a panic handler on the Rust side in release builds that similarly
shows a simplified message

---------

Co-authored-by: Benjamin Woodruff <benjamin.woodruff@vercel.com>

packages/next-swc/crates/napi/Cargo.toml

@@ -51,6 +51,7 @@ backtrace = "0.3"
 fxhash = "0.2.1"
 dhat = { workspace = true, optional = true }
 indexmap = { workspace = true }
+owo-colors = { workspace = true }
 napi = { version = "2", default-features = false, features = [
   "napi3",
   "serde-json",

packages/next-swc/crates/napi/src/lib.rs

@@ -35,13 +35,16 @@ extern crate napi_derive;
 
 use std::{
     env,
+    io::prelude::*,
     panic::set_hook,
-    sync::{Arc, Once},
+    sync::{Arc, Mutex, Once},
+    time::Instant,
 };
 
 use backtrace::Backtrace;
 use fxhash::FxHashSet;
 use napi::bindgen_prelude::*;
+use owo_colors::OwoColorize;
 use turbopack_binding::swc::core::{
     base::{Compiler, TransformOutput},
     common::{FilePathMapping, SourceMap},
@@ -73,19 +76,85 @@ shadow_rs::shadow!(build);
 static ALLOC: turbopack_binding::turbo::malloc::TurboMalloc =
     turbopack_binding::turbo::malloc::TurboMalloc;
 
+static LOG_THROTTLE: Mutex<Option<Instant>> = Mutex::new(None);
+static LOG_FILE_PATH: &str = ".next/turbopack.log";
+
 #[cfg(feature = "__internal_dhat-heap")]
 #[global_allocator]
 static ALLOC: dhat::Alloc = dhat::Alloc;
 
 #[cfg(not(target_arch = "wasm32"))]
 #[napi::module_init]
+
 fn init() {
-    if cfg!(debug_assertions) || env::var("SWC_DEBUG").unwrap_or_default() == "1" {
-        set_hook(Box::new(|panic_info| {
-            let backtrace = Backtrace::new();
-            println!("Panic: {:?}\nBacktrace: {:?}", panic_info, backtrace);
-        }));
-    }
+    use std::{fs::OpenOptions, io};
+
+    set_hook(Box::new(|panic_info| {
+        // hold open this mutex guard to prevent concurrent writes to the file!
+        let mut last_error_time = LOG_THROTTLE.lock().unwrap();
+        if let Some(last_error_time) = last_error_time.as_ref() {
+            if last_error_time.elapsed().as_secs() < 1 {
+                // Throttle panic logging to once per second
+                return;
+            }
+        }
+        *last_error_time = Some(Instant::now());
+
+        let backtrace = Backtrace::new();
+        let info = format!("Panic: {}\nBacktrace: {:?}", panic_info, backtrace);
+        if cfg!(debug_assertions) || env::var("SWC_DEBUG") == Ok("1".to_string()) {
+            eprintln!("{}", info);
+        } else {
+            let size = std::fs::metadata(LOG_FILE_PATH).map(|m| m.len());
+            if let Ok(size) = size {
+                if size > 512 * 1024 {
+                    // Truncate the earliest error from log file if it's larger than 512KB
+                    let new_lines = {
+                        let log_read = OpenOptions::new()
+                            .read(true)
+                            .open(LOG_FILE_PATH)
+                            .unwrap_or_else(|_| panic!("Failed to open {}", LOG_FILE_PATH));
+
+                        io::BufReader::new(&log_read)
+                            .lines()
+                            .skip(1)
+                            .skip_while(|line| match line {
+                                Ok(line) => !line.starts_with("Panic:"),
+                                Err(_) => false,
+                            })
+                            .collect::<Vec<_>>()
+                    };
+
+                    let mut log_write = OpenOptions::new()
+                        .create(true)
+                        .truncate(true)
+                        .write(true)
+                        .open(LOG_FILE_PATH)
+                        .unwrap_or_else(|_| panic!("Failed to open {}", LOG_FILE_PATH));
+
+                    for line in new_lines {
+                        match line {
+                            Ok(line) => {
+                                writeln!(log_write, "{}", line).unwrap();
+                            }
+                            Err(_) => {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            let mut log_file = OpenOptions::new()
+                .create(true)
+                .append(true)
+                .open(LOG_FILE_PATH)
+                .unwrap_or_else(|_| panic!("Failed to open {}", LOG_FILE_PATH));
+
+            writeln!(log_file, "{}", info).unwrap();
+            eprintln!("{}: An unexpected Turbopack error occurred. Please report the content of {} to https://github.com/vercel/next.js/issues/new", "FATAL".red().bold(), LOG_FILE_PATH);
+        }
+    }));
 }
 
 #[inline]

packages/next/src/build/swc/index.ts

@@ -23,6 +23,7 @@ import {
 import type { PageExtensions } from '../page-extensions-type'
 import type { __ApiPreviewProps } from '../../server/api-utils'
 import { getReactCompilerLoader } from '../get-babel-loader-config'
+import { TurbopackInternalError } from '../../server/dev/turbopack-utils'
 
 const nextVersion = process.env.__NEXT_VERSION as string
 
@@ -796,7 +797,9 @@ function bindingToApi(
     try {
       return await fn()
     } catch (nativeError: any) {
-      throw new Error(nativeError.message, { cause: nativeError })
+      throw new TurbopackInternalError(nativeError.message, {
+        cause: nativeError,
+      })
     }
   }
 

packages/next/src/client/components/react-dev-overlay/internal/helpers/nodeStackFrames.ts

@@ -25,6 +25,16 @@ export function getFilesystemFrame(frame: StackFrame): StackFrame {
 }
 
 export function getServerError(error: Error, type: ErrorSourceType): Error {
+  if (error.name === 'TurbopackInternalError') {
+    // If this is an internal Turbopack error we shouldn't show internal details
+    // to the user. These are written to a log file instead.
+    const turbopackInternalError = new Error(
+      'An unexpected Turbopack error occurred. Please report the content of .next/turbopack.log to the Next.js team at https://github.com/vercel/next.js/issues/new'
+    )
+    decorateServerError(turbopackInternalError, type)
+    return turbopackInternalError
+  }
+
   let n: Error
   try {
     throw new Error(error.message)

packages/next/src/server/dev/turbopack-utils.ts

@@ -44,7 +44,23 @@ export async function getTurbopackJsConfig(
   return jsConfig ?? { compilerOptions: {} }
 }
 
-export class ModuleBuildError extends Error {}
+// An error generated from emitted Turbopack issues. This can include build
+// errors caused by issues with user code.
+export class ModuleBuildError extends Error {
+  name = 'ModuleBuildError'
+}
+
+// An error caused by an internal issue in Turbopack. These should be written
+// to a log file and details should not be shown to the user.
+export class TurbopackInternalError extends Error {
+  name = 'TurbopackInternalError'
+  cause: unknown
+
+  constructor(message: string, cause: unknown) {
+    super(message)
+    this.cause = cause
+  }
+}
 
 /**
  * Thin stopgap workaround layer to mimic existing wellknown-errors-plugin in webpack's build

packages/next/src/server/lib/router-utils/setup-dev-bundler.ts

@@ -79,7 +79,10 @@ import { createHotReloaderTurbopack } from '../../dev/hot-reloader-turbopack'
 import { getErrorSource } from '../../../shared/lib/error-source'
 import type { StackFrame } from 'next/dist/compiled/stacktrace-parser'
 import { generateEncryptionKeyBase64 } from '../../app-render/encryption-utils'
-import { ModuleBuildError } from '../../dev/turbopack-utils'
+import {
+  ModuleBuildError,
+  TurbopackInternalError,
+} from '../../dev/turbopack-utils'
 import { isMetadataRoute } from '../../../lib/metadata/is-metadata-route'
 import { normalizeMetadataPageToRoute } from '../../../lib/metadata/get-metadata-route'
 
@@ -1033,7 +1036,11 @@ function logError(
   type?: 'unhandledRejection' | 'uncaughtException' | 'warning' | 'app-dir'
 ) {
   if (err instanceof ModuleBuildError) {
+    // Errors that may come from issues from the user's code
     Log.error(err.message)
+  } else if (err instanceof TurbopackInternalError) {
+    // An internal Turbopack error that has been handled by next-swc, written
+    // to disk and a simplified message shown to user on the Rust side.
   } else if (type === 'warning') {
     Log.warn(err)
   } else if (type === 'app-dir') {