Revert "Ensure bail out on ssr error in static generation (#68764)"

This reverts commit 7d952ed.

packages/next/src/server/app-render/app-render.tsx

@@ -68,7 +68,6 @@ import {
   createHTMLReactServerErrorHandler,
   createHTMLErrorHandler,
   type DigestedError,
-  isUserLandError,
 } from './create-error-handler'
 import {
   getShortDynamicParamType,
@@ -977,14 +976,7 @@ async function renderToHTMLOrFlightImpl(
     // prerendering phase and the build.
     if (response.digestErrorsMap.size) {
       const buildFailingError = response.digestErrorsMap.values().next().value
-      if (buildFailingError) throw buildFailingError
-    }
-    // Pick first userland SSR error, which is also not a RSC error.
-    if (response.ssrErrors.length) {
-      const buildFailingError = response.ssrErrors.find((err) =>
-        isUserLandError(err)
-      )
-      if (buildFailingError) throw buildFailingError
+      throw buildFailingError
     }
 
     const options: RenderResultOptions = {
@@ -1237,37 +1229,34 @@ async function renderToStream(
 
   const reactServerErrorsByDigest: Map<string, DigestedError> = new Map()
   const silenceLogger = false
-  function onHTMLRenderRSCError(err: DigestedError) {
-    return renderOpts.onInstrumentationRequestError?.(
-      err,
-      req,
-      createErrorContext(ctx, 'react-server-components')
-    )
-  }
   const serverComponentsErrorHandler = createHTMLReactServerErrorHandler(
     !!renderOpts.dev,
     !!renderOpts.nextExport,
     reactServerErrorsByDigest,
     silenceLogger,
-    onHTMLRenderRSCError
+    // RSC rendering error will report as SSR error
+    // @TODO we should report RSC errors where they happen for instrumentation purposes
+    // and should omit the error reporter in the SSR layer instead
+    undefined
   )
-
-  function onHTMLRenderSSRError(err: DigestedError) {
+  function onServerRenderError(err: DigestedError) {
+    const renderSource = reactServerErrorsByDigest.has(err.digest)
+      ? 'react-server-components'
+      : 'server-rendering'
     return renderOpts.onInstrumentationRequestError?.(
       err,
       req,
-      createErrorContext(ctx, 'server-rendering')
+      createErrorContext(ctx, renderSource)
     )
   }
-
   const allCapturedErrors: Array<unknown> = []
   const htmlRendererErrorHandler = createHTMLErrorHandler(
     !!renderOpts.dev,
     !!renderOpts.nextExport,
     reactServerErrorsByDigest,
     allCapturedErrors,
     silenceLogger,
-    onHTMLRenderSSRError
+    onServerRenderError
   )
 
   let primaryRenderReactServerStream: null | ReadableStream<Uint8Array> = null
@@ -1586,7 +1575,6 @@ async function renderToStream(
 type PrenderToStringResult = {
   stream: ReadableStream<Uint8Array>
   digestErrorsMap: Map<string, DigestedError>
-  ssrErrors: Array<unknown>
   dynamicTracking?: null | DynamicTrackingState
   err?: unknown
 }
@@ -1651,26 +1639,24 @@ async function prerenderToStream(
   const reactServerErrorsByDigest: Map<string, DigestedError> = new Map()
   // We don't report errors during prerendering through our instrumentation hooks
   const silenceLogger = !!renderOpts.experimental.isRoutePPREnabled
-  function onHTMLRenderRSCError(err: DigestedError) {
-    return renderOpts.onInstrumentationRequestError?.(
-      err,
-      req,
-      createErrorContext(ctx, 'react-server-components')
-    )
-  }
   const serverComponentsErrorHandler = createHTMLReactServerErrorHandler(
     !!renderOpts.dev,
     !!renderOpts.nextExport,
     reactServerErrorsByDigest,
     silenceLogger,
-    onHTMLRenderRSCError
+    // RSC rendering error will report as SSR error
+    // @TODO we should report RSC errors where they happen for instrumentation purposes
+    // and should omit the error reporter in the SSR layer instead
+    undefined
   )
-
-  function onHTMLRenderSSRError(err: DigestedError) {
+  function onServerRenderError(err: DigestedError) {
+    const renderSource = reactServerErrorsByDigest.has(err.digest)
+      ? 'react-server-components'
+      : 'server-rendering'
     return renderOpts.onInstrumentationRequestError?.(
       err,
       req,
-      createErrorContext(ctx, 'server-rendering')
+      createErrorContext(ctx, renderSource)
     )
   }
   const allCapturedErrors: Array<unknown> = []
@@ -1680,7 +1666,7 @@ async function prerenderToStream(
     reactServerErrorsByDigest,
     allCapturedErrors,
     silenceLogger,
-    onHTMLRenderSSRError
+    onServerRenderError
   )
 
   let dynamicTracking: null | DynamicTrackingState = null
@@ -1804,7 +1790,6 @@ async function prerenderToStream(
         // require the same set so we unify the code path here
         return {
           digestErrorsMap: reactServerErrorsByDigest,
-          ssrErrors: allCapturedErrors,
           stream: await continueDynamicPrerender(prelude, {
             getServerInsertedHTML,
           }),
@@ -1852,7 +1837,6 @@ async function prerenderToStream(
 
         return {
           digestErrorsMap: reactServerErrorsByDigest,
-          ssrErrors: allCapturedErrors,
           stream: await continueStaticPrerender(htmlStream, {
             inlinedDataStream: createInlinedDataReadableStream(
               inlinedReactServerDataStream,
@@ -1922,7 +1906,6 @@ async function prerenderToStream(
       })
       return {
         digestErrorsMap: reactServerErrorsByDigest,
-        ssrErrors: allCapturedErrors,
         stream: await continueFizzStream(htmlStream, {
           inlinedDataStream: createInlinedDataReadableStream(
             inlinedReactServerDataStream,
@@ -2061,7 +2044,6 @@ async function prerenderToStream(
         // the response in the caller.
         err,
         digestErrorsMap: reactServerErrorsByDigest,
-        ssrErrors: allCapturedErrors,
         stream: await continueFizzStream(fizzStream, {
           inlinedDataStream: createInlinedDataReadableStream(
             // This is intentionally using the readable datastream from the

packages/next/src/server/app-render/create-error-handler.tsx

@@ -139,21 +139,19 @@ export function createHTMLErrorHandler(
   dev: boolean,
   isNextExport: boolean,
   reactServerErrors: Map<string, DigestedError>,
-  allCapturedErrors: Array<unknown>,
+  allCapturedError: Array<unknown>,
   silenceLogger: boolean,
-  onHTMLRenderSSRError: (err: any) => void
+  onHTMLRenderError: (err: any) => void
 ): ErrorHandler {
   return (err: any, errorInfo: any) => {
-    let isSSRError = true
-
     // If the error already has a digest, respect the original digest,
     // so it won't get re-generated into another new error.
+
     if (err.digest) {
       if (reactServerErrors.has(err.digest)) {
         // This error is likely an obfuscated error from react-server.
         // We recover the original error here.
         err = reactServerErrors.get(err.digest)
-        isSSRError = false
       } else {
         // The error is not from react-server but has a digest
         // from other means so we don't need to produce a new one
@@ -164,7 +162,7 @@ export function createHTMLErrorHandler(
       ).toString()
     }
 
-    allCapturedErrors.push(err)
+    allCapturedError.push(err)
 
     // If the response was closed, we don't need to log the error.
     if (isAbortError(err)) return
@@ -205,21 +203,11 @@ export function createHTMLErrorHandler(
         })
       }
 
-      if (
-        !silenceLogger &&
-        // HTML errors contain RSC errors as well, filter them out before reporting
-        isSSRError
-      ) {
-        onHTMLRenderSSRError(err)
+      if (!silenceLogger) {
+        onHTMLRenderError(err)
       }
     }
 
     return err.digest
   }
 }
-
-export function isUserLandError(err: any): boolean {
-  return (
-    !isAbortError(err) && !isBailoutToCSRError(err) && !isNextRouterError(err)
-  )
-}