liftedinit · jgryffindor · May 12, 2025 · May 13, 2025 · May 14, 2025 · May 14, 2025
diff --git a/package-lock.json b/package-lock.json
diff --git a/server/package.json b/server/package.json
@@ -47,6 +47,7 @@
     "passport-local": "^1.0.0",
     "pg": "^8.9.0",
     "pg-query-stream": "^4.4.0",
+    "prom-client": "^15.1.3",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.0",
     "rxjs-stream": "^5.0.0",

diff --git a/server/src/app.module.ts b/server/src/app.module.ts
@@ -35,6 +35,7 @@ import { SystemWideMetric } from "./database/entities/systemwide-metric.entity";
 import { SystemWideModule } from "./metrics/systemwide/systemwide.module";
 import { Migration } from "./database/entities/migration.entity";
 import { MigrationWhitelist } from "./database/entities/migration-whitelist.entity";
+import { MonitoringModule } from "./metrics/monitoring/monitoring.module";
 
 @Module({
   controllers: [],
@@ -91,6 +92,7 @@ import { MigrationWhitelist } from "./database/entities/migration-whitelist.enti
       }),
     }),
     TypeOrmModule.forFeature([Event, Transaction, TransactionDetails, PrometheusQuery, Metric]),
+    MonitoringModule,
     AdminConfigModule,
     AppConfigModule,
     SchedulerConfigModule,
@@ -107,6 +109,7 @@ import { MigrationWhitelist } from "./database/entities/migration-whitelist.enti
     GeoSchedulerModule,
   ],
 })
+
 export class AppModule {
   constructor(private dataSource: DataSource) {}
 }
diff --git a/server/src/metrics/metrics.module.ts b/server/src/metrics/metrics.module.ts
@@ -21,10 +21,12 @@ import { SystemWideService } from "./systemwide/systemwide.service";
 import { SystemWideMetric } from "../database/entities/systemwide-metric.entity";
 import { LocationModule } from "./location/location.module";
 import { LocationService } from "./location/location.service";
+import { MonitoringModule } from "./monitoring/monitoring.module";
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([Metric, Location, Block, Transaction, SystemWideMetric, PrometheusQuery]),
+    MonitoringModule,
     HttpModule,
     MetricsSchedulerConfigModule,
     PrometheusQueryModule,

diff --git a/server/src/metrics/monitoring/monitoring.controller.ts b/server/src/metrics/monitoring/monitoring.controller.ts
@@ -0,0 +1,21 @@
+import { Controller, Get, Logger, Res } from '@nestjs/common';
+import { Response } from 'express';
+import { Registry, collectDefaultMetrics, register } from 'prom-client';
+import { METRIC_PREFIX } from './monitoring.service';
+
+@Controller('monitoring')
+export class MonitoringController {
+  private readonly logger = new Logger(MonitoringController.name);
+
+  constructor() {
+    // Initialize the Prometheus registry
+    collectDefaultMetrics({ register, prefix: METRIC_PREFIX  });
+  }
+
+  @Get('metrics')
+  async getMetrics(@Res() res: Response): Promise<void> {
+    const metrics = await register.metrics(); 
+    res.set('Content-Type', register.contentType);
+    res.send(metrics);
+  }
+}
diff --git a/server/src/metrics/monitoring/monitoring.middleware.ts b/server/src/metrics/monitoring/monitoring.middleware.ts
@@ -0,0 +1,21 @@
+
+import { Injectable, Logger, NestMiddleware } from '@nestjs/common';
+import { MonitoringService } from './monitoring.service';
+
+@Injectable()
+export class MonitoringMiddleware implements NestMiddleware {
+  private readonly logger = new Logger(MonitoringMiddleware.name);
+
+  constructor(private readonly monitoringService: MonitoringService) {
+    this.logger.log('MonitoringMiddleware initialized');
+  }
+
+  async use(req: any, res: any, next: () => void) {
+    if (req.originalUrl.includes('/monitoring/metrics')) {
+
+      // Update all custom metrics before serving the metrics endpoint
+      this.monitoringService.updateMetrics();
+    }
+    next();
+  }
+}
diff --git a/server/src/metrics/monitoring/monitoring.module.ts b/server/src/metrics/monitoring/monitoring.module.ts
@@ -0,0 +1,34 @@
+// src/monitoring/monitoring.module.ts
+import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { MonitoringService } from './monitoring.service';
+import { MonitoringController } from './monitoring.controller';
+import { PrometheusQueryModule } from '../prometheus-query/query.module';
+import { PrometheusQuery } from '../../database/entities/prometheus-query.entity';
+import { MetricsService } from '../metrics.service';
+import { Metric } from '../../database/entities/metric.entity';
+import { MetricsSchedulerConfigModule } from '../../config/metrics-scheduler/configuration.module';
+import { Registry } from 'prom-client';
+import { MonitoringMiddleware } from './monitoring.middleware';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Metric, PrometheusQuery]),
+    PrometheusQueryModule, 
+    MetricsSchedulerConfigModule,
+  ],
+  controllers: [MonitoringController],
+  providers: [
+    MonitoringService, 
+    MetricsService,
+    Registry,
+  ],
+  exports: [MonitoringService, MetricsService],
+})
+export class MonitoringModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(MonitoringMiddleware)
+      .forRoutes('monitoring/metrics');
+  }
+}
diff --git a/server/src/metrics/monitoring/monitoring.service.ts b/server/src/metrics/monitoring/monitoring.service.ts
@@ -0,0 +1,125 @@
+import { Injectable, Logger } from '@nestjs/common';
+import {
+  register,
+  Gauge,
+  Counter,
+  Metric,
+} from 'prom-client';
+import { MetricsService } from '../metrics.service';
+
+export const METRIC_PREFIX = 'talib_';
+
+type MetricType = 'gauge' | 'counter';
+
+type MetricInstance =
+  | Gauge<string>
+  | Counter<string>;
+
+type MetricValue =
+  | { value: number; labels?: Record<string, string> }
+
+interface MetricDefinition {
+  type: MetricType;
+      name: string;
+  help: string;
+  labels?: string[];
+  getValue: () => Promise<MetricValue>;
+}
+
+function isValueMetric(val: MetricValue): val is { value: number; labels?: Record<string, string> } {
+  return 'value' in val;
+}
+
+@Injectable()
+export class MonitoringService {
+  private readonly logger = new Logger(MonitoringService.name);
+  private readonly metrics: Record<string, MetricInstance> = {};
+
+  // Define the metrics to be monitored
+  // Each metric has a type, name, help text, optional labels, and a function to get its value
+  private readonly metricDefinitions: MetricDefinition[] = [
+    {
+      type: 'gauge',
+      name: 'mfx_power_conversion',
+      help: 'The current MFX-to-power conversion rate',
+      getValue: async () => {
+        const res = await this.metricsService.getCurrent('mfxpowerconversion');
+        return {
+          value: res ? Number(res.data) : 0,
+          labels: { test: 'someValue' },
+        };
+      },
+    },
+  ];
+
+  constructor(private readonly metricsService: MetricsService) {
+    // Initialize the Prometheus registry
+    register.clear();
+    register.setDefaultLabels({ app: 'talib' });
+    this.registerMetrics();
+    this.logger.log('MonitoringService initialized');
+  }
+
+  // Register metrics with Prometheus
+  private registerMetrics(): void {
+    for (const def of this.metricDefinitions) {
+      let metric: MetricInstance;
+      const metricName = METRIC_PREFIX + def.name;
+
+    switch (def.type) {
+      case 'gauge':
+        metric = new Gauge({
+          name: metricName,
+          help: def.help,
+          labelNames: def.labels || [],
+        });
+        break;
+      case 'counter':
+        metric = new Counter({
+          name: metricName,
+          help: def.help,
+          labelNames: def.labels || [],
+        });
+        break;
+    }
+
+      register.registerMetric(metric);
+      this.metrics[def.name] = metric;
+    }
+
+    this.logger.log(`Registered ${this.metricDefinitions.length} metrics`);
+  }
+
+  // Update metrics
+  async updateMetrics(): Promise<void> {
+    for (const def of this.metricDefinitions) {
+      const metric = this.metrics[def.name];
+      if (!metric) continue;
+
+      try {
+        const result = await def.getValue();
+        const labels = result.labels || {};
+
+        switch (def.type) {
+          case 'gauge':
+            if (isValueMetric(result)) {
+              def.labels?.length
+                ? (metric as Gauge<string>).set(labels, result.value)
+                : (metric as Gauge<string>).set(result.value);
+            }
+            break;
+
+          case 'counter':
+            if (isValueMetric(result)) {
+              def.labels?.length
+                ? (metric as Counter<string>).inc(labels, result.value)
+                : (metric as Counter<string>).inc(result.value);
+            }
+            break;
+        }
+      } catch (err) {
+        this.logger.error(`Error updating metric ${def.name}:`, err);
+      }
+    }
+  }
+}