@athenna/cron 5.7.0 → 5.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/cron",
-  "version": "5.7.0",
+  "version": "5.9.0",
   "description": "Athenna scheduler application. Built on top of node-cron.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -57,26 +57,26 @@
     "node-cron": "^3.0.3"
   },
   "devDependencies": {
-    "@athenna/artisan": "^5.6.0",
-    "@athenna/common": "^5.7.0",
-    "@athenna/config": "^5.3.0",
-    "@athenna/ioc": "^5.1.0",
-    "@athenna/logger": "^5.3.0",
-    "@athenna/test": "^5.3.0",
+    "@athenna/artisan": "^5.7.0",
+    "@athenna/common": "^5.14.0",
+    "@athenna/config": "^5.4.0",
+    "@athenna/ioc": "^5.2.0",
+    "@athenna/logger": "^5.7.0",
+    "@athenna/test": "^5.5.0",
     "@athenna/tsconfig": "^5.0.0",
     "@athenna/view": "^5.3.0",
     "@types/node-cron": "^3.0.11",
-    "@typescript-eslint/eslint-plugin": "^8.21.0",
-    "@typescript-eslint/parser": "^8.21.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
     "cls-rtracer": "^2.6.3",
     "commitizen": "^4.3.1",
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "^8.57.1",
-    "eslint-config-prettier": "^8.10.0",
+    "eslint-config-prettier": "^8.10.2",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^15.7.0",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-prettier": "^4.2.5",
     "eslint-plugin-promise": "^6.6.0",
     "husky": "^3.1.0",
     "lint-staged": "^12.5.0",

package/src/cron/CronBuilder.d.ts

@@ -11,11 +11,16 @@ import { Macroable } from '@athenna/common';
 import type { CronExceptionHandler } from '#src/handlers/CronExceptionHandler';
 export declare class CronBuilder extends Macroable {
     static rTracerPlugin: any;
+    static loggerIsSet: boolean;
     static exceptionHandler: CronExceptionHandler;
     /**
      * Register the cls-rtracer plugin into cron handlers.
      */
     static registerRTracer(plugin: any): void;
+    /**
+     * Register the logger plugin into cron handlers.
+     */
+    static registerLogger(isToSetLogger: boolean): void;
     private cron;
     /**
      * Defines the CRON expression that will determine when

package/src/cron/CronBuilder.js

@@ -7,18 +7,26 @@
  * file that was distributed with this source code.
  */
 import { schedule } from 'node-cron';
+import { Log } from '@athenna/logger';
 import { Macroable, Options } from '@athenna/common';
 export class CronBuilder extends Macroable {
     constructor() {
         super(...arguments);
         this.cron = {};
     }
+    static { this.loggerIsSet = false; }
     /**
      * Register the cls-rtracer plugin into cron handlers.
      */
     static registerRTracer(plugin) {
         this.rTracerPlugin = plugin;
     }
+    /**
+     * Register the logger plugin into cron handlers.
+     */
+    static registerLogger(isToSetLogger) {
+        this.loggerIsSet = isToSetLogger;
+    }
     /**
      * Defines the CRON expression that will determine when
      * the task will run.
@@ -69,42 +77,56 @@ export class CronBuilder extends Macroable {
      * ```
      */
     handler(handler) {
-        const register = () => {
-            const getCtx = () => ({
-                name: this.cron.name,
-                traceId: CronBuilder.rTracerPlugin
-                    ? CronBuilder.rTracerPlugin.id()
-                    : null,
-                pattern: this.cron.pattern,
-                timezone: this.cron.timezone,
-                runOnInit: this.cron.runOnInit,
-                recoverMissedExecutions: this.cron.recoverMissedExecutions
-            });
-            const options = Options.create({
-                name: this.cron.name,
-                timezone: this.cron.timezone,
-                runOnInit: this.cron.runOnInit,
-                scheduled: this.cron.scheduled,
-                recoverMissedExecutions: this.cron.recoverMissedExecutions
-            });
-            if (CronBuilder.rTracerPlugin) {
-                return schedule(this.cron.pattern, () => CronBuilder.rTracerPlugin.runWithId(() => this.cron.handler(getCtx())), options);
-            }
-            return schedule(this.cron.pattern, () => this.cron.handler(getCtx()), options);
+        const getCtx = () => ({
+            name: this.cron.name,
+            traceId: CronBuilder.rTracerPlugin
+                ? CronBuilder.rTracerPlugin.id()
+                : null,
+            pattern: this.cron.pattern,
+            timezone: this.cron.timezone,
+            runOnInit: this.cron.runOnInit,
+            recoverMissedExecutions: this.cron.recoverMissedExecutions
+        });
+        const options = Options.create({
+            name: this.cron.name,
+            timezone: this.cron.timezone,
+            runOnInit: this.cron.runOnInit,
+            scheduled: this.cron.scheduled,
+            recoverMissedExecutions: this.cron.recoverMissedExecutions
+        });
+        this.cron.handler = async (...args) => {
+            return handler(...args);
         };
-        if (!CronBuilder.exceptionHandler) {
-            this.cron.handler = handler;
-            return register();
+        if (CronBuilder.exceptionHandler) {
+            this.cron.handler = async (...args) => {
+                try {
+                    await handler(...args);
+                }
+                catch (err) {
+                    CronBuilder.exceptionHandler.handle(err);
+                }
+            };
         }
-        this.cron.handler = async (...args) => {
-            try {
-                await handler(...args);
-            }
-            catch (err) {
-                CronBuilder.exceptionHandler.handle(err);
+        if (CronBuilder.rTracerPlugin) {
+            const rTracerHandler = () => {
+                return CronBuilder.rTracerPlugin.runWithId(() => {
+                    const ctx = getCtx();
+                    if (CronBuilder.loggerIsSet) {
+                        Log.channelOrVanilla('cronjob').info(ctx);
+                    }
+                    return this.cron.handler(ctx);
+                });
+            };
+            return schedule(this.cron.pattern, rTracerHandler, options);
+        }
+        const basicHandler = () => {
+            const ctx = getCtx();
+            if (CronBuilder.loggerIsSet) {
+                Log.channelOrVanilla('cronjob').info(ctx);
             }
+            return this.cron.handler(ctx);
         };
-        return register();
+        return schedule(this.cron.pattern, basicHandler, options);
     }
     /**
      * Defines if the task needs to be scheduled to run

package/src/cron/CronImpl.d.ts

@@ -32,6 +32,15 @@ export declare class CronImpl extends Macroable {
      * ```
      */
     validate(pattern: string): boolean;
+    /**
+     * Register the logger for all tasks.
+     *
+     * @example
+     * ```ts
+     * Cron.setLogger()
+     * ```
+     */
+    setLogger(isToSetLogger: boolean): this;
     /**
      * Register the error handler for all tasks.
      *

package/src/cron/CronImpl.js

@@ -37,6 +37,18 @@ export class CronImpl extends Macroable {
     validate(pattern) {
         return validate(pattern);
     }
+    /**
+     * Register the logger for all tasks.
+     *
+     * @example
+     * ```ts
+     * Cron.setLogger()
+     * ```
+     */
+    setLogger(isToSetLogger) {
+        CronBuilder.loggerIsSet = isToSetLogger;
+        return this;
+    }
     /**
      * Register the error handler for all tasks.
      *

package/src/handlers/CronExceptionHandler.js

@@ -42,21 +42,11 @@ export class CronExceptionHandler {
         if (!this.canBeLogged(error)) {
             return;
         }
-        const isUsingJsonFormatter = Config.is('logging.channels.exception.formatter', 'json');
-        if (isUsingJsonFormatter) {
-            Log.channelOrVanilla('exception').error({
-                name: error.name,
-                code: error.code,
-                status: error.status,
-                message: error.message,
-                help: error.help,
-                cause: error.cause,
-                details: error.details,
-                stack: error.stack
-            });
+        if (Config.is('cron.logger.prettifyException', true)) {
+            Log.channelOrVanilla('exception').error(await error.prettify());
             return;
         }
-        Log.channelOrVanilla('exception').error(await error.prettify());
+        Log.channelOrVanilla('exception').error(error);
     }
     /**
      * Return a boolean indicating if the error can be logged or not.

package/src/kernels/CronKernel.d.ts

@@ -7,6 +7,10 @@ export declare class CronKernel {
      * Register the exception handler for all Cron tasks.
      */
     registerExceptionHandler(path?: string): Promise<void>;
+    /**
+     * Register the logger to all Cron tasks.
+     */
+    registerLogger(): Promise<void>;
     /**
      * Register all the schedulers found inside "rc.schedulers" config
      * inside the service provider.

package/src/kernels/CronKernel.js

@@ -32,6 +32,17 @@ export class CronKernel {
         const Handler = await Module.resolve(path, this.getParentURL());
         CronBuilder.exceptionHandler = new Handler();
     }
+    /**
+     * Register the logger to all Cron tasks.
+     */
+    async registerLogger() {
+        if (!Config.exists('cron.logger.enabled') ||
+            Config.is('cron.logger.enabled', false)) {
+            debug('Not able to register cronjob logger. Enable it in your cron.logger.enabled configuration.');
+            return;
+        }
+        CronBuilder.loggerIsSet = Config.is('cron.logger.enabled', true);
+    }
     /**
      * Register all the schedulers found inside "rc.schedulers" config
      * inside the service provider.