Skip to content

🎥 Make videos programmatically with React

`@remotion/lambda`: Return errors from buffered invocations (#10557)

Jonny Burgerb5a6370547e4
diff --git a/packages/lambda/src/functions/index.ts b/packages/lambda/src/functions/index.ts
index 8bbc576184..550d688649 100644
--- a/packages/lambda/src/functions/index.ts
+++ b/packages/lambda/src/functions/index.ts
@@ -5,7 +5,12 @@ import type {
ResponseStream,
ServerlessPayload,
} from '@remotion/serverless';
-import {innerHandler, streamWriter} from '@remotion/serverless';
+import {
+ innerHandler,
+ innerRoutine,
+ ServerlessRoutines,
+ streamWriter,
+} from '@remotion/serverless';
import {serverAwsImplementation} from './aws-server-implementation';
import {streamifyResponse} from './helpers/streamify-response';
@@ -16,7 +21,14 @@ export const routine = (
): Promise<void> => {
const responseWriter = streamWriter(responseStream);
- return innerHandler({
+ const handle =
+ params.type === ServerlessRoutines.info ||
+ params.type === ServerlessRoutines.start ||
+ params.type === ServerlessRoutines.compositions
+ ? innerRoutine
+ : innerHandler;
+
+ return handle({
params,
responseWriter,
context,
diff --git a/packages/lambda/src/test/unit/routine.test.ts b/packages/lambda/src/test/unit/routine.test.ts
new file mode 100644
index 0000000000..c2b1346509
--- /dev/null
+++ b/packages/lambda/src/test/unit/routine.test.ts
@@ -0,0 +1,48 @@
+import {expect, test} from 'bun:test';
+import {
+ ResponseStream,
+ ServerlessRoutines,
+ VERSION,
+} from '@remotion/serverless';
+import {routine} from '../../functions';
+
+test('buffered routines serialize exceptions and end the response', async () => {
+ for (const type of [
+ ServerlessRoutines.info,
+ ServerlessRoutines.start,
+ ServerlessRoutines.compositions,
+ ]) {
+ const responseStream = new ResponseStream();
+
+ await routine(
+ {
+ type,
+ version: VERSION,
+ logLevel: 'error',
+ } as never,
+ responseStream,
+ {
+ awsRequestId: 'request-id',
+ invokedFunctionArn: '',
+ getRemainingTimeInMillis: () => 120_000,
+ },
+ );
+
+ expect(responseStream.writableEnded).toBe(true);
+ const response = JSON.parse(
+ new TextDecoder().decode(responseStream.getBufferedData()),
+ ) as {
+ type: string;
+ message: string;
+ stack: string;
+ };
+ expect(response).toMatchObject({
+ type: 'error',
+ message:
+ 'Lambda function unexpectedly does not have context.invokedFunctionArn',
+ });
+ expect(response.stack).toContain(
+ 'Error: Lambda function unexpectedly does not have context.invokedFunctionArn',
+ );
+ }
+});
diff --git a/packages/serverless/src/index.ts b/packages/serverless/src/index.ts
index 094cffbb12..f43d4bc32b 100644
--- a/packages/serverless/src/index.ts
+++ b/packages/serverless/src/index.ts
@@ -6,15 +6,18 @@ export {
export {compositionsHandler} from './handlers/compositions';
export {launchHandler} from './handlers/launch';
export {progressHandler} from './handlers/progress';
-export {RequestContext, rendererHandler} from './handlers/renderer';
+export {type RequestContext, rendererHandler} from './handlers/renderer';
export {startHandler} from './handlers/start';
export {stillHandler} from './handlers/still';
export {infoHandler} from './info';
-export {innerHandler} from './inner-routine';
+export {innerHandler, innerRoutine} from './inner-routine';
export {invokeWebhook} from './invoke-webhook';
export {setCurrentRequestId, stopLeakDetection} from './leak-detection';
export * from './provider-implementation';
export {ResponseStream} from './streaming/response-stream';
-export {ResponseStreamWriter, streamWriter} from './streaming/stream-writer';
+export {
+ type ResponseStreamWriter,
+ streamWriter,
+} from './streaming/stream-writer';
export {validateComposition} from './validate-composition';
diff --git a/packages/serverless/src/inner-routine.ts b/packages/serverless/src/inner-routine.ts
index 273831f08e..0ad6b945a5 100644
--- a/packages/serverless/src/inner-routine.ts
+++ b/packages/serverless/src/inner-routine.ts
@@ -191,11 +191,15 @@ export const innerHandler = async <Provider extends CloudProvider>({
} catch (err) {
// eslint-disable-next-line no-console
console.log({err});
+ const response: OrError<0> = {
+ type: 'error',
+ message: (err as Error).message,
+ stack: (err as Error).stack as string,
+ };
await responseWriter.write(
- new TextEncoder().encode(
- JSON.stringify({type: 'error', message: (err as Error).stack}),
- ),
+ new TextEncoder().encode(JSON.stringify(response)),
);
+ await responseWriter.end();
return;
}
}
diff --git a/packages/serverless/src/test/inner-routine.test.ts b/packages/serverless/src/test/inner-routine.test.ts
index 5f8b013e76..b3d0b6a01f 100644
--- a/packages/serverless/src/test/inner-routine.test.ts
+++ b/packages/serverless/src/test/inner-routine.test.ts
@@ -4,7 +4,7 @@ import type {
ProviderSpecifics,
} from '@remotion/serverless-client';
import {VERSION} from '@remotion/serverless-client';
-import {innerHandler} from '../inner-routine';
+import {innerHandler, innerRoutine} from '../inner-routine';
import type {InsideFunctionSpecifics} from '../provider-implementation';
type MockProvider = CloudProvider<
@@ -74,3 +74,56 @@ test('buffered still errors are written to the response', async () => {
'Error: downloadBehavior must be null or an object',
);
});
+
+test('buffered render start exceptions are written to the response', async () => {
+ const chunks: Uint8Array[] = [];
+ let ended = false;
+
+ await innerRoutine<MockProvider>({
+ params: {
+ type: 'start',
+ version: VERSION,
+ logLevel: 'error',
+ deleteAfter: null,
+ } as never,
+ responseWriter: {
+ write: (message) => {
+ chunks.push(message);
+ return Promise.resolve();
+ },
+ end: () => {
+ ended = true;
+ return Promise.resolve();
+ },
+ },
+ context: {
+ awsRequestId: 'request-id',
+ invokedFunctionArn:
+ 'arn:aws:lambda:mock-region:123456789012:function:test',
+ getRemainingTimeInMillis: () => 120_000,
+ },
+ providerSpecifics: {
+ printLoggingHelper: false,
+ randomHash: () => 'random-hash',
+ } as unknown as ProviderSpecifics<MockProvider>,
+ insideFunctionSpecifics: {
+ deleteTmpDir: () => Promise.resolve(),
+ generateRandomId: () => {
+ throw new Error('Could not generate a render ID');
+ },
+ } as unknown as InsideFunctionSpecifics<MockProvider>,
+ });
+
+ expect(ended).toBe(true);
+ expect(chunks).toHaveLength(1);
+ const response = JSON.parse(new TextDecoder().decode(chunks[0])) as {
+ type: string;
+ message: string;
+ stack: string;
+ };
+ expect(response).toMatchObject({
+ type: 'error',
+ message: 'Could not generate a render ID',
+ });
+ expect(response.stack).toContain('Error: Could not generate a render ID');
+});