@vidtreo/recorder 1.7.4 → 1.7.6

package/dist/index.js

@@ -3075,7 +3075,6 @@ var DEFAULT_RETENTION_HOURS = 24;
 var MAX_RETRIES = 10;
 var MILLISECONDS_PER_HOUR = 60 * 60 * 1000;
 var ID_PREFIX = "upload-";
-var ID_RANDOM_LENGTH = 9;
 var VERSION_ERROR_NAME = "VersionError";
 var ERROR_SCHEMA_MISSING_STORE = "Database schema is missing required object store: pending-uploads";
 var ERROR_SCHEMA_MISSING_STATUS_INDEX = "Database schema is missing required index: status";
@@ -3371,7 +3370,7 @@ class VideoStorageService {
     });
   }
   generateUploadId() {
-    return `${ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 2 + ID_RANDOM_LENGTH)}`;
+    return `${ID_PREFIX}${crypto.randomUUID()}`;
   }
   executeTransaction(mode, operation) {
     if (!this.db) {
@@ -6312,7 +6311,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.7.4",
+  version: "1.7.6",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -6452,6 +6451,8 @@ var TELEMETRY_EVENT_CATEGORY_MAP = {
   "recording.stop.failed": "error",
   "recording.route.selected": "lifecycle",
   "upload.started": "performance",
+  "upload.attempt.failed": "error",
+  "upload.retry.scheduled": "performance",
   "upload.succeeded": "performance",
   "upload.failed": "error",
   "upload.route.selected": "lifecycle",
@@ -7188,6 +7189,12 @@ class UploadQueueManager {
     return Object.entries(expected).every(([key, value]) => actual[key] === value);
   }
   async processUpload(upload, shouldThrowOnError = false) {
+    const attempt = upload.retryCount + 1;
+    let progressDetails = {
+      progress: 0,
+      loadedBytes: 0,
+      totalBytes: 0
+    };
     try {
       await this.storageService.updateUploadStatus(upload.id, {
         status: "uploading"
@@ -7196,29 +7203,58 @@ class UploadQueueManager {
         apiKey: upload.apiKey,
         backendUrl: upload.backendUrl,
         filename: upload.filename,
+        idempotencyKey: upload.id,
         mimeType: upload.mimeType,
         metadata: upload.metadata,
         userMetadata: upload.userMetadata,
         onProgress: (progress) => {
           this.callbacks.onUploadProgress?.(upload.id, progress);
+        },
+        onProgressDetails: (details) => {
+          progressDetails = details;
+          this.callbacks.onUploadProgressDetails?.(upload.id, details);
         }
       });
+      this.callbacks.onUploadAttemptSucceeded?.(upload.id, {
+        attempt,
+        maxAttempts: MAX_RETRIES2,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes
+      });
       await this.storageService.deleteUpload(upload.id);
       this.callbacks.onUploadComplete?.(upload.id, result);
       return result;
     } catch (error) {
       const errorMessage = extractErrorMessage(error);
       const retryCount = upload.retryCount + 1;
+      const willRetry = retryCount < MAX_RETRIES2;
+      const retryDelayMs = willRetry ? this.calculateRetryDelay(retryCount) : null;
       await this.storageService.updateUploadStatus(upload.id, {
         status: "failed",
         retryCount,
         lastError: errorMessage
       });
-      if (retryCount >= MAX_RETRIES2) {
-        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
-      } else {
+      this.callbacks.onUploadAttemptFailed?.(upload.id, {
+        attempt,
+        maxAttempts: MAX_RETRIES2,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes,
+        reason: errorMessage,
+        retryDelayMs,
+        willRetry
+      });
+      if (willRetry) {
         const delay2 = this.calculateRetryDelay(retryCount);
+        this.callbacks.onUploadProgress?.(upload.id, 0);
+        this.callbacks.onUploadRetry?.(upload.id, {
+          attempt: attempt + 1,
+          maxAttempts: MAX_RETRIES2,
+          reason: errorMessage,
+          retryDelayMs: delay2
+        });
         this.scheduleRetry(delay2);
+      } else {
+        this.callbacks.onUploadError?.(upload.id, new Error(`Upload failed after ${MAX_RETRIES2} attempts: ${errorMessage}`));
       }
       if (shouldThrowOnError) {
         throw new Error(errorMessage);
@@ -7250,6 +7286,9 @@ class UploadQueueManager {
 // src/core/upload/upload-service.ts
 var API_UPLOAD_PATH = "/api/v1/videos/upload";
 var MIME_TYPE_PARAMETER_SEPARATOR = ";";
+var MAX_TRANSFER_PROGRESS = 0.99;
+var UPLOAD_INACTIVITY_TIMEOUT_MS = 45000;
+var UPLOAD_INACTIVITY_ERROR = "Upload stalled after 45 seconds without progress";
 
 class VideoUploadService {
   uploadVideo(blob, options) {
@@ -7259,37 +7298,76 @@ class VideoUploadService {
     if (!blob.type || blob.type.trim() === "") {
       throw new Error("Blob type is required");
     }
-    return this.uploadVideoFile(blob, options);
+    const idempotencyKey = this.resolveIdempotencyKey(options.idempotencyKey);
+    return this.uploadVideoFile(blob, options, idempotencyKey);
   }
-  uploadVideoFile(blob, options) {
+  uploadVideoFile(blob, options, idempotencyKey) {
     return new Promise((resolve, reject) => {
       const xhr = new XMLHttpRequest;
       const uploadBlob = this.createUploadBlob(blob, options.mimeType);
-      if (options.onProgress) {
-        const onProgress = options.onProgress;
-        xhr.upload.addEventListener("progress", (event) => {
-          if (event.lengthComputable) {
-            const progress = event.loaded / event.total;
-            onProgress(progress);
-          }
-        });
-      }
+      let inactivityTimeoutId = null;
+      let isSettled = false;
+      let loadedBytes = 0;
+      let totalBytes = 0;
+      const clearInactivityTimeout = () => {
+        if (inactivityTimeoutId === null) {
+          return;
+        }
+        window.clearTimeout(inactivityTimeoutId);
+        inactivityTimeoutId = null;
+      };
+      const rejectRequest = (reason, shouldAbort = false) => {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        clearInactivityTimeout();
+        if (shouldAbort) {
+          xhr.abort();
+        }
+        reject(reason);
+      };
+      const resolveRequest = (result) => {
+        if (isSettled) {
+          return;
+        }
+        isSettled = true;
+        clearInactivityTimeout();
+        this.reportCompletion(options, loadedBytes, totalBytes);
+        resolve(result);
+      };
+      const restartInactivityTimeout = () => {
+        clearInactivityTimeout();
+        inactivityTimeoutId = window.setTimeout(() => {
+          rejectRequest(new Error(UPLOAD_INACTIVITY_ERROR), true);
+        }, UPLOAD_INACTIVITY_TIMEOUT_MS);
+      };
+      xhr.upload.addEventListener("progress", (event) => {
+        this.reportProgress(event, options);
+        if (event.loaded <= loadedBytes) {
+          return;
+        }
+        loadedBytes = event.loaded;
+        totalBytes = event.total;
+        restartInactivityTimeout();
+      });
       xhr.addEventListener("load", () => {
         if (xhr.status >= 200 && xhr.status <= 299) {
-          this.parseSuccessResponse(xhr, resolve, reject);
+          this.parseSuccessResponse(xhr, resolveRequest, rejectRequest);
           return;
         }
-        this.parseErrorResponse(xhr, reject);
+        this.parseErrorResponse(xhr, rejectRequest);
       });
       xhr.addEventListener("error", () => {
-        reject(new Error("Network error during upload"));
+        rejectRequest(new Error("Network error during upload"));
       });
       xhr.addEventListener("abort", () => {
-        reject(new Error("Upload was aborted"));
+        rejectRequest(new Error("Upload was aborted"));
       });
       const url = `${options.backendUrl}${API_UPLOAD_PATH}`;
       xhr.open("POST", url);
       xhr.setRequestHeader("Authorization", `Bearer ${options.apiKey}`);
+      xhr.setRequestHeader("Idempotency-Key", idempotencyKey);
       const formData = new FormData;
       formData.append("file", uploadBlob, options.filename);
       const metadata = {
@@ -7301,6 +7379,33 @@ class VideoUploadService {
       }
       formData.append("metadata", JSON.stringify(metadata));
       xhr.send(formData);
+      restartInactivityTimeout();
+    });
+  }
+  resolveIdempotencyKey(idempotencyKey) {
+    if (idempotencyKey) {
+      return idempotencyKey;
+    }
+    return crypto.randomUUID();
+  }
+  reportProgress(event, options) {
+    if (!event.lengthComputable) {
+      return;
+    }
+    const progress = Math.min(event.loaded / event.total, MAX_TRANSFER_PROGRESS);
+    options.onProgress?.(progress);
+    options.onProgressDetails?.({
+      progress,
+      loadedBytes: event.loaded,
+      totalBytes: event.total
+    });
+  }
+  reportCompletion(options, loadedBytes, totalBytes) {
+    options.onProgress?.(1);
+    options.onProgressDetails?.({
+      progress: 1,
+      loadedBytes,
+      totalBytes
     });
   }
   createUploadBlob(blob, mimeType) {
@@ -23210,6 +23315,8 @@ class RecorderController {
   callbacks;
   telemetryManager;
   uploadMetadataManager;
+  uploadAttemptFailureById = new Map;
+  uploadAttemptSuccessById = new Map;
   uploadQueueManager = null;
   isInitialized = false;
   isDemo = false;
@@ -23551,6 +23658,11 @@ class RecorderController {
       }, error);
       throw error;
     }
+    let progressDetails = {
+      progress: 0,
+      loadedBytes: 0,
+      totalBytes: 0
+    };
     try {
       const result = await this.uploadService.uploadVideo(options.blob, {
         apiKey: options.apiKey,
@@ -23559,18 +23671,37 @@ class RecorderController {
         mimeType: options.mimeType,
         metadata: undefined,
         userMetadata: options.userMetadata,
-        onProgress: this.uploadCallbacks.onProgress
+        onProgress: this.uploadCallbacks.onProgress,
+        onProgressDetails: (details) => {
+          progressDetails = details;
+        }
       });
       this.uploadCallbacks.onSuccess(result);
       this.telemetryManager.sendEvent("upload.succeeded", {
         filename: options.filename,
         duration: options.duration,
         sourceType: options.sourceType,
-        recordingId: result.id
+        recordingId: result.id,
+        attempt: 1,
+        maxAttempts: 1,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes
       });
     } catch (error) {
       const uploadError = error instanceof Error ? error : new Error(extractErrorMessage(error));
       this.uploadCallbacks.onError(uploadError);
+      this.telemetryManager.sendEvent("upload.attempt.failed", {
+        filename: options.filename,
+        duration: options.duration,
+        sourceType: options.sourceType,
+        attempt: 1,
+        maxAttempts: 1,
+        loadedBytes: progressDetails.loadedBytes,
+        totalBytes: progressDetails.totalBytes,
+        reason: uploadError.message,
+        willRetry: false,
+        retryDelayMs: null
+      }, uploadError);
       this.telemetryManager.sendEvent("upload.failed", {
         filename: options.filename,
         duration: options.duration,
@@ -23819,19 +23950,60 @@ class RecorderController {
       onUploadProgress: (_id, progress) => {
         this.uploadCallbacks.onProgress(progress);
       },
+      onUploadAttemptFailed: (id, details) => {
+        this.uploadAttemptFailureById.set(id, details);
+        const metadata = this.uploadMetadataManager.getMetadata(id);
+        if (!metadata) {
+          return;
+        }
+        const error = new Error(details.reason);
+        this.telemetryManager.sendEvent("upload.attempt.failed", {
+          filename: metadata.filename,
+          duration: metadata.duration,
+          sourceType: metadata.sourceType,
+          ...details
+        }, error);
+      },
+      onUploadAttemptSucceeded: (id, details) => {
+        this.uploadAttemptSuccessById.set(id, details);
+      },
+      onUploadRetry: (id, details) => {
+        this.uploadCallbacks.onRetry?.(details);
+        const metadata = this.uploadMetadataManager.getMetadata(id);
+        const failureDetails = this.uploadAttemptFailureById.get(id);
+        if (!(metadata && failureDetails)) {
+          return;
+        }
+        this.telemetryManager.sendEvent("upload.retry.scheduled", {
+          filename: metadata.filename,
+          duration: metadata.duration,
+          sourceType: metadata.sourceType,
+          attempt: details.attempt,
+          maxAttempts: details.maxAttempts,
+          previousAttempt: failureDetails.attempt,
+          loadedBytes: failureDetails.loadedBytes,
+          totalBytes: failureDetails.totalBytes,
+          reason: details.reason,
+          retryDelayMs: details.retryDelayMs
+        });
+      },
       onUploadComplete: (id, result) => {
         this.isUploadInProgress = false;
         this.uploadCallbacks.onSuccess(result);
         const metadata = this.uploadMetadataManager.getMetadata(id);
+        const successDetails = this.uploadAttemptSuccessById.get(id);
         if (metadata) {
           this.telemetryManager.sendEvent("upload.succeeded", {
             filename: metadata.filename,
             duration: metadata.duration,
             sourceType: metadata.sourceType,
-            recordingId: result.id
+            recordingId: result.id,
+            ...successDetails && successDetails
           });
           this.uploadMetadataManager.clearMetadata(id);
         }
+        this.uploadAttemptFailureById.delete(id);
+        this.uploadAttemptSuccessById.delete(id);
       },
       onUploadError: (id, error) => {
         this.isUploadInProgress = false;
@@ -23845,6 +24017,8 @@ class RecorderController {
           }, error);
           this.uploadMetadataManager.clearMetadata(id);
         }
+        this.uploadAttemptFailureById.delete(id);
+        this.uploadAttemptSuccessById.delete(id);
       }
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",