@artian-techs/adonis-orbit 0.2.0 → 0.2.1

package/build/src/recorder.d.ts

@@ -9,6 +9,12 @@ import type { OrbitConfig } from './types.js';
  * The channels of the queue answer at once, thus the events are written apart.
  * A sink that refuses an event must never stop the job that runs.
  *
+ * The start and the end of a short job come in the same tick, and a sink
+ * answers each write apart. The end would land before the start, and the row
+ * would stay open. The events of one job thus go to one sink one after the
+ * other, in the order that the queue gave them. Two jobs do not wait for each
+ * other, and two sinks do not wait for each other.
+ *
  * A configuration that names no sink keeps nothing.
  *
  * The recorder gives back a `flush`. It waits for the writes that are open,

package/build/src/recorder.js

@@ -46,6 +46,12 @@ function keep(rule, job, payload) {
  * The channels of the queue answer at once, thus the events are written apart.
  * A sink that refuses an event must never stop the job that runs.
  *
+ * The start and the end of a short job come in the same tick, and a sink
+ * answers each write apart. The end would land before the start, and the row
+ * would stay open. The events of one job thus go to one sink one after the
+ * other, in the order that the queue gave them. Two jobs do not wait for each
+ * other, and two sinks do not wait for each other.
+ *
  * A configuration that names no sink keeps nothing.
  *
  * The recorder gives back a `flush`. It waits for the writes that are open,
@@ -56,13 +62,30 @@ export function recordJobRuns(config) {
     const rule = config.payload ?? 'full';
     /** The writes that are started, and that no sink finished yet. */
     const pending = new Set();
+    /** The last write of each job that a sink did not finish yet, by sink. */
+    const lanes = new Map(sinks.map((sink) => [sink, new Map()]));
     function write(events) {
+        const ids = [...new Set(events.map((event) => event.job.id))];
         for (const sink of sinks) {
-            const done = sink.write(events).catch((error) => {
+            const lane = lanes.get(sink);
+            const before = Promise.all(ids.map((id) => lane.get(id)));
+            const done = before
+                .then(() => sink.write(events))
+                .catch((error) => {
                 logger.error({ err: error }, 'The trace of a job could not be written');
             });
+            for (const id of ids) {
+                lane.set(id, done);
+            }
             pending.add(done);
-            void done.finally(() => pending.delete(done));
+            void done.finally(() => {
+                pending.delete(done);
+                for (const id of ids) {
+                    if (lane.get(id) === done) {
+                        lane.delete(id);
+                    }
+                }
+            });
         }
     }
     /**

package/build/src/sinks/database_sink.d.ts

@@ -2,13 +2,18 @@ import type { JobEvent, Sink } from '../types.js';
 /**
  * Keep the trace of the jobs in the table of the application.
  *
- * The two inserts are written in SQL because they need `on conflict`, which
+ * The three writes are written in SQL because they need `on conflict`, which
  * Lucid does not carry. The model would read the row before writing it, and
  * two processes that write together would then undo each other.
  *
- * The row that the dispatch writes and the row that the worker writes are the
- * same row. Either of the two can arrive first, thus the first one writes and
- * the second one completes.
+ * The three events of one job write the same row, and each one can land
+ * first: the dispatch and the worker run in two processes, and a worker that
+ * stops before its writes end leaves the row to the reconciler. The first
+ * event writes the row, and the next ones complete it.
+ *
+ * A row that is closed stays closed. A start that lands after the end fills
+ * what the end did not know, and changes nothing else. A `lost` that lands
+ * after the end changes nothing: the row has its answer.
  */
 export default class DatabaseSink implements Sink {
     #private;

package/build/src/sinks/database_sink.js

@@ -7,16 +7,25 @@ const STATUS = {
     retrying: JobRunStatus.RETRYING,
     lost: JobRunStatus.LOST,
 };
+/** The statuses of a row that waits for an answer. */
+const OPEN = [JobRunStatus.PENDING, JobRunStatus.RUNNING, JobRunStatus.RETRYING];
+/** `job_runs.status in (?, ?, ?)`, with one mark for each open status. */
+const IS_OPEN = `${JobRun.table}.status in (${OPEN.map(() => '?').join(', ')})`;
 /**
  * Keep the trace of the jobs in the table of the application.
  *
- * The two inserts are written in SQL because they need `on conflict`, which
+ * The three writes are written in SQL because they need `on conflict`, which
  * Lucid does not carry. The model would read the row before writing it, and
  * two processes that write together would then undo each other.
  *
- * The row that the dispatch writes and the row that the worker writes are the
- * same row. Either of the two can arrive first, thus the first one writes and
- * the second one completes.
+ * The three events of one job write the same row, and each one can land
+ * first: the dispatch and the worker run in two processes, and a worker that
+ * stops before its writes end leaves the row to the reconciler. The first
+ * event writes the row, and the next ones complete it.
+ *
+ * A row that is closed stays closed. A start that lands after the end fills
+ * what the end did not know, and changes nothing else. A `lost` that lands
+ * after the end changes nothing: the row has its answer.
  */
 export default class DatabaseSink {
     async write(events) {
@@ -52,15 +61,24 @@ export default class DatabaseSink {
        values ${rows}
        on conflict (job_id) do nothing`, values);
     }
-    /** Write the row of the job that a worker holds, or complete it. */
+    /**
+     * Write the row of the job that a worker holds, or complete it.
+     *
+     * An open row takes the start: the status, the count of the tries and the
+     * time of this try. A closed row keeps its status, and takes the time of the
+     * start only while it has none.
+     */
     #take({ job, at }) {
         return db.rawQuery(`insert into ${JobRun.table}
          (job_id, name, queue, status, payload, attempts, started_at, created_at, updated_at)
        values (?, ?, ?, ?, ?, ?, ?, ?, ?)
        on conflict (job_id) do update set
-         status = excluded.status,
-         attempts = excluded.attempts,
-         started_at = excluded.started_at,
+         status = case when ${IS_OPEN} then excluded.status else ${JobRun.table}.status end,
+         attempts = greatest(${JobRun.table}.attempts, excluded.attempts),
+         started_at = case when ${IS_OPEN}
+           then excluded.started_at
+           else coalesce(${JobRun.table}.started_at, excluded.started_at)
+         end,
          updated_at = excluded.updated_at`, [
             job.id,
             job.name,
@@ -71,19 +89,43 @@ export default class DatabaseSink {
             at,
             at,
             at,
+            ...OPEN,
+            ...OPEN,
         ]);
     }
-    /** Say how the try of a job ended. */
+    /**
+     * Say how the try of a job ended.
+     *
+     * The end can land before the start, thus it writes the row when there is
+     * none. A `lost` says that nobody answered, thus it writes nothing on a row
+     * that has an answer.
+     */
     #close({ job, at, outcome, duration, error }) {
         const ended = outcome !== 'retrying';
-        return JobRun.query()
-            .where('jobId', job.id)
-            .update({
-            status: STATUS[outcome],
+        return db.rawQuery(`insert into ${JobRun.table}
+         (job_id, name, queue, status, payload, attempts, duration, error, finished_at, created_at, updated_at)
+       values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       on conflict (job_id) do update set
+         status = excluded.status,
+         attempts = greatest(${JobRun.table}.attempts, excluded.attempts),
+         duration = excluded.duration,
+         error = excluded.error,
+         finished_at = excluded.finished_at,
+         updated_at = excluded.updated_at
+       where excluded.status <> ? or ${IS_OPEN}`, [
+            job.id,
+            job.name,
+            job.queue,
+            STATUS[outcome],
+            JSON.stringify(job.payload),
+            job.attempts,
             duration,
             error,
-            finishedAt: ended ? at : null,
-            updatedAt: at,
-        });
+            ended ? at : null,
+            at,
+            at,
+            JobRunStatus.LOST,
+            ...OPEN,
+        ]);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artian-techs/adonis-orbit",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "See what the queue of AdonisJS does, keep it, and ask a job again.",
   "main": "build/index.js",