@shipfox/api-runners 2.0.0

package/dist/db/schema/running-job-executions.d.ts

@@ -0,0 +1,334 @@
+export declare const runningJobExecutions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "running_jobs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workflowRunId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workflowRunAttemptId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workflow_run_attempt_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        jobId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        jobExecutionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "job_execution_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        projectId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "project_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runnerSessionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_session_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provisionerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioner_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provisionedRunnerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provisioned_runner_id";
+            tableName: "running_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requiredLabels: import("drizzle-orm/pg-core").PgColumn<{
+            name: "required_labels";
+            tableName: "running_jobs";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "required_labels";
+                tableName: "running_jobs";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "required_labels";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+        runnerLabels: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_labels";
+            tableName: "running_jobs";
+            dataType: "array";
+            columnType: "PgArray";
+            data: string[];
+            driverParam: string | string[];
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "runner_labels";
+                tableName: "running_jobs";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "runner_labels";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                enumValues: [string, ...string[]];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+        startedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "started_at";
+            tableName: "running_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        firstHeartbeatAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "first_heartbeat_at";
+            tableName: "running_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastHeartbeatAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_heartbeat_at";
+            tableName: "running_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cancellationRequestedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cancellation_requested_at";
+            tableName: "running_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type RunningJobExecutionDb = typeof runningJobExecutions.$inferSelect;
+export type RunningJobExecutionInsertDb = typeof runningJobExecutions.$inferInsert;
+//# sourceMappingURL=running-job-executions.d.ts.map

package/dist/db/schema/running-job-executions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"running-job-executions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/running-job-executions.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC7E,MAAM,MAAM,2BAA2B,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC"}

package/dist/db/schema/running-job-executions.js

@@ -0,0 +1,41 @@
+import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
+import { sql } from 'drizzle-orm';
+import { check, index, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+import { pgTable } from './common.js';
+import { runnerSessions } from './runner-sessions.js';
+export const runningJobExecutions = pgTable('running_jobs', {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    workflowRunId: uuid('workflow_run_id').notNull(),
+    workflowRunAttemptId: uuid('workflow_run_attempt_id').notNull(),
+    jobId: uuid('job_id').notNull(),
+    jobExecutionId: uuid('job_execution_id').notNull().unique(),
+    projectId: uuid('project_id').notNull(),
+    runnerSessionId: uuid('runner_session_id').notNull().references(()=>runnerSessions.id),
+    provisionerId: uuid('provisioner_id'),
+    provisionedRunnerId: text('provisioned_runner_id'),
+    requiredLabels: text('required_labels').array().notNull(),
+    runnerLabels: text('runner_labels').array().notNull(),
+    startedAt: timestamp('started_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    firstHeartbeatAt: timestamp('first_heartbeat_at', {
+        withTimezone: true
+    }),
+    lastHeartbeatAt: timestamp('last_heartbeat_at', {
+        withTimezone: true
+    }).notNull().defaultNow(),
+    cancellationRequestedAt: timestamp('cancellation_requested_at', {
+        withTimezone: true
+    })
+}, (table)=>[
+        index('runners_running_jobs_no_first_heartbeat_started_idx').on(table.startedAt).where(sql`"first_heartbeat_at" IS NULL`),
+        index('runners_running_jobs_last_heartbeat_at_idx').on(table.lastHeartbeatAt),
+        index('runners_running_jobs_provisioned_runner_started_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.startedAt.desc()).where(sql`"provisioner_id" IS NOT NULL`),
+        index('runners_running_jobs_cancellation_requested_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId).where(sql`"cancellation_requested_at" IS NOT NULL`),
+        index('runners_running_jobs_job_id_idx').on(table.jobId),
+        index('runners_running_jobs_runner_session_id_idx').on(table.runnerSessionId),
+        check('runners_running_jobs_link_ck', sql`(${table.provisionerId} IS NULL) = (${table.provisionedRunnerId} IS NULL)`)
+    ]);
+
+//# sourceMappingURL=running-job-executions.js.map

package/dist/db/schema/running-job-executions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/running-job-executions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, text, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\nimport {runnerSessions} from './runner-sessions.js';\n\nexport const runningJobExecutions = pgTable(\n  'running_jobs',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    workflowRunId: uuid('workflow_run_id').notNull(),\n    workflowRunAttemptId: uuid('workflow_run_attempt_id').notNull(),\n    jobId: uuid('job_id').notNull(),\n    jobExecutionId: uuid('job_execution_id').notNull().unique(),\n    projectId: uuid('project_id').notNull(),\n    runnerSessionId: uuid('runner_session_id')\n      .notNull()\n      .references(() => runnerSessions.id),\n    provisionerId: uuid('provisioner_id'),\n    provisionedRunnerId: text('provisioned_runner_id'),\n    requiredLabels: text('required_labels').array().notNull(),\n    runnerLabels: text('runner_labels').array().notNull(),\n    startedAt: timestamp('started_at', {withTimezone: true}).notNull().defaultNow(),\n    firstHeartbeatAt: timestamp('first_heartbeat_at', {withTimezone: true}),\n    lastHeartbeatAt: timestamp('last_heartbeat_at', {withTimezone: true}).notNull().defaultNow(),\n    cancellationRequestedAt: timestamp('cancellation_requested_at', {withTimezone: true}),\n  },\n  (table) => [\n    index('runners_running_jobs_no_first_heartbeat_started_idx')\n      .on(table.startedAt)\n      .where(sql`\"first_heartbeat_at\" IS NULL`),\n    index('runners_running_jobs_last_heartbeat_at_idx').on(table.lastHeartbeatAt),\n    index('runners_running_jobs_provisioned_runner_started_idx')\n      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.startedAt.desc())\n      .where(sql`\"provisioner_id\" IS NOT NULL`),\n    index('runners_running_jobs_cancellation_requested_idx')\n      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId)\n      .where(sql`\"cancellation_requested_at\" IS NOT NULL`),\n    index('runners_running_jobs_job_id_idx').on(table.jobId),\n    index('runners_running_jobs_runner_session_id_idx').on(table.runnerSessionId),\n    check(\n      'runners_running_jobs_link_ck',\n      sql`(${table.provisionerId} IS NULL) = (${table.provisionedRunnerId} IS NULL)`,\n    ),\n  ],\n);\n\nexport type RunningJobExecutionDb = typeof runningJobExecutions.$inferSelect;\nexport type RunningJobExecutionInsertDb = typeof runningJobExecutions.$inferInsert;\n"],"names":["uuidv7PrimaryKey","sql","check","index","text","timestamp","uuid","pgTable","runnerSessions","runningJobExecutions","id","workspaceId","notNull","workflowRunId","workflowRunAttemptId","jobId","jobExecutionId","unique","projectId","runnerSessionId","references","provisionerId","provisionedRunnerId","requiredLabels","array","runnerLabels","startedAt","withTimezone","defaultNow","firstHeartbeatAt","lastHeartbeatAt","cancellationRequestedAt","table","on","where","desc"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,IAAI,QAAO,sBAAsB;AACxE,SAAQC,OAAO,QAAO,cAAc;AACpC,SAAQC,cAAc,QAAO,uBAAuB;AAEpD,OAAO,MAAMC,uBAAuBF,QAClC,gBACA;IACEG,IAAIV;IACJW,aAAaL,KAAK,gBAAgBM,OAAO;IACzCC,eAAeP,KAAK,mBAAmBM,OAAO;IAC9CE,sBAAsBR,KAAK,2BAA2BM,OAAO;IAC7DG,OAAOT,KAAK,UAAUM,OAAO;IAC7BI,gBAAgBV,KAAK,oBAAoBM,OAAO,GAAGK,MAAM;IACzDC,WAAWZ,KAAK,cAAcM,OAAO;IACrCO,iBAAiBb,KAAK,qBACnBM,OAAO,GACPQ,UAAU,CAAC,IAAMZ,eAAeE,EAAE;IACrCW,eAAef,KAAK;IACpBgB,qBAAqBlB,KAAK;IAC1BmB,gBAAgBnB,KAAK,mBAAmBoB,KAAK,GAAGZ,OAAO;IACvDa,cAAcrB,KAAK,iBAAiBoB,KAAK,GAAGZ,OAAO;IACnDc,WAAWrB,UAAU,cAAc;QAACsB,cAAc;IAAI,GAAGf,OAAO,GAAGgB,UAAU;IAC7EC,kBAAkBxB,UAAU,sBAAsB;QAACsB,cAAc;IAAI;IACrEG,iBAAiBzB,UAAU,qBAAqB;QAACsB,cAAc;IAAI,GAAGf,OAAO,GAAGgB,UAAU;IAC1FG,yBAAyB1B,UAAU,6BAA6B;QAACsB,cAAc;IAAI;AACrF,GACA,CAACK,QAAU;QACT7B,MAAM,uDACH8B,EAAE,CAACD,MAAMN,SAAS,EAClBQ,KAAK,CAACjC,GAAG,CAAC,4BAA4B,CAAC;QAC1CE,MAAM,8CAA8C8B,EAAE,CAACD,MAAMF,eAAe;QAC5E3B,MAAM,uDACH8B,EAAE,CAACD,MAAMrB,WAAW,EAAEqB,MAAMX,aAAa,EAAEW,MAAMV,mBAAmB,EAAEU,MAAMN,SAAS,CAACS,IAAI,IAC1FD,KAAK,CAACjC,GAAG,CAAC,4BAA4B,CAAC;QAC1CE,MAAM,mDACH8B,EAAE,CAACD,MAAMrB,WAAW,EAAEqB,MAAMX,aAAa,EAAEW,MAAMV,mBAAmB,EACpEY,KAAK,CAACjC,GAAG,CAAC,uCAAuC,CAAC;QACrDE,MAAM,mCAAmC8B,EAAE,CAACD,MAAMjB,KAAK;QACvDZ,MAAM,8CAA8C8B,EAAE,CAACD,MAAMb,eAAe;QAC5EjB,MACE,gCACAD,GAAG,CAAC,CAAC,EAAE+B,MAAMX,aAAa,CAAC,aAAa,EAAEW,MAAMV,mBAAmB,CAAC,SAAS,CAAC;KAEjF,EACD"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { type ShipfoxModule } from '@shipfox/node-module';
+export { type MintEphemeralRegistrationTokenParams, type MintEphemeralRegistrationTokenResult, type MintEphemeralRegistrationTokensBatchParams, type MintEphemeralRegistrationTokensBatchProvisionedRunner, type MintEphemeralRegistrationTokensBatchResult, mintEphemeralRegistrationToken, mintEphemeralRegistrationTokensBatch, } from '#core/ephemeral-registration-tokens.js';
+export { type EffectiveRunnerToolCapabilitiesResult, getEffectiveRunnerToolCapabilities, unadvertisedRunnerTools, } from '#core/runner-tool-capabilities.js';
+export { cancelRunnerJobs, type EnqueueJobExecutionParams, enqueueJobExecution, isJobLeaseActive, releaseJobExecution, } from '#db/index.js';
+export declare const runnersModule: ShipfoxModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,KAAK,aAAa,EAAoB,MAAM,sBAAsB,CAAC;AAY3E,OAAO,EACL,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,0CAA0C,EAC/C,KAAK,qDAAqD,EAC1D,KAAK,0CAA0C,EAC/C,8BAA8B,EAC9B,oCAAoC,GACrC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EACL,KAAK,qCAAqC,EAC1C,kCAAkC,EAClC,uBAAuB,GACxB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EACL,gBAAgB,EAChB,KAAK,yBAAyB,EAC9B,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAOtB,eAAO,MAAM,aAAa,EAAE,aAgB3B,CAAC"}

package/dist/index.js

@@ -0,0 +1,56 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runnersEventSchemas } from '@shipfox/api-runners-dto';
+import { WORKFLOWS_JOB_EXECUTION_TIMED_OUT } from '@shipfox/api-workflows-dto';
+import { subscriberFactory } from '@shipfox/node-module';
+import { db, migrationsPath, runnersOutbox } from '#db/index.js';
+import { registerRunnersServiceMetrics } from '#metrics/index.js';
+import { createProvisionerTokenAuthMethod, createRunnerRegistrationTokenAuthMethod, onWorkflowsJobExecutionTimedOut, routes } from '#presentation/index.js';
+import { createRunnersMaintenanceActivities } from '#temporal/activities/index.js';
+import { RUNNERS_MAINTENANCE_TASK_QUEUE } from '#temporal/constants.js';
+export { mintEphemeralRegistrationToken, mintEphemeralRegistrationTokensBatch } from '#core/ephemeral-registration-tokens.js';
+export { getEffectiveRunnerToolCapabilities, unadvertisedRunnerTools } from '#core/runner-tool-capabilities.js';
+export { cancelRunnerJobs, enqueueJobExecution, isJobLeaseActive, releaseJobExecution } from '#db/index.js';
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');
+const subscriber = subscriberFactory();
+export const runnersModule = {
+    name: 'runners',
+    database: {
+        db,
+        migrationsPath
+    },
+    auth: [
+        createRunnerRegistrationTokenAuthMethod(),
+        createProvisionerTokenAuthMethod()
+    ],
+    routes,
+    metrics: registerRunnersServiceMetrics,
+    publishers: [
+        {
+            name: 'runners',
+            table: runnersOutbox,
+            db,
+            eventSchemas: runnersEventSchemas
+        }
+    ],
+    subscribers: [
+        subscriber(WORKFLOWS_JOB_EXECUTION_TIMED_OUT, onWorkflowsJobExecutionTimedOut)
+    ],
+    workers: [
+        {
+            taskQueue: RUNNERS_MAINTENANCE_TASK_QUEUE,
+            workflowsPath,
+            activities: createRunnersMaintenanceActivities,
+            workflows: [
+                {
+                    name: 'stuckJobDetector',
+                    id: 'stuck-job-detector',
+                    cronSchedule: '* * * * *'
+                }
+            ]
+        }
+    ]
+};
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\nimport {runnersEventSchemas} from '@shipfox/api-runners-dto';\nimport {\n  WORKFLOWS_JOB_EXECUTION_TIMED_OUT,\n  type WorkflowsEventMapDto,\n} from '@shipfox/api-workflows-dto';\nimport {type ShipfoxModule, subscriberFactory} from '@shipfox/node-module';\nimport {db, migrationsPath, runnersOutbox} from '#db/index.js';\nimport {registerRunnersServiceMetrics} from '#metrics/index.js';\nimport {\n  createProvisionerTokenAuthMethod,\n  createRunnerRegistrationTokenAuthMethod,\n  onWorkflowsJobExecutionTimedOut,\n  routes,\n} from '#presentation/index.js';\nimport {createRunnersMaintenanceActivities} from '#temporal/activities/index.js';\nimport {RUNNERS_MAINTENANCE_TASK_QUEUE} from '#temporal/constants.js';\n\nexport {\n  type MintEphemeralRegistrationTokenParams,\n  type MintEphemeralRegistrationTokenResult,\n  type MintEphemeralRegistrationTokensBatchParams,\n  type MintEphemeralRegistrationTokensBatchProvisionedRunner,\n  type MintEphemeralRegistrationTokensBatchResult,\n  mintEphemeralRegistrationToken,\n  mintEphemeralRegistrationTokensBatch,\n} from '#core/ephemeral-registration-tokens.js';\nexport {\n  type EffectiveRunnerToolCapabilitiesResult,\n  getEffectiveRunnerToolCapabilities,\n  unadvertisedRunnerTools,\n} from '#core/runner-tool-capabilities.js';\nexport {\n  cancelRunnerJobs,\n  type EnqueueJobExecutionParams,\n  enqueueJobExecution,\n  isJobLeaseActive,\n  releaseJobExecution,\n} from '#db/index.js';\n\nconst packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');\nconst workflowsPath = resolve(packageRoot, 'dist/temporal/workflows/index.js');\n\nconst subscriber = subscriberFactory<WorkflowsEventMapDto>();\n\nexport const runnersModule: ShipfoxModule = {\n  name: 'runners',\n  database: {db, migrationsPath},\n  auth: [createRunnerRegistrationTokenAuthMethod(), createProvisionerTokenAuthMethod()],\n  routes,\n  metrics: registerRunnersServiceMetrics,\n  publishers: [{name: 'runners', table: runnersOutbox, db, eventSchemas: runnersEventSchemas}],\n  subscribers: [subscriber(WORKFLOWS_JOB_EXECUTION_TIMED_OUT, onWorkflowsJobExecutionTimedOut)],\n  workers: [\n    {\n      taskQueue: RUNNERS_MAINTENANCE_TASK_QUEUE,\n      workflowsPath,\n      activities: createRunnersMaintenanceActivities,\n      workflows: [{name: 'stuckJobDetector', id: 'stuck-job-detector', cronSchedule: '* * * * *'}],\n    },\n  ],\n};\n"],"names":["dirname","resolve","fileURLToPath","runnersEventSchemas","WORKFLOWS_JOB_EXECUTION_TIMED_OUT","subscriberFactory","db","migrationsPath","runnersOutbox","registerRunnersServiceMetrics","createProvisionerTokenAuthMethod","createRunnerRegistrationTokenAuthMethod","onWorkflowsJobExecutionTimedOut","routes","createRunnersMaintenanceActivities","RUNNERS_MAINTENANCE_TASK_QUEUE","mintEphemeralRegistrationToken","mintEphemeralRegistrationTokensBatch","getEffectiveRunnerToolCapabilities","unadvertisedRunnerTools","cancelRunnerJobs","enqueueJobExecution","isJobLeaseActive","releaseJobExecution","packageRoot","url","workflowsPath","subscriber","runnersModule","name","database","auth","metrics","publishers","table","eventSchemas","subscribers","workers","taskQueue","activities","workflows","id","cronSchedule"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AACvC,SAAQC,mBAAmB,QAAO,2BAA2B;AAC7D,SACEC,iCAAiC,QAE5B,6BAA6B;AACpC,SAA4BC,iBAAiB,QAAO,uBAAuB;AAC3E,SAAQC,EAAE,EAAEC,cAAc,EAAEC,aAAa,QAAO,eAAe;AAC/D,SAAQC,6BAA6B,QAAO,oBAAoB;AAChE,SACEC,gCAAgC,EAChCC,uCAAuC,EACvCC,+BAA+B,EAC/BC,MAAM,QACD,yBAAyB;AAChC,SAAQC,kCAAkC,QAAO,gCAAgC;AACjF,SAAQC,8BAA8B,QAAO,yBAAyB;AAEtE,SAMEC,8BAA8B,EAC9BC,oCAAoC,QAC/B,yCAAyC;AAChD,SAEEC,kCAAkC,EAClCC,uBAAuB,QAClB,oCAAoC;AAC3C,SACEC,gBAAgB,EAEhBC,mBAAmB,EACnBC,gBAAgB,EAChBC,mBAAmB,QACd,eAAe;AAEtB,MAAMC,cAAcvB,QAAQD,QAAQE,cAAc,YAAYuB,GAAG,IAAI;AACrE,MAAMC,gBAAgBzB,QAAQuB,aAAa;AAE3C,MAAMG,aAAatB;AAEnB,OAAO,MAAMuB,gBAA+B;IAC1CC,MAAM;IACNC,UAAU;QAACxB;QAAIC;IAAc;IAC7BwB,MAAM;QAACpB;QAA2CD;KAAmC;IACrFG;IACAmB,SAASvB;IACTwB,YAAY;QAAC;YAACJ,MAAM;YAAWK,OAAO1B;YAAeF;YAAI6B,cAAchC;QAAmB;KAAE;IAC5FiC,aAAa;QAACT,WAAWvB,mCAAmCQ;KAAiC;IAC7FyB,SAAS;QACP;YACEC,WAAWvB;YACXW;YACAa,YAAYzB;YACZ0B,WAAW;gBAAC;oBAACX,MAAM;oBAAoBY,IAAI;oBAAsBC,cAAc;gBAAW;aAAE;QAC9F;KACD;AACH,EAAE"}

package/dist/metrics/index.d.ts

@@ -0,0 +1,3 @@
+export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, provisionedRunnerAbsentTerminatedCount, provisionedRunnerCountDivergenceCount, provisionedRunnerReconcileCallCount, provisionedRunnerTerminateIntentHonoredCount, provisionedRunnerTerminateIntentIssuedCount, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure, } from './instance.js';
+export { registerRunnersServiceMetrics } from './service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/metrics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/metrics/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,6BAA6B,EAC7B,sCAAsC,EACtC,qCAAqC,EACrC,mCAAmC,EACnC,4CAA4C,EAC5C,2CAA2C,EAC3C,2BAA2B,EAC3B,kCAAkC,GACnC,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,6BAA6B,EAAC,MAAM,cAAc,CAAC"}

package/dist/metrics/index.js

@@ -0,0 +1,4 @@
+export { jobExecutionClaimedCount, jobExecutionEnqueuedCount, jobExecutionLeaseExpiredCount, provisionedRunnerAbsentTerminatedCount, provisionedRunnerCountDivergenceCount, provisionedRunnerReconcileCallCount, provisionedRunnerTerminateIntentHonoredCount, provisionedRunnerTerminateIntentIssuedCount, recordRunnersRateLimitCheck, recordRunnersRateLimitPruneFailure } from './instance.js';
+export { registerRunnersServiceMetrics } from './service.js';
+
+//# sourceMappingURL=index.js.map

package/dist/metrics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/index.ts"],"sourcesContent":["export {\n  jobExecutionClaimedCount,\n  jobExecutionEnqueuedCount,\n  jobExecutionLeaseExpiredCount,\n  provisionedRunnerAbsentTerminatedCount,\n  provisionedRunnerCountDivergenceCount,\n  provisionedRunnerReconcileCallCount,\n  provisionedRunnerTerminateIntentHonoredCount,\n  provisionedRunnerTerminateIntentIssuedCount,\n  recordRunnersRateLimitCheck,\n  recordRunnersRateLimitPruneFailure,\n} from './instance.js';\nexport {registerRunnersServiceMetrics} from './service.js';\n"],"names":["jobExecutionClaimedCount","jobExecutionEnqueuedCount","jobExecutionLeaseExpiredCount","provisionedRunnerAbsentTerminatedCount","provisionedRunnerCountDivergenceCount","provisionedRunnerReconcileCallCount","provisionedRunnerTerminateIntentHonoredCount","provisionedRunnerTerminateIntentIssuedCount","recordRunnersRateLimitCheck","recordRunnersRateLimitPruneFailure","registerRunnersServiceMetrics"],"mappings":"AAAA,SACEA,wBAAwB,EACxBC,yBAAyB,EACzBC,6BAA6B,EAC7BC,sCAAsC,EACtCC,qCAAqC,EACrCC,mCAAmC,EACnCC,4CAA4C,EAC5CC,2CAA2C,EAC3CC,2BAA2B,EAC3BC,kCAAkC,QAC7B,gBAAgB;AACvB,SAAQC,6BAA6B,QAAO,eAAe"}

package/dist/metrics/instance.d.ts

@@ -0,0 +1,34 @@
+export declare const jobExecutionEnqueuedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const jobExecutionClaimedCount: import("@shipfox/node-opentelemetry").Counter<{
+    outcome: "claimed" | "empty";
+}>;
+export declare const jobExecutionLeaseExpiredCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const provisionedRunnerReportCount: import("@shipfox/node-opentelemetry").Counter<{
+    state: "starting" | "running" | "stopping" | "stopped" | "failed" | "terminated";
+}>;
+export declare const provisionedRunnerReapedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const provisionedRunnerCountDivergenceCount: import("@shipfox/node-opentelemetry").Counter<{
+    template_key?: string;
+    state: "starting" | "running";
+    direction: "backend-higher" | "advertised-higher";
+}>;
+export declare const provisionedRunnerReconcileCallCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const provisionedRunnerAbsentTerminatedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export declare const provisionedRunnerTerminateIntentIssuedCount: import("@shipfox/node-opentelemetry").Counter<{
+    surface: "poll-demand" | "reconcile";
+    reason: "job-cancelled" | "terminal-state";
+}>;
+export declare const provisionedRunnerTerminateIntentHonoredCount: import("@shipfox/node-opentelemetry").Counter<{
+    reason: "job-cancelled";
+}>;
+export declare const reservationReleasedCount: import("@shipfox/node-opentelemetry").Counter<Record<string, never>>;
+export type RunnersRateLimitAction = 'provisioner-mint' | 'ephemeral-register';
+export type RunnersRateLimitScope = 'provisioner' | 'ephemeral-token';
+export type RunnersRateLimitOutcome = 'allowed' | 'blocked' | 'unavailable';
+export declare function recordRunnersRateLimitCheck(params: {
+    action: RunnersRateLimitAction;
+    scope: RunnersRateLimitScope;
+    outcome: RunnersRateLimitOutcome;
+}): void;
+export declare function recordRunnersRateLimitPruneFailure(): void;
+//# sourceMappingURL=instance.d.ts.map

package/dist/metrics/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/metrics/instance.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,yBAAyB,sEAKrC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aAAiC,SAAS,GAAG,OAAO;EAGxF,CAAC;AAEF,eAAO,MAAM,6BAA6B,sEAGzC,CAAC;AAEF,eAAO,MAAM,4BAA4B;WAChC,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY;EAGhF,CAAC;AAEH,eAAO,MAAM,4BAA4B,sEAKxC,CAAC;AAEF,eAAO,MAAM,qCAAqC;mBACjC,MAAM;WACd,UAAU,GAAG,SAAS;eAClB,gBAAgB,GAAG,mBAAmB;EAIjD,CAAC;AAEH,eAAO,MAAM,mCAAmC,sEAG/C,CAAC;AAEF,eAAO,MAAM,sCAAsC,sEAMlD,CAAC;AAEF,eAAO,MAAM,2CAA2C;aAC7C,aAAa,GAAG,WAAW;YAC5B,eAAe,GAAG,gBAAgB;EAG1C,CAAC;AAEH,eAAO,MAAM,4CAA4C;YAC/C,eAAe;EAGvB,CAAC;AAEH,eAAO,MAAM,wBAAwB,sEAGpC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAC/E,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG,iBAAiB,CAAC;AACtE,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAsB5E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,OAAO,EAAE,uBAAuB,CAAC;CAClC,GAAG,IAAI,CAQP;AAED,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD"}

package/dist/metrics/instance.js

@@ -0,0 +1,60 @@
+import { instanceMetrics } from '@shipfox/node-opentelemetry';
+const meter = instanceMetrics.getMeter('runners');
+export const jobExecutionEnqueuedCount = meter.createCounter('runners_job_execution_enqueued', {
+    description: 'Job executions added to the pending queue'
+});
+export const jobExecutionClaimedCount = meter.createCounter('runners_job_execution_claimed', {
+    description: 'Job execution claim attempts by outcome'
+});
+export const jobExecutionLeaseExpiredCount = meter.createCounter('runners_job_execution_lease_expired', {
+    description: 'Job execution leases reaped after passing the heartbeat threshold'
+});
+export const provisionedRunnerReportCount = meter.createCounter('runners_provisioned_runner_reported', {
+    description: 'Provisioned runner lifecycle reports accepted by state'
+});
+export const provisionedRunnerReapedCount = meter.createCounter('runners_provisioned_runner_reaped', {
+    description: 'Stale provisioned runners marked failed by backend maintenance'
+});
+export const provisionedRunnerCountDivergenceCount = meter.createCounter('runners_provisioned_runner_count_divergence', {
+    description: 'Absolute difference between provisioner-advertised and backend-observed provisioned runner counts'
+});
+export const provisionedRunnerReconcileCallCount = meter.createCounter('runners_provisioned_runner_reconcile_called', {
+    description: 'Provisioned runner reconcile calls completed successfully'
+});
+export const provisionedRunnerAbsentTerminatedCount = meter.createCounter('runners_provisioned_runner_absent_terminated', {
+    description: 'Owned provisioned runners marked terminated because they were absent from reconcile'
+});
+export const provisionedRunnerTerminateIntentIssuedCount = meter.createCounter('runners_provisioned_runner_terminate_intent_issued', {
+    description: 'Provisioned runner terminate intents returned to provisioners'
+});
+export const provisionedRunnerTerminateIntentHonoredCount = meter.createCounter('runners_provisioned_runner_terminate_intent_honored', {
+    description: 'Provisioned runner terminate intents honored by first transition to terminated'
+});
+export const reservationReleasedCount = meter.createCounter('runners_reservation_released', {
+    description: 'Reservation units released from terminal provisioned runner reports'
+});
+const rateLimitCheckCount = meter.createCounter('runners_rate_limit_checks', {
+    description: 'Runners rate limit checks by action, scope, and outcome'
+});
+const rateLimitPruneFailureCount = meter.createCounter('runners_rate_limit_prune_failures', {
+    description: 'Runners rate limit prune failures'
+});
+function recordMetric(record) {
+    try {
+        record();
+    } catch  {
+    // Metrics must not affect runner or provisioner request outcomes.
+    }
+}
+export function recordRunnersRateLimitCheck(params) {
+    recordMetric(()=>rateLimitCheckCount.add(1, {
+            action: params.action,
+            scope: params.scope,
+            outcome: params.outcome
+        }));
+}
+export function recordRunnersRateLimitPruneFailure() {
+    recordMetric(()=>rateLimitPruneFailureCount.add(1));
+}
+
+//# sourceMappingURL=instance.js.map

package/dist/metrics/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/instance.ts"],"sourcesContent":["import {instanceMetrics} from '@shipfox/node-opentelemetry';\n\nconst meter = instanceMetrics.getMeter('runners');\n\nexport const jobExecutionEnqueuedCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_enqueued',\n  {\n    description: 'Job executions added to the pending queue',\n  },\n);\n\nexport const jobExecutionClaimedCount = meter.createCounter<{outcome: 'claimed' | 'empty'}>(\n  'runners_job_execution_claimed',\n  {description: 'Job execution claim attempts by outcome'},\n);\n\nexport const jobExecutionLeaseExpiredCount = meter.createCounter<Record<string, never>>(\n  'runners_job_execution_lease_expired',\n  {description: 'Job execution leases reaped after passing the heartbeat threshold'},\n);\n\nexport const provisionedRunnerReportCount = meter.createCounter<{\n  state: 'starting' | 'running' | 'stopping' | 'stopped' | 'failed' | 'terminated';\n}>('runners_provisioned_runner_reported', {\n  description: 'Provisioned runner lifecycle reports accepted by state',\n});\n\nexport const provisionedRunnerReapedCount = meter.createCounter<Record<string, never>>(\n  'runners_provisioned_runner_reaped',\n  {\n    description: 'Stale provisioned runners marked failed by backend maintenance',\n  },\n);\n\nexport const provisionedRunnerCountDivergenceCount = meter.createCounter<{\n  template_key?: string;\n  state: 'starting' | 'running';\n  direction: 'backend-higher' | 'advertised-higher';\n}>('runners_provisioned_runner_count_divergence', {\n  description:\n    'Absolute difference between provisioner-advertised and backend-observed provisioned runner counts',\n});\n\nexport const provisionedRunnerReconcileCallCount = meter.createCounter<Record<string, never>>(\n  'runners_provisioned_runner_reconcile_called',\n  {description: 'Provisioned runner reconcile calls completed successfully'},\n);\n\nexport const provisionedRunnerAbsentTerminatedCount = meter.createCounter<Record<string, never>>(\n  'runners_provisioned_runner_absent_terminated',\n  {\n    description:\n      'Owned provisioned runners marked terminated because they were absent from reconcile',\n  },\n);\n\nexport const provisionedRunnerTerminateIntentIssuedCount = meter.createCounter<{\n  surface: 'poll-demand' | 'reconcile';\n  reason: 'job-cancelled' | 'terminal-state';\n}>('runners_provisioned_runner_terminate_intent_issued', {\n  description: 'Provisioned runner terminate intents returned to provisioners',\n});\n\nexport const provisionedRunnerTerminateIntentHonoredCount = meter.createCounter<{\n  reason: 'job-cancelled';\n}>('runners_provisioned_runner_terminate_intent_honored', {\n  description: 'Provisioned runner terminate intents honored by first transition to terminated',\n});\n\nexport const reservationReleasedCount = meter.createCounter<Record<string, never>>(\n  'runners_reservation_released',\n  {description: 'Reservation units released from terminal provisioned runner reports'},\n);\n\nexport type RunnersRateLimitAction = 'provisioner-mint' | 'ephemeral-register';\nexport type RunnersRateLimitScope = 'provisioner' | 'ephemeral-token';\nexport type RunnersRateLimitOutcome = 'allowed' | 'blocked' | 'unavailable';\n\nconst rateLimitCheckCount = meter.createCounter<{\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}>('runners_rate_limit_checks', {\n  description: 'Runners rate limit checks by action, scope, and outcome',\n});\n\nconst rateLimitPruneFailureCount = meter.createCounter('runners_rate_limit_prune_failures', {\n  description: 'Runners rate limit prune failures',\n});\n\nfunction recordMetric(record: () => void): void {\n  try {\n    record();\n  } catch {\n    // Metrics must not affect runner or provisioner request outcomes.\n  }\n}\n\nexport function recordRunnersRateLimitCheck(params: {\n  action: RunnersRateLimitAction;\n  scope: RunnersRateLimitScope;\n  outcome: RunnersRateLimitOutcome;\n}): void {\n  recordMetric(() =>\n    rateLimitCheckCount.add(1, {\n      action: params.action,\n      scope: params.scope,\n      outcome: params.outcome,\n    }),\n  );\n}\n\nexport function recordRunnersRateLimitPruneFailure(): void {\n  recordMetric(() => rateLimitPruneFailureCount.add(1));\n}\n"],"names":["instanceMetrics","meter","getMeter","jobExecutionEnqueuedCount","createCounter","description","jobExecutionClaimedCount","jobExecutionLeaseExpiredCount","provisionedRunnerReportCount","provisionedRunnerReapedCount","provisionedRunnerCountDivergenceCount","provisionedRunnerReconcileCallCount","provisionedRunnerAbsentTerminatedCount","provisionedRunnerTerminateIntentIssuedCount","provisionedRunnerTerminateIntentHonoredCount","reservationReleasedCount","rateLimitCheckCount","rateLimitPruneFailureCount","recordMetric","record","recordRunnersRateLimitCheck","params","add","action","scope","outcome","recordRunnersRateLimitPruneFailure"],"mappings":"AAAA,SAAQA,eAAe,QAAO,8BAA8B;AAE5D,MAAMC,QAAQD,gBAAgBE,QAAQ,CAAC;AAEvC,OAAO,MAAMC,4BAA4BF,MAAMG,aAAa,CAC1D,kCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMC,2BAA2BL,MAAMG,aAAa,CACzD,iCACA;IAACC,aAAa;AAAyC,GACvD;AAEF,OAAO,MAAME,gCAAgCN,MAAMG,aAAa,CAC9D,uCACA;IAACC,aAAa;AAAmE,GACjF;AAEF,OAAO,MAAMG,+BAA+BP,MAAMG,aAAa,CAE5D,uCAAuC;IACxCC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMI,+BAA+BR,MAAMG,aAAa,CAC7D,qCACA;IACEC,aAAa;AACf,GACA;AAEF,OAAO,MAAMK,wCAAwCT,MAAMG,aAAa,CAIrE,+CAA+C;IAChDC,aACE;AACJ,GAAG;AAEH,OAAO,MAAMM,sCAAsCV,MAAMG,aAAa,CACpE,+CACA;IAACC,aAAa;AAA2D,GACzE;AAEF,OAAO,MAAMO,yCAAyCX,MAAMG,aAAa,CACvE,gDACA;IACEC,aACE;AACJ,GACA;AAEF,OAAO,MAAMQ,8CAA8CZ,MAAMG,aAAa,CAG3E,sDAAsD;IACvDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMS,+CAA+Cb,MAAMG,aAAa,CAE5E,uDAAuD;IACxDC,aAAa;AACf,GAAG;AAEH,OAAO,MAAMU,2BAA2Bd,MAAMG,aAAa,CACzD,gCACA;IAACC,aAAa;AAAqE,GACnF;AAMF,MAAMW,sBAAsBf,MAAMG,aAAa,CAI5C,6BAA6B;IAC9BC,aAAa;AACf;AAEA,MAAMY,6BAA6BhB,MAAMG,aAAa,CAAC,qCAAqC;IAC1FC,aAAa;AACf;AAEA,SAASa,aAAaC,MAAkB;IACtC,IAAI;QACFA;IACF,EAAE,OAAM;IACN,kEAAkE;IACpE;AACF;AAEA,OAAO,SAASC,4BAA4BC,MAI3C;IACCH,aAAa,IACXF,oBAAoBM,GAAG,CAAC,GAAG;YACzBC,QAAQF,OAAOE,MAAM;YACrBC,OAAOH,OAAOG,KAAK;YACnBC,SAASJ,OAAOI,OAAO;QACzB;AAEJ;AAEA,OAAO,SAASC;IACdR,aAAa,IAAMD,2BAA2BK,GAAG,CAAC;AACpD"}

package/dist/metrics/service.d.ts

@@ -0,0 +1,2 @@
+export declare function registerRunnersServiceMetrics(): void;
+//# sourceMappingURL=service.d.ts.map

package/dist/metrics/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/metrics/service.ts"],"names":[],"mappings":"AAGA,wBAAgB,6BAA6B,IAAI,IAAI,CAkBpD"}

package/dist/metrics/service.js

@@ -0,0 +1,21 @@
+import { getServiceMetricsProvider } from '@shipfox/node-opentelemetry';
+import { getJobExecutionQueueDepth } from '#db/job-executions.js';
+export function registerRunnersServiceMetrics() {
+    const meter = getServiceMetricsProvider().getMeter('runners');
+    const pendingJobExecutions = meter.createObservableGauge('runners_pending_job_executions', {
+        description: 'Job executions currently waiting in the queue to be claimed'
+    });
+    const runningJobExecutions = meter.createObservableGauge('runners_running_job_executions', {
+        description: 'Job executions currently claimed by a runner and in progress'
+    });
+    meter.addBatchObservableCallback(async (observer)=>{
+        const depth = await getJobExecutionQueueDepth();
+        observer.observe(pendingJobExecutions, depth.pendingJobExecutions);
+        observer.observe(runningJobExecutions, depth.runningJobExecutions);
+    }, [
+        pendingJobExecutions,
+        runningJobExecutions
+    ]);
+}
+
+//# sourceMappingURL=service.js.map

package/dist/metrics/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/metrics/service.ts"],"sourcesContent":["import {getServiceMetricsProvider} from '@shipfox/node-opentelemetry';\nimport {getJobExecutionQueueDepth} from '#db/job-executions.js';\n\nexport function registerRunnersServiceMetrics(): void {\n  const meter = getServiceMetricsProvider().getMeter('runners');\n\n  const pendingJobExecutions = meter.createObservableGauge('runners_pending_job_executions', {\n    description: 'Job executions currently waiting in the queue to be claimed',\n  });\n  const runningJobExecutions = meter.createObservableGauge('runners_running_job_executions', {\n    description: 'Job executions currently claimed by a runner and in progress',\n  });\n\n  meter.addBatchObservableCallback(\n    async (observer) => {\n      const depth = await getJobExecutionQueueDepth();\n      observer.observe(pendingJobExecutions, depth.pendingJobExecutions);\n      observer.observe(runningJobExecutions, depth.runningJobExecutions);\n    },\n    [pendingJobExecutions, runningJobExecutions],\n  );\n}\n"],"names":["getServiceMetricsProvider","getJobExecutionQueueDepth","registerRunnersServiceMetrics","meter","getMeter","pendingJobExecutions","createObservableGauge","description","runningJobExecutions","addBatchObservableCallback","observer","depth","observe"],"mappings":"AAAA,SAAQA,yBAAyB,QAAO,8BAA8B;AACtE,SAAQC,yBAAyB,QAAO,wBAAwB;AAEhE,OAAO,SAASC;IACd,MAAMC,QAAQH,4BAA4BI,QAAQ,CAAC;IAEnD,MAAMC,uBAAuBF,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IACA,MAAMC,uBAAuBL,MAAMG,qBAAqB,CAAC,kCAAkC;QACzFC,aAAa;IACf;IAEAJ,MAAMM,0BAA0B,CAC9B,OAAOC;QACL,MAAMC,QAAQ,MAAMV;QACpBS,SAASE,OAAO,CAACP,sBAAsBM,MAAMN,oBAAoB;QACjEK,SAASE,OAAO,CAACJ,sBAAsBG,MAAMH,oBAAoB;IACnE,GACA;QAACH;QAAsBG;KAAqB;AAEhD"}