@dev-blinq/cucumber_client 1.0.1186-dev → 1.0.1188-dev

package/bin/client/local_agent.js

@@ -383,7 +383,7 @@ class LocalAgent {
             error: command.data.errorMessage,
           });
           agent.stepFailResolve(command.data.errorMessage);
-          logger.info("Step fail, " + command.data.errorMessage);
+          logger.error("Step fail, " + command.data.errorMessage);
         } else {
           agent.stepEndResolve();
           logger.info("Step end");

package/bin/client/scenario_report.js

@@ -193,7 +193,8 @@ class ScenarioReport {
     fs.writeFileSync(path, zipBlob);
     return path;
   }
-
+  // Note to future self:
+  // Increased the max retries to 3 and added exponential backoff to increase consistency but traded off availability :)
   async _uploadScenario() {
     try {
       const scenarioDoc = await this.scenarioUploadService.createScenarioDocument(this.name);
@@ -201,62 +202,91 @@ class ScenarioReport {
       const projectId = scenarioDoc.project_id;
       this.scenario_id = scenarioDocId;
       this._saveToFile();
-
-      // console.log("scenarioDocId", scenarioDocId);
       await this.sendRetrainStats(scenarioDocId);
-      // create zip file
       if (process.env.NODE_ENV_BLINQ === "local") {
-        const zipFilePath = await this.createScenarioZip();
-        // upload to server
-        const formData = new FormData();
-        // const file = File(zipFileBlob, "report.zip");
-        formData.append(scenarioDocId, fs.readFileSync(zipFilePath), "report.zip");
-        await this.scenarioUploadService.upload(formData);
+        await this._uploadLocalBundle(scenarioDocId);
       } else {
-        const report = getJsonReport(this);
-        fs.writeFileSync(path.join(this.scenarioPath, "scenario.json"), JSON.stringify(report, null, 2));
-        const fileUris = [
-          ...this.getFileUrisScreenShotDir(this.scenarioPath),
-          "scenario.json",
-          "network.json",
-          "editorLogs.log",
-        ];
-        const networkJsonPath = path.join(this.scenarioPath, "network.json");
-        if (!fs.existsSync(networkJsonPath)) {
-          fs.writeFileSync(networkJsonPath, JSON.stringify({}), "utf-8");
-        }
-        const presignedUrls = await this.scenarioUploadService.getPresignedUrls(fileUris, scenarioDocId);
-        for (let i = 0; i < fileUris.length; i += BATCH_SIZE) {
-          const batch = fileUris.slice(i, Math.min(i + BATCH_SIZE, fileUris.length));
-          await Promise.all(
-            batch
-              .filter((fileUrl) => presignedUrls[fileUrl] !== undefined)
-              .map(async (fileUrl) => {
-                const filePath = path.join(this.scenarioPath, fileUrl);
-                for (let j = 0; j < MAX_RETRIES; j++) {
-                  const success = await this.scenarioUploadService.uploadFile(filePath, presignedUrls[fileUrl]);
-                  if (success) {
-                    return;
-                  }
-                }
-                console.error("Failed to upload file", fileUrl);
-              })
-          );
-        }
-        await this.scenarioUploadService.uploadComplete(scenarioDocId, projectId);
+        await this._uploadRemoteBundle(scenarioDocId, projectId);
       }
       logger.info("Scenario uploaded successfully");
-
       this.logReportLink(projectId, scenarioDocId);
-
-      // delete zip file
-      // fs.unlinkSync(this.scenarioPath + '/example.zip');
     } catch (err) {
-      logger.info("Failed to upload scenario - ignored");
-      logger.debug(err);
-      //console.error(err);
+      logger.error("Scenario uploaded failed");
+      logger.debug("Error while uploading : ", err);
     }
   }
+  // Local environment uploader decomposed the function for better readability
+  async _uploadLocalBundle(scenarioDocId) {
+    const zipFilePath = await this.createScenarioZip();
+    const formData = new FormData();
+    formData.append("scenarioId", scenarioDocId);
+    formData.append("file", fs.createReadStream(zipFilePath));
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await this.scenarioUploadService.upload(formData);
+        fs.unlinkSync(zipFilePath);
+        return;
+      } catch (err) {
+        logger.debug("Local upload attempt failed", { attempt, error: err });
+        // added delays between retries for better consistency over availability
+        await this._delay(2 ** attempt * 1000);
+      }
+    }
+    throw new Error(`Local upload failed after ${MAX_RETRIES} attempts`);
+  }
+
+  // decomposed the function for better readability  this function is used to upload
+  async _uploadRemoteBundle(scenarioDocId, projectId) {
+    const report = getJsonReport(this);
+    fs.writeFileSync(path.join(this.scenarioPath, "scenario.json"), JSON.stringify(report, null, 2));
+
+    const fileUris = [
+      ...this.getFileUrisScreenShotDir(this.scenarioPath),
+      "scenario.json",
+      "network.json",
+      "editorLogs.log",
+    ];
+    const networkJsonPath = path.join(this.scenarioPath, "network.json");
+    if (!fs.existsSync(networkJsonPath)) {
+      fs.writeFileSync(networkJsonPath, JSON.stringify({}), "utf-8");
+    }
+
+    const presignedUrls = await this.scenarioUploadService.getPresignedUrls(fileUris, scenarioDocId);
+    const missing = fileUris.filter((uri) => !presignedUrls[uri]);
+    if (missing.length) {
+      throw new Error(`Missing presigned URLs for: ${missing.join(", ")}`);
+    }
+
+    // Upload files in batches with retries
+    for (let i = 0; i < fileUris.length; i += BATCH_SIZE) {
+      const batch = fileUris.slice(i, i + BATCH_SIZE);
+      await Promise.all(batch.map((uri) => this._retryUploadFile(uri, presignedUrls[uri])));
+    }
+
+    await this.scenarioUploadService.uploadComplete(scenarioDocId, projectId);
+  }
+
+  // Retry helper it will retry the upload of a file if it fails given file uri and url here Max_retires is and each retiry wait time  : 2secs ,4secs, 8 secs
+  // Note to self : if the still upload fails a lot we have to investigate the file formats too
+  async _retryUploadFile(fileUri, url) {
+    const filePath = path.join(this.scenarioPath, fileUri);
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await this.scenarioUploadService.uploadFile(filePath, url);
+        return;
+      } catch (err) {
+        logger.debug("Upload file attempt failed ", { fileUri, attempt, error: err });
+        await this._delay(2 ** attempt * 1000);
+      }
+    }
+    throw new Error(`Failed to upload file ${fileUri} after ${MAX_RETRIES} attempts`);
+  }
+
+  // Utility delay can be used to delay anything  (Note to self : Replace it with the built in delay function later)
+  _delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
 
   logReportLink(projectId, scenarioId) {
     let baseUrl = "https://www.app.blinq.io";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1186-dev",
+  "version": "1.0.1188-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -28,7 +28,7 @@
     "@cucumber/tag-expressions": "^6.1.1",
     "@dev-blinq/cucumber-js": "1.0.172-dev",
     "@faker-js/faker": "^8.1.0",
-    "automation_model": "1.0.718-dev",
+    "automation_model": "1.0.719-dev",
     "axios": "^1.7.4",
     "chokidar": "^3.6.0",
     "create-require": "^1.1.1",