feat(webapp): record deployment outcome span at terminal status

Author: nicktrn

apps/webapp/app/v3/services/createDeploymentBackgroundWorkerV4.server.ts

@@ -15,6 +15,7 @@ import {
 } from "./createBackgroundWorker.server";
 import { findOrCreateBackgroundWorker } from "./createDeploymentBackgroundWorkerV4/findOrCreateBackgroundWorker.server";
 import { TimeoutDeploymentService } from "./timeoutDeployment.server";
+import { recordDeploymentOutcome } from "./recordDeploymentOutcome.server";
 import { env } from "~/env.server";
 
 export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
@@ -297,6 +298,14 @@ export class CreateDeploymentBackgroundWorkerServiceV4 extends BaseService {
       // sibling attempt may have just enqueued it as part of a successful
       // BUILDING → DEPLOYING transition.
       await TimeoutDeploymentService.dequeue(deployment.id, this._prisma);
+
+      recordDeploymentOutcome({
+        status: "FAILED",
+        deploymentFriendlyId: deployment.friendlyId,
+        projectId: deployment.projectId,
+        environmentId: deployment.environmentId,
+        reason: error.message,
+      });
     }
 
     throw error;

apps/webapp/app/v3/services/deploymentIndexFailed.server.ts

@@ -3,6 +3,7 @@ import { BaseService } from "./baseService.server";
 import { logger } from "~/services/logger.server";
 import { type WorkerDeploymentStatus } from "@trigger.dev/database";
 import { DeploymentService } from "./deployment.server";
+import { recordDeploymentOutcome } from "./recordDeploymentOutcome.server";
 
 const FINAL_DEPLOYMENT_STATUSES: WorkerDeploymentStatus[] = [
   "CANCELED",
@@ -74,6 +75,16 @@ export class DeploymentIndexFailed extends BaseService {
       },
     });
 
+    recordDeploymentOutcome({
+      status: "FAILED",
+      deploymentFriendlyId: deployment.friendlyId,
+      organizationId: deployment.environment.project.organizationId,
+      projectId: deployment.environment.projectId,
+      environmentId: deployment.environmentId,
+      environmentType: deployment.environment.type,
+      reason: error.message,
+    });
+
     const deploymentService = new DeploymentService();
     await deploymentService
       .appendToEventLog(deployment.environment.project, failedDeployment, [

apps/webapp/app/v3/services/failDeployment.server.ts

@@ -5,6 +5,7 @@ import { type WorkerDeploymentStatus } from "@trigger.dev/database";
 import { type FailDeploymentRequestBody } from "@trigger.dev/core/v3/schemas";
 import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { DeploymentService } from "./deployment.server";
+import { recordDeploymentOutcome } from "./recordDeploymentOutcome.server";
 
 export const FINAL_DEPLOYMENT_STATUSES: WorkerDeploymentStatus[] = [
   "CANCELED",
@@ -51,6 +52,16 @@ export class FailDeploymentService extends BaseService {
       },
     });
 
+    recordDeploymentOutcome({
+      status: "FAILED",
+      deploymentFriendlyId: friendlyId,
+      organizationId: authenticatedEnv.organizationId,
+      projectId: authenticatedEnv.projectId,
+      environmentId: authenticatedEnv.id,
+      environmentType: authenticatedEnv.type,
+      reason: params.error.message,
+    });
+
     const deploymentService = new DeploymentService();
     await deploymentService
       .appendToEventLog(authenticatedEnv.project, failedDeployment, [

apps/webapp/app/v3/services/finalizeDeployment.server.ts

@@ -10,6 +10,7 @@ import { projectPubSub } from "./projectPubSub.server";
 import { FailDeploymentService } from "./failDeployment.server";
 import { TimeoutDeploymentService } from "./timeoutDeployment.server";
 import { DeploymentService } from "./deployment.server";
+import { recordDeploymentOutcome } from "./recordDeploymentOutcome.server";
 import { engine } from "../runEngine.server";
 import { tryCatch } from "@trigger.dev/core";
 
@@ -78,6 +79,15 @@ export class FinalizeDeploymentService extends BaseService {
       },
     });
 
+    recordDeploymentOutcome({
+      status: "DEPLOYED",
+      deploymentFriendlyId: deployment.friendlyId,
+      organizationId: authenticatedEnv.organizationId,
+      projectId: authenticatedEnv.projectId,
+      environmentId: authenticatedEnv.id,
+      environmentType: authenticatedEnv.type,
+    });
+
     const deploymentService = new DeploymentService();
     await deploymentService
       .appendToEventLog(authenticatedEnv.project, finalizedDeployment, [

apps/webapp/app/v3/services/recordDeploymentOutcome.server.ts

@@ -0,0 +1,50 @@
+import { SpanStatusCode } from "@opentelemetry/api";
+import { type WorkerDeploymentStatus } from "@trigger.dev/database";
+import { logger } from "~/services/logger.server";
+import { tracer } from "~/v3/tracer.server";
+
+type TerminalDeploymentStatus = Extract<
+  WorkerDeploymentStatus,
+  "DEPLOYED" | "FAILED" | "TIMED_OUT" | "CANCELED"
+>;
+
+/**
+ * Records a deployment's terminal status as a `deployment.outcome` span so
+ * deploy success/failure is queryable from traces (no DB read). Call after each
+ * terminal-status write. Org/project/env are best-effort; never throws.
+ */
+export function recordDeploymentOutcome(params: {
+  status: TerminalDeploymentStatus;
+  deploymentFriendlyId: string;
+  organizationId?: string;
+  projectId?: string;
+  environmentId?: string;
+  environmentType?: string;
+  reason?: string;
+}): void {
+  try {
+    const span = tracer.startSpan("deployment.outcome", {
+      attributes: {
+        "$trigger.org.id": params.organizationId,
+        "$trigger.project.id": params.projectId,
+        "$trigger.env.id": params.environmentId,
+        "$trigger.env.type": params.environmentType,
+        "deployment.outcome.status": params.status,
+        "deployment.outcome.success": params.status === "DEPLOYED",
+        "deployment.outcome.deployment_id": params.deploymentFriendlyId,
+        "deployment.outcome.reason": params.reason,
+      },
+    });
+
+    if (params.status !== "DEPLOYED") {
+      span.setStatus({ code: SpanStatusCode.ERROR, message: params.reason });
+    }
+
+    span.end();
+  } catch (error) {
+    logger.debug("recordDeploymentOutcome failed", {
+      deploymentFriendlyId: params.deploymentFriendlyId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}

apps/webapp/app/v3/services/timeoutDeployment.server.ts

@@ -5,6 +5,7 @@ import { PerformDeploymentAlertsService } from "./alerts/performDeploymentAlerts
 import { type PrismaClientOrTransaction } from "~/db.server";
 import { workerQueue } from "~/services/worker.server";
 import { DeploymentService } from "./deployment.server";
+import { recordDeploymentOutcome } from "./recordDeploymentOutcome.server";
 
 export class TimeoutDeploymentService extends BaseService {
   public async call(id: string, fromStatus: string, errorMessage: string) {
@@ -48,6 +49,16 @@ export class TimeoutDeploymentService extends BaseService {
       },
     });
 
+    recordDeploymentOutcome({
+      status: "TIMED_OUT",
+      deploymentFriendlyId: deployment.friendlyId,
+      organizationId: deployment.environment.project.organizationId,
+      projectId: deployment.environment.projectId,
+      environmentId: deployment.environmentId,
+      environmentType: deployment.environment.type,
+      reason: errorMessage,
+    });
+
     const deploymentService = new DeploymentService();
     await deploymentService
       .appendToEventLog(deployment.environment.project, timedOutDeployment, [