@signageos/lib 23.8.1 → 23.8.2-master.4405

package/dist/Logging/format.js

@@ -0,0 +1,79 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatNestedErrors = void 0;
+var winston = __importStar(require("winston"));
+/**
+ * Recursively formats Error objects in the log data structure.
+ * Handles errors in direct properties, arrays, and nested objects.
+ * Includes protection against circular references.
+ *
+ * Without this step, the output of serialization of the Error object is an empty object.
+ * @see https://stackoverflow.com/questions/18391212/is-it-not-possible-to-stringify-an-error-using-json-stringify
+ */
+exports.formatNestedErrors = winston.format(function (info) {
+    var formatErrorsRecursively = function (obj, seen) {
+        if (seen === void 0) { seen = new WeakSet(); }
+        if (obj instanceof Error) {
+            return Object.assign({}, obj, {
+                message: obj.message,
+                stack: obj.stack,
+            });
+        }
+        if (Array.isArray(obj)) {
+            if (seen.has(obj)) {
+                return '[Circular]';
+            }
+            seen.add(obj);
+            var result = obj.map(function (item) { return formatErrorsRecursively(item, seen); });
+            seen.delete(obj);
+            return result;
+        }
+        if (obj !== null && typeof obj === 'object') {
+            // Handle Date objects specially - don't process them recursively
+            if (obj instanceof Date) {
+                return obj;
+            }
+            if (seen.has(obj)) {
+                return '[Circular]';
+            }
+            seen.add(obj);
+            var result = {};
+            for (var _i = 0, _a = Object.entries(obj); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], value = _b[1];
+                result[key] = formatErrorsRecursively(value, seen);
+            }
+            seen.delete(obj);
+            return result;
+        }
+        return obj;
+    };
+    for (var _i = 0, _a = Object.entries(info); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        info[key] = formatErrorsRecursively(value);
+    }
+    return info;
+});
+//# sourceMappingURL=format.js.map

package/dist/Logging/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/Logging/format.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAmC;AAEnC;;;;;;;GAOG;AACU,QAAA,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAC,IAAI;IACrD,IAAM,uBAAuB,GAAG,UAAC,GAAQ,EAAE,IAAoB;QAApB,qBAAA,EAAA,WAAW,OAAO,EAAE;QAC9D,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;YAC1B,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE;gBAC7B,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,KAAK,EAAE,GAAG,CAAC,KAAK;aAChB,CAAC,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnB,OAAO,YAAY,CAAC;YACrB,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,IAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,UAAC,IAAI,IAAK,OAAA,uBAAuB,CAAC,IAAI,EAAE,IAAI,CAAC,EAAnC,CAAmC,CAAC,CAAC;YACtE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjB,OAAO,MAAM,CAAC;QACf,CAAC;QAED,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC7C,iEAAiE;YACjE,IAAI,GAAG,YAAY,IAAI,EAAE,CAAC;gBACzB,OAAO,GAAG,CAAC;YACZ,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnB,OAAO,YAAY,CAAC;YACrB,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,IAAM,MAAM,GAAQ,EAAE,CAAC;YACvB,KAA2B,UAAmB,EAAnB,KAAA,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAnB,cAAmB,EAAnB,IAAmB,EAAE,CAAC;gBAAtC,IAAA,WAAY,EAAX,GAAG,QAAA,EAAE,KAAK,QAAA;gBACrB,MAAM,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YACpD,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjB,OAAO,MAAM,CAAC;QACf,CAAC;QAED,OAAO,GAAG,CAAC;IACZ,CAAC,CAAC;IAEF,KAA2B,UAAoB,EAApB,KAAA,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAApB,cAAoB,EAApB,IAAoB,EAAE,CAAC;QAAvC,IAAA,WAAY,EAAX,GAAG,QAAA,EAAE,KAAK,QAAA;QACrB,IAAI,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC,CAAC"}

package/dist/Logging/logger.d.ts

@@ -0,0 +1,53 @@
+import * as winston from 'winston';
+/** Central logger that aims to standardize how we work with logs across the applications.
+ *
+ * Goals:
+ *   - Provide single API for all logs
+ *   - Produce all logs in a standard format (most likely JSON) so that we can easily parse and analyze them with monitoring tools (i.e. Loki)
+ *   - Provide a way to namespace logs so that we can easily filter logs by a specific part of the application
+ */
+export interface ILogger {
+    error(message: string, meta?: object): ILogger;
+    warn(message: string, meta?: object): ILogger;
+    info(message: string, meta?: object): ILogger;
+    debug(message: string, meta?: object): ILogger;
+    /**
+     * Create a new logger instance that will include the provided namespace in metadata for all logs
+     *
+     * Can be nested to create a hierarchy of namespaces.
+     * For example:
+     *
+     *   ```typescript
+     *   const namespacedLogger = logger.createNamespace('myNamespace');
+     *   const subNamespacedLogger = namespacedLogger.createNamespace('subNamespace');
+     *   subNamespacedLogger.info('This log will include both "myNamespace" and "subNamespace" in the metadata');
+     *   ```
+     *
+     * Will produce a log with this included in the metadata:
+     *
+     *  ```json
+     *   {
+     *     "namespace": "myNamespace:subNamespace"
+     *   }
+     *   ```
+     */
+    createNamespace(namespace: string): ILogger;
+}
+export declare class WinstonLogger implements ILogger {
+    private logger;
+    private namespace?;
+    private settings;
+    constructor(logger: winston.Logger, namespace?: string | undefined);
+    error(message: string, meta?: object): ILogger;
+    warn(message: string, meta?: object): ILogger;
+    info(message: string, meta?: object): ILogger;
+    debug(message: string, meta?: object): ILogger;
+    createNamespace(namespace: string): ILogger;
+    setIgnoredLogNamespaces(ignoredLogNamespaces: string[]): void;
+    /**
+     * Log a message with the given level
+     *
+     * Logging can be disabled for specific namespaces by setting the `IGNORED_LOG_NAMESPACES` environment variable.
+     */
+    private log;
+}

package/dist/Logging/logger.js

@@ -0,0 +1,63 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinstonLogger = void 0;
+var WinstonLogger = /** @class */ (function () {
+    function WinstonLogger(logger, namespace) {
+        this.logger = logger;
+        this.namespace = namespace;
+        this.settings = {
+            ignoredLogNamespaces: [],
+        };
+        this.settings = {
+            ignoredLogNamespaces: typeof process.env.IGNORED_LOG_NAMESPACES !== 'undefined' ? process.env.IGNORED_LOG_NAMESPACES.split(',') : [],
+        };
+    }
+    WinstonLogger.prototype.error = function (message, meta) {
+        this.log('error', message, meta);
+        return this;
+    };
+    WinstonLogger.prototype.warn = function (message, meta) {
+        this.log('warn', message, meta);
+        return this;
+    };
+    WinstonLogger.prototype.info = function (message, meta) {
+        this.log('info', message, meta);
+        return this;
+    };
+    WinstonLogger.prototype.debug = function (message, meta) {
+        this.log('debug', message, meta);
+        return this;
+    };
+    WinstonLogger.prototype.createNamespace = function (namespace) {
+        var prefix = this.namespace ? "".concat(this.namespace, ":") : '';
+        return new WinstonLogger(this.logger, prefix + namespace);
+    };
+    WinstonLogger.prototype.setIgnoredLogNamespaces = function (ignoredLogNamespaces) {
+        this.settings.ignoredLogNamespaces = ignoredLogNamespaces;
+    };
+    /**
+     * Log a message with the given level
+     *
+     * Logging can be disabled for specific namespaces by setting the `IGNORED_LOG_NAMESPACES` environment variable.
+     */
+    WinstonLogger.prototype.log = function (level, message, meta) {
+        var ignoreLogs = typeof this.namespace !== 'undefined' && this.settings.ignoredLogNamespaces.includes(this.namespace);
+        if (!ignoreLogs) {
+            this.logger.log(level, message, __assign({ namespace: this.namespace }, meta));
+        }
+    };
+    return WinstonLogger;
+}());
+exports.WinstonLogger = WinstonLogger;
+//# sourceMappingURL=logger.js.map

package/dist/Logging/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/Logging/logger.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAsCA;IAKC,uBACS,MAAsB,EACtB,SAAkB;QADlB,WAAM,GAAN,MAAM,CAAgB;QACtB,cAAS,GAAT,SAAS,CAAS;QANnB,aAAQ,GAAuC;YACtD,oBAAoB,EAAE,EAAE;SACxB,CAAC;QAMD,IAAI,CAAC,QAAQ,GAAG;YACf,oBAAoB,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC,sBAAsB,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,sBAAsB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;SACpI,CAAC;IACH,CAAC;IAEM,6BAAK,GAAZ,UAAa,OAAe,EAAE,IAAa;QAC1C,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,4BAAI,GAAX,UAAY,OAAe,EAAE,IAAa;QACzC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,4BAAI,GAAX,UAAY,OAAe,EAAE,IAAa;QACzC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,6BAAK,GAAZ,UAAa,OAAe,EAAE,IAAa;QAC1C,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,uCAAe,GAAtB,UAAuB,SAAiB;QACvC,IAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,UAAG,IAAI,CAAC,SAAS,MAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAC3D,CAAC;IAEM,+CAAuB,GAA9B,UAA+B,oBAA8B;QAC5D,IAAI,CAAC,QAAQ,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACK,2BAAG,GAAX,UAAY,KAAa,EAAE,OAAe,EAAE,IAAa;QACxD,IAAM,UAAU,GAAG,OAAO,IAAI,CAAC,SAAS,KAAK,WAAW,IAAI,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxH,IAAI,CAAC,UAAU,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,aAAI,SAAS,EAAE,IAAI,CAAC,SAAS,IAAK,IAAI,EAAG,CAAC;QACzE,CAAC;IACF,CAAC;IACF,oBAAC;AAAD,CAAC,AAtDD,IAsDC;AAtDY,sCAAa"}

package/dist/Logging/logging.d.ts

@@ -0,0 +1,12 @@
+import { WinstonLogger } from './logger';
+/**
+ * Singleton logger to be used across the entire application
+ */
+export declare const logger: WinstonLogger;
+/**
+ * This function will redirect all console logs and debug logs to the logger.
+ *
+ * The goal is to collect all logs that are not logged through the central logger and make them go through the logger.
+ * That way we can control the format and destination of all logs no matter where they are logged.
+ */
+export declare function redirectAllLogsToLogger(): void;

package/dist/Logging/logging.js

@@ -0,0 +1,113 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.redirectAllLogsToLogger = redirectAllLogsToLogger;
+var winston = __importStar(require("winston"));
+var logger_1 = require("./logger");
+var console_1 = require("./console");
+var debug_1 = require("./debug");
+var format_1 = require("./format");
+var LogFormat;
+(function (LogFormat) {
+    LogFormat["JSON"] = "json";
+    LogFormat["JSON_PRETTY"] = "json_pretty";
+    LogFormat["Simple"] = "simple";
+})(LogFormat || (LogFormat = {}));
+var logLevel = process.env.LOG_LEVEL || 'debug';
+var logFormat = process.env.LOG_FORMAT || LogFormat.JSON;
+var ensureJSONKeyOrder = winston.format(function (info) {
+    var level = info.level, message = info.message, rest = __rest(info, ["level", "message"]);
+    return __assign({ level: level, message: message }, rest);
+});
+var winstonFormatters = [
+    // parses errors and adds stack trace, when error is passed as the first argument instead of message
+    winston.format.errors({ stack: true }),
+    // parses nested error objects and adds stack trace
+    (0, format_1.formatNestedErrors)(),
+];
+switch (logFormat) {
+    case LogFormat.JSON:
+        winstonFormatters.push(ensureJSONKeyOrder(), // ensures that the keys in the JSON are always in the order we want
+        winston.format.json({ deterministic: false }));
+        break;
+    case LogFormat.JSON_PRETTY:
+        winstonFormatters.push(ensureJSONKeyOrder(), // ensures that the keys in the JSON are always in the order we want
+        winston.format.json(), winston.format.prettyPrint({ colorize: true }));
+        break;
+    case LogFormat.Simple:
+        winstonFormatters.push(winston.format.colorize(), // adds colors to the log
+        winston.format.simple());
+        break;
+    default:
+        throw new Error("Unknown log format: ".concat(logFormat, ", allowed values are: json, simple"));
+}
+/**
+ * Since we aim to have a single API for all logs in the application, it's implemented as singleton.
+ * If that turns to be insufficient, we can change that later.
+ */
+var winstonLogger = winston.createLogger({
+    level: logLevel,
+    format: (_a = winston.format).combine.apply(_a, winstonFormatters),
+    transports: [new winston.transports.Console()],
+});
+/**
+ * Singleton logger to be used across the entire application
+ */
+exports.logger = new logger_1.WinstonLogger(winstonLogger);
+/**
+ * This function will redirect all console logs and debug logs to the logger.
+ *
+ * The goal is to collect all logs that are not logged through the central logger and make them go through the logger.
+ * That way we can control the format and destination of all logs no matter where they are logged.
+ */
+function redirectAllLogsToLogger() {
+    (0, console_1.redirectConsoleToLogger)(exports.logger);
+    (0, debug_1.redirectDebugToLogger)(exports.logger);
+}
+//# sourceMappingURL=logging.js.map

package/dist/Logging/logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.js","sourceRoot":"","sources":["../../src/Logging/logging.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,0DAGC;AA3ED,+CAAmC;AACnC,mCAAyC;AACzC,qCAAoD;AACpD,iCAAgD;AAChD,mCAA8C;AAE9C,IAAK,SAIJ;AAJD,WAAK,SAAS;IACb,0BAAa,CAAA;IACb,wCAA2B,CAAA;IAC3B,8BAAiB,CAAA;AAClB,CAAC,EAJI,SAAS,KAAT,SAAS,QAIb;AAED,IAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,IAAI,OAAO,CAAC;AAClD,IAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,SAAS,CAAC,IAAI,CAAC;AAE3D,IAAM,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAC,IAAI;IACtC,IAAA,KAAK,GAAuB,IAAI,MAA3B,EAAE,OAAO,GAAc,IAAI,QAAlB,EAAK,IAAI,UAAK,IAAI,EAAlC,oBAA2B,CAAF,CAAU;IACzC,kBAAS,KAAK,OAAA,EAAE,OAAO,SAAA,IAAK,IAAI,EAAG;AACpC,CAAC,CAAC,CAAC;AAEH,IAAM,iBAAiB,GAA6B;IACnD,oGAAoG;IACpG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACtC,mDAAmD;IACnD,IAAA,2BAAkB,GAAE;CACpB,CAAC;AAEF,QAAQ,SAAS,EAAE,CAAC;IACnB,KAAK,SAAS,CAAC,IAAI;QAClB,iBAAiB,CAAC,IAAI,CACrB,kBAAkB,EAAE,EAAE,oEAAoE;QAC1F,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,CAC7C,CAAC;QACF,MAAM;IACP,KAAK,SAAS,CAAC,WAAW;QACzB,iBAAiB,CAAC,IAAI,CACrB,kBAAkB,EAAE,EAAE,oEAAoE;QAC1F,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,EACrB,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC9C,CAAC;QACF,MAAM;IACP,KAAK,SAAS,CAAC,MAAM;QACpB,iBAAiB,CAAC,IAAI,CACrB,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,yBAAyB;QACpD,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,CACvB,CAAC;QACF,MAAM;IACP;QACC,MAAM,IAAI,KAAK,CAAC,8BAAuB,SAAS,uCAAoC,CAAC,CAAC;AACxF,CAAC;AAED;;;GAGG;AACH,IAAM,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAC1C,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,CAAA,KAAA,OAAO,CAAC,MAAM,CAAA,CAAC,OAAO,WAAI,iBAAiB,CAAC;IACpD,UAAU,EAAE,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;CAC9C,CAAC,CAAC;AAEH;;GAEG;AACU,QAAA,MAAM,GAAG,IAAI,sBAAa,CAAC,aAAa,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,SAAgB,uBAAuB;IACtC,IAAA,iCAAuB,EAAC,cAAM,CAAC,CAAC;IAChC,IAAA,6BAAqB,EAAC,cAAM,CAAC,CAAC;AAC/B,CAAC"}

package/dist/Metrics/MetricsClient.d.ts

@@ -0,0 +1,46 @@
+import { Response } from 'express';
+import * as prometheusClient from 'prom-client';
+export type PrometheusClient = typeof prometheusClient;
+export type BeforeServeListener = (client: PrometheusClient) => void;
+/**
+ * Metrics client
+ *
+ * If you want to add custom application-specific metrics, you have to call getClient()
+ * add your metrics to the client.
+ *
+ * Example:
+ *
+ *  const client = metricsClient.getClient();
+ *  const myCounter = new client.Counter({
+ *    name: 'my_counter',
+ *    help: 'This is my counter',
+ *  });
+ *  // now you can independently increment the counter in your code
+ *  // and the value will automatically be exposed when serving metrics
+ *
+ * For more info, see https://www.npmjs.com/package/prom-client
+ */
+export interface IMetricsClient {
+    /**
+     * Returns Prometheus client
+     *
+     * This is useful for adding custom metrics
+     */
+    getClient(): PrometheusClient;
+    /**
+     * Initialize metrics client to start serving default Node.js metrics
+     */
+    init(): void;
+    /** Serve metrics as HTTP response */
+    serve(response: Response): Promise<Response>;
+    /** Clear all metrics and reset the client */
+    clear(): void;
+}
+export declare class MetricsClient implements IMetricsClient {
+    private client;
+    constructor(client?: PrometheusClient);
+    getClient(): PrometheusClient;
+    init(): void;
+    serve(response: Response): Promise<Response>;
+    clear(): void;
+}

package/dist/Metrics/MetricsClient.js

@@ -0,0 +1,101 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsClient = void 0;
+var prometheusClient = __importStar(require("prom-client"));
+var processSocketsMetrics_1 = require("./processSocketsMetrics");
+var MetricsClient = /** @class */ (function () {
+    function MetricsClient(client) {
+        if (client === void 0) { client = prometheusClient; }
+        this.client = client;
+    }
+    MetricsClient.prototype.getClient = function () {
+        return this.client;
+    };
+    MetricsClient.prototype.init = function () {
+        this.client.collectDefaultMetrics();
+        (0, processSocketsMetrics_1.collectSocketMetrics)({
+            registry: this.client.register,
+            process: process,
+        });
+    };
+    MetricsClient.prototype.serve = function (response) {
+        return __awaiter(this, void 0, void 0, function () {
+            var responseBody;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        response.set('Content-Type', this.client.register.contentType);
+                        return [4 /*yield*/, this.client.register.metrics()];
+                    case 1:
+                        responseBody = _a.sent();
+                        return [2 /*return*/, response.send(responseBody)];
+                }
+            });
+        });
+    };
+    MetricsClient.prototype.clear = function () {
+        this.client.register.clear();
+    };
+    return MetricsClient;
+}());
+exports.MetricsClient = MetricsClient;
+//# sourceMappingURL=MetricsClient.js.map

package/dist/Metrics/MetricsClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsClient.js","sourceRoot":"","sources":["../../src/Metrics/MetricsClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,4DAAgD;AAChD,iEAA+D;AAyC/D;IACC,uBAAoB,MAA2C;QAA3C,uBAAA,EAAA,yBAA2C;QAA3C,WAAM,GAAN,MAAM,CAAqC;IAAG,CAAC;IAE5D,iCAAS,GAAhB;QACC,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAEM,4BAAI,GAAX;QACC,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;QACpC,IAAA,4CAAoB,EAAC;YACpB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC9B,OAAO,SAAA;SACP,CAAC,CAAC;IACJ,CAAC;IAEY,6BAAK,GAAlB,UAAmB,QAAkB;;;;;;wBACpC,QAAQ,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;wBAC1C,qBAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAA;;wBAAnD,YAAY,GAAG,SAAoC;wBACzD,sBAAO,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,EAAC;;;;KACnC;IAEM,6BAAK,GAAZ;QACC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IACF,oBAAC;AAAD,CAAC,AAxBD,IAwBC;AAxBY,sCAAa"}

package/dist/Metrics/deviceConsumerMetrics.d.ts

@@ -0,0 +1,6 @@
+import { Metrics } from './metrics';
+export type MetricsEvents = 'incoming_actions_received' | 'incoming_actions_successful' | 'incoming_actions_erred' | 'incoming_actions_processing_duration' | 'outgoing_actions_successful' | 'outgoing_actions_erred' | 'outgoing_actions_ack_duration';
+export type TLabelsTypes = {
+    actionType: 'NOT_PREDEFINED_VALUE';
+};
+export declare const metrics: Metrics<MetricsEvents, TLabelsTypes>;

package/dist/Metrics/deviceConsumerMetrics.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metrics = void 0;
+var metrics_1 = require("./metrics");
+var defaultOptions = {
+    /**
+     * Buckets for the action_duration_seconds_bucket metric.
+     * Default buckets are [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10, 30, 60]
+     */
+    durationInSecondsHistogramBuckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10, 30, 60],
+};
+var prefix = 'sos_device_consumer_';
+var labels = {
+    actionType: 'NOT_PREDEFINED_VALUE',
+};
+var metricsConfig = {
+    incoming_actions_received: {
+        metric: 'Counter',
+        help: 'Total number of incoming actions received',
+        labels: labels,
+    },
+    incoming_actions_successful: {
+        metric: 'Counter',
+        help: 'Total number of successfully processed incoming actions',
+        labels: labels,
+    },
+    incoming_actions_erred: {
+        metric: 'Counter',
+        help: 'Total number of incoming actions that resulted in an error',
+        labels: labels,
+    },
+    incoming_actions_processing_duration: {
+        metric: 'Histogram',
+        help: 'Duration of incoming action processing in seconds',
+        buckets: defaultOptions.durationInSecondsHistogramBuckets,
+        labels: labels,
+    },
+    outgoing_actions_successful: {
+        metric: 'Counter',
+        help: 'Total number of successfully processed outgoing actions',
+        labels: labels,
+    },
+    outgoing_actions_erred: {
+        metric: 'Counter',
+        help: 'Total number of outgoing actions that resulted in an error',
+        labels: labels,
+    },
+    outgoing_actions_ack_duration: {
+        metric: 'Histogram',
+        help: 'Duration of outgoing action acknowledgment in seconds',
+        buckets: defaultOptions.durationInSecondsHistogramBuckets,
+        labels: labels,
+    },
+};
+exports.metrics = new metrics_1.Metrics({
+    metricsConfig: metricsConfig,
+    prefix: prefix,
+});
+//# sourceMappingURL=deviceConsumerMetrics.js.map

package/dist/Metrics/deviceConsumerMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceConsumerMetrics.js","sourceRoot":"","sources":["../../src/Metrics/deviceConsumerMetrics.ts"],"names":[],"mappings":";;;AAAA,qCAAoD;AAEpD,IAAM,cAAc,GAAG;IACtB;;;OAGG;IACH,iCAAiC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;CAC9E,CAAC;AAEF,IAAM,MAAM,GAAG,sBAAsB,CAAC;AAetC,IAAM,MAAM,GAAG;IACd,UAAU,EAAE,sBAAsB;CACzB,CAAC;AAEX,IAAM,aAAa,GAAgD;IAClE,yBAAyB,EAAE;QAC1B,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,2CAA2C;QACjD,MAAM,QAAA;KACN;IACD,2BAA2B,EAAE;QAC5B,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,yDAAyD;QAC/D,MAAM,QAAA;KACN;IACD,sBAAsB,EAAE;QACvB,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,4DAA4D;QAClE,MAAM,QAAA;KACN;IACD,oCAAoC,EAAE;QACrC,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,mDAAmD;QACzD,OAAO,EAAE,cAAc,CAAC,iCAAiC;QACzD,MAAM,QAAA;KACN;IACD,2BAA2B,EAAE;QAC5B,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,yDAAyD;QAC/D,MAAM,QAAA;KACN;IACD,sBAAsB,EAAE;QACvB,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,4DAA4D;QAClE,MAAM,QAAA;KACN;IACD,6BAA6B,EAAE;QAC9B,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,uDAAuD;QAC7D,OAAO,EAAE,cAAc,CAAC,iCAAiC;QACzD,MAAM,QAAA;KACN;CACD,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,iBAAO,CAA8B;IAC/D,aAAa,eAAA;IACb,MAAM,QAAA;CACN,CAAC,CAAC"}

package/dist/Metrics/eventConsumerMetrics.d.ts

@@ -0,0 +1,19 @@
+import IEvent, { IEventPayload } from '../AMQP/EventSourcing/IEvent';
+import { Metrics } from './metrics';
+export type EventProcessedData = {
+    event: IEvent<IEventPayload>;
+    stats: {
+        /** Timestamp in milliseconds when consumption started */
+        start: number;
+        duration: number;
+    };
+};
+declare const eventPhases: readonly ["processing", "eventStart", "commandStart"];
+type EventPhase = (typeof eventPhases)[number];
+type MetricsEvents = 'events_total' | 'event_duration_seconds' | 'event_duration_seconds_total' | 'event_success_total' | 'event_error_total';
+type TLabelsTypes = {
+    eventType: 'NOT_PREDEFINED_VALUE';
+    phase: readonly EventPhase[];
+};
+export declare const metrics: Metrics<MetricsEvents, TLabelsTypes>;
+export {};

package/dist/Metrics/eventConsumerMetrics.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metrics = void 0;
+var metrics_1 = require("./metrics");
+var defaultOptions = {
+    /**
+     * Buckets for the event_duration_seconds_bucket metric.
+     * Default buckets are [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10, 30, 60]
+     */
+    durationInSecondsHistogramBuckets: [0.01, 0.05, 0.1, 0.5, 1, 2, 5, 10, 30, 60],
+};
+var prefix = 'sos_event_consumer_';
+var eventPhases = ['processing', 'eventStart', 'commandStart'];
+var labels = {
+    eventType: 'NOT_PREDEFINED_VALUE',
+};
+var metricsConfig = {
+    events_total: {
+        metric: 'Counter',
+        help: 'Number of all events',
+        labels: labels,
+    },
+    event_duration_seconds_total: {
+        metric: 'Counter',
+        help: 'Total duration of all events in seconds',
+        labels: {
+            eventType: 'NOT_PREDEFINED_VALUE',
+            phase: eventPhases,
+        },
+    },
+    event_duration_seconds: {
+        metric: 'Histogram',
+        help: 'Duration of all events in seconds',
+        buckets: defaultOptions.durationInSecondsHistogramBuckets,
+        labels: labels,
+    },
+    event_success_total: {
+        metric: 'Counter',
+        help: 'Number of events that succeeded',
+        labels: labels,
+    },
+    event_error_total: {
+        metric: 'Counter',
+        help: 'Number of events that errored',
+        labels: labels,
+    },
+};
+exports.metrics = new metrics_1.Metrics({
+    metricsConfig: metricsConfig,
+    prefix: prefix,
+});
+//# sourceMappingURL=eventConsumerMetrics.js.map

package/dist/Metrics/eventConsumerMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventConsumerMetrics.js","sourceRoot":"","sources":["../../src/Metrics/eventConsumerMetrics.ts"],"names":[],"mappings":";;;AACA,qCAAoD;AAEpD,IAAM,cAAc,GAAG;IACtB;;;OAGG;IACH,iCAAiC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;CAC9E,CAAC;AAEF,IAAM,MAAM,GAAG,qBAAqB,CAAC;AAWrC,IAAM,WAAW,GAAG,CAAC,YAAY,EAAE,YAAY,EAAE,cAAc,CAAU,CAAC;AAgB1E,IAAM,MAAM,GAAG;IACd,SAAS,EAAE,sBAAsB;CACxB,CAAC;AAEX,IAAM,aAAa,GAAgD;IAClE,YAAY,EAAE;QACb,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,sBAAsB;QAC5B,MAAM,QAAA;KACN;IACD,4BAA4B,EAAE;QAC7B,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,yCAAyC;QAC/C,MAAM,EAAE;YACP,SAAS,EAAE,sBAAsB;YACjC,KAAK,EAAE,WAAW;SAClB;KACD;IACD,sBAAsB,EAAE;QACvB,MAAM,EAAE,WAAW;QACnB,IAAI,EAAE,mCAAmC;QACzC,OAAO,EAAE,cAAc,CAAC,iCAAiC;QACzD,MAAM,QAAA;KACN;IACD,mBAAmB,EAAE;QACpB,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,iCAAiC;QACvC,MAAM,QAAA;KACN;IACD,iBAAiB,EAAE;QAClB,MAAM,EAAE,SAAS;QACjB,IAAI,EAAE,+BAA+B;QACrC,MAAM,QAAA;KACN;CACD,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,iBAAO,CAA8B;IAC/D,aAAa,eAAA;IACb,MAAM,QAAA;CACN,CAAC,CAAC"}

package/dist/Metrics/eventQueueMetrics.d.ts

@@ -0,0 +1,7 @@
+import { Metrics, TNOT_PREDEFINED_VALUE } from './metrics';
+type MetricsEvents = 'event_enqueued';
+type TLabelsTypes = {
+    eventType: TNOT_PREDEFINED_VALUE;
+};
+export declare const metrics: Metrics<MetricsEvents, TLabelsTypes>;
+export {};