@fjell/cache 4.7.42 → 4.7.44

package/dist/index.js

@@ -94,48 +94,78 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Set a query result with rich metadata for two-layer architecture
    */
   async setQueryResult(queryHash, itemKeys) {
+    logger.debug("QUERY_CACHE: TwoLayerCacheMap.setQueryResult() called", {
+      queryHash,
+      itemKeyCount: itemKeys.length,
+      itemKeys: itemKeys.map((k) => JSON.stringify(k))
+    });
     await this.underlyingCache.setQueryResult(queryHash, itemKeys);
+    logger.debug("QUERY_CACHE: Stored query result in underlying cache", { queryHash });
     const now = /* @__PURE__ */ new Date();
     const isComplete = this.determineQueryCompleteness(queryHash, itemKeys);
     const ttlSeconds = isComplete ? this.options.queryTTL : this.options.facetTTL;
+    const expiresAt = new Date(now.getTime() + ttlSeconds * 1e3);
     const metadata = {
       queryType: this.extractQueryType(queryHash),
       isComplete,
       createdAt: now,
-      expiresAt: new Date(now.getTime() + ttlSeconds * 1e3),
+      expiresAt,
       filter: this.extractFilter(queryHash),
       params: this.extractParams(queryHash)
     };
     this.queryMetadataMap.set(queryHash, metadata);
-    if (this.options.debug) {
-      logger.debug("Set query result with metadata", {
-        queryHash,
-        itemCount: itemKeys.length,
-        isComplete,
-        ttlSeconds,
-        expiresAt: metadata.expiresAt.toISOString()
-      });
-    }
+    logger.debug("QUERY_CACHE: Set query result with metadata", {
+      queryHash,
+      itemCount: itemKeys.length,
+      isComplete,
+      ttlSeconds,
+      queryType: metadata.queryType,
+      createdAt: metadata.createdAt.toISOString(),
+      expiresAt: metadata.expiresAt.toISOString(),
+      filter: metadata.filter,
+      params: metadata.params
+    });
   }
   /**
    * Get a query result with expiration checking
    */
   async getQueryResult(queryHash) {
+    logger.debug("QUERY_CACHE: TwoLayerCacheMap.getQueryResult() called", { queryHash });
     const metadata = this.queryMetadataMap.get(queryHash);
-    if (metadata && metadata.expiresAt < /* @__PURE__ */ new Date()) {
-      await this.deleteQueryResult(queryHash);
-      if (this.options.debug) {
-        logger.debug("Query result expired and removed", { queryHash });
+    if (metadata) {
+      const now = /* @__PURE__ */ new Date();
+      const isExpired = metadata.expiresAt < now;
+      logger.debug("QUERY_CACHE: Query metadata found", {
+        queryHash,
+        isExpired,
+        expiresAt: metadata.expiresAt.toISOString(),
+        now: now.toISOString(),
+        isComplete: metadata.isComplete,
+        queryType: metadata.queryType
+      });
+      if (isExpired) {
+        logger.debug("QUERY_CACHE: Query result EXPIRED, removing", {
+          queryHash,
+          expiresAt: metadata.expiresAt.toISOString(),
+          now: now.toISOString()
+        });
+        await this.deleteQueryResult(queryHash);
+        return null;
       }
-      return null;
+    } else {
+      logger.debug("QUERY_CACHE: No metadata found for query hash", { queryHash });
     }
+    logger.debug("QUERY_CACHE: Fetching query result from underlying cache", { queryHash });
     const result = await this.underlyingCache.getQueryResult(queryHash);
-    if (result && this.options.debug) {
-      logger.debug("Query result cache hit", {
+    if (result) {
+      logger.debug("QUERY_CACHE: Query result retrieved from underlying cache", {
         queryHash,
         itemCount: result.length,
-        isComplete: metadata?.isComplete
+        isComplete: metadata?.isComplete,
+        itemKeys: result.map((k) => JSON.stringify(k))
       });
+    } else {
+      logger.debug("QUERY_CACHE: No query result found in underlying cache", { queryHash });
     }
     return result;
   }
@@ -150,25 +180,44 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Delete a query result and its metadata
    */
   async deleteQueryResult(queryHash) {
+    logger.debug("QUERY_CACHE: TwoLayerCacheMap.deleteQueryResult() called", { queryHash });
+    const hadMetadata = this.queryMetadataMap.has(queryHash);
+    const metadata = this.queryMetadataMap.get(queryHash);
     await this.underlyingCache.deleteQueryResult(queryHash);
     this.queryMetadataMap.delete(queryHash);
-    if (this.options.debug) {
-      logger.debug("Deleted query result", { queryHash });
-    }
+    logger.debug("QUERY_CACHE: Deleted query result", {
+      queryHash,
+      hadMetadata,
+      wasComplete: metadata?.isComplete,
+      queryType: metadata?.queryType
+    });
   }
   // ===== QUERY INVALIDATION (CRITICAL FOR TWO-LAYER ARCHITECTURE) =====
   /**
    * Invalidate queries that are affected by item changes
    */
   async invalidateQueriesForItem(itemKey) {
+    logger.debug("QUERY_CACHE: Invalidating queries for item change", {
+      itemKey: JSON.stringify(itemKey)
+    });
     const affectedQueries = await this.findQueriesContainingItem(itemKey);
+    logger.debug("QUERY_CACHE: Found queries containing item", {
+      itemKey: JSON.stringify(itemKey),
+      affectedQueryCount: affectedQueries.length,
+      affectedQueries
+    });
     for (const queryHash of affectedQueries) {
       await this.deleteQueryResult(queryHash);
     }
-    if (this.options.debug && affectedQueries.length > 0) {
-      logger.debug("Invalidated queries for item change", {
+    if (affectedQueries.length > 0) {
+      logger.debug("QUERY_CACHE: Invalidated queries for item change", {
         itemKey: JSON.stringify(itemKey),
-        queriesInvalidated: affectedQueries.length
+        queriesInvalidated: affectedQueries.length,
+        queryHashes: affectedQueries
+      });
+    } else {
+      logger.debug("QUERY_CACHE: No queries found containing item", {
+        itemKey: JSON.stringify(itemKey)
       });
     }
   }
@@ -191,6 +240,9 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Determine if a query result is complete or partial based on query hash
    */
   determineQueryCompleteness(queryHash, itemKeys) {
+    if (queryHash.includes('"query":{}') || queryHash.includes('"query": {}')) {
+      return true;
+    }
     if (queryHash.includes("facet:") || queryHash.includes("filter:")) {
       return false;
     }
@@ -304,18 +356,40 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
    * Clean up expired queries
    */
   async cleanup() {
+    const startTime = Date.now();
     const now = /* @__PURE__ */ new Date();
     const expiredQueries = [];
+    logger.debug("TWO_LAYER: Starting query cleanup", {
+      totalQueries: this.queryMetadataMap.size,
+      now: now.toISOString()
+    });
     for (const [queryHash, metadata] of this.queryMetadataMap.entries()) {
       if (metadata.expiresAt < now) {
         expiredQueries.push(queryHash);
+        logger.debug("TWO_LAYER: Found expired query", {
+          queryHash,
+          queryType: metadata.queryType,
+          isComplete: metadata.isComplete,
+          expiresAt: metadata.expiresAt.toISOString(),
+          expiredByMs: now.getTime() - metadata.expiresAt.getTime()
+        });
       }
     }
     for (const queryHash of expiredQueries) {
       await this.deleteQueryResult(queryHash);
     }
-    if (this.options.debug && expiredQueries.length > 0) {
-      logger.debug("Cleaned up expired queries", { count: expiredQueries.length });
+    const duration = Date.now() - startTime;
+    if (expiredQueries.length > 0) {
+      logger.debug("TWO_LAYER: Query cleanup completed", {
+        expiredCount: expiredQueries.length,
+        totalQueries: this.queryMetadataMap.size,
+        duration
+      });
+    } else {
+      logger.debug("TWO_LAYER: Query cleanup - no expired queries", {
+        totalQueries: this.queryMetadataMap.size,
+        duration
+      });
     }
     return expiredQueries.length;
   }
@@ -327,24 +401,68 @@ var TwoLayerCacheMap = class _TwoLayerCacheMap extends CacheMap {
   // The types are accessible through super.types
   // ===== MISSING ABSTRACT METHODS FROM CacheMap =====
   async invalidateItemKeys(keys) {
+    const startTime = Date.now();
+    logger.debug("TWO_LAYER: Invalidating item keys", {
+      keyCount: keys.length,
+      keys: keys.map((k) => JSON.stringify(k))
+    });
     if ("invalidateItemKeys" in this.underlyingCache && typeof this.underlyingCache.invalidateItemKeys === "function") {
       await this.underlyingCache.invalidateItemKeys(keys);
     }
+    let totalInvalidatedQueries = 0;
     for (const key of keys) {
+      const beforeCount = this.queryMetadataMap.size;
       await this.invalidateQueriesForItem(key);
+      const afterCount = this.queryMetadataMap.size;
+      const invalidated = beforeCount - afterCount;
+      totalInvalidatedQueries += invalidated;
+      if (invalidated > 0) {
+        logger.debug("TWO_LAYER: Invalidated queries for item", {
+          key: JSON.stringify(key),
+          queriesInvalidated: invalidated
+        });
+      }
     }
+    const duration = Date.now() - startTime;
+    logger.debug("TWO_LAYER: Item key invalidation completed", {
+      keyCount: keys.length,
+      totalQueriesInvalidated: totalInvalidatedQueries,
+      duration
+    });
   }
   async invalidateLocation(locations) {
+    const startTime = Date.now();
+    const queryCountBefore = this.queryMetadataMap.size;
+    logger.debug("TWO_LAYER: Invalidating location", {
+      locations: JSON.stringify(locations),
+      queryCountBefore
+    });
     if ("invalidateLocation" in this.underlyingCache && typeof this.underlyingCache.invalidateLocation === "function") {
       await this.underlyingCache.invalidateLocation(locations);
     }
     this.queryMetadataMap.clear();
+    const duration = Date.now() - startTime;
+    logger.debug("TWO_LAYER: Location invalidation completed", {
+      locations: JSON.stringify(locations),
+      queriesCleared: queryCountBefore,
+      duration
+    });
   }
   async clearQueryResults() {
+    const startTime = Date.now();
+    const queryCountBefore = this.queryMetadataMap.size;
+    logger.debug("TWO_LAYER: Clearing all query results", {
+      queryCountBefore
+    });
     if ("clearQueryResults" in this.underlyingCache && typeof this.underlyingCache.clearQueryResults === "function") {
       await this.underlyingCache.clearQueryResults();
     }
     this.queryMetadataMap.clear();
+    const duration = Date.now() - startTime;
+    logger.debug("TWO_LAYER: Cleared all query results", {
+      queriesCleared: queryCountBefore,
+      duration
+    });
   }
   /**
    * Check if two-layer mode is enabled
@@ -699,66 +817,151 @@ async function executeAllLogic(query, locations, context) {
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger2.debug("Generated query hash for all", { queryHash });
+  logger2.debug("QUERY_CACHE: Generated query hash for all()", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations),
+    pkType
+  });
+  logger2.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger2.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger2.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+      queryHash,
+      cachedKeyCount: cachedItemKeys.length,
+      itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
+    });
     const cachedItems = [];
     let allItemsAvailable = true;
+    const missingKeys = [];
     for (const itemKey of cachedItemKeys) {
       const item = await cacheMap.get(itemKey);
       if (item) {
         cachedItems.push(item);
+        logger2.debug("QUERY_CACHE: Retrieved cached item", {
+          itemKey: JSON.stringify(itemKey),
+          itemKeyStr: JSON.stringify(item.key)
+        });
       } else {
         allItemsAvailable = false;
+        missingKeys.push(itemKey);
+        logger2.debug("QUERY_CACHE: Cached item MISSING from item cache", {
+          itemKey: JSON.stringify(itemKey),
+          queryHash
+        });
         break;
       }
     }
     if (allItemsAvailable) {
+      logger2.debug("QUERY_CACHE: All cached items available, returning from cache", {
+        queryHash,
+        itemCount: cachedItems.length
+      });
       return cachedItems;
     } else {
-      logger2.debug("Some cached items missing, invalidating query cache");
+      logger2.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
+        queryHash,
+        missingKeys: missingKeys.map((k) => JSON.stringify(k)),
+        foundCount: cachedItems.length,
+        expectedCount: cachedItemKeys.length
+      });
       cacheMap.deleteQueryResult(queryHash);
     }
+  } else {
+    logger2.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
+  logger2.debug("QUERY_CACHE: Attempting direct cache query using queryIn()", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations)
+  });
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger2.debug("Found items directly in cache, skipping API call", { itemCount: directCachedItems.length });
+      logger2.debug("QUERY_CACHE: Direct cache query SUCCESS - Found items in item cache", {
+        queryHash,
+        itemCount: directCachedItems.length,
+        itemKeys: directCachedItems.map((item) => JSON.stringify(item.key))
+      });
       const itemKeys = directCachedItems.map((item) => item.key);
       await cacheMap.setQueryResult(queryHash, itemKeys);
-      logger2.debug("Cached query result from direct cache hit", { queryHash, itemKeyCount: itemKeys.length });
+      logger2.debug("QUERY_CACHE: Stored query result from direct cache hit", {
+        queryHash,
+        itemKeyCount: itemKeys.length,
+        itemKeys: itemKeys.map((k) => JSON.stringify(k))
+      });
       return directCachedItems;
+    } else {
+      logger2.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
     }
   } catch (error) {
-    logger2.debug("Error querying cache directly, proceeding to API", { error });
+    logger2.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
+      queryHash,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
+  logger2.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations)
+  });
   let ret = [];
   try {
     ret = await api.all(query, locations);
+    logger2.debug("QUERY_CACHE: API response received", {
+      queryHash,
+      itemCount: ret.length,
+      itemKeys: ret.map((item) => JSON.stringify(item.key))
+    });
+    logger2.debug("QUERY_CACHE: Storing items in item cache", {
+      queryHash,
+      itemCount: ret.length
+    });
     for (const v of ret) {
       await cacheMap.set(v.key, v);
+      logger2.debug("QUERY_CACHE: Stored item in cache", {
+        itemKey: JSON.stringify(v.key),
+        queryHash
+      });
       const keyStr = JSON.stringify(v.key);
       ttlManager.onItemAdded(keyStr, cacheMap);
       const evictedKeys = await context.evictionManager.onItemAdded(keyStr, v, cacheMap);
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
+        logger2.debug("QUERY_CACHE: Evicted item due to cache limits", {
+          evictedKey,
+          queryHash
+        });
       }
     }
     const itemKeys = ret.map((item) => item.key);
-    cacheMap.setQueryResult(queryHash, itemKeys);
-    logger2.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+    await cacheMap.setQueryResult(queryHash, itemKeys);
+    logger2.debug("QUERY_CACHE: Stored query result in query cache", {
+      queryHash,
+      itemKeyCount: itemKeys.length,
+      itemKeys: itemKeys.map((k) => JSON.stringify(k))
+    });
     const event = CacheEventFactory.createQueryEvent(query, locations, ret);
     context.eventEmitter.emit(event);
+    logger2.debug("QUERY_CACHE: Emitted query event", { queryHash });
   } catch (e) {
     if (e instanceof NotFoundError) {
-      cacheMap.setQueryResult(queryHash, []);
-      logger2.debug("Cached empty query result for not found", { queryHash });
+      logger2.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
+      await cacheMap.setQueryResult(queryHash, []);
+      logger2.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
     } else {
+      logger2.debug("QUERY_CACHE: API error occurred", {
+        queryHash,
+        error: e instanceof Error ? e.message : String(e)
+      });
       throw e;
     }
   }
+  logger2.debug("QUERY_CACHE: all() operation completed", {
+    queryHash,
+    resultCount: ret.length
+  });
   return ret;
 }
 
@@ -961,37 +1164,93 @@ async function executeOneLogic(query, locations, context) {
     }
   }
   const queryHash = createQueryHash(pkType, query, locations);
-  logger3.debug("Generated query hash for one", { queryHash });
+  logger3.debug("QUERY_CACHE: Generated query hash for one()", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations),
+    pkType
+  });
+  logger3.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger3.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
+    logger3.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+      queryHash,
+      cachedKeyCount: cachedItemKeys.length,
+      itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
+    });
     if (cachedItemKeys.length === 0) {
+      logger3.debug("QUERY_CACHE: Cached empty result (not found)", { queryHash });
       return null;
     }
-    const item = await cacheMap.get(cachedItemKeys[0]);
+    const itemKey = cachedItemKeys[0];
+    logger3.debug("QUERY_CACHE: Retrieving first cached item", {
+      queryHash,
+      itemKey: JSON.stringify(itemKey)
+    });
+    const item = await cacheMap.get(itemKey);
     if (item) {
+      logger3.debug("QUERY_CACHE: Retrieved cached item successfully", {
+        queryHash,
+        itemKey: JSON.stringify(itemKey),
+        itemKeyStr: JSON.stringify(item.key)
+      });
       return item;
     } else {
-      logger3.debug("Cached item missing, invalidating query cache");
+      logger3.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
+        queryHash,
+        itemKey: JSON.stringify(itemKey)
+      });
       cacheMap.deleteQueryResult(queryHash);
     }
+  } else {
+    logger3.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
+  logger3.debug("QUERY_CACHE: Attempting direct cache query using queryIn()", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations)
+  });
   try {
     const directCachedItems = await cacheMap.queryIn(query, locations);
     if (directCachedItems && directCachedItems.length > 0) {
-      logger3.debug("Found item directly in cache, skipping API call");
+      logger3.debug("QUERY_CACHE: Direct cache query SUCCESS - Found item in item cache", {
+        queryHash,
+        itemCount: directCachedItems.length,
+        itemKeys: directCachedItems.map((item) => JSON.stringify(item.key))
+      });
       const foundItem = directCachedItems[0];
       await cacheMap.setQueryResult(queryHash, [foundItem.key]);
-      logger3.debug("Cached query result from direct cache hit", { queryHash, itemKey: foundItem.key });
+      logger3.debug("QUERY_CACHE: Stored query result from direct cache hit", {
+        queryHash,
+        itemKey: JSON.stringify(foundItem.key)
+      });
       return foundItem;
+    } else {
+      logger3.debug("QUERY_CACHE: Direct cache query returned no items", { queryHash });
     }
   } catch (error) {
-    logger3.debug("Error querying cache directly, proceeding to API", { error });
+    logger3.debug("QUERY_CACHE: Error querying cache directly, proceeding to API", {
+      queryHash,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
+  logger3.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+    queryHash,
+    query: JSON.stringify(query),
+    locations: JSON.stringify(locations)
+  });
   let retItem = null;
   try {
     retItem = await api.one(query, locations);
     if (retItem) {
+      logger3.debug("QUERY_CACHE: API response received", {
+        queryHash,
+        itemKey: JSON.stringify(retItem.key)
+      });
+      logger3.debug("QUERY_CACHE: Storing item in item cache", {
+        queryHash,
+        itemKey: JSON.stringify(retItem.key)
+      });
       await cacheMap.set(retItem.key, retItem);
       const keyStr = JSON.stringify(retItem.key);
       const metadata = await cacheMap.getMetadata(keyStr);
@@ -1011,21 +1270,38 @@ async function executeOneLogic(query, locations, context) {
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
+        logger3.debug("QUERY_CACHE: Evicted item due to cache limits", {
+          evictedKey,
+          queryHash
+        });
       }
       await cacheMap.setQueryResult(queryHash, [retItem.key]);
-      logger3.debug("Cached query result", { queryHash, itemKey: retItem.key });
+      logger3.debug("QUERY_CACHE: Stored query result in query cache", {
+        queryHash,
+        itemKey: JSON.stringify(retItem.key)
+      });
     } else {
+      logger3.debug("QUERY_CACHE: API returned null, caching empty result", { queryHash });
       await cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("Cached empty query result", { queryHash });
+      logger3.debug("QUERY_CACHE: Cached empty query result", { queryHash });
     }
   } catch (e) {
     if (e instanceof NotFoundError2) {
-      cacheMap.setQueryResult(queryHash, []);
-      logger3.debug("Cached empty query result for not found", { queryHash });
+      logger3.debug("QUERY_CACHE: API returned NotFoundError, caching empty result", { queryHash });
+      await cacheMap.setQueryResult(queryHash, []);
+      logger3.debug("QUERY_CACHE: Cached empty query result for not found", { queryHash });
     } else {
+      logger3.debug("QUERY_CACHE: API error occurred", {
+        queryHash,
+        error: e instanceof Error ? e.message : String(e)
+      });
       throw e;
     }
   }
+  logger3.debug("QUERY_CACHE: one() operation completed", {
+    queryHash,
+    result: retItem ? JSON.stringify(retItem.key) : null
+  });
   return retItem || null;
 }
 
@@ -1107,68 +1383,128 @@ var get = async (key, context) => {
   return [context, result];
 };
 async function executeGetLogic(key, context) {
+  const startTime = Date.now();
   const { api, cacheMap, pkType, ttlManager, statsManager } = context;
+  const keyStr = JSON.stringify(key);
+  logger5.debug("CACHE_OP: get() started", {
+    key: keyStr,
+    ttlEnabled: ttlManager.isTTLEnabled(),
+    defaultTTL: ttlManager.getDefaultTTL(),
+    cacheType: cacheMap.implementationType
+  });
   statsManager.incrementRequests();
   if (!isValidItemKey(key)) {
-    logger5.error("Key for Get is not a valid ItemKey: %j", key);
+    logger5.error("CACHE_OP: Invalid key for get", { key: keyStr });
     throw new Error("Key for Get is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger5.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger5.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
     statsManager.incrementMisses();
     try {
+      const apiStartTime = Date.now();
       const ret2 = await api.get(key);
+      const apiDuration = Date.now() - apiStartTime;
       if (ret2) {
-        logger5.debug("API response received (not cached due to bypass)", { key });
+        logger5.debug("CACHE_OP: API response received (bypass mode, not cached)", {
+          key: keyStr,
+          apiDuration,
+          totalDuration: Date.now() - startTime
+        });
         return ret2;
       } else {
-        logger5.debug("API returned null", { key });
+        logger5.debug("CACHE_OP: API returned null (bypass mode)", {
+          key: keyStr,
+          apiDuration
+        });
         return null;
       }
     } catch (error) {
-      logger5.error("API request failed", { key, error });
+      logger5.error("CACHE_OP: API request failed in bypass mode", {
+        key: keyStr,
+        duration: Date.now() - startTime,
+        error
+      });
       throw error;
     }
   }
   if (ttlManager.isTTLEnabled()) {
-    const keyStr2 = JSON.stringify(key);
+    const cacheCheckStart = Date.now();
     const cachedItem = await cacheMap.get(key);
+    const cacheCheckDuration = Date.now() - cacheCheckStart;
     if (cachedItem) {
-      const isValid = await ttlManager.validateItem(keyStr2, cacheMap);
+      logger5.debug("CACHE_OP: Item found in cache, checking TTL validity", {
+        key: keyStr,
+        cacheCheckDuration,
+        defaultTTL: ttlManager.getDefaultTTL()
+      });
+      const ttlCheckStart = Date.now();
+      const isValid = await ttlManager.validateItem(keyStr, cacheMap);
+      const ttlCheckDuration = Date.now() - ttlCheckStart;
       if (isValid) {
-        logger5.debug("Cache hit with valid TTL", { key, defaultTTL: ttlManager.getDefaultTTL() });
+        const totalDuration = Date.now() - startTime;
+        logger5.debug("CACHE_OP: Cache HIT with valid TTL", {
+          key: keyStr,
+          cacheCheckDuration,
+          ttlCheckDuration,
+          totalDuration,
+          defaultTTL: ttlManager.getDefaultTTL()
+        });
         statsManager.incrementHits();
         return cachedItem;
       } else {
-        logger5.debug("Cache item expired, removing", { key });
+        logger5.debug("CACHE_OP: Cache item EXPIRED, removing from cache", {
+          key: keyStr,
+          cacheCheckDuration,
+          ttlCheckDuration
+        });
         cacheMap.delete(key);
         statsManager.incrementMisses();
       }
     } else {
+      logger5.debug("CACHE_OP: Cache MISS (no item found)", {
+        key: keyStr,
+        cacheCheckDuration
+      });
       statsManager.incrementMisses();
     }
-    logger5.debug("Cache miss or expired", { key, defaultTTL: ttlManager.getDefaultTTL() });
+    logger5.debug("CACHE_OP: Proceeding to API fetch (TTL-enabled cache miss or expired)", {
+      key: keyStr,
+      defaultTTL: ttlManager.getDefaultTTL()
+    });
   } else {
+    const cacheCheckStart = Date.now();
     const cachedItem = await cacheMap.get(key);
+    const cacheCheckDuration = Date.now() - cacheCheckStart;
     if (cachedItem) {
-      logger5.debug("Cache hit (TTL disabled)", { key });
+      const totalDuration = Date.now() - startTime;
+      logger5.debug("CACHE_OP: Cache HIT (TTL disabled)", {
+        key: keyStr,
+        cacheCheckDuration,
+        totalDuration
+      });
       statsManager.incrementHits();
       return cachedItem;
     } else {
+      logger5.debug("CACHE_OP: Cache MISS (TTL disabled)", {
+        key: keyStr,
+        cacheCheckDuration
+      });
       statsManager.incrementMisses();
     }
   }
   let ret;
-  const keyStr = keyToString(key);
+  const requestKeyStr = keyToString(key);
   try {
-    const requestEntry = inFlightRequests.get(keyStr);
+    const requestEntry = inFlightRequests.get(requestKeyStr);
     let apiRequest;
+    const apiStartTime = Date.now();
     if (!requestEntry) {
+      logger5.debug("CACHE_OP: Creating new API request", { key: keyStr });
       apiRequest = api.get(key);
       if (apiRequest && typeof apiRequest.then === "function") {
         const timestamp = Date.now();
-        inFlightRequests.set(keyStr, { promise: apiRequest, timestamp });
-        const cleanup = () => inFlightRequests.delete(keyStr);
+        inFlightRequests.set(requestKeyStr, { promise: apiRequest, timestamp });
+        const cleanup = () => inFlightRequests.delete(requestKeyStr);
         if (typeof apiRequest.finally === "function") {
           apiRequest.finally(cleanup);
         } else {
@@ -1176,37 +1512,90 @@ async function executeGetLogic(key, context) {
         }
       }
     } else {
-      logger5.debug("Using in-flight request for key", { key });
+      logger5.debug("CACHE_OP: Using existing in-flight request", {
+        key: keyStr,
+        requestAge: Date.now() - requestEntry.timestamp
+      });
       apiRequest = requestEntry.promise;
     }
     ret = await apiRequest;
+    const apiDuration = Date.now() - apiStartTime;
     if (ret) {
+      logger5.debug("CACHE_OP: API request successful, caching result", {
+        key: keyStr,
+        apiDuration,
+        itemKeyMatches: JSON.stringify(ret.key) === keyStr
+      });
+      const cacheSetStart = Date.now();
       await cacheMap.set(ret.key, ret);
-      const keyStr2 = JSON.stringify(ret.key);
-      const metadata = await cacheMap.getMetadata(keyStr2);
+      const cacheSetDuration = Date.now() - cacheSetStart;
+      const itemKeyStr = JSON.stringify(ret.key);
+      const metadataStart = Date.now();
+      const metadata = await cacheMap.getMetadata(itemKeyStr);
       if (!metadata) {
         const now = Date.now();
+        const estimatedSize = estimateValueSize(ret);
         const baseMetadata = {
-          key: keyStr2,
+          key: itemKeyStr,
           addedAt: now,
           lastAccessedAt: now,
           accessCount: 1,
-          estimatedSize: estimateValueSize(ret)
+          estimatedSize
         };
-        await cacheMap.setMetadata(keyStr2, baseMetadata);
+        await cacheMap.setMetadata(itemKeyStr, baseMetadata);
+        logger5.debug("CACHE_OP: Created base metadata for cached item", {
+          key: itemKeyStr,
+          estimatedSize
+        });
+      }
+      const metadataDuration = Date.now() - metadataStart;
+      const evictionStart = Date.now();
+      const evictedKeys = await context.evictionManager.onItemAdded(itemKeyStr, ret, cacheMap);
+      const evictionDuration = Date.now() - evictionStart;
+      if (evictedKeys.length > 0) {
+        logger5.debug("CACHE_OP: Eviction triggered by new item", {
+          key: itemKeyStr,
+          evictedCount: evictedKeys.length,
+          evictedKeys
+        });
       }
-      const evictedKeys = await context.evictionManager.onItemAdded(keyStr2, ret, cacheMap);
-      await ttlManager.onItemAdded(keyStr2, cacheMap);
+      const ttlStart = Date.now();
+      await ttlManager.onItemAdded(itemKeyStr, cacheMap);
+      const ttlDuration = Date.now() - ttlStart;
       for (const evictedKey of evictedKeys) {
         const parsedKey = JSON.parse(evictedKey);
         await cacheMap.delete(parsedKey);
+        logger5.debug("CACHE_OP: Removed evicted item", { evictedKey });
       }
       const event = CacheEventFactory.itemRetrieved(ret.key, ret, "api");
       context.eventEmitter.emit(event);
+      const totalDuration = Date.now() - startTime;
+      logger5.debug("CACHE_OP: get() completed successfully (cache miss)", {
+        key: keyStr,
+        apiDuration,
+        cacheSetDuration,
+        metadataDuration,
+        evictionDuration,
+        ttlDuration,
+        totalDuration,
+        evictedCount: evictedKeys.length
+      });
+    } else {
+      logger5.debug("CACHE_OP: API returned null", {
+        key: keyStr,
+        apiDuration,
+        totalDuration: Date.now() - startTime
+      });
     }
   } catch (e) {
-    inFlightRequests.delete(keyStr);
-    logger5.error("Error getting item for key", { key, message: e.message, stack: e.stack });
+    inFlightRequests.delete(requestKeyStr);
+    const duration = Date.now() - startTime;
+    logger5.error("CACHE_OP: Error in get() operation", {
+      key: keyStr,
+      duration,
+      message: e.message,
+      stack: e.stack
+    });
     throw e;
   }
   return ret || null;
@@ -1218,43 +1607,88 @@ import {
 } from "@fjell/core";
 var logger6 = logger_default.get("retrieve");
 var retrieve = async (key, context) => {
+  const startTime = Date.now();
   const { cacheMap, pkType, statsManager } = context;
+  const keyStr = JSON.stringify(key);
   logger6.default("retrieve", { key });
+  logger6.debug("CACHE_OP: retrieve() started", {
+    key: keyStr,
+    cacheType: cacheMap.implementationType,
+    bypassEnabled: !!context.options?.bypassCache
+  });
   statsManager.incrementRequests();
   if (!isValidItemKey2(key)) {
-    logger6.error("Key for Retrieve is not a valid ItemKey: %j", key);
+    logger6.error("CACHE_OP: Invalid key for retrieve", { key: keyStr });
     throw new Error("Key for Retrieve is not a valid ItemKey");
   }
   if (context.options?.bypassCache) {
-    logger6.debug("Cache bypass enabled, fetching directly from API", { key });
+    logger6.debug("CACHE_OP: Cache bypass enabled, fetching directly from API", { key: keyStr });
     statsManager.incrementMisses();
     try {
+      const apiStartTime = Date.now();
       const { api } = context;
       const retrieved2 = await api.get(key);
+      const apiDuration = Date.now() - apiStartTime;
       if (retrieved2) {
-        logger6.debug("API response received (not cached due to bypass)", { key });
+        logger6.debug("CACHE_OP: API response received (bypass mode)", {
+          key: keyStr,
+          apiDuration,
+          hasValue: true
+        });
         return [null, retrieved2];
       } else {
-        logger6.debug("API returned null", { key });
+        logger6.debug("CACHE_OP: API returned null (bypass mode)", {
+          key: keyStr,
+          apiDuration
+        });
         return [null, null];
       }
     } catch (error) {
-      logger6.error("API request failed", { key, error });
+      const duration = Date.now() - startTime;
+      logger6.error("CACHE_OP: API request failed in bypass mode", {
+        key: keyStr,
+        duration,
+        error
+      });
       throw error;
     }
   }
   const containsItemKey = await cacheMap.includesKey(key);
+  logger6.debug("CACHE_OP: Cache key check completed", {
+    key: keyStr,
+    exists: containsItemKey
+  });
   let retrieved;
   let contextToReturn;
   if (containsItemKey) {
     logger6.default("Looking for Object in Cache", key);
+    logger6.debug("CACHE_OP: Cache HIT - retrieving from cache", { key: keyStr });
+    const getStartTime = Date.now();
     retrieved = await cacheMap.get(key);
+    const getDuration = Date.now() - getStartTime;
     contextToReturn = null;
     statsManager.incrementHits();
+    const totalDuration = Date.now() - startTime;
+    logger6.debug("CACHE_OP: retrieve() completed (cache hit)", {
+      key: keyStr,
+      getDuration,
+      totalDuration,
+      hasValue: !!retrieved
+    });
   } else {
     logger6.default("Object Not Found in Cache, Retrieving from Server API", { key });
+    logger6.debug("CACHE_OP: Cache MISS - fetching from API", { key: keyStr });
     statsManager.incrementMisses();
+    const apiStartTime = Date.now();
     [contextToReturn, retrieved] = await get(key, context);
+    const apiDuration = Date.now() - apiStartTime;
+    const totalDuration = Date.now() - startTime;
+    logger6.debug("CACHE_OP: retrieve() completed (cache miss)", {
+      key: keyStr,
+      apiDuration,
+      totalDuration,
+      hasValue: !!retrieved
+    });
   }
   const retValue = [
     contextToReturn,
@@ -1749,44 +2183,107 @@ async function executeFindLogic(finder, params, locations, context) {
     }
   }
   const queryHash = createFinderHash(finder, params, locations);
-  logger14.debug("Generated query hash for find", { queryHash, finder, params, locations });
+  logger14.debug("QUERY_CACHE: Generated query hash for find()", {
+    queryHash,
+    finder,
+    params: JSON.stringify(params),
+    locations: JSON.stringify(locations)
+  });
+  logger14.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys) {
-    logger14.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length, queryHash });
+    logger14.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+      queryHash,
+      cachedKeyCount: cachedItemKeys.length,
+      itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
+    });
     const cachedItems = [];
     let allItemsAvailable = true;
+    const missingKeys = [];
     for (const itemKey of cachedItemKeys) {
       const item = await cacheMap.get(itemKey);
       if (item) {
         cachedItems.push(item);
+        logger14.debug("QUERY_CACHE: Retrieved cached item", {
+          itemKey: JSON.stringify(itemKey),
+          itemKeyStr: JSON.stringify(item.key)
+        });
       } else {
         allItemsAvailable = false;
+        missingKeys.push(itemKey);
+        logger14.debug("QUERY_CACHE: Cached item MISSING from item cache", {
+          itemKey: JSON.stringify(itemKey),
+          queryHash
+        });
         break;
       }
     }
     if (allItemsAvailable) {
+      logger14.debug("QUERY_CACHE: All cached items available, returning from cache", {
+        queryHash,
+        itemCount: cachedItems.length
+      });
       return cachedItems;
     } else {
-      logger14.debug("Some cached items missing, invalidating query cache");
+      logger14.debug("QUERY_CACHE: Some cached items missing, invalidating query cache", {
+        queryHash,
+        missingKeys: missingKeys.map((k) => JSON.stringify(k)),
+        foundCount: cachedItems.length,
+        expectedCount: cachedItemKeys.length
+      });
       cacheMap.deleteQueryResult(queryHash);
     }
+  } else {
+    logger14.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
+  logger14.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+    queryHash,
+    finder,
+    params: JSON.stringify(params),
+    locations: JSON.stringify(locations)
+  });
   const ret = await api.find(finder, params, locations);
+  logger14.debug("QUERY_CACHE: API response received", {
+    queryHash,
+    itemCount: ret.length,
+    itemKeys: ret.map((item) => JSON.stringify(item.key))
+  });
+  logger14.debug("QUERY_CACHE: Storing items in item cache", {
+    queryHash,
+    itemCount: ret.length
+  });
   for (const v of ret) {
     await cacheMap.set(v.key, v);
+    logger14.debug("QUERY_CACHE: Stored item in cache", {
+      itemKey: JSON.stringify(v.key),
+      queryHash
+    });
     const keyStr = JSON.stringify(v.key);
     ttlManager.onItemAdded(keyStr, cacheMap);
     const evictedKeys = await context.evictionManager.onItemAdded(keyStr, v, cacheMap);
     for (const evictedKey of evictedKeys) {
       const parsedKey = JSON.parse(evictedKey);
       await cacheMap.delete(parsedKey);
+      logger14.debug("QUERY_CACHE: Evicted item due to cache limits", {
+        evictedKey,
+        queryHash
+      });
     }
   }
   const itemKeys = ret.map((item) => item.key);
-  cacheMap.setQueryResult(queryHash, itemKeys);
-  logger14.debug("Cached query result", { queryHash, itemKeyCount: itemKeys.length });
+  await cacheMap.setQueryResult(queryHash, itemKeys);
+  logger14.debug("QUERY_CACHE: Stored query result in query cache", {
+    queryHash,
+    itemKeyCount: itemKeys.length,
+    itemKeys: itemKeys.map((k) => JSON.stringify(k))
+  });
   const event = CacheEventFactory.createQueryEvent(params, locations, ret);
   eventEmitter.emit(event);
+  logger14.debug("QUERY_CACHE: Emitted query event", { queryHash });
+  logger14.debug("QUERY_CACHE: find() operation completed", {
+    queryHash,
+    resultCount: ret.length
+  });
   return ret;
 }
 
@@ -1824,34 +2321,86 @@ async function executeFindOneLogic(finder, finderParams, locations, context) {
     }
   }
   const queryHash = createFinderHash(finder, finderParams, locations);
-  logger15.debug("Generated query hash for findOne", { queryHash });
+  logger15.debug("QUERY_CACHE: Generated query hash for findOne()", {
+    queryHash,
+    finder,
+    finderParams: JSON.stringify(finderParams),
+    locations: JSON.stringify(locations)
+  });
+  logger15.debug("QUERY_CACHE: Checking query cache for hash", { queryHash });
   const cachedItemKeys = await cacheMap.getQueryResult(queryHash);
   if (cachedItemKeys && cachedItemKeys.length > 0) {
-    logger15.debug("Using cached query results", { cachedKeyCount: cachedItemKeys.length });
-    const item = await cacheMap.get(cachedItemKeys[0]);
+    logger15.debug("QUERY_CACHE: Cache HIT - Found cached query result", {
+      queryHash,
+      cachedKeyCount: cachedItemKeys.length,
+      itemKeys: cachedItemKeys.map((k) => JSON.stringify(k))
+    });
+    const itemKey = cachedItemKeys[0];
+    logger15.debug("QUERY_CACHE: Retrieving first cached item", {
+      queryHash,
+      itemKey: JSON.stringify(itemKey)
+    });
+    const item = await cacheMap.get(itemKey);
     if (item) {
+      logger15.debug("QUERY_CACHE: Retrieved cached item successfully", {
+        queryHash,
+        itemKey: JSON.stringify(itemKey),
+        itemKeyStr: JSON.stringify(item.key)
+      });
       return item;
     } else {
-      logger15.debug("Cached item missing, invalidating query cache");
+      logger15.debug("QUERY_CACHE: Cached item MISSING from item cache, invalidating query cache", {
+        queryHash,
+        itemKey: JSON.stringify(itemKey)
+      });
       cacheMap.deleteQueryResult(queryHash);
     }
+  } else {
+    logger15.debug("QUERY_CACHE: Cache MISS - No cached query result found", { queryHash });
   }
+  logger15.debug("QUERY_CACHE: Fetching from API (cache miss or invalid)", {
+    queryHash,
+    finder,
+    finderParams: JSON.stringify(finderParams),
+    locations: JSON.stringify(locations)
+  });
   const ret = await api.findOne(finder, finderParams, locations);
   if (ret === null) {
+    logger15.debug("QUERY_CACHE: API returned null, throwing error", { queryHash, finder });
     throw new Error(`findOne returned null for finder: ${finder}`);
   }
-  cacheMap.set(ret.key, ret);
+  logger15.debug("QUERY_CACHE: API response received", {
+    queryHash,
+    itemKey: JSON.stringify(ret.key)
+  });
+  logger15.debug("QUERY_CACHE: Storing item in item cache", {
+    queryHash,
+    itemKey: JSON.stringify(ret.key)
+  });
+  await cacheMap.set(ret.key, ret);
   const keyStr = JSON.stringify(ret.key);
   ttlManager.onItemAdded(keyStr, cacheMap);
   const evictedKeys = await context.evictionManager.onItemAdded(keyStr, ret, cacheMap);
   for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
     await cacheMap.delete(parsedKey);
+    logger15.debug("QUERY_CACHE: Evicted item due to cache limits", {
+      evictedKey,
+      queryHash
+    });
   }
-  cacheMap.setQueryResult(queryHash, [ret.key]);
-  logger15.debug("Cached query result", { queryHash, itemKey: ret.key });
+  await cacheMap.setQueryResult(queryHash, [ret.key]);
+  logger15.debug("QUERY_CACHE: Stored query result in query cache", {
+    queryHash,
+    itemKey: JSON.stringify(ret.key)
+  });
   const event = CacheEventFactory.createQueryEvent(finderParams, locations, [ret]);
   eventEmitter.emit(event);
+  logger15.debug("QUERY_CACHE: Emitted query event", { queryHash });
+  logger15.debug("QUERY_CACHE: findOne() operation completed", {
+    queryHash,
+    itemKey: JSON.stringify(ret.key)
+  });
   return ret;
 }
 
@@ -1909,39 +2458,93 @@ var normalizeKey = (key) => {
   return key;
 };
 var set = async (key, v, context) => {
+  const startTime = Date.now();
   const { cacheMap, pkType, ttlManager, evictionManager, eventEmitter } = context;
+  const keyStr = JSON.stringify(key);
   logger16.default("set", { key, v });
+  logger16.debug("CACHE_OP: set() started", {
+    key: keyStr,
+    cacheType: cacheMap.implementationType
+  });
   if (!isValidItemKey6(key)) {
-    logger16.error("Key for Set is not a valid ItemKey: %j", key);
+    logger16.error("CACHE_OP: Invalid key for set", { key: keyStr });
     throw new Error("Key for Set is not a valid ItemKey");
   }
   if (!isItemKeyEqualNormalized(key, v.key)) {
-    logger16.error("Key does not match item key: %j != %j", key, v.key);
+    logger16.error("CACHE_OP: Key mismatch in set", {
+      providedKey: keyStr,
+      itemKey: JSON.stringify(v.key)
+    });
     throw new Error("Key does not match item key");
   }
+  const checkStartTime = Date.now();
   const previousItem = await cacheMap.get(key);
+  const checkDuration = Date.now() - checkStartTime;
+  logger16.debug("CACHE_OP: Previous item check", {
+    key: keyStr,
+    hadPreviousItem: !!previousItem,
+    checkDuration
+  });
+  const setStartTime = Date.now();
   await cacheMap.set(key, v);
-  const keyStr = JSON.stringify(key);
+  const setDuration = Date.now() - setStartTime;
+  const metadataStartTime = Date.now();
   const metadata = await cacheMap.getMetadata(keyStr);
   if (!metadata) {
     const now = Date.now();
+    const estimatedSize = estimateValueSize(v);
     const baseMetadata = {
       key: keyStr,
       addedAt: now,
       lastAccessedAt: now,
       accessCount: 1,
-      estimatedSize: estimateValueSize(v)
+      estimatedSize
     };
     await cacheMap.setMetadata(keyStr, baseMetadata);
+    logger16.debug("CACHE_OP: Created base metadata", {
+      key: keyStr,
+      estimatedSize
+    });
+  } else {
+    logger16.debug("CACHE_OP: Metadata already exists", {
+      key: keyStr,
+      addedAt: new Date(metadata.addedAt).toISOString(),
+      accessCount: metadata.accessCount
+    });
   }
+  const metadataDuration = Date.now() - metadataStartTime;
+  const ttlStartTime = Date.now();
   await ttlManager.onItemAdded(keyStr, cacheMap);
+  const ttlDuration = Date.now() - ttlStartTime;
+  const evictionStartTime = Date.now();
   const evictedKeys = await evictionManager.onItemAdded(keyStr, v, cacheMap);
+  const evictionDuration = Date.now() - evictionStartTime;
+  if (evictedKeys.length > 0) {
+    logger16.debug("CACHE_OP: Eviction triggered by set", {
+      key: keyStr,
+      evictedCount: evictedKeys.length,
+      evictedKeys
+    });
+  }
   for (const evictedKey of evictedKeys) {
     const parsedKey = JSON.parse(evictedKey);
     await cacheMap.delete(parsedKey);
+    logger16.debug("CACHE_OP: Removed evicted item", { evictedKey });
   }
   const event = CacheEventFactory.itemSet(key, v, previousItem);
   eventEmitter.emit(event);
+  const totalDuration = Date.now() - startTime;
+  logger16.debug("CACHE_OP: set() completed", {
+    key: keyStr,
+    checkDuration,
+    setDuration,
+    metadataDuration,
+    ttlDuration,
+    evictionDuration,
+    totalDuration,
+    evictedCount: evictedKeys.length,
+    wasUpdate: !!previousItem
+  });
   return [context, v];
 };
 
@@ -5119,9 +5722,17 @@ var EvictionManager = class {
       return;
     }
     try {
+      logger24.debug("EVICTION: Item accessed, updating metadata", {
+        key,
+        strategy: this.evictionStrategy.getStrategyName()
+      });
       await this.evictionStrategy.onItemAccessed(key, metadataProvider);
     } catch (error) {
-      logger24.error("Error in eviction strategy onItemAccessed", { key, error });
+      logger24.error("EVICTION: Error in eviction strategy onItemAccessed", {
+        key,
+        error,
+        strategy: this.evictionStrategy?.getStrategyName()
+      });
     }
   }
   /**
@@ -5132,28 +5743,81 @@ var EvictionManager = class {
    * @returns Array of keys that were evicted
    */
   async onItemAdded(key, value, metadataProvider) {
+    const startTime = Date.now();
     const evictedKeys = [];
     if (!this.evictionStrategy) {
+      logger24.debug("EVICTION: No eviction strategy configured", { key });
       return evictedKeys;
     }
     try {
       const estimatedSize = estimateValueSize(value);
+      logger24.debug("EVICTION: Item addition started", {
+        key,
+        estimatedSize,
+        strategy: this.evictionStrategy.getStrategyName()
+      });
+      const contextStartTime = Date.now();
       const context = await this.createEvictionContext(metadataProvider, estimatedSize);
+      const contextDuration = Date.now() - contextStartTime;
+      logger24.debug("EVICTION: Current cache state", {
+        key,
+        currentItemCount: context.currentSize.itemCount,
+        currentSizeBytes: context.currentSize.sizeBytes,
+        maxItems: context.limits.maxItems,
+        maxSizeBytes: context.limits.maxSizeBytes,
+        newItemSize: estimatedSize,
+        contextDuration
+      });
+      const selectionStartTime = Date.now();
       const keysToEvict = await this.evictionStrategy.selectForEviction(metadataProvider, context);
+      const selectionDuration = Date.now() - selectionStartTime;
+      if (keysToEvict.length > 0) {
+        logger24.debug("EVICTION: Items selected for eviction", {
+          key,
+          evictCount: keysToEvict.length,
+          keysToEvict,
+          selectionDuration,
+          strategy: this.evictionStrategy.getStrategyName()
+        });
+      }
+      const removalStartTime = Date.now();
       for (const evictKey of keysToEvict) {
         await this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
         evictedKeys.push(evictKey);
+        logger24.debug("EVICTION: Marked item for eviction", {
+          evictedKey: evictKey,
+          newKey: key
+        });
       }
+      const removalDuration = Date.now() - removalStartTime;
+      const addMetadataStart = Date.now();
       await this.evictionStrategy.onItemAdded(key, estimatedSize, metadataProvider);
+      const addMetadataDuration = Date.now() - addMetadataStart;
+      const totalDuration = Date.now() - startTime;
       if (evictedKeys.length > 0) {
-        logger24.debug("Items evicted during addition", {
+        logger24.debug("EVICTION: Eviction completed", {
           newKey: key,
+          evictedCount: evictedKeys.length,
           evictedKeys,
-          strategy: this.evictionStrategy.getStrategyName()
+          strategy: this.evictionStrategy.getStrategyName(),
+          selectionDuration,
+          removalDuration,
+          addMetadataDuration,
+          totalDuration
+        });
+      } else {
+        logger24.debug("EVICTION: No eviction needed", {
+          newKey: key,
+          estimatedSize,
+          totalDuration
         });
       }
     } catch (error) {
-      logger24.error("Error in eviction strategy onItemAdded", { key, error });
+      logger24.error("EVICTION: Error in eviction strategy onItemAdded", {
+        key,
+        error,
+        strategy: this.evictionStrategy?.getStrategyName()
+      });
     }
     return evictedKeys;
   }
@@ -5178,25 +5842,47 @@ var EvictionManager = class {
    * @returns Array of keys that were evicted
    */
   async performEviction(metadataProvider) {
+    const startTime = Date.now();
     const evictedKeys = [];
     if (!this.evictionStrategy) {
+      logger24.debug("EVICTION: No eviction strategy configured for manual eviction");
       return evictedKeys;
     }
     try {
+      logger24.debug("EVICTION: Manual eviction started", {
+        strategy: this.evictionStrategy.getStrategyName()
+      });
       const context = await this.createEvictionContext(metadataProvider);
+      logger24.debug("EVICTION: Manual eviction - current cache state", {
+        currentItemCount: context.currentSize.itemCount,
+        currentSizeBytes: context.currentSize.sizeBytes,
+        maxItems: context.limits.maxItems,
+        maxSizeBytes: context.limits.maxSizeBytes
+      });
       const keysToEvict = await this.evictionStrategy.selectForEviction(metadataProvider, context);
       for (const evictKey of keysToEvict) {
         await this.evictionStrategy.onItemRemoved(evictKey, metadataProvider);
         evictedKeys.push(evictKey);
       }
+      const duration = Date.now() - startTime;
       if (evictedKeys.length > 0) {
-        logger24.debug("Manual eviction performed", {
+        logger24.debug("EVICTION: Manual eviction completed", {
+          evictedCount: evictedKeys.length,
           evictedKeys,
-          strategy: this.evictionStrategy.getStrategyName()
+          strategy: this.evictionStrategy.getStrategyName(),
+          duration
+        });
+      } else {
+        logger24.debug("EVICTION: Manual eviction - no items to evict", {
+          strategy: this.evictionStrategy.getStrategyName(),
+          duration
         });
       }
     } catch (error) {
-      logger24.error("Error in manual eviction", { error });
+      logger24.error("EVICTION: Error in manual eviction", {
+        error,
+        strategy: this.evictionStrategy?.getStrategyName()
+      });
     }
     return evictedKeys;
   }
@@ -6625,7 +7311,7 @@ var TTLManager = class {
       metadata
     });
     if (!metadata) {
-      logger25.warning("TTL_DEBUG: No metadata found for item when setting TTL", {
+      logger25.debug("TTL_DEBUG: No metadata found for item when setting TTL", {
         key,
         metadataProviderType: metadataProvider?.constructor?.name,
         metadataProviderMethods: metadataProvider ? Object.getOwnPropertyNames(Object.getPrototypeOf(metadataProvider)) : null
@@ -6665,12 +7351,28 @@ var TTLManager = class {
   async isExpired(key, metadataProvider) {
     const metadata = await metadataProvider.getMetadata(key);
     if (!metadata || !metadata.expiresAt) {
+      logger25.debug("TTL_CHECK: No TTL set for item", { key, hasMetadata: !!metadata });
       return false;
     }
     const now = Date.now();
     const expired = now >= metadata.expiresAt;
+    const remainingMs = metadata.expiresAt - now;
     if (expired) {
-      logger25.trace("Item expired", { key, expiresAt: metadata.expiresAt, now });
+      logger25.debug("TTL_CHECK: Item EXPIRED", {
+        key,
+        expiresAt: new Date(metadata.expiresAt).toISOString(),
+        now: new Date(now).toISOString(),
+        expiredByMs: now - metadata.expiresAt,
+        ttl: metadata.ttl
+      });
+    } else {
+      logger25.debug("TTL_CHECK: Item still valid", {
+        key,
+        expiresAt: new Date(metadata.expiresAt).toISOString(),
+        remainingMs,
+        remainingSec: Math.floor(remainingMs / 1e3),
+        ttl: metadata.ttl
+      });
     }
     return expired;
   }
@@ -6680,9 +7382,22 @@ var TTLManager = class {
    */
   async validateItem(key, metadataProvider) {
     if (!this.config.validateOnAccess) {
+      logger25.debug("TTL_VALIDATE: Validation disabled, skipping check", { key });
       return true;
     }
-    return !await this.isExpired(key, metadataProvider);
+    logger25.debug("TTL_VALIDATE: Validating item", {
+      key,
+      ttlEnabled: this.isTTLEnabled(),
+      defaultTTL: this.config.defaultTTL
+    });
+    const isExpired = await this.isExpired(key, metadataProvider);
+    const isValid = !isExpired;
+    logger25.debug("TTL_VALIDATE: Validation result", {
+      key,
+      isValid,
+      isExpired
+    });
+    return isValid;
   }
   /**
    * Get TTL information for an item
@@ -6707,17 +7422,44 @@ var TTLManager = class {
    * Find all expired items
    */
   async findExpiredItems(metadataProvider) {
+    const startTime = Date.now();
     const expiredKeys = [];
     const allMetadata = await metadataProvider.getAllMetadata();
     const now = Date.now();
+    logger25.debug("TTL_CLEANUP: Scanning for expired items", {
+      totalItems: allMetadata.size,
+      now: new Date(now).toISOString()
+    });
+    let itemsWithTTL = 0;
     for (const [key, metadata] of allMetadata) {
       const ttlMetadata = metadata;
-      if (ttlMetadata.expiresAt && now >= ttlMetadata.expiresAt) {
-        expiredKeys.push(key);
+      if (ttlMetadata.expiresAt) {
+        itemsWithTTL++;
+        if (now >= ttlMetadata.expiresAt) {
+          expiredKeys.push(key);
+          logger25.debug("TTL_CLEANUP: Found expired item", {
+            key,
+            expiresAt: new Date(ttlMetadata.expiresAt).toISOString(),
+            expiredByMs: now - ttlMetadata.expiresAt
+          });
+        }
       }
     }
+    const duration = Date.now() - startTime;
     if (expiredKeys.length > 0) {
-      logger25.debug("Found expired items", { count: expiredKeys.length, keys: expiredKeys });
+      logger25.debug("TTL_CLEANUP: Expired items found", {
+        expiredCount: expiredKeys.length,
+        totalItems: allMetadata.size,
+        itemsWithTTL,
+        keys: expiredKeys,
+        duration
+      });
+    } else {
+      logger25.debug("TTL_CLEANUP: No expired items found", {
+        totalItems: allMetadata.size,
+        itemsWithTTL,
+        duration
+      });
     }
     return expiredKeys;
   }