refactor(supervisor,webapp): remove the compute gateway path

Remove the unused compute gateway integration from the supervisor and webapp, along with the internal compute client package.

Mono-RevId: 7fad1730cdc6eac639f9df2300a599732d3b0a5d

Author: 1stvamp

apps/supervisor/package.json

@@ -16,7 +16,6 @@
   },
   "dependencies": {
     "@aws-sdk/client-ecr": "^3.839.0",
-    "@internal/compute": "workspace:*",
     "@kubernetes/client-node": "^1.0.0",
     "@trigger.dev/core": "workspace:*",
     "dockerode": "^4.0.6",

apps/supervisor/src/env.test.ts

@@ -78,7 +78,11 @@ describe("worker queue selection", () => {
   it.each([
     { config: {}, subscription: { ...ondemand, compat: "compute" }, error: "compatibility" },
     {
-      config: { COMPUTE_GATEWAY_URL: "http://localhost:8080" },
+      config: {
+        KUBERNETES_FORCE_ENABLED: "true",
+        KUBERNETES_RUN_CRD_ENABLED: "true",
+        KUBERNETES_RUNNER_RUNTIME: "microvm",
+      },
       subscription: ondemand,
       error: "compatibility",
     },
@@ -106,7 +110,7 @@ describe("worker queue selection", () => {
   );
 
   it.each(["ondemand", "scheduled"])(
-    "accepts %s compute restores on the native microVM Runner backend without a gateway",
+    "accepts %s compute restores on the native microVM Runner backend",
     (queueClass) => {
       expect(() =>
         Env.parse({
@@ -123,11 +127,13 @@ describe("worker queue selection", () => {
     }
   );
 
-  it("accepts shared fresh work and compute restores on the compute backend", () => {
+  it("accepts shared fresh work and compute restores on the native microVM Runner backend", () => {
     expect(() =>
       Env.parse({
         ...base,
-        COMPUTE_GATEWAY_URL: "http://localhost:8080",
+        KUBERNETES_FORCE_ENABLED: "true",
+        KUBERNETES_RUN_CRD_ENABLED: "true",
+        KUBERNETES_RUNNER_RUNTIME: "microvm",
         TRIGGER_WORKER_QUEUE_SUBSCRIPTIONS: JSON.stringify([
           { ...ondemand, compat: "any" },
           { ...restore, compat: "compute" },
@@ -178,16 +184,3 @@ describe("Env superRefine - backpressure source awareness", () => {
     ).toThrow();
   });
 });
-
-describe("Env superRefine - compute snapshots", () => {
-  it("needs the metadata URL and workload API domain only for the gateway", () => {
-    expect(() => Env.parse({ ...base, COMPUTE_SNAPSHOTS_ENABLED: "true" })).not.toThrow();
-    expect(() =>
-      Env.parse({
-        ...base,
-        COMPUTE_SNAPSHOTS_ENABLED: "true",
-        COMPUTE_GATEWAY_URL: "http://gateway:8080",
-      })
-    ).toThrow(/TRIGGER_METADATA_URL[\s\S]*TRIGGER_WORKLOAD_API_DOMAIN/);
-  });
-});

apps/supervisor/src/env.ts

@@ -180,22 +180,9 @@ export const Env = z
     DOCKER_RUNNER_NETWORKS: z.string().default("host"),
 
     // Compute settings
-    COMPUTE_GATEWAY_URL: z.string().url().optional(),
-    COMPUTE_GATEWAY_AUTH_TOKEN: z.string().optional(),
-    COMPUTE_GATEWAY_TIMEOUT_MS: z.coerce.number().int().default(30_000),
     COMPUTE_SNAPSHOTS_ENABLED: BoolEnv.default(false),
-    COMPUTE_TRACE_SPANS_ENABLED: BoolEnv.default(true),
-    COMPUTE_TRACE_OTLP_ENDPOINT: z.string().url().optional(), // Override for span export (derived from TRIGGER_API_URL if unset)
     COMPUTE_SNAPSHOT_DELAY_MS: z.coerce.number().int().min(0).max(60_000).default(5_000),
     COMPUTE_SNAPSHOT_DISPATCH_LIMIT: z.coerce.number().int().min(1).max(100).default(10),
-    // Instance create retries for transient placement failures (1 = no retries)
-    COMPUTE_INSTANCE_CREATE_MAX_ATTEMPTS: z.coerce.number().int().min(1).max(10).default(3),
-    COMPUTE_INSTANCE_CREATE_RETRY_BASE_DELAY_MS: z.coerce
-      .number()
-      .int()
-      .min(0)
-      .max(10_000)
-      .default(250),
 
     // Kubernetes settings
     KUBERNETES_FORCE_ENABLED: BoolEnv.default(false),
@@ -382,7 +369,7 @@ export const Env = z
         data.KUBERNETES_FORCE_ENABLED &&
         data.KUBERNETES_RUN_CRD_ENABLED &&
         data.KUBERNETES_RUNNER_RUNTIME === "microvm";
-      const compatibility = data.COMPUTE_GATEWAY_URL || nativeMicrovm ? "compute" : "container";
+      const compatibility = nativeMicrovm ? "compute" : "container";
 
       for (const [index, subscription] of data.TRIGGER_WORKER_QUEUE_SUBSCRIPTIONS.entries()) {
         if (subscription.compat !== "any" && subscription.compat !== compatibility) {
@@ -393,13 +380,12 @@ export const Env = z
           });
         } else if (
           subscription.phase === "restore" &&
-          !(compatibility === "compute"
-            ? data.COMPUTE_GATEWAY_URL || nativeMicrovm
-            : data.TRIGGER_CHECKPOINT_URL)
+          compatibility === "container" &&
+          !data.TRIGGER_CHECKPOINT_URL
         ) {
           ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: `Restore subscriptions require ${compatibility === "compute" ? "COMPUTE_GATEWAY_URL" : "TRIGGER_CHECKPOINT_URL"}`,
+            message: "Restore subscriptions require TRIGGER_CHECKPOINT_URL",
             path: ["TRIGGER_WORKER_QUEUE_SUBSCRIPTIONS", index],
           });
         }
@@ -434,26 +420,6 @@ export const Env = z
         }
       }
     }
-    // Only the gateway reads these for a snapshot: it builds its callback URL
-    // from the domain and hands the metadata URL to the instance.
-    if (data.COMPUTE_SNAPSHOTS_ENABLED && data.COMPUTE_GATEWAY_URL && !data.TRIGGER_METADATA_URL) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "TRIGGER_METADATA_URL is required when COMPUTE_SNAPSHOTS_ENABLED is true",
-        path: ["TRIGGER_METADATA_URL"],
-      });
-    }
-    if (
-      data.COMPUTE_SNAPSHOTS_ENABLED &&
-      data.COMPUTE_GATEWAY_URL &&
-      !data.TRIGGER_WORKLOAD_API_DOMAIN
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "TRIGGER_WORKLOAD_API_DOMAIN is required when COMPUTE_SNAPSHOTS_ENABLED is true",
-        path: ["TRIGGER_WORKLOAD_API_DOMAIN"],
-      });
-    }
     if (data.WORKLOAD_TOKEN_ENFORCEMENT !== "disabled" && !data.WORKLOAD_TOKEN_SECRET) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
@@ -487,7 +453,6 @@ export const Env = z
     TRIGGER_WORKER_QUEUE_CLASS:
       data.TRIGGER_WORKER_QUEUE_CLASS ??
       (data.TRIGGER_WORKER_QUEUE_SUBSCRIPTIONS === undefined ? "default" : undefined),
-    COMPUTE_TRACE_OTLP_ENDPOINT: data.COMPUTE_TRACE_OTLP_ENDPOINT ?? `${data.TRIGGER_API_URL}/otel`,
   }));
 
 export const env = Env.parse(stdEnv);

apps/supervisor/src/index.ts

@@ -25,7 +25,6 @@ import {
 } from "./workloadManager/runCrd.js";
 import { RestoreWatcher, type RestoreFailure } from "./services/restoreWatcher.js";
 import { DockerWorkloadManager } from "./workloadManager/docker.js";
-import { ComputeWorkloadManager } from "./workloadManager/compute.js";
 import {
   HttpServer,
   CheckpointClient,
@@ -41,12 +40,11 @@ import { FailedPodHandler } from "./services/failedPodHandler.js";
 import { DequeueDrain } from "./services/dequeueDrain.js";
 import { getWorkerToken } from "./workerToken.js";
 import { mintDeploymentToken } from "./workloadToken.js";
-import { OtlpTraceService } from "./services/otlpTraceService.js";
 import {
   WarmStartVerificationService,
   type WarmStartTimings,
 } from "./services/warmStartVerificationService.js";
-import { extractTraceparent, getRestoreRunnerId } from "./util.js";
+import { extractTraceparent } from "./util.js";
 import { Redis } from "ioredis";
 import { BackpressureMonitor } from "./backpressure/backpressureMonitor.js";
 import { RedisBackpressureSignalSource } from "./backpressure/redisBackpressureSignalSource.js";
@@ -101,8 +99,7 @@ class ManagedSupervisor {
   private readonly metricsServer?: HttpServer;
   private readonly workloadServer: WorkloadServer;
   private readonly workloadManager: WorkloadManager;
-  private readonly workloadManagerBackend: "compute" | "kubernetes" | "run-crd" | "docker";
-  private readonly computeManager?: ComputeWorkloadManager;
+  private readonly workloadManagerBackend: "kubernetes" | "run-crd" | "docker";
   private readonly runCrdManager?: RunCrdWorkloadManager;
   private readonly restoreInformer?: RunnerRestoreInformer;
   private readonly restoreWatcher?: RestoreWatcher;
@@ -113,7 +110,6 @@ class ManagedSupervisor {
 
   private readonly podCleaner?: PodCleaner;
   private readonly failedPodHandler?: FailedPodHandler;
-  private readonly tracing?: OtlpTraceService;
   private readonly backpressureMonitors: BackpressureMonitor[] = [];
   private readonly backpressureRedis?: Redis;
 
@@ -135,7 +131,6 @@ class ManagedSupervisor {
     const {
       TRIGGER_WORKER_TOKEN,
       MANAGED_WORKER_SECRET,
-      COMPUTE_GATEWAY_AUTH_TOKEN,
       DOCKER_REGISTRY_PASSWORD,
       TRIGGER_DEQUEUE_BACKPRESSURE_REDIS_PASSWORD,
       WORKLOAD_TOKEN_SECRET,
@@ -172,48 +167,7 @@ class ManagedSupervisor {
         : new DockerResourceMonitor(new Docker())
       : new NoopResourceMonitor();
 
-    if (env.COMPUTE_GATEWAY_URL) {
-      if (!env.TRIGGER_WORKLOAD_API_DOMAIN) {
-        throw new Error("TRIGGER_WORKLOAD_API_DOMAIN is not set, cannot create compute manager");
-      }
-
-      const callbackUrl = `${env.TRIGGER_WORKLOAD_API_PROTOCOL}://${env.TRIGGER_WORKLOAD_API_DOMAIN}:${env.TRIGGER_WORKLOAD_API_PORT_EXTERNAL}/api/v1/compute/snapshot-complete`;
-
-      if (env.COMPUTE_TRACE_SPANS_ENABLED) {
-        this.tracing = new OtlpTraceService({
-          endpointUrl: env.COMPUTE_TRACE_OTLP_ENDPOINT,
-        });
-      }
-
-      const computeManager = new ComputeWorkloadManager({
-        ...workloadManagerOptions,
-        gateway: {
-          url: env.COMPUTE_GATEWAY_URL,
-          authToken: env.COMPUTE_GATEWAY_AUTH_TOKEN,
-          timeoutMs: env.COMPUTE_GATEWAY_TIMEOUT_MS,
-        },
-        snapshots: {
-          enabled: env.COMPUTE_SNAPSHOTS_ENABLED,
-          delayMs: env.COMPUTE_SNAPSHOT_DELAY_MS,
-          dispatchLimit: env.COMPUTE_SNAPSHOT_DISPATCH_LIMIT,
-          callbackUrl,
-        },
-        tracing: this.tracing,
-        runner: {
-          instanceName: env.TRIGGER_WORKER_INSTANCE_NAME,
-          otelEndpoint: env.OTEL_EXPORTER_OTLP_ENDPOINT,
-          prettyLogs: env.RUNNER_PRETTY_LOGS,
-          sendRunDebugLogs: env.SEND_RUN_DEBUG_LOGS,
-        },
-        createRetry: {
-          maxAttempts: env.COMPUTE_INSTANCE_CREATE_MAX_ATTEMPTS,
-          baseDelayMs: env.COMPUTE_INSTANCE_CREATE_RETRY_BASE_DELAY_MS,
-        },
-      });
-      this.computeManager = computeManager;
-      this.workloadManager = computeManager;
-      this.workloadManagerBackend = "compute";
-    } else if (this.isKubernetes && env.KUBERNETES_RUN_CRD_ENABLED) {
+    if (this.isKubernetes && env.KUBERNETES_RUN_CRD_ENABLED) {
       // Only a process that dequeues creates resumes, and only the microvm lane restores.
       if (
         env.KUBERNETES_RUNNER_RESTORE_INFORMER_ENABLED &&
@@ -522,66 +476,10 @@ class ManagedSupervisor {
 
             const { checkpoint, ...rest } = message;
 
-            // Register trace context early so snapshot spans work for all paths
-            // (cold create, restore, warm start). Re-registration on restore is safe
-            // since dequeue always provides fresh context.
-            if (this.computeManager?.traceSpansEnabled && traceparent) {
-              this.workloadServer.registerRunTraceContext(message.run.friendlyId, {
-                traceparent,
-                envId: message.environment.id,
-                orgId: message.organization.id,
-                projectId: message.project.id,
-              });
-            }
-
             if (checkpoint) {
               setExtra(fromContext(), "path_taken", "restore");
               this.logger.debug("Restoring run", { runId: message.run.id });
 
-              if (this.computeManager) {
-                const restoreStart = performance.now();
-                try {
-                  const runnerId = getRestoreRunnerId(message.run.friendlyId, checkpoint.id);
-
-                  const didRestore = await this.computeManager.restore({
-                    snapshotId: checkpoint.location,
-                    runnerId,
-                    runFriendlyId: message.run.friendlyId,
-                    snapshotFriendlyId: message.snapshot.friendlyId,
-                    machine: message.run.machine,
-                    traceContext: message.run.traceContext,
-                    envId: message.environment.id,
-                    orgId: message.organization.id,
-                    projectId: message.project.id,
-                    hasPrivateLink: message.organization.hasPrivateLink,
-                    dequeuedAt: message.dequeuedAt,
-                  });
-                  recordPhaseSince("restore", restoreStart, undefined);
-                  setExtra(fromContext(), "did_restore", didRestore);
-
-                  if (didRestore) {
-                    this.logger.debug("Compute restore successful", {
-                      runId: message.run.id,
-                      runnerId,
-                    });
-                  } else {
-                    this.logger.error("Compute restore failed", {
-                      runId: message.run.id,
-                      runnerId,
-                    });
-                  }
-                } catch (error) {
-                  recordPhaseSince(
-                    "restore",
-                    restoreStart,
-                    error instanceof Error ? error : new Error(String(error))
-                  );
-                  this.logger.error("Failed to restore run (compute)", { error });
-                }
-
-                return;
-              }
-
               if (this.runCrdManager?.restores(checkpoint)) {
                 await this.restoreRunner(this.runCrdManager, message, checkpoint);
                 return;
@@ -673,10 +571,7 @@ class ManagedSupervisor {
       host: env.TRIGGER_WORKLOAD_API_HOST_INTERNAL,
       workerClient: this.workerSession.httpClient,
       checkpointClient: this.checkpointClient,
-      computeManager: this.computeManager,
       runnerSnapshotter: this.runCrdManager,
-      tracing: this.tracing,
-      snapshotCallbackSecret: workerToken,
       wideEventOpts: this.wideEventOpts,
       wideEventsNoisyRoutes: this.wideEventsNoisyRoutes,
     });