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

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

@@ -0,0 +1,17 @@
+import { MetricInterface } from '../features/metrics';
+export declare class EventLoopMetricOption {
+    eventLoopActive: boolean;
+    eventLoopDelay: boolean;
+}
+export default class EventLoopHandlesRequestsMetric implements MetricInterface {
+    private metricService;
+    private logger;
+    private requestTimer;
+    private handleTimer;
+    private delayTimer;
+    private delayLoopInterval;
+    private runtimeStatsService;
+    private handle;
+    init(config?: EventLoopMetricOption | boolean): any;
+    destroy(): void;
+}

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

@@ -0,0 +1,18 @@
+import { MetricInterface } from '../features/metrics';
+export declare class HttpMetricsConfig {
+    http: boolean;
+}
+export default class HttpMetrics implements MetricInterface {
+    private defaultConf;
+    private metrics;
+    private logger;
+    private metricService;
+    private modules;
+    private hooks;
+    init(config?: HttpMetricsConfig | boolean): any;
+    private registerHttpMetric;
+    private registerHttpsMetric;
+    destroy(): void;
+    private hookHttp;
+    private hookRequire;
+}

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

@@ -0,0 +1,15 @@
+import { MetricInterface } from '../features/metrics';
+export declare class NetworkTrafficConfig {
+    upload: boolean;
+    download: boolean;
+}
+export default class NetworkMetric implements MetricInterface {
+    private metricService;
+    private timer;
+    private logger;
+    private socketProto;
+    init(config?: NetworkTrafficConfig | boolean): any;
+    destroy(): void;
+    private catchDownload;
+    private catchUpload;
+}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkTrafficConfig = void 0;
+const netModule = require("net");
+const metrics_1 = require("../services/metrics");
+const Debug = require("debug");
+const meter_1 = require("../utils/metrics/meter");
+const shimmer = require("shimmer");
+const serviceManager_1 = require("../serviceManager");
+class NetworkTrafficConfig {
+}
+exports.NetworkTrafficConfig = NetworkTrafficConfig;
+const defaultConfig = {
+    upload: false,
+    download: false
+};
+const allEnabled = {
+    upload: true,
+    download: true
+};
+class NetworkMetric {
+    constructor() {
+        this.logger = Debug('axm:features:metrics:network');
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === true) {
+            config = allEnabled;
+        }
+        if (config === undefined) {
+            config = defaultConfig;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined) {
+            return this.logger(`Failed to load metric service`);
+        }
+        if (config.download === true) {
+            this.catchDownload();
+        }
+        if (config.upload === true) {
+            this.catchUpload();
+        }
+        this.logger('init');
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearTimeout(this.timer);
+        }
+        if (this.socketProto !== undefined && this.socketProto !== null) {
+            shimmer.unwrap(this.socketProto, 'read');
+            shimmer.unwrap(this.socketProto, 'write');
+        }
+        this.logger('destroy');
+    }
+    catchDownload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const downloadMeter = new meter_1.default({});
+        this.metricService.registerMetric({
+            name: 'Network In',
+            id: 'internal/network/in',
+            historic: true,
+            type: metrics_1.MetricType.meter,
+            implementation: downloadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.read;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket read, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'read', function (original) {
+                return function () {
+                    this.on('data', (data) => {
+                        if (typeof data.length === 'number') {
+                            downloadMeter.mark(data.length);
+                        }
+                    });
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+    catchUpload() {
+        if (this.metricService === undefined)
+            return this.logger(`Failed to load metric service`);
+        const uploadMeter = new meter_1.default();
+        this.metricService.registerMetric({
+            name: 'Network Out',
+            id: 'internal/network/out',
+            type: metrics_1.MetricType.meter,
+            historic: true,
+            implementation: uploadMeter,
+            unit: 'kb/s',
+            handler: function () {
+                return Math.floor(this.implementation.val() / 1024 * 1000) / 1000;
+            }
+        });
+        setTimeout(() => {
+            const property = netModule.Socket.prototype.write;
+            const isWrapped = property && property.__wrapped === true;
+            if (isWrapped) {
+                return this.logger(`Already patched socket write, canceling`);
+            }
+            shimmer.wrap(netModule.Socket.prototype, 'write', function (original) {
+                return function (data) {
+                    if (typeof data.length === 'number') {
+                        uploadMeter.mark(data.length);
+                    }
+                    return original.apply(this, arguments);
+                };
+            });
+        }, 500);
+    }
+}
+exports.default = NetworkMetric;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { MetricInterface } from '../features/metrics';
+export declare class RuntimeMetricsOptions {
+    gcOldPause: boolean;
+    gcNewPause: boolean;
+    pageFaults: boolean;
+    contextSwitchs: boolean;
+}
+export default class RuntimeMetrics implements MetricInterface {
+    private metricService;
+    private logger;
+    private runtimeStatsService;
+    private handle;
+    private metrics;
+    init(config?: RuntimeMetricsOptions | boolean): any;
+    destroy(): void;
+}

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

@@ -0,0 +1,23 @@
+import { MetricInterface } from '../features/metrics';
+export declare class V8MetricsConfig {
+    new_space: boolean;
+    old_space: boolean;
+    map_space: boolean;
+    code_space: boolean;
+    large_object_space: boolean;
+    heap_total_size: boolean;
+    heap_used_size: boolean;
+    heap_used_percent: boolean;
+}
+export default class V8Metric implements MetricInterface {
+    private timer;
+    private TIME_INTERVAL;
+    private metricService;
+    private logger;
+    private metricStore;
+    private unitKB;
+    private metricsDefinitions;
+    init(config?: V8MetricsConfig | boolean): any;
+    destroy(): void;
+    private formatMiBytes;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V8MetricsConfig = void 0;
+const v8 = require("v8");
+const debug_1 = require("debug");
+const serviceManager_1 = require("../serviceManager");
+class V8MetricsConfig {
+}
+exports.V8MetricsConfig = V8MetricsConfig;
+const defaultOptions = {
+    new_space: false,
+    old_space: false,
+    map_space: false,
+    code_space: false,
+    large_object_space: false,
+    heap_total_size: true,
+    heap_used_size: true,
+    heap_used_percent: true
+};
+class V8Metric {
+    constructor() {
+        this.TIME_INTERVAL = 800;
+        this.logger = (0, debug_1.default)('axm:features:metrics:v8');
+        this.metricStore = new Map();
+        this.unitKB = 'MiB';
+        this.metricsDefinitions = {
+            total_heap_size: {
+                name: 'Heap Size',
+                id: 'internal/v8/heap/total',
+                unit: this.unitKB,
+                historic: true
+            },
+            heap_used_percent: {
+                name: 'Heap Usage',
+                id: 'internal/v8/heap/usage',
+                unit: '%',
+                historic: true
+            },
+            used_heap_size: {
+                name: 'Used Heap Size',
+                id: 'internal/v8/heap/used',
+                unit: this.unitKB,
+                historic: true
+            }
+        };
+    }
+    init(config) {
+        if (config === false)
+            return;
+        if (config === undefined) {
+            config = defaultOptions;
+        }
+        if (config === true) {
+            config = defaultOptions;
+        }
+        this.metricService = serviceManager_1.ServiceManager.get('metrics');
+        if (this.metricService === undefined)
+            return this.logger('Failed to load metric service');
+        this.logger('init');
+        if (!v8.hasOwnProperty('getHeapStatistics')) {
+            return this.logger(`V8.getHeapStatistics is not available, aborting`);
+        }
+        for (let metricName in this.metricsDefinitions) {
+            if (config[metricName] === false)
+                continue;
+            const isEnabled = config[metricName];
+            if (isEnabled === false)
+                continue;
+            let metric = this.metricsDefinitions[metricName];
+            this.metricStore.set(metricName, this.metricService.metric(metric));
+        }
+        this.timer = setInterval(() => {
+            const stats = v8.getHeapStatistics();
+            for (let metricName in this.metricsDefinitions) {
+                if (typeof stats[metricName] !== 'number')
+                    continue;
+                const gauge = this.metricStore.get(metricName);
+                if (gauge === undefined)
+                    continue;
+                gauge.set(this.formatMiBytes(stats[metricName]));
+            }
+            const usage = (stats.used_heap_size / stats.total_heap_size * 100).toFixed(2);
+            const usageMetric = this.metricStore.get('heap_used_percent');
+            if (usageMetric !== undefined) {
+                usageMetric.set(parseFloat(usage));
+            }
+        }, this.TIME_INTERVAL);
+        this.timer.unref();
+    }
+    destroy() {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+        }
+        this.logger('destroy');
+    }
+    formatMiBytes(val) {
+        return (val / 1024 / 1024).toFixed(2);
+    }
+}
+exports.default = V8Metric;
+//# sourceMappingURL=data:application/json;base64,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