Merge feat/run-ops-shards-tri-13429 into feat/sentinels-replication-n-tri-13432

Author: d-cs

.changeset/local-bundle-deploy.md

@@ -0,0 +1,6 @@
+---
+"@trigger.dev/core": patch
+"trigger.dev": patch
+---
+
+Add an experimental `--local-bundle` deploy flag that runs the install and bundling steps on your machine and uploads only the build output; the image is still built remotely. Useful when your project's install step needs tooling or credentials that only exist locally.

.github/workflows/codeql.yml

@@ -0,0 +1,40 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions: {}
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    if: github.repository == 'triggerdotdev/trigger.dev'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write # Upload SARIF to GitHub Security tab
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [actions, javascript-typescript]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+        with:
+          languages: ${{ matrix.language }}
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@db488ddef3bf6cb639b32c2e9a7c0a7ea8271d28 # v4.37.8
+        with:
+          category: /language:${{ matrix.language }}

.server-changes/admin-dashboard-enabled-flag.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Self-hosted instances can now disable the admin dashboard and user impersonation entirely. See the self-hosting docs for the new setting.

.server-changes/deployment-logs-follow-scroll.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: feature
+---
+
+Deployment logs no longer jump to the bottom while you are reading earlier output. Scroll up to pause auto-scroll, and scroll back down or use the new scroll-to-bottom button in the log header to resume following.

.server-changes/runs-list-query-limit-error.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+When a runs list or runs.list API request spans too much data to complete, it now returns a clear, actionable error asking you to narrow the time range, instead of failing with a generic error.

.server-changes/runs-list-read-isolation.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Improved the performance and reliability of the runs list and the runs.list API, especially for large projects and filtered views.

apps/webapp/app/components/runs/v3/RunsListErrorState.tsx

@@ -0,0 +1,28 @@
+import { Callout } from "~/components/primitives/Callout";
+
+/**
+ * Error state for a runs list that failed to load. Shown as the `errorElement` of the deferred
+ * runs-list data. The most common recoverable cause is a query that was too expensive over a broad
+ * time range (see `RunsListQueryError`), so the copy guides narrowing the range; a refresh covers
+ * transient failures. The precise reason is not shown because Remix scrubs thrown error messages in
+ * production.
+ */
+export function RunsListErrorState() {
+  return (
+    <div className="flex items-center justify-center px-3 py-12">
+      <Callout variant="error" className="max-w-fit">
+        We couldn't load these runs. If you're filtering over a broad time range, try narrowing it,
+        then refresh to try again.
+      </Callout>
+    </div>
+  );
+}
+
+/**
+ * Renders nothing. Used as the `errorElement` for secondary awaits of the same runs-list promise
+ * (e.g. the pagination controls), so a rejection is handled locally there and does not bubble to
+ * the route error boundary. The primary awaits render {@link RunsListErrorState}.
+ */
+export function RunsListErrorStateNoop() {
+  return null;
+}

apps/webapp/app/components/runs/v3/deploymentLogsCache.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+import { DeploymentLogsCache, type DeploymentLogEntry } from "./deploymentLogsCache";
+
+function lines(count: number): DeploymentLogEntry[] {
+  return Array.from({ length: count }, (_, i) => ({
+    message: `line ${i}`,
+    timestamp: new Date(0),
+    level: "info" as const,
+  }));
+}
+
+describe("DeploymentLogsCache", () => {
+  it("returns undefined for unknown keys", () => {
+    const cache = new DeploymentLogsCache(2, 100);
+    expect(cache.get("missing")).toBeUndefined();
+  });
+
+  it("stores and returns entries", () => {
+    const cache = new DeploymentLogsCache(2, 100);
+    const value = { logs: lines(3), nextSeqNum: 3, finalized: true, complete: true };
+    cache.set("a", value);
+    expect(cache.get("a")).toBe(value);
+    expect(cache.size).toBe(1);
+    expect(cache.lineCount).toBe(3);
+  });
+
+  it("evicts the least recently used deployment past the entry limit", () => {
+    const cache = new DeploymentLogsCache(2, 100);
+    cache.set("a", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+    cache.set("b", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+    cache.get("a");
+    cache.set("c", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+
+    expect(cache.get("b")).toBeUndefined();
+    expect(cache.get("a")).toBeDefined();
+    expect(cache.get("c")).toBeDefined();
+    expect(cache.size).toBe(2);
+  });
+
+  it("evicts oldest deployments past the total line budget", () => {
+    const cache = new DeploymentLogsCache(10, 10);
+    cache.set("a", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+    cache.set("b", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+    cache.set("c", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+
+    expect(cache.get("a")).toBeUndefined();
+    expect(cache.get("b")).toBeDefined();
+    expect(cache.get("c")).toBeDefined();
+    expect(cache.lineCount).toBe(8);
+  });
+
+  it("always keeps the entry just set, even when it alone exceeds the budget", () => {
+    const cache = new DeploymentLogsCache(10, 10);
+    cache.set("a", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+    cache.set("big", { logs: lines(50), nextSeqNum: 50, finalized: true, complete: true });
+
+    expect(cache.get("a")).toBeUndefined();
+    expect(cache.get("big")?.logs).toHaveLength(50);
+    expect(cache.size).toBe(1);
+    expect(cache.lineCount).toBe(50);
+  });
+
+  it("treats replacing a key as a recent use", () => {
+    const cache = new DeploymentLogsCache(2, 100);
+    cache.set("a", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+    cache.set("b", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+    cache.set("a", { logs: lines(2), nextSeqNum: 2, finalized: true, complete: true });
+    cache.set("c", { logs: lines(1), nextSeqNum: 1, finalized: false, complete: false });
+
+    expect(cache.get("b")).toBeUndefined();
+    expect(cache.get("a")?.logs).toHaveLength(2);
+    expect(cache.get("c")).toBeDefined();
+  });
+
+  it("keeps recently read deployments when evicting for the line budget", () => {
+    const cache = new DeploymentLogsCache(10, 10);
+    cache.set("a", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+    cache.set("b", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+    cache.get("a");
+    cache.set("c", { logs: lines(4), nextSeqNum: 4, finalized: true, complete: true });
+
+    expect(cache.get("b")).toBeUndefined();
+    expect(cache.get("a")).toBeDefined();
+    expect(cache.get("c")).toBeDefined();
+    expect(cache.lineCount).toBe(8);
+  });
+
+  it("replaces an existing key without double counting lines", () => {
+    const cache = new DeploymentLogsCache(10, 100);
+    cache.set("a", { logs: lines(4), nextSeqNum: 4, finalized: false, complete: false });
+    cache.set("a", { logs: lines(6), nextSeqNum: 6, finalized: true, complete: true });
+
+    expect(cache.size).toBe(1);
+    expect(cache.lineCount).toBe(6);
+    expect(cache.get("a")?.complete).toBe(true);
+  });
+});

apps/webapp/app/components/runs/v3/deploymentLogsCache.ts

@@ -0,0 +1,57 @@
+export type DeploymentLogEntry = {
+  message: string;
+  timestamp: Date;
+  level: "info" | "error" | "warn" | "debug";
+};
+
+export type CachedDeploymentLogs = {
+  logs: readonly DeploymentLogEntry[];
+  nextSeqNum: number;
+  finalized: boolean;
+  complete: boolean;
+};
+
+export class DeploymentLogsCache {
+  private entries = new Map<string, CachedDeploymentLogs>();
+  private totalLines = 0;
+
+  constructor(
+    private readonly maxDeployments: number,
+    private readonly maxTotalLines: number
+  ) {}
+
+  get(key: string): CachedDeploymentLogs | undefined {
+    const entry = this.entries.get(key);
+    if (!entry) return undefined;
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+    return entry;
+  }
+
+  set(key: string, value: CachedDeploymentLogs) {
+    const existing = this.entries.get(key);
+    if (existing) {
+      this.totalLines -= existing.logs.length;
+      this.entries.delete(key);
+    }
+    this.entries.set(key, value);
+    this.totalLines += value.logs.length;
+
+    for (const [oldestKey, oldest] of this.entries) {
+      if (oldestKey === key) break;
+      if (this.entries.size <= this.maxDeployments && this.totalLines <= this.maxTotalLines) break;
+      this.entries.delete(oldestKey);
+      this.totalLines -= oldest.logs.length;
+    }
+  }
+
+  get size() {
+    return this.entries.size;
+  }
+
+  get lineCount() {
+    return this.totalLines;
+  }
+}
+
+export const deploymentLogsCache = new DeploymentLogsCache(20, 20_000);

apps/webapp/app/db.server.ts

@@ -578,14 +578,19 @@ export const runOpsLegacyReplicaClient: RunOpsPrismaClient = runOpsTopology.lega
   .replica as unknown as RunOpsPrismaClient;
 
 // Gen-2 shard handles for the run-store boundary. Empty unless RUN_OPS_SHARDS is configured.
+// `aliasOf` carries the descriptor's declared alias so the router can dedup an aliased shard (which
+// shares its target's database) out of every fan-out sum — the DECLARATION, not client identity.
+const runOpsShardAliasByKey = new Map(env.RUN_OPS_SHARDS.map((d) => [d.key, d.aliasOf]));
 export const runOpsShardHandles: Array<{
   key: string;
   writer: RunOpsPrismaClient;
   replica: RunOpsPrismaClient;
+  aliasOf?: string;
 }> = [...runOpsTopology.shards.entries()].map(([key, clients]) => ({
   key,
   writer: clients.writer,
   replica: clients.replica,
+  aliasOf: runOpsShardAliasByKey.get(key),
 }));
 
 export const runOpsSplitReadEnabled: boolean = computeRunOpsSplitReadEnabled({