nestlens 0.1.1 → 0.2.0

package/dist/core/storage/redis.storage.d.ts

@@ -0,0 +1,77 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { Entry, EntryFilter, EntryStats, EntryType, CursorPaginationParams, CursorPaginatedResponse, StorageStats, MonitoredTag, TagWithCount } from '../../types';
+import { StorageInterface } from './storage.interface';
+import { RedisStorageConfig } from '../../nestlens.config';
+/**
+ * Redis storage implementation for NestLens.
+ * Requires ioredis to be installed.
+ * Ideal for production environments with horizontal scaling.
+ *
+ * Redis Key Structure:
+ * - {prefix}entries:{id} - Hash storing entry data
+ * - {prefix}entries:all - Sorted set of all entry IDs (score = timestamp)
+ * - {prefix}entries:type:{type} - Sorted set of entry IDs by type
+ * - {prefix}entries:request:{requestId} - Set of entry IDs for a request
+ * - {prefix}entries:sequence - Counter for entry IDs
+ * - {prefix}tags:{entryId} - Set of tags for an entry
+ * - {prefix}tags:index:{tag} - Set of entry IDs with this tag
+ * - {prefix}tags:counts - Hash of tag -> count
+ * - {prefix}monitored - Hash of monitored tags
+ * - {prefix}monitored:sequence - Counter for monitored tag IDs
+ * - {prefix}family:{hash} - Set of entry IDs with this family hash
+ */
+export declare class RedisStorage implements StorageInterface, OnModuleDestroy {
+    private readonly logger;
+    private client;
+    private readonly keyPrefix;
+    private readonly config;
+    constructor(config?: RedisStorageConfig);
+    /**
+     * Builds a Redis key with the configured prefix
+     */
+    private key;
+    /**
+     * Lazily loads ioredis and creates a client
+     */
+    private loadRedisClient;
+    private getClient;
+    initialize(): Promise<void>;
+    save(entry: Entry): Promise<Entry>;
+    saveBatch(entries: Entry[]): Promise<Entry[]>;
+    find(filter: EntryFilter): Promise<Entry[]>;
+    findWithCursor(type: EntryType | undefined, params: CursorPaginationParams): Promise<CursorPaginatedResponse<Entry>>;
+    findById(id: number): Promise<Entry | null>;
+    count(type?: EntryType): Promise<number>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    getLatestSequence(type?: EntryType): Promise<number | null>;
+    hasEntriesAfter(sequence: number, type?: EntryType): Promise<number>;
+    getStats(): Promise<EntryStats>;
+    getStorageStats(): Promise<StorageStats>;
+    prune(before: Date): Promise<number>;
+    pruneByType(type: EntryType, before: Date): Promise<number>;
+    addTags(entryId: number, tags: string[]): Promise<void>;
+    removeTags(entryId: number, tags: string[]): Promise<void>;
+    getEntryTags(entryId: number): Promise<string[]>;
+    getAllTags(): Promise<TagWithCount[]>;
+    findByTags(tags: string[], logic?: 'AND' | 'OR', limit?: number): Promise<Entry[]>;
+    addMonitoredTag(tag: string): Promise<MonitoredTag>;
+    removeMonitoredTag(tag: string): Promise<void>;
+    getMonitoredTags(): Promise<MonitoredTag[]>;
+    resolveEntry(id: number): Promise<void>;
+    unresolveEntry(id: number): Promise<void>;
+    updateFamilyHash(id: number, familyHash: string): Promise<void>;
+    findByFamilyHash(familyHash: string, limit?: number): Promise<Entry[]>;
+    getGroupedByFamilyHash(type?: EntryType, limit?: number): Promise<{
+        familyHash: string;
+        count: number;
+        latestEntry: Entry;
+    }[]>;
+    onModuleDestroy(): void;
+    private fetchEntriesByIds;
+    private hashToEntry;
+    private hydrateEntriesWithTags;
+    private deleteEntry;
+    private applyAdvancedFilters;
+}
+//# sourceMappingURL=redis.storage.d.ts.map

package/dist/core/storage/redis.storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.storage.d.ts","sourceRoot":"","sources":["../../../src/core/storage/redis.storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAErE,OAAO,EACL,KAAK,EACL,WAAW,EACX,UAAU,EACV,SAAS,EACT,sBAAsB,EACtB,uBAAuB,EACvB,YAAY,EACZ,YAAY,EACZ,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBACa,YAAa,YAAW,gBAAgB,EAAE,eAAe;IACpE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,MAAM,GAAE,kBAAuB;IAK3C;;OAEG;IACH,OAAO,CAAC,GAAG;IAIX;;OAEG;YACW,eAAe;IAsB7B,OAAO,CAAC,SAAS;IAOX,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAqClC,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IA0C7C,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAmC3C,cAAc,CAClB,IAAI,EAAE,SAAS,GAAG,SAAS,EAC3B,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAsDpC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAa3C,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IAMxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,iBAAiB,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQ3D,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IAMpE,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAkC/B,eAAe,IAAI,OAAO,CAAC,YAAY,CAAC;IA+CxC,KAAK,CAAC,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAepC,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IAqB3D,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAavD,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1D,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAMhD,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAUrC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,GAAE,KAAK,GAAG,IAAW,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAsBpF,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAmBnD,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK9C,gBAAgB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAY3C,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASvC,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOzC,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/D,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAWlE,sBAAsB,CAC1B,IAAI,CAAC,EAAE,SAAS,EAChB,KAAK,SAAK,GACT,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC;IAqCvE,eAAe,IAAI,IAAI;YAQT,iBAAiB;IAyB/B,OAAO,CAAC,WAAW;YAgBL,sBAAsB;YAYtB,WAAW;IA6BzB,OAAO,CAAC,oBAAoB;CA0B7B"}

package/dist/core/storage/redis.storage.js

@@ -0,0 +1,595 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var RedisStorage_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStorage = void 0;
+const common_1 = require("@nestjs/common");
+/**
+ * Redis storage implementation for NestLens.
+ * Requires ioredis to be installed.
+ * Ideal for production environments with horizontal scaling.
+ *
+ * Redis Key Structure:
+ * - {prefix}entries:{id} - Hash storing entry data
+ * - {prefix}entries:all - Sorted set of all entry IDs (score = timestamp)
+ * - {prefix}entries:type:{type} - Sorted set of entry IDs by type
+ * - {prefix}entries:request:{requestId} - Set of entry IDs for a request
+ * - {prefix}entries:sequence - Counter for entry IDs
+ * - {prefix}tags:{entryId} - Set of tags for an entry
+ * - {prefix}tags:index:{tag} - Set of entry IDs with this tag
+ * - {prefix}tags:counts - Hash of tag -> count
+ * - {prefix}monitored - Hash of monitored tags
+ * - {prefix}monitored:sequence - Counter for monitored tag IDs
+ * - {prefix}family:{hash} - Set of entry IDs with this family hash
+ */
+let RedisStorage = RedisStorage_1 = class RedisStorage {
+    constructor(config = {}) {
+        this.logger = new common_1.Logger(RedisStorage_1.name);
+        this.client = null;
+        this.config = config;
+        this.keyPrefix = config.keyPrefix ?? 'nestlens:';
+    }
+    /**
+     * Builds a Redis key with the configured prefix
+     */
+    key(...parts) {
+        return this.keyPrefix + parts.join(':');
+    }
+    /**
+     * Lazily loads ioredis and creates a client
+     */
+    async loadRedisClient() {
+        try {
+            // Dynamic import - ioredis is an optional peer dependency
+            const { default: RedisClient } = await Promise.resolve().then(() => __importStar(require('ioredis')));
+            if (this.config.url) {
+                return new RedisClient(this.config.url);
+            }
+            return new RedisClient({
+                host: this.config.host ?? 'localhost',
+                port: this.config.port ?? 6379,
+                password: this.config.password,
+                db: this.config.db ?? 0,
+            });
+        }
+        catch (error) {
+            throw new Error('ioredis is required for Redis storage. Install it with: npm install ioredis');
+        }
+    }
+    getClient() {
+        if (!this.client) {
+            throw new Error('Redis client not initialized. Call initialize() first.');
+        }
+        return this.client;
+    }
+    async initialize() {
+        this.client = await this.loadRedisClient();
+        this.logger.log('Redis storage initialized');
+    }
+    // ==================== Core CRUD Operations ====================
+    async save(entry) {
+        const client = this.getClient();
+        const id = await client.incr(this.key('entries', 'sequence'));
+        const createdAt = new Date().toISOString();
+        const timestamp = Date.now();
+        const savedEntry = {
+            ...entry,
+            id,
+            createdAt,
+        };
+        // Store entry as hash
+        await client.hset(this.key('entries', String(id)), 'id', String(id), 'type', entry.type, 'requestId', entry.requestId ?? '', 'payload', JSON.stringify(entry.payload), 'createdAt', createdAt, 'familyHash', entry.familyHash ?? '', 'resolvedAt', entry.resolvedAt ?? '');
+        // Add to sorted sets for indexing
+        await client.zadd(this.key('entries', 'all'), timestamp, String(id));
+        await client.zadd(this.key('entries', 'type', entry.type), timestamp, String(id));
+        // Add to request index if applicable
+        if (entry.requestId) {
+            await client.sadd(this.key('entries', 'request', entry.requestId), String(id));
+        }
+        return savedEntry;
+    }
+    async saveBatch(entries) {
+        if (entries.length === 0)
+            return [];
+        const client = this.getClient();
+        const pipeline = client.pipeline();
+        const results = [];
+        // Pre-fetch IDs
+        const startId = await client.incrby(this.key('entries', 'sequence'), entries.length);
+        const timestamp = Date.now();
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const id = startId - entries.length + 1 + i;
+            const createdAt = new Date().toISOString();
+            const savedEntry = { ...entry, id, createdAt };
+            results.push(savedEntry);
+            pipeline.hset(this.key('entries', String(id)), 'id', String(id), 'type', entry.type, 'requestId', entry.requestId ?? '', 'payload', JSON.stringify(entry.payload), 'createdAt', createdAt, 'familyHash', entry.familyHash ?? '', 'resolvedAt', entry.resolvedAt ?? '');
+            pipeline.zadd(this.key('entries', 'all'), timestamp + i, String(id));
+            pipeline.zadd(this.key('entries', 'type', entry.type), timestamp + i, String(id));
+            if (entry.requestId) {
+                pipeline.sadd(this.key('entries', 'request', entry.requestId), String(id));
+            }
+        }
+        await pipeline.exec();
+        return results;
+    }
+    async find(filter) {
+        const client = this.getClient();
+        let ids;
+        if (filter.requestId) {
+            ids = await client.smembers(this.key('entries', 'request', filter.requestId));
+        }
+        else if (filter.type) {
+            const start = filter.offset ?? 0;
+            const end = start + (filter.limit ?? 100) - 1;
+            ids = await client.zrevrange(this.key('entries', 'type', filter.type), start, end);
+        }
+        else {
+            const start = filter.offset ?? 0;
+            const end = start + (filter.limit ?? 100) - 1;
+            ids = await client.zrevrange(this.key('entries', 'all'), start, end);
+        }
+        if (ids.length === 0)
+            return [];
+        const entries = await this.fetchEntriesByIds(ids);
+        // Apply date filters
+        let filtered = entries;
+        if (filter.from) {
+            const fromTime = filter.from.getTime();
+            filtered = filtered.filter((e) => new Date(e.createdAt).getTime() >= fromTime);
+        }
+        if (filter.to) {
+            const toTime = filter.to.getTime();
+            filtered = filtered.filter((e) => new Date(e.createdAt).getTime() <= toTime);
+        }
+        return this.hydrateEntriesWithTags(filtered);
+    }
+    async findWithCursor(type, params) {
+        const client = this.getClient();
+        const limit = params.limit ?? 50;
+        const indexKey = type ? this.key('entries', 'type', type) : this.key('entries', 'all');
+        let ids;
+        if (params.beforeSequence !== undefined) {
+            ids = await client.zrevrangebyscore(indexKey, `(${params.beforeSequence}`, '-inf', 'LIMIT', '0', String(limit + 1));
+        }
+        else if (params.afterSequence !== undefined) {
+            ids = await client.zrangebyscore(indexKey, `(${params.afterSequence}`, '+inf', 'LIMIT', '0', String(limit + 1));
+        }
+        else {
+            ids = await client.zrevrange(indexKey, 0, limit);
+        }
+        const hasMore = ids.length > limit;
+        if (hasMore)
+            ids = ids.slice(0, limit);
+        if (params.afterSequence !== undefined) {
+            ids.reverse();
+        }
+        let entries = await this.fetchEntriesByIds(ids);
+        // Apply advanced filters
+        if (params.filters) {
+            entries = this.applyAdvancedFilters(entries, params.filters);
+        }
+        const hydratedEntries = await this.hydrateEntriesWithTags(entries);
+        const total = await client.zcard(indexKey);
+        return {
+            data: hydratedEntries,
+            meta: {
+                hasMore,
+                oldestSequence: hydratedEntries.length > 0 ? hydratedEntries[hydratedEntries.length - 1].id : null,
+                newestSequence: hydratedEntries.length > 0 ? hydratedEntries[0].id : null,
+                total,
+            },
+        };
+    }
+    async findById(id) {
+        const client = this.getClient();
+        const hash = await client.hgetall(this.key('entries', String(id)));
+        if (!hash || !hash.id)
+            return null;
+        const entry = this.hashToEntry(hash);
+        if (!entry)
+            return null;
+        const [hydrated] = await this.hydrateEntriesWithTags([entry]);
+        return hydrated;
+    }
+    async count(type) {
+        const client = this.getClient();
+        const key = type ? this.key('entries', 'type', type) : this.key('entries', 'all');
+        return client.zcard(key);
+    }
+    async clear() {
+        const client = this.getClient();
+        const keys = await client.keys(this.keyPrefix + '*');
+        if (keys.length > 0) {
+            await client.del(...keys);
+        }
+        this.logger.log('Storage cleared');
+    }
+    async close() {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+        }
+        this.logger.log('Redis storage closed');
+    }
+    // ==================== Statistics ====================
+    async getLatestSequence(type) {
+        const client = this.getClient();
+        const key = type ? this.key('entries', 'type', type) : this.key('entries', 'all');
+        const result = await client.zrevrange(key, 0, 0);
+        return result.length > 0 ? parseInt(result[0], 10) : null;
+    }
+    async hasEntriesAfter(sequence, type) {
+        const client = this.getClient();
+        const key = type ? this.key('entries', 'type', type) : this.key('entries', 'all');
+        return client.zcount(key, `(${sequence}`, '+inf');
+    }
+    async getStats() {
+        const client = this.getClient();
+        // Get counts by type
+        const types = [
+            'request', 'query', 'exception', 'log', 'cache', 'event', 'job',
+            'schedule', 'mail', 'http-client', 'redis', 'model', 'notification',
+            'view', 'command', 'gate', 'batch', 'dump',
+        ];
+        const byType = {};
+        let total = 0;
+        for (const type of types) {
+            const count = await client.zcard(this.key('entries', 'type', type));
+            if (count > 0) {
+                byType[type] = count;
+                total += count;
+            }
+        }
+        // For avgResponseTime and slowQueries, we'd need to iterate over entries
+        // which is expensive in Redis. Return undefined for now.
+        return {
+            total,
+            byType,
+            avgResponseTime: undefined,
+            slowQueries: 0,
+            exceptions: byType.exception || 0,
+            unresolvedExceptions: 0,
+        };
+    }
+    async getStorageStats() {
+        const client = this.getClient();
+        const types = [
+            'request', 'query', 'exception', 'log', 'cache', 'event', 'job',
+            'schedule', 'mail', 'http-client', 'redis', 'model', 'notification',
+            'view', 'command', 'gate', 'batch', 'dump',
+        ];
+        const byType = {};
+        let total = 0;
+        for (const type of types) {
+            const count = await client.zcard(this.key('entries', 'type', type));
+            if (count > 0) {
+                byType[type] = count;
+                total += count;
+            }
+        }
+        // Get oldest and newest entries
+        const oldest = await client.zrange(this.key('entries', 'all'), 0, 0);
+        const newest = await client.zrevrange(this.key('entries', 'all'), 0, 0);
+        let oldestEntry = null;
+        let newestEntry = null;
+        if (oldest.length > 0) {
+            const hash = await client.hget(this.key('entries', oldest[0]), 'createdAt');
+            oldestEntry = hash ?? null;
+        }
+        if (newest.length > 0) {
+            const hash = await client.hget(this.key('entries', newest[0]), 'createdAt');
+            newestEntry = hash ?? null;
+        }
+        return {
+            total,
+            byType,
+            oldestEntry,
+            newestEntry,
+            databaseSize: undefined, // Redis doesn't expose this easily
+        };
+    }
+    // ==================== Pruning ====================
+    async prune(before) {
+        const client = this.getClient();
+        const maxScore = before.getTime();
+        const ids = await client.zrangebyscore(this.key('entries', 'all'), '-inf', maxScore);
+        if (ids.length === 0)
+            return 0;
+        for (const id of ids) {
+            await this.deleteEntry(parseInt(id, 10));
+        }
+        this.logger.log(`Pruned ${ids.length} entries older than ${before.toISOString()}`);
+        return ids.length;
+    }
+    async pruneByType(type, before) {
+        const client = this.getClient();
+        const maxScore = before.getTime();
+        const ids = await client.zrangebyscore(this.key('entries', 'type', type), '-inf', maxScore);
+        if (ids.length === 0)
+            return 0;
+        for (const id of ids) {
+            await this.deleteEntry(parseInt(id, 10));
+        }
+        return ids.length;
+    }
+    // ==================== Tag Methods ====================
+    async addTags(entryId, tags) {
+        const client = this.getClient();
+        const pipeline = client.pipeline();
+        for (const tag of tags) {
+            pipeline.sadd(this.key('tags', String(entryId)), tag);
+            pipeline.sadd(this.key('tags', 'index', tag), String(entryId));
+            pipeline.hincrby(this.key('tags', 'counts'), tag, 1);
+        }
+        await pipeline.exec();
+    }
+    async removeTags(entryId, tags) {
+        const client = this.getClient();
+        for (const tag of tags) {
+            await client.srem(this.key('tags', String(entryId)), tag);
+            await client.srem(this.key('tags', 'index', tag), String(entryId));
+            await client.hincrby(this.key('tags', 'counts'), tag, -1);
+        }
+    }
+    async getEntryTags(entryId) {
+        const client = this.getClient();
+        const tags = await client.smembers(this.key('tags', String(entryId)));
+        return tags.sort();
+    }
+    async getAllTags() {
+        const client = this.getClient();
+        const counts = await client.hgetall(this.key('tags', 'counts'));
+        return Object.entries(counts)
+            .map(([tag, count]) => ({ tag, count: parseInt(count, 10) }))
+            .filter((t) => t.count > 0)
+            .sort((a, b) => b.count - a.count || a.tag.localeCompare(b.tag));
+    }
+    async findByTags(tags, logic = 'OR', limit = 50) {
+        if (tags.length === 0)
+            return [];
+        const client = this.getClient();
+        const tagKeys = tags.map((t) => this.key('tags', 'index', t));
+        let ids;
+        if (logic === 'AND') {
+            ids = await client.sinter(...tagKeys);
+        }
+        else {
+            ids = await client.sunion(...tagKeys);
+        }
+        if (ids.length === 0)
+            return [];
+        const entries = await this.fetchEntriesByIds(ids.slice(0, limit));
+        const sorted = entries.sort((a, b) => b.id - a.id);
+        return this.hydrateEntriesWithTags(sorted);
+    }
+    // ==================== Monitored Tags ====================
+    async addMonitoredTag(tag) {
+        const client = this.getClient();
+        const existing = await client.hget(this.key('monitored'), tag);
+        if (existing) {
+            return JSON.parse(existing);
+        }
+        const id = await client.incr(this.key('monitored', 'sequence'));
+        const monitored = {
+            id,
+            tag,
+            createdAt: new Date().toISOString(),
+        };
+        await client.hset(this.key('monitored'), tag, JSON.stringify(monitored));
+        return monitored;
+    }
+    async removeMonitoredTag(tag) {
+        const client = this.getClient();
+        await client.hdel(this.key('monitored'), tag);
+    }
+    async getMonitoredTags() {
+        const client = this.getClient();
+        const all = await client.hgetall(this.key('monitored'));
+        return Object.values(all)
+            .filter((v) => v && v !== '')
+            .map((v) => JSON.parse(v))
+            .sort((a, b) => a.tag.localeCompare(b.tag));
+    }
+    // ==================== Resolution ====================
+    async resolveEntry(id) {
+        const client = this.getClient();
+        await client.hset(this.key('entries', String(id)), 'resolvedAt', new Date().toISOString());
+    }
+    async unresolveEntry(id) {
+        const client = this.getClient();
+        await client.hset(this.key('entries', String(id)), 'resolvedAt', '');
+    }
+    // ==================== Family Hash ====================
+    async updateFamilyHash(id, familyHash) {
+        const client = this.getClient();
+        await client.hset(this.key('entries', String(id)), 'familyHash', familyHash);
+        await client.sadd(this.key('family', familyHash), String(id));
+    }
+    async findByFamilyHash(familyHash, limit = 50) {
+        const client = this.getClient();
+        const ids = await client.smembers(this.key('family', familyHash));
+        if (ids.length === 0)
+            return [];
+        const entries = await this.fetchEntriesByIds(ids);
+        const sorted = entries.sort((a, b) => b.id - a.id).slice(0, limit);
+        return this.hydrateEntriesWithTags(sorted);
+    }
+    async getGroupedByFamilyHash(type, limit = 50) {
+        const client = this.getClient();
+        // Get all family hash keys
+        const familyKeys = await client.keys(this.key('family', '*'));
+        const groups = [];
+        for (const key of familyKeys) {
+            const familyHash = key.replace(this.key('family', ''), '');
+            const ids = await client.smembers(key);
+            if (ids.length === 0)
+                continue;
+            // Get entries for this family
+            const entries = await this.fetchEntriesByIds(ids);
+            const filtered = type ? entries.filter((e) => e.type === type) : entries;
+            if (filtered.length === 0)
+                continue;
+            // Sort and get latest
+            filtered.sort((a, b) => b.id - a.id);
+            const [latestEntry] = await this.hydrateEntriesWithTags([filtered[0]]);
+            groups.push({
+                familyHash,
+                count: filtered.length,
+                latestEntry,
+            });
+        }
+        return groups
+            .sort((a, b) => b.count - a.count || b.latestEntry.id - a.latestEntry.id)
+            .slice(0, limit);
+    }
+    // ==================== Lifecycle ====================
+    onModuleDestroy() {
+        this.close().catch((err) => {
+            this.logger.error('Error closing Redis connection', err);
+        });
+    }
+    // ==================== Private Helpers ====================
+    async fetchEntriesByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const client = this.getClient();
+        const pipeline = client.pipeline();
+        for (const id of ids) {
+            pipeline.hgetall(this.key('entries', id));
+        }
+        const results = await pipeline.exec();
+        const entries = [];
+        for (const [err, data] of results ?? []) {
+            if (err || !data || typeof data !== 'object')
+                continue;
+            const hash = data;
+            if (!hash.id)
+                continue;
+            const entry = this.hashToEntry(hash);
+            if (entry)
+                entries.push(entry);
+        }
+        return entries;
+    }
+    hashToEntry(hash) {
+        try {
+            return {
+                id: parseInt(hash.id, 10),
+                type: hash.type,
+                requestId: hash.requestId || undefined,
+                payload: JSON.parse(hash.payload || '{}'),
+                createdAt: hash.createdAt,
+                familyHash: hash.familyHash || undefined,
+                resolvedAt: hash.resolvedAt || undefined,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async hydrateEntriesWithTags(entries) {
+        const client = this.getClient();
+        const result = [];
+        for (const entry of entries) {
+            const tags = await client.smembers(this.key('tags', String(entry.id)));
+            result.push({ ...entry, tags: tags.sort() });
+        }
+        return result;
+    }
+    async deleteEntry(id) {
+        const client = this.getClient();
+        // Get entry to find its type
+        const hash = await client.hgetall(this.key('entries', String(id)));
+        if (!hash || !hash.type)
+            return;
+        // Remove from indexes
+        await client.del(this.key('entries', String(id)));
+        await client.zrem(this.key('entries', 'all'), String(id));
+        await client.zrem(this.key('entries', 'type', hash.type), String(id));
+        if (hash.requestId) {
+            await client.srem(this.key('entries', 'request', hash.requestId), String(id));
+        }
+        if (hash.familyHash) {
+            await client.srem(this.key('family', hash.familyHash), String(id));
+        }
+        // Remove tags
+        const tags = await client.smembers(this.key('tags', String(id)));
+        for (const tag of tags) {
+            await client.srem(this.key('tags', 'index', tag), String(id));
+            await client.hincrby(this.key('tags', 'counts'), tag, -1);
+        }
+        await client.del(this.key('tags', String(id)));
+    }
+    applyAdvancedFilters(entries, filters) {
+        if (!filters)
+            return entries;
+        return entries.filter((entry) => {
+            const payload = entry.payload;
+            // Apply the same filter logic as MemoryStorage
+            if (filters.levels?.length && entry.type === 'log') {
+                if (!filters.levels.includes(payload.level))
+                    return false;
+            }
+            if (filters.search) {
+                const payloadStr = JSON.stringify(payload).toLowerCase();
+                if (!payloadStr.includes(filters.search.toLowerCase()))
+                    return false;
+            }
+            if (filters.resolved !== undefined) {
+                const isResolved = !!entry.resolvedAt;
+                if (isResolved !== filters.resolved)
+                    return false;
+            }
+            // Additional filters can be added as needed
+            return true;
+        });
+    }
+};
+exports.RedisStorage = RedisStorage;
+exports.RedisStorage = RedisStorage = RedisStorage_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], RedisStorage);
+//# sourceMappingURL=redis.storage.js.map