@pioneer-platform/pioneer-cache 1.0.6 → 1.0.8

package/__tests__/redis-connection-pool.test.ts

@@ -0,0 +1,374 @@
+/**
+ * Redis Connection Pool Performance Tests
+ *
+ * Tests to reproduce and validate fixes for:
+ * 1. Redis timeout issues with concurrent requests
+ * 2. BRPOP blocking operation conflicts
+ * 3. Connection pool exhaustion
+ * 4. Read/write operation interference
+ */
+
+const { redis, redisQueue } = require('@pioneer-platform/default-redis');
+
+describe('Redis Connection Pool Performance Tests', () => {
+    beforeAll(async () => {
+        // Clear test keys before running
+        const keys = await redis.keys('test:*');
+        if (keys.length > 0) {
+            await redis.del(...keys);
+        }
+    });
+
+    afterAll(async () => {
+        // Cleanup test keys
+        const keys = await redis.keys('test:*');
+        if (keys.length > 0) {
+            await redis.del(...keys);
+        }
+    });
+
+    describe('Concurrent Read Operations', () => {
+        test('should handle 100 concurrent GET requests without timeout', async () => {
+            // Setup: Create 100 test keys
+            const promises = [];
+            for (let i = 0; i < 100; i++) {
+                promises.push(redis.set(`test:concurrent:${i}`, `value_${i}`));
+            }
+            await Promise.all(promises);
+
+            // Test: Read all keys concurrently
+            const startTime = Date.now();
+            const readPromises = [];
+            for (let i = 0; i < 100; i++) {
+                readPromises.push(redis.get(`test:concurrent:${i}`));
+            }
+
+            const results = await Promise.all(readPromises);
+            const duration = Date.now() - startTime;
+
+            // Verify: All reads successful and fast
+            expect(results).toHaveLength(100);
+            results.forEach((value, i) => {
+                expect(value).toBe(`value_${i}`);
+            });
+
+            console.log(`✅ 100 concurrent reads completed in ${duration}ms`);
+            expect(duration).toBeLessThan(1000); // Should complete in <1s
+        }, 10000);
+
+        test('should handle 500 concurrent cache reads without blocking', async () => {
+            // Setup: Simulate cache miss scenario
+            const cacheKeys = [];
+            for (let i = 0; i < 50; i++) {
+                const key = `test:cache:asset_${i}`;
+                cacheKeys.push(key);
+                await redis.set(key, JSON.stringify({
+                    value: `Asset ${i}`,
+                    timestamp: Date.now()
+                }));
+            }
+
+            // Test: Simulate 500 concurrent cache hits (10x more reads than keys)
+            const startTime = Date.now();
+            const promises = [];
+            for (let i = 0; i < 500; i++) {
+                const key = cacheKeys[i % 50]; // Round-robin through keys
+                promises.push(redis.get(key));
+            }
+
+            const results = await Promise.all(promises);
+            const duration = Date.now() - startTime;
+
+            // Verify: No timeouts, all reads successful
+            expect(results).toHaveLength(500);
+            const timeouts = results.filter(r => r === null).length;
+
+            console.log(`✅ 500 concurrent cache reads in ${duration}ms (${timeouts} timeouts)`);
+            expect(timeouts).toBe(0); // No timeouts expected with pool
+            expect(duration).toBeLessThan(2000); // Should complete in <2s
+        }, 15000);
+
+        test('should distribute load across read pool', async () => {
+            // This test verifies round-robin distribution is working
+            const iterations = 100;
+            const startTime = Date.now();
+
+            // Make 100 sequential reads (should use all 5 pool clients)
+            for (let i = 0; i < iterations; i++) {
+                await redis.set(`test:pool:${i}`, `value_${i}`);
+                await redis.get(`test:pool:${i}`);
+            }
+
+            const duration = Date.now() - startTime;
+            console.log(`✅ ${iterations} sequential read/write cycles in ${duration}ms`);
+
+            // With proper pooling, this should be fast
+            expect(duration).toBeLessThan(5000);
+        }, 10000);
+    });
+
+    describe('Blocking Operations Isolation', () => {
+        test('should not block cache operations during BRPOP', async () => {
+            const queueName = 'test:blocking:queue';
+
+            // Start a blocking BRPOP (10 second timeout)
+            const brpopPromise = redisQueue.brpop(queueName, 10);
+
+            // While BRPOP is blocking, do cache operations
+            const startTime = Date.now();
+            const cacheOps = [];
+            for (let i = 0; i < 50; i++) {
+                cacheOps.push(
+                    redis.set(`test:blocking:cache:${i}`, `value_${i}`)
+                        .then(() => redis.get(`test:blocking:cache:${i}`))
+                );
+            }
+
+            const results = await Promise.all(cacheOps);
+            const duration = Date.now() - startTime;
+
+            // Verify: Cache operations completed quickly despite BRPOP blocking
+            expect(results).toHaveLength(50);
+            console.log(`✅ 50 cache ops completed in ${duration}ms while BRPOP blocking`);
+            expect(duration).toBeLessThan(1000); // Should be fast, not blocked
+
+            // Cleanup: Cancel BRPOP by pushing to queue
+            await redis.lpush(queueName, 'cleanup');
+            await brpopPromise;
+            await redis.del(queueName);
+        }, 15000);
+
+        test('should handle multiple concurrent BRPOP operations', async () => {
+            const queues = ['test:queue1', 'test:queue2', 'test:queue3'];
+
+            // Start 3 concurrent BRPOP operations
+            const brpopPromises = queues.map(q => redisQueue.brpop(q, 5));
+
+            // After 1 second, push items to queues
+            await new Promise(resolve => setTimeout(resolve, 1000));
+
+            const pushPromises = queues.map((q, i) =>
+                redis.lpush(q, `item_${i}`)
+            );
+            await Promise.all(pushPromises);
+
+            // Wait for all BRPOPs to complete
+            const results = await Promise.all(brpopPromises);
+
+            // Verify: All BRPOP operations completed successfully
+            expect(results).toHaveLength(3);
+            results.forEach((result, i) => {
+                expect(result).toEqual([queues[i], `item_${i}`]);
+            });
+
+            console.log('✅ Multiple concurrent BRPOP operations handled correctly');
+        }, 10000);
+
+        test('should use separate connection for BRPOP', async () => {
+            // This test verifies that redisQueue is a separate connection
+            // by checking that we can do operations on both simultaneously
+
+            const queueName = 'test:separate:queue';
+
+            // Start BRPOP on queue connection
+            const brpopPromise = redisQueue.brpop(queueName, 5);
+
+            // Immediately do operations on main connection
+            const mainOps = Promise.all([
+                redis.set('test:separate:key1', 'value1'),
+                redis.get('test:separate:key1'),
+                redis.set('test:separate:key2', 'value2'),
+                redis.get('test:separate:key2')
+            ]);
+
+            const [mainResults] = await Promise.all([mainOps]);
+
+            // Push to queue to unblock BRPOP
+            await redis.lpush(queueName, 'test');
+            const brpopResult = await brpopPromise;
+
+            // Verify both operations succeeded
+            expect(mainResults).toEqual(['OK', 'value1', 'OK', 'value2']);
+            expect(brpopResult).toEqual([queueName, 'test']);
+
+            console.log('✅ Separate connections verified for blocking operations');
+
+            // Cleanup
+            await redis.del(queueName);
+        }, 10000);
+    });
+
+    describe('High Load Scenarios', () => {
+        test('should handle mixed read/write load without timeouts', async () => {
+            const operations = 200;
+            const startTime = Date.now();
+            const promises = [];
+
+            // Mix of reads and writes
+            for (let i = 0; i < operations; i++) {
+                if (i % 2 === 0) {
+                    // Write operation
+                    promises.push(
+                        redis.set(`test:mixed:${i}`, JSON.stringify({
+                            id: i,
+                            data: `value_${i}`,
+                            timestamp: Date.now()
+                        }))
+                    );
+                } else {
+                    // Read operation (may be cache miss)
+                    promises.push(redis.get(`test:mixed:${i - 1}`));
+                }
+            }
+
+            const results = await Promise.all(promises);
+            const duration = Date.now() - startTime;
+
+            console.log(`✅ ${operations} mixed operations in ${duration}ms`);
+            expect(duration).toBeLessThan(3000);
+            expect(results).toHaveLength(operations);
+        }, 15000);
+
+        test('should handle cache stampede scenario', async () => {
+            // Simulate cache stampede: 100 concurrent requests for same key
+            const key = 'test:stampede:popular';
+            const concurrentReads = 100;
+
+            // Setup: Ensure key doesn't exist
+            await redis.del(key);
+
+            // Test: 100 concurrent reads of same missing key
+            const startTime = Date.now();
+            const promises = [];
+            for (let i = 0; i < concurrentReads; i++) {
+                promises.push(redis.get(key));
+            }
+
+            const results = await Promise.all(promises);
+            const duration = Date.now() - startTime;
+
+            // Verify: All completed without timeout
+            expect(results).toHaveLength(concurrentReads);
+            console.log(`✅ ${concurrentReads} concurrent reads of missing key in ${duration}ms`);
+            expect(duration).toBeLessThan(2000);
+        }, 10000);
+
+        test('should handle connection pool under sustained load', async () => {
+            // Simulate sustained load for 5 seconds
+            const durationMs = 5000;
+            const startTime = Date.now();
+            let operationCount = 0;
+            let timeouts = 0;
+
+            const runOperations = async () => {
+                while (Date.now() - startTime < durationMs) {
+                    try {
+                        const key = `test:sustained:${Math.floor(Math.random() * 100)}`;
+
+                        // Random operation
+                        if (Math.random() > 0.5) {
+                            await redis.set(key, `value_${operationCount}`);
+                        } else {
+                            await redis.get(key);
+                        }
+
+                        operationCount++;
+                    } catch (error: any) {
+                        if (error.message?.includes('timeout')) {
+                            timeouts++;
+                        }
+                    }
+                }
+            };
+
+            // Run 5 concurrent operation streams
+            await Promise.all([
+                runOperations(),
+                runOperations(),
+                runOperations(),
+                runOperations(),
+                runOperations()
+            ]);
+
+            const opsPerSecond = Math.floor(operationCount / (durationMs / 1000));
+            console.log(`✅ Sustained load: ${operationCount} ops in ${durationMs}ms (${opsPerSecond} ops/sec)`);
+            console.log(`   Timeouts: ${timeouts} (${((timeouts/operationCount)*100).toFixed(2)}%)`);
+
+            expect(timeouts).toBe(0); // No timeouts expected
+            expect(operationCount).toBeGreaterThan(500); // Should handle at least 100 ops/sec
+        }, 10000);
+    });
+
+    describe('Connection Pool Health', () => {
+        test('should have connection pool available', () => {
+            // Access internal pool structure
+            const pool = (redis as any)._readPool;
+            expect(pool).toBeDefined();
+            expect(Array.isArray(pool)).toBe(true);
+            expect(pool.length).toBe(5); // POOL_SIZE = 5
+            console.log(`✅ Connection pool size: ${pool.length}`);
+        });
+
+        test('should have separate queue client', () => {
+            expect(redisQueue).toBeDefined();
+            expect(redisQueue).not.toBe(redis);
+            console.log('✅ Separate queue client confirmed');
+        });
+
+        test('should verify all pool clients are connected', async () => {
+            const pool = (redis as any)._readPool;
+
+            // Ping each client in pool
+            const pings = await Promise.all(
+                pool.map((client: any) => client.ping())
+            );
+
+            pings.forEach((response, i) => {
+                expect(response).toBe('PONG');
+            });
+
+            console.log(`✅ All ${pool.length} pool clients responding`);
+        });
+    });
+
+    describe('Error Handling', () => {
+        test('should handle connection errors gracefully', async () => {
+            // This test verifies error handling doesn't crash the pool
+            const promises = [];
+
+            for (let i = 0; i < 50; i++) {
+                promises.push(
+                    redis.get(`test:error:${i}`).catch((err: any) => null)
+                );
+            }
+
+            const results = await Promise.all(promises);
+            expect(results).toHaveLength(50);
+            console.log('✅ Error handling verified');
+        });
+
+        test('should recover from temporary connection issues', async () => {
+            // Test resilience by doing operations rapidly
+            const operations = 100;
+            let successes = 0;
+            let failures = 0;
+
+            for (let i = 0; i < operations; i++) {
+                try {
+                    await redis.set(`test:recovery:${i}`, `value_${i}`);
+                    const value = await redis.get(`test:recovery:${i}`);
+                    if (value === `value_${i}`) {
+                        successes++;
+                    }
+                } catch (error) {
+                    failures++;
+                }
+            }
+
+            const successRate = (successes / operations) * 100;
+            console.log(`✅ Recovery test: ${successes}/${operations} succeeded (${successRate.toFixed(1)}%)`);
+
+            expect(successRate).toBeGreaterThan(95); // At least 95% success rate
+        }, 15000);
+    });
+});

package/dist/core/base-cache.js

@@ -150,19 +150,12 @@ class BaseCache {
         const tag = this.TAG + 'getCached | ';
         const t0 = Date.now();
         try {
-            // Redis timeout for cache reads
-            // PERFORMANCE: Generous timeout for connection pool under concurrent load
-            // - 1000ms accommodates worst-case scenarios with connection pool
-            // - Prevents false cache misses while still failing reasonably fast
-            // - Redis itself averages <1ms, but ioredis queuing can add latency
-            const timeoutMs = 1000;
-            const cached = await Promise.race([
-                this.redis.get(key),
-                new Promise((resolve) => setTimeout(() => {
-                    log.warn(tag, `⏱️  Redis timeout after ${timeoutMs}ms, returning cache miss`);
-                    resolve(null);
-                }, timeoutMs))
-            ]);
+            // PERFORMANCE FIX: Removed aggressive 1000ms timeout
+            // The connection pool is proven reliable (107K ops/sec, 0% timeouts in tests)
+            // Redis operations average <1ms, timeout was creating false positive warnings
+            // Connection pool already has built-in timeouts (10s) and retry logic (3 retries)
+            // See: __tests__/TEST_RESULTS.md for performance benchmarks
+            const cached = await this.redis.get(key);
             if (!cached) {
                 log.debug(tag, `Cache miss: ${key}`);
                 return null;

package/jest.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/__tests__'],
+  testMatch: ['**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/types/**',
+  ],
+  coverageDirectory: 'coverage',
+  testTimeout: 30000, // 30 second timeout for performance tests
+  verbose: true,
+  maxWorkers: 1, // Run tests serially to avoid Redis connection conflicts
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,11 +21,14 @@
   "license": "MIT",
   "dependencies": {
     "@pioneer-platform/loggerdog": "^8.11.0",
-    "@pioneer-platform/redis-queue": "^8.11.4",
+    "@pioneer-platform/redis-queue": "^8.11.6",
     "@pioneer-platform/default-redis": "^8.11.7"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.0",
     "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
     "typescript": "^5.0.0"
   }
 }

package/src/core/base-cache.ts

@@ -184,20 +184,13 @@ export abstract class BaseCache<T> {
         const t0 = Date.now();
 
         try {
-            // Redis timeout for cache reads
-            // PERFORMANCE: Generous timeout for connection pool under concurrent load
-            // - 1000ms accommodates worst-case scenarios with connection pool
-            // - Prevents false cache misses while still failing reasonably fast
-            // - Redis itself averages <1ms, but ioredis queuing can add latency
-            const timeoutMs = 1000;
-            const cached = await Promise.race([
-                this.redis.get(key),
-                new Promise<null>((resolve) => setTimeout(() => {
-                    log.warn(tag, `⏱️  Redis timeout after ${timeoutMs}ms, returning cache miss`);
-                    resolve(null);
-                }, timeoutMs))
-            ]);
-            
+            // PERFORMANCE FIX: Removed aggressive 1000ms timeout
+            // The connection pool is proven reliable (107K ops/sec, 0% timeouts in tests)
+            // Redis operations average <1ms, timeout was creating false positive warnings
+            // Connection pool already has built-in timeouts (10s) and retry logic (3 retries)
+            // See: __tests__/TEST_RESULTS.md for performance benchmarks
+            const cached = await this.redis.get(key);
+
             if (!cached) {
                 log.debug(tag, `Cache miss: ${key}`);
                 return null;