@lokalise/prisma-utils 3.0.1 → 3.2.0

package/README.md

@@ -14,3 +14,14 @@ const result: Either<unknown, [Item, Segment]> = await prismaTransaction(prisma,
 ```
 
 This implementation will retry the transaction on P2034 error, which satisfies Prisma recommendations for distributed databases such as CockroachDB.
+
+### Prisma metrics plugin
+
+Plugin to collect and send metrics to prometheus. Prisma metrics will be added to our app metrics.
+
+Add the plugin to your Fastify instance by registering it with the following options:
+
+- `isEnabled`;
+- `collectionOptions` (by default we collect metrics `every 5 seconds`) to override default collector behaviour
+
+Once the plugin has been added to your Fastify instance and loaded, we will start collection prisma metrics.

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export type * from './types';
 export * from './errors';
 export { prismaTransaction } from './prismaTransaction';
 export { prismaClientFactory } from './prismaClientFactory';
+export { prismaMetricsPlugin, type PrismaMetricsPluginOptions } from './plugins/prismaMetricsPlugin';

package/dist/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prismaClientFactory = exports.prismaTransaction = void 0;
+exports.prismaMetricsPlugin = exports.prismaClientFactory = exports.prismaTransaction = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./errors"), exports);
 var prismaTransaction_1 = require("./prismaTransaction");
 Object.defineProperty(exports, "prismaTransaction", { enumerable: true, get: function () { return prismaTransaction_1.prismaTransaction; } });
 var prismaClientFactory_1 = require("./prismaClientFactory");
 Object.defineProperty(exports, "prismaClientFactory", { enumerable: true, get: function () { return prismaClientFactory_1.prismaClientFactory; } });
+var prismaMetricsPlugin_1 = require("./plugins/prismaMetricsPlugin");
+Object.defineProperty(exports, "prismaMetricsPlugin", { enumerable: true, get: function () { return prismaMetricsPlugin_1.prismaMetricsPlugin; } });

package/dist/plugins/CollectionScheduler.d.ts

@@ -0,0 +1,12 @@
+export type CollectionScheduler = {
+    start: () => void;
+    stop: () => void;
+};
+export declare class PromiseBasedCollectionScheduler implements CollectionScheduler {
+    private active;
+    private readonly collectionIntervalInMs;
+    private readonly collect;
+    constructor(collectionIntervalInMs: number, collect: () => Promise<void>);
+    start(): Promise<void>;
+    stop(): void;
+}

package/dist/plugins/CollectionScheduler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseBasedCollectionScheduler = void 0;
+const promises_1 = require("node:timers/promises");
+class PromiseBasedCollectionScheduler {
+    active = true;
+    collectionIntervalInMs;
+    collect;
+    constructor(collectionIntervalInMs, collect) {
+        this.collectionIntervalInMs = collectionIntervalInMs;
+        this.collect = collect;
+    }
+    async start() {
+        while (this.active) {
+            await this.collect();
+            await (0, promises_1.setTimeout)(this.collectionIntervalInMs);
+        }
+    }
+    stop() {
+        this.active = false;
+    }
+}
+exports.PromiseBasedCollectionScheduler = PromiseBasedCollectionScheduler;

package/dist/plugins/MetricsCollector.d.ts

@@ -0,0 +1,31 @@
+import type { PrismaClient } from '@prisma/client';
+import type { FastifyBaseLogger } from 'fastify';
+import * as prometheus from 'prom-client';
+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[];
+};
+export type MetricCollectorOptions = {
+    metricsPrefix: string;
+};
+export declare class MetricsCollector {
+    private readonly prisma;
+    private readonly options;
+    private readonly registry;
+    private readonly logger;
+    private metrics?;
+    constructor(prisma: PrismaClient, options: MetricCollectorOptions, registry: prometheus.Registry, logger: FastifyBaseLogger);
+    /**
+     * Updates metrics for prisma
+     */
+    collect(): Promise<void>;
+    /**
+     * Stops the metrics collection and cleans up resources
+     */
+    dispose(): Promise<void>;
+    private registerMetrics;
+    private getRegisteredMetrics;
+    private getJsonMetrics;
+}

package/dist/plugins/MetricsCollector.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+const tslib_1 = require("tslib");
+const prometheus = tslib_1.__importStar(require("prom-client"));
+function registerMetrics(_prefix, jsonMetrics) {
+    const metrics = {
+        counters: {},
+        gauges: {},
+        histograms: {},
+        names: [],
+    };
+    for (const metric of jsonMetrics.counters) {
+        metrics.counters[metric.key] = new prometheus.Counter({
+            name: metric.key,
+            help: metric.description,
+            labelNames: ['prisma', 'connection_pool'],
+        });
+        metrics.names.push(metric.key);
+    }
+    for (const metric of jsonMetrics.gauges) {
+        metrics.gauges[metric.key] = new prometheus.Gauge({
+            name: metric.key,
+            help: metric.description,
+            labelNames: ['prisma', 'connection_pool'],
+        });
+        metrics.names.push(metric.key);
+    }
+    for (const metric of jsonMetrics.histograms) {
+        metrics.histograms[metric.key] = new prometheus.Histogram({
+            name: metric.key,
+            help: metric.description,
+            buckets: metric.value.buckets.filter((bucket) => bucket[1] === 0).map((bucket) => bucket[0]),
+            labelNames: ['prisma', 'connection_pool'],
+        });
+        metrics.names.push(metric.key);
+    }
+    return metrics;
+}
+function getMetricKeys(_prefix, jsonMetrics) {
+    const metricKeys = [];
+    metricKeys.push(...jsonMetrics.counters.map((metric) => metric.key));
+    metricKeys.push(...jsonMetrics.gauges.map((metric) => metric.key));
+    metricKeys.push(...jsonMetrics.histograms.map((metric) => metric.key));
+    return metricKeys;
+}
+class MetricsCollector {
+    prisma;
+    options;
+    registry;
+    logger;
+    metrics;
+    constructor(prisma, options, registry, logger) {
+        this.prisma = prisma;
+        this.options = options;
+        this.registry = registry;
+        this.logger = logger;
+        this.registerMetrics(this.registry, this.options).then((result) => {
+            this.metrics = result;
+        });
+    }
+    /**
+     * Updates metrics for prisma
+     */
+    async collect() {
+        if (!this.metrics) {
+            return;
+        }
+        try {
+            const jsonMetrics = await this.getJsonMetrics();
+            for (const counterMetric of jsonMetrics.counters) {
+                // 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);
+            }
+            for (const gaugeMetric of jsonMetrics.gauges) {
+                this.metrics.gauges[gaugeMetric.key].set(gaugeMetric.value);
+            }
+            for (const histogramMetric of jsonMetrics.histograms) {
+                this.metrics.histograms[histogramMetric.key].observe(histogramMetric.value.count);
+            }
+        }
+        catch (err) {
+            /* c8 ignore start */
+            this.logger.error(err);
+        }
+        /* c8 ignore stop */
+    }
+    /**
+     * Stops the metrics collection and cleans up resources
+     */
+    async dispose() { }
+    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 */
+            return existingMetrics;
+        }
+        /* c8 ignore stop */
+        return registerMetrics(metricsPrefix, jsonMetrics);
+    }
+    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;
+        }
+        /* c8 ignore start */
+        const retrievedMetrics = registry.getMetricsAsArray();
+        const returnValue = {
+            counters: {},
+            histograms: {},
+            gauges: {},
+        };
+        for (const metric of retrievedMetrics) {
+            if (!metricNames.includes(metric.name)) {
+                continue;
+            }
+            if (metric.type.toString() === 'counter') {
+                returnValue.counters[metric.name] = metric;
+            }
+            if (metric.type.toString() === 'gauge') {
+                returnValue.gauges[metric.name] = metric;
+            }
+            if (metric.type.toString() === 'histogram') {
+                returnValue.histograms[metric.name] = metric;
+            }
+        }
+        return returnValue;
+        /* c8 ignore stop */
+    }
+    getJsonMetrics() {
+        return this.prisma.$metrics.json();
+    }
+}
+exports.MetricsCollector = MetricsCollector;

package/dist/plugins/prismaMetricsPlugin.d.ts

@@ -0,0 +1,21 @@
+import type { FastifyPluginCallback } from 'fastify';
+import 'fastify-metrics';
+import type { PrismaClient } from '@prisma/client';
+import type { MetricCollectorOptions } from './MetricsCollector';
+declare module 'fastify' {
+    interface FastifyInstance {
+        prismaMetrics: {
+            collect: () => Promise<void>;
+        };
+    }
+}
+export type PrismaMetricsPluginOptions = {
+    prisma: PrismaClient;
+    collectionOptions?: {
+        type: 'interval';
+        intervalInMs: number;
+    } | {
+        type: 'manual';
+    };
+} & Partial<MetricCollectorOptions>;
+export declare const prismaMetricsPlugin: FastifyPluginCallback<PrismaMetricsPluginOptions>;

package/dist/plugins/prismaMetricsPlugin.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prismaMetricsPlugin = void 0;
+const tslib_1 = require("tslib");
+require("fastify-metrics");
+const fastify_plugin_1 = tslib_1.__importDefault(require("fastify-plugin"));
+const CollectionScheduler_1 = require("./CollectionScheduler");
+const MetricsCollector_1 = require("./MetricsCollector");
+function plugin(fastify, pluginOptions, next) {
+    if (!fastify.metrics) {
+        return next(new Error('No Prometheus Client found, Prisma metrics plugin requires `fastify-metrics` plugin to be registered'));
+    }
+    const options = {
+        collectionOptions: {
+            type: 'interval',
+            intervalInMs: 5000,
+        },
+        ...pluginOptions,
+        metricsPrefix: 'prisma',
+    };
+    try {
+        const collector = new MetricsCollector_1.MetricsCollector(options.prisma, options, fastify.metrics.client.register, fastify.log);
+        const collectFn = async () => await collector.collect();
+        let scheduler;
+        if (options.collectionOptions.type === 'interval') {
+            scheduler = new CollectionScheduler_1.PromiseBasedCollectionScheduler(options.collectionOptions.intervalInMs, collectFn);
+            // Void is set so the scheduler can run indefinitely
+            void scheduler.start();
+        }
+        fastify.addHook('onClose', async () => {
+            if (scheduler) {
+                scheduler.stop();
+            }
+            await collector.dispose();
+        });
+        fastify.decorate('prismaMetrics', {
+            collect: collectFn,
+        });
+        next();
+    }
+    catch (err) {
+        /* c8 ignore start */
+        return next(err instanceof Error
+            ? err
+            : new Error('Unknown error in prisma-metrics-plugin', { cause: err }));
+        /* c8 ignore stop */
+    }
+}
+exports.prismaMetricsPlugin = (0, fastify_plugin_1.default)(plugin, {
+    fastify: '5.x',
+    name: 'prisma-metrics-plugin',
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lokalise/prisma-utils",
-    "version": "3.0.1",
+    "version": "3.2.0",
     "type": "commonjs",
     "license": "Apache-2.0",
     "files": ["dist", "README.md", "LICENSE.md"],
@@ -9,7 +9,7 @@
     "homepage": "https://github.com/lokalise/shared-ts-libs",
     "repository": {
         "type": "git",
-        "url": "git://github.com/lokalise/shared-ts-libs.git"
+        "url": "https://github.com/lokalise/shared-ts-libs.git"
     },
     "scripts": {
         "build": "rimraf dist && npm run db:update-client && tsc",
@@ -31,22 +31,24 @@
         "postversion": "biome check --write package.json"
     },
     "dependencies": {
-        "@lokalise/node-core": "^11.2.0"
+        "@lokalise/node-core": "^13.1.0"
     },
     "peerDependencies": {
-        "@prisma/client": "^5.16.1",
-        "prisma": "^5.16.1"
+        "@prisma/client": "^5.0.0",
+        "prisma": "^5.0.0"
     },
     "devDependencies": {
-        "@biomejs/biome": "^1.8.3",
-        "@lokalise/biome-config": "^1.3.0",
-        "@prisma/client": "^5.14.0",
-        "@vitest/coverage-v8": "^2.0.4",
+        "@biomejs/biome": "^1.9.4",
+        "@lokalise/biome-config": "^1.5.0",
+        "@lokalise/backend-http-client": "^2.3.0",
+        "@lokalise/fastify-extras": "^25.0.0",
+        "@prisma/client": "^5.21.1",
+        "@vitest/coverage-v8": "^2.1.3",
         "cross-env": "^7.0.3",
         "dotenv-cli": "^7.4.1",
-        "prisma": "^5.14.0",
-        "rimraf": "^5.0.7",
-        "typescript": "5.5.4",
-        "vitest": "^2.0.4"
+        "prisma": "^5.21.1",
+        "rimraf": "^6.0.1",
+        "typescript": "5.6.3",
+        "vitest": "^2.1.3"
     }
 }