diff --git a/lib/index.d.ts b/lib/index.d.ts index 28f176d..66e3c16 100644 --- a/lib/index.d.ts +++ b/lib/index.d.ts @@ -1,6 +1,7 @@ /// -import { Redis as _Redis, Cluster } from "ioredis"; +import IoRedis, { Redis as _Redis, Cluster } from "ioredis"; import EventEmitter from "events"; +import { Registry, Counter, Histogram } from "prom-client"; interface RedisConfig { /** provide host ip/url, default - localhost */ host?: string; @@ -45,15 +46,43 @@ declare class Redis { emitter: EventEmitter; config: RedisConfig; client: Cluster | _Redis; + commandTimeout?: number; + metrics?: { + register: Registry; + labels: { + [key: string]: string; + }; + }; + trackers?: { + commands?: Counter; + errors?: Counter; + latencies?: Histogram; + }; /** * @param {string} name - unique name to this service * @param {EventEmitter} emitter * @param {RedisConfig} config - configuration object of service + * @param {Registry} metrics - prometheus client */ - constructor(name: string, emitter: EventEmitter, config: RedisConfig); + constructor(name: string, emitter: EventEmitter, config: RedisConfig, metrics?: { + register: Registry; + labels: { + [key: string]: string; + }; + }); log(message: string, data: unknown): void; success(message: string, data: unknown): void; error(err: Error, data: unknown): void; + makeError(message: string, data: unknown): Error; + trackCommand(command: string): void; + trackErrors(command: string, errorMessage: string): void; + trackLatencies(command: string, startTime: number): void; + createTimeoutPromise(ms: number, command: string): { + timeoutPromise: Promise; + clear: () => void; + }; + executeCommand(target: any, prop: any, args: any): Promise; + makeProxy(client: Cluster | _Redis): Cluster | IoRedis; /** * Connect to redis server with the config * diff --git a/lib/index.js b/lib/index.js index b2ad13d..8eb50f7 100644 --- a/lib/index.js +++ b/lib/index.js @@ -23,6 +23,9 @@ var __importStar = (this && this.__importStar) || function (mod) { return result; }; const ioredis_1 = __importStar(require("ioredis")); +const commands_1 = require("@ioredis/commands"); +const prom_client_1 = require("prom-client"); +const perf_hooks_1 = require("perf_hooks"); function retryStrategy(times) { if (times > 1000) { // eslint-disable-next-line no-console @@ -53,14 +56,49 @@ class Redis { emitter; config; client; + commandTimeout; + metrics; + trackers; /** * @param {string} name - unique name to this service * @param {EventEmitter} emitter * @param {RedisConfig} config - configuration object of service + * @param {Registry} metrics - prometheus client */ - constructor(name, emitter, config) { + constructor(name, emitter, config, metrics) { this.name = name; this.emitter = emitter; + this.commandTimeout = config.commandTimeout; + this.metrics = metrics; + if (this.metrics) { + // register counters + this.trackers = {}; + // create counter for tracking the number of times redis commands are called + this.trackers.commands = new prom_client_1.Counter({ + name: `${this.name.replaceAll("-", "_")}:commands`, + help: "keep track of all redis commands", + labelNames: [...Object.keys(this.metrics.labels), "command"], + registers: [this.metrics.register], + }); + // create counter for tracking the number of times redis commands have failed + this.trackers.errors = new prom_client_1.Counter({ + name: `${this.name.replaceAll("-", "_")}:errors`, + help: "keep track of all redis command errors", + labelNames: [ + ...Object.keys(this.metrics.labels), + "command", + "errorMessage", + ], + registers: [this.metrics.register], + }); + // create histogram for tracking latencies of redis commands + this.trackers.latencies = new prom_client_1.Histogram({ + name: `${this.name.replaceAll("-", "_")}:latencies`, + help: "keep track of redis command latencies", + labelNames: [...Object.keys(this.metrics.labels), "command"], + registers: [this.metrics.register], + }); + } this.config = Object.assign({ host: "localhost", port: 6379, @@ -99,6 +137,101 @@ class Redis { err, }); } + makeError(message, data) { + const error = new Error(message); + this.error(error, data); + return error; + } + trackCommand(command) { + if (this.trackers?.commands) { + this.trackers.commands.inc({ + ...this.metrics.labels, + command, + }, 1); + } + } + trackErrors(command, errorMessage) { + if (this.trackers?.errors) { + this.trackers.errors.inc({ + ...this.metrics.labels, + command, + errorMessage, + }, 1); + } + } + trackLatencies(command, startTime) { + if (this.trackers?.latencies) { + const endTime = perf_hooks_1.performance.now(); + this.trackers.latencies.observe({ + ...this.metrics.labels, + command, + }, endTime - startTime); + } + } + createTimeoutPromise(ms, command) { + let timeoutId; + const timeoutPromise = new Promise((_, reject) => { + timeoutId = setTimeout(() => { + reject(this.makeError("redis.COMMAND_TIMEOUT", { + command, + timeout: ms, + })); + }, ms); + }); + return { + timeoutPromise, + clear: () => { + clearTimeout(timeoutId); + }, + }; + } + async executeCommand(target, prop, args) { + const startTime = perf_hooks_1.performance.now(); + try { + this.trackCommand(String(prop)); + const result = await target[prop](...args); + this.trackLatencies(String(prop), startTime); + return result; + } + catch (err) { + this.trackLatencies(String(prop), startTime); + this.trackErrors(String(prop), err.message); + throw this.makeError("redis.COMMAND_ERROR", { + command: prop, + args, + error: err, + }); + } + } + makeProxy(client) { + return new Proxy(client, { + get: (target, prop) => { + // check if a command or not + if (!(0, commands_1.exists)(String(prop))) { + return target[prop]; + } + // check if client in ready state + if (this.client.status !== "ready") { + throw this.makeError("redis.NOT_READY", { + command: prop, + }); + } + return (...args) => { + // If timeout is set, apply Promise.race + if (this.client.isCluster && this.commandTimeout) { + const { timeoutPromise, clear } = this.createTimeoutPromise(this.commandTimeout, String(prop)); + return Promise.race([ + this.executeCommand(target, prop, args), + timeoutPromise, + ]).finally(clear); + } + else { + return this.executeCommand(target, prop, args); + } + }; + }, + }); + } /** * Connect to redis server with the config * @@ -198,6 +331,7 @@ class Redis { // single node finish } this.log(`Connecting in ${infoObj.mode} mode`, infoObj); + client = this.makeProxy(client); // common events client.on("connect", () => { this.success(`Successfully connected in ${infoObj.mode} mode`, null); @@ -249,4 +383,4 @@ class Redis { } } module.exports = Redis; -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/package.json b/package.json index 62c0135..2fb0fb0 100644 --- a/package.json +++ b/package.json @@ -23,7 +23,9 @@ }, "homepage": "https://github.com/akshendra/redis-wrapper#readme", "dependencies": { - "ioredis": "5.3.2" + "@ioredis/commands": "^1.2.0", + "ioredis": "5.3.2", + "prom-client": "^15.0.0" }, "devDependencies": { "@types/node": "^16.11.7", @@ -36,4 +38,4 @@ "eslint-plugin-import": "^2.23.4", "typescript": "^4.4.4" } -} \ No newline at end of file +} diff --git a/src/index.ts b/src/index.ts index 2900adf..1db290e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -5,6 +5,9 @@ import IoRedis, { RedisOptions, } from "ioredis"; import EventEmitter from "events"; +import { exists as isCommand } from "@ioredis/commands"; +import { Registry, Counter, Histogram } from "prom-client"; +import { performance } from "perf_hooks"; function retryStrategy(times: number): number { if (times > 1000) { @@ -67,15 +70,66 @@ class Redis { emitter: EventEmitter; config: RedisConfig; client: Cluster | _Redis; + commandTimeout?: number; + metrics?: { + register: Registry; + labels: { [key: string]: string }; + }; + trackers?: { commands?: Counter; errors?: Counter; latencies?: Histogram }; /** * @param {string} name - unique name to this service * @param {EventEmitter} emitter * @param {RedisConfig} config - configuration object of service + * @param {Registry} metrics - prometheus client */ - constructor(name: string, emitter: EventEmitter, config: RedisConfig) { + constructor( + name: string, + emitter: EventEmitter, + config: RedisConfig, + metrics?: { + register: Registry; + labels: { [key: string]: string }; + } + ) { this.name = name; this.emitter = emitter; + this.commandTimeout = config.commandTimeout; + this.metrics = metrics; + + if (this.metrics) { + // register counters + this.trackers = {}; + + // create counter for tracking the number of times redis commands are called + this.trackers.commands = new Counter({ + name: `${this.name.replaceAll("-", "_")}:commands`, + help: "keep track of all redis commands", + labelNames: [...Object.keys(this.metrics.labels), "command"], + registers: [this.metrics.register], + }); + + // create counter for tracking the number of times redis commands have failed + this.trackers.errors = new Counter({ + name: `${this.name.replaceAll("-", "_")}:errors`, + help: "keep track of all redis command errors", + labelNames: [ + ...Object.keys(this.metrics.labels), + "command", + "errorMessage", + ], + registers: [this.metrics.register], + }); + + // create histogram for tracking latencies of redis commands + this.trackers.latencies = new Histogram({ + name: `${this.name.replaceAll("-", "_")}:latencies`, + help: "keep track of redis command latencies", + labelNames: [...Object.keys(this.metrics.labels), "command"], + registers: [this.metrics.register], + }); + } + this.config = Object.assign( { host: "localhost", @@ -131,6 +185,128 @@ class Redis { }); } + makeError(message: string, data: unknown): Error { + const error = new Error(message); + this.error(error, data); + return error; + } + + trackCommand(command: string): void { + if (this.trackers?.commands) { + this.trackers.commands.inc( + { + ...this.metrics.labels, + command, + }, + 1 + ); + } + } + + trackErrors(command: string, errorMessage: string): void { + if (this.trackers?.errors) { + this.trackers.errors.inc( + { + ...this.metrics.labels, + command, + errorMessage, + }, + 1 + ); + } + } + + trackLatencies(command: string, startTime: number): void { + if (this.trackers?.latencies) { + const endTime = performance.now(); + this.trackers.latencies.observe( + { + ...this.metrics.labels, + command, + }, + endTime - startTime + ); + } + } + + createTimeoutPromise( + ms: number, + command: string + ): { + timeoutPromise: Promise; + clear: () => void; + } { + let timeoutId: NodeJS.Timeout; + const timeoutPromise = new Promise((_, reject) => { + timeoutId = setTimeout(() => { + reject( + this.makeError("redis.COMMAND_TIMEOUT", { + command, + timeout: ms, + }) + ); + }, ms); + }); + return { + timeoutPromise, + clear: () => { + clearTimeout(timeoutId); + }, + }; + } + + async executeCommand(target, prop, args): Promise { + const startTime = performance.now(); + try { + this.trackCommand(String(prop)); + const result = await target[prop](...args); + this.trackLatencies(String(prop), startTime); + return result; + } catch (err) { + this.trackLatencies(String(prop), startTime); + this.trackErrors(String(prop), err.message); + throw this.makeError("redis.COMMAND_ERROR", { + command: prop, + args, + error: err, + }); + } + } + + makeProxy(client: Cluster | _Redis) { + return new Proxy(client, { + get: (target, prop) => { + // check if a command or not + if (!isCommand(String(prop))) { + return target[prop]; + } + + // check if client in ready state + if (this.client.status !== "ready") { + throw this.makeError("redis.NOT_READY", { + command: prop, + }); + } + + return (...args: unknown[]): Promise => { + // If timeout is set, apply Promise.race + if (this.client.isCluster && this.commandTimeout) { + const { timeoutPromise, clear } = this.createTimeoutPromise( + this.commandTimeout, + String(prop) + ); + return Promise.race([ + this.executeCommand(target, prop, args), + timeoutPromise, + ]).finally(clear); + } else { + return this.executeCommand(target, prop, args); + } + }; + }, + }); + } + /** * Connect to redis server with the config * @@ -236,6 +412,8 @@ class Redis { this.log(`Connecting in ${infoObj.mode} mode`, infoObj); + client = this.makeProxy(client); + // common events client.on("connect", () => { this.success(`Successfully connected in ${infoObj.mode} mode`, null); diff --git a/tests/single.js b/tests/single.js index aaee6be..45ab77a 100644 --- a/tests/single.js +++ b/tests/single.js @@ -1,65 +1,77 @@ - - -const Redis = require('../lib/index'); -const { EventEmitter } = require('events'); +const Redis = require("../lib/index"); +const { EventEmitter } = require("events"); +const promClient = require("prom-client"); const emitter = new EventEmitter(); -emitter.on('log', console.log.bind(console)); -emitter.on('success', console.log.bind(console)); -emitter.on('error', console.error.bind(console)); +emitter.on("log", console.log.bind(console)); +emitter.on("success", console.log.bind(console)); +emitter.on("error", console.error.bind(console)); async function doSome(client) { for (let i = 0; i < 1000; i += 1) { console.log(i); - await client.set(`Key:${i}`, i); + // add timeout of 1s + await new Promise((resolve) => setTimeout(resolve, 1000)); + try { + await client.set(`Key:${i}`, i); + const data = await client.get(`Key:${i}`); + console.log(`Fetched: ${data}`); + } catch (err) { + console.log(err); + } } } async function doPPL(redis) { - await redis.ppl([{ - command: 'hset', - args: [ - 'Map', - 'one', - '1', - ], - }, { - command: 'hmset', - args: [ - 'Map', - { 'two': 2, 'three': 3 }, - ], - }, { - command: 'set', - args: [ - 'count', - '3', - ], - }]); - const response = await redis.ppl([{ - command: 'hgetall', - args: [ - 'Map', - ], - }, { - command: 'get', - args: [ - 'count', - ], - action(val) { - return { - count: val, - }; + await redis.ppl([ + { + command: "hset", + args: ["Map", "one", "1"], + }, + { + command: "hmset", + args: ["Map", { two: 2, three: 3 }], + }, + { + command: "set", + args: ["count", "3"], }, - }]); + ]); + const response = await redis.ppl([ + { + command: "hgetall", + args: ["Map"], + }, + { + command: "get", + args: ["count"], + action(val) { + return { + count: val, + }; + }, + }, + ]); console.log(JSON.stringify(response, null, 2)); } -const redis = new Redis('redis', emitter, { - host: '127.0.0.1', - port: 6379, -}); -redis.init() +const redis = new Redis( + "redis", + emitter, + { + host: "127.0.0.1", + port: 6379, + commandTimeout: 100, + }, + { + register: promClient.register, + labels: { + service: "test-test_test9", + }, + } +); +redis + .init() .then(() => { const client = redis.client; return doSome(client); @@ -68,10 +80,10 @@ redis.init() return doPPL(redis); }) .then(() => { - console.log('Started'); + console.log("Started"); process.exit(0); }) - .catch(err => { + .catch((err) => { console.error(err); process.exit(1); });