trigger.dev 3.0.0-beta.36 → 3.0.0-beta.38

package/dist/workers/dev/worker-facade.js

@@ -9,7 +9,9 @@ import {
   getEnvVar,
   logLevels,
   OtelTaskLogger,
-  ConsoleInterceptor
+  ConsoleInterceptor,
+  usage,
+  DevUsageManager
 } from "@trigger.dev/core/v3/workers";
 import {
   TaskRunErrorCodes,
@@ -27,6 +29,7 @@ __WORKER_SETUP__;
 __IMPORTED_PROJECT_CONFIG__;
 var durableClock = new DurableClock();
 clock.setGlobalClock(durableClock);
+usage.setGlobalUsageManager(new DevUsageManager());
 var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
 var consoleInterceptor = new ConsoleInterceptor(
   otelLogger,
@@ -76,6 +79,9 @@ var handler = new ZodMessageHandler({
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
+            },
+            usage: {
+              durationMs: 0
             }
           }
         });
@@ -93,6 +99,9 @@ var handler = new ZodMessageHandler({
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
+            },
+            usage: {
+              durationMs: 0
             }
           }
         });
@@ -109,10 +118,17 @@ var handler = new ZodMessageHandler({
       try {
         _execution = execution;
         _isRunning = true;
-        const result = await executor.execute(execution, metadata, traceContext);
+        const measurement = usage.start();
+        const { result } = await executor.execute(execution, metadata, traceContext, measurement);
+        const usageSample = usage.stop(measurement);
         return sender.send("TASK_RUN_COMPLETED", {
           execution,
-          result
+          result: {
+            ...result,
+            usage: {
+              durationMs: usageSample.cpuTime
+            }
+          }
         });
       } finally {
         _execution = void 0;

package/dist/workers/dev/worker-setup.js

@@ -8,7 +8,7 @@ import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
 import "source-map-support/register.js";
 
 // package.json
-var version = "3.0.0-beta.36";
+var version = "3.0.0-beta.38";
 
 // src/workers/dev/worker-setup.ts
 __SETUP_IMPORTED_PROJECT_CONFIG__;

package/dist/workers/prod/entry-point.js

@@ -5,7 +5,7 @@ import {
   PreStopCauses,
   ProdWorkerToCoordinatorMessages
 } from "@trigger.dev/core/v3";
-import { ZodSocketConnection as ZodSocketConnection2 } from "@trigger.dev/core/v3/zodSocket";
+import { ZodSocketConnection } from "@trigger.dev/core/v3/zodSocket";
 
 // ../core-apps/src/http.ts
 var HttpReply = class {
@@ -65,24 +65,6 @@ var SimpleLogger = class {
   }
 };
 
-// ../core-apps/src/provider.ts
-import {
-  ClientToSharedQueueMessages,
-  clientWebsocketMessages,
-  PlatformToProviderMessages,
-  ProviderToPlatformMessages,
-  SharedQueueToClientMessages
-} from "@trigger.dev/core/v3";
-import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
-import { ZodSocketConnection } from "@trigger.dev/core/v3/zodSocket";
-var HTTP_SERVER_PORT = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
-var MACHINE_NAME = process.env.MACHINE_NAME || "local";
-var PLATFORM_HOST = process.env.PLATFORM_HOST || "127.0.0.1";
-var PLATFORM_WS_PORT = process.env.PLATFORM_WS_PORT || 3030;
-var PLATFORM_SECRET = process.env.PLATFORM_SECRET || "provider-secret";
-var SECURE_CONNECTION = ["1", "true"].includes(process.env.SECURE_CONNECTION ?? "false");
-var logger = new SimpleLogger(`[${MACHINE_NAME}]`);
-
 // src/workers/prod/entry-point.ts
 import { readFile } from "node:fs/promises";
 import { createServer } from "node:http";
@@ -171,6 +153,7 @@ var ProdBackgroundWorker = class {
   attemptCreatedNotification = Evt.create();
   _onClose = new Evt();
   tasks = [];
+  stderr = [];
   _taskRunProcess;
   _taskRunProcessesBeingKilled = /* @__PURE__ */ new Map();
   _closed = false;
@@ -234,6 +217,20 @@ var ProdBackgroundWorker = class {
         child.kill();
         reject(new Error("Worker timed out"));
       }, 1e4);
+      child.stdout?.on("data", (data) => {
+        console.log(data.toString());
+      });
+      child.stderr?.on("data", (data) => {
+        console.error(data.toString());
+        this.stderr.push(data.toString());
+      });
+      child.on("exit", (code) => {
+        if (!resolved) {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(new Error(`Worker exited with code ${code}`));
+        }
+      });
       new ZodIpcConnection({
         listenSchema: ProdChildToWorkerMessages,
         emitSchema: ProdWorkerToChildMessages,
@@ -265,19 +262,6 @@ var ProdBackgroundWorker = class {
           }
         }
       });
-      child.stdout?.on("data", (data) => {
-        console.log(data.toString());
-      });
-      child.stderr?.on("data", (data) => {
-        console.error(data.toString());
-      });
-      child.on("exit", (code) => {
-        if (!resolved) {
-          clearTimeout(timeout);
-          resolved = true;
-          reject(new Error(`Worker exited with code ${code}`));
-        }
-      });
     });
     this._initialized = true;
   }
@@ -702,7 +686,10 @@ var TaskRunProcess = class {
     const killParentProcess = kill && !killChildProcess;
     console.log("Cleaning up task run process", {
       killChildProcess,
-      killParentProcess
+      killParentProcess,
+      ipc: this._ipc,
+      childPid: this._childPid,
+      realChildPid: this._child?.pid
     });
     await this._ipc?.sendWithAck(
       "CLEANUP",
@@ -818,13 +805,13 @@ var TaskRunProcess = class {
 
 // src/workers/prod/entry-point.ts
 import { setTimeout as setTimeout2 } from "node:timers/promises";
-var HTTP_SERVER_PORT2 = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
+var HTTP_SERVER_PORT = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
 var COORDINATOR_HOST = process.env.COORDINATOR_HOST || "127.0.0.1";
 var COORDINATOR_PORT = Number(process.env.COORDINATOR_PORT || 50080);
-var MACHINE_NAME2 = process.env.MACHINE_NAME || "local";
+var MACHINE_NAME = process.env.MACHINE_NAME || "local";
 var POD_NAME = process.env.POD_NAME || "some-pod";
 var SHORT_HASH = process.env.TRIGGER_CONTENT_HASH.slice(0, 9);
-var logger2 = new SimpleLogger(`[${MACHINE_NAME2}][${SHORT_HASH}]`);
+var logger = new SimpleLogger(`[${MACHINE_NAME}][${SHORT_HASH}]`);
 var ProdWorker = class {
   constructor(port, host = "0.0.0.0") {
     this.host = host;
@@ -854,24 +841,24 @@ var ProdWorker = class {
   #httpServer;
   #coordinatorSocket;
   async #handleSignal(signal) {
-    logger2.log("Received signal", { signal });
+    logger.log("Received signal", { signal });
     if (signal === "SIGTERM") {
       let gracefulExitTimeoutElapsed = false;
       if (this.executing) {
         const terminationGracePeriodSeconds = 60 * 60;
-        logger2.log("Waiting for attempt to complete before exiting", {
+        logger.log("Waiting for attempt to complete before exiting", {
           terminationGracePeriodSeconds
         });
         await setTimeout2(terminationGracePeriodSeconds * 1e3 - 5e3);
         gracefulExitTimeoutElapsed = true;
-        logger2.log("Termination timeout reached, exiting gracefully.");
+        logger.log("Termination timeout reached, exiting gracefully.");
       } else {
-        logger2.log("Not executing, exiting immediately.");
+        logger.log("Not executing, exiting immediately.");
       }
       await this.#exitGracefully(gracefulExitTimeoutElapsed);
       return;
     }
-    logger2.log("Unhandled signal", { signal });
+    logger.log("Unhandled signal", { signal });
   }
   async #exitGracefully(gracefulExitTimeoutElapsed = false) {
     await this.#backgroundWorker.close(gracefulExitTimeoutElapsed);
@@ -894,7 +881,7 @@ var ProdWorker = class {
           "\n",
           ""
         );
-        logger2.log("reconnecting", {
+        logger.log("reconnecting", {
           coordinatorHost: {
             fromEnv: COORDINATOR_HOST,
             fromVolume: coordinatorHost,
@@ -903,7 +890,7 @@ var ProdWorker = class {
         });
       }
     } catch (error) {
-      logger2.error("taskinfo read error during reconnect", {
+      logger.error("taskinfo read error during reconnect", {
         error: error instanceof Error ? error.message : error
       });
     } finally {
@@ -932,7 +919,7 @@ var ProdWorker = class {
       this.#coordinatorSocket.socket.emit("READY_FOR_CHECKPOINT", { version: "v1" });
     });
     backgroundWorker.onCancelCheckpoint.attach(async (message) => {
-      logger2.log("onCancelCheckpoint", { message });
+      logger.log("onCancelCheckpoint", { message });
       const { checkpointCanceled } = await this.#coordinatorSocket.socket.emitWithAck(
         "CANCEL_CHECKPOINT",
         {
@@ -940,7 +927,7 @@ var ProdWorker = class {
           reason: message.reason
         }
       );
-      logger2.log("onCancelCheckpoint coordinator response", { checkpointCanceled });
+      logger.log("onCancelCheckpoint coordinator response", { checkpointCanceled });
       if (checkpointCanceled) {
         if (message.reason === "WAIT_FOR_DURATION") {
           this.paused = false;
@@ -951,7 +938,7 @@ var ProdWorker = class {
       backgroundWorker.checkpointCanceledNotification.post({ checkpointCanceled });
     });
     backgroundWorker.onCreateTaskRunAttempt.attach(async (message) => {
-      logger2.log("onCreateTaskRunAttempt()", { message });
+      logger.log("onCreateTaskRunAttempt()", { message });
       const createAttempt = await this.#coordinatorSocket.socket.emitWithAck(
         "CREATE_TASK_RUN_ATTEMPT",
         {
@@ -979,7 +966,7 @@ var ProdWorker = class {
     });
     backgroundWorker.onWaitForDuration.attach(async (message) => {
       if (!this.attemptFriendlyId) {
-        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        logger.error("Failed to send wait message, attempt friendly ID not set", { message });
         this.#emitUnrecoverableError(
           "NoAttemptId",
           "Attempt ID not set before waiting for duration"
@@ -997,7 +984,7 @@ var ProdWorker = class {
     });
     backgroundWorker.onWaitForTask.attach(async (message) => {
       if (!this.attemptFriendlyId) {
-        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        logger.error("Failed to send wait message, attempt friendly ID not set", { message });
         this.#emitUnrecoverableError("NoAttemptId", "Attempt ID not set before waiting for task");
         return;
       }
@@ -1012,7 +999,7 @@ var ProdWorker = class {
     });
     backgroundWorker.onWaitForBatch.attach(async (message) => {
       if (!this.attemptFriendlyId) {
-        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        logger.error("Failed to send wait message, attempt friendly ID not set", { message });
         this.#emitUnrecoverableError("NoAttemptId", "Attempt ID not set before waiting for batch");
         return;
       }
@@ -1028,7 +1015,7 @@ var ProdWorker = class {
     return backgroundWorker;
   }
   async #prepareForWait(reason, willCheckpointAndRestore) {
-    logger2.log(`prepare for ${reason}`, { willCheckpointAndRestore });
+    logger.log(`prepare for ${reason}`, { willCheckpointAndRestore });
     this.#backgroundWorker.preCheckpointNotification.post({ willCheckpointAndRestore });
     if (willCheckpointAndRestore) {
       this.paused = true;
@@ -1040,10 +1027,10 @@ var ProdWorker = class {
     }
   }
   async #prepareForRetry(willCheckpointAndRestore, shouldExit) {
-    logger2.log("prepare for retry", { willCheckpointAndRestore, shouldExit });
+    logger.log("prepare for retry", { willCheckpointAndRestore, shouldExit });
     if (shouldExit) {
       if (willCheckpointAndRestore) {
-        logger2.log("WARNING: Will checkpoint but also requested exit. This won't end well.");
+        logger.log("WARNING: Will checkpoint but also requested exit. This won't end well.");
       }
       await this.#exitGracefully();
       return;
@@ -1082,7 +1069,7 @@ var ProdWorker = class {
   // FIXME: If the the worker can't connect for a while, this runs MANY times - it should only run once
   #createCoordinatorSocket(host) {
     const extraHeaders = this.#returnValidatedExtraHeaders({
-      "x-machine-name": MACHINE_NAME2,
+      "x-machine-name": MACHINE_NAME,
       "x-pod-name": POD_NAME,
       "x-trigger-content-hash": this.contentHash,
       "x-trigger-project-ref": this.projectRef,
@@ -1094,9 +1081,9 @@ var ProdWorker = class {
     if (this.attemptFriendlyId) {
       extraHeaders["x-trigger-attempt-friendly-id"] = this.attemptFriendlyId;
     }
-    logger2.log(`connecting to coordinator: ${host}:${COORDINATOR_PORT}`);
-    logger2.debug(`connecting with extra headers`, { extraHeaders });
-    const coordinatorConnection = new ZodSocketConnection2({
+    logger.log(`connecting to coordinator: ${host}:${COORDINATOR_PORT}`);
+    logger.debug(`connecting with extra headers`, { extraHeaders });
+    const coordinatorConnection = new ZodSocketConnection({
       namespace: "prod-worker",
       host,
       port: COORDINATOR_PORT,
@@ -1106,21 +1093,21 @@ var ProdWorker = class {
       handlers: {
         RESUME_AFTER_DEPENDENCY: async ({ completions }) => {
           if (!this.paused) {
-            logger2.error("Failed to resume after dependency: Worker not paused");
+            logger.error("Failed to resume after dependency: Worker not paused");
             return;
           }
           if (completions.length === 0) {
-            logger2.error("Failed to resume after dependency: No completions");
+            logger.error("Failed to resume after dependency: No completions");
             return;
           }
           if (this.nextResumeAfter !== "WAIT_FOR_TASK" && this.nextResumeAfter !== "WAIT_FOR_BATCH") {
-            logger2.error("Failed to resume after dependency: Invalid next resume", {
+            logger.error("Failed to resume after dependency: Invalid next resume", {
               nextResumeAfter: this.nextResumeAfter
             });
             return;
           }
           if (this.nextResumeAfter === "WAIT_FOR_TASK" && completions.length > 1) {
-            logger2.error(
+            logger.error(
               "Failed to resume after dependency: Waiting for single task but got multiple completions",
               {
                 completions
@@ -1140,13 +1127,13 @@ var ProdWorker = class {
         },
         RESUME_AFTER_DURATION: async (message) => {
           if (!this.paused) {
-            logger2.error("worker not paused", {
+            logger.error("worker not paused", {
               attemptId: message.attemptId
             });
             return;
           }
           if (this.nextResumeAfter !== "WAIT_FOR_DURATION") {
-            logger2.error("not waiting to resume after duration", {
+            logger.error("not waiting to resume after duration", {
               nextResumeAfter: this.nextResumeAfter
             });
             return;
@@ -1155,42 +1142,42 @@ var ProdWorker = class {
         },
         EXECUTE_TASK_RUN: async ({ executionPayload }) => {
           if (this.executing) {
-            logger2.error("dropping execute request, already executing");
+            logger.error("dropping execute request, already executing");
             return;
           }
           if (this.completed.has(executionPayload.execution.attempt.id)) {
-            logger2.error("dropping execute request, already completed");
+            logger.error("dropping execute request, already completed");
             return;
           }
           this.executing = true;
           this.attemptFriendlyId = executionPayload.execution.attempt.id;
           const completion = await this.#backgroundWorker.executeTaskRun(executionPayload);
-          logger2.log("completed", completion);
+          logger.log("completed", completion);
           this.completed.add(executionPayload.execution.attempt.id);
           const { willCheckpointAndRestore, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck("TASK_RUN_COMPLETED", {
             version: "v1",
             execution: executionPayload.execution,
             completion
           });
-          logger2.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
+          logger.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
           this.#prepareForRetry(willCheckpointAndRestore, shouldExit);
         },
         EXECUTE_TASK_RUN_LAZY_ATTEMPT: async (message) => {
           if (this.executing) {
-            logger2.error("dropping execute request, already executing");
+            logger.error("dropping execute request, already executing");
             return;
           }
           this.executing = true;
           try {
             const { completion, execution } = await this.#backgroundWorker.executeTaskRunLazyAttempt(message.lazyPayload);
-            logger2.log("completed", completion);
+            logger.log("completed", completion);
             this.completed.add(execution.attempt.id);
             const { willCheckpointAndRestore, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck("TASK_RUN_COMPLETED", {
               version: "v1",
               execution,
               completion
             });
-            logger2.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
+            logger.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
             this.#prepareForRetry(willCheckpointAndRestore, shouldExit);
           } catch (error) {
             const completion = {
@@ -1217,15 +1204,15 @@ var ProdWorker = class {
         },
         REQUEST_ATTEMPT_CANCELLATION: async (message) => {
           if (!this.executing) {
-            logger2.log("dropping cancel request, not executing", { status: this.#status });
+            logger.log("dropping cancel request, not executing", { status: this.#status });
             return;
           }
-          logger2.log("cancelling attempt", { attemptId: message.attemptId, status: this.#status });
+          logger.log("cancelling attempt", { attemptId: message.attemptId, status: this.#status });
           await this.#backgroundWorker.cancelAttempt(message.attemptId);
         },
         REQUEST_EXIT: async (message) => {
           if (message.version === "v2" && message.delayInMs) {
-            logger2.log("exit requested with delay", { delayInMs: message.delayInMs });
+            logger.log("exit requested with delay", { delayInMs: message.delayInMs });
             await setTimeout2(message.delayInMs);
           }
           this.#coordinatorSocket.close();
@@ -1242,15 +1229,15 @@ var ProdWorker = class {
           });
         }
       },
-      onConnection: async (socket, handler, sender, logger3) => {
-        logger3.log("connected to coordinator", { status: this.#status });
+      onConnection: async (socket, handler, sender, logger2) => {
+        logger2.log("connected to coordinator", { status: this.#status });
         if (this.waitForPostStart) {
-          logger3.log("skip connection handler, waiting for post start hook");
+          logger2.log("skip connection handler, waiting for post start hook");
           return;
         }
         if (this.paused) {
           if (!this.nextResumeAfter) {
-            logger3.error("Missing next resume reason", { status: this.#status });
+            logger2.error("Missing next resume reason", { status: this.#status });
             this.#emitUnrecoverableError(
               "NoNextResume",
               "Next resume reason not set while resuming from paused state"
@@ -1258,7 +1245,7 @@ var ProdWorker = class {
             return;
           }
           if (!this.attemptFriendlyId) {
-            logger3.error("Missing friendly ID", { status: this.#status });
+            logger2.error("Missing friendly ID", { status: this.#status });
             this.#emitUnrecoverableError(
               "NoAttemptId",
               "Attempt ID not set while resuming from paused state"
@@ -1282,15 +1269,16 @@ var ProdWorker = class {
               supportsLazyAttempts: true
             });
             if (success) {
-              logger3.info("indexing done, shutting down..");
+              logger2.info("indexing done, shutting down..");
               process.exit(0);
             } else {
-              logger3.info("indexing failure, shutting down..");
+              logger2.info("indexing failure, shutting down..");
               process.exit(1);
             }
           } catch (e) {
+            const stderr = this.#backgroundWorker.stderr.join("\n");
             if (e instanceof TaskMetadataParseError) {
-              logger3.error("tasks metadata parse error", {
+              logger2.error("tasks metadata parse error", {
                 zodIssues: e.zodIssues,
                 tasks: e.tasks
               });
@@ -1300,16 +1288,18 @@ var ProdWorker = class {
                 error: {
                   name: "TaskMetadataParseError",
                   message: "There was an error parsing the task metadata",
-                  stack: JSON.stringify({ zodIssues: e.zodIssues, tasks: e.tasks })
+                  stack: JSON.stringify({ zodIssues: e.zodIssues, tasks: e.tasks }),
+                  stderr
                 }
               });
             } else if (e instanceof UncaughtExceptionError) {
               const error = {
                 name: e.originalError.name,
                 message: e.originalError.message,
-                stack: e.originalError.stack
+                stack: e.originalError.stack,
+                stderr
               };
-              logger3.error("uncaught exception", { originalError: error });
+              logger2.error("uncaught exception", { originalError: error });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
@@ -1319,32 +1309,35 @@ var ProdWorker = class {
               const error = {
                 name: e.name,
                 message: e.message,
-                stack: e.stack
+                stack: e.stack,
+                stderr
               };
-              logger3.error("error", { error });
+              logger2.error("error", { error });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
                 error
               });
             } else if (typeof e === "string") {
-              logger3.error("string error", { error: { message: e } });
+              logger2.error("string error", { error: { message: e } });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
                 error: {
                   name: "Error",
-                  message: e
+                  message: e,
+                  stderr
                 }
               });
             } else {
-              logger3.error("unknown error", { error: e });
+              logger2.error("unknown error", { error: e });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
                 error: {
                   name: "Error",
-                  message: "Unknown error"
+                  message: "Unknown error",
+                  stderr
                 }
               });
             }
@@ -1361,8 +1354,8 @@ var ProdWorker = class {
           totalCompletions: this.completed.size
         });
       },
-      onError: async (socket, err, logger3) => {
-        logger3.error("onError", {
+      onError: async (socket, err, logger2) => {
+        logger2.error("onError", {
           error: {
             name: err.name,
             message: err.message
@@ -1370,14 +1363,14 @@ var ProdWorker = class {
         });
         await this.#reconnect();
       },
-      onDisconnect: async (socket, reason, description, logger3) => {
+      onDisconnect: async (socket, reason, description, logger2) => {
       }
     });
     return coordinatorConnection;
   }
   #createHttpServer() {
     const httpServer = createServer(async (req, res) => {
-      logger2.log(`[${req.method}]`, req.url);
+      logger.log(`[${req.method}]`, req.url);
       const reply = new HttpReply(res);
       try {
         const url = new URL(req.url ?? "", `http://${req.headers.host}`);
@@ -1410,7 +1403,7 @@ var ProdWorker = class {
           case "/preStop": {
             const cause = PreStopCauses.safeParse(url.searchParams.get("cause"));
             if (!cause.success) {
-              logger2.error("Failed to parse cause", { cause });
+              logger.error("Failed to parse cause", { cause });
               return reply.text("Failed to parse cause", 400);
             }
             switch (cause.data) {
@@ -1418,7 +1411,7 @@ var ProdWorker = class {
                 break;
               }
               default: {
-                logger2.error("Unhandled cause", { cause: cause.data });
+                logger.error("Unhandled cause", { cause: cause.data });
                 break;
               }
             }
@@ -1427,7 +1420,7 @@ var ProdWorker = class {
           case "/postStart": {
             const cause = PostStartCauses.safeParse(url.searchParams.get("cause"));
             if (!cause.success) {
-              logger2.error("Failed to parse cause", { cause });
+              logger.error("Failed to parse cause", { cause });
               return reply.text("Failed to parse cause", 400);
             }
             switch (cause.data) {
@@ -1442,7 +1435,7 @@ var ProdWorker = class {
                 break;
               }
               default: {
-                logger2.error("Unhandled cause", { cause: cause.data });
+                logger.error("Unhandled cause", { cause: cause.data });
                 break;
               }
             }
@@ -1453,7 +1446,7 @@ var ProdWorker = class {
           }
         }
       } catch (error) {
-        logger2.error("HTTP server error", { error });
+        logger.error("HTTP server error", { error });
         reply.empty(500);
       }
     });
@@ -1461,13 +1454,13 @@ var ProdWorker = class {
       socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
     });
     httpServer.on("listening", () => {
-      logger2.log("http server listening on port", this.#httpPort);
+      logger.log("http server listening on port", this.#httpPort);
     });
     httpServer.on("error", async (error) => {
       if (error.code != "EADDRINUSE") {
         return;
       }
-      logger2.error(`port ${this.#httpPort} already in use, retrying with random port..`);
+      logger.error(`port ${this.#httpPort} already in use, retrying with random port..`);
       this.#httpPort = getRandomPortNumber();
       await setTimeout2(100);
       this.start();
@@ -1530,7 +1523,7 @@ var ProdWorker = class {
     this.#httpServer.listen(this.#httpPort, this.host);
   }
 };
-var prodWorker = new ProdWorker(HTTP_SERVER_PORT2);
+var prodWorker = new ProdWorker(HTTP_SERVER_PORT);
 prodWorker.start();
 function gatherProcessEnv() {
   const env = {