Merge branch 'w1-ro-taskdetail-taskdetailpresenter-getactivity-split-neutral-verify' into integration-batch-01

Author: d-cs

.server-changes/verify-taskdetail-activity-split-neutral.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Add a ClickHouse testcontainer test pinning `TaskDetailPresenter.getActivity` as verified ClickHouse-only (task_runs_v2) and classified split-neutral for the run-ops DB split.

apps/webapp/app/presenters/v3/TaskDetailPresenter.server.ts

@@ -162,6 +162,8 @@ export class TaskDetailPresenter {
     };
   }
 
+  // SPLIT-NEUTRAL (W1-RO-TASKDETAIL): served entirely from ClickHouse (task_runs_v2);
+  // no run-ops Postgres read — single-DB behavior is n-a, RoutingRunStore is not involved.
   async getActivity({
     organizationId,
     projectId,

apps/webapp/test/presenters/TaskDetailPresenter.getActivity.test.ts

@@ -0,0 +1,159 @@
+// SPLIT-NEUTRAL VERIFICATION (W1-RO-TASKDETAIL): getActivity reads ClickHouse
+// (task_runs_v2) ONLY and never touches the run-ops Prisma client. The hetero
+// PG14/PG17 fixture is deliberately not applicable here — there is no run-ops
+// Postgres read to validate cross-version. The throwing Proxy passed as
+// `replica` proves it: any access throws, so a passing test is the proof.
+
+import { describe, expect, vi } from "vitest";
+import { clickhouseTest } from "@internal/testcontainers";
+import { ClickHouse, type TaskRunV2 } from "@internal/clickhouse";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { TaskDetailPresenter } from "~/presenters/v3/TaskDetailPresenter.server";
+
+vi.setConfig({ testTimeout: 60_000 });
+
+const organizationId = "org_activity_test";
+const projectId = "project_activity_test";
+const environmentId = "env_activity_test";
+const taskSlug = "my-activity-task";
+
+function makeRun(overrides: Partial<TaskRunV2>): TaskRunV2 {
+  const createdAt = overrides.created_at ?? Date.now();
+  return {
+    environment_id: environmentId,
+    organization_id: organizationId,
+    project_id: projectId,
+    run_id: `run_${randomUUID()}`,
+    friendly_id: `friendly_${randomUUID()}`,
+    updated_at: createdAt,
+    created_at: createdAt,
+    status: "COMPLETED_SUCCESSFULLY",
+    environment_type: "PRODUCTION",
+    attempt: 1,
+    engine: "V2",
+    task_identifier: taskSlug,
+    queue: "my-queue",
+    schedule_id: "",
+    batch_id: "",
+    task_version: "",
+    sdk_version: "",
+    cli_version: "",
+    machine_preset: "",
+    root_run_id: "",
+    parent_run_id: "",
+    span_id: "",
+    trace_id: "",
+    idempotency_key: "",
+    expiration_ttl: "",
+    _version: "1",
+    _is_deleted: 0,
+    ...overrides,
+  };
+}
+
+describe("TaskDetailPresenter.getActivity (ClickHouse-only)", () => {
+  clickhouseTest(
+    "buckets task_runs_v2 activity by status group, excludes deleted, never reads Postgres",
+    async ({ clickhouseContainer }) => {
+      const clickhouse = new ClickHouse({
+        url: clickhouseContainer.getConnectionUrl(),
+        name: "task-detail-activity-test",
+        compression: { request: true },
+      });
+
+      const insert = clickhouse.writer.insert({
+        name: "insertTaskRunsActivityTest",
+        table: "trigger_dev.task_runs_v2",
+        schema: z.any(),
+        settings: { async_insert: 0, enable_json_type: 1, type_json_skip_duplicated_paths: 1 },
+      });
+
+      // 6h window => 1h buckets => 6 buckets.
+      const from = new Date("2026-01-01T00:00:00Z");
+      const to = new Date("2026-01-01T06:00:00Z");
+
+      // Bucket 0 (00:00–01:00): 1 COMPLETED, 1 FAILED.
+      // Bucket 2 (02:00–03:00): 1 CANCELED, 1 RUNNING (EXECUTING), 1 unknown-status
+      //   (folds into RUNNING) => RUNNING total = 2.
+      // Plus a deleted row in bucket 0 that MUST be excluded.
+      const bucket0 = new Date("2026-01-01T00:30:00Z").getTime();
+      const bucket2 = new Date("2026-01-01T02:30:00Z").getTime();
+
+      const rows = [
+        makeRun({ created_at: bucket0, status: "COMPLETED_SUCCESSFULLY" }),
+        makeRun({ created_at: bucket0, status: "CRASHED" }), // FAILED group
+        makeRun({ created_at: bucket2, status: "CANCELED" }), // CANCELED group
+        makeRun({ created_at: bucket2, status: "EXECUTING" }), // RUNNING group
+        makeRun({ created_at: bucket2, status: "SOME_UNKNOWN_STATUS" }), // folds into RUNNING
+        // Deleted row — distinct run, _is_deleted = 1, must NOT be counted.
+        makeRun({ created_at: bucket0, status: "COMPLETED_SUCCESSFULLY", _is_deleted: 1 }),
+      ];
+
+      const [insertError] = await insert(rows);
+      expect(insertError).toBeNull();
+
+      const throwingReplica = new Proxy(
+        {},
+        {
+          get() {
+            throw new Error("getActivity must not touch the run-ops Prisma client");
+          },
+        }
+      ) as never;
+
+      const presenter = new TaskDetailPresenter(throwingReplica, clickhouse);
+
+      const activity = await presenter.getActivity({
+        organizationId,
+        projectId,
+        environmentId,
+        taskSlug,
+        from,
+        to,
+      });
+
+      // Stable legend, fixed group order.
+      expect(activity.statuses).toEqual(["COMPLETED", "FAILED", "CANCELED", "RUNNING"]);
+
+      // 6 one-hour buckets, every bucket carries all four group keys.
+      expect(activity.data).toHaveLength(6);
+      for (const point of activity.data) {
+        expect(typeof point.bucket).toBe("number");
+        expect(point).toHaveProperty("COMPLETED");
+        expect(point).toHaveProperty("FAILED");
+        expect(point).toHaveProperty("CANCELED");
+        expect(point).toHaveProperty("RUNNING");
+      }
+
+      // Buckets are epoch MILLISECONDS aligned to the hour.
+      const expectedStart = Math.floor(from.getTime() / (60 * 60 * 1000)) * (60 * 60 * 1000);
+      const byBucket = new Map(activity.data.map((p) => [p.bucket, p]));
+      const p0 = byBucket.get(expectedStart)!;
+      const p2 = byBucket.get(expectedStart + 2 * 60 * 60 * 1000)!;
+      expect(p0).toBeDefined();
+      expect(p2).toBeDefined();
+
+      // Bucket 0: 1 COMPLETED, 1 FAILED, deleted row excluded.
+      expect(p0.COMPLETED).toBe(1);
+      expect(p0.FAILED).toBe(1);
+      expect(p0.CANCELED).toBe(0);
+      expect(p0.RUNNING).toBe(0);
+
+      // Bucket 2: 1 CANCELED, RUNNING = EXECUTING (1) + unknown status (1) = 2.
+      expect(p2.COMPLETED).toBe(0);
+      expect(p2.FAILED).toBe(0);
+      expect(p2.CANCELED).toBe(1);
+      expect(p2.RUNNING).toBe(2);
+
+      // Every other bucket is all-zero for every group.
+      for (const point of activity.data) {
+        if (point.bucket === p0.bucket || point.bucket === p2.bucket) continue;
+        expect(point.COMPLETED).toBe(0);
+        expect(point.FAILED).toBe(0);
+        expect(point.CANCELED).toBe(0);
+        expect(point.RUNNING).toBe(0);
+      }
+    }
+  );
+});