@pioneer-platform/pioneer-cache 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @pioneer-platform/pioneer-cache
 
+## 1.0.5
+
+### Patch Changes
+
+- cache work
+- Updated dependencies
+  - @pioneer-platform/redis-queue@8.11.3
+
+## 1.0.4
+
+### Patch Changes
+
+- cache work
+- Updated dependencies
+  - @pioneer-platform/redis-queue@8.11.2
+
 ## 1.0.3
 
 ### Patch Changes

package/dist/core/base-cache.js

@@ -151,10 +151,11 @@ class BaseCache {
         const t0 = Date.now();
         try {
             // Redis timeout for cache reads
-            // PERFORMANCE FIX: Reduced from 10000ms to 100ms
-            // Local Redis should respond in <10ms. 100ms timeout prevents cascading failures
-            // when Redis is overloaded while still catching actual connection issues.
-            const timeoutMs = 100;
+            // 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(() => {
@@ -257,20 +258,34 @@ class BaseCache {
                 }
                 return;
             }
-            const job = {
-                type: `REFRESH_${this.config.name.toUpperCase()}`,
-                key: this.buildKey(params),
-                params,
-                priority,
-                retryCount: 0,
-                timestamp: Date.now()
-            };
-            // Queue job async (don't wait)
+            const key = this.buildKey(params);
+            // RATE LIMITING: Prevent duplicate refresh jobs within time window
+            // Use Redis SET NX EX for atomic rate limiting
+            const rateLimitKey = `refresh_lock:${key}`;
+            const rateLimitWindow = 5000; // 5 seconds - don't queue same refresh more than once per 5s
+            // Queue job async (don't wait) with rate limiting
             setImmediate(async () => {
                 try {
+                    // Try to acquire rate limit lock (atomic operation)
+                    const acquired = await this.redis.set(rateLimitKey, '1', 'PX', rateLimitWindow, // Expire in milliseconds
+                    'NX' // Only set if not exists
+                    );
+                    if (!acquired) {
+                        // Rate limit hit - job already queued recently
+                        log.debug(tag, `⏱️ Rate limit: Skip queuing ${key} (already queued in last ${rateLimitWindow}ms)`);
+                        return;
+                    }
+                    const job = {
+                        type: `REFRESH_${this.config.name.toUpperCase()}`,
+                        key,
+                        params,
+                        priority,
+                        retryCount: 0,
+                        timestamp: Date.now()
+                    };
                     await this.redisQueue.createWork(this.config.queueName, job);
                     if (this.config.logRefreshJobs) {
-                        log.debug(tag, `Queued refresh job: ${job.key} (priority: ${priority})`);
+                        log.debug(tag, `✅ Queued refresh job: ${job.key} (priority: ${priority})`);
                     }
                 }
                 catch (error) {

package/dist/core/cache-manager.d.ts

@@ -8,6 +8,7 @@ import type { HealthCheckResult } from '../types';
  */
 export interface CacheManagerConfig {
     redis: any;
+    redisQueue?: any;
     balanceModule?: any;
     markets?: any;
     enableBalanceCache?: boolean;
@@ -21,6 +22,7 @@ export interface CacheManagerConfig {
  */
 export declare class CacheManager {
     private redis;
+    private redisQueue;
     private balanceCache?;
     private priceCache?;
     private portfolioCache?;

package/dist/core/cache-manager.js

@@ -21,6 +21,7 @@ class CacheManager {
     constructor(config) {
         this.workers = [];
         this.redis = config.redis;
+        this.redisQueue = config.redisQueue || config.redis; // Fallback to main redis if not provided
         // Initialize Balance Cache
         if (config.enableBalanceCache !== false && config.balanceModule) {
             this.balanceCache = new balance_cache_1.BalanceCache(this.redis, config.balanceModule);
@@ -69,7 +70,8 @@ class CacheManager {
             }
             // Start unified worker if we have any caches with queues
             if (cacheRegistry.size > 0) {
-                const worker = await (0, refresh_worker_1.startUnifiedWorker)(this.redis, cacheRegistry, 'cache-refresh', // Unified queue name
+                const worker = await (0, refresh_worker_1.startUnifiedWorker)(this.redisQueue, // Use dedicated queue client for blocking operations
+                cacheRegistry, 'cache-refresh', // Unified queue name
                 {
                     maxRetries: 3,
                     retryDelay: 5000,

package/dist/stores/price-cache.d.ts

@@ -22,6 +22,7 @@ export declare class PriceCache extends BaseCache<PriceData> {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     protected fetchFromSource(params: Record<string, any>): Promise<PriceData>;
     /**

package/dist/stores/price-cache.js

@@ -55,6 +55,7 @@ class PriceCache extends base_cache_1.BaseCache {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     async fetchFromSource(params) {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -63,32 +64,36 @@ class PriceCache extends base_cache_1.BaseCache {
             // Use CAIP-first API (no symbol conversion needed!)
             // This directly queries the markets module with CAIP identifiers
             const price = await this.markets.getAssetPriceByCaip(caip);
-            // FIX #7: Gracefully handle zero prices without throwing
-            // This prevents disrupting batch operations during API rate limits
-            if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Price fetch returned $${price} for ${caip} (likely API timeout or rate limit) - returning stale cache if available`);
+            // FIX #8: Accept zero prices - they are VALID for unpriceable tokens
+            // Zero means "this token has no market value and we should stop trying to price it"
+            // Changed from: price <= 0 to: price < 0
+            if (isNaN(price) || price < 0) {
+                log.warn(tag, `Price fetch returned invalid price $${price} for ${caip} - returning stale cache if available`);
                 // Try to get stale cached value instead of failing
                 const key = this.buildKey(params);
                 const cachedValue = await this.getCached(key);
-                if (cachedValue && cachedValue.value.price > 0) {
+                if (cachedValue && cachedValue.value.price >= 0) {
                     log.info(tag, `Returning stale cached price for ${caip}: $${cachedValue.value.price}`);
                     return cachedValue.value;
                 }
                 // Try legacy cache as fallback
                 const legacyValue = await this.getLegacyCached(params);
-                if (legacyValue && legacyValue.price > 0) {
+                if (legacyValue && legacyValue.price >= 0) {
                     log.info(tag, `Returning legacy cached price for ${caip}: $${legacyValue.price}`);
                     return legacyValue;
                 }
-                // Last resort: return zero price but don't cache it
-                log.warn(tag, `No cached price available for ${caip}, returning zero`);
+                // Last resort: throw error for truly invalid prices
+                log.warn(tag, `No cached price available for ${caip}, invalid price: $${price}`);
                 throw new Error(`No valid price available for ${caip}`);
             }
             log.debug(tag, `Fetched price for ${caip}: $${price}`);
+            // FIX #8: Mark zero prices with special source to indicate they are unpriceable tokens
+            // This allows us to track and monitor unpriceable token caching
+            const source = price === 0 ? 'unpriceable' : 'markets-caip';
             return {
                 caip,
                 price,
-                source: 'markets-caip'
+                source
             };
         }
         catch (error) {

package/dist/workers/refresh-worker.d.ts

@@ -35,6 +35,7 @@ export declare class RefreshWorker {
     stop(): Promise<void>;
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     private poll;
     /**

package/dist/workers/refresh-worker.js

@@ -72,6 +72,7 @@ class RefreshWorker {
     }
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     async poll() {
         const tag = TAG + 'poll | ';
@@ -79,6 +80,7 @@ class RefreshWorker {
             return;
         }
         try {
+            // FIX #3: Atomic check-and-set to prevent race conditions
             // Don't poll if already processing
             if (this.isProcessing) {
                 this.schedulePoll();
@@ -87,14 +89,20 @@ class RefreshWorker {
             // Get next job from queue
             const work = await this.redisQueue.getWork(this.config.queueName, 1);
             if (work) {
+                // Set processing flag BEFORE processing to prevent double execution
                 this.isProcessing = true;
-                await this.processJob(work);
-                this.isProcessing = false;
+                try {
+                    await this.processJob(work);
+                }
+                finally {
+                    // Always clear flag, even if processJob throws
+                    this.isProcessing = false;
+                }
             }
         }
         catch (error) {
             log.error(tag, 'Error in poll loop:', error.message);
-            this.isProcessing = false;
+            // Flag already cleared in inner finally block
         }
         finally {
             // Schedule next poll
@@ -138,7 +146,18 @@ class RefreshWorker {
         catch (error) {
             const processingTime = Date.now() - startTime;
             log.error(tag, `❌ Failed to process ${job.type} after ${processingTime}ms:`, error);
-            // Retry logic
+            // FIX #1: Detect permanent failures (don't retry unpriceable tokens)
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isPermanentFailure = (errorMsg.includes('No valid price available') ||
+                errorMsg.includes('unpriceable') ||
+                errorMsg.includes('not found') ||
+                errorMsg.includes('404'));
+            if (isPermanentFailure) {
+                log.warn(tag, `Permanent failure detected for ${job.type}, will not retry: ${errorMsg}`);
+                // Don't retry - job complete (failed permanently)
+                return;
+            }
+            // Retry logic (only for transient failures)
             if ((job.retryCount || 0) < this.config.maxRetries) {
                 const newRetryCount = (job.retryCount || 0) + 1;
                 log.info(tag, `Retrying job (attempt ${newRetryCount}/${this.config.maxRetries})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "@pioneer-platform/loggerdog": "^8.11.0",
-    "@pioneer-platform/redis-queue": "^8.11.1",
+    "@pioneer-platform/redis-queue": "^8.11.3",
     "@pioneer-platform/default-redis": "^8.11.7"
   },
   "devDependencies": {

package/src/core/base-cache.ts

@@ -185,10 +185,11 @@ export abstract class BaseCache<T> {
 
         try {
             // Redis timeout for cache reads
-            // PERFORMANCE FIX: Reduced from 10000ms to 100ms
-            // Local Redis should respond in <10ms. 100ms timeout prevents cascading failures
-            // when Redis is overloaded while still catching actual connection issues.
-            const timeoutMs = 100;
+            // 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(() => {
@@ -307,22 +308,43 @@ export abstract class BaseCache<T> {
                 return;
             }
 
-            const job: RefreshJob = {
-                type: `REFRESH_${this.config.name.toUpperCase()}`,
-                key: this.buildKey(params),
-                params,
-                priority,
-                retryCount: 0,
-                timestamp: Date.now()
-            };
+            const key = this.buildKey(params);
 
-            // Queue job async (don't wait)
+            // RATE LIMITING: Prevent duplicate refresh jobs within time window
+            // Use Redis SET NX EX for atomic rate limiting
+            const rateLimitKey = `refresh_lock:${key}`;
+            const rateLimitWindow = 5000; // 5 seconds - don't queue same refresh more than once per 5s
+
+            // Queue job async (don't wait) with rate limiting
             setImmediate(async () => {
                 try {
+                    // Try to acquire rate limit lock (atomic operation)
+                    const acquired = await this.redis.set(
+                        rateLimitKey,
+                        '1',
+                        'PX', rateLimitWindow,  // Expire in milliseconds
+                        'NX'  // Only set if not exists
+                    );
+
+                    if (!acquired) {
+                        // Rate limit hit - job already queued recently
+                        log.debug(tag, `⏱️ Rate limit: Skip queuing ${key} (already queued in last ${rateLimitWindow}ms)`);
+                        return;
+                    }
+
+                    const job: RefreshJob = {
+                        type: `REFRESH_${this.config.name.toUpperCase()}`,
+                        key,
+                        params,
+                        priority,
+                        retryCount: 0,
+                        timestamp: Date.now()
+                    };
+
                     await this.redisQueue.createWork(this.config.queueName, job);
 
                     if (this.config.logRefreshJobs) {
-                        log.debug(tag, `Queued refresh job: ${job.key} (priority: ${priority})`);
+                        log.debug(tag, `✅ Queued refresh job: ${job.key} (priority: ${priority})`);
                     }
 
                 } catch (error) {

package/src/core/cache-manager.ts

@@ -21,6 +21,7 @@ const TAG = ' | CacheManager | ';
  */
 export interface CacheManagerConfig {
     redis: any;
+    redisQueue?: any;                      // Dedicated Redis client for blocking queue operations (brpop, etc.)
     balanceModule?: any;                   // Optional: if not provided, balance cache won't be initialized
     markets?: any;                         // Optional: if not provided, price cache won't be initialized
     enableBalanceCache?: boolean;
@@ -35,6 +36,7 @@ export interface CacheManagerConfig {
  */
 export class CacheManager {
     private redis: any;
+    private redisQueue: any;  // Dedicated client for blocking operations
     private balanceCache?: BalanceCache;
     private priceCache?: PriceCache;
     private portfolioCache?: PortfolioCache;
@@ -43,6 +45,7 @@ export class CacheManager {
 
     constructor(config: CacheManagerConfig) {
         this.redis = config.redis;
+        this.redisQueue = config.redisQueue || config.redis;  // Fallback to main redis if not provided
 
         // Initialize Balance Cache
         if (config.enableBalanceCache !== false && config.balanceModule) {
@@ -105,7 +108,7 @@ export class CacheManager {
             // Start unified worker if we have any caches with queues
             if (cacheRegistry.size > 0) {
                 const worker = await startUnifiedWorker(
-                    this.redis,
+                    this.redisQueue,                // Use dedicated queue client for blocking operations
                     cacheRegistry,
                     'cache-refresh',                // Unified queue name
                     {

package/src/stores/price-cache.ts

@@ -71,6 +71,7 @@ export class PriceCache extends BaseCache<PriceData> {
     /**
      * Fetch price from markets API using CAIP-first approach
      * FIX #7: Graceful handling of zero prices to prevent cache disruption
+     * FIX #8: Cache zero prices for unpriceable tokens to prevent infinite retry loops
      */
     protected async fetchFromSource(params: Record<string, any>): Promise<PriceData> {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -82,38 +83,43 @@ export class PriceCache extends BaseCache<PriceData> {
             // This directly queries the markets module with CAIP identifiers
             const price = await this.markets.getAssetPriceByCaip(caip);
 
-            // FIX #7: Gracefully handle zero prices without throwing
-            // This prevents disrupting batch operations during API rate limits
-            if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Price fetch returned $${price} for ${caip} (likely API timeout or rate limit) - returning stale cache if available`);
+            // FIX #8: Accept zero prices - they are VALID for unpriceable tokens
+            // Zero means "this token has no market value and we should stop trying to price it"
+            // Changed from: price <= 0 to: price < 0
+            if (isNaN(price) || price < 0) {
+                log.warn(tag, `Price fetch returned invalid price $${price} for ${caip} - returning stale cache if available`);
 
                 // Try to get stale cached value instead of failing
                 const key = this.buildKey(params);
                 const cachedValue = await this.getCached(key);
 
-                if (cachedValue && cachedValue.value.price > 0) {
+                if (cachedValue && cachedValue.value.price >= 0) {
                     log.info(tag, `Returning stale cached price for ${caip}: $${cachedValue.value.price}`);
                     return cachedValue.value;
                 }
 
                 // Try legacy cache as fallback
                 const legacyValue = await this.getLegacyCached(params);
-                if (legacyValue && legacyValue.price > 0) {
+                if (legacyValue && legacyValue.price >= 0) {
                     log.info(tag, `Returning legacy cached price for ${caip}: $${legacyValue.price}`);
                     return legacyValue;
                 }
 
-                // Last resort: return zero price but don't cache it
-                log.warn(tag, `No cached price available for ${caip}, returning zero`);
+                // Last resort: throw error for truly invalid prices
+                log.warn(tag, `No cached price available for ${caip}, invalid price: $${price}`);
                 throw new Error(`No valid price available for ${caip}`);
             }
 
             log.debug(tag, `Fetched price for ${caip}: $${price}`);
 
+            // FIX #8: Mark zero prices with special source to indicate they are unpriceable tokens
+            // This allows us to track and monitor unpriceable token caching
+            const source = price === 0 ? 'unpriceable' : 'markets-caip';
+
             return {
                 caip,
                 price,
-                source: 'markets-caip'
+                source
             };
 
         } catch (error) {

package/src/workers/refresh-worker.ts

@@ -100,6 +100,7 @@ export class RefreshWorker {
 
     /**
      * Poll for next job from the queue
+     * FIX #3: Atomic flag check and job processing to prevent race conditions
      */
     private async poll(): Promise<void> {
         const tag = TAG + 'poll | ';
@@ -109,6 +110,7 @@ export class RefreshWorker {
         }
 
         try {
+            // FIX #3: Atomic check-and-set to prevent race conditions
             // Don't poll if already processing
             if (this.isProcessing) {
                 this.schedulePoll();
@@ -119,14 +121,19 @@ export class RefreshWorker {
             const work = await this.redisQueue.getWork(this.config.queueName, 1);
 
             if (work) {
+                // Set processing flag BEFORE processing to prevent double execution
                 this.isProcessing = true;
-                await this.processJob(work);
-                this.isProcessing = false;
+                try {
+                    await this.processJob(work);
+                } finally {
+                    // Always clear flag, even if processJob throws
+                    this.isProcessing = false;
+                }
             }
 
         } catch (error: any) {
             log.error(tag, 'Error in poll loop:', error.message);
-            this.isProcessing = false;
+            // Flag already cleared in inner finally block
         } finally {
             // Schedule next poll
             this.schedulePoll();
@@ -180,7 +187,22 @@ export class RefreshWorker {
             const processingTime = Date.now() - startTime;
             log.error(tag, `❌ Failed to process ${job.type} after ${processingTime}ms:`, error);
 
-            // Retry logic
+            // FIX #1: Detect permanent failures (don't retry unpriceable tokens)
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isPermanentFailure = (
+                errorMsg.includes('No valid price available') ||
+                errorMsg.includes('unpriceable') ||
+                errorMsg.includes('not found') ||
+                errorMsg.includes('404')
+            );
+
+            if (isPermanentFailure) {
+                log.warn(tag, `Permanent failure detected for ${job.type}, will not retry: ${errorMsg}`);
+                // Don't retry - job complete (failed permanently)
+                return;
+            }
+
+            // Retry logic (only for transient failures)
             if ((job.retryCount || 0) < this.config.maxRetries) {
                 const newRetryCount = (job.retryCount || 0) + 1;
                 log.info(tag, `Retrying job (attempt ${newRetryCount}/${this.config.maxRetries})`);