firstly 0.7.2 → 0.7.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # firstly
 
+## 0.7.3
+
+### Patch Changes
+
+- [#315](https://github.com/jycouet/firstly/pull/315) [`3403d6c`](https://github.com/jycouet/firstly/commit/3403d6cffa657ad04acdac26024bdf6e989df7b4) Thanks [@jycouet](https://github.com/jycouet)! - cron: quieter logs by default - a tick only logs `done in Xms` when it took at least `logs.ended` ms (default 100; `true` = always, `false` = never). `starting` and `result` lines are opt-in, `logs.setup` can silence the registration line. If `onTick` throws, the run is now stored as `failed` (error in `result`), always logged, and no longer leaks the concurrency slot.
+
 ## 0.7.2
 
 ### Patch Changes

package/esm/cron/Cron.d.ts

@@ -1,4 +1,4 @@
-declare const statuses: readonly ["starting", "ended", "skipped"];
+declare const statuses: readonly ["starting", "ended", "skipped", "failed"];
 type StatusType = (typeof statuses)[number];
 export declare class Cron {
     id?: string;

package/esm/cron/Cron.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Entity, Fields } from 'remult';
 import { Roles_Cron } from './Roles_Cron';
-const statuses = ['starting', 'ended', 'skipped'];
+const statuses = ['starting', 'ended', 'skipped', 'failed'];
 let Cron = class Cron {
     id;
     topic;

package/esm/cron/server/index.d.ts

@@ -41,9 +41,17 @@ export type CronJobParams = {
     onTick: CronOnTick;
     topic: string;
     concurrent?: number;
+    /**
+     * Defaults: a tick logs `done in Xms` only when it took at least `ended` ms
+     * (default 100, `true` = always, `false` = never) + a `setup done` line at registration.
+     * `starting` & `result` are opt-in (full history incl. results is stored in `_ff_crons`).
+     * Failures and concurrency skips are always logged.
+     */
     logs?: {
+        setup?: boolean;
         starting?: boolean;
-        ended?: boolean;
+        result?: boolean;
+        ended?: boolean | number;
     };
     start?: boolean;
     runOnInit?: boolean;

package/esm/cron/server/index.js

@@ -30,6 +30,8 @@ export const cronTime = {
      */
     every_friday_morning: '11 5 * * 5',
 };
+const DEFAULT_ENDED_MIN_MS = 100;
+const fmtDuration = (ms) => (ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`);
 /**
  * usage:
  *
@@ -59,47 +61,55 @@ export const cron = (jobsInfos) => {
         key: 'cron',
         entities: [Cron],
     });
-    const logJobs = (topic, job, message, with_metadata = true, isSuccess = true) => {
-        const l = [];
-        l.push(magenta(`[${topic}]`));
-        l.push(message);
-        if (with_metadata) {
-            // If the job is "stopped", there will still be a next date, but it will not fire it. The job has to start.
-            l.push(`(${job.isActive ? green('running') : red('stopped')}, next at ${yellow(job.nextDate().toISO())})`);
-        }
-        if (isSuccess) {
-            log.success(l.join(' '));
-        }
-        else {
-            log.info(l.join(' '));
-        }
-    };
     m.initApi = async () => {
         jobsInfos.forEach((infos) => {
             const { topic, runOnInit, logs, concurrent, onTick: originalOnTick, ...params } = infos;
             const concurrentToUse = concurrent ?? 1;
+            const prefix = magenta(`[${topic}]`);
+            const endedMinMs = logs?.ended === false
+                ? Infinity
+                : logs?.ended === true
+                    ? 0
+                    : (logs?.ended ?? DEFAULT_ENDED_MIN_MS);
             // Create a wrapper that converts the return type to void for CronJob
             const wrappedOnTick = async () => {
-                if (jobs[topic].concurrentInProgress < concurrentToUse) {
-                    jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress + 1;
-                    const rCron = await repo(Cron).insert({ topic });
-                    if (logs?.starting === undefined || logs?.starting === true) {
-                        logJobs(topic, job, 'starting...', false, false);
-                    }
+                if (jobs[topic].concurrentInProgress >= concurrentToUse) {
+                    await repo(Cron).insert({ topic, status: 'skipped' });
+                    log.info(`${prefix} skipped because of concurrent limit (${yellow(concurrentToUse.toString())})`);
+                    return;
+                }
+                jobs[topic].concurrentInProgress++;
+                const startedAt = Date.now();
+                const rCron = await repo(Cron).insert({ topic });
+                if (logs?.starting) {
+                    log.info(`${prefix} starting...`);
+                }
+                try {
                     const res = await originalOnTick();
-                    log.info(`[${topic}] result:`, res);
                     rCron.result = res;
                     rCron.endedAt = new Date();
                     rCron.status = 'ended';
                     await repo(Cron).save(rCron);
-                    if (logs?.ended === undefined || logs?.ended === true) {
-                        logJobs(topic, job, 'done');
+                    const ms = Date.now() - startedAt;
+                    if (ms >= endedMinMs) {
+                        const msg = `${prefix} done in ${fmtDuration(ms)}`;
+                        if (logs?.result) {
+                            log.success(msg, res);
+                        }
+                        else {
+                            log.success(msg);
+                        }
                     }
-                    jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress - 1;
                 }
-                else {
-                    await repo(Cron).insert({ topic, status: 'skipped' });
-                    logJobs(topic, job, `skipped because of concurrent limit (${yellow(concurrentToUse.toString())})`, false, false);
+                catch (error) {
+                    rCron.result = { error: error instanceof Error ? error.message : String(error) };
+                    rCron.endedAt = new Date();
+                    rCron.status = 'failed';
+                    await repo(Cron).save(rCron);
+                    log.error(`${prefix} failed after ${fmtDuration(Date.now() - startedAt)}`, error);
+                }
+                finally {
+                    jobs[topic].concurrentInProgress--;
                 }
             };
             // Use type assertion to bypass complex generic type issues
@@ -108,7 +118,10 @@ export const cron = (jobsInfos) => {
                 onTick: wrappedOnTick,
             });
             jobs[topic] = { job, concurrentInProgress: 0 };
-            logJobs(topic, job, 'setup done');
+            if (logs?.setup !== false) {
+                // A stopped job still reports a next date, it just won't fire it.
+                log.success(`${prefix} setup done (${job.isActive ? green('running') : red('stopped')}, next at ${yellow(job.nextDate().toISO())})`);
+            }
             // If not it will be done too early
             if (runOnInit) {
                 job.fireOnTick();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstly",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "type": "module",
   "description": "Firstly, an opinionated Remult setup!",
   "funding": "https://github.com/sponsors/jycouet",