@remotion/lambda 4.0.65 → 4.0.67

package/dist/functions/helpers/get-browser-instance.js

@@ -21,10 +21,10 @@ const waitForLaunched = () => {
     return new Promise((resolve, reject) => {
         const check = () => setTimeout(() => {
             if (launching) {
-                resolve();
+                check();
             }
             else {
-                check();
+                resolve();
             }
         }, 16);
         setTimeout(() => reject(new Error('Timeout launching browser')), 5000);
@@ -32,7 +32,7 @@ const waitForLaunched = () => {
     });
 };
 const forgetBrowserEventLoop = (logLevel) => {
-    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, 'Keeping browser open for next invocation');
+    renderer_1.RenderInternals.Log.infoAdvanced({ indent: false, logLevel }, 'Keeping browser open for next invocation');
     _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance.forgetEventLoop();
 };
 exports.forgetBrowserEventLoop = forgetBrowserEventLoop;
@@ -43,6 +43,7 @@ const getBrowserInstance = async (logLevel, indent, chromiumOptions) => {
         // Override the `null` value, which might come from CLI with swANGLE
         gl: (_a = chromiumOptions.gl) !== null && _a !== void 0 ? _a : 'swangle',
     };
+    const configurationString = makeConfigurationString(actualChromiumOptions, logLevel);
     if (launching) {
         renderer_1.RenderInternals.Log.info('Already waiting for browser launch...');
         await waitForLaunched();
@@ -50,7 +51,6 @@ const getBrowserInstance = async (logLevel, indent, chromiumOptions) => {
             throw new Error('expected to launch');
         }
     }
-    const configurationString = makeConfigurationString(actualChromiumOptions, logLevel);
     if (!_browserInstance) {
         renderer_1.RenderInternals.Log.info('Cold Lambda function, launching new Lambda function');
         launching = true;

package/dist/functions/helpers/get-current-region.d.ts

@@ -1 +1 @@
-export declare const getCurrentRegionInFunction: () => "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ca-central-1" | "sa-east-1" | "eu-south-1" | "af-south-1" | "ap-east-1" | "me-south-1";
+export declare const getCurrentRegionInFunction: () => "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-south-1" | "eu-north-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-south-1" | "ap-east-1" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ca-central-1" | "me-south-1" | "sa-east-1";

package/dist/functions/helpers/leak-detection.d.ts

@@ -0,0 +1,4 @@
+import type { NodeIntrospection } from '../../shared/why-is-node-running';
+export declare const stopLeakDetection: () => void;
+export declare const setCurrentRequestId: (awsRequestId: string) => void;
+export declare const startLeakDetection: (leakDetection: NodeIntrospection, awsRequestId: string) => void;

package/dist/functions/helpers/leak-detection.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLeakDetection = exports.setCurrentRequestId = exports.stopLeakDetection = void 0;
+const why_is_node_running_1 = require("../../shared/why-is-node-running");
+let currentRequestId = null;
+let leakDetectionTimeout = null;
+const stopLeakDetection = () => {
+    if (leakDetectionTimeout !== null) {
+        clearTimeout(leakDetectionTimeout.timeout);
+        leakDetectionTimeout = null;
+    }
+};
+exports.stopLeakDetection = stopLeakDetection;
+const setCurrentRequestId = (awsRequestId) => {
+    currentRequestId = awsRequestId;
+};
+exports.setCurrentRequestId = setCurrentRequestId;
+const startLeakDetection = (leakDetection, awsRequestId) => {
+    currentRequestId = awsRequestId;
+    leakDetectionTimeout = {
+        awsRequestId,
+        timeout: setTimeout(() => {
+            // First allow request ID to be set
+            setTimeout(() => {
+                if (currentRequestId !== awsRequestId) {
+                    // New function, all good
+                    return;
+                }
+                console.log('Leak detected: Lambda function is still running 10s after the render has finished.');
+                console.log('You may report this to the Remotion team.');
+                console.log('Include the logs below:');
+                (0, why_is_node_running_1.whyIsNodeRunning)(leakDetection);
+                console.log('Force-quitting the Lambda function now.');
+                process.exit(0);
+            }, 100);
+        }, 10000),
+    };
+    leakDetectionTimeout.timeout.unref();
+};
+exports.startLeakDetection = startLeakDetection;

package/dist/functions/helpers/request-context.d.ts

@@ -0,0 +1,5 @@
+export type RequestContext = {
+    invokedFunctionArn: string;
+    getRemainingTimeInMillis: () => number;
+    awsRequestId: string;
+};

package/dist/functions/helpers/request-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/functions/helpers/streaming-payloads.d.ts

@@ -4,16 +4,16 @@ declare const streamingPayloadSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     type: z.ZodLiteral<"render-id-determined">;
     renderId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    renderId: string;
     type: "render-id-determined";
-}, {
     renderId: string;
+}, {
     type: "render-id-determined";
+    renderId: string;
 }>]>;
 export type StreamingPayloads = z.infer<typeof streamingPayloadSchema>;
 export declare const isStreamingPayload: (str: string) => false | {
-    renderId: string;
     type: "render-id-determined";
+    renderId: string;
 };
 export declare const sendProgressEvent: (responseStream: ResponseStream, payload: StreamingPayloads) => void;
 export {};

package/dist/functions/index.js

@@ -6,6 +6,7 @@ const constants_1 = require("../shared/constants");
 const compositions_1 = require("./compositions");
 const clean_tmpdir_1 = require("./helpers/clean-tmpdir");
 const is_warm_1 = require("./helpers/is-warm");
+const leak_detection_1 = require("./helpers/leak-detection");
 const lifecycle_1 = require("./helpers/lifecycle");
 const print_cloudwatch_helper_1 = require("./helpers/print-cloudwatch-helper");
 const streamify_response_1 = require("./helpers/streamify-response");
@@ -18,8 +19,11 @@ const renderer_2 = require("./renderer");
 const start_1 = require("./start");
 const still_1 = require("./still");
 const innerHandler = async (params, responseStream, context) => {
+    (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
     const timeoutInMilliseconds = context.getRemainingTimeInMillis();
+    console.log('AWS Request ID:', context.awsRequestId);
+    (0, leak_detection_1.stopLeakDetection)();
     if (!(context === null || context === void 0 ? void 0 : context.invokedFunctionArn)) {
         throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
     }
@@ -108,7 +112,7 @@ const innerHandler = async (params, responseStream, context) => {
         const response = await (0, renderer_2.rendererHandler)(params, {
             expectedBucketOwner: currentUserId,
             isWarm,
-        });
+        }, context);
         responseStream.write(JSON.stringify(response), () => {
             responseStream.end();
         });

package/dist/functions/renderer.d.ts

@@ -1,9 +1,10 @@
 import type { LambdaPayload } from '../shared/constants';
+import type { RequestContext } from './helpers/request-context';
 type Options = {
     expectedBucketOwner: string;
     isWarm: boolean;
 };
-export declare const rendererHandler: (params: LambdaPayload, options: Options) => Promise<{
+export declare const rendererHandler: (params: LambdaPayload, options: Options, requestContext: RequestContext) => Promise<{
     type: 'success';
 }>;
 export {};

package/dist/functions/renderer.js

@@ -13,10 +13,12 @@ const chunk_progress_1 = require("../shared/chunk-progress");
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const is_flaky_error_1 = require("../shared/is-flaky-error");
+const why_is_node_running_1 = require("../shared/why-is-node-running");
 const get_browser_instance_1 = require("./helpers/get-browser-instance");
 const get_chromium_executable_path_1 = require("./helpers/get-chromium-executable-path");
 const get_current_region_1 = require("./helpers/get-current-region");
 const io_1 = require("./helpers/io");
+const leak_detection_1 = require("./helpers/leak-detection");
 const on_downloads_logger_1 = require("./helpers/on-downloads-logger");
 const write_lambda_error_1 = require("./helpers/write-lambda-error");
 const renderHandler = async (params, options, logs) => {
@@ -212,11 +214,12 @@ const renderHandler = async (params, options, logs) => {
     renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Done!');
     return {};
 };
-const rendererHandler = async (params, options) => {
+const rendererHandler = async (params, options, requestContext) => {
     if (params.type !== constants_1.LambdaRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
     const logs = [];
+    const leakDetection = (0, why_is_node_running_1.enableNodeIntrospection)();
     try {
         await renderHandler(params, options, logs);
         return {
@@ -275,6 +278,7 @@ const rendererHandler = async (params, options) => {
     }
     finally {
         (0, get_browser_instance_1.forgetBrowserEventLoop)(params.logLevel);
+        (0, leak_detection_1.startLeakDetection)(leakDetection, requestContext.awsRequestId);
     }
 };
 exports.rendererHandler = rendererHandler;

package/dist/internals.d.ts

@@ -1,5 +1,5 @@
 export declare const LambdaInternals: {
-    executeCommand: (args: string[], remotionRoot: string, logLevel: "error" | "verbose" | "info" | "warn") => Promise<void>;
+    executeCommand: (args: string[], remotionRoot: string, logLevel: "verbose" | "info" | "warn" | "error") => Promise<void>;
     makeLambdaRenderMediaPayload: ({ rendererFunctionName, frameRange, framesPerLambda, forceBucketName: bucketName, codec, composition, serveUrl, imageFormat, inputProps, region, crf, envVariables, pixelFormat, proResProfile, x264Preset, maxRetries, privacy, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, everyNthFrame, numberOfGifLoops, audioBitrate, concurrencyPerLambda, audioCodec, forceHeight, forceWidth, webhook, videoBitrate, downloadBehavior, muted, overwrite, jpegQuality, offthreadVideoCacheSizeInBytes, deleteAfter, colorSpace, }: import("./api/make-lambda-payload").InnerRenderMediaOnLambdaInput) => Promise<import("./defaults").LambdaStartPayload>;
     getRenderProgressPayload: ({ bucketName, renderId, s3OutputProvider, }: import(".").GetRenderProgressInput) => import("./defaults").LambdaStatusPayload;
 };

package/dist/shared/stackback.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+export declare const stackback: (error: Error) => NodeJS.CallSite[];
+declare global {
+    interface Error {
+        _sb_callsites: NodeJS.CallSite[];
+    }
+}

package/dist/shared/stackback.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stackback = void 0;
+function FormatStackTrace(error, frames) {
+    const lines = [];
+    try {
+        lines.push(error.toString());
+    }
+    catch (e) {
+        try {
+            lines.push('<error: ' + e + '>');
+        }
+        catch (ee) {
+            lines.push('<error>');
+        }
+    }
+    for (let i = 0; i < frames.length; i++) {
+        const frame = frames[i];
+        let line;
+        try {
+            line = frame.toString();
+        }
+        catch (e) {
+            try {
+                line = '<error: ' + e + '>';
+            }
+            catch (ee) {
+                // Any code that reaches this point is seriously nasty!
+                line = '<error>';
+            }
+        }
+        lines.push('    at ' + line);
+    }
+    return lines.join('\n');
+}
+const stackback = (error) => {
+    // save original stacktrace
+    const save = Error.prepareStackTrace;
+    // replace capture with our function
+    Error.prepareStackTrace = function (err, trace) {
+        // cache stack frames so we don't have to get them again
+        // use a non-enumerable property
+        Object.defineProperty(err, '_sb_callsites', {
+            value: trace,
+        });
+        return (save || FormatStackTrace)(err, trace);
+    };
+    // force capture of the stack frames
+    // eslint-disable-next-line no-unused-expressions
+    error.stack;
+    // someone already asked for the stack so we can't do this trick
+    if (!error._sb_callsites) {
+        return [];
+    }
+    // return original capture function
+    Error.prepareStackTrace = save;
+    return error._sb_callsites;
+};
+exports.stackback = stackback;

package/dist/shared/why-is-node-running.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import asyncHooks from 'async_hooks';
+type Resource = {
+    type: string;
+    stacks: NodeJS.CallSite[];
+    resource: {
+        hasRef?: () => boolean;
+    };
+};
+export type NodeIntrospection = {
+    hook: asyncHooks.AsyncHook;
+    active: Map<number, Resource>;
+};
+export declare const enableNodeIntrospection: () => NodeIntrospection;
+export declare function whyIsNodeRunning({ active, hook }: NodeIntrospection): void;
+export {};

package/dist/shared/why-is-node-running.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whyIsNodeRunning = exports.enableNodeIntrospection = void 0;
+const async_hooks_1 = __importDefault(require("async_hooks"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const stackback_1 = require("./stackback");
+const enableNodeIntrospection = () => {
+    const active = new Map();
+    const hook = async_hooks_1.default.createHook({
+        init(asyncId, type, _triggerAsyncId, resource) {
+            if (type === 'TIMERWRAP' || type === 'PROMISE')
+                return;
+            if (type === 'PerformanceObserver' || type === 'RANDOMBYTESREQUEST')
+                return;
+            const err = new Error('whatevs');
+            const stacks = (0, stackback_1.stackback)(err);
+            active.set(asyncId, { type, stacks, resource });
+        },
+        destroy(asyncId) {
+            active.delete(asyncId);
+        },
+    });
+    hook.enable();
+    return { hook, active };
+};
+exports.enableNodeIntrospection = enableNodeIntrospection;
+function whyIsNodeRunning({ active, hook }) {
+    hook.disable();
+    const activeResources = [...active.values()].filter((r) => {
+        if (typeof r.resource.hasRef === 'function' && !r.resource.hasRef())
+            return false;
+        return true;
+    });
+    console.error('There are %d handle(s) keeping the process running', activeResources.length);
+    function printStacks(o) {
+        const stacks = o.stacks.slice(1).filter((s) => {
+            const filename = s.getFileName();
+            return (filename &&
+                filename.indexOf(path_1.sep) > -1 &&
+                filename.indexOf('internal' + path_1.sep) !== 0);
+        });
+        console.error('');
+        console.error('# %s', o.type);
+        if (stacks[0]) {
+            let padding = '';
+            stacks.forEach((s) => {
+                const pad = (s.getFileName() + ':' + s.getLineNumber()).replace(/./g, ' ');
+                if (pad.length > padding.length)
+                    padding = pad;
+            });
+            stacks.forEach((s) => {
+                const prefix = s.getFileName() + ':' + s.getLineNumber();
+                try {
+                    const src = fs_1.default
+                        .readFileSync(s.getFileName(), 'utf-8')
+                        .split(/\n|\r\n/);
+                    console.error(prefix +
+                        padding.slice(prefix.length) +
+                        ' - ' +
+                        src[s.getLineNumber() - 1].trim());
+                }
+                catch (e) {
+                    console.error(prefix + padding.slice(prefix.length));
+                }
+            });
+        }
+        else {
+            console.error('(unknown stack trace)');
+        }
+    }
+    for (const o of activeResources) {
+        printStacks(o);
+    }
+}
+exports.whyIsNodeRunning = whyIsNodeRunning;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.65",
+  "version": "4.0.67",
   "description": "Distributed renderer for Remotion based on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -26,10 +26,10 @@
     "aws-policies": "^1.0.1",
     "mime-types": "2.1.34",
     "zod": "3.22.3",
-    "@remotion/bundler": "4.0.65",
-    "@remotion/cli": "4.0.65",
-    "@remotion/renderer": "4.0.65",
-    "remotion": "4.0.65"
+    "@remotion/bundler": "4.0.67",
+    "@remotion/cli": "4.0.67",
+    "@remotion/renderer": "4.0.67",
+    "remotion": "4.0.67"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.276",
@@ -43,11 +43,11 @@
     "ts-node": "^10.8.0",
     "vitest": "0.31.1",
     "zip-lib": "^0.7.2",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.65",
-    "@remotion/bundler": "4.0.65"
+    "@remotion/bundler": "4.0.67",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.67"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.65"
+    "@remotion/bundler": "4.0.67"
   },
   "publishConfig": {
     "access": "public"