@deniscuciuc/redis-analyzer 1.0.0

package/dist/src/analyzers/persistence-analyzer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistenceAnalyzer = void 0;
+const constants_1 = require("../constants");
+class PersistenceAnalyzer {
+    analyze(info) {
+        const now = Math.floor(Date.now() / 1000);
+        const secondsSinceRdb = info.rdbLastSaveTime > 0 ? now - info.rdbLastSaveTime : 0;
+        const hoursSinceRdb = secondsSinceRdb / 3600;
+        const recommendations = [];
+        let severity = "ok";
+        if (info.rdbLastBgsaveStatus === "err") {
+            severity = "critical";
+            recommendations.push("Last RDB save failed. Check Redis logs and available disk space immediately.");
+        }
+        else if (info.rdbLastSaveTime > 0 &&
+            hoursSinceRdb > constants_1.THRESHOLDS.persistence.rdbStaleHours) {
+            severity = "warning";
+            recommendations.push(`No successful RDB save in ${hoursSinceRdb.toFixed(1)} hours. Verify save settings or trigger a manual BGSAVE.`);
+        }
+        if (info.aofEnabled && info.aofLastBgrewriteStatus === "err") {
+            severity = "critical";
+            recommendations.push("Last AOF rewrite failed. Check disk pressure and Redis background rewrite activity.");
+        }
+        if (!info.aofEnabled && info.rdbChangesSinceLastSave > 10_000) {
+            if (severity === "ok") {
+                severity = "warning";
+            }
+            recommendations.push(`${info.rdbChangesSinceLastSave.toLocaleString()} unsaved changes detected since the last RDB snapshot. Consider enabling AOF or reducing snapshot intervals.`);
+        }
+        if (!info.aofEnabled && info.rdbLastSaveTime === 0) {
+            if (severity === "ok") {
+                severity = "warning";
+            }
+            recommendations.push("No persistence configured (no AOF and no successful RDB snapshot). Data will be lost on restart.");
+        }
+        return {
+            rdb: {
+                enabled: info.rdbLastSaveTime > 0 ||
+                    info.rdbChangesSinceLastSave > 0 ||
+                    info.rdbBgsaveInProgress,
+                lastSaveTime: info.rdbLastSaveTime,
+                secondsSinceLastSave: secondsSinceRdb,
+                lastStatus: info.rdbLastBgsaveStatus,
+                changesSinceLastSave: info.rdbChangesSinceLastSave,
+                saveInProgress: info.rdbBgsaveInProgress,
+            },
+            aof: {
+                enabled: info.aofEnabled,
+                lastStatus: info.aofLastBgrewriteStatus,
+                rewriteInProgress: info.aofRewriteInProgress,
+                currentSizeBytes: info.aofCurrentSize,
+            },
+            severity,
+            recommendations,
+        };
+    }
+}
+exports.PersistenceAnalyzer = PersistenceAnalyzer;

package/dist/src/analyzers/replication-analyzer.d.ts

@@ -0,0 +1,5 @@
+import type { RedisInfo, ReplicationAnalysis } from "../types";
+export declare class ReplicationAnalyzer {
+    analyze(info: RedisInfo): ReplicationAnalysis;
+}
+//# sourceMappingURL=replication-analyzer.d.ts.map

package/dist/src/analyzers/replication-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replication-analyzer.d.ts","sourceRoot":"","sources":["../../../src/analyzers/replication-analyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/D,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,mBAAmB;CA0D7C"}

package/dist/src/analyzers/replication-analyzer.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplicationAnalyzer = void 0;
+const constants_1 = require("../constants");
+class ReplicationAnalyzer {
+    analyze(info) {
+        if (info.role === "master" && info.connectedSlaves === 0) {
+            return {
+                role: "standalone",
+                connectedSlaves: 0,
+                severity: "ok",
+                recommendations: [],
+            };
+        }
+        const recommendations = [];
+        let severity = "ok";
+        let lagSeconds;
+        if (info.role === "slave") {
+            if (info.masterLinkStatus === "down") {
+                severity = "critical";
+                recommendations.push("Replication link to the primary is down. Check network reachability and primary health.");
+            }
+            else if (info.masterLastIoSecondsAgo !== undefined) {
+                lagSeconds = info.masterLastIoSecondsAgo;
+                if (lagSeconds >= constants_1.THRESHOLDS.replication.lagCritical) {
+                    severity = "critical";
+                    recommendations.push(`Replication lag is ${lagSeconds}s. Check network throughput, replica CPU pressure, and write load on the primary.`);
+                }
+                else if (lagSeconds >= constants_1.THRESHOLDS.replication.lagWarning) {
+                    severity = "warning";
+                    recommendations.push(`Replication lag of ${lagSeconds}s detected. Monitor catch-up speed and backlog size.`);
+                }
+            }
+            if (info.masterSyncInProgress) {
+                recommendations.push("A full resync is in progress. Expect reduced replica freshness until synchronization completes.");
+            }
+        }
+        if (info.role === "master" && info.connectedSlaves > 0) {
+            recommendations.push(`Primary has ${info.connectedSlaves} replica(s). Validate lag from replica INFO output.`);
+        }
+        return {
+            role: info.role === "master" ? "master" : "slave",
+            connectedSlaves: info.connectedSlaves,
+            linkStatus: info.masterLinkStatus,
+            lagSeconds,
+            syncInProgress: info.masterSyncInProgress,
+            severity,
+            recommendations,
+        };
+    }
+}
+exports.ReplicationAnalyzer = ReplicationAnalyzer;

package/dist/src/cli/options.d.ts

@@ -0,0 +1,24 @@
+import type { AnalyzerOptions } from "../types";
+export interface ParsedOptions extends AnalyzerOptions {
+    host: string;
+    port: number;
+    password?: string;
+    db: number;
+    tls: boolean;
+    uri?: string;
+    profile?: string;
+    config?: string;
+    compare?: string;
+    html: boolean;
+    watch?: number;
+    command: string;
+    json: boolean;
+    quiet: boolean;
+    outputDir: string;
+    slowCommandThreshold: number;
+    maxSlowCommands: number;
+    interactive: boolean;
+}
+export declare function parseOptions(argv?: string[]): ParsedOptions;
+export declare function toAnalyzerOptions(options: ParsedOptions): AnalyzerOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/src/cli/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,MAAM,WAAW,aAAc,SAAQ,eAAe;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,OAAO,CAAC;CACrB;AAED,wBAAgB,YAAY,CAAC,IAAI,WAAwB,GAAG,aAAa,CA8GxE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,eAAe,CAMzE"}

package/dist/src/cli/options.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOptions = parseOptions;
+exports.toAnalyzerOptions = toAnalyzerOptions;
+const constants_1 = require("../constants");
+function parseOptions(argv = process.argv.slice(2)) {
+    const options = {
+        host: constants_1.DEFAULTS.host,
+        port: constants_1.DEFAULTS.port,
+        db: constants_1.DEFAULTS.db,
+        tls: false,
+        command: "full",
+        json: false,
+        quiet: false,
+        html: false,
+        outputDir: constants_1.DEFAULTS.output,
+        slowCommandThreshold: constants_1.DEFAULTS.slowCommandThreshold,
+        maxSlowCommands: constants_1.DEFAULTS.maxSlowCommands,
+        interactive: false,
+    };
+    for (let index = 0; index < argv.length; index++) {
+        switch (argv[index]) {
+            case "--host":
+            case "-h":
+                options.host = argv[++index];
+                break;
+            case "--port":
+            case "-p":
+                options.port = Number.parseInt(argv[++index], 10);
+                break;
+            case "--password":
+            case "-a":
+                options.password = argv[++index];
+                break;
+            case "--db":
+            case "-n":
+                options.db = Number.parseInt(argv[++index], 10);
+                break;
+            case "--tls":
+                options.tls = true;
+                break;
+            case "--uri":
+                options.uri = argv[++index];
+                break;
+            case "--output":
+            case "-o":
+                options.outputDir = argv[++index];
+                break;
+            case "--profile":
+                options.profile = argv[++index];
+                break;
+            case "--config":
+                options.config = argv[++index];
+                break;
+            case "--compare":
+                options.compare = argv[++index];
+                break;
+            case "--html":
+                options.html = true;
+                break;
+            case "--watch": {
+                const nextValue = argv[index + 1];
+                if (nextValue && !nextValue.startsWith("-")) {
+                    options.watch = Number.parseInt(nextValue, 10);
+                    index++;
+                }
+                else {
+                    options.watch = constants_1.DEFAULTS.watchInterval;
+                }
+                break;
+            }
+            case "--slow-threshold":
+                options.slowCommandThreshold = Number.parseInt(argv[++index], 10);
+                break;
+            case "--max-slow-commands":
+                options.maxSlowCommands = Number.parseInt(argv[++index], 10);
+                break;
+            case "--help":
+                printHelp();
+                process.exit(0);
+                return options;
+            case "--json":
+            case "-j":
+                options.json = true;
+                break;
+            case "--quiet":
+            case "-q":
+                options.quiet = true;
+                break;
+            case "--command":
+            case "-c":
+                options.command = argv[++index];
+                break;
+            case "--interactive":
+            case "-i":
+            case "start":
+                options.interactive = true;
+                break;
+        }
+    }
+    if (options.watch !== undefined &&
+        (!Number.isFinite(options.watch) || options.watch <= 0)) {
+        throw new Error(`Invalid watch interval: ${options.watch}`);
+    }
+    if (!constants_1.COMMANDS.includes(options.command)) {
+        throw new Error(`Unknown command "${options.command}". Use --help to see available commands.`);
+    }
+    return options;
+}
+function toAnalyzerOptions(options) {
+    return {
+        slowCommandThreshold: options.slowCommandThreshold,
+        maxSlowCommands: options.maxSlowCommands,
+        outputDir: options.outputDir,
+    };
+}
+function printHelp() {
+    console.log(`
+Redis Analyzer
+==============
+
+Usage:
+  npx ts-node index.ts [options]
+
+Connection options:
+  -h, --host <host>              Redis host (env: REDIS_HOST)
+  -p, --port <port>              Redis port (env: REDIS_PORT)
+  -a, --password <password>      Redis password (env: REDIS_PASSWORD)
+  -n, --db <number>              Redis database number (env: REDIS_DB)
+      --tls                      Enable TLS (env: REDIS_TLS=true)
+      --uri <uri>                Redis URI (env: REDIS_URI)
+      --profile <name>           Use named profile from .analyzerrc.json
+      --config <path>            Use a custom config file path
+
+Analysis options:
+      --slow-threshold <μs>      Slow command threshold in microseconds (default: ${constants_1.DEFAULTS.slowCommandThreshold})
+      --max-slow-commands <n>    Max slow log rows to fetch (default: ${constants_1.DEFAULTS.maxSlowCommands})
+      --compare <path>           Compare against a previous JSON report
+      --watch [seconds]          Watch mode (default interval: ${constants_1.DEFAULTS.watchInterval}s)
+
+Output options:
+  -o, --output <dir>             Output directory for reports (default: ${constants_1.DEFAULTS.output})
+  -j, --json                     Output JSON to stdout
+      --html                     Also generate an HTML report
+  -q, --quiet                    Suppress non-essential output
+  -i, --interactive              Interactive mode with menu
+      start                      Alias for --interactive
+
+Commands:
+  -c, --command <cmd>            Run a specific analysis command
+
+Available commands:
+  ${constants_1.COMMANDS.join("\n  ")}
+`);
+}

package/dist/src/cli/runner.d.ts

@@ -0,0 +1,13 @@
+import type { Redis } from "ioredis";
+import type { FullRedisReport, FullReport, RedisConnection, RedisInfo } from "../types";
+import type { ParsedOptions } from "./options";
+export declare function summarizeKeyspaces(info: RedisInfo): {
+    totalKeys: number;
+    totalExpiringKeys: number;
+    expiringRatio: number;
+    keyspaces: RedisInfo["keyspaces"];
+};
+export declare function buildFullReport(client: Redis, options: ParsedOptions, connection: RedisConnection): Promise<FullRedisReport>;
+export declare function executeCommand(client: Redis, options: ParsedOptions, connection: RedisConnection): Promise<void>;
+export declare function loadPreviousReport(reportPath: string): FullReport;
+//# sourceMappingURL=runner.d.ts.map

package/dist/src/cli/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/cli/runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAUrC,OAAO,KAAK,EACX,eAAe,EACf,UAAU,EACV,eAAe,EACf,SAAS,EAET,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AA+C/C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;CAClC,CAeA;AAED,wBAAsB,eAAe,CACpC,MAAM,EAAE,KAAK,EACb,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,eAAe,GACzB,OAAO,CAAC,eAAe,CAAC,CAmD1B;AAED,wBAAsB,cAAc,CACnC,MAAM,EAAE,KAAK,EACb,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,eAAe,GACzB,OAAO,CAAC,IAAI,CAAC,CA2Df;AAwFD,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CASjE"}

package/dist/src/cli/runner.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeKeyspaces = summarizeKeyspaces;
+exports.buildFullReport = buildFullReport;
+exports.executeCommand = executeCommand;
+exports.loadPreviousReport = loadPreviousReport;
+const node_fs_1 = require("node:fs");
+const memory_analyzer_1 = require("../analyzers/memory-analyzer");
+const performance_analyzer_1 = require("../analyzers/performance-analyzer");
+const persistence_analyzer_1 = require("../analyzers/persistence-analyzer");
+const replication_analyzer_1 = require("../analyzers/replication-analyzer");
+const stats_collector_1 = require("../collectors/stats-collector");
+const constants_1 = require("../constants");
+const health_1 = require("../health");
+const diff_reporter_1 = require("../reporters/diff-reporter");
+const report_generator_1 = require("../reporters/report-generator");
+const options_1 = require("./options");
+function createServices(client, options) {
+    const analyzerOptions = (0, options_1.toAnalyzerOptions)(options);
+    return {
+        client,
+        collector: new stats_collector_1.StatsCollector(client),
+        memory: new memory_analyzer_1.MemoryAnalyzer(),
+        performance: new performance_analyzer_1.PerformanceAnalyzer(),
+        persistence: new persistence_analyzer_1.PersistenceAnalyzer(),
+        replication: new replication_analyzer_1.ReplicationAnalyzer(),
+        reporter: new report_generator_1.ReportGenerator(options.outputDir, analyzerOptions),
+    };
+}
+function buildMetrics(info) {
+    return {
+        version: info.redisVersion,
+        mode: info.redisMode,
+        uptimeDays: info.uptimeInDays,
+        connectedClients: info.connectedClients,
+        blockedClients: info.blockedClients,
+        maxClients: info.maxClients,
+        opsPerSec: info.instantaneousOpsPerSec,
+        totalKeyCount: info.keyspaces.reduce((sum, keyspace) => sum + keyspace.keys, 0),
+        keyspacesCount: info.keyspaces.length,
+        rejectedConnections: info.rejectedConnections,
+    };
+}
+function summarizeKeyspaces(info) {
+    const totalKeys = info.keyspaces.reduce((sum, keyspace) => sum + keyspace.keys, 0);
+    const totalExpiringKeys = info.keyspaces.reduce((sum, keyspace) => sum + keyspace.expires, 0);
+    return {
+        totalKeys,
+        totalExpiringKeys,
+        expiringRatio: totalKeys === 0 ? 0 : (totalExpiringKeys / totalKeys) * 100,
+        keyspaces: info.keyspaces,
+    };
+}
+async function buildFullReport(client, options, connection) {
+    const services = createServices(client, options);
+    const [info, totalSlowLogged, config] = await Promise.all([
+        services.collector.getInfo(),
+        services.collector.getSlowLogLength(),
+        services.collector.getConfigValues(constants_1.IMPORTANT_CONFIG_KEYS),
+    ]);
+    const slowCommands = await services.collector.getSlowLog(options.maxSlowCommands);
+    const memory = services.memory.analyze(info);
+    const hitRate = services.performance.analyzeHitRate(info);
+    const persistence = services.persistence.analyze(info);
+    const replication = services.replication.analyze(info);
+    const slowCommandAnalysis = services.performance.analyzeSlowCommands(slowCommands, totalSlowLogged, options.slowCommandThreshold);
+    const metrics = buildMetrics(info);
+    const reportBase = {
+        generatedAt: new Date(),
+        host: connection.host,
+        port: connection.port,
+        db: connection.db,
+        metrics,
+        memory,
+        hitRate,
+        persistence,
+        replication,
+        slowCommands: slowCommandAnalysis,
+        keyspaces: info.keyspaces,
+        config,
+    };
+    const recommendations = (0, health_1.buildRecommendations)({
+        memory,
+        hitRate,
+        persistence,
+        replication,
+        metrics,
+    });
+    const healthScore = (0, health_1.computeHealthScore)(reportBase);
+    return {
+        ...reportBase,
+        healthScore,
+        recommendations,
+    };
+}
+async function executeCommand(client, options, connection) {
+    const log = options.quiet || options.json ? () => { } : console.log;
+    const services = createServices(client, options);
+    if (options.command !== "full") {
+        const result = await runCommand(services, options, connection);
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const report = await buildFullReport(client, options, connection);
+    if (options.compare) {
+        const previous = loadPreviousReport(options.compare);
+        diff_reporter_1.DiffReporter.print(diff_reporter_1.DiffReporter.diff(report, previous), options.json ? console.error : console.log);
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            success: true,
+            report,
+            summary: {
+                healthScore: report.healthScore,
+                usedMemory: report.memory.usedMemoryHuman,
+                memoryUsagePercent: Number(report.memory.usagePercent.toFixed(2)),
+                hitRate: Number(report.hitRate.hitRate.toFixed(2)),
+                totalKeys: report.metrics.totalKeyCount,
+                slowCommandsLogged: report.slowCommands.totalLogged,
+                rejectedConnections: report.metrics.rejectedConnections,
+            },
+            recommendations: report.recommendations,
+        }, null, 2));
+        return;
+    }
+    services.reporter.printSummary(report);
+    log("\nGenerating reports...");
+    const [markdown, json, html] = await Promise.all([
+        services.reporter.generateFullReport(report),
+        services.reporter.generateJsonReport(report),
+        options.html ? services.reporter.generateHtmlReport(report) : undefined,
+    ]);
+    log("\nReports generated:");
+    log(`  - Markdown: ${markdown}`);
+    log(`  - JSON: ${json}`);
+    if (html) {
+        log(`  - HTML: ${html}`);
+    }
+}
+async function runCommand(services, options, connection) {
+    switch (options.command) {
+        case "health": {
+            const report = await buildFullReport(services.client, options, connection);
+            return {
+                healthScore: report.healthScore,
+                metrics: report.metrics,
+                issues: report.recommendations.map((recommendation) => recommendation.message),
+            };
+        }
+        case "server-info": {
+            const info = await services.collector.getInfo();
+            return {
+                version: info.redisVersion,
+                mode: info.redisMode,
+                os: info.os,
+                uptimeDays: info.uptimeInDays,
+                tcpPort: info.tcpPort,
+                configFile: info.configFile,
+            };
+        }
+        case "memory": {
+            const info = await services.collector.getInfo();
+            return services.memory.analyze(info);
+        }
+        case "hit-rate": {
+            const info = await services.collector.getInfo();
+            return services.performance.analyzeHitRate(info);
+        }
+        case "slow-commands": {
+            const [commands, totalLogged] = await Promise.all([
+                services.collector.getSlowLog(options.maxSlowCommands),
+                services.collector.getSlowLogLength(),
+            ]);
+            return services.performance.analyzeSlowCommands(commands, totalLogged, options.slowCommandThreshold);
+        }
+        case "keys": {
+            const info = await services.collector.getInfo();
+            return summarizeKeyspaces(info);
+        }
+        case "connections": {
+            const info = await services.collector.getInfo();
+            return {
+                connectedClients: info.connectedClients,
+                blockedClients: info.blockedClients,
+                maxClients: info.maxClients,
+                clientUtilization: info.maxClients === 0
+                    ? 0
+                    : Number(((info.connectedClients / info.maxClients) * 100).toFixed(2)),
+                rejectedConnections: info.rejectedConnections,
+                recentMaxInputBufferBytes: info.clientRecentMaxInputBuffer,
+                recentMaxOutputBufferBytes: info.clientRecentMaxOutputBuffer,
+            };
+        }
+        case "persistence": {
+            const info = await services.collector.getInfo();
+            return services.persistence.analyze(info);
+        }
+        case "replication": {
+            const info = await services.collector.getInfo();
+            return services.replication.analyze(info);
+        }
+        case "config":
+            return services.collector.getConfigValues(constants_1.IMPORTANT_CONFIG_KEYS);
+        default:
+            throw new Error(`Unsupported command: ${options.command}`);
+    }
+}
+function loadPreviousReport(reportPath) {
+    if (!(0, node_fs_1.existsSync)(reportPath)) {
+        throw new Error(`Previous report not found: ${reportPath}`);
+    }
+    const parsed = JSON.parse((0, node_fs_1.readFileSync)(reportPath, "utf-8"));
+    return "report" in parsed ? parsed.report : parsed;
+}

package/dist/src/collectors/stats-collector.d.ts

@@ -0,0 +1,15 @@
+import type { Redis } from "ioredis";
+import type { RedisInfo, SlowCommand } from "../types";
+type RawSlowLogEntry = [number, number, number, string[], string?, string?];
+export declare function parseSlowLogEntries(entries: RawSlowLogEntry[]): SlowCommand[];
+export declare function parseRedisInfo(raw: string): RedisInfo;
+export declare class StatsCollector {
+    private readonly client;
+    constructor(client: Redis);
+    getInfo(): Promise<RedisInfo>;
+    getSlowLog(count: number): Promise<SlowCommand[]>;
+    getSlowLogLength(): Promise<number>;
+    getConfigValues(keys: readonly string[]): Promise<Record<string, string>>;
+}
+export {};
+//# sourceMappingURL=stats-collector.d.ts.map

package/dist/src/collectors/stats-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats-collector.d.ts","sourceRoot":"","sources":["../../../src/collectors/stats-collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAgB,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAErE,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAE5E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,WAAW,EAAE,CAa7E;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CA8GrD;AAED,qBAAa,cAAc;IACd,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK;IAEpC,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC;IAI7B,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKjD,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKnC,eAAe,CACpB,IAAI,EAAE,SAAS,MAAM,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAelC"}