@lucaapp/service-utils 1.8.0 → 1.9.1

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export * from './lib/kafka';
 export * from './lib/serviceIdentity';
 export * from './lib/metrics';
 export * from './lib/wsEvent';
+export * from './lib/lifecycle';
+export * from './lib/logger';

package/dist/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./lib/kafka"), exports);
 __exportStar(require("./lib/serviceIdentity"), exports);
 __exportStar(require("./lib/metrics"), exports);
 __exportStar(require("./lib/wsEvent"), exports);
+__exportStar(require("./lib/lifecycle"), exports);
+__exportStar(require("./lib/logger"), exports);

package/dist/lib/kafka/kafkaClient.d.ts

@@ -21,7 +21,7 @@ declare class KafkaClient {
     private verifySignature;
     private parseValue;
     private ensureTopics;
-    consume: <T extends KafkaTopic>(groupId: string, kafkaTopic: T, handler: EventPayloadHandler<T>, fromBeginning?: boolean) => Promise<Consumer>;
+    consume: <T extends KafkaTopic>(kafkaTopic: T, handler: EventPayloadHandler<T>, fromBeginning?: boolean) => Promise<Consumer>;
     produce: <T extends KafkaTopic>(kafkaTopic: T, key: string, value: KafkaEvent<T>) => Promise<void>;
 }
 export { KafkaClient };

package/dist/lib/kafka/kafkaClient.js

@@ -154,8 +154,9 @@ class KafkaClient {
             });
             this.logger.debug(`Topic=${topic} created.`);
         };
-        this.consume = async (groupId, kafkaTopic, handler, fromBeginning = false) => {
+        this.consume = async (kafkaTopic, handler, fromBeginning = false) => {
             const topic = await this.getTopic(kafkaTopic);
+            const groupId = `${this.environment.valueOf()}_${this.serviceIdentity.identityName}`;
             try {
                 const consumer = this.kafkaClient.consumer({ groupId });
                 await consumer.connect();
@@ -180,6 +181,7 @@ class KafkaClient {
                             messageConsumedErrorCounter
                                 .labels({ topic: kafkaTopic.valueOf(), groupId })
                                 .inc();
+                            throw error;
                         }
                     },
                 });

package/dist/lib/lifecycle/index.d.ts

@@ -0,0 +1,17 @@
+import { Logger, LoggerOptions } from 'pino';
+declare class Lifecycle {
+    state: {
+        isShuttingDown: boolean;
+    };
+    private readonly shutdownDelay;
+    private readonly logger;
+    constructor(shutdownDelay: number, logger: Logger<LoggerOptions>);
+    shutdownHandlers: Array<() => void>;
+    gracefulShutdown: (isImmediate?: boolean) => Promise<void>;
+    private sigtermHandler;
+    unhandledRejectionHandler: (error: unknown) => void;
+    uncaughtExceptionHandler: (error: unknown) => void;
+    registerShutdownHandler: (shutdownHandler: () => void) => void;
+    registerHooks: () => void;
+}
+export { Lifecycle };

package/dist/lib/lifecycle/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lifecycle = void 0;
+const moment_1 = __importDefault(require("moment"));
+const sleep_1 = require("./sleep");
+class Lifecycle {
+    constructor(shutdownDelay, logger) {
+        this.state = {
+            isShuttingDown: false,
+        };
+        this.shutdownHandlers = [];
+        this.gracefulShutdown = async (isImmediate = false) => {
+            if (this.state.isShuttingDown)
+                return;
+            this.state.isShuttingDown = true;
+            if (!isImmediate) {
+                this.logger.info(`shutting down in ${this.shutdownDelay.as('seconds')}s.`);
+                await (0, sleep_1.sleep)(this.shutdownDelay.as('milliseconds'));
+            }
+            this.logger.info('starting shutdown');
+            for (const shutdownHandler of this.shutdownHandlers) {
+                shutdownHandler();
+            }
+            this.logger.info('shutdown complete');
+        };
+        this.sigtermHandler = async () => {
+            this.logger.info('SIGTERM received.');
+            await this.gracefulShutdown();
+            process.exit(0);
+        };
+        this.unhandledRejectionHandler = (error) => {
+            this.logger.error(error, 'unhandledRejection');
+            process.exit(1);
+        };
+        this.uncaughtExceptionHandler = (error) => {
+            this.logger.error(error, 'uncaughtException');
+            process.exit(1);
+        };
+        this.registerShutdownHandler = (shutdownHandler) => {
+            this.shutdownHandlers.push(shutdownHandler);
+        };
+        this.registerHooks = () => {
+            process.on('SIGTERM', this.sigtermHandler);
+            process.on('uncaughtException', this.uncaughtExceptionHandler);
+            process.on('unhandledRejection', this.unhandledRejectionHandler);
+        };
+        this.shutdownDelay = moment_1.default.duration(shutdownDelay, 'seconds');
+        this.logger = logger;
+    }
+}
+exports.Lifecycle = Lifecycle;

package/dist/lib/lifecycle/sleep.d.ts

@@ -0,0 +1,3 @@
+declare const sleep: (msToSleep: number) => Promise<void>;
+declare const randomSleep: () => Promise<void>;
+export { sleep, randomSleep };

package/dist/lib/lifecycle/sleep.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSleep = exports.sleep = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const util_1 = require("util");
+const setTimeoutPromise = (0, util_1.promisify)(setTimeout);
+const sleep = (msToSleep) => setTimeoutPromise(msToSleep);
+exports.sleep = sleep;
+const randomSleep = () => setTimeoutPromise(crypto_1.default.randomInt(100, 500));
+exports.randomSleep = randomSleep;

package/dist/lib/logger/index.d.ts

@@ -0,0 +1,6 @@
+import { Logger, LoggerOptions } from 'pino';
+import { HttpLoggerCreationOptions } from './utils';
+export declare class LoggerFactory {
+    static getLogger(logLevel: string): Logger<LoggerOptions>;
+    static getHttpLogger(options: HttpLoggerCreationOptions): import("pino-http").HttpLogger;
+}

package/dist/lib/logger/index.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const pino_1 = __importDefault(require("pino"));
+const pino_http_1 = __importDefault(require("pino-http"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const uuid_1 = require("uuid");
+class LoggerFactory {
+    static getLogger(logLevel) {
+        return (0, pino_1.default)({ level: logLevel });
+    }
+    static getHttpLogger(options) {
+        const { requestSerializer, responseSerializer, errorSerializer, defaultHttpLogLevel, customMessage, } = new HttpLoggerHelpers(options);
+        const logger = this.getLogger(options.logLevel);
+        return (0, pino_http_1.default)({
+            logger: logger,
+            serializers: {
+                req: requestSerializer,
+                res: responseSerializer,
+                err: errorSerializer,
+            },
+            customLogLevel: (response, error) => {
+                if (response.statusCode >= 400 && response.statusCode < 500)
+                    return 'warn';
+                if (response.statusCode >= 500 || error)
+                    return 'error';
+                return defaultHttpLogLevel;
+            },
+            customSuccessMessage: customMessage,
+            customErrorMessage: (_, response) => customMessage(response),
+            genReqId: () => (0, uuid_1.v4)(),
+        });
+    }
+}
+exports.LoggerFactory = LoggerFactory;
+class HttpLoggerHelpers {
+    constructor({ debug, e2e, defaultHttpLogLevel }) {
+        this.requestSerializer = (request) => {
+            if (this.debug || this.e2e)
+                return request;
+            request.headers = (0, pick_1.default)(request.headers, [
+                'connection',
+                'host',
+                'origin',
+                'x-real-ip',
+                'x-forwarded-for',
+                'x-forwarded-proto',
+                'x-forwarded-host',
+                'x-forwarded-port',
+                'x-scheme',
+                'user-agent',
+                'content-type',
+                'accept',
+                'referer',
+                'accept-encoding',
+                'ssl-client-subject-dn',
+            ]);
+            return request;
+        };
+        this.responseSerializer = (response) => {
+            if (this.debug)
+                return response;
+            response.headers = (0, pick_1.default)(response.headers, [
+                'content-type',
+                'content-length',
+            ]);
+            return response;
+        };
+        this.errorSerializer = (error) => {
+            if (error?.parameters)
+                error.parameters = undefined;
+            if (error?.parent?.parameters)
+                error.parent.parameters = undefined;
+            if (error?.original?.parameters)
+                error.original.parameters = undefined;
+            return error;
+        };
+        this.customMessage = (response) => {
+            const { req: { method, originalUrl }, statusCode, } = response;
+            return `${statusCode} ${method} ${originalUrl}`;
+        };
+        this.debug = !!debug;
+        this.e2e = !!e2e;
+        this.defaultHttpLogLevel = defaultHttpLogLevel || 'info';
+    }
+}

package/dist/lib/logger/utils.d.ts

@@ -0,0 +1,9 @@
+import { Service } from '../serviceIdentity';
+import { Level } from 'pino';
+export interface HttpLoggerCreationOptions {
+    logLevel: string;
+    defaultHttpLogLevel: Level;
+    service: Service;
+    debug: boolean;
+    e2e: boolean;
+}

package/dist/lib/logger/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/serviceIdentity/environment.d.ts

@@ -1,19 +1,19 @@
 declare enum Environment {
-    LOCAL = "LOCAL",
-    DEV = "DEV",
-    QS = "QS",
-    AQS = "AQS",
-    RELEASE = "RELEASE",
-    HOTFIX = "HOTFIX",
-    PENTEST = "PENTEST",
-    P1 = "P1",
-    P2 = "P2",
-    P3 = "P3",
-    P4 = "P4",
-    P5 = "P5",
-    P6 = "P6",
-    DEMO = "DEMO",
-    PREPROD = "PREPROD",
-    PROD = "PROD"
+    LOCAL = "local",
+    DEV = "dev",
+    QS = "qs",
+    AQS = "aqs",
+    RELEASE = "release",
+    HOTFIX = "hotfix",
+    PENTEST = "pentest",
+    P1 = "p1",
+    P2 = "p2",
+    P3 = "p3",
+    P4 = "p4",
+    P5 = "p5",
+    P6 = "p6",
+    DEMO = "demo",
+    PREPROD = "preprod",
+    PROD = "prod"
 }
 export { Environment };

package/dist/lib/serviceIdentity/environment.js

@@ -3,21 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Environment = void 0;
 var Environment;
 (function (Environment) {
-    Environment["LOCAL"] = "LOCAL";
-    Environment["DEV"] = "DEV";
-    Environment["QS"] = "QS";
-    Environment["AQS"] = "AQS";
-    Environment["RELEASE"] = "RELEASE";
-    Environment["HOTFIX"] = "HOTFIX";
-    Environment["PENTEST"] = "PENTEST";
-    Environment["P1"] = "P1";
-    Environment["P2"] = "P2";
-    Environment["P3"] = "P3";
-    Environment["P4"] = "P4";
-    Environment["P5"] = "P5";
-    Environment["P6"] = "P6";
-    Environment["DEMO"] = "DEMO";
-    Environment["PREPROD"] = "PREPROD";
-    Environment["PROD"] = "PROD";
+    Environment["LOCAL"] = "local";
+    Environment["DEV"] = "dev";
+    Environment["QS"] = "qs";
+    Environment["AQS"] = "aqs";
+    Environment["RELEASE"] = "release";
+    Environment["HOTFIX"] = "hotfix";
+    Environment["PENTEST"] = "pentest";
+    Environment["P1"] = "p1";
+    Environment["P2"] = "p2";
+    Environment["P3"] = "p3";
+    Environment["P4"] = "p4";
+    Environment["P5"] = "p5";
+    Environment["P6"] = "p6";
+    Environment["DEMO"] = "demo";
+    Environment["PREPROD"] = "preprod";
+    Environment["PROD"] = "prod";
 })(Environment || (Environment = {}));
 exports.Environment = Environment;

package/dist/lib/serviceIdentity/service.d.ts

@@ -2,6 +2,8 @@ declare enum Service {
     BACKEND = "backend",
     BACKEND_PAY = "backend-pay",
     BACKEND_POS = "backend-pos",
+    BACKEND_ID = "backend-id",
+    BACKEND_ATTESTATION = "backend-attestation",
     BACKEND_PUBSUB = "backend-pubsub"
 }
 export { Service };

package/dist/lib/serviceIdentity/service.js

@@ -6,6 +6,8 @@ var Service;
     Service["BACKEND"] = "backend";
     Service["BACKEND_PAY"] = "backend-pay";
     Service["BACKEND_POS"] = "backend-pos";
+    Service["BACKEND_ID"] = "backend-id";
+    Service["BACKEND_ATTESTATION"] = "backend-attestation";
     Service["BACKEND_PUBSUB"] = "backend-pubsub";
 })(Service || (Service = {}));
 exports.Service = Service;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -20,6 +20,7 @@
   "devDependencies": {
     "@types/express": "4.17.13",
     "@types/jest": "^28.1.5",
+    "@types/lodash": "^4.14.187",
     "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^5.30.6",
     "@typescript-eslint/parser": "^5.30.6",
@@ -31,7 +32,6 @@
     "semantic-release": "^19.0.3",
     "semantic-release-monorepo": "^7.0.5",
     "ts-jest": "^28.0.5",
-    "pino": "^8.6.1",
     "typescript": "^4.7.4"
   },
   "dependencies": {
@@ -40,7 +40,9 @@
     "axios": "^0.27.2",
     "jose": "4.9.2",
     "kafkajs": "2.1.0",
+    "lodash": "^4.17.21",
     "moment": "^2.29.4",
+    "pino-http": "6.6.0",
     "prom-client": "14.1.0",
     "uuid": "^9.0.0"
   }