@lokalise/prisma-utils 3.2.0 → 3.2.1

package/dist/plugins/CollectionScheduler.js

@@ -12,8 +12,8 @@ class PromiseBasedCollectionScheduler {
     }
     async start() {
         while (this.active) {
-            await this.collect();
             await (0, promises_1.setTimeout)(this.collectionIntervalInMs);
+            await this.collect();
         }
     }
     stop() {

package/dist/plugins/MetricsCollector.d.ts

@@ -5,7 +5,7 @@ export type PrometheusMetricsDefinitions = {
     counters: Record<string, prometheus.Counter<'prisma' | 'connection-pool'>>;
     gauges: Record<string, prometheus.Gauge<'prisma' | 'connection-pool'>>;
     histograms: Record<string, prometheus.Histogram<'prisma' | 'connection-pool'>>;
-    names: string[];
+    keys: string[];
 };
 export type MetricCollectorOptions = {
     metricsPrefix: string;
@@ -15,17 +15,22 @@ export declare class MetricsCollector {
     private readonly options;
     private readonly registry;
     private readonly logger;
-    private metrics?;
+    private metrics;
     constructor(prisma: PrismaClient, options: MetricCollectorOptions, registry: prometheus.Registry, logger: FastifyBaseLogger);
     /**
-     * Updates metrics for prisma
+     * Updates metrics for prisma.
+     * If metric was not registered before it will be registered here.
      */
-    collect(): Promise<void>;
+    collect(prefix: string): Promise<void>;
+    private registerNewMetrics;
     /**
      * Stops the metrics collection and cleans up resources
      */
     dispose(): Promise<void>;
     private registerMetrics;
+    /**
+     * If metrics are already registered, we just return them to avoid triggering a Prometheus error.
+     */
     private getRegisteredMetrics;
     private getJsonMetrics;
 }

package/dist/plugins/MetricsCollector.js

@@ -8,7 +8,7 @@ function registerMetrics(_prefix, jsonMetrics) {
         counters: {},
         gauges: {},
         histograms: {},
-        names: [],
+        keys: [],
     };
     for (const metric of jsonMetrics.counters) {
         metrics.counters[metric.key] = new prometheus.Counter({
@@ -16,7 +16,7 @@ function registerMetrics(_prefix, jsonMetrics) {
             help: metric.description,
             labelNames: ['prisma', 'connection_pool'],
         });
-        metrics.names.push(metric.key);
+        metrics.keys.push(metric.key);
     }
     for (const metric of jsonMetrics.gauges) {
         metrics.gauges[metric.key] = new prometheus.Gauge({
@@ -24,7 +24,7 @@ function registerMetrics(_prefix, jsonMetrics) {
             help: metric.description,
             labelNames: ['prisma', 'connection_pool'],
         });
-        metrics.names.push(metric.key);
+        metrics.keys.push(metric.key);
     }
     for (const metric of jsonMetrics.histograms) {
         metrics.histograms[metric.key] = new prometheus.Histogram({
@@ -33,7 +33,7 @@ function registerMetrics(_prefix, jsonMetrics) {
             buckets: metric.value.buckets.filter((bucket) => bucket[1] === 0).map((bucket) => bucket[0]),
             labelNames: ['prisma', 'connection_pool'],
         });
-        metrics.names.push(metric.key);
+        metrics.keys.push(metric.key);
     }
     return metrics;
 }
@@ -55,30 +55,62 @@ class MetricsCollector {
         this.options = options;
         this.registry = registry;
         this.logger = logger;
+        this.metrics = {
+            counters: {},
+            gauges: {},
+            histograms: {},
+            keys: [],
+        };
         this.registerMetrics(this.registry, this.options).then((result) => {
             this.metrics = result;
+            this.logger.debug({}, `Prisma metrics registered ${result.keys}`);
         });
     }
     /**
-     * Updates metrics for prisma
+     * Updates metrics for prisma.
+     * If metric was not registered before it will be registered here.
      */
-    async collect() {
-        if (!this.metrics) {
-            return;
-        }
+    async collect(prefix) {
         try {
+            const nonRegisteredMetrics = {
+                counters: [],
+                gauges: [],
+                histograms: [],
+            };
             const jsonMetrics = await this.getJsonMetrics();
             for (const counterMetric of jsonMetrics.counters) {
+                const existingMetric = this.metrics.counters[counterMetric.key];
+                /* c8 ignore start */
+                if (!existingMetric) {
+                    nonRegisteredMetrics.counters.push(counterMetric);
+                    continue;
+                }
+                /* c8 ignore stop */
                 // we need to reset counter since prisma returns already the accumulated counter value
-                this.metrics.counters[counterMetric.key].reset();
-                this.metrics.counters[counterMetric.key].inc(counterMetric.value);
+                existingMetric.reset();
+                existingMetric.inc(counterMetric.value);
             }
             for (const gaugeMetric of jsonMetrics.gauges) {
-                this.metrics.gauges[gaugeMetric.key].set(gaugeMetric.value);
+                const existingMetric = this.metrics.gauges[gaugeMetric.key];
+                /* c8 ignore start */
+                if (!existingMetric) {
+                    nonRegisteredMetrics.gauges.push(gaugeMetric);
+                    continue;
+                }
+                /* c8 ignore stop */
+                existingMetric.set(gaugeMetric.value);
             }
             for (const histogramMetric of jsonMetrics.histograms) {
-                this.metrics.histograms[histogramMetric.key].observe(histogramMetric.value.count);
+                const existingMetric = this.metrics.histograms[histogramMetric.key];
+                /* c8 ignore start */
+                if (!existingMetric) {
+                    nonRegisteredMetrics.histograms.push(histogramMetric);
+                    continue;
+                }
+                /* c8 ignore stop */
+                existingMetric.observe(histogramMetric.value.count);
             }
+            this.registerNewMetrics(prefix, nonRegisteredMetrics);
         }
         catch (err) {
             /* c8 ignore start */
@@ -86,6 +118,26 @@ class MetricsCollector {
         }
         /* c8 ignore stop */
     }
+    registerNewMetrics(prefix, nonRegisteredMetrics) {
+        if (!nonRegisteredMetrics.counters.length &&
+            !nonRegisteredMetrics.gauges.length &&
+            !nonRegisteredMetrics.histograms.length) {
+            return;
+        }
+        /* c8 ignore start */
+        const newMetrics = registerMetrics(prefix, nonRegisteredMetrics);
+        for (const [key, value] of Object.entries(newMetrics.counters)) {
+            this.metrics.counters[key] = value;
+        }
+        for (const [key, value] of Object.entries(newMetrics.gauges)) {
+            this.metrics.gauges[key] = value;
+        }
+        for (const [key, value] of Object.entries(newMetrics.histograms)) {
+            this.metrics.histograms[key] = value;
+        }
+        this.logger.debug({}, `Prisma metrics registered ${newMetrics.keys}`);
+        /* c8 ignore stop */
+    }
     /**
      * Stops the metrics collection and cleans up resources
      */
@@ -93,7 +145,6 @@ class MetricsCollector {
     async registerMetrics(registry, { metricsPrefix }) {
         const jsonMetrics = await this.getJsonMetrics();
         const metricNames = getMetricKeys(metricsPrefix, jsonMetrics);
-        // If metrics are already registered, just return them to avoid triggering a Prometheus error
         const existingMetrics = this.getRegisteredMetrics(registry, metricNames);
         if (existingMetrics) {
             /* c8 ignore start */
@@ -102,8 +153,10 @@ class MetricsCollector {
         /* c8 ignore stop */
         return registerMetrics(metricsPrefix, jsonMetrics);
     }
+    /**
+     * If metrics are already registered, we just return them to avoid triggering a Prometheus error.
+     */
     getRegisteredMetrics(registry, metricNames) {
-        // If metrics are already registered, just return them to avoid triggering a Prometheus error
         if (!metricNames.length || !registry.getSingleMetric(metricNames[0])) {
             return;
         }

package/dist/plugins/prismaMetricsPlugin.js

@@ -20,7 +20,7 @@ function plugin(fastify, pluginOptions, next) {
     };
     try {
         const collector = new MetricsCollector_1.MetricsCollector(options.prisma, options, fastify.metrics.client.register, fastify.log);
-        const collectFn = async () => await collector.collect();
+        const collectFn = async () => await collector.collect(options.metricsPrefix);
         let scheduler;
         if (options.collectionOptions.type === 'interval') {
             scheduler = new CollectionScheduler_1.PromiseBasedCollectionScheduler(options.collectionOptions.intervalInMs, collectFn);
@@ -37,14 +37,14 @@ function plugin(fastify, pluginOptions, next) {
             collect: collectFn,
         });
         next();
+        /* c8 ignore start */
     }
     catch (err) {
-        /* c8 ignore start */
         return next(err instanceof Error
             ? err
             : new Error('Unknown error in prisma-metrics-plugin', { cause: err }));
-        /* c8 ignore stop */
     }
+    /* c8 ignore stop */
 }
 exports.prismaMetricsPlugin = (0, fastify_plugin_1.default)(plugin, {
     fastify: '5.x',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lokalise/prisma-utils",
-    "version": "3.2.0",
+    "version": "3.2.1",
     "type": "commonjs",
     "license": "Apache-2.0",
     "files": ["dist", "README.md", "LICENSE.md"],