@remotion/lambda 4.0.63 → 4.0.66

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/renderer.js

@@ -13,16 +13,22 @@ 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 on_downloads_logger_1 = require("./helpers/on-downloads-logger");
 const write_lambda_error_1 = require("./helpers/write-lambda-error");
+let leakDetectionTimeout = null;
 const renderHandler = async (params, options, logs) => {
     if (params.type !== constants_1.LambdaRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
+    if (leakDetectionTimeout !== null) {
+        clearTimeout(leakDetectionTimeout);
+        leakDetectionTimeout = null;
+    }
     if (params.launchFunctionConfig.version !== version_1.VERSION) {
         throw new Error(`The version of the function that was specified as "rendererFunctionName" is ${version_1.VERSION} but the version of the function that invoked the render is ${params.launchFunctionConfig.version}. Please make sure that the version of the function that is specified as "rendererFunctionName" is the same as the version of the function that is invoked.`);
     }
@@ -217,6 +223,7 @@ const rendererHandler = async (params, options) => {
         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 +282,15 @@ const rendererHandler = async (params, options) => {
     }
     finally {
         (0, get_browser_instance_1.forgetBrowserEventLoop)(params.logLevel);
+        leakDetectionTimeout = setTimeout(() => {
+            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);
+        }, 10000);
+        leakDetectionTimeout.unref();
     }
 };
 exports.rendererHandler = rendererHandler;

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;
+    };
+};
+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.63",
+  "version": "4.0.66",
   "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.63",
-    "@remotion/renderer": "4.0.63",
-    "remotion": "4.0.63",
-    "@remotion/cli": "4.0.63"
+    "@remotion/bundler": "4.0.66",
+    "@remotion/cli": "4.0.66",
+    "remotion": "4.0.66",
+    "@remotion/renderer": "4.0.66"
   },
   "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/bundler": "4.0.63",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.63"
+    "@remotion/bundler": "4.0.66",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.66"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.63"
+    "@remotion/bundler": "4.0.66"
   },
   "publishConfig": {
     "access": "public"