@codefresh-io/service-base 7.4.1 → 8.0.0

package/index.js

@@ -1,5 +1,5 @@
-
-
+/* eslint-disable global-require */
+/* eslint-disable import/order */
 const config = require('./infra/config');
 const service = require('./infra');
 const {
@@ -50,6 +50,7 @@ enabledComponents.forEach((key) => {
             throw new Error(`Component '${key}'' is dependent on component '${dependency}' which is missing.`);
         }
     });
+    // eslint-disable-next-line import/no-dynamic-require
     exportedComponents[component.name || key] = require(`./infra/${key}`);
 });
 

package/infra/__tests__/smoke_test.spec.js

@@ -6,21 +6,26 @@ const mongoClient = require('../mongo');
  * @type {MongoMemoryServer}
  */
 let mongod;
+
 async function clientSetupByUriAndDbName() {
     const uri = mongod.getUri();
     const { port, dbPath, dbName } = mongod.instanceInfo;
-    console.log(`using port ${port}`);
-    console.log(`dbPath ${dbPath}`);
-    console.log(`dbName ${dbName}`);
 
     await mongoClient.init({ mongo: { uri, dbName } });
     return { dbName, dbPath, uri, port };
 }
 
 describe('mongo init compatibility code', () => {
+    beforeAll(async () => {
+        // Dummy warmup to download MongoDB binaries before running tests, to avoid timeout on the first test
+        const warmUpInstance = await MongoMemoryServer.create();
+        await warmUpInstance.stop();
+    }, 60 * 1000);
+
     beforeEach(async () => {
         mongod = await MongoMemoryServer.create();
     });
+
     afterEach(async () => {
         await mongoClient.stop();
         await mongod.stop();

package/infra/config.js

@@ -63,7 +63,9 @@ base.postgres = {
 base.mongo = {
     uri: process.env.MONGO_URI || `mongodb://${APPLICATION_DOMAIN}/${name}`,
     /** @type {import('mongodb').MongoClientOptions} */
-    options: {},
+    options: {
+        monitorCommands: true,
+    },
 };
 
 if (process.env.MTLS_CERT_PATH) {
@@ -110,7 +112,7 @@ base.logger = {
         correlationId: () => {
             try {
                 return getRequestId();
-            } catch (err) {
+            } catch {
                 return {};
             }
         },
@@ -121,18 +123,13 @@ base.logger = {
                     authEntity.activeAccount = _.omit(authEntity.activeAccount, 'features');
                 }
                 return authEntity;
-            } catch (err) {
+            } catch {
                 return {};
             }
         },
     },
 };
 
-base.httpLogger = {
-    level: process.env.HTTP_LOGGER_LEVEL || 'debug',
-    format: 'dev',
-};
-
 base.httpQueryParser = {
     allowPrototypes: true,
     arrayLimit: process.env.URI_QUERY_ARRAY_MAX_LENGTH || 100,

package/infra/encryption/safe.js

@@ -1,8 +1,5 @@
-const { randomUUID } = require('node:crypto');
 const _ = require('lodash');
-const Promise = require('bluebird');
-const crypto = require('crypto');
-
+const crypto = require('node:crypto');
 const config = require('../config');
 const mongoClient = require('../mongo');
 
@@ -43,7 +40,7 @@ function getOrCreateSafe(safeId) {
 
             const newSafe = {
                 _id: safeId,
-                key: (Buffer.from(randomUUID())).toString('base64'), // eslint-disable-line
+                key: (Buffer.from(crypto.randomUUID())).toString('base64'),
             };
             return collection.insertOne(newSafe)
                 .then(() => new Safe(newSafe))
@@ -56,7 +53,7 @@ function getOrCreateSafe(safeId) {
 // decrypt cipher text: try to decrypt with crypto library first
 // if did not find CRYPTO_PREFIX prefix, try to use old triplesec decryption
 Safe.prototype.read_crypto = function (ciphertext) { // eslint-disable-line
-    const deferred = Promise.defer();
+    const deferred = Promise.withResolvers();
 
     const key = Buffer.alloc(32, _.get(config, 'safe.secret'));
     const iv = Buffer.alloc(16, this.safeModel.key);
@@ -85,7 +82,7 @@ Safe.prototype.read_crypto = function (ciphertext) { // eslint-disable-line
 
 // encrypt text and add CRYPTO_PREFIX prefix (to mark the new encryption)
 Safe.prototype.write_crypto = function (plaintext) { // eslint-disable-line
-    const deferred = Promise.defer();
+    const deferred = Promise.withResolvers();
     const key = Buffer.alloc(32, _.get(config, 'safe.secret'));
     const iv = Buffer.alloc(16, this.safeModel.key);
 

package/infra/eventbus.js

@@ -1,118 +1,114 @@
-const Promise = require('bluebird');
+// @ts-check
 const eventBus = require('@codefresh-io/eventbus');
 const monitor = require('@codefresh-io/cf-monitor');
-const CFError = require('cf-errors');
+const { globalLogger } = require('./global-logger');
 
 class Eventbus {
+    #logger = globalLogger.child(this.constructor.name);
+
     constructor() {
         this.eventbusInitialized = false;
     }
 
     /**
-     * starts the connection to eventbus
-     * @returns {*}
+     * Starts the connection to eventbus
+     * @param {any} config
+     * @returns {Promise<Eventbus>}
      */
     init(config) {
-        const logger = require('cf-logs').Logger('codefresh:infra:eventbus'); // eslint-disable-line
-        this.logger = logger;
-        return Promise.resolve()
-            .then(() => {
-                this.config = config;
-
-                const deferred = Promise.defer();
-
-                // TODO a fallback for case where rabbitmq is not up. should be removed once rabbitmq is fully used
-                setTimeout(() => {
-                    deferred.resolve(this);
-                }, 30000);
-
-                eventBus.init({
-                    bus: {
-                        url: this.config.eventbus.uri,
-                        reconnectInterval: 5,
-                    },
-                    store: {
-                        host: this.config.postgres.host,
-                        port: this.config.postgres.port,
-                        database: this.config.postgres.database,
-                        user: this.config.postgres.user,
-                        password: this.config.postgres.password,
-                        ssl: this.config.postgres.ssl,
-                    },
-                    microServiceName: this.config.eventbus.serviceName,
-                });
+        this.config = config;
+        this.#logger.info('Initializing Eventbus connection');
+        /** @type {PromiseWithResolvers<Eventbus>} */
+        const deferred = Promise.withResolvers();
+
+        // TODO a fallback for case where rabbitmq is not up. should be removed once rabbitmq is fully used
+        setTimeout(() => {
+            deferred.resolve(this);
+        }, 30000);
+
+        eventBus.init({
+            bus: {
+                url: this.config.eventbus.uri,
+                reconnectInterval: 5,
+            },
+            store: {
+                host: this.config.postgres.host,
+                port: this.config.postgres.port,
+                database: this.config.postgres.database,
+                user: this.config.postgres.user,
+                password: this.config.postgres.password,
+                ssl: this.config.postgres.ssl,
+            },
+            microServiceName: this.config.eventbus.serviceName,
+        });
 
-                eventBus.on('ready', () => {
-                    logger.info('Eventbus ready');
-                    this.eventbusInitialized = true;
-                    deferred.resolve(this);
-                });
+        eventBus.on('ready', () => {
+            this.#logger.info('Eventbus ready');
+            this.eventbusInitialized = true;
+            deferred.resolve(this);
+        });
 
-                eventBus.on('error', (err) => {
-                    const error = new Error(`Eventbus error: ${err.stack}`);
-                    logger.error(error.stack);
-                    monitor.noticeError(error);
-                });
+        eventBus.on('error', (err) => {
+            this.#logger.error('Eventbus error', err);
+            monitor.noticeError(new Error(`Eventbus error: ${err.stack}`));
+        });
 
-                return deferred.promise;
-            });
+        return deferred.promise;
     }
 
     /**
      * stops the connection to eventbus
-     * @returns {*}
+     * @returns {Promise<void>}
      */
     stop() {
-        const logger = this.logger; // eslint-disable-line
-        if (!this.eventbusInitialized) {
-            return Promise.resolve();
-        }
-
-        const deferred = Promise.defer();
+        if (!this.eventbusInitialized) return Promise.resolve();
 
+        /** @type {PromiseWithResolvers<void>} */
+        const deferred = Promise.withResolvers();
         eventBus.on('close', () => {
-            logger.info('Eventbus client closed');
+            this.#logger.info('Eventbus client closed');
             deferred.resolve();
         });
-
         eventBus.quit();
-
         return deferred.promise;
     }
 
-    subscribe(eventName, handler, options) {
-        const logger = this.logger; // eslint-disable-line
-        return eventBus.subscribe(eventName, handler, options)
-            .then((listener) => {
-                logger.info(`Listening on event ${eventName}`);
-                listener.on('error', (err) => {
-                    logger.error(`${eventName} handler failed: ${err.stack}`);
-                    monitor.noticeError(err);
-                    return listener;
-                });
-            });
+    /**
+     *
+     * @param {unknown} eventName
+     * @param {unknown} handler
+     * @param {unknown} options
+     * @returns {Promise<void>}
+     */
+    async subscribe(eventName, handler, options) {
+        const logger = this.#logger.child('subscribe');
+        const listener = await eventBus.subscribe(eventName, handler, options);
+        logger.info(`Subscribed to event "${eventName}"`);
+        listener.on('error', (/** @type {unknown} */ err) => {
+            logger.error(`Handler for event "${eventName}" failed`, err);
+            monitor.noticeError(err);
+        });
     }
 
-    publish(eventName, data, returnPromise = false) { // eslint-disable-line
-        const logger = this.logger; // eslint-disable-line
-
-        logger.debug(`publishing event: ${eventName}`);
-        const promise = eventBus.publish(eventName, data);
-
-        if (returnPromise) {
-            return promise;
-        }
-        promise
-            .then(() => {
-                logger.debug(`event: ${eventName} published successfully`);
-            })
-            .catch((err) => {
-                const error = new CFError({
-                    cause: err,
-                    message: `Failed to publish event ${eventName}`,
-                });
-                logger.error(error.stack);
-                monitor.noticeError(error);
+    /**
+     * @param {unknown} eventName
+     * @param {unknown} data
+     * @param {boolean} [shouldReturnPromise]
+     * @returns {Promise<void>|void}
+     */
+    // eslint-disable-next-line consistent-return
+    publish(eventName, data, shouldReturnPromise = false) {
+        const logger = this.#logger.child('publish');
+        logger.debug(`Publishing event "${eventName}"`);
+        const publishResultPromise = eventBus.publish(eventName, data);
+
+        if (shouldReturnPromise) return publishResultPromise;
+
+        publishResultPromise
+            .then(() => logger.debug(`Event "${eventName}" published successfully`))
+            .catch((error) => {
+                logger.error(`Failed to publish event "${eventName}"`, error);
+                monitor.noticeError(new Error(`Failed to publish event "${eventName}"`, { cause: error }));
             });
     }
 }

package/infra/express.js

@@ -1,161 +1,171 @@
-const Promise = require('bluebird');
+// @ts-check
+const { httpLoggerMiddlewareFactory } = require('@codefresh-io/cf-telemetry/logs/express');
+const { Logger } = require('@codefresh-io/cf-telemetry/logs');
 const express = require('express');
 const qs = require('qs');
 const compression = require('compression');
 const bodyParser = require('body-parser');
 const methodOverride = require('method-override');
 const cookieParser = require('cookie-parser');
-const morgan = require('morgan');
 const monitor = require('@codefresh-io/cf-monitor');
+// @ts-ignore
 const { newDomainMiddleware } = require('@codefresh-io/http-infra');
 const { openapi } = require('@codefresh-io/cf-openapi');
 const CFError = require('cf-errors');
+const { globalLogger } = require('./global-logger');
+
+/**
+ * @typedef {import('express').Application } ExpressApp
+ * @typedef {import('express').RequestHandler} RequestHandler
+ * @typedef {import('express').ErrorRequestHandler} ErrorRequestHandler
+ * @typedef {import('express').Request} Request
+ * @typedef {import('express').Response} Response
+ * @typedef {import('express').NextFunction} NextFunction
+ * @typedef {import('node:http').Server} HttpServer
+ */
 
 class Express {
+    #logger = globalLogger.child(this.constructor.name);
+
     constructor() {
-        this.expressApp = express(); // the express app definition
-        this.expressServer = undefined; // the express server instance
+        /** @type {ExpressApp} */
+        this.expressApp = express();
+        /** @type {HttpServer|undefined} */
+        this.expressServer = undefined;
+        /** @type {boolean} */
         this.healthy = true;
     }
 
-    stop() {
-        return Promise.resolve()
-            .then(() => this.expressServer.close());
+    /**
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        this.#logger.info('Stopping Express server');
+        if (!this.expressServer) return;
+        this.expressServer.close();
     }
 
     /**
-     * starts the connection to mongo
-     * @returns {*}
+     * Initializes the Express server.
+     * @param {any} config
+     * @param {any} createRoutes
+     * @param {any} [opt]
+     * @returns {Promise<void>}
      */
-    init(config, createRoutes, opt = {}) {
-        const logger = require('cf-logs').Logger('codefresh:infra:express'); // eslint-disable-line
-        this.logger = logger;
+    async init(config, createRoutes, opt = {}) {
         this.options = opt;
-        return Promise.resolve()
-            .then(() => {
-                this.config = config;
-                this.createRoutes = createRoutes;
-                return this._create()
-                    .then(() => this._start(this.expressApp))
-                    .then((expressServer) => {
-                        this.expressServer = expressServer;
-                    })
-                    .then(() => {
-                        openapi.events().subscribe();
-                        openapi.events().publish();
-                    });
-            });
+        this.config = config;
+        this.createRoutes = createRoutes;
+        await this._create();
+        this.expressServer = await this._start(this.expressApp);
+        openapi.events().subscribe();
+        openapi.events().publish();
     }
 
-    _create() {
-        const logger = this.logger; // eslint-disable-line
-        return Promise.resolve()
-            .then(() => {
-                const app = this.expressApp;
-                app.set('query parser', (str) => qs.parse(str, this.config.httpQueryParser));
-
-                app.use(newDomainMiddleware());
-
-                app.use(cookieParser());
-                app.use(compression());
-
-                openapi.endpoints().registerUtilityMiddleware(app);
-                app.use(bodyParser.json());
-
-                app.use(bodyParser.urlencoded({ extended: true }));
-                app.use(methodOverride());
-
-                if (this.config.httpLogger) {
-                    app.use(morgan(this.config.httpLogger.format, {
-                        skip: (req, res) => {
-                            if (this.config.httpLogger.level === 'debug') {
-                                return false;
-                            }
-                            const code = res.statusCode;
-                            return code < 400;
-                        },
-                        stream: {
-                            write: (str) => {
-                                logger.info(str.substring(0, str.length - 1));
-                            },
-                        },
-                    }));
+    async _create() {
+        /** Should be the first middleware */
+        this.expressApp.use(httpLoggerMiddlewareFactory(new Logger('http')));
+
+        this.expressApp.set('query parser', (/** @type {string} */ str) => qs.parse(str, this.config.httpQueryParser));
+
+        this.expressApp.use(newDomainMiddleware());
+
+        this.expressApp.use(cookieParser());
+        this.expressApp.use(compression());
+
+        openapi.endpoints().registerUtilityMiddleware(this.expressApp);
+        this.expressApp.use(bodyParser.json());
+
+        this.expressApp.use(bodyParser.urlencoded({ extended: true }));
+        this.expressApp.use(methodOverride());
+
+        openapi.endpoints().register(this.expressApp);
+        await this.createRoutes(this.expressApp);
+
+        this.expressApp.get('/api/ping', (req, res) => {
+            res.status(200).send();
+        });
+
+        this.expressApp.get('/api/ready', (req, res) => {
+            if (this.options.isReady()) {
+                res.status(200).send();
+            } else {
+                res.status(503).send();
+            }
+        });
+
+        this.expressApp.get('/api/health', (req, res) => {
+            if (this.options.isHealthy()) {
+                res.status(200).send();
+            } else {
+                res.status(503).send();
+            }
+        });
+
+        /** @type {ErrorRequestHandler} */
+        const errorHandler = (err, _req, res, next) => {
+            this.#logger.error('Request handler error', err);
+
+            if (res.headersSent) {
+                next(err);
+                return;
+            }
+
+            if (err instanceof CFError) {
+                if (!err.getFirstValue('recognized')) {
+                    monitor.noticeError(err);
                 }
-                openapi.endpoints().register(app);
-                return this.createRoutes(app)
-                    .then(() => {
-                        app.get('/api/ping', (req, res) => {
-                            res.status(200).send();
-                        });
-
-                        app.get('/api/ready', (req, res) => {
-                            if (this.options.isReady()) {
-                                res.status(200).send();
-                            } else {
-                                res.status(503).send();
-                            }
-                        });
-
-                        app.get('/api/health', (req, res) => {
-                            if (this.options.isHealthy()) {
-                                res.status(200).send();
-                            } else {
-                                res.status(503).send();
-                            }
-                        });
-
-                        // the last error handler
-                        app.use((err, req, res, next) => { // eslint-disable-line
-                            logger.error(err.stack);
-
-                            if (res.headersSent) {
-                                return next(err);
-                            }
-
-                            if (err instanceof CFError) {
-                                if (!err.getFirstValue('recognized')) {
-                                    monitor.noticeError(err);
-                                }
-                            } else {
-                                monitor.noticeError(err);
-                            }
-
-                            const statusCode = err.statusCode || 500;
-                            // check if err object has overridden toString method
-                            // before sending toString() response to prevent [object Object] responses
-                            const message = err.toString === Object.prototype.toString
-                                ? (err.message || 'Internal server error')
-                                : err.toString();
-                            res.status(statusCode).send({ message });
-                        });
-                    });
-            });
+            } else {
+                monitor.noticeError(err);
+            }
+
+            const statusCode = err.statusCode || 500;
+            // check if err object has overridden toString method
+            // before sending toString() response to prevent [object Object] responses
+            const message = err.toString === Object.prototype.toString
+                ? (err.message || 'Internal server error')
+                : err.toString();
+            res.status(statusCode).send({ message });
+        };
+        /** Should be the last middleware */
+        this.expressApp.use(errorHandler);
     }
 
+    /**
+     * @param {ExpressApp} app
+     * @returns {Promise<HttpServer>}
+     */
     _start(app) {
-        const logger = this.logger; // eslint-disable-line
+        this.#logger.info('Starting Express server');
+
         openapi.dependencies().fetch();
-        return new Promise((resolve, reject) => {
-            const server = app.listen(this.config.port, (err) => {
-                if (err) {
-                    logger.info(`Failed to load service with message ${err.message}`);
-                    reject(err);
-                } else {
-                    logger.info(`Express server listening on port ${this.config.port}, in mode ${this.config.env}`);
-                    resolve(server);
-                }
-            });
+        /** @type {PromiseWithResolvers<HttpServer>} */
+        const deferred = Promise.withResolvers();
+        const server = app.listen(this.config.port, (err) => {
+            if (err) {
+                this.#logger.error('Failed to start Express server', err);
+                deferred.reject(err);
+                return;
+            }
+            this.#logger.info(`Express server listening on port "${this.config.port}", in mode "${this.config.env}"`);
+            deferred.resolve(server);
         });
+        return deferred.promise;
     }
 
-    makeEndpoint(fn) { // eslint-disable-line
-        return function (req, res, next) { // eslint-disable-line
-            Promise.resolve()
-                .then(() => fn(req, res))
-                .then((ret) => {
-                    res.send(ret);
-                })
-                .catch((err) => next(err));
+    /**
+     * @param {(req: Request, res: Response) => Promise<any>} fn
+     * @returns {RequestHandler}
+     */
+    makeEndpoint(fn) {
+        this.#logger.debug(`Wrapping request handler "${fn?.name}" with error handling`);
+        return async function routeHandler(req, res, next) {
+            try {
+                const resp = await fn(req, res);
+                res.send(resp);
+            } catch (error) {
+                next(error);
+            }
         };
     }
 }

package/infra/global-logger.js

@@ -0,0 +1,7 @@
+const { Logger } = require('@codefresh-io/cf-telemetry/logs');
+
+const globalLogger = new Logger('@codefresh-io/service-base');
+
+module.exports = {
+    globalLogger,
+};

package/infra/helper.js

@@ -1,12 +1,11 @@
 const splitUriBySlash = (uri) => {
     const parts = uri.split('/');
-    const lastIndex = parts.length - 1;
     return {
-        prefix: parts.slice(0, -1)
-            .join('/'),
-        dbName: parts[lastIndex].split('?')[0],
+        prefix: parts.slice(0, -1).join('/'),
+        dbName: parts.at(-1).split('?')[0],
     };
 };
 
 const getDbNameFromUri = (uri) => splitUriBySlash(uri).dbName;
+
 module.exports = { splitUriBySlash, getDbNameFromUri };

package/infra/index.js

@@ -1,8 +1,7 @@
 const monitor = require('@codefresh-io/cf-monitor');
 
 monitor.init();
-const Promise = require('bluebird'); // jshint ignore:line
-const cflogs = require('cf-logs');
+const Bluebird = require('bluebird');
 const { openapi } = require('@codefresh-io/cf-openapi');
 const config = require('./config');
 const eventbus = require('./eventbus');
@@ -12,10 +11,11 @@ const express = require('./express');
 const logging = require('./logging');
 const redis = require('./redis');
 const { publishInterface, subscribeInterface } = require('./openapi-events');
-
-let logger;
+const { globalLogger } = require('./global-logger');
 
 class Microservice {
+    #logger = globalLogger.child(this.constructor.name);
+
     constructor() {
         this._ready = false;
         this._healthy = false;
@@ -30,26 +30,28 @@ class Microservice {
     }
 
     markAsReady() {
-        logger.info('Service marked as ready');
+        this.#logger.info('Service marked as ready');
         this._ready = true;
     }
 
     markAsNotReady() {
-        logger.info('Service marked as not ready');
+        this.#logger.info('Service marked as not ready');
         this._ready = false;
     }
 
     markAsHealthy() {
-        logger.info('Service marked as healthy');
+        this.#logger.info('Service marked as healthy');
         this._healthy = true;
     }
 
     markAsUnhealthy() {
-        logger.info('Service marked as unhealthy');
+        this.#logger.info('Service marked as unhealthy');
         this._healthy = false;
     }
 
     init(initFn) {
+        const logger = this.#logger.child('init');
+        logger.info('Initializing service');
         const enabledComponents = config.getConfigArray('enabledComponents');
         const opt = {
             isReady: this.isReady.bind(this),
@@ -57,7 +59,6 @@ class Microservice {
         };
         return logging.init(config)
             .then(() => {
-                logger = cflogs.Logger('codefresh:infra:index');
                 let sigintCount = 0;
                 this._validateGraceTimers();
                 return processEvents.init(config)
@@ -91,7 +92,7 @@ class Microservice {
                 this.markAsHealthy();
             })
             .catch((err) => {
-                console.error(`Initialization error: ${err.stack}`);
+                logger.error('Initialization error', err);
                 process.exit(1);
             });
     }
@@ -100,7 +101,8 @@ class Microservice {
     // - first phase need to make sure to not accept any new requests/events
     // - then a decent amount of time will be given to clear all on-going contexts
     // - second phase will close all dependencies connections like mongo, postgres etc
-    stop() { // eslint-disable-line
+    stop() {
+        const logger = this.#logger.child('stop');
         const enabledComponents = config.getConfigArray('enabledComponents');
         const gracePeriod = config.gracePeriodTimers.totalPeriod;
 
@@ -129,24 +131,24 @@ class Microservice {
             logger.info('About to stop redis');
             promises.push(redis.stop.bind(redis));
         }
-        return Promise
+        return Bluebird
             .resolve()
             .then(() => {
                 this.markAsNotReady();
                 logger.info(`Waiting more ${incomingHttpRequests} ms to accept more request`);
-                return Promise.resolve()
+                return Bluebird.resolve()
                     .delay(incomingHttpRequests);
             })
             .then(() => {
                 logger.info(`Waiting more ${ongoingHttpRequest} ms to process all ongoing requests`);
-                return Promise.resolve()
+                return Bluebird.resolve()
                     .delay(ongoingHttpRequest)
                     .then(() => express.stop());
             })
             .then(() => {
                 logger.info(`Setting up ${infraDependencies} ms to finish all core service connections timeout`);
-                return Promise.resolve()
-                    .then(() => Promise.all(promises))
+                return Bluebird.resolve()
+                    .then(() => Bluebird.all(promises))
                     .timeout(infraDependencies);
             })
             .timeout(gracePeriod)
@@ -155,21 +157,21 @@ class Microservice {
                 process.exit();
             })
             .catch((error) => {
-                console.error(`error during shutdown: ${error.stack}`);
+                this.#logger.error('Error during shutdown', error);
                 process.exit();
             });
     }
 
-    _validateGraceTimers() { // eslint-disable-line
+    _validateGraceTimers() {
         const gracePeriod = config.gracePeriodTimers.totalPeriod;
         const incomingHttpRequests = config.gracePeriodTimers.secondsToAcceptAdditionalRequests;
         const ongoingHttpRequest = config.gracePeriodTimers.secondsToProcessOngoingRequests;
         const infraDependencies = config.gracePeriodTimers.secondsToCloseInfraConnections;
 
         if (gracePeriod < (incomingHttpRequests + ongoingHttpRequest + infraDependencies)) {
-            const message = `Total grace period: ${gracePeriod}, the service needs at least ${incomingHttpRequests + ongoingHttpRequest + infraDependencies} to perform graceful shuwdown. Check service configuration`; // eslint-disable-line
+            const message = `Total grace period: ${gracePeriod}, the service needs at least ${incomingHttpRequests + ongoingHttpRequest + infraDependencies} to perform graceful shutdown. Check service configuration`; // eslint-disable-line
             if (!config.gracePeriodTimers.skipGraceTimersValidation) {
-                logger.warn(message);
+                this.#logger.warn(message);
             } else {
                 throw new Error(message);
             }

package/infra/logging.js

@@ -1,32 +1,39 @@
-const Promise = require('bluebird');
+// @ts-check
+const { Logger } = require('@codefresh-io/cf-telemetry/logs');
 const cflogs = require('cf-logs');
-const { name: serviceName } = require('./config');
-
-let logger;
+const { globalLogger } = require('./global-logger');
 
+/**
+ * Legacy shim for logging.
+ * Feel free to remove once dependent services are using logger from `@codefresh-io/cf-telemetry` directly.
+ */
 class Logging {
-    getLogger(namespace) { // eslint-disable-line
-        return cflogs.Logger(`codefresh:${serviceName}${namespace ? `:${namespace}` : ''}`);
+    /**
+     * @param {string} scope
+     * @returns {Logger}
+     * @deprecated Import logger from `@codefresh-io/cf-telemetry` directly instead of this wrapper.
+     */
+    getLogger(scope) { // eslint-disable-line
+        return new Logger(scope);
     }
 
-    init(config) { // eslint-disable-line
-        return Promise.resolve()
-            .then(() => {
-                cflogs.init(config.logger);
-                logger = cflogs.Logger('codefresh');
-                // override the default console.log
-                console.log = (message) => {
-                    logger.log('info', message);
-                };
-                console.error = (message) => {
-                    logger.log('error', message);
-                };
-            });
+    /**
+     * @param {any} config
+     */
+    // eslint-disable-next-line class-methods-use-this
+    async init(config) {
+        // Init for legacy logger still used by some services. Feel free to remove if dependent services are not using `cf-logs` anymore.
+        cflogs.init(config.logger);
+        // override the default console.log
+        const consoleOverride = globalLogger.child('console-override');
+        console.debug = consoleOverride.debug.bind(consoleOverride);
+        console.log = consoleOverride.info.bind(consoleOverride);
+        console.warn = consoleOverride.warn.bind(consoleOverride);
+        console.error = consoleOverride.error.bind(consoleOverride);
     }
 
-    stop() { // eslint-disable-line
-        return Promise.resolve();
-    }
+    // eslint-disable-next-line no-empty-function, class-methods-use-this
+    async stop() {}
 }
 
 module.exports = new Logging();

package/infra/mongo.js

@@ -1,50 +1,70 @@
+// @ts-check
 const { MongoClient, ObjectId } = require('mongodb');
+const { monitorMongoDBClient } = require('@codefresh-io/cf-telemetry/metrics/mongodb');
+const { globalLogger } = require('./global-logger');
 const { getDbNameFromUri } = require('./helper');
 
+/**
+ * @typedef {object} MongoConfig
+ * @property {string} uri MongoDB connection URI.
+ * @property {import('mongodb').MongoClientOptions} [options] MongoDB client options.
+ * @property {string} [dbName] Database name.
+ *
+ * @typedef {object} Config
+ * @property {MongoConfig} mongo MongoDB configuration.
+ */
+
 class Mongo {
+    #logger = globalLogger.child(this.constructor.name);
+
     constructor() {
         this.db = undefined;
         this.ObjectId = ObjectId;
     }
 
     /**
-     * starts the connection to mongo
+     * Initializes the MongoDB client and connects to the database.
+     * @param {Config} config
+     * @returns {Promise<void>}
      */
     async init(config) {
-        const clientSettings = { ...config.mongo.options };
-        const logger = require('cf-logs').Logger('codefresh:infra:mongo'); // eslint-disable-line
-        this.logger = logger;
-
-        const { uri } = config.mongo;
-        const dbName = config.mongo.dbName || getDbNameFromUri(uri);
-        const client = new MongoClient(uri, clientSettings);
-        logger.info(`Mongo db name ${dbName}`);
-
         try {
-            await client.connect();
-            logger.info('Mongo driver connected');
+            this.#logger.info('Initializing MongoDB connection');
+            const { uri, options } = config.mongo;
+            const dbName = config.mongo.dbName || getDbNameFromUri(uri);
+            const client = new MongoClient(uri, options);
+            monitorMongoDBClient(client);
+            this.client = await client.connect();
+            this.db = this.client.db(dbName);
+            this.#logger.info('MongoDB client connected');
         } catch (error) {
-            logger.error('Error connecting to MongoDB:', error);
+            this.#logger.error('Unable to connect to MongoDB', error);
             throw error;
         }
-
-        this.client = client;
-        this.db = this.client.db(dbName);
-        logger.info('Mongo db initialized');
     }
 
     /**
-     * stops the connection to mongo
+     * Closes the MongoDB client connection.
+     * @returns {Promise<void>}
      */
     async stop() {
-        if (!this.db) {
-            return;
+        try {
+            this.#logger.info('Closing MongoDB connection');
+            await this.client?.close();
+            this.#logger.info('MongoDB connection closed');
+        } catch (error) {
+            this.#logger.error('Unable to close MongoDB connection', error);
+            throw error;
         }
-        await this.client.close();
     }
 
+    /**
+     * Returns the specified collection.
+     * @param {string} collectionName
+     * @returns {import('mongodb').Collection | undefined} It only returns `undefined` if the client was not initialized yet.
+     */
     collection(collectionName) {
-        return this.db.collection(collectionName);
+        return this.db?.collection(collectionName);
     }
 }
 

package/infra/process-events.js

@@ -1,36 +1,35 @@
-const EventEmitter = require('events');
-const Promise = require('bluebird');
+// @ts-check
+const EventEmitter = require('node:events');
+const { globalLogger } = require('./global-logger');
 
 class ProcessEvents extends EventEmitter {
+    #logger = globalLogger.child(this.constructor.name);
+
     /**
-     * starts listening on process events
-     * @param config
+     * Starts listening on process events
+     * @param {unknown} config
      */
-    init(config) {
-        const logger = require('cf-logs').Logger('codefresh:infra:process-events'); // eslint-disable-line
-        return Promise.resolve()
-            .then(() => {
-                this.config = config;
+    async init(config) {
+        this.config = config;
 
-                // graceful shutdown
-                process.on('SIGTERM', () => {
-                    logger.info('SIGTERM received');
-                    this.emit('SIGTERM');
-                });
+        // graceful shutdown
+        process.on('SIGTERM', () => {
+            this.#logger.info('SIGTERM received');
+            this.emit('SIGTERM');
+        });
 
-                process.on('SIGINT', () => {
-                    logger.info('SIGINT received');
-                    this.emit('SIGINT');
-                });
+        process.on('SIGINT', () => {
+            this.#logger.info('SIGINT received');
+            this.emit('SIGINT');
+        });
 
-                process.on('unhandledRejection', (err) => {
-                    logger.error(`Unhandled rejection ${err.stack}`);
-                });
+        process.on('unhandledRejection', (err) => {
+            this.#logger.error('Unhandled rejection', err);
+        });
 
-                process.on('uncaughtException', (err) => {
-                    logger.error(`Uncaught Exception: ${err.stack}`);
-                });
-            });
+        process.on('uncaughtException', (err) => {
+            this.#logger.error('Uncaught Exception', err);
+        });
     }
 }
 

package/infra/redis.js

@@ -1,8 +1,17 @@
-const Promise = require('bluebird');
+// @ts-check
 const monitor = require('@codefresh-io/cf-monitor');
 const redis = require('redis');
+const { globalLogger } = require('./global-logger');
+
+/**
+ * @typedef {Partial<import('redis').ClientOpts>} RedisConfig
+ * @typedef {object} Config
+ * @property {RedisConfig} redis Redis configuration.
+ */
 
 class Redis {
+    #logger = globalLogger.child(this.constructor.name);
+
     constructor() {
         this.client = undefined;
         this.redisInitialized = false;
@@ -10,12 +19,14 @@ class Redis {
 
     /**
      * starts the connection to redis
-     * @returns {*}
+     * @param {Config} config
+     * @returns {Promise<void>}
      */
     init(config) {
-        const logger = require('cf-logs').Logger('codefresh:infra:redis'); // eslint-disable-line
-        this.logger = logger;
-        const deferred = Promise.defer();
+        this.#logger.info('Initializing Redis connection');
+
+        /** @type {PromiseWithResolvers<void>} */
+        const deferred = Promise.withResolvers();
 
         // TODO a fallback for case where redis is not up. should be removed once redis is fully used
         setTimeout(() => {
@@ -31,21 +42,21 @@ class Redis {
         });
 
         this.client.on('ready', () => {
-            logger.info('Redis client ready');
+            this.#logger.info('Redis client ready');
             this.redisInitialized = true;
             deferred.resolve();
         });
 
         this.client.on('connect', () => {
-            logger.info('Redis client connecting');
+            this.#logger.info('Redis client connecting');
         });
 
         this.client.on('reconnecting', () => {
-            logger.info('Redis client reconnecting');
+            this.#logger.info('Redis client reconnecting');
         });
 
         this.client.on('error', (error) => {
-            logger.error(error.message);
+            this.#logger.error('Redis client error', error);
             monitor.noticeError(error);
         });
 
@@ -54,23 +65,20 @@ class Redis {
 
     /**
      * stops the connection to redis
-     * @returns {*}
+     * @returns {Promise<void>}
      */
-    stop() {
-        const logger = this.logger; // eslint-disable-line
+    async stop() {
         if (!this.redisInitialized) {
             return Promise.resolve();
         }
 
-        const deferred = Promise.defer();
-
-        this.client.on('end', () => {
-            logger.info('Redis client ended');
+        /** @type {PromiseWithResolvers<void>} */
+        const deferred = Promise.withResolvers();
+        this.client?.on('end', () => {
+            this.#logger.info('Redis client connection closed');
             deferred.resolve();
         });
-
-        this.client.quit();
-
+        this.client?.quit();
         return deferred.promise;
     }
 }

package/infra/validation.js

@@ -3,6 +3,9 @@ const Promise = require('bluebird');
 const Joi = require('joi').extend(require('@wegolook/joi-objectid'));
 const YAML = require('js-yaml');
 const Ajv = require('ajv');
+const { globalLogger } = require('./global-logger');
+
+const logger = globalLogger.child('validation');
 
 const customYamlJoi = Joi.extend((joi) => ({ // eslint-disable-line
     name: 'yaml',
@@ -11,7 +14,8 @@ const customYamlJoi = Joi.extend((joi) => ({ // eslint-disable-line
         try {
             YAML.safeLoad(value);
             return value;
-        } catch (err) {
+        } catch (error) {
+            logger.debug('YAML validation error', error);
             return this.createError('yaml', { v: value }, state, options);
         }
     },
@@ -29,6 +33,7 @@ const customJsonSchemaStringJoi = Joi.extend((joi) => ({ // eslint-disable-line
             ajv.compile(JSON.parse(value));
             return value;
         } catch (err) {
+            logger.debug('JSON Schema validation error', err);
             return this.createError('jsonSchemaString.pre', { v: value, err: err.toString().replace('Error: schema is invalid: ', '') }, state, options); // eslint-disable-line max-len
         }
     },

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@codefresh-io/service-base",
-  "version": "7.4.1",
+  "version": "8.0.0",
   "main": "index.js",
   "description": "",
   "bin": {
     "cf-openapi": "./node_modules/cf-openapi/bin/cf-openapi"
   },
   "engines": {
-    "node": "^20.0.0 || ^22.0.0"
+    "node": ">=22 <=24"
   },
   "files": [
     "index.js",
     "infra/**/*"
   ],
   "scripts": {
-    "test": "(find . -not -path './node_modules/*' -path '*/*.spec.js' | grep -v '__tests__' | NODE_ENV=test xargs mocha) && jest",
+    "test": "(find . -not -path './node_modules/*' -path '*/*.spec.js' | grep -v '__tests__' | NODE_ENV=test xargs mocha) && CF_TELEMETRY_LOGS_PRETTIFY=single-line jest",
     "start": "node index.js",
-    "lint": "eslint infra/**",
+    "lint": "eslint .",
     "build": "echo 'No build step'"
   },
   "repository": {
@@ -29,7 +29,6 @@
     "url": "https://github.com/codefresh-io/service-base/issues"
   },
   "resolutions": {
-    "eslint/**/ansi-regex": "^4.0.0",
     "js-yaml": "^3.13.1",
     "json-schema": "^0.4.0",
     "get-func-name": "^2.0.1"
@@ -48,7 +47,7 @@
     "bluebird": "^3.5.3",
     "body-parser": "^1.19.2",
     "cf-errors": "^0.1.15",
-    "cf-logs": "^1.1.26",
+    "cf-logs": "^1.1.28",
     "chai": "4.3.10",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.4",
@@ -57,25 +56,29 @@
     "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "method-override": "^3.0.0",
-    "mongodb": "^6.15.0",
-    "morgan": "^1.9.1",
-    "proxyquire": "^1.8.0",
+    "mongodb": "^6.21.0",
+    "qs": "^6.14.1",
     "queue": "^4.2.1",
-    "qs":"^6.14.1",
     "redis": "^3.1.0",
     "request": "2.88.2",
     "request-promise": "4.2.6"
   },
   "devDependencies": {
-    "@shelf/jest-mongodb": "^4.2.0",
-    "eslint": "^8.52.0",
+    "@codefresh-io/cf-telemetry": "^3.9.1",
+    "@eslint/eslintrc": "^3.3.1",
+    "eslint": "^9.32.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jest": "^27.6.3",
-    "eslint-plugin-mocha": "^4.12.1",
-    "jest": "^29.7.0",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-mocha": "^10.5.0",
+    "jest": "^30.2.0",
     "mocha": "^8.2.1",
-    "mongodb-memory-server": "^9.1.6"
+    "mongodb-memory-server": "^11.0.1",
+    "proxyquire": "^1.8.0"
+  },
+  "peerDependencies": {
+    "@codefresh-io/cf-telemetry": "^3.9.1"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }