@omnitronix/game-engine-sdk 1.0.1

package/dist/esm/common/logger/logger.js

@@ -0,0 +1,133 @@
+import { DomainException } from '../error-handling/domain.exception';
+import { createLogger, format, transports } from 'winston';
+export class Logger {
+    constructor(context, logFormat) {
+        this.context = context;
+        const format = logFormat ?? this.detectLogFormat();
+        this.logger = this.createWinstonLogger(format);
+    }
+    detectLogFormat() {
+        const envFormat = process.env.LOG_FORMAT?.toLowerCase();
+        switch (envFormat) {
+            case 'pretty':
+                return 'pretty';
+            case 'json':
+                return 'json';
+            default:
+                return 'json';
+        }
+    }
+    createWinstonLogger(logFormat) {
+        const winstonFormat = this.getLogFormat(logFormat);
+        return createLogger({
+            level: 'info',
+            format: winstonFormat,
+            transports: this.getTransports(),
+        });
+    }
+    getLogFormat(logFormat) {
+        return format.combine(format.timestamp(), this.selectFormat(logFormat));
+    }
+    selectFormat(logFormat) {
+        switch (logFormat) {
+            case 'pretty':
+                return this.getPrettyFormat();
+            case 'json':
+                return this.getJsonFormat();
+            default:
+                return this.getJsonFormat();
+        }
+    }
+    getJsonFormat() {
+        return format.combine(format(info => {
+            if (this.context) {
+                info.message = `[${this.context}] ${info.message}`;
+            }
+            return info;
+        })(), format.json());
+    }
+    getPrettyFormat() {
+        return format.combine(format.colorize(), format.printf(({ timestamp, level, message, error, ...meta }) => {
+            const contextStr = this.context ? `[${this.context}] ` : '';
+            let output = `${timestamp} ${level}: ${contextStr}${message}`;
+            if (error && typeof error === 'object' && 'name' in error && 'message' in error) {
+                output += `\n  Error: ${error.name}: ${error.message}`;
+                if (error.name === 'DomainException' && 'errorCode' in error) {
+                    output += `\n  Internal Code: ${error.errorCode}`;
+                }
+                if ('stack' in error && error.stack) {
+                    output += `\n  Stack: ${error.stack}`;
+                }
+            }
+            const metaKeys = Object.keys(meta).filter(key => key !== 'timestamp' && key !== 'level' && key !== 'message');
+            if (metaKeys.length > 0) {
+                output += `\n  Meta: ${JSON.stringify(meta, null, 2)}`;
+            }
+            return output;
+        }));
+    }
+    safeStringify(obj) {
+        try {
+            return JSON.stringify(obj, (key, value) => {
+                if (typeof value === 'bigint') {
+                    return value.toString();
+                }
+                return value;
+            });
+        }
+        catch (_error) {
+            return '[Object cannot be serialized]';
+        }
+    }
+    getTransports() {
+        return [new transports.Console(), new transports.File({ filename: 'logs/app.log' })];
+    }
+    log(message, { level = 'info', ...rest } = {}) {
+        switch (level) {
+            case 'error':
+                this.logger.error(message, rest);
+                break;
+            case 'warn':
+                this.logger.warn(message, rest);
+                break;
+            case 'debug':
+                this.logger.debug(message, rest);
+                break;
+            case 'verbose':
+                this.logger.verbose(message, rest);
+                break;
+            default:
+                this.logger.info(message, rest);
+                break;
+        }
+    }
+    error(message, ...optionalParams) {
+        if (optionalParams.length > 0 && optionalParams[0] instanceof Error) {
+            const error = optionalParams[0];
+            const errorData = {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            };
+            if (error instanceof DomainException) {
+                errorData.errorCode = error.errorCode;
+            }
+            this.logger.error(message, {
+                error: errorData,
+                ...optionalParams.slice(1),
+            });
+        }
+        else {
+            this.logger.error(message, ...optionalParams);
+        }
+    }
+    warn(message, ...optionalParams) {
+        this.logger.warn(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        this.logger.debug(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        this.logger.verbose(message, ...optionalParams);
+    }
+}

package/dist/esm/common/logger/logger.module.js

@@ -0,0 +1,16 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+let LoggerModule = class LoggerModule {
+};
+LoggerModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+    })
+], LoggerModule);
+export { LoggerModule };

package/dist/esm/common/logger/logging.middleware.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var LoggingMiddleware_1;
+import { Injectable } from '@nestjs/common';
+import { Logger } from './logger';
+const BLOCKED_ENDPOINTS = ['/api/races/active'];
+let LoggingMiddleware = LoggingMiddleware_1 = class LoggingMiddleware {
+    constructor() {
+        this.logger = new Logger(LoggingMiddleware_1.name);
+    }
+    use(req, res, next) {
+        const { method, originalUrl, body } = req;
+        const sanitizedBody = { ...body };
+        if (sanitizedBody.password) {
+            sanitizedBody.password = '***';
+        }
+        if (sanitizedBody.token) {
+            sanitizedBody.token = '***';
+        }
+        res.on('finish', () => {
+            const isBlockedEndpoint = BLOCKED_ENDPOINTS.some(endpoint => originalUrl.includes(endpoint));
+            const isSuccessfulRequest = res.statusCode < 400;
+            if (!(isBlockedEndpoint && isSuccessfulRequest)) {
+                this.logger.log(`Request: ${method} ${originalUrl} | Body: ${JSON.stringify(sanitizedBody)}`);
+            }
+        });
+        next();
+    }
+};
+LoggingMiddleware = LoggingMiddleware_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], LoggingMiddleware);
+export { LoggingMiddleware };

package/dist/esm/common/metrics/database-metrics.service.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { METRICS_PORT } from './metrics.port';
+import { Inject, Injectable } from '@nestjs/common';
+let DatabaseMetricsService = class DatabaseMetricsService {
+    constructor(metricsPort) {
+        this.metricsPort = metricsPort;
+    }
+    updateConnectionPoolSize(poolType, state, size) {
+        this.metricsPort.getGauge('rgs_db_connection_pool_size').set({
+            pool_type: poolType,
+            state,
+        }, size);
+    }
+    trackConnectionError(errorType) {
+        this.metricsPort.getCounter('rgs_db_connection_errors_total').inc({
+            error_type: errorType,
+        });
+    }
+};
+DatabaseMetricsService = __decorate([
+    Injectable(),
+    __param(0, Inject(METRICS_PORT)),
+    __metadata("design:paramtypes", [Object])
+], DatabaseMetricsService);
+export { DatabaseMetricsService };

package/dist/esm/common/metrics/helpers/metrics.helpers.js

@@ -0,0 +1,32 @@
+export function toMinorUnits(amount) {
+    return Math.round(amount * 100);
+}
+export function getEventCountBucket(count) {
+    if (count <= 5)
+        return '1-5';
+    if (count <= 10)
+        return '6-10';
+    if (count <= 25)
+        return '11-25';
+    if (count <= 50)
+        return '26-50';
+    if (count <= 100)
+        return '51-100';
+    return '100+';
+}
+export function getStreamVersionBucket(version) {
+    if (version <= 10)
+        return '1-10';
+    if (version <= 50)
+        return '11-50';
+    if (version <= 100)
+        return '51-100';
+    if (version <= 500)
+        return '101-500';
+    return '500+';
+}
+export function sanitizeRoute(route) {
+    return route
+        .replace(/\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '/:id')
+        .replace(/\/\d+/g, '/:id');
+}

package/dist/esm/common/metrics/metrics.module.js

@@ -0,0 +1,204 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { ExceptionsFilter } from '../error-handling/all-exceptions.filter';
+import { Module } from '@nestjs/common';
+import { makeCounterProvider, makeGaugeProvider, makeHistogramProvider, } from '@willsoto/nestjs-prometheus';
+import { METRICS_PORT } from './metrics.port';
+import { PrometheusService } from './prometheus.service';
+let MetricsModule = class MetricsModule {
+};
+MetricsModule = __decorate([
+    Module({
+        providers: [
+            {
+                provide: METRICS_PORT,
+                useClass: PrometheusService,
+            },
+            ExceptionsFilter,
+            makeHistogramProvider({
+                name: 'rgs_http_server_requests_duration_ms',
+                help: 'Duration of HTTP requests in milliseconds',
+                labelNames: ['method', 'route', 'status_code', 'operator_code'],
+                buckets: [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_ws_connections',
+                help: 'Current number of WebSocket connections',
+                labelNames: ['state', 'operator_code'],
+            }),
+            makeCounterProvider({
+                name: 'rgs_ws_messages_total',
+                help: 'Total WebSocket messages sent or received',
+                labelNames: ['type', 'operator_code', 'event_name'],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_ws_event_duration_ms',
+                help: 'Duration of WebSocket event processing in milliseconds',
+                labelNames: ['event_name', 'operator_code'],
+                buckets: [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+            }),
+            makeCounterProvider({
+                name: 'rgs_sessions_total',
+                help: 'Total number of game sessions by final status',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction', 'status'],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_sessions_active',
+                help: 'Current number of active game sessions',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction'],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_session_duration_ms',
+                help: 'Game session duration from init to end in milliseconds',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction', 'end_status'],
+                buckets: [10000, 30000, 60000, 120000, 300000, 600000, 1800000, 3600000],
+            }),
+            makeCounterProvider({
+                name: 'rgs_rounds_completed_total',
+                help: 'Total game rounds completed',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction', 'result'],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_wager_minor_units',
+                help: 'Wager amounts in minor units',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction', 'currency'],
+                buckets: [10, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_win_minor_units',
+                help: 'Win amounts in minor units',
+                labelNames: ['operator_code', 'game_code', 'jurisdiction', 'currency'],
+                buckets: [10, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000],
+            }),
+            makeCounterProvider({
+                name: 'rgs_wallet_requests_total',
+                help: 'Total wallet API requests',
+                labelNames: ['operation_type', 'operator_code', 'currency', 'status'],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_wallet_requests_duration_ms',
+                help: 'Duration of wallet API requests in milliseconds',
+                labelNames: ['operation_type', 'operator_code', 'status'],
+                buckets: [10, 50, 100, 250, 500, 1000, 2000, 5000, 10000],
+            }),
+            makeHistogramProvider({
+                name: 'game_engine_command_duration_ms',
+                help: 'Duration of game engine command processing in milliseconds',
+                labelNames: ['command_type', 'game_code', 'game_version'],
+                buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1000],
+            }),
+            makeCounterProvider({
+                name: 'game_engine_commands_total',
+                help: 'Total game engine commands processed',
+                labelNames: ['command_type', 'game_code', 'game_version'],
+            }),
+            makeCounterProvider({
+                name: 'game_engine_errors_total',
+                help: 'Total game engine errors or exceptions',
+                labelNames: ['game_code', 'game_version', 'error_type'],
+            }),
+            makeCounterProvider({
+                name: 'game_engine_rng_calls_total',
+                help: 'Total RNG calls made by game engine',
+                labelNames: ['game_code', 'game_version'],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_event_store_write_duration_ms',
+                help: 'Event store write duration',
+                labelNames: ['aggregate_type', 'event_count_bucket'],
+                buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2000],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_event_store_read_duration_ms',
+                help: 'Event store read duration',
+                labelNames: ['aggregate_type', 'stream_version_bucket'],
+                buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2000],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_aggregate_reconstruction_duration_ms',
+                help: 'Aggregate reconstruction time',
+                labelNames: ['aggregate_type', 'events_count_bucket'],
+                buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2000],
+            }),
+            makeHistogramProvider({
+                name: 'rgs_aggregate_reconstruction_events',
+                help: 'Number of events in reconstruction',
+                labelNames: ['aggregate_type'],
+                buckets: [1, 5, 10, 25, 50, 100, 250, 500],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_db_connection_pool_size',
+                help: 'Connection pool size',
+                labelNames: ['pool_type', 'state'],
+            }),
+            makeCounterProvider({
+                name: 'rgs_db_connection_errors_total',
+                help: 'Database connection errors',
+                labelNames: ['error_type'],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_games_total',
+                help: 'Total games in catalog',
+                labelNames: ['status'],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_game_configs_total',
+                help: 'Total game configurations per jurisdiction',
+                labelNames: ['jurisdiction'],
+            }),
+            makeGaugeProvider({
+                name: 'rgs_enabled_games_per_operator',
+                help: 'Enabled games count per operator',
+                labelNames: ['operator_code', 'jurisdiction'],
+            }),
+            makeGaugeProvider({
+                name: 'rng_buffer_capacity',
+                help: 'Capacity of the RNG buffer',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+            }),
+            makeGaugeProvider({
+                name: 'rng_buffer_fill_level',
+                help: 'Current fill level of the RNG buffer',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+            }),
+            makeGaugeProvider({
+                name: 'rng_buffer_fill_ratio',
+                help: 'Current fill ratio of the RNG buffer',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+            }),
+            makeCounterProvider({
+                name: 'rng_buffer_refill_requests_total',
+                help: 'Total number of RNG buffer refill requests',
+                labelNames: ['rng_range', 'engine_type', 'reason', 'game_code'],
+            }),
+            makeCounterProvider({
+                name: 'rng_buffer_refill_failures_total',
+                help: 'Total number of failed RNG buffer refill requests',
+                labelNames: ['rng_range', 'engine_type', 'reason', 'error', 'game_code'],
+            }),
+            makeHistogramProvider({
+                name: 'rng_buffer_refill_duration_ms',
+                help: 'Duration of RNG buffer refill operations in milliseconds',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+                buckets: [1, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+            }),
+            makeCounterProvider({
+                name: 'rng_buffer_starvation_events_total',
+                help: 'Total number of RNG buffer starvation events',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+            }),
+            makeHistogramProvider({
+                name: 'rng_buffer_latency_ms',
+                help: 'Latency of RNG buffer operations in milliseconds',
+                labelNames: ['rng_range', 'engine_type', 'game_code'],
+                buckets: [1, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+            }),
+        ],
+        exports: [METRICS_PORT],
+    })
+], MetricsModule);
+export { MetricsModule };

package/dist/esm/common/metrics/metrics.port.js

@@ -0,0 +1 @@
+export const METRICS_PORT = Symbol('METRICS_PORT');

package/dist/esm/common/metrics/prometheus.service.js

@@ -0,0 +1,102 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable } from '@nestjs/common';
+import { InjectMetric } from '@willsoto/nestjs-prometheus';
+import { Counter as PromCounter, Gauge as PromGauge, Histogram as PromHistogram, } from 'prom-client';
+let PrometheusService = class PrometheusService {
+    constructor(engineCommandsTotal, engineErrorsTotal, engineRngCallsTotal, engineCommandDuration, rngBufferCapacity, rngBufferFillLevel, rngBufferFillRatio, rngBufferRefillRequestsTotal, rngBufferRefillFailuresTotal, rngBufferRefillDuration, rngBufferStarvationEventsTotal, rngBufferLatency) {
+        this.engineCommandsTotal = engineCommandsTotal;
+        this.engineErrorsTotal = engineErrorsTotal;
+        this.engineRngCallsTotal = engineRngCallsTotal;
+        this.engineCommandDuration = engineCommandDuration;
+        this.rngBufferCapacity = rngBufferCapacity;
+        this.rngBufferFillLevel = rngBufferFillLevel;
+        this.rngBufferFillRatio = rngBufferFillRatio;
+        this.rngBufferRefillRequestsTotal = rngBufferRefillRequestsTotal;
+        this.rngBufferRefillFailuresTotal = rngBufferRefillFailuresTotal;
+        this.rngBufferRefillDuration = rngBufferRefillDuration;
+        this.rngBufferStarvationEventsTotal = rngBufferStarvationEventsTotal;
+        this.rngBufferLatency = rngBufferLatency;
+        this.metricsRegistry = new Map();
+        this.initializeRegistry();
+    }
+    initializeMetricsFromDatabase() {
+        throw new Error('Method not implemented.');
+    }
+    initializeRegistry() {
+        this.metricsRegistry.set('game_engine_commands_total', this.engineCommandsTotal);
+        this.metricsRegistry.set('game_engine_errors_total', this.engineErrorsTotal);
+        this.metricsRegistry.set('game_engine_rng_calls_total', this.engineRngCallsTotal);
+        this.metricsRegistry.set('game_engine_command_duration_ms', this.engineCommandDuration);
+        this.metricsRegistry.set('rng_buffer_capacity', this.rngBufferCapacity);
+        this.metricsRegistry.set('rng_buffer_fill_level', this.rngBufferFillLevel);
+        this.metricsRegistry.set('rng_buffer_fill_ratio', this.rngBufferFillRatio);
+        this.metricsRegistry.set('rng_buffer_refill_requests_total', this.rngBufferRefillRequestsTotal);
+        this.metricsRegistry.set('rng_buffer_refill_failures_total', this.rngBufferRefillFailuresTotal);
+        this.metricsRegistry.set('rng_buffer_refill_duration_ms', this.rngBufferRefillDuration);
+        this.metricsRegistry.set('rng_buffer_starvation_events_total', this.rngBufferStarvationEventsTotal);
+        this.metricsRegistry.set('rng_buffer_latency_ms', this.rngBufferLatency);
+    }
+    getCounter(name) {
+        const metric = this.metricsRegistry.get(name);
+        if (!metric) {
+            throw new Error(`Counter ${name} not found in metrics registry`);
+        }
+        return metric;
+    }
+    getGauge(name) {
+        const metric = this.metricsRegistry.get(name);
+        if (!metric) {
+            throw new Error(`Gauge ${name} not found in metrics registry`);
+        }
+        return metric;
+    }
+    getHistogram(name) {
+        const metric = this.metricsRegistry.get(name);
+        if (!metric) {
+            throw new Error(`Histogram ${name} not found in metrics registry`);
+        }
+        return metric;
+    }
+    async getMetrics() {
+        return '';
+    }
+};
+PrometheusService = __decorate([
+    Injectable(),
+    __param(0, InjectMetric('game_engine_commands_total')),
+    __param(1, InjectMetric('game_engine_errors_total')),
+    __param(2, InjectMetric('game_engine_rng_calls_total')),
+    __param(3, InjectMetric('game_engine_command_duration_ms')),
+    __param(4, InjectMetric('rng_buffer_capacity')),
+    __param(5, InjectMetric('rng_buffer_fill_level')),
+    __param(6, InjectMetric('rng_buffer_fill_ratio')),
+    __param(7, InjectMetric('rng_buffer_refill_requests_total')),
+    __param(8, InjectMetric('rng_buffer_refill_failures_total')),
+    __param(9, InjectMetric('rng_buffer_refill_duration_ms')),
+    __param(10, InjectMetric('rng_buffer_starvation_events_total')),
+    __param(11, InjectMetric('rng_buffer_latency_ms')),
+    __metadata("design:paramtypes", [PromCounter,
+        PromCounter,
+        PromCounter,
+        PromHistogram,
+        PromGauge,
+        PromGauge,
+        PromGauge,
+        PromCounter,
+        PromCounter,
+        PromHistogram,
+        PromCounter,
+        PromHistogram])
+], PrometheusService);
+export { PrometheusService };

package/dist/esm/common/retry/retry-policies.js

@@ -0,0 +1,39 @@
+import { RetryPolicy } from './retry-policy';
+export const HTTP_RETRYABLE_ERRORS = [
+    'TIMEOUT',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'NETWORK',
+];
+export class RetryPolicies {
+    static walletOperation() {
+        return new RetryPolicy({
+            maxAttempts: 5,
+            delayMs: 200,
+            backoffMultiplier: 2,
+            maxDelayMs: 3000,
+            retryableErrors: HTTP_RETRYABLE_ERRORS,
+        });
+    }
+    static externalApi() {
+        return new RetryPolicy({
+            maxAttempts: 3,
+            delayMs: 100,
+            backoffMultiplier: 2,
+            maxDelayMs: 1000,
+            retryableErrors: HTTP_RETRYABLE_ERRORS,
+        });
+    }
+    static database() {
+        return new RetryPolicy({
+            maxAttempts: 3,
+            delayMs: 50,
+            backoffMultiplier: 2,
+            maxDelayMs: 500,
+            retryableErrors: ['deadlock', 'serialization', 'timeout'],
+        });
+    }
+}

package/dist/esm/common/retry/retry-policy.js

@@ -0,0 +1,61 @@
+import { Logger } from '../logger/logger';
+export class RetryPolicy {
+    constructor(options) {
+        this.logger = new Logger(RetryPolicy.name);
+        this.maxAttempts = Math.max(1, options.maxAttempts);
+        this.delayMs = Math.max(0, options.delayMs);
+        this.backoffMultiplier = options.backoffMultiplier ?? 1;
+        this.maxDelayMs = options.maxDelayMs ?? Number.POSITIVE_INFINITY;
+        this.retryableErrors = options.retryableErrors;
+        this.onRetry = options.onRetry;
+        this.operationName = options.operationName;
+    }
+    async execute(fn) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                const result = await fn();
+                if (attempt > 1) {
+                    this.logger.log(`${this.operationName ?? 'operation'} succeeded on attempt ${attempt}`);
+                }
+                return result;
+            }
+            catch (error) {
+                const err = error;
+                lastError = err;
+                if (!this.isRetryable(err)) {
+                    throw err;
+                }
+                if (attempt === this.maxAttempts) {
+                    this.logger.error(`${this.operationName ?? 'operation'} failed after ${attempt} attempts: ${err.message}`, err);
+                    break;
+                }
+                const delay = this.calculateDelay(attempt);
+                this.logger.warn(`${this.operationName ?? 'operation'} failed on attempt ${attempt}/${this.maxAttempts} with error: ${err.message}. Retrying in ${delay}ms...`);
+                if (this.onRetry) {
+                    try {
+                        this.onRetry(attempt, err);
+                    }
+                    catch { }
+                }
+                await this.sleep(delay);
+            }
+        }
+        throw lastError ?? new Error('RetryPolicy failed without error');
+    }
+    isRetryable(error) {
+        if (!this.retryableErrors || this.retryableErrors.length === 0)
+            return true;
+        const causeCode = error?.cause?.code ?? '';
+        const text = `${error?.code ?? ''} ${error?.name ?? ''} ${error.message} ${causeCode}`;
+        return this.retryableErrors.some(pattern => text.includes(pattern));
+    }
+    calculateDelay(attempt) {
+        const factor = Math.max(1, this.backoffMultiplier);
+        const raw = this.delayMs * Math.pow(factor, attempt - 1);
+        return Math.min(raw, this.maxDelayMs);
+    }
+    async sleep(ms) {
+        await new Promise(resolve => setTimeout(resolve, ms));
+    }
+}