@remotion/serverless 4.0.425 → 4.0.426

package/dist/handlers/launch.js

@@ -343,7 +343,7 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
                 willRetry: false,
                 totalAttempts: 1,
             });
-            overallProgress.upload();
+            overallProgress.upload('artifactWriteError');
             renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to write artifact to S3', err);
         });
         return { alreadyExisted: false };
@@ -488,7 +488,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
                 willRetry: false,
                 totalAttempts: 1,
             });
-            overallProgress.upload();
+            overallProgress.upload('timeoutWebhookError');
         }
     };
     let webhookInvoked = false;
@@ -565,7 +565,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
                 willRetry: false,
                 totalAttempts: 1,
             });
-            overallProgress.upload();
+            overallProgress.upload('successWebhookError');
             renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke webhook:');
             renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err);
         }
@@ -589,7 +589,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
             willRetry: false,
             message: err.message,
         });
-        await overallProgress.upload();
+        await overallProgress.upload('fatalError');
         runCleanupTasks();
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Wrote error to S3');
         clearTimeout(webhookDueToTimeout);
@@ -633,7 +633,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
                     willRetry: false,
                     totalAttempts: 1,
                 });
-                overallProgress.upload();
+                overallProgress.upload('errorWebhookError');
                 renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke webhook:');
                 renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, error);
             }

package/dist/merge-chunks.js

@@ -89,7 +89,7 @@ const mergeChunksAndFinishRender = async (options) => {
         timeToFinish: Date.now() - options.startTime,
         providerSpecifics: options.providerSpecifics,
     });
-    options.overallProgress.setPostRenderData(postRenderData);
+    await options.overallProgress.setPostRenderData(postRenderData);
     fs_1.default.unlinkSync(outfile);
     await cleanupChunksProm;
     return postRenderData;

package/dist/overall-render-progress.d.ts

@@ -1,6 +1,6 @@
 import type { ChunkRetry, CloudProvider, FunctionErrorInfo, OverallRenderProgress, PostRenderData, ProviderSpecifics, ReceivedArtifact, RenderMetadata } from '@remotion/serverless-client';
 export type OverallProgressHelper<Provider extends CloudProvider> = {
-    upload: () => Promise<void>;
+    upload: (reason: string) => Promise<void>;
     setFrames: ({ encoded, rendered, index }: {
         rendered: number;
         encoded: number;
@@ -11,7 +11,7 @@ export type OverallProgressHelper<Provider extends CloudProvider> = {
     setCombinedFrames: (framesEncoded: number) => void;
     setTimeToCombine: (timeToCombine: number) => void;
     addRetry: (retry: ChunkRetry) => void;
-    setPostRenderData: (postRenderData: PostRenderData<Provider>) => void;
+    setPostRenderData: (postRenderData: PostRenderData<Provider>) => Promise<void>;
     setRenderMetadata: (renderMetadata: RenderMetadata<Provider>) => void;
     addErrorWithoutUpload: (errorInfo: FunctionErrorInfo) => void;
     setExpectedChunks: (expectedChunks: number) => void;

package/dist/overall-render-progress.js

@@ -31,51 +31,57 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
     let framesEncoded = [];
     let lambdasInvoked = [];
     const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp);
-    let currentUploadPromise = null;
-    const getCurrentProgress = () => renderProgress;
-    let latestUploadRequest = 0;
-    const getLatestRequestId = () => latestUploadRequest;
+    let dirty = false;
+    let dirtyReasons = [];
+    let uploadLoopPromise = null;
     let encodeStartTime = null;
     let renderFramesStartTime = null;
-    const upload = async () => {
-        const uploadRequestId = ++latestUploadRequest;
-        if (currentUploadPromise) {
-            await currentUploadPromise;
+    const markDirty = (reason) => {
+        dirty = true;
+        dirtyReasons.push(reason);
+    };
+    const runUploadLoop = async () => {
+        while (dirty) {
+            dirty = false;
+            const reasons = dirtyReasons.join(', ');
+            dirtyReasons = [];
+            const toWrite = JSON.stringify(renderProgress);
+            renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Uploading progress - ${reasons} (${toWrite.length} bytes)`);
+            const start = Date.now();
+            try {
+                await providerSpecifics.writeFile({
+                    body: toWrite,
+                    bucketName,
+                    customCredentials: null,
+                    downloadBehavior: null,
+                    expectedBucketOwner,
+                    key: (0, serverless_client_1.overallProgressKey)(renderId),
+                    privacy: 'private',
+                    region,
+                    forcePathStyle,
+                    storageClass: null,
+                    requestHandler: null,
+                });
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Uploaded progress in ${Date.now() - start}ms`);
+                // Space out the requests a bit
+                await new Promise((resolve) => {
+                    setTimeout(resolve, Math.max(0, 250 - (Date.now() - start)));
+                });
+            }
+            catch (err) {
+                // If an error occurs in uploading the state that contains the errors,
+                // that is unfortunate. We just log it.
+                renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Error uploading progress', err);
+            }
         }
-        // If request has been replaced by a new one
-        if (getLatestRequestId() !== uploadRequestId) {
-            return;
+        uploadLoopPromise = null;
+    };
+    const upload = async (reason) => {
+        markDirty(reason);
+        if (!uploadLoopPromise) {
+            uploadLoopPromise = runUploadLoop();
         }
-        const toWrite = JSON.stringify(getCurrentProgress());
-        const start = Date.now();
-        currentUploadPromise = providerSpecifics
-            .writeFile({
-            body: toWrite,
-            bucketName,
-            customCredentials: null,
-            downloadBehavior: null,
-            expectedBucketOwner,
-            key: (0, serverless_client_1.overallProgressKey)(renderId),
-            privacy: 'private',
-            region,
-            forcePathStyle,
-            storageClass: null,
-            requestHandler: null,
-        })
-            .then(() => {
-            // By default, upload is way too fast (~20 requests per second)
-            // Space out the requests a bit
-            return new Promise((resolve) => {
-                setTimeout(resolve, Math.max(0, 250 - (Date.now() - start)));
-            });
-        })
-            .catch((err) => {
-            // If an error occurs in uploading the state that contains the errors,
-            // that is unfortunate. We just log it.
-            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Error uploading progress', err);
-        });
-        await currentUploadPromise;
-        currentUploadPromise = null;
+        await uploadLoopPromise;
     };
     return {
         upload,
@@ -108,7 +114,7 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
             }
             renderProgress.framesRendered = totalFramesRendered;
             renderProgress.framesEncoded = totalFramesEncoded;
-            upload();
+            upload(`setFrames(rendered=${totalFramesRendered}, encoded=${totalFramesEncoded})`);
         },
         addChunkCompleted: (chunkIndex, start, rendered) => {
             var _a;
@@ -123,15 +129,15 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
                 start,
                 rendered,
             });
-            upload();
+            upload(`addChunkCompleted(chunk=${chunkIndex})`);
         },
         setCombinedFrames: (frames) => {
             renderProgress.combinedFrames = frames;
-            upload();
+            upload(`setCombinedFrames(${frames})`);
         },
         setTimeToCombine: (timeToCombine) => {
             renderProgress.timeToCombine = timeToCombine;
-            upload();
+            upload(`setTimeToCombine(${timeToCombine})`);
         },
         setLambdaInvoked(chunk) {
             if (lambdasInvoked.length === 0) {
@@ -139,15 +145,15 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
             }
             lambdasInvoked[chunk] = true;
             renderProgress.lambdasInvoked = lambdasInvoked.reduce((a, b) => a + Number(b), 0);
-            upload();
+            upload(`setLambdaInvoked(chunk=${chunk})`);
         },
-        setPostRenderData(postRenderData) {
+        async setPostRenderData(postRenderData) {
             renderProgress.postRenderData = postRenderData;
-            upload();
+            await upload('setPostRenderData');
         },
         setRenderMetadata: (renderMetadata) => {
             renderProgress.renderMetadata = renderMetadata;
-            upload();
+            upload('setRenderMetadata');
         },
         addErrorWithoutUpload: (errorInfo) => {
             renderProgress.errors.push(errorInfo);
@@ -159,19 +165,19 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
         },
         setCompositionValidated(timestamp) {
             renderProgress.compositionValidated = timestamp;
-            upload();
+            upload('setCompositionValidated');
         },
         setServeUrlOpened(timestamp) {
             renderProgress.serveUrlOpened = timestamp;
-            upload();
+            upload('setServeUrlOpened');
         },
         addRetry(retry) {
             renderProgress.retries.push(retry);
-            upload();
+            upload('addRetry');
         },
         addReceivedArtifact(asset) {
             renderProgress.receivedArtifact.push(asset);
-            upload();
+            upload('addReceivedArtifact');
         },
         getReceivedArtifacts() {
             return renderProgress.receivedArtifact;

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/serverless"
 	},
 	"name": "@remotion/serverless",
-	"version": "4.0.425",
+	"version": "4.0.426",
 	"description": "A runtime for distributed rendering",
 	"main": "dist",
 	"sideEffects": false,
@@ -23,13 +23,13 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@remotion/renderer": "4.0.425",
-		"@remotion/bundler": "4.0.425",
-		"@remotion/licensing": "4.0.425",
-		"@remotion/serverless-client": "4.0.425"
+		"@remotion/renderer": "4.0.426",
+		"@remotion/bundler": "4.0.426",
+		"@remotion/licensing": "4.0.426",
+		"@remotion/serverless-client": "4.0.426"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.425",
+		"@remotion/eslint-config-internal": "4.0.426",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},