Skip to content

🎥 Make videos programmatically with React

`@remotion/lambda`: Hide unused renderer logs link

Jonny Burger7baa42a71424
diff --git a/packages/lambda/src/cli/commands/render/render.ts b/packages/lambda/src/cli/commands/render/render.ts
index 15dfb52775..d148a3f218 100644
--- a/packages/lambda/src/cli/commands/render/render.ts
+++ b/packages/lambda/src/cli/commands/render/render.ts
@@ -382,6 +382,8 @@ export const renderCommand = async ({
const framesPerLambda = parsedLambdaCli['frames-per-lambda'] ?? undefined;
const concurrency = parsedLambdaCli['concurrency'] ?? undefined;
const concurrencyPerLambda = parsedLambdaCli['concurrency-per-lambda'] ?? 1;
+ const rendererFunctionName =
+ parsedLambdaCli['renderer-function-name'] ?? null;
const webhookCustomData = getWebhookCustomData(logLevel);
@@ -430,7 +432,7 @@ export const renderCommand = async ({
customData: webhookCustomData,
}
: null,
- rendererFunctionName: parsedLambdaCli['renderer-function-name'] ?? null,
+ rendererFunctionName,
forceBucketName: parsedLambdaCli['force-bucket-name'] ?? null,
audioCodec,
deleteAfter: deleteAfter ?? null,
@@ -560,11 +562,15 @@ export const renderCommand = async ({
url: res.cloudWatchMainLogs,
fallback: res.cloudWatchMainLogs,
}),
- CliInternals.makeHyperlink({
- text: `Renderer functions`,
- url: res.cloudWatchLogs,
- fallback: res.cloudWatchLogs,
- }),
+ ...(concurrency === 1 && rendererFunctionName === null
+ ? []
+ : [
+ CliInternals.makeHyperlink({
+ text: `Renderer functions`,
+ url: res.cloudWatchLogs,
+ fallback: res.cloudWatchLogs,
+ }),
+ ]),
);
Log.verbose(
{indent: false, logLevel},
diff --git a/packages/lambda/src/test/integration/cli-render-logs.test.ts b/packages/lambda/src/test/integration/cli-render-logs.test.ts
new file mode 100644
index 0000000000..ea11aa525f
--- /dev/null
+++ b/packages/lambda/src/test/integration/cli-render-logs.test.ts
@@ -0,0 +1,104 @@
+import {afterEach, beforeEach, expect, test} from 'bun:test';
+// eslint-disable-next-line no-restricted-imports
+import {CliInternals} from '@remotion/cli';
+import {LambdaClientInternals} from '@remotion/lambda-client';
+import {ServerlessRoutines} from '@remotion/serverless';
+import {parsedLambdaCli} from '../../cli/args';
+import {renderCommand} from '../../cli/commands/render/render';
+import {mockImplementation} from '../mocks/mock-implementation';
+import {doAfter, doBefore, getProcessWriteOutput} from './console-hooks';
+
+const enableCancellationOption = CliInternals.parsedCli['enable-cancellation'];
+const originalCallFunctionSync =
+ LambdaClientInternals.awsImplementation.callFunctionSync;
+const originalFunctionName = parsedLambdaCli['function-name'];
+const originalRegion = parsedLambdaCli.region;
+const originalConcurrency = parsedLambdaCli.concurrency;
+const originalRendererFunctionName = parsedLambdaCli['renderer-function-name'];
+
+beforeEach(() => {
+ doBefore();
+ CliInternals.parsedCli['enable-cancellation'] = false;
+ parsedLambdaCli['function-name'] = 'custom-function';
+ parsedLambdaCli.region = 'us-east-1';
+ parsedLambdaCli.concurrency = 1;
+ parsedLambdaCli['renderer-function-name'] = undefined;
+});
+
+afterEach(() => {
+ LambdaClientInternals.awsImplementation.callFunctionSync =
+ originalCallFunctionSync;
+ CliInternals.parsedCli['enable-cancellation'] = enableCancellationOption;
+ parsedLambdaCli['function-name'] = originalFunctionName;
+ parsedLambdaCli.region = originalRegion;
+ parsedLambdaCli.concurrency = originalConcurrency;
+ parsedLambdaCli['renderer-function-name'] = originalRendererFunctionName;
+ doAfter();
+});
+
+test('Only shows the main CloudWatch logs for a direct single-function render', async () => {
+ let resolveStatusRequested: () => void = () => undefined;
+ const statusRequested = new Promise<void>((resolve) => {
+ resolveStatusRequested = resolve;
+ });
+ const pendingStatus = new Promise<never>(() => undefined);
+
+ LambdaClientInternals.awsImplementation.callFunctionSync = ((input) => {
+ if (input.type === 'start') {
+ return Promise.resolve({bucketName: 'bucket', renderId: 'render-id'});
+ }
+
+ if (input.type === 'status') {
+ resolveStatusRequested();
+ return pendingStatus;
+ }
+
+ return Promise.reject(
+ new Error(`Unexpected Lambda routine: ${input.type}`),
+ );
+ }) as typeof originalCallFunctionSync;
+
+ let resolveExit: (exitCode: number) => void = () => undefined;
+ const exitCode = new Promise<number>((resolve) => {
+ resolveExit = resolve;
+ });
+ const unregisterCtrlC = CliInternals.handleCtrlC({
+ indent: false,
+ logLevel: 'verbose',
+ exit: resolveExit,
+ });
+
+ renderCommand({
+ args: ['https://example.com', 'composition-id'],
+ remotionRoot: process.cwd(),
+ logLevel: 'verbose',
+ providerSpecifics: mockImplementation,
+ }).catch(() => undefined);
+
+ try {
+ await statusRequested;
+ const output = getProcessWriteOutput();
+ const mainLogs = LambdaClientInternals.getCloudwatchMethodUrl({
+ region: 'us-east-1',
+ functionName: 'custom-function',
+ renderId: 'render-id',
+ rendererFunctionName: null,
+ method: ServerlessRoutines.launch,
+ });
+ const rendererLogs = LambdaClientInternals.getCloudwatchRendererUrl({
+ region: 'us-east-1',
+ functionName: 'custom-function',
+ renderId: 'render-id',
+ rendererFunctionName: null,
+ chunk: null,
+ });
+
+ expect(output).toContain(mainLogs);
+ expect(output).not.toContain(rendererLogs);
+
+ process.emit('SIGINT', 'SIGINT');
+ expect(await exitCode).toBe(130);
+ } finally {
+ unregisterCtrlC();
+ }
+});
diff --git a/packages/lambda/src/test/integration/console-hooks.ts b/packages/lambda/src/test/integration/console-hooks.ts
index 4e8e17e6ce..676fca40a2 100644
--- a/packages/lambda/src/test/integration/console-hooks.ts
+++ b/packages/lambda/src/test/integration/console-hooks.ts
@@ -26,14 +26,14 @@ export const doBefore = () => {
stdoutOutput.push(str);
};
- console.log = (str: string) => {
- // originalStdout(str);
- stdoutOutput.push(str);
+ console.log = (...args: unknown[]) => {
+ // originalStdout(args.join(' '));
+ stdoutOutput.push(args.map(String).join(' '));
};
- console.error = (str: string) => {
- // originalStderr(str);
- stderrOutput.push(str);
+ console.error = (...args: unknown[]) => {
+ // originalStderr(args.join(' '));
+ stderrOutput.push(args.map(String).join(' '));
};
// @ts-expect-error