@budibase/server 2.6.19-alpha.30 → 2.6.19-alpha.31

package/dist/automation.js

@@ -128,6 +128,7 @@ var init_environment = __esm({
       ENABLE_ANALYTICS: process.env.ENABLE_ANALYTICS,
       SELF_HOSTED: process.env.SELF_HOSTED,
       HTTP_MB_LIMIT: process.env.HTTP_MB_LIMIT,
+      FORKED_PROCESS_NAME: process.env.FORKED_PROCESS_NAME || "main",
       // old
       CLIENT_ID: process.env.CLIENT_ID,
       _set(key, value) {
@@ -3647,6 +3648,7 @@ var init_logger = __esm({
         }
         const mergingObject = {
           err: error,
+          pid: process.pid,
           ...contextObject
         };
         if (objects.length) {
@@ -26770,8 +26772,10 @@ function makeVariableKey(queryId, variable) {
 }
 function threadSetup() {
   if (environment_default.isTest() || environment_default.DISABLE_THREADING || !environment_default.isInThread()) {
+    console.debug(`[${environment_default.FORKED_PROCESS_NAME}] thread setup skipped`);
     return;
   }
+  console.debug(`[${environment_default.FORKED_PROCESS_NAME}] thread setup running`);
   init8();
 }
 async function checkCacheForDynamicVariable(queryId, variable) {
@@ -26845,13 +26849,17 @@ var _Thread = class {
     this.count = opts.count ? opts.count : 1;
     this.disableThreading = this.shouldDisableThreading();
     if (!this.disableThreading) {
+      console.debug(
+        `[${environment_default.FORKED_PROCESS_NAME}] initialising worker farm type=${type}`
+      );
       const workerOpts = {
         autoStart: true,
         maxConcurrentWorkers: this.count,
         workerOptions: {
           env: {
             ...process.env,
-            FORKED_PROCESS: "1"
+            FORKED_PROCESS: "1",
+            FORKED_PROCESS_NAME: type
           }
         }
       };
@@ -26861,6 +26869,10 @@ var _Thread = class {
       }
       this.workers = (0, import_worker_farm.default)(workerOpts, typeToFile(type), ["execute"]);
       _Thread.workerRefs.push(this.workers);
+    } else {
+      console.debug(
+        `[${environment_default.FORKED_PROCESS_NAME}] skipping worker farm type=${type}`
+      );
     }
   }
   shouldDisableThreading() {
@@ -26872,9 +26884,7 @@ var _Thread = class {
       function fire(worker) {
         worker.execute(job, (err, response2) => {
           if (err && err.type === "TimeoutError") {
-            reject(
-              new Error(`Query response time exceeded ${timeout2}ms timeout.`)
-            );
+            reject(new Error(`Thread timeout exceeded ${timeout2}ms timeout.`));
           } else if (err) {
             reject(err);
           } else {
@@ -31950,10 +31960,29 @@ init_constants6();
 init_environment();
 init_src4();
 init_src2();
+var import_object_sizeof = __toESM(require("object-sizeof"));
+var MAX_LOG_SIZE_MB = 5;
+var MB_IN_BYTES = 1024 * 1024;
+function sanitiseResults(results) {
+  const message = `[removed] - max results size of ${MAX_LOG_SIZE_MB}MB exceeded`;
+  for (let step of results.steps) {
+    step.inputs = {
+      message
+    };
+    step.outputs = {
+      message,
+      success: step.outputs.success
+    };
+  }
+}
 async function storeLog2(automation, results) {
   if (environment_default.DISABLE_AUTOMATION_LOGS) {
     return;
   }
+  const bytes = (0, import_object_sizeof.default)(results);
+  if (bytes / MB_IN_BYTES > MAX_LOG_SIZE_MB) {
+    sanitiseResults(results);
+  }
   await automations_exports.logs.storeLog(automation, results);
 }
 
@@ -31969,8 +31998,8 @@ var FILTER_STEP_ID = BUILTIN_ACTION_DEFINITIONS.FILTER.stepId;
 var LOOP_STEP_ID = BUILTIN_ACTION_DEFINITIONS.LOOP.stepId;
 var CRON_STEP_ID2 = definitions.CRON.stepId;
 var STOPPED_STATUS = { success: true, status: "stopped" /* STOPPED */ };
-function getLoopIterations(loopStep, input) {
-  const binding = typecastForLooping(loopStep, input);
+function getLoopIterations(loopStep) {
+  let binding = loopStep.inputs.binding;
   if (!binding) {
     return 0;
   }
@@ -31986,7 +32015,6 @@ var Orchestrator = class {
   constructor(job) {
     let automation = job.data.automation;
     let triggerOutput = job.data.event;
-    let timeout2 = job.data.event.timeout;
     const metadata = triggerOutput.metadata;
     this._chainCount = metadata ? metadata.automationChainCount : 0;
     this._appId = triggerOutput.appId;
@@ -32120,7 +32148,7 @@ var Orchestrator = class {
     });
   }
   async execute() {
-    var _a;
+    var _a, _b;
     this._context.env = await getEnvironmentVariables2();
     let automation = this._automation;
     let stopped = false;
@@ -32139,6 +32167,7 @@ var Orchestrator = class {
         return;
       }
     }
+    const start2 = performance.now();
     for (let step of automation.definition.steps) {
       if (timeoutFlag) {
         break;
@@ -32157,20 +32186,16 @@ var Orchestrator = class {
       }
       if (loopStep) {
         input = await (0, import_string_templates8.processObject)(loopStep.inputs, this._context);
-        iterations = getLoopIterations(loopStep, input);
+        iterations = getLoopIterations(loopStep);
       }
       for (let index2 = 0; index2 < iterations; index2++) {
         let originalStepInput = (0, import_fp8.cloneDeep)(step.inputs);
         if (loopStep && input.binding) {
-          let newInput = await (0, import_string_templates8.processObject)(
-            loopStep.inputs,
-            (0, import_fp8.cloneDeep)(this._context)
-          );
           let tempOutput = { items: loopSteps, iterations: iterationCount };
           try {
-            newInput.binding = typecastForLooping(
+            loopStep.inputs.binding = typecastForLooping(
               loopStep,
-              newInput
+              loopStep.inputs
             );
           } catch (err) {
             this.updateContextAndOutput(loopStepNumber, step, tempOutput, {
@@ -32183,7 +32208,7 @@ var Orchestrator = class {
           }
           let item = [];
           if (typeof loopStep.inputs.binding === "string" && loopStep.inputs.option === "String") {
-            item = stringSplit(newInput.binding);
+            item = stringSplit(loopStep.inputs.binding);
           } else if (Array.isArray(loopStep.inputs.binding)) {
             item = loopStep.inputs.binding;
           }
@@ -32326,7 +32351,18 @@ var Orchestrator = class {
         loopSteps = [];
       }
     }
-    await storeLog2(this._automation, this.executionOutput);
+    const end2 = performance.now();
+    const executionTime = end2 - start2;
+    console.log(`Execution time: ${executionTime} milliseconds`);
+    try {
+      await storeLog2(this._automation, this.executionOutput);
+    } catch (e) {
+      if (e.status === 413 && ((_b = e.request) == null ? void 0 : _b.data)) {
+        delete e.request.data;
+        e.request.data = { message: "removed due to large size" };
+      }
+      logging_exports.logAlert("Error writing automation log", e);
+    }
     if (isProdAppID2(this._appId) && isRecurring(automation) && metadata) {
       await this.updateMetadata(metadata);
     }
@@ -32335,20 +32371,28 @@ var Orchestrator = class {
 };
 function execute3(job, callback) {
   const appId = job.data.event.appId;
+  const automationId = job.data.automation._id;
   if (!appId) {
     throw new Error("Unable to execute, event doesn't contain app ID.");
   }
-  return context_exports.doInAppContext(appId, async () => {
-    const envVars = await getEnvironmentVariables2();
-    await context_exports.doInEnvironmentContext(envVars, async () => {
-      const automationOrchestrator = new Orchestrator(job);
-      try {
-        const response2 = await automationOrchestrator.execute();
-        callback(null, response2);
-      } catch (err) {
-        callback(err);
-      }
-    });
+  if (!automationId) {
+    throw new Error("Unable to execute, event doesn't contain automation ID.");
+  }
+  return context_exports.doInAutomationContext({
+    appId,
+    automationId,
+    task: async () => {
+      const envVars = await getEnvironmentVariables2();
+      await context_exports.doInEnvironmentContext(envVars, async () => {
+        const automationOrchestrator = new Orchestrator(job);
+        try {
+          const response2 = await automationOrchestrator.execute();
+          callback(null, response2);
+        } catch (err) {
+          callback(err);
+        }
+      });
+    }
   });
 }
 function executeSynchronously(job) {