Unverified Commit 6c7f57a4 authored by vercel-fleet-prod[bot]'s avatar vercel-fleet-prod[bot] Committed by GitHub

fix: drain diagnostics only for failed builds

Co-authored-by: 's avatarTobias Koppers <1365881+sokra@users.noreply.github.com>
parent a038ddb2
...@@ -1068,6 +1068,7 @@ export default async function build( ...@@ -1068,6 +1068,7 @@ export default async function build(
let loadedConfig: NextConfigComplete | undefined let loadedConfig: NextConfigComplete | undefined
let staticWorker: StaticWorker let staticWorker: StaticWorker
let buildFailed = false
// Turbopack compile warnings are deferred until after static generation. // Turbopack compile warnings are deferred until after static generation.
let deferredTurbopackWarnings: string[] | undefined let deferredTurbopackWarnings: string[] | undefined
...@@ -4293,7 +4294,7 @@ export default async function build( ...@@ -4293,7 +4294,7 @@ export default async function build(
// When output: export we want to end the worker later as it's still used for writeFullyStaticExport // When output: export we want to end the worker later as it's still used for writeFullyStaticExport
if (config.output !== 'export') { if (config.output !== 'export') {
// ensure the worker is not left hanging // ensure the worker is not left hanging
await staticWorker?.end() staticWorker?.end()
staticWorker = undefined! // Reset staticWorker to make sure it does not end in `finally` staticWorker = undefined! // Reset staticWorker to make sure it does not end in `finally`
} }
...@@ -4528,7 +4529,7 @@ export default async function build( ...@@ -4528,7 +4529,7 @@ export default async function build(
if (config.output === 'export') { if (config.output === 'export') {
// TODO: When writeFullyStaticExport doesn't fail when staticWorker is passed moved this after writeFullyStaticExport. // TODO: When writeFullyStaticExport doesn't fail when staticWorker is passed moved this after writeFullyStaticExport.
// End the worker here when it's output: export. // End the worker here when it's output: export.
await staticWorker.end() staticWorker.end()
staticWorker = undefined! // Reset staticWorker to make sure it does not end in `finally` staticWorker = undefined! // Reset staticWorker to make sure it does not end in `finally`
await nextBuildSpan await nextBuildSpan
...@@ -4676,6 +4677,7 @@ export default async function build( ...@@ -4676,6 +4677,7 @@ export default async function build(
} }
}) })
} catch (e) { } catch (e) {
buildFailed = true
const telemetry: Telemetry | undefined = traceGlobals.get('telemetry') const telemetry: Telemetry | undefined = traceGlobals.get('telemetry')
if (telemetry) { if (telemetry) {
telemetry.record( telemetry.record(
...@@ -4690,7 +4692,11 @@ export default async function build( ...@@ -4690,7 +4692,11 @@ export default async function build(
} finally { } finally {
// @ts-expect-error Existence of staticWorker is checked here intentionally. // @ts-expect-error Existence of staticWorker is checked here intentionally.
if (staticWorker) { if (staticWorker) {
await staticWorker.end() if (buildFailed) {
await staticWorker.endGracefully()
} else {
staticWorker.end()
}
} }
// Ensure we wait for lockfile patching if present // Ensure we wait for lockfile patching if present
await lockfilePatchPromise.cur await lockfilePatchPromise.cur
......
...@@ -156,12 +156,20 @@ describe('lib/worker shutdown', () => { ...@@ -156,12 +156,20 @@ describe('lib/worker shutdown', () => {
latestKill = undefined latestKill = undefined
}) })
it('waits for stdout and stderr to drain without interrupting the worker', async () => { it('retains interrupt-driven shutdown by default', async () => {
const { Worker } = require('./worker') as typeof import('./worker')
const worker = new Worker(__filename, noopOptions)
await expect(worker.end()).resolves.toEqual({ forceExited: false })
expect(latestKill).toHaveBeenCalledWith('SIGINT')
})
it('gracefully waits for stdout and stderr to drain', async () => {
const { Worker } = require('./worker') as typeof import('./worker') const { Worker } = require('./worker') as typeof import('./worker')
const worker = new Worker(__filename, noopOptions) const worker = new Worker(__filename, noopOptions)
let didEnd = false let didEnd = false
const endPromise = worker.end().then((result) => { const endPromise = worker.endGracefully().then((result) => {
didEnd = true didEnd = true
return result return result
}) })
...@@ -179,16 +187,16 @@ describe('lib/worker shutdown', () => { ...@@ -179,16 +187,16 @@ describe('lib/worker shutdown', () => {
await expect(endPromise).resolves.toEqual({ forceExited: false }) await expect(endPromise).resolves.toEqual({ forceExited: false })
}) })
it('bounds the output drain wait', async () => { it('bounds the graceful output drain wait', async () => {
jest.useFakeTimers() jest.useFakeTimers()
const { Worker } = require('./worker') as typeof import('./worker') const { Worker } = require('./worker') as typeof import('./worker')
const worker = new Worker(__filename, noopOptions) const worker = new Worker(__filename, noopOptions)
const endPromise = worker.end() const endPromise = worker.endGracefully()
await Promise.resolve() await Promise.resolve()
jest.advanceTimersByTime(1000) jest.advanceTimersByTime(1000)
await expect(endPromise).resolves.toEqual({ forceExited: false }) await expect(endPromise).resolves.toEqual({ forceExited: false })
expect(latestKill).toHaveBeenCalledWith('SIGINT') expect(latestKill).not.toHaveBeenCalled()
}) })
}) })
...@@ -24,28 +24,23 @@ const cleanupWorkers = (worker: JestWorker) => { ...@@ -24,28 +24,23 @@ const cleanupWorkers = (worker: JestWorker) => {
const WORKER_STDIO_DRAIN_TIMEOUT_MS = 1000 const WORKER_STDIO_DRAIN_TIMEOUT_MS = 1000
const waitForStreamEnd = ( const waitForStreamEnd = (stream: NodeJS.ReadableStream): Promise<void> => {
stream: NodeJS.ReadableStream,
signal: AbortSignal
): Promise<boolean> => {
const readable = stream as Readable const readable = stream as Readable
if (readable.readableEnded || readable.destroyed) { if (readable.readableEnded || readable.destroyed) {
return Promise.resolve(true) return Promise.resolve()
} }
return new Promise((resolve) => { return new Promise((resolve) => {
const finish = (didDrain: boolean) => { const finish = () => {
stream.off('end', onEnd) clearTimeout(timeout)
stream.off('close', onEnd) stream.off('end', finish)
signal.removeEventListener('abort', onAbort) stream.off('close', finish)
resolve(didDrain) resolve()
} }
const onEnd = () => finish(true) const timeout = setTimeout(finish, WORKER_STDIO_DRAIN_TIMEOUT_MS)
const onAbort = () => finish(false)
stream.once('end', onEnd) stream.once('end', finish)
stream.once('close', onEnd) stream.once('close', finish)
signal.addEventListener('abort', onAbort, { once: true })
}) })
} }
...@@ -319,42 +314,31 @@ export class Worker { ...@@ -319,42 +314,31 @@ export class Worker {
this._onActivityAbort = onActivityAbort this._onActivityAbort = onActivityAbort
} }
async end(): ReturnType<JestWorker['end']> { end(): ReturnType<JestWorker['end']> {
const worker = this._worker const worker = this._worker
if (!worker) { if (!worker) {
throw new Error('Farm is ended, no more calls can be done to it') throw new Error('Farm is ended, no more calls can be done to it')
} }
cleanupWorkers(worker)
// Worker method results and stdio use separate IPC channels. A method can
// resolve before its final output reaches the parent, so start observing
// both streams before asking jest-worker to shut down.
const outputStreams = [worker.getStdout(), worker.getStderr()]
const drainController = new AbortController()
const outputEnded = Promise.all(
outputStreams.map((stream) =>
waitForStreamEnd(stream, drainController.signal)
)
)
this._worker = undefined this._worker = undefined
let result: Awaited<ReturnType<JestWorker['end']>> return worker.end()
try { }
result = await worker.end()
} catch (error) {
drainController.abort()
throw error
}
const drainTimeout = setTimeout(
() => drainController.abort(),
WORKER_STDIO_DRAIN_TIMEOUT_MS
)
const didDrain = await outputEnded
clearTimeout(drainTimeout)
if (didDrain.includes(false)) { /**
cleanupWorkers(worker) * Shuts down without interrupting the worker so a failed build can preserve
* its trailing diagnostics. Successful builds use `end()` to retain their
* existing shutdown behavior.
*/
async endGracefully(): ReturnType<JestWorker['end']> {
const worker = this._worker
if (!worker) {
throw new Error('Farm is ended, no more calls can be done to it')
} }
const outputStreams = [worker.getStdout(), worker.getStderr()]
this._worker = undefined
const result = await worker.end()
await Promise.all(outputStreams.map(waitForStreamEnd))
return result return result
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment