mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-20 18:26:40 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - The server stores the events that a runner sends for each run, and it records the identity of the runner process > - Sometimes the server stops storing a run's events for minutes, and the server log stays quiet > - In two restart-chaos cases, the identity write of the run started and then did not commit for about 197 s and 480 s > - The existing database report only fires when the reattach phase ends at its cap, so it did not fire for the cold-start case > - This pull request logs the pending writes and the blocking database sessions whenever any run write stays pending for 30 s > - The benefit is that the next stall names the session and the query that hold the run, so the fix can target one proven holder ## Linked Issues or Issue Description Refs #21946 **What happened?** Restart-chaos waves on master showed two stalls in event storage. 1. Cold start of an OpenCode run, with no restart. The runner emitted `session.started` at 22:13:23.7Z. The server stored it at 22:16:40.97Z, about 197 s later. The second `native.process_identity_recorded` write of the run started at 22:13:23.706Z, and `runner.turn.submit` took 197270 ms. A second wave showed the same shape (about 191 s). The server log had nothing in that window. 2. After a hard kill, every API GET timed out from 22:35:24Z to 22:43:23Z, server CPU was 0%, and no run events were stored. The process identity transaction of the run began at 22:35:22.6Z and committed at about 22:43:23Z. **Expected behavior** When the server cannot store a run's events, the server log names the cause: which run writes are pending, and which database sessions hold or wait for locks. **Steps to reproduce** 1. Start a transaction that locks a `heartbeat_runs` row (`for update`) and stays idle. 2. Record a process identity for that run (`persistHeartbeatRunProcessMetadata`). 3. Before this change, nothing is logged while the write waits. After this change, a warning names the idle holder and the waiting statement after 30 s. The new database test does this with a 300 ms threshold. **Relevant logs or output** Example warning from the new test: `runner event intake stalled; pending run writes, database sessions and lock waits` with `operations: [{stage: "process_identity", pendingMs: 301}]` and `waits: [{state: "idle in transaction", query: "select id from heartbeat_runs where id = ? ... for update"}, {waitEventType: "Lock", blockedBy: [<holder pid>]}]`. ## What Changed - New `server/src/services/run-intake-stall-watch.ts`. It keeps an in-memory list of pending run operations: event receipts (`PaperclipControlPlanePort.appendEvent`), event writes (`appendHeartbeatRunEvent`, `appendHeartbeatRunEventBatch`), and process identity writes (`persistHeartbeatRunProcessMetadata`). - When an operation stays pending for 30 s, the watch logs one warning per stalled run. The warning has: the pending operations and their age, the pending count and oldest age per run, the pool size, the database sessions per application name and state, the lock waits and holders (`pg_blocking_pids`, query without literals, cut to 160 characters), and the event-loop lag. Reports are at most one per 30 s. A second line logs when a reported operation finishes. - The watch arms a timer only while an operation is pending. It reads the database only when it reports, through the private liveness pool with a 5 s statement timeout. - The server names its main pool `paperclip:<boot id>` unless `DATABASE_APPLICATION_NAME` is set. This shows which server process owns each session after a restart. - `readDatabaseSessionWaits` moves from the reattach phase to `server/src/services/database-session-waits.ts`. The reattach phase re-exports it. - `@paperclipai/db` exports `databaseClientOptionsFromEnv` and `DatabaseClientOptions`. - `doc/DATABASE.md` describes the new log lines and the pool name. - I did not add `idle_in_transaction_session_timeout` to the main pool. Some code holds a transaction open on purpose, and a blind timeout could abort valid work. The new report names idle-in-transaction holders instead. - These are server log lines only. This change does not touch Telemetry or OpenTelemetry. ## Verification - `cd server && npx vitest run src/services/run-intake-stall-watch.test.ts` (5 tests). The database test holds a run row in an idle transaction, starts a process identity write, and checks that the warning names the holder pid, its query, the waiting statement, and the pool name. It is red without the tracking in `run-lifecycle.ts` and `heartbeat-run-events.ts` (`expected [] to have a length of 1`), and green with it. - Unit tests with fake timers check one report per stalled run, the 30 s throttle, the clear line, and that no timer stays armed when nothing is pending. - `cd server && npx vitest run src/services/controller-process-identity.test.ts` checks the pool name and the `DATABASE_APPLICATION_NAME` override. - `npx tsc --noEmit` passes for `server` and `packages/db`. - `pnpm verify` ran locally on the affected tests. ## Risks - Low risk. Each run event adds one map insert and one map delete. No database work happens while writes finish within 30 s. - The main pool `application_name` changes from `paperclip` to `paperclip:<boot id>`. A dashboard that filters on exactly `paperclip` must use a prefix match, or the operator can set `DATABASE_APPLICATION_NAME`. - A report reads `pg_stat_activity` on the liveness pool. A report during a full database stall can fail; the warning then has `databaseReadError` and still lists the pending operations. ## Model Used - Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, used as a coding agent with tool use (shell, file edits, local test runs). ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [ ] All Paperclip CI gates are green - [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [ ] I will address all Greptile and reviewer comments before requesting merge 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
78 lines
3.4 KiB
TypeScript
78 lines
3.4 KiB
TypeScript
import { sql } from "drizzle-orm";
|
|
import { livenessDb, type Db } from "@paperclipai/db";
|
|
|
|
export type DatabaseSessionWait = {
|
|
pid: number;
|
|
applicationName: string | null;
|
|
state: string | null;
|
|
waitEventType: string | null;
|
|
waitEvent: string | null;
|
|
blockedBy: number[];
|
|
transactionSeconds: number | null;
|
|
stateSeconds: number | null;
|
|
query: string | null;
|
|
};
|
|
|
|
export type DatabaseSessionCount = { applicationName: string; state: string; sessions: number };
|
|
|
|
const SESSION_WAITS_SQL = sql`
|
|
with sessions as (
|
|
select pid, application_name, state, wait_event_type, wait_event, pg_blocking_pids(pid) as blocked_by,
|
|
xact_start, state_change, query
|
|
from pg_stat_activity
|
|
where datname = current_database() and pid <> pg_backend_pid() and backend_type = 'client backend'
|
|
), blockers as (select distinct unnest(blocked_by) as pid from sessions)
|
|
select pid, application_name, state, wait_event_type, wait_event, blocked_by,
|
|
extract(epoch from clock_timestamp() - xact_start)::int as transaction_seconds,
|
|
extract(epoch from clock_timestamp() - state_change)::int as state_seconds,
|
|
left(regexp_replace(regexp_replace(query, '''(?:[^'']|'''')*''', '?', 'g'), '\\m[0-9][0-9.]*\\M', '?', 'g'), 160) as query
|
|
from sessions
|
|
where cardinality(blocked_by) > 0 or pid in (select pid from blockers)
|
|
or state like 'idle in transaction%'
|
|
or (xact_start is not null and clock_timestamp() - xact_start > interval '30 seconds')
|
|
order by xact_start nulls last
|
|
limit 50`;
|
|
|
|
function sessionWait(row: Record<string, unknown>): DatabaseSessionWait {
|
|
return {
|
|
pid: Number(row.pid),
|
|
applicationName: (row.application_name as string | null) ?? null,
|
|
state: (row.state as string | null) ?? null,
|
|
waitEventType: (row.wait_event_type as string | null) ?? null,
|
|
waitEvent: (row.wait_event as string | null) ?? null,
|
|
blockedBy: Array.isArray(row.blocked_by) ? row.blocked_by.map(Number) : [],
|
|
transactionSeconds: row.transaction_seconds === null ? null : Number(row.transaction_seconds),
|
|
stateSeconds: row.state_seconds === null ? null : Number(row.state_seconds),
|
|
query: (row.query as string | null) ?? null,
|
|
};
|
|
}
|
|
|
|
export async function readDatabaseSessionWaits(db: Db): Promise<DatabaseSessionWait[]> {
|
|
return livenessDb(db).transaction(async tx => {
|
|
await tx.execute(sql`select set_config('statement_timeout', '5000', true)`);
|
|
const rows = await tx.execute<Record<string, unknown>>(SESSION_WAITS_SQL);
|
|
return rows.map(sessionWait);
|
|
});
|
|
}
|
|
|
|
export async function readDatabaseSessionReport(db: Db, statementTimeoutMs = 5_000): Promise<{
|
|
sessions: DatabaseSessionCount[]; waits: DatabaseSessionWait[];
|
|
}> {
|
|
return livenessDb(db).transaction(async tx => {
|
|
await tx.execute(sql`select set_config('statement_timeout', ${String(statementTimeoutMs)}, true)`);
|
|
const counts = await tx.execute<Record<string, unknown>>(sql`
|
|
select coalesce(application_name, '') as application_name, coalesce(state, '') as state, count(*)::int as sessions
|
|
from pg_stat_activity
|
|
where datname = current_database() and pid <> pg_backend_pid() and backend_type = 'client backend'
|
|
group by 1, 2
|
|
order by 3 desc
|
|
limit 40`);
|
|
const rows = await tx.execute<Record<string, unknown>>(SESSION_WAITS_SQL);
|
|
return {
|
|
sessions: counts.map(row => ({ applicationName: String(row.application_name), state: String(row.state),
|
|
sessions: Number(row.sessions) })),
|
|
waits: rows.map(sessionWait),
|
|
};
|
|
});
|
|
}
|