@breautek/storm 9.6.4 → 9.7.0

package/src/MetricStore.ts

@@ -1,61 +1,159 @@
 
-export type TSupportedMetricStoreValues = string | number | boolean;
+import * as prom from 'prom-client';
 
-export class MetricStore {
-    private static $instance: MetricStore;
+export interface IMetricConfig {
+    name: string;
+    help: string;
+    labelNames?: string[];
+}
 
-    private $data: Record<string, TSupportedMetricStoreValues>;
+export interface IMetricData {
+    type: string;
+    content: string;
+}
 
-    private constructor() {
-        this.$data = {};
+export interface IHistogramConfig extends IMetricConfig {
+    buckets?: number[];
+}
+
+export interface IMetricCounter {
+    inc(value?: number): void;
+    inc(labels: Record<string, string | number>, value?: number): void;
+}
+
+export interface IMetricGauge {
+    set(value: number): void;
+    set(labels: Record<string, string | number>, value: number): void;
+    inc(value?: number): void;
+    inc(labels: Record<string, string | number>, value?: number): void;
+    dec(value?: number): void;
+    dec(labels: Record<string, string | number>, value?: number): void;
+}
+
+export interface IMetricHistogram {
+    observe(value: number): void;
+    observe(labels: Record<string, string | number>, value: number): void;
+    startTimer(labels?: Record<string, string | number>): (labels?: Record<string, string | number>) => number;
+}
+
+class CounterWrapper implements IMetricCounter {
+    private $inner: prom.Counter;
+    public constructor(config: IMetricConfig) {
+        this.$inner = new prom.Counter({
+            name: config.name,
+            help: config.help,
+            labelNames: config.labelNames ?? []
+        });
     }
+    public inc(labelsOrValue?: Record<string, string | number> | number, value?: number): void {
+        if (typeof labelsOrValue === 'number') {
+            this.$inner.inc(labelsOrValue);
+        }
+        else if (labelsOrValue !== undefined) {
+            this.$inner.inc(labelsOrValue, value);
+        }
+        else {
+            this.$inner.inc();
+        }
+    }
+}
+
+class GaugeWrapper implements IMetricGauge {
+    private $inner: prom.Gauge;
+    public constructor(config: IMetricConfig) {
+        this.$inner = new prom.Gauge({
+            name: config.name,
+            help: config.help,
+            labelNames: config.labelNames ?? []
+        });
+    }
+    public set(labelsOrValue: Record<string, string | number> | number, value?: number): void {
+        if (typeof labelsOrValue === 'number') {
+            this.$inner.set(labelsOrValue);
+        }
+        else {
+            this.$inner.set(labelsOrValue, value);
+        }
+    }
+    public inc(labelsOrValue?: Record<string, string | number> | number, value?: number): void {
+        if (typeof labelsOrValue === 'number') {
+            this.$inner.inc(labelsOrValue);
+        }
+        else if (labelsOrValue !== undefined) {
+            this.$inner.inc(labelsOrValue, value);
+        }
+        else {
+            this.$inner.inc();
+        }
+    }
+    public dec(labelsOrValue?: Record<string, string | number> | number, value?: number): void {
+        if (typeof labelsOrValue === 'number') {
+            this.$inner.dec(labelsOrValue);
+        }
+        else if (labelsOrValue !== undefined) {
+            this.$inner.dec(labelsOrValue, value);
+        }
+        else {
+            this.$inner.dec();
+        }
+    }
+}
+
+class HistogramWrapper implements IMetricHistogram {
+    private $inner: prom.Histogram;
+    public constructor(config: IHistogramConfig) {
+        this.$inner = new prom.Histogram({
+            name: config.name,
+            help: config.help,
+            labelNames: config.labelNames ?? [],
+            ...(config.buckets !== undefined ? { buckets: config.buckets } : {})
+        });
+    }
+    public observe(labelsOrValue: Record<string, string | number> | number, value?: number): void {
+        if (typeof labelsOrValue === 'number') {
+            this.$inner.observe(labelsOrValue);
+        }
+        else {
+            this.$inner.observe(labelsOrValue, value);
+        }
+    }
+    public startTimer(labels?: Record<string, string | number>): (labels?: Record<string, string | number>) => number {
+        return this.$inner.startTimer(labels);
+    }
+}
+
+export class MetricStore {
+    private static $instance: MetricStore;
+
+    private constructor() {}
 
     public static getInstance(): MetricStore {
         if (!MetricStore.$instance) {
             MetricStore.$instance = new MetricStore();
         }
-
         return MetricStore.$instance;
     }
 
-    public purge(): void {
-        this.$data = {};
+    public setDefaultLabels(labels: Record<string, string>): void {
+        prom.register.setDefaultLabels(labels);
     }
 
-    public set(key: string, value: TSupportedMetricStoreValues): void {
-        this.$data[key] = value;
+    public createCounter(config: IMetricConfig): IMetricCounter {
+        return new CounterWrapper(config);
     }
 
-    public get(key: string): TSupportedMetricStoreValues | null {
-        let value: TSupportedMetricStoreValues = this.$data[key];
-        if (value === undefined) return null;
-        return value;
+    public createGauge(config: IMetricConfig): IMetricGauge {
+        return new GaugeWrapper(config);
     }
 
-    public increment(key: string): void {
-        let value: TSupportedMetricStoreValues = this.get(key);
-        
-        if (!value) {
-            value = 0;
-        }
-
-        if (typeof value !== 'number') {
-            this.set(key, 0);
-            return;
-        }
-
-        value++;
-        this.set(key, value);
+    public createHistogram(config: IHistogramConfig): IMetricHistogram {
+        return new HistogramWrapper(config);
     }
 
-    public decrement(key: string): void {
-        let value: TSupportedMetricStoreValues = this.get(key);
-        if (value === null || value === undefined || typeof value !== 'number') {
-            this.set(key, 0);
-            return;
-        }
-
-        value--;
-        this.set(key, value);
+    public async getMetrics(): Promise<IMetricData> {
+        return {
+            type: prom.register.contentType,
+            content: await prom.register.metrics()
+        };
     }
 }

package/src/MySQLConnection.ts

@@ -40,7 +40,7 @@ import { GetProcessList, IGetProcessListOutput } from './private/GetProcessList'
 import { GetMySQLVersion, IGetMySQLVersionResult } from './GetMySQLVersion';
 import { GetPrimaryPositionQuery } from './private/GetPrimaryPositionQuery';
 import { queryFormatter } from './mysql/queryFormatter';
-import { MetricStore } from './MetricStore';
+import { IMetricGauge } from './MetricStore';
 
 const DEFAULT_HIGH_WATERMARK: number = 512; // in number of result objects
 const TAG: string = 'MySQLConnection';
@@ -69,8 +69,9 @@ export class MySQLConnection extends DatabaseConnection<MySQL.PoolConnection> {
     private $hasReplicationEnabled: boolean;
     private $isMasterConnection: boolean;
     private $version: IGetMySQLVersionResult;
+    private $activeConnectionsGauge: IMetricGauge | null;
 
-    public constructor(connection: MySQL.PoolConnection, instantiationStack: string, isReadOnly: boolean = true) {
+    public constructor(connection: MySQL.PoolConnection, instantiationStack: string, isReadOnly: boolean = true, activeConnectionsGauge: IMetricGauge | null = null) {
         connection.config.namedPlaceholders = true;
 
         if (!getInstance().getConfig().enableMySQL2BreakingChanges) {
@@ -109,6 +110,7 @@ export class MySQLConnection extends DatabaseConnection<MySQL.PoolConnection> {
         this.$opened = true;
         this.$transaction = false;
         this.$isMasterConnection = null;
+        this.$activeConnectionsGauge = activeConnectionsGauge;
     }
 
     /**
@@ -349,6 +351,7 @@ export class MySQLConnection extends DatabaseConnection<MySQL.PoolConnection> {
         }
 
         this.$opened = false;
+        this.$activeConnectionsGauge?.dec();
 
         if (forceClose) {
             if (this.isTransaction()) {
@@ -362,6 +365,5 @@ export class MySQLConnection extends DatabaseConnection<MySQL.PoolConnection> {
         }
 
         this.getAPI().release();
-        MetricStore.getInstance().decrement('mysql.active_connections');
     }
 }

package/src/MySQLDatabase.ts

@@ -21,12 +21,13 @@ import {getInstance} from './instance';
 import { IDatabasePosition } from './IDatabasePosition';
 import { ConnectionReplicationWaiter } from './private/ConnectionReplicationWaiter';
 import { ILogger } from '@arashi/interfaces';
-import { MetricStore } from './MetricStore';
+import { IMetricGauge, MetricStore } from './MetricStore';
 
 const TAG: string = 'MySQLDatabase';
 
 export class MySQLDatabase extends Database<MySQL.PoolOptions, MySQL.PoolConnection> {
     private $cluster: MySQL.PoolCluster;
+    private $activeConnectionsGauge: IMetricGauge;
 
     constructor() {
         super();
@@ -38,6 +39,11 @@ export class MySQLDatabase extends Database<MySQL.PoolOptions, MySQL.PoolConnect
         this.$cluster.on('enqueue', () => {
             getInstance().getLogger().warn(TAG, 'Waiting for available connection...');
         });
+
+        this.$activeConnectionsGauge = MetricStore.getInstance().createGauge({
+            name: 'storm_mysql_active_connections',
+            help: 'Number of MySQL connections currently claimed from the pool'
+        });
     }
 
     public escape(value: any): string {
@@ -70,8 +76,8 @@ export class MySQLDatabase extends Database<MySQL.PoolOptions, MySQL.PoolConnect
                     return;
                 }
     
-                MetricStore.getInstance().increment('mysql.active_connections');
-                resolve(new MySQLConnection(connection, instantationStack, !requireWriteAccess));
+                this.$activeConnectionsGauge.inc();
+                resolve(new MySQLConnection(connection, instantationStack, !requireWriteAccess, this.$activeConnectionsGauge));
             });
         });
     }

package/src/PrometheusServer.ts

@@ -0,0 +1,109 @@
+/*
+   Copyright 2017-2026 Norman Breau
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+import { Application } from './Application';
+import * as http from 'node:http';
+import { IConfig } from './IConfig';
+import { IMetricData, MetricStore } from './MetricStore';
+
+const TAG: string = 'PrometheusServer';
+const RETRY_DELAY: number = 5000;
+
+export class PrometheusServer {
+    private $app: Application;
+    private $socket: http.Server;
+    private $bind: string;
+    private $port: number;
+    private $isClosing: boolean;
+    private $retryTimer: NodeJS.Timeout;
+    
+    public constructor(app: Application) {
+        this.$app = app;
+        this.$socket = null;
+        this.$isClosing = false;
+        this.$retryTimer = null;
+
+        let config: IConfig = app.getConfig();
+
+        this.$bind = config.prometheus?.bind || '127.0.0.1';
+        this.$port = config.prometheus?.port;
+
+        if (!this.$port) {
+            app.getLogger().warn(TAG, 'Using default port algorithm for Prometheus. Better to explicitly set a port via --prometheus-port.');
+            this.$port = app.getDefaultPortForPrometheus();
+        }
+    }
+
+    public start(): void {
+        this.$app.getLogger().info(TAG, 'Initializing Prometheus');
+        void this.$createSocket();
+    }
+
+    private $createSocket(): Promise<void> {
+        if (this.$isClosing) {
+            return Promise.resolve();
+        }
+
+        return new Promise<void>((resolve, reject) => {
+            this.$socket = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+                let data: IMetricData = await MetricStore.getInstance().getMetrics();
+                res.setHeader('Content-Type', data.type);
+                res.end(data.content);
+            });
+
+            this.$socket.once('error', (err: Error) => {
+                this.$socket = null;
+                resolve();
+
+                if (this.$isClosing) {
+                    return;
+                }
+
+                this.$app.getLogger().error(TAG, 'Prometheus Socket Error');
+                this.$app.getLogger().error(TAG, err);
+
+                this.$retryTimer = setTimeout(() => {
+                    void this.$createSocket();
+                }, RETRY_DELAY);
+            });
+
+            this.$socket.listen(this.$port, this.$bind, null, () => {
+                this.$app.getLogger().info(TAG, `Prometheus Server bounded`);
+                resolve();
+            });
+        });
+    }
+
+    public async close(): Promise<void> {
+        this.$isClosing = true;
+        clearTimeout(this.$retryTimer);
+        return new Promise<void>((resolve, reject) => {
+            if (!this.$socket) {
+                resolve();
+                return;
+            }
+
+            this.$socket.close((err?: Error) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+
+                resolve();
+            });
+        });
+    }
+}

package/src/Request.ts

@@ -149,6 +149,13 @@ export class Request<TBody = any, TAuthToken extends IAuthTokenData = IAuthToken
         return this.$request.params[name];
     }
 
+    /**
+     * Returns the matched route
+     */
+    public getRoute(): string {
+        return this.$request.route.path;
+    }
+
     /**
      * Gets a URL parameter as string. If the value is multiple
      * then only the first value is returned.

package/src/api.ts

@@ -105,7 +105,14 @@ export {TokenManager, TExpiresIn} from './TokenManager';
 
 // Utils
 export {ExitCode} from './ExitCode';
-export {MetricStore} from './MetricStore';
+export {
+    MetricStore,
+    IHistogramConfig,
+    IMetricConfig,
+    IMetricCounter,
+    IMetricGauge,
+    IMetricHistogram
+} from './MetricStore';
 
 // Database Objects
 export {TCoordinate} from './TCoordinate';

package/lib/handlers/HealthHandler.d.ts

@@ -1,13 +0,0 @@
-import { IAuthTokenData } from '@arashi/token';
-import { Application } from '../Application';
-import { Handler } from '../Handler';
-import { Request } from '../Request';
-export interface IHealthHandlerMySQLStats {
-    activeConnections: number;
-}
-export interface IHealthHandlerOutput {
-    mysql: IHealthHandlerMySQLStats;
-}
-export declare class HealthHandler extends Handler<Application, void, IHealthHandlerOutput> {
-    protected _get(request: Request<void, IAuthTokenData>): Promise<IHealthHandlerOutput>;
-}

package/lib/handlers/HealthHandler.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HealthHandler = void 0;
-const Handler_1 = require("../Handler");
-const MetricStore_1 = require("../MetricStore");
-const ForbiddenError_1 = require("../ForbiddenError");
-class HealthHandler extends Handler_1.Handler {
-    async _get(request) {
-        if (request.getIP() !== '127.0.0.1') {
-            throw new ForbiddenError_1.ForbiddenError();
-        }
-        let metrics = MetricStore_1.MetricStore.getInstance();
-        let out = {
-            mysql: {
-                activeConnections: metrics.get('mysql.active_connections')
-            }
-        };
-        return out;
-    }
-}
-exports.HealthHandler = HealthHandler;
-//# sourceMappingURL=HealthHandler.js.map

package/lib/handlers/HealthHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"HealthHandler.js","sourceRoot":"","sources":["../../src/handlers/HealthHandler.ts"],"names":[],"mappings":";;;AAGA,wCAAmC;AAEnC,gDAA6C;AAC7C,sDAAmD;AAUnD,MAAa,aAAc,SAAQ,iBAIlC;IACsB,KAAK,CAAC,IAAI,CAAC,OAAsC;QAEhE,IAAI,OAAO,CAAC,KAAK,EAAE,KAAK,WAAW,EAAE,CAAC;YAClC,MAAM,IAAI,+BAAc,EAAE,CAAC;QAC/B,CAAC;QAED,IAAI,OAAO,GAAgB,yBAAW,CAAC,WAAW,EAAE,CAAC;QACrD,IAAI,GAAG,GAAyB;YAC5B,KAAK,EAAE;gBACH,iBAAiB,EAAE,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAW;aACvE;SACJ,CAAC;QAEF,OAAO,GAAG,CAAC;IACf,CAAC;CACJ;AApBD,sCAoBC"}

package/src/handlers/HealthHandler.ts

@@ -1,37 +0,0 @@
-
-import { IAuthTokenData } from '@arashi/token';
-import { Application } from '../Application';
-import {Handler} from '../Handler';
-import { Request } from '../Request';
-import { MetricStore } from '../MetricStore';
-import { ForbiddenError } from '../ForbiddenError';
-
-export interface IHealthHandlerMySQLStats {
-    activeConnections: number;
-}
-
-export interface IHealthHandlerOutput {
-    mysql: IHealthHandlerMySQLStats;
-}
-
-export class HealthHandler extends Handler<
-    Application,
-    void,
-    IHealthHandlerOutput
-> {
-    protected override async _get(request: Request<void, IAuthTokenData>): Promise<IHealthHandlerOutput> {
-
-        if (request.getIP() !== '127.0.0.1') {
-            throw new ForbiddenError();
-        }
-
-        let metrics: MetricStore = MetricStore.getInstance();
-        let out: IHealthHandlerOutput = {
-            mysql: {
-                activeConnections: metrics.get('mysql.active_connections') as number
-            }
-        };
-
-        return out;
-    }
-}