Flushing with timeout doesn't timeout and eventually crashes

[Vadorequest]

• Review the documentation: https://docs.sentry.io/
• Search for existing issues: https://github.com/getsentry/sentry-javascript/issues
• Use the latest release: https://github.com/getsentry/sentry-javascript/releases
• Provide a link to the affected event from your Sentry account

Package + Version

• @sentry/nextjs 6.9.0

Description

Using this code in a Next.js API:

import {captureException, flush, withSentry} from '@sentry/nextjs';

const handler = async () => {
 try {
 throw new Error(
 'This is a fake error meant to help testing Sentry error reporting (monitoring).'
 );
 } catch (e) {
 captureException(e);

 await flush(5000); // Need to flush on API to send errors properly (issue in @sentry/nextjs)
 }
};

export default withSentry(handler);

Calling the API endpoint runs until the Serverless function times out.
Providing a value to flush() doesn't seem to be effective.

[Vadorequest]

Also note I had to manually flush because if I don't, no error gets logged...

[Vadorequest]

I had forgotten to run res.end() at the end, that was the cause of the infinite loading.

But, the events don't show in Sentry nevertheless.

[kamilogorek]

@lobsterkatie this is 99% the issue that you already found here -

sentry-javascript/packages/nextjs/src/utils/handlers.ts

Lines 113 to 153 in ecfc3c7

	function wrapEndMethod(origEnd: ResponseEndMethod): WrappedResponseEndMethod {
	return async function newEnd(this: ScopedResponse, ...args: any[]) {
	// if the handler errored, it will have popped us out of the domain, so push the domain's scope onto the stack
	// just in case (if we *are* still in the domain, this will replace the current scope with a clone of itself,
	// which is effectively a no-op as long as we remember to pop it off when we're done)
	const currentHub = getCurrentHub();
	currentHub.pushScope(this.__sentryScope);
	const transaction = getActiveTransaction();
	console.log('Active transaction:', transaction?.name);
	if (transaction) {
	transaction.setHttpStatus(this.statusCode);
	// Push `transaction.finish` to the next event loop so open spans have a better chance of finishing before the
	// transaction closes, and make sure to wait until that's done before flushing events
	const transactionFinished: Promise<void> = new Promise(resolve => {
	setImmediate(() => {
	transaction.finish();
	resolve();
	});
	});
	await transactionFinished;
	}
	// flush the event queue to ensure that events get sent to Sentry before the response is finished and the lambda
	// ends
	try {
	logger.log('Flushing events...');
	await flush(2000);
	} catch (e) {
	logger.log(`Error while flushing events:\n${e}`);
	} finally {
	logger.log('Done flushing events');
	}
	// now that our work is done, we can pop off the scope and allow the response to end
	currentHub.popScope();
	return origEnd.call(this, ...args);
	};
	}

[lobsterkatie]

Yup - that's exactly it. There are still a few things in flux with that PR, but it should merge this week.