feat: 초기 프로젝트 설정 및 룰.md 파일 추가

api.hyungi.net/node_modules/@pm2/io/build/main/utils/BinaryHeap.d.ts

@@ -0,0 +1,16 @@
+export default class BinaryHeap {
+    private _elements;
+    constructor(options: any);
+    add(): void;
+    first(): any;
+    removeFirst(): any;
+    clone(): BinaryHeap;
+    toSortedArray(): any[];
+    toArray(): never[];
+    size(): any;
+    _bubble(bubbleIndex: any): void;
+    _sink(sinkIndex: any): void;
+    _parentIndex(index: any): number;
+    _childIndexes(index: any): number[];
+    _score(element: any): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/BinaryHeap.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BinaryHeap {
+    constructor(options) {
+        options = options || {};
+        this._elements = options.elements || [];
+        this._score = options.score || this._score;
+    }
+    add() {
+        for (let i = 0; i < arguments.length; i++) {
+            const element = arguments[i];
+            this._elements.push(element);
+            this._bubble(this._elements.length - 1);
+        }
+    }
+    first() {
+        return this._elements[0];
+    }
+    removeFirst() {
+        const root = this._elements[0];
+        const last = this._elements.pop();
+        if (this._elements.length > 0) {
+            this._elements[0] = last;
+            this._sink(0);
+        }
+        return root;
+    }
+    clone() {
+        return new BinaryHeap({
+            elements: this.toArray(),
+            score: this._score
+        });
+    }
+    toSortedArray() {
+        const array = [];
+        const clone = this.clone();
+        while (true) {
+            const element = clone.removeFirst();
+            if (element === undefined)
+                break;
+            array.push(element);
+        }
+        return array;
+    }
+    toArray() {
+        return [].concat(this._elements);
+    }
+    size() {
+        return this._elements.length;
+    }
+    _bubble(bubbleIndex) {
+        const bubbleElement = this._elements[bubbleIndex];
+        const bubbleScore = this._score(bubbleElement);
+        while (bubbleIndex > 0) {
+            const parentIndex = this._parentIndex(bubbleIndex);
+            const parentElement = this._elements[parentIndex];
+            const parentScore = this._score(parentElement);
+            if (bubbleScore <= parentScore)
+                break;
+            this._elements[parentIndex] = bubbleElement;
+            this._elements[bubbleIndex] = parentElement;
+            bubbleIndex = parentIndex;
+        }
+    }
+    _sink(sinkIndex) {
+        const sinkElement = this._elements[sinkIndex];
+        const sinkScore = this._score(sinkElement);
+        const length = this._elements.length;
+        while (true) {
+            let swapIndex;
+            let swapScore;
+            let swapElement = null;
+            const childIndexes = this._childIndexes(sinkIndex);
+            for (let i = 0; i < childIndexes.length; i++) {
+                const childIndex = childIndexes[i];
+                if (childIndex >= length)
+                    break;
+                const childElement = this._elements[childIndex];
+                const childScore = this._score(childElement);
+                if (childScore > sinkScore) {
+                    if (swapScore === undefined || swapScore < childScore) {
+                        swapIndex = childIndex;
+                        swapScore = childScore;
+                        swapElement = childElement;
+                    }
+                }
+            }
+            if (swapIndex === undefined)
+                break;
+            this._elements[swapIndex] = sinkElement;
+            this._elements[sinkIndex] = swapElement;
+            sinkIndex = swapIndex;
+        }
+    }
+    _parentIndex(index) {
+        return Math.floor((index - 1) / 2);
+    }
+    _childIndexes(index) {
+        return [
+            2 * index + 1,
+            2 * index + 2
+        ];
+    }
+    _score(element) {
+        return element.valueOf();
+    }
+}
+exports.default = BinaryHeap;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EDS.d.ts

@@ -0,0 +1,21 @@
+export default class ExponentiallyDecayingSample {
+    private RESCALE_INTERVAL;
+    private ALPHA;
+    private SIZE;
+    private _elements;
+    private _rescaleInterval;
+    private _alpha;
+    private _size;
+    private _landmark;
+    private _nextRescale;
+    private _mean;
+    constructor(options?: any);
+    update(value: any, timestamp?: any): void;
+    toSortedArray(): any;
+    toArray(): any;
+    _weight(age: any): number;
+    _priority(age: any): number;
+    _random(): number;
+    _rescale(now: any): void;
+    avg(now: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EDS.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const BinaryHeap_1 = require("./BinaryHeap");
+const units_1 = require("./units");
+class ExponentiallyDecayingSample {
+    constructor(options) {
+        this.RESCALE_INTERVAL = 1 * units_1.default.HOURS;
+        this.ALPHA = 0.015;
+        this.SIZE = 1028;
+        options = options || {};
+        this._elements = new BinaryHeap_1.default({
+            score: function (element) {
+                return -element.priority;
+            }
+        });
+        this._rescaleInterval = options.rescaleInterval || this.RESCALE_INTERVAL;
+        this._alpha = options.alpha || this.ALPHA;
+        this._size = options.size || this.SIZE;
+        this._random = options.random || this._random;
+        this._landmark = null;
+        this._nextRescale = null;
+        this._mean = null;
+    }
+    update(value, timestamp) {
+        const now = Date.now();
+        if (!this._landmark) {
+            this._landmark = now;
+            this._nextRescale = this._landmark + this._rescaleInterval;
+        }
+        timestamp = timestamp || now;
+        const newSize = this._elements.size() + 1;
+        const element = {
+            priority: this._priority(timestamp - this._landmark),
+            value: value
+        };
+        if (newSize <= this._size) {
+            this._elements.add(element);
+        }
+        else if (element.priority > this._elements.first().priority) {
+            this._elements.removeFirst();
+            this._elements.add(element);
+        }
+        if (now >= this._nextRescale)
+            this._rescale(now);
+    }
+    toSortedArray() {
+        return this._elements
+            .toSortedArray()
+            .map(function (element) {
+            return element.value;
+        });
+    }
+    toArray() {
+        return this._elements
+            .toArray()
+            .map(function (element) {
+            return element.value;
+        });
+    }
+    _weight(age) {
+        return Math.exp(this._alpha * (age / 1000));
+    }
+    _priority(age) {
+        return this._weight(age) / this._random();
+    }
+    _random() {
+        return Math.random();
+    }
+    _rescale(now) {
+        now = now || Date.now();
+        const self = this;
+        const oldLandmark = this._landmark;
+        this._landmark = now || Date.now();
+        this._nextRescale = now + this._rescaleInterval;
+        const factor = self._priority(-(self._landmark - oldLandmark));
+        this._elements
+            .toArray()
+            .forEach(function (element) {
+            element.priority *= factor;
+        });
+    }
+    avg(now) {
+        let sum = 0;
+        this._elements
+            .toArray()
+            .forEach(function (element) {
+            sum += element.value;
+        });
+        return (sum / this._elements.size());
+    }
+}
+exports.default = ExponentiallyDecayingSample;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EWMA.d.ts

@@ -0,0 +1,12 @@
+export default class ExponentiallyWeightedMovingAverage {
+    private _timePeriod;
+    private _tickInterval;
+    private _alpha;
+    private _count;
+    private _rate;
+    private TICK_INTERVAL;
+    constructor(timePeriod?: number, tickInterval?: number);
+    update(n: any): void;
+    tick(): void;
+    rate(timeUnit: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/EWMA.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const units_1 = require("./units");
+class ExponentiallyWeightedMovingAverage {
+    constructor(timePeriod, tickInterval) {
+        this._count = 0;
+        this._rate = 0;
+        this.TICK_INTERVAL = 5 * units_1.default.SECONDS;
+        this._timePeriod = timePeriod || 1 * units_1.default.MINUTES;
+        this._tickInterval = tickInterval || this.TICK_INTERVAL;
+        this._alpha = 1 - Math.exp(-this._tickInterval / this._timePeriod);
+    }
+    update(n) {
+        this._count += n;
+    }
+    tick() {
+        const instantRate = this._count / this._tickInterval;
+        this._count = 0;
+        this._rate += (this._alpha * (instantRate - this._rate));
+    }
+    rate(timeUnit) {
+        return (this._rate || 0) * timeUnit;
+    }
+}
+exports.default = ExponentiallyWeightedMovingAverage;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRVdNQS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9FV01BLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsbUNBQTJCO0FBRTNCLE1BQXFCLGtDQUFrQztJQVNyRCxZQUFhLFVBQW1CLEVBQUUsWUFBcUI7UUFML0MsV0FBTSxHQUFXLENBQUMsQ0FBQTtRQUNsQixVQUFLLEdBQVcsQ0FBQyxDQUFBO1FBRWpCLGtCQUFhLEdBQVcsQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFHL0MsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLElBQUksQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFDbEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxZQUFZLElBQUksSUFBSSxDQUFDLGFBQWEsQ0FBQTtRQUN2RCxJQUFJLENBQUMsTUFBTSxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUE7SUFDcEUsQ0FBQztJQUVELE1BQU0sQ0FBRSxDQUFDO1FBQ1AsSUFBSSxDQUFDLE1BQU0sSUFBSSxDQUFDLENBQUE7SUFDbEIsQ0FBQztJQUVELElBQUk7UUFDRixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUE7UUFDcEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUE7UUFFZixJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtJQUMxRCxDQUFDO0lBRUQsSUFBSSxDQUFFLFFBQVE7UUFDWixPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssSUFBSSxDQUFDLENBQUMsR0FBRyxRQUFRLENBQUE7SUFDckMsQ0FBQztDQUNGO0FBN0JELHFEQTZCQyJ9

api.hyungi.net/node_modules/@pm2/io/build/main/utils/autocast.d.ts

@@ -0,0 +1,13 @@
+export default class Autocast {
+    commonStrings: {
+        true: boolean;
+        false: boolean;
+        undefined: undefined;
+        null: null;
+        NaN: number;
+    };
+    process(key: any, value: any, o: any): void;
+    traverse(o: any, func: any): void;
+    autocast(s: any): any;
+    private _cast;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/autocast.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Autocast {
+    constructor() {
+        this.commonStrings = {
+            'true': true,
+            'false': false,
+            'undefined': undefined,
+            'null': null,
+            'NaN': NaN
+        };
+    }
+    process(key, value, o) {
+        if (typeof (value) === 'object')
+            return;
+        o[key] = this._cast(value);
+    }
+    traverse(o, func) {
+        for (let i in o) {
+            func.apply(this, [i, o[i], o]);
+            if (o[i] !== null && typeof (o[i]) === 'object') {
+                this.traverse(o[i], func);
+            }
+        }
+    }
+    autocast(s) {
+        if (typeof (s) === 'object') {
+            this.traverse(s, this.process);
+            return s;
+        }
+        return this._cast(s);
+    }
+    _cast(s) {
+        let key;
+        if (s instanceof Date)
+            return s;
+        if (typeof s === 'boolean')
+            return s;
+        if (!isNaN(s))
+            return Number(s);
+        for (key in this.commonStrings) {
+            if (s === key)
+                return this.commonStrings[key];
+        }
+        return s;
+    }
+}
+exports.default = Autocast;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2Nhc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvYXV0b2Nhc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFxQixRQUFRO0lBQTdCO1FBSUUsa0JBQWEsR0FBRztZQUNkLE1BQU0sRUFBRSxJQUFJO1lBQ1osT0FBTyxFQUFFLEtBQUs7WUFDZCxXQUFXLEVBQUUsU0FBUztZQUN0QixNQUFNLEVBQUUsSUFBSTtZQUNaLEtBQUssRUFBRSxHQUFHO1NBQ1gsQ0FBQTtJQStDSCxDQUFDO0lBN0NDLE9BQU8sQ0FBRSxHQUFHLEVBQUMsS0FBSyxFQUFFLENBQUM7UUFDbkIsSUFBSSxPQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssUUFBUTtZQUFFLE9BQU07UUFDdEMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7SUFDNUIsQ0FBQztJQUVELFFBQVEsQ0FBRSxDQUFDLEVBQUMsSUFBSTtRQUNkLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUMsQ0FBQyxDQUFDLEVBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDNUIsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssSUFBSSxJQUFJLE9BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFFL0MsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUMsSUFBSSxDQUFDLENBQUE7WUFDMUIsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0lBS0QsUUFBUSxDQUFFLENBQUM7UUFDVCxJQUFJLE9BQU0sQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUMzQixJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUE7WUFDOUIsT0FBTyxDQUFDLENBQUE7UUFDVixDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ3RCLENBQUM7SUFFTyxLQUFLLENBQUUsQ0FBQztRQUNkLElBQUksR0FBRyxDQUFBO1FBR1AsSUFBSSxDQUFDLFlBQVksSUFBSTtZQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQy9CLElBQUksT0FBTyxDQUFDLEtBQUssU0FBUztZQUFFLE9BQU8sQ0FBQyxDQUFBO1FBR3BDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQUUsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFHL0IsS0FBSyxHQUFHLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQy9CLElBQUksQ0FBQyxLQUFLLEdBQUc7Z0JBQUUsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFBO1FBQy9DLENBQUM7UUFHRCxPQUFPLENBQUMsQ0FBQTtJQUNWLENBQUM7Q0FDRjtBQXpERCwyQkF5REMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/counter.d.ts

@@ -0,0 +1,10 @@
+export default class Counter {
+    private _count;
+    private used;
+    constructor(opts?: any);
+    val(): number;
+    inc(n?: number): void;
+    dec(n?: number): void;
+    reset(count?: number): void;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/counter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Counter {
+    constructor(opts) {
+        this.used = false;
+        opts = opts || {};
+        this._count = opts.count || 0;
+    }
+    val() {
+        return this._count;
+    }
+    inc(n) {
+        this.used = true;
+        this._count += (n || 1);
+    }
+    dec(n) {
+        this.used = true;
+        this._count -= (n || 1);
+    }
+    reset(count) {
+        this._count = count || 0;
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Counter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlscy9tZXRyaWNzL2NvdW50ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFxQixPQUFPO0lBSTFCLFlBQWEsSUFBSztRQUZWLFNBQUksR0FBWSxLQUFLLENBQUE7UUFHM0IsSUFBSSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUE7UUFDakIsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsQ0FBQTtJQUMvQixDQUFDO0lBRUQsR0FBRztRQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQTtJQUNwQixDQUFDO0lBRUQsR0FBRyxDQUFFLENBQVU7UUFDYixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtRQUNoQixJQUFJLENBQUMsTUFBTSxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBO0lBQ3pCLENBQUM7SUFFRCxHQUFHLENBQUUsQ0FBVTtRQUNiLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBQ2hCLElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDekIsQ0FBQztJQUVELEtBQUssQ0FBRSxLQUFjO1FBQ25CLElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxJQUFJLENBQUMsQ0FBQTtJQUMxQixDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQTtJQUNsQixDQUFDO0NBQ0Y7QUE5QkQsMEJBOEJDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/gauge.d.ts

@@ -0,0 +1,7 @@
+export default class Gauge {
+    private value;
+    private used;
+    val(): number;
+    set(value: any): void;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/gauge.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Gauge {
+    constructor() {
+        this.value = 0;
+        this.used = false;
+    }
+    val() {
+        return this.value;
+    }
+    set(value) {
+        this.used = true;
+        this.value = value;
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Gauge;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2F1Z2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvbWV0cmljcy9nYXVnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLE1BQXFCLEtBQUs7SUFBMUI7UUFDVSxVQUFLLEdBQUcsQ0FBQyxDQUFBO1FBQ1QsU0FBSSxHQUFHLEtBQUssQ0FBQTtJQWN0QixDQUFDO0lBWkMsR0FBRztRQUNELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQTtJQUNuQixDQUFDO0lBRUQsR0FBRyxDQUFFLEtBQUs7UUFDUixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtRQUNoQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQTtJQUNwQixDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQTtJQUNsQixDQUFDO0NBQ0Y7QUFoQkQsd0JBZ0JDIn0=

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/histogram.d.ts

@@ -0,0 +1,43 @@
+export default class Histogram {
+    private _measurement;
+    private _callFn;
+    private _sample;
+    private _min;
+    private _max;
+    private _count;
+    private _sum;
+    private _varianceM;
+    private _varianceS;
+    private _ema;
+    private used;
+    constructor(opts?: any);
+    update(value: number): void;
+    percentiles(percentiles: any): {};
+    val(): any;
+    getMin(): any;
+    getMax(): any;
+    getSum(): number;
+    getCount(): number;
+    getEma(): number;
+    fullResults(): {
+        min: any;
+        max: any;
+        sum: number;
+        variance: number | null;
+        mean: number;
+        count: number;
+        median: any;
+        p75: any;
+        p95: any;
+        p99: any;
+        p999: any;
+        ema: number;
+    };
+    _updateMin(value: any): void;
+    _updateMax(value: any): void;
+    _updateVariance(value: any): any;
+    _updateEma(value: any): number | undefined;
+    _calculateMean(): number;
+    _calculateVariance(): number | null;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/meter.d.ts

@@ -0,0 +1,12 @@
+export default class Meter {
+    private _tickInterval;
+    private _samples;
+    private _timeframe;
+    private _rate;
+    private _interval;
+    private used;
+    constructor(opts?: any);
+    mark: (n?: number) => void;
+    val: () => number;
+    isUsed(): boolean;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/metrics/meter.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EWMA_1 = require("../EWMA");
+const units_1 = require("../units");
+class Meter {
+    constructor(opts) {
+        this.used = false;
+        this.mark = function (n = 1) {
+            this.used = true;
+            this._rate.update(n);
+        };
+        this.val = function () {
+            return Math.round(this._rate.rate(this._samples * units_1.default.SECONDS) * 100) / 100;
+        };
+        const self = this;
+        if (typeof opts !== 'object') {
+            opts = {};
+        }
+        this._samples = opts.samples || opts.seconds || 1;
+        this._timeframe = opts.timeframe || 60;
+        this._tickInterval = opts.tickInterval || 5 * units_1.default.SECONDS;
+        this._rate = new EWMA_1.default(this._timeframe * units_1.default.SECONDS, this._tickInterval);
+        if (opts.debug && opts.debug === true) {
+            return;
+        }
+        this._interval = setInterval(function () {
+            self._rate.tick();
+        }, this._tickInterval);
+        this._interval.unref();
+    }
+    isUsed() {
+        return this.used;
+    }
+}
+exports.default = Meter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWV0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvbWV0cmljcy9tZXRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGtDQUEwQjtBQUMxQixvQ0FBNEI7QUFFNUIsTUFBcUIsS0FBSztJQVN4QixZQUFhLElBQVU7UUFGZixTQUFJLEdBQVksS0FBSyxDQUFBO1FBMEI3QixTQUFJLEdBQUcsVUFBVSxJQUFZLENBQUM7WUFDNUIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUE7WUFDaEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDdEIsQ0FBQyxDQUFBO1FBRUQsUUFBRyxHQUFHO1lBQ0osT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEdBQUcsZUFBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEdBQUcsQ0FBQyxHQUFHLEdBQUcsQ0FBQTtRQUMvRSxDQUFDLENBQUE7UUE5QkMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBRWpCLElBQUksT0FBTyxJQUFJLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDN0IsSUFBSSxHQUFHLEVBQUUsQ0FBQTtRQUNYLENBQUM7UUFFRCxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLE9BQU8sSUFBSSxDQUFDLENBQUE7UUFDakQsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsU0FBUyxJQUFJLEVBQUUsQ0FBQTtRQUN0QyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxZQUFZLElBQUksQ0FBQyxHQUFHLGVBQUssQ0FBQyxPQUFPLENBQUE7UUFFM0QsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLGNBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxHQUFHLGVBQUssQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBO1FBRTFFLElBQUksSUFBSSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsS0FBSyxLQUFLLElBQUksRUFBRSxDQUFDO1lBQ3RDLE9BQU07UUFDUixDQUFDO1FBRUQsSUFBSSxDQUFDLFNBQVMsR0FBRyxXQUFXLENBQUM7WUFDM0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQTtRQUNuQixDQUFDLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFBO1FBRXRCLElBQUksQ0FBQyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDeEIsQ0FBQztJQVdELE1BQU07UUFDSixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUE7SUFDbEIsQ0FBQztDQUNGO0FBN0NELHdCQTZDQyJ9

api.hyungi.net/node_modules/@pm2/io/build/main/utils/miscellaneous.d.ts

@@ -0,0 +1,4 @@
+export default class MiscUtils {
+    static generateUUID(): string;
+    static getValueFromDump(property: any, parentProperty?: any): number;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/miscellaneous.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serviceManager_1 = require("../serviceManager");
+class MiscUtils {
+    static generateUUID() {
+        return Math.random().toString(36).substr(2, 16);
+    }
+    static getValueFromDump(property, parentProperty) {
+        if (!parentProperty) {
+            parentProperty = 'handles';
+        }
+        const dump = serviceManager_1.ServiceManager.get('eventLoopService').inspector.dump();
+        return dump[parentProperty].hasOwnProperty(property) ? dump[parentProperty][property].length : 0;
+    }
+}
+exports.default = MiscUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlzY2VsbGFuZW91cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9taXNjZWxsYW5lb3VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEsc0RBQWtEO0FBRWxELE1BQXFCLFNBQVM7SUFDNUIsTUFBTSxDQUFDLFlBQVk7UUFDakIsT0FBTyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUE7SUFDakQsQ0FBQztJQUVELE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBRSxRQUFRLEVBQUUsY0FBZTtRQUNoRCxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDcEIsY0FBYyxHQUFHLFNBQVMsQ0FBQTtRQUM1QixDQUFDO1FBQ0QsTUFBTSxJQUFJLEdBQUcsK0JBQWMsQ0FBQyxHQUFHLENBQUMsa0JBQWtCLENBQUMsQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUE7UUFDcEUsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDbEcsQ0FBQztDQUNGO0FBWkQsNEJBWUMifQ==

api.hyungi.net/node_modules/@pm2/io/build/main/utils/module.d.ts

@@ -0,0 +1,5 @@
+export default class ModuleUtils {
+    static loadModule(modulePath: string, args?: Object): any | Error;
+    static detectModule(moduleName: string): string | null;
+    private static _lookForModule;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/module.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const Debug = require("debug");
+const path = require("path");
+const debug = Debug('axm:utils:module');
+class ModuleUtils {
+    static loadModule(modulePath, args) {
+        let nodule;
+        try {
+            if (args) {
+                nodule = require(modulePath).apply(this, args);
+            }
+            else {
+                nodule = require(modulePath);
+            }
+            debug(`Succesfully required module at path ${modulePath}`);
+            return nodule;
+        }
+        catch (err) {
+            debug(`Failed to load module at path ${modulePath}: ${err.message}`);
+            return err;
+        }
+    }
+    static detectModule(moduleName) {
+        const fakePath = ['./node_modules', '/node_modules'];
+        if (!require.main) {
+            return null;
+        }
+        const paths = typeof require.main.paths === 'undefined' ? fakePath : require.main.paths;
+        const requirePaths = paths.slice();
+        return ModuleUtils._lookForModule(requirePaths, moduleName);
+    }
+    static _lookForModule(requirePaths, moduleName) {
+        const fsConstants = fs.constants || fs;
+        for (let requirePath of requirePaths) {
+            const completePath = path.join(requirePath, moduleName);
+            debug(`Looking for module ${moduleName} in ${completePath}`);
+            try {
+                fs.accessSync(completePath, fsConstants.R_OK);
+                debug(`Found module ${moduleName} in path ${completePath}`);
+                return completePath;
+            }
+            catch (err) {
+                debug(`module ${moduleName} not found in path ${completePath}`);
+                continue;
+            }
+        }
+        return null;
+    }
+}
+exports.default = ModuleUtils;
+//# sourceMappingURL=data:application/json;base64,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

api.hyungi.net/node_modules/@pm2/io/build/main/utils/stackParser.d.ts

@@ -0,0 +1,37 @@
+export type MissFunction = (key: string) => any;
+export type CacheOptions = {
+    miss: MissFunction;
+    ttl?: number;
+};
+export type StackContext = {
+    callsite: string;
+    context: string;
+};
+export type FrameMetadata = {
+    line_number: number;
+    file_name: string;
+};
+export declare class Cache {
+    private cache;
+    private ttlCache;
+    private worker;
+    private tllTime;
+    private onMiss;
+    constructor(opts: CacheOptions);
+    workerFn(): void;
+    get(key: string): any;
+    set(key: string, value: any): boolean;
+    reset(): void;
+}
+export type StackTraceParserOptions = {
+    cache: Cache;
+    contextSize: number;
+};
+export declare class StackTraceParser {
+    private cache;
+    private contextSize;
+    constructor(options: StackTraceParserOptions);
+    isAbsolute(path: any): boolean;
+    parse(stack: FrameMetadata[]): StackContext | null;
+    retrieveContext(error: Error): StackContext | null;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/transactionAggregator.d.ts

@@ -0,0 +1,74 @@
+import { EventEmitter2 } from 'eventemitter2';
+import EWMA from './EWMA';
+import Histogram from './metrics/histogram';
+export interface Span {
+    name: string;
+    labels: any;
+    kind: string;
+    startTime: number;
+    min: number;
+    max: number;
+    median: number;
+}
+export interface Variance {
+    spans: Span[];
+    count: number;
+    min: number;
+    max: number;
+    median: number;
+    p95: number;
+}
+export interface Route {
+    path: string;
+    meta: {
+        min: number;
+        max: number;
+        count: number;
+        meter: number;
+        median: number;
+        p95: number;
+    };
+    variances: Variance[];
+}
+export interface Trace {
+    routes: Route[];
+    meta: {
+        trace_count: number;
+        http_meter: number;
+        db_meter: number;
+        http_percentiles: {
+            median: number;
+            p95: number;
+            p99: number;
+        };
+        db_percentiles: any;
+    };
+}
+export interface TraceCache {
+    routes: any;
+    meta: {
+        trace_count: number;
+        http_meter: EWMA;
+        db_meter: EWMA;
+        histogram: Histogram;
+        db_histograms: any;
+    };
+}
+export declare class TransactionAggregator extends EventEmitter2 {
+    private spanTypes;
+    private cache;
+    private privacyRegex;
+    private worker;
+    init(sendInterval?: number): void;
+    destroy(): void;
+    getAggregation(): TraceCache;
+    validateData(packet: any): boolean;
+    aggregate(packet: any): false | TraceCache;
+    mergeTrace(aggregated: any, trace: any): void;
+    updateSpanDuration(spans: any, newSpans: any): void;
+    compareList(one: any[], two: any[]): boolean;
+    matchPath(path: any, routes: any): any;
+    prepareAggregationforShipping(): Trace;
+    isIdentifier(id: any): boolean;
+    censorSpans(spans: any): any;
+}

api.hyungi.net/node_modules/@pm2/io/build/main/utils/units.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    NANOSECONDS: number;
+    MICROSECONDS: number;
+    MILLISECONDS: number;
+    SECONDS: number;
+    MINUTES: number;
+    HOURS: number;
+    DAYS: number;
+};
+export default _default;

api.hyungi.net/node_modules/@pm2/io/build/main/utils/units.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MILLISECONDS = 1;
+const SECONDS = 1000 * MILLISECONDS;
+const MINUTES = 60 * SECONDS;
+const HOURS = 60 * MINUTES;
+exports.default = {
+    NANOSECONDS: 1 / (1000 * 1000),
+    MICROSECONDS: 1 / 1000,
+    MILLISECONDS: MILLISECONDS,
+    SECONDS: SECONDS,
+    MINUTES: MINUTES,
+    HOURS: HOURS,
+    DAYS: 24 * HOURS
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvdW5pdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxNQUFNLFlBQVksR0FBRyxDQUFDLENBQUE7QUFDdEIsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLFlBQVksQ0FBQTtBQUNuQyxNQUFNLE9BQU8sR0FBRyxFQUFFLEdBQUcsT0FBTyxDQUFBO0FBQzVCLE1BQU0sS0FBSyxHQUFHLEVBQUUsR0FBRyxPQUFPLENBQUE7QUFFMUIsa0JBQWU7SUFDYixXQUFXLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUM5QixZQUFZLEVBQUUsQ0FBQyxHQUFHLElBQUk7SUFDdEIsWUFBWSxFQUFFLFlBQVk7SUFDMUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsS0FBSyxFQUFFLEtBQUs7SUFDWixJQUFJLEVBQUUsRUFBRSxHQUFHLEtBQUs7Q0FDakIsQ0FBQSJ9