better machine ID and don't send metrics in between runs in a warm process

Author: ericallam

packages/cli-v3/src/dev/taskRunProcessPool.ts

@@ -2,6 +2,7 @@ import {
   MachinePresetResources,
   ServerBackgroundWorker,
   WorkerManifest,
+  generateFriendlyId,
 } from "@trigger.dev/core/v3";
 import { TaskRunProcess } from "../executions/taskRunProcess.js";
 import { logger } from "../utilities/logger.js";
@@ -106,6 +107,7 @@ export class TaskRunProcessPool {
       env: {
         ...this.options.env,
         ...env,
+        TRIGGER_MACHINE_ID: generateFriendlyId("machine"),
       },
       serverWorker,
       machineResources,

packages/cli-v3/src/entryPoints/dev-run-worker.ts

@@ -213,6 +213,8 @@ async function doBootstrap() {
       forceFlushTimeoutMillis: 30_000,
       resource: config.telemetry?.resource,
       hostMetrics: true,
+      // Drop per-CPU per-state system.cpu metrics in dev to reduce noise
+      droppedMetrics: ["system.cpu.*"],
     });
 
     const otelTracer: Tracer = tracingSDK.getTracer("trigger-dev-worker", VERSION);
@@ -622,8 +624,11 @@ const zodIpc = new ZodIpcConnection({
       }
       await flushAll(timeoutInMs);
     },
-    FLUSH: async ({ timeoutInMs }) => {
+    FLUSH: async ({ timeoutInMs, disableContext }) => {
       await flushAll(timeoutInMs);
+      if (disableContext) {
+        taskContext.disable();
+      }
     },
     RESOLVE_WAITPOINT: async ({ waitpoint }) => {
       _sharedWorkerRuntime?.resolveWaitpoints([waitpoint]);

packages/cli-v3/src/entryPoints/managed-run-worker.ts

@@ -610,8 +610,11 @@ const zodIpc = new ZodIpcConnection({
       }
       await flushAll(timeoutInMs);
     },
-    FLUSH: async ({ timeoutInMs }) => {
+    FLUSH: async ({ timeoutInMs, disableContext }) => {
       await flushAll(timeoutInMs);
+      if (disableContext) {
+        taskContext.disable();
+      }
     },
     RESOLVE_WAITPOINT: async ({ waitpoint }) => {
       _sharedWorkerRuntime?.resolveWaitpoints([waitpoint]);

packages/cli-v3/src/entryPoints/managed/taskRunProcessProvider.ts

@@ -1,4 +1,4 @@
-import { WorkerManifest } from "@trigger.dev/core/v3";
+import { WorkerManifest, generateFriendlyId } from "@trigger.dev/core/v3";
 import { TaskRunProcess } from "../../executions/taskRunProcess.js";
 import { RunnerEnv } from "./env.js";
 import { RunLogger, SendDebugLogOptions } from "./logger.js";
@@ -22,6 +22,7 @@ export class TaskRunProcessProvider {
   private readonly logger: RunLogger;
   private readonly processKeepAliveEnabled: boolean;
   private readonly processKeepAliveMaxExecutionCount: number;
+  private readonly machineId = generateFriendlyId("machine");
 
   // Process keep-alive state
   private persistentProcess: TaskRunProcess | null = null;
@@ -269,6 +270,7 @@ export class TaskRunProcessProvider {
     return {
       ...taskRunEnv,
       ...this.env.gatherProcessEnv(),
+      TRIGGER_MACHINE_ID: this.machineId,
       HEARTBEAT_INTERVAL_MS: String(this.env.TRIGGER_HEARTBEAT_INTERVAL_SECONDS * 1000),
     };
   }

packages/cli-v3/src/executions/taskRunProcess.ts

@@ -126,7 +126,7 @@ export class TaskRunProcess {
       return;
     }
 
-    await tryCatch(this.#flush());
+    await tryCatch(this.#flush({ disableContext: !kill }));
 
     if (kill) {
       await this.#gracefullyTerminate(this.options.gracefulTerminationTimeoutInMs);
@@ -240,10 +240,10 @@ export class TaskRunProcess {
     return this;
   }
 
-  async #flush(timeoutInMs: number = 5_000) {
+  async #flush({ timeoutInMs = 5_000, disableContext = false } = {}) {
     logger.debug("flushing task run process", { pid: this.pid });
 
-    await this._ipc?.sendWithAck("FLUSH", { timeoutInMs }, timeoutInMs + 1_000);
+    await this._ipc?.sendWithAck("FLUSH", { timeoutInMs, disableContext }, timeoutInMs + 1_000);
   }
 
   async #cancel(timeoutInMs: number = 30_000) {

packages/core/src/v3/index.ts

@@ -49,6 +49,7 @@ export {
   NULL_SENTINEL,
 } from "./utils/flattenAttributes.js";
 export { omit } from "./utils/omit.js";
+export { generateFriendlyId, fromFriendlyId } from "./isomorphic/friendlyId.js";
 export {
   calculateNextRetryDelay,
   calculateResetAt,

packages/core/src/v3/otel/machineId.ts

@@ -1,3 +1,4 @@
-import { randomUUID } from "crypto";
+import { generateFriendlyId } from "../isomorphic/friendlyId.js";
+import { getEnvVar } from "../utils/getEnv.js";
 
-export const machineId = randomUUID();
+export const machineId = getEnvVar("TRIGGER_MACHINE_ID") ?? generateFriendlyId("machine");

packages/core/src/v3/otel/tracingSDK.ts

@@ -28,6 +28,7 @@ import {
   SimpleLogRecordProcessor,
 } from "@opentelemetry/sdk-logs";
 import {
+  AggregationType,
   MeterProvider,
   PeriodicExportingMetricReader,
   type MetricReader,
@@ -82,6 +83,8 @@ export type TracingSDKConfig = {
   diagLogLevel?: TracingDiagnosticLogLevel;
   resource?: Resource;
   hostMetrics?: boolean;
+  /** Metric instrument name patterns to drop (supports wildcards, e.g. "system.cpu.*") */
+  droppedMetrics?: string[];
 };
 
 const idGenerator = new RandomIdGenerator();
@@ -300,6 +303,10 @@ export class TracingSDK {
     const meterProvider = new MeterProvider({
       resource: commonResources,
       readers: metricReaders,
+      views: (config.droppedMetrics ?? []).map((pattern) => ({
+        instrumentName: pattern,
+        aggregation: { type: AggregationType.DROP },
+      })),
     });
 
     this._meterProvider = meterProvider;

packages/core/src/v3/schemas/messages.ts

@@ -213,6 +213,7 @@ export const WorkerToExecutorMessageCatalog = {
   FLUSH: {
     message: z.object({
       timeoutInMs: z.number(),
+      disableContext: z.boolean().optional(),
     }),
     callback: z.void(),
   },

packages/core/src/v3/taskContext/otelProcessors.ts

@@ -1,5 +1,5 @@
 import { Attributes, Context, trace, Tracer } from "@opentelemetry/api";
-import { ExportResult } from "@opentelemetry/core";
+import { ExportResult, ExportResultCode } from "@opentelemetry/core";
 import { LogRecordProcessor, SdkLogRecord } from "@opentelemetry/sdk-logs";
 import type {
   AggregationOption,
@@ -130,7 +130,8 @@ export class TaskContextMetricExporter implements PushMetricExporter {
 
   export(metrics: ResourceMetrics, resultCallback: (result: ExportResult) => void): void {
     if (!taskContext.ctx) {
-      this._innerExporter.export(metrics, resultCallback);
+      // No active run — drop metrics (between-run noise)
+      resultCallback({ code: ExportResultCode.SUCCESS });
       return;
     }