@abyss-project/console 1.0.1

package/dist/middlewares/context.middleware.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequestContext = exports.createRequestContext = exports.contextMiddleware = void 0;
+const uuid_1 = require("uuid");
+let asyncHooks;
+if (typeof window === 'undefined') {
+    asyncHooks = require('async_hooks');
+}
+const store = new Map();
+const asyncHook = asyncHooks === null || asyncHooks === void 0 ? void 0 : asyncHooks.createHook({
+    init: (asyncId, _, triggerAsyncId) => {
+        const existingEntry = store.get(triggerAsyncId);
+        if (existingEntry) {
+            store.set(asyncId, existingEntry);
+        }
+    },
+    destroy: (asyncId) => {
+        if (store.has(asyncId)) {
+            store.delete(asyncId);
+        }
+    },
+});
+asyncHook === null || asyncHook === void 0 ? void 0 : asyncHook.enable();
+const contextMiddleware = (req, res, next) => {
+    const data = { headers: req.headers };
+    (0, exports.createRequestContext)(data);
+    next();
+};
+exports.contextMiddleware = contextMiddleware;
+const createRequestContext = (data, requestId = (0, uuid_1.v4)()) => {
+    const requestInfo = { requestId, data };
+    store.set(asyncHooks === null || asyncHooks === void 0 ? void 0 : asyncHooks.executionAsyncId(), requestInfo);
+    return requestInfo;
+};
+exports.createRequestContext = createRequestContext;
+const getRequestContext = () => {
+    return store.get(asyncHooks === null || asyncHooks === void 0 ? void 0 : asyncHooks.executionAsyncId());
+};
+exports.getRequestContext = getRequestContext;

package/dist/middlewares/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context.middleware';
+export * from './logger-endpoint.middleware';
+export * from './logger-setup.middleware';

package/dist/middlewares/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context.middleware"), exports);
+__exportStar(require("./logger-endpoint.middleware"), exports);
+__exportStar(require("./logger-setup.middleware"), exports);

package/dist/middlewares/logger-endpoint.middleware.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from 'express-serve-static-core';
+import { Logger } from '../models';
+import { IMonitorLocals } from '../types';
+export declare const CONTROLLER_FILE_ENDS_WITH: string;
+export declare const loggerEndpointMiddleware: (logger: Logger, req: Request, res: Response<unknown, IMonitorLocals>, next: NextFunction, callback?: ((req: Request, res: Response<unknown, IMonitorLocals>, next: NextFunction) => Promise<void>) | undefined) => Promise<void>;

package/dist/middlewares/logger-endpoint.middleware.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerEndpointMiddleware = exports.CONTROLLER_FILE_ENDS_WITH = void 0;
+const lodash_1 = require("lodash");
+const context_middleware_1 = require("./context.middleware");
+const types_1 = require("../types");
+const net_1 = __importDefault(require("net"));
+const import_utils_1 = require("../utils/import.utils");
+exports.CONTROLLER_FILE_ENDS_WITH = `.controller${(0, import_utils_1.extensionFileToImport)()}`;
+const loggerEndpointMiddleware = async (logger, req, res, next, callback) => {
+    res.locals.timer = {
+        start: new Date(),
+        startTime: process.hrtime(),
+    };
+    const requestId = (0, context_middleware_1.getRequestContext)().requestId;
+    res.on('close', async () => {
+        var _a;
+        try {
+            res.locals.timer.durationToClose = getDurationInMilliseconds(res.locals.timer.startTime);
+            if (!res.locals.shouldNotPublishLog) {
+                const ips = [];
+                const forwardedFor = req.headers['x-forwarded-for'];
+                if (forwardedFor) {
+                    if (Array.isArray(forwardedFor)) {
+                        ips.push(...forwardedFor);
+                    }
+                    else {
+                        ips.push(forwardedFor);
+                    }
+                }
+                if (req.socket.remoteAddress) {
+                    ips.push(req.socket.remoteAddress);
+                }
+                if (req.ip) {
+                    ips.push(req.ip);
+                }
+                await logger.log('', {
+                    requestId,
+                    context: 'API',
+                    applicationLogEndpoint: {
+                        responseHttpCode: res.statusCode,
+                        responseTime: Math.round(res.locals.timer.durationToClose),
+                        ip: (0, lodash_1.uniq)(ips).filter(net_1.default.isIP),
+                        endpoint: res.locals.path || ((_a = req.route) === null || _a === void 0 ? void 0 : _a.path) || req.path,
+                        controller: res.locals.controller || 'Unknown Controller',
+                        method: types_1.APIMethod[req.method.toUpperCase()],
+                        requestParams: req.params,
+                        requestQuery: req.query,
+                        requestBody: res.locals.shouldNotSaveRequestBody
+                            ? null
+                            : req.body
+                                ? JSON.parse(JSON.stringify(req.body))
+                                : null,
+                        responseBody: res.locals.shouldNotSaveResponseBody
+                            ? null
+                            : res.locals.responseBody
+                                ? JSON.parse(JSON.stringify(res.locals.responseBody))
+                                : null,
+                    },
+                });
+            }
+            try {
+                if (callback) {
+                    await callback(req, res, next);
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    });
+    next();
+};
+exports.loggerEndpointMiddleware = loggerEndpointMiddleware;
+const getDurationInMilliseconds = (start) => {
+    const NS_PER_SEC = 1e9;
+    const NS_TO_MS = 1e6;
+    const diff = process.hrtime(start);
+    return (diff[0] * NS_PER_SEC + diff[1]) / NS_TO_MS;
+};

package/dist/middlewares/logger-setup.middleware.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from 'express-serve-static-core';
+export declare const loggerSetupMiddleware: (req: Request, res: Response<any, {
+    controller: string;
+    responseBody?: unknown;
+}>, next: NextFunction) => Promise<void>;

package/dist/middlewares/logger-setup.middleware.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerSetupMiddleware = void 0;
+const loggerSetupMiddleware = async (req, res, next) => {
+    const originalJson = res.json;
+    const originalSend = res.send;
+    res.send = function (...args) {
+        return originalSend.apply(res, args);
+    };
+    res.json = function (...args) {
+        res.locals.responseBody = args[0];
+        return originalJson.apply(res, args);
+    };
+    next();
+};
+exports.loggerSetupMiddleware = loggerSetupMiddleware;

package/dist/models/index.d.ts

@@ -0,0 +1 @@
+export * from './logger.model';

package/dist/models/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./logger.model"), exports);

package/dist/models/logger.model.d.ts

@@ -0,0 +1,61 @@
+import { APIMethod, ICreateApplicationLogBody, LogLevel } from '../types';
+export type LogData = ICreateApplicationLogBody;
+export type PayloadLog = {
+    context?: string | null;
+    scenario?: string | null;
+    requestId?: string | null;
+    data?: Record<string, unknown> | null;
+    applicationLogEndpoint?: {
+        controller: string;
+        endpoint: string;
+        ip: string[];
+        method: APIMethod;
+        responseTime: number;
+        responseHttpCode: number;
+        requestParams?: Record<string, string> | null;
+        requestQuery?: Record<string, string | string[]> | null;
+        requestBody?: Record<string, unknown> | string | null;
+        responseBody?: Record<string, unknown> | string | null;
+    };
+    applicationEvent?: {
+        event: string;
+        level: LogLevel;
+        message?: string | null;
+        data?: Record<string, unknown> | null;
+    };
+};
+type Options = {
+    shouldSaveStack?: boolean;
+    customerConsoleLogger?: (data: LogData) => void;
+    compact?: boolean;
+};
+export type PayloadSendLog = PayloadLog & {
+    level: LogLevel;
+    message: string;
+    stack?: string;
+};
+type PayloadConstructor = {
+    shouldDisableConsoleLogging?: boolean;
+    shouldDisableConsoleResponseBodyLogging?: boolean;
+    shouldDisableRemoteLogging?: boolean;
+    customConsoleLogger?: (data: LogData) => void;
+    customPublishLog?: (payload: LogData, options?: Options) => Promise<void>;
+    processId?: string;
+};
+export declare class Logger {
+    private shouldDisableConsoleLogging;
+    private shouldDisableRemoteLogging;
+    private shouldDisableConsoleResponseBodyLogging;
+    private customConsoleLogger?;
+    private customPublishLog?;
+    private processId;
+    constructor(payload: PayloadConstructor);
+    log(message: string, payload?: PayloadLog, options?: Options): Promise<void>;
+    debug(message: string, payload?: PayloadLog, options?: Omit<Options, 'shouldSaveStack'>): Promise<void>;
+    error(message: string | Error, payload?: PayloadLog, options?: Options): Promise<void>;
+    info(message: string, payload?: PayloadLog, options?: Options): Promise<void>;
+    warn(message: string, payload?: PayloadLog, options?: Options): Promise<void>;
+    private publishLog;
+    private console;
+}
+export {};

package/dist/models/logger.model.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const api_1 = require("../api");
+const types_1 = require("../types");
+const dayjs_1 = __importDefault(require("dayjs"));
+const __1 = require("..");
+const lodash_1 = require("lodash");
+const alert_utils_1 = require("../utils/alert.utils");
+const MAXIMUM_BODY_SIZE = 1024 * 1024 * 1024;
+const MAXIMUM_FIELD_LENGTH = 255;
+let chalk;
+if (typeof window === 'undefined') {
+    chalk = require('chalk');
+}
+const INFO_LEVEL = {
+    ERROR: chalk === null || chalk === void 0 ? void 0 : chalk.red('ERROR'),
+    WARN: chalk === null || chalk === void 0 ? void 0 : chalk.bgYellow.black('WARN'),
+    INFO: chalk === null || chalk === void 0 ? void 0 : chalk.blueBright('INFO'),
+    DEBUG: chalk === null || chalk === void 0 ? void 0 : chalk.grey('DEBUG'),
+    LOG: chalk === null || chalk === void 0 ? void 0 : chalk.grey('LOG'),
+};
+class Logger {
+    constructor(payload) {
+        this.shouldDisableRemoteLogging = payload.shouldDisableRemoteLogging || false;
+        this.shouldDisableConsoleLogging = payload.shouldDisableConsoleLogging || false;
+        this.shouldDisableConsoleResponseBodyLogging =
+            payload.shouldDisableConsoleResponseBodyLogging || false;
+        this.processId = payload.processId || process.pid.toString();
+        this.customConsoleLogger = payload.customConsoleLogger;
+        this.customPublishLog = payload.customPublishLog;
+    }
+    async log(message, payload = {}, options) {
+        this.publishLog({ ...payload, message, level: types_1.LogLevel.LOG }, options);
+    }
+    async debug(message, payload = {}, options) {
+        this.publishLog({ ...payload, message, stack: new Error().stack, level: types_1.LogLevel.LOG }, options);
+    }
+    async error(message, payload = {}, options) {
+        if (message instanceof Error) {
+            this.publishLog({
+                ...payload,
+                message: `${message.name} ${message.message}`,
+                stack: message.stack,
+                level: types_1.LogLevel.ERROR,
+                data: {
+                    ...payload.data,
+                    errorName: message.name,
+                },
+            }, options);
+        }
+        else {
+            this.publishLog({ ...payload, message, level: types_1.LogLevel.ERROR }, options);
+        }
+    }
+    async info(message, payload = {}, options) {
+        this.publishLog({ ...payload, message, level: types_1.LogLevel.INFO }, options);
+    }
+    async warn(message, payload = {}, options) {
+        this.publishLog({ ...payload, message, level: types_1.LogLevel.WARN }, options);
+    }
+    async publishLog(payload, options) {
+        var _a, _b;
+        const log = {
+            ...payload,
+            dateValue: new Date(),
+            processId: this.processId,
+        };
+        try {
+            this.console(log, options === null || options === void 0 ? void 0 : options.customerConsoleLogger);
+            if (this.customPublishLog) {
+                await this.customPublishLog(log, options);
+            }
+            else {
+                const { applicationId, secretPublishToken } = __1.AbyssMonitorCore.getConfig();
+                if (!this.shouldDisableRemoteLogging && applicationId && secretPublishToken) {
+                    const size = Buffer.byteLength(JSON.stringify(log));
+                    const body = log;
+                    let isBodyTruncated = false;
+                    if (size >= MAXIMUM_BODY_SIZE) {
+                        isBodyTruncated = true;
+                        if ((_a = body.applicationLogEndpoint) === null || _a === void 0 ? void 0 : _a.requestBody) {
+                            body.applicationLogEndpoint.requestBody = 'Payload Too Large';
+                        }
+                        if ((_b = body.applicationLogEndpoint) === null || _b === void 0 ? void 0 : _b.responseBody) {
+                            body.applicationLogEndpoint.responseBody = 'Payload Too Large';
+                        }
+                    }
+                    const newSize = Buffer.byteLength(JSON.stringify(body));
+                    if (newSize >= MAXIMUM_BODY_SIZE) {
+                        this.warn(`Unable to save log because payload is too big (more than 1Mo even after removing responseBody and requestBody)`, {
+                            requestId: body.requestId
+                                ? (0, lodash_1.truncate)(body.requestId, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                            context: body.context
+                                ? (0, lodash_1.truncate)(body.context, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                            scenario: body.scenario
+                                ? (0, lodash_1.truncate)(body.scenario, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                        });
+                        return;
+                    }
+                    const applicationLog = await (0, api_1.createApplicationLog)({ applicationId }, { token: secretPublishToken }, body);
+                    (0, __1.nonBlockingPromise)((async () => {
+                        (0, alert_utils_1.sendLogAlert)({
+                            ...payload,
+                            logData: log,
+                            logger: this,
+                            applicationLogId: applicationLog.data.applicationLog.id || '',
+                            compact: options === null || options === void 0 ? void 0 : options.compact,
+                        });
+                    })(), this);
+                    if (isBodyTruncated) {
+                        this.warn(`Endpoint log ${applicationLog.data.applicationLog.id} has been truncated (requestBody & responseBody) because payload was too big (more than 1Mo)`, {
+                            requestId: body.requestId
+                                ? (0, lodash_1.truncate)(body.requestId, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                            context: body.context
+                                ? (0, lodash_1.truncate)(body.context, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                            scenario: body.scenario
+                                ? (0, lodash_1.truncate)(body.scenario, { length: MAXIMUM_FIELD_LENGTH })
+                                : undefined,
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Unable to publish log. Error: ${error}`);
+            (0, alert_utils_1.sendLogAlert)({
+                ...payload,
+                logData: log,
+                logger: this,
+                author: 'AbyssMonitor Logger',
+            });
+        }
+    }
+    console(data, customConsoleLogger) {
+        if (this.shouldDisableConsoleLogging) {
+            return;
+        }
+        if (customConsoleLogger) {
+            customConsoleLogger(data);
+        }
+        else if (this.customConsoleLogger) {
+            this.customConsoleLogger(data);
+        }
+        else if (data.applicationLogEndpoint) {
+            let message = `${chalk.grey((0, dayjs_1.default)().format('DD/MM/YYYY HH:mm:ss'))} | ${chalk.bgBlueBright(' API ')} | `;
+            message += `${chalk.grey(data.requestId)} | ${chalk.greenBright(types_1.APIMethod[data.applicationLogEndpoint.method])} | ${data.applicationLogEndpoint.controller} ${data.applicationLogEndpoint.endpoint} | `;
+            if (data.applicationLogEndpoint.responseHttpCode >= 100 &&
+                data.applicationLogEndpoint.responseHttpCode <= 199) {
+                message += `${chalk.blue(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            else if (data.applicationLogEndpoint.responseHttpCode >= 200 &&
+                data.applicationLogEndpoint.responseHttpCode <= 299) {
+                message += `${chalk.green(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            else if (data.applicationLogEndpoint.responseHttpCode >= 300 &&
+                data.applicationLogEndpoint.responseHttpCode <= 399) {
+                message += `${chalk.magenta(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            else if (data.applicationLogEndpoint.responseHttpCode >= 400 &&
+                data.applicationLogEndpoint.responseHttpCode <= 499) {
+                message += `${chalk.yellow(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            else if (data.applicationLogEndpoint.responseHttpCode >= 500 &&
+                data.applicationLogEndpoint.responseHttpCode <= 599) {
+                message += `${chalk.red(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            else {
+                message += `${chalk.bgCyanBright.black(data.applicationLogEndpoint.responseHttpCode)}`;
+            }
+            if (data.applicationLogEndpoint.responseTime < 50) {
+                message += ` | ${chalk.greenBright(data.applicationLogEndpoint.responseTime, 'ms')}  | `;
+            }
+            else if (data.applicationLogEndpoint.responseTime < 150) {
+                message += ` | ${chalk.yellow(data.applicationLogEndpoint.responseTime, 'ms')} | `;
+            }
+            else {
+                message += ` | ${chalk.red(data.applicationLogEndpoint.responseTime, 'ms')} | `;
+            }
+            message += `${(data.applicationLogEndpoint.ip || []).join(' ')} | `;
+            if (!this.shouldDisableConsoleResponseBodyLogging &&
+                (data.applicationLogEndpoint.responseHttpCode < 200 ||
+                    data.applicationLogEndpoint.responseHttpCode > 399)) {
+                message += `${JSON.stringify(data.applicationLogEndpoint.responseBody)}`;
+            }
+            console.log(message);
+        }
+        else {
+            console.log(`${chalk.grey((0, dayjs_1.default)().format('DD/MM/YYYY HH:mm:ss'))} | ${INFO_LEVEL[types_1.LogLevel[data.level]]} | ${data.processId}${data.requestId ? ` | ${data.requestId}` : ''}${data.context ? ` | ${data.context}` : ''} | ${data.message || data.stack} `);
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/models/stats-publisher.model.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { Logger, ApplicationStatsType } from '..';
+type StartOptions = {
+    interval?: number;
+    customCallback?: (values: {
+        type: ApplicationStatsType;
+        dateValue: Date;
+        processId: string;
+        value: number;
+        percentValue: number;
+    }[]) => Promise<void>;
+    logger?: Logger;
+    processId?: string;
+};
+export declare class StatsPublisher {
+    static interval: NodeJS.Timeout | null;
+    static start(options?: StartOptions): void;
+    static stop(): void;
+}
+export {};

package/dist/models/stats-publisher.model.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsPublisher = void 0;
+const axios_1 = require("axios");
+const __1 = require("..");
+const node_os_utils_1 = __importDefault(require("node-os-utils"));
+const INTERVAL_BETWEEN_STATS_PUBLISH = 30000;
+class StatsPublisher {
+    static start(options) {
+        if (typeof window !== 'undefined') {
+            return;
+        }
+        const si = require('systeminformation');
+        const checkDiskSpace = require('check-disk-space').default;
+        const interval = setInterval(async () => {
+            var _a, _b, _c, _d, _e;
+            try {
+                const devices = await si.blockDevices();
+                const dateValue = new Date();
+                const [cpuUsage, cpuSpeed, cpu, { usedMemMb, totalMemMb }, ...devicesSpace] = await Promise.all([
+                    node_os_utils_1.default.cpu.usage(),
+                    si.cpuCurrentSpeed(),
+                    si.cpu(),
+                    node_os_utils_1.default.mem.used(),
+                    ...devices.map((device) => checkDiskSpace(device.mount)),
+                ]);
+                const totalDisk = devicesSpace.reduce((acc, drive) => acc + drive.size, 0);
+                const totalDiskFree = devicesSpace.reduce((acc, drive) => acc + drive.free, 0);
+                const totalDiskUSage = totalDisk - totalDiskFree;
+                const totalDiskUSagePerCent = (totalDiskUSage / totalDisk) * 100 || 0;
+                const payload = {
+                    cpuUsage: (cpuSpeed.avg * (cpu.cores || 1) * 1000 * 1000 * 1000 * cpuUsage) / 100,
+                    cpuPercentUsage: cpuUsage,
+                    ramUsage: usedMemMb * 1024 * 1024,
+                    ramPercentUsage: ((usedMemMb * 1024 * 1024) / (totalMemMb * 1024 * 1024)) * 100,
+                    diskUsage: totalDiskUSage,
+                    diskPercentUsage: totalDiskUSagePerCent,
+                };
+                const stats = [
+                    {
+                        type: __1.ApplicationStatsType.CPU_USAGE,
+                        dateValue,
+                        value: payload.cpuUsage,
+                        percentValue: payload.cpuPercentUsage,
+                        processId: (options === null || options === void 0 ? void 0 : options.processId) || process.pid.toString(),
+                    },
+                    {
+                        type: __1.ApplicationStatsType.RAM_USAGE,
+                        dateValue,
+                        value: payload.ramUsage,
+                        percentValue: payload.ramPercentUsage,
+                        processId: (options === null || options === void 0 ? void 0 : options.processId) || process.pid.toString(),
+                    },
+                    {
+                        type: __1.ApplicationStatsType.DISK_USAGE,
+                        dateValue,
+                        value: payload.diskUsage,
+                        percentValue: payload.diskPercentUsage,
+                        processId: (options === null || options === void 0 ? void 0 : options.processId) || process.pid.toString(),
+                    },
+                ];
+                if (options === null || options === void 0 ? void 0 : options.customCallback) {
+                    await options.customCallback(stats);
+                }
+                else {
+                    const applicationId = __1.AbyssMonitorCore.getConfig().applicationId;
+                    const secretPublishToken = __1.AbyssMonitorCore.getConfig().secretPublishToken;
+                    if (!applicationId) {
+                        (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.warn(`No applicationId provided on AbyssMonitorCore. Skipping publish stats`);
+                        return;
+                    }
+                    if (!secretPublishToken) {
+                        (_b = options === null || options === void 0 ? void 0 : options.logger) === null || _b === void 0 ? void 0 : _b.warn(`No secretPublishToken provided on AbyssMonitorCore. Skipping publish stats`);
+                        return;
+                    }
+                    await (0, __1.createApplicationStats)({ applicationId }, { token: secretPublishToken }, { stats: stats });
+                    await (0, __1.sendStatsAlert)({
+                        ...payload,
+                        logger: options === null || options === void 0 ? void 0 : options.logger,
+                        statsData: {
+                            cpu: { percentValue: payload.cpuPercentUsage, value: payload.cpuUsage },
+                            ram: { percentValue: payload.ramPercentUsage, value: payload.ramUsage },
+                            disk: { percentValue: payload.diskPercentUsage, value: payload.diskUsage },
+                        },
+                        processId: (options === null || options === void 0 ? void 0 : options.processId) || process.pid.toString(),
+                        dateValue,
+                    });
+                }
+            }
+            catch (error) {
+                console.log(error);
+                (_c = options === null || options === void 0 ? void 0 : options.logger) === null || _c === void 0 ? void 0 : _c.error(`Failed to publish stats. Error ${error}`, { data: { error } });
+                if ((0, axios_1.isAxiosError)(error) && ((_d = error.response) === null || _d === void 0 ? void 0 : _d.status) === 401) {
+                    (_e = options === null || options === void 0 ? void 0 : options.logger) === null || _e === void 0 ? void 0 : _e.warn(`Unauthorized to publish stats, disabling stats publisher.`);
+                    this.stop();
+                }
+            }
+        }, (options === null || options === void 0 ? void 0 : options.interval) && (options === null || options === void 0 ? void 0 : options.interval) >= INTERVAL_BETWEEN_STATS_PUBLISH
+            ? options === null || options === void 0 ? void 0 : options.interval
+            : INTERVAL_BETWEEN_STATS_PUBLISH);
+        StatsPublisher.interval = interval;
+    }
+    static stop() {
+        if (StatsPublisher.interval) {
+            clearInterval(StatsPublisher.interval);
+        }
+        StatsPublisher.interval = null;
+    }
+}
+exports.StatsPublisher = StatsPublisher;

package/dist/types/dto/domain-verification.dto.d.ts

@@ -0,0 +1,19 @@
+import { VerificationMethod, VerificationStatus } from '../interface/models/domain-verification.model';
+export interface DomainVerificationResult {
+    success: boolean;
+    status: VerificationStatus;
+    method?: VerificationMethod;
+    message?: string;
+    error?: string;
+    verifiedAt?: Date;
+    details?: Record<string, any>;
+}
+export interface DnsVerificationResult extends DomainVerificationResult {
+    txtRecords?: string[];
+    foundToken?: boolean;
+}
+export interface HttpVerificationResult extends DomainVerificationResult {
+    fileContent?: string;
+    statusCode?: number;
+    redirectCount?: number;
+}

package/dist/types/dto/domain-verification.dto.js

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

package/dist/types/dto/index.d.ts

@@ -0,0 +1 @@
+export * from './domain-verification.dto';

package/dist/types/dto/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./domain-verification.dto"), exports);