sm-utility 2.4.30 → 2.4.32

package/excel/excel-creator/excelCreator.js

@@ -10,14 +10,14 @@ const logger_1 = require("../../logger");
 class ExcelCreator {
     create(sheets) {
         try {
-            logger_1.logger.info("ExcelCreator initiated", { context: sheets });
+            logger_1.logger.info("ExcelCreator initiated", { context: { sheets_count: sheets.length } });
             const builderSheets = sheets.map((sheet) => new sheetExcelCreator_1.SheetExcelCreator().create(sheet));
             const buffer = node_xlsx_1.default.build(builderSheets);
-            logger_1.logger.info("ExcelCreator finished", { context: sheets });
+            logger_1.logger.info("ExcelCreator finished", { context: { sheets_count: sheets.length } });
             return buffer;
         }
         catch (error) {
-            logger_1.logger.error("ExcelCreator failed", { context: sheets, error });
+            logger_1.logger.error("ExcelCreator failed", { context: { sheets_count: sheets.length }, error });
             throw error;
         }
     }

package/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./thread"), exports);
 __exportStar(require("./excel"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./tracing"), exports);
+__exportStar(require("./profiler"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-utility",
-  "version": "2.4.30",
+  "version": "2.4.32",
   "description": "reusable utility codes for sm projects",
   "main": "index.js",
   "types": "./index.d.ts",

package/profiler/index.d.ts

@@ -0,0 +1,3 @@
+export { Profiler } from "./profiler";
+export { ProfilingPathBuilder, ProfilingType, } from "./profilingPath.builder";
+export { IFileUploader, ProfilingSignalsManager, } from "./profilingSignalsManager";

package/profiler/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilingSignalsManager = exports.ProfilingType = exports.ProfilingPathBuilder = exports.Profiler = void 0;
+var profiler_1 = require("./profiler");
+Object.defineProperty(exports, "Profiler", { enumerable: true, get: function () { return profiler_1.Profiler; } });
+var profilingPath_builder_1 = require("./profilingPath.builder");
+Object.defineProperty(exports, "ProfilingPathBuilder", { enumerable: true, get: function () { return profilingPath_builder_1.ProfilingPathBuilder; } });
+Object.defineProperty(exports, "ProfilingType", { enumerable: true, get: function () { return profilingPath_builder_1.ProfilingType; } });
+var profilingSignalsManager_1 = require("./profilingSignalsManager");
+Object.defineProperty(exports, "ProfilingSignalsManager", { enumerable: true, get: function () { return profilingSignalsManager_1.ProfilingSignalsManager; } });

package/profiler/profiler.d.ts

@@ -0,0 +1,15 @@
+import { Writable } from "stream";
+type Params = {
+    outputStream: Writable;
+};
+type ProfileParams = Params & {
+    /** duration in milliseconds for the profiling period */
+    duration?: number;
+};
+export declare class Profiler {
+    static takeHeapSnapshot({ outputStream, }: Params): Promise<void>;
+    static takeCpuProfile({ outputStream, duration, }: ProfileParams): Promise<void>;
+    static takeHeapProfile({ outputStream, duration, }: ProfileParams): Promise<void>;
+    private static post;
+}
+export {};

package/profiler/profiler.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Profiler = void 0;
+const inspector_1 = require("inspector");
+const logger_1 = require("../logger");
+class Profiler {
+    static async takeHeapSnapshot({ outputStream, }) {
+        const session = new inspector_1.Session();
+        session.connect();
+        try {
+            await this.post(session, "HeapProfiler.enable");
+            session.on("HeapProfiler.addHeapSnapshotChunk", (m) => {
+                outputStream.write(m.params.chunk);
+            });
+            await this.post(session, "HeapProfiler.takeHeapSnapshot");
+            await this.post(session, "HeapProfiler.disable");
+        }
+        catch (err) {
+            logger_1.logger.error(err);
+        }
+        finally {
+            session.disconnect();
+        }
+    }
+    static async takeCpuProfile({ outputStream, duration = 10000, }) {
+        const session = new inspector_1.Session();
+        session.connect();
+        try {
+            await this.post(session, "Profiler.enable");
+            await this.post(session, "Profiler.start");
+            await new Promise((resolve) => {
+                setTimeout(resolve, duration);
+            });
+            const { profile } = await this.post(session, "Profiler.stop");
+            outputStream.write(JSON.stringify(profile));
+        }
+        catch (err) {
+            logger_1.logger.error(err);
+        }
+        finally {
+            session.disconnect();
+        }
+    }
+    static async takeHeapProfile({ outputStream, duration = 10000, }) {
+        const session = new inspector_1.Session();
+        session.connect();
+        try {
+            await this.post(session, "HeapProfiler.enable");
+            await this.post(session, "HeapProfiler.startSampling");
+            await new Promise((resolve) => {
+                setTimeout(resolve, duration);
+            });
+            const { profile } = await this.post(session, "HeapProfiler.stopSampling");
+            outputStream.write(JSON.stringify(profile));
+            await this.post(session, "HeapProfiler.disable");
+        }
+        catch (err) {
+            logger_1.logger.error(err);
+        }
+        finally {
+            session.disconnect();
+        }
+    }
+    static post(session, method, params) {
+        return new Promise((resolve, reject) => {
+            session.post(method, params || {}, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+    }
+}
+exports.Profiler = Profiler;

package/profiler/profilingPath.builder.d.ts

@@ -0,0 +1,27 @@
+export declare enum ProfilingType {
+    HEAP_SNAPSHOT = "HEAP_SNAPSHOT",
+    HEAP_PROFILE = "HEAP_PROFILE",
+    CPU_PROFILE = "CPU_PROFILE"
+}
+export declare class ProfilingPathBuilder {
+    /**
+     * Build the filename with the format:
+     * YYYY-MM-DD_HH-MM-SS_{env}_{serviceName}_{profileType}.{extension}
+     */
+    static buildFileName({ type, serviceName, env, timestamp, }: {
+        type: ProfilingType;
+        serviceName: string;
+        env: string;
+        timestamp?: Date;
+    }): string;
+    /**
+     * Build the S3 key based on the structure:
+     * {env}/{serviceName}/{profileType-folder}/{filename}
+     */
+    static buildS3Key({ env, serviceName, type, fileName, }: {
+        env: string;
+        serviceName: string;
+        type: ProfilingType;
+        fileName: string;
+    }): string;
+}

package/profiler/profilingPath.builder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilingPathBuilder = exports.ProfilingType = void 0;
+var ProfilingType;
+(function (ProfilingType) {
+    ProfilingType["HEAP_SNAPSHOT"] = "HEAP_SNAPSHOT";
+    ProfilingType["HEAP_PROFILE"] = "HEAP_PROFILE";
+    ProfilingType["CPU_PROFILE"] = "CPU_PROFILE";
+})(ProfilingType || (exports.ProfilingType = ProfilingType = {}));
+const FileExtension = {
+    HEAP_SNAPSHOT: "heapsnapshot",
+    HEAP_PROFILE: "heapprofile",
+    CPU_PROFILE: "cpuprofile",
+};
+class ProfilingPathBuilder {
+    /**
+     * Build the filename with the format:
+     * YYYY-MM-DD_HH-MM-SS_{env}_{serviceName}_{profileType}.{extension}
+     */
+    static buildFileName({ type, serviceName, env, timestamp = new Date(), }) {
+        const ext = FileExtension[type];
+        const formattedDate = timestamp
+            .toISOString()
+            .replace("T", "_")
+            .replace(/:/g, "-")
+            .replace(/\..+/, "");
+        return `${formattedDate}_${env}_${serviceName}.${ext}`;
+    }
+    /**
+     * Build the S3 key based on the structure:
+     * {env}/{serviceName}/{profileType-folder}/{filename}
+     */
+    static buildS3Key({ env, serviceName, type, fileName, }) {
+        return `${env}/${serviceName}/${FileExtension[type]}/${fileName}`;
+    }
+}
+exports.ProfilingPathBuilder = ProfilingPathBuilder;

package/profiler/profilingSignalsManager.d.ts

@@ -0,0 +1,51 @@
+type Options = {
+    /**
+     * If true, the heap snapshot will be taken when the SIGUSR1 signal is received.
+     */
+    heapSnapshot?: boolean;
+    /**
+     * If true, the sampling profiles for CPU and Heap will be taken when the SIGUSR2 signal is received.
+     * To configure the sampling profiles, the configured instructions file must be created with the following format:
+     * ```
+     * cpu;15000
+     * heap;15000
+     * ```
+     * The format is `mode;duration` where `mode` is `cpu` or `heap` and `duration` is the duration in milliseconds.
+     */
+    samplingProfiles?: boolean;
+};
+type ProfilingLogger = {
+    info(message: unknown, ...meta: unknown[]): void;
+    error(message: unknown, ...meta: unknown[]): void;
+};
+export interface IFileUploader {
+    uploadFile(destBucket: string, destKey: string, body: Buffer, contentType?: string): Promise<string | void>;
+}
+type ProfilingSignalsManagerParams = {
+    serviceName: string;
+    environment: string;
+    fileUploader?: IFileUploader;
+    bucket?: string;
+    profilingInstructionsPath?: string;
+    outputDirectory?: string;
+    shouldUpload?: () => boolean;
+    logger?: ProfilingLogger;
+};
+export declare class ProfilingSignalsManager {
+    private readonly params;
+    private readonly bucket;
+    private readonly profilingInstructionsPath;
+    private readonly outputDirectory;
+    private readonly shouldUpload;
+    private readonly logger;
+    constructor(params: ProfilingSignalsManagerParams);
+    registerHandlers(options: Options): void;
+    private registerHeapSnapshotSignalListener;
+    private handleHeapSnapshot;
+    private registerSamplingProfilesSignalListener;
+    private handleHeapProfiling;
+    private handleCpuProfiling;
+    private handleProfileOutput;
+    private removeFile;
+}
+export {};

package/profiler/profilingSignalsManager.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilingSignalsManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const profiler_1 = require("./profiler");
+const profilingPath_builder_1 = require("./profilingPath.builder");
+class ProfilingSignalsManager {
+    constructor(params) {
+        this.params = params;
+        this.bucket = params.bucket || "smartrips-profiling";
+        this.profilingInstructionsPath =
+            params.profilingInstructionsPath || "/tmp/profiling";
+        this.outputDirectory = params.outputDirectory || process.cwd();
+        this.shouldUpload =
+            params.shouldUpload || (() => process.env.NODE_ENV !== "dev");
+        this.logger = params.logger || logger_1.logger;
+    }
+    registerHandlers(options) {
+        if (options.heapSnapshot) {
+            this.registerHeapSnapshotSignalListener();
+        }
+        if (options.samplingProfiles) {
+            this.registerSamplingProfilesSignalListener();
+        }
+    }
+    registerHeapSnapshotSignalListener() {
+        process.on("SIGUSR1", () => {
+            try {
+                this.handleHeapSnapshot();
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        });
+    }
+    handleHeapSnapshot() {
+        this.logger.info("Heap snapshot signal received");
+        const fileName = profilingPath_builder_1.ProfilingPathBuilder.buildFileName({
+            type: profilingPath_builder_1.ProfilingType.HEAP_SNAPSHOT,
+            serviceName: this.params.serviceName,
+            env: this.params.environment,
+        });
+        const filePath = path_1.default.resolve(this.outputDirectory, fileName);
+        const writeStream = fs_1.default.createWriteStream(filePath);
+        writeStream.on("finish", async () => {
+            await this.handleProfileOutput({
+                filePath,
+                fileName,
+                type: profilingPath_builder_1.ProfilingType.HEAP_SNAPSHOT,
+                contentType: "application/octet-stream",
+                profileName: "Heap snapshot",
+            });
+        });
+        profiler_1.Profiler.takeHeapSnapshot({ outputStream: writeStream })
+            .then(() => writeStream.end())
+            .catch((err) => this.logger.error(err));
+    }
+    registerSamplingProfilesSignalListener() {
+        process.on("SIGUSR2", () => {
+            try {
+                const samplingInstructions = fs_1.default
+                    .readFileSync(this.profilingInstructionsPath, "utf-8")
+                    .trim();
+                const [mode, duration] = samplingInstructions.split(";");
+                const durationInMs = Number(duration);
+                if (!mode || Number.isNaN(durationInMs)) {
+                    this.logger.error("Invalid sampling instructions. Use format cpu;15000");
+                    return;
+                }
+                if (mode === "cpu") {
+                    this.handleCpuProfiling({ duration: durationInMs });
+                }
+                else if (mode === "heap") {
+                    this.handleHeapProfiling({ duration: durationInMs });
+                }
+                else {
+                    this.logger.error("Unsupported mode. Use cpu or heap.");
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        });
+    }
+    handleHeapProfiling({ duration }) {
+        this.logger.info(`Heap profile signal received for ${duration}ms`);
+        const fileName = profilingPath_builder_1.ProfilingPathBuilder.buildFileName({
+            type: profilingPath_builder_1.ProfilingType.HEAP_PROFILE,
+            serviceName: this.params.serviceName,
+            env: this.params.environment,
+        });
+        const filePath = path_1.default.resolve(this.outputDirectory, fileName);
+        const writeStream = fs_1.default.createWriteStream(filePath);
+        writeStream.on("finish", async () => {
+            await this.handleProfileOutput({
+                filePath,
+                fileName,
+                type: profilingPath_builder_1.ProfilingType.HEAP_PROFILE,
+                profileName: "Heap profile",
+            });
+        });
+        profiler_1.Profiler.takeHeapProfile({ outputStream: writeStream, duration })
+            .then(() => writeStream.end())
+            .catch((err) => this.logger.error(err));
+    }
+    handleCpuProfiling({ duration }) {
+        this.logger.info(`CPU profile signal received for ${duration}ms`);
+        const type = profilingPath_builder_1.ProfilingType.CPU_PROFILE;
+        const fileName = profilingPath_builder_1.ProfilingPathBuilder.buildFileName({
+            type,
+            serviceName: this.params.serviceName,
+            env: this.params.environment,
+        });
+        const filePath = path_1.default.resolve(this.outputDirectory, fileName);
+        const writeStream = fs_1.default.createWriteStream(filePath);
+        writeStream.on("finish", async () => {
+            await this.handleProfileOutput({
+                filePath,
+                fileName,
+                type,
+                profileName: "CPU profile",
+            });
+        });
+        profiler_1.Profiler.takeCpuProfile({ outputStream: writeStream, duration })
+            .then(() => writeStream.end())
+            .catch((err) => this.logger.error(err));
+    }
+    async handleProfileOutput({ filePath, fileName, type, contentType, profileName, }) {
+        try {
+            if (this.shouldUpload()) {
+                const s3Key = profilingPath_builder_1.ProfilingPathBuilder.buildS3Key({
+                    fileName,
+                    type,
+                    serviceName: this.params.serviceName,
+                    env: this.params.environment,
+                });
+                if (!this.params.fileUploader) {
+                    throw new Error("Profiling fileUploader is required.");
+                }
+                const uploadedTo = await this.params.fileUploader.uploadFile(this.bucket, s3Key, fs_1.default.readFileSync(filePath), contentType);
+                this.logger.info(`${profileName} saved to ${uploadedTo || s3Key}`);
+                this.removeFile(filePath);
+            }
+            else {
+                this.logger.info(`${profileName} saved to ${filePath}`);
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+            this.removeFile(filePath);
+        }
+    }
+    removeFile(filePath) {
+        if (fs_1.default.existsSync(filePath)) {
+            fs_1.default.unlinkSync(filePath);
+        }
+    }
+}
+exports.ProfilingSignalsManager = ProfilingSignalsManager;