@itentialopensource/adapter-utils 5.10.6 → 5.10.7

package/lib/cacheHandler.js

@@ -43,7 +43,12 @@ function deleteCacheData(cacheHandler) {
 
   const handler = cacheHandler;
 
-  // get all keys to make sure nothing else is editing the cache at this time
+  // Log INFO level if cache is disabled
+  if (!handler.enabled) {
+    log.info(`${origin}: Cache is turned off.`);
+  }
+
+  // Get all keys to ensure nothing else is editing the cache at this time
   const keysArr = [];
   handler.cache.forEach((entity) => {
     keysArr.push(entity.lockKey);
@@ -51,12 +56,18 @@ function deleteCacheData(cacheHandler) {
 
   lock.acquire(keysArr, () => {
     if (!handler.enabled) {
+      // Clear cache and log once when going from enabled to disabled
+      if (handler.cache.length > 0 || handler.propertiesMap.size > 0) {
+        log.info(`${origin}: Cache has been cleared.`);
+      }
+
       handler.cache.forEach((entity) => {
         clearInterval(entity.intervalId);
       });
       handler.cache = [];
       handler.propertiesMap.clear();
-      log.warn(`${origin}: Cache deletion confirmed`);
+    } else {
+      log.debug(`${origin}: Cache is currently enabled.`);
     }
   });
 }
@@ -132,79 +143,91 @@ function validateProperties(obj) {
   }
 
   const props = obj;
-  // check cache, cache.enabled, cache.entities exist
+
+  // Check cache, cache.enabled, cache.entities exist
   if (!props.cache) {
-    // no cache, no props
+    // No cache, initialize default props
     props.cache = {
       enabled: false,
       entities: []
     };
   } else {
     if (!props.cache.enabled) {
+      log.info(`${origin}: Cache is turned off.`);
       props.cache.enabled = false;
-      log.error(`${origin}: Passed in cache properties but did not specify enabled!`);
     }
-    if (!props.cache.entities) {
+
+    if (props.cache.enabled && !props.cache.entities) {
       props.cache.entities = [];
-      log.error(`${origin}: Passed in cache properties but did not specify entities (not even as empty array)!`);
+      log.info(`${origin}: Cache entities initialized as an empty array.`);
     }
   }
-  // check each entity type in entities
-  for (let i = 0; i < props.cache.entities.length; i += 1) {
-    // must have entityType and populate
-    if (!props.cache.entities[i].entityType || !props.cache.entities[i].populate || props.cache.entities[i].populate.length === 0) {
-      log.warn(`${origin}: removed invalid cache property at index ${i}`);
-      // remove rather than throw error
-      props.cache.entities.splice(i, 1);
-      i -= 1; // already pointing at next after splice
-      break;
-    }
 
-    // default frequency = 24 hrs, caps if <60 or >10080
-    if (!props.cache.entities[i].frequency) {
-      props.cache.entities[i].frequency = 24 * 60; // 1 day in minutes
-    } else if (props.cache.entities[i].frequency < 15) { // 15 min minimum
-      log.warn(`${origin}: Passed in frequency of ${props.cache.entities[i].frequency} is too small! Set to 15 minute.`);
-      props.cache.entities[i].frequency = 15;
-    } else if (props.cache.entities[i].frequency > 10080) { // 1 week max
-      log.warn(`${origin}: Passed in frequency of ${props.cache.entities[i].frequency} is too large! Set to 1 week.`);
-      props.cache.entities[i].frequency = 10080;
-    }
+  // Validate each entity in cache.entities if cache is enabled
+  if (props.cache.enabled) {
+    for (let i = 0; i < props.cache.entities.length; i += 1) {
+      const entity = props.cache.entities[i];
+
+      // Ensure entityType and populate exist and are valid
+      if (!entity.entityType || !entity.populate || entity.populate.length === 0) {
+        log.warn(`${origin}: Removed invalid cache property at index ${i}`);
+        props.cache.entities.splice(i, 1);
+        i -= 1; // Adjust index after removal
+        break;
+      }
 
-    // default flushOnFail = false
-    if (!props.cache.entities[i].flushOnFail) {
-      props.cache.entities[i].flushOnFail = false;
-    }
+      // Validate frequency (default: 24 hrs, min: 15 mins, max: 1 week)
+      if (!entity.frequency) {
+        entity.frequency = 24 * 60; // Default to 1 day in minutes
+        log.debug(`${origin}: Frequency set to default (1440 minutes).`);
+      } else if (entity.frequency < 15) {
+        log.warn(`${origin}: Frequency ${entity.frequency} too small! Adjusted to 15 minutes.`);
+        entity.frequency = 15;
+      } else if (entity.frequency > 10080) {
+        log.warn(`${origin}: Frequency ${entity.frequency} too large! Adjusted to 1 week.`);
+        entity.frequency = 10080;
+      }
 
-    // Limits entity type to 1000 entities
-    if (!props.cache.entities[i].limit) {
-      props.cache.entities[i].limits = 1000;
-    }
+      // Default flushOnFail = false
+      if (entity.flushOnFail === undefined) {
+        entity.flushOnFail = false;
+        log.debug(`${origin}: flushOnFail defaulted to false.`);
+      }
 
-    if (!props.cache.entities[i].retryAttempts) {
-      props.cache.entities[i].retryAttempts = 5; // currently only used for startup
-    }
+      // Default limit = 1000
+      if (!entity.limit) {
+        entity.limit = 1000;
+        log.debug(`${origin}: Limit defaulted to 1000.`);
+      }
 
-    // make sure task and filterField exists for every object in cachedTasks
-    if (!props.cache.entities[i].cachedTasks) {
-      props.cache.entities[i].cachedTasks = [];
-    } else {
-      props.cache.entities[i].cachedTasks.forEach((cacheTask) => {
-        const curTask = cacheTask; // for lint
-        if (!curTask.name) {
-          log.error('Cached task has no task name!');
-          curTask.name = ''; // prevent errors, will not ever match a task name
-        }
-        if (!curTask.filterField) {
-          // if no filter then assume is a get all call, would need to explicitly check this
-          curTask.filterField = '';
-        }
-      });
-    }
+      // Default retryAttempts = 5
+      if (!entity.retryAttempts) {
+        entity.retryAttempts = 5; // Used for startup retries
+        log.debug(`${origin}: retryAttempts defaulted to 5.`);
+      }
 
-    // fill in missing populate fields
-    validatePopulate(props.cache.entities[i].populate);
+      // Validate cachedTasks
+      if (!entity.cachedTasks) {
+        entity.cachedTasks = [];
+        log.debug(`${origin}: cachedTasks initialized as an empty array.`);
+      } else {
+        entity.cachedTasks.forEach((cacheTask, idx) => {
+          const curTask = cacheTask; // for lint
+          if (!cacheTask.name) {
+            log.error(`${origin}: Cached task at index ${idx} has no name! Defaulting to an empty string.`);
+            curTask.name = ''; // Prevent errors, will not match a task name
+          }
+          if (!cacheTask.filterField) {
+            curTask.filterField = ''; // Assume a "get all" call if no filter specified
+          }
+        });
+      }
+
+      // Fill in missing populate fields
+      validatePopulate(entity.populate);
+    }
   }
+
   return props;
 }
 
@@ -337,15 +360,20 @@ function removeCacheEntry(cache, entityType) {
 
   for (let i = 0; i < cache.length; i += 1) {
     if (cache[i].entityType === entityType) {
+      log.debug(`${origin}: Found entity type '${entityType}' in cache. Attempting to remove.`);
+
       lock.acquire(cache[i].lockKey, () => {
+        log.debug(`${origin}: Lock acquired for entity type '${entityType}'. Clearing interval and removing from cache.`);
         clearInterval(cache[i].intervalId);
-        cache[i].splice(i, 1);
+        cache.splice(i, 1);
       });
-      log.info(`Successfully removed ${entityType} from cache.`);
+
+      log.info(`${origin}: Successfully removed '${entityType}' from cache.`);
       return;
     }
   }
-  log.error(`${origin}: Did not find cache type ${entityType} to remove!`);
+
+  log.error(`${origin}: Entity type '${entityType}' not found in cache. Removal failed.`);
 }
 
 /**
@@ -477,76 +505,92 @@ class CacheHandler {
       return;
     }
 
+    log.debug(`${origin}: Validating and setting new properties.`);
     this.props = validateProperties(properties);
 
     const wasEnabled = this.enabled || false; // in case undefined
     this.enabled = this.props.cache.enabled;
+
     if (!this.enabled) {
-      // destroy cache and properties for memory efficiency
       if (wasEnabled) {
+        log.warn(`${origin}: Cache was disabled from enabled state. Clearing cache for memory efficiency.`);
         deleteCacheData(this);
       } else {
         log.debug(`${origin}: Cache remains disabled. No action required.`);
       }
-      log.warn('Cache was disabled from enabled, removed cache memory.');
       return;
     }
 
-    // check entityType was not deleted (if so flush that cache type)
+    log.debug(`${origin}: Checking for deleted or updated entity types.`);
     this.propertiesMap.forEach((value, key) => {
+      let entityExists = false;
+
       for (let i = 0; i < this.props.cache.entities.length; i += 1) {
-        if (!this.props.cache.entities[i].name === key) { // currently in cache, but not props
-          removeCacheEntry(this.cache, key);
-          this.propertiesMap.delete(key);
-          log.warn(`${origin}: Removed cache entity type due to change in properties.`);
-          log.info(`Deleted props for entity type ${key} with val ${value}`);
-          return; // continue forEach
+        if (this.props.cache.entities[i].name === key) {
+          entityExists = true;
+          break;
         }
       }
+
+      if (!entityExists) {
+        log.warn(`${origin}: Detected removed entity type '${key}'. Removing from cache.`);
+        removeCacheEntry(this.cache, key);
+        this.propertiesMap.delete(key);
+        log.info(`${origin}: Deleted properties for entity type '${key}' with value '${value}'.`);
+      }
     });
 
-    // set properties map
+    log.debug(`${origin}: Updating and setting properties map for cache entities.`);
     this.props.cache.entities.forEach((entity) => {
       if (!this.propertiesMap.has(entity.entityType)) {
-        // entity does not exist yet
+        log.debug(`${origin}: Adding new entity type '${entity.entityType}' to properties map.`);
         this.propertiesMap.set(entity.entityType, {});
-        this.propertiesMap.get(entity.entityType).frequency = entity.frequency;
-        this.propertiesMap.get(entity.entityType).flushOnFail = entity.flushOnFail;
-        this.propertiesMap.get(entity.entityType).populate = entity.populate;
-        this.propertiesMap.get(entity.entityType).limit = entity.limit;
-        this.propertiesMap.get(entity.entityType).retryAttempts = entity.retryAttempts;
+        const entityProps = this.propertiesMap.get(entity.entityType);
+        entityProps.frequency = entity.frequency;
+        entityProps.flushOnFail = entity.flushOnFail;
+        entityProps.populate = entity.populate;
+        entityProps.limit = entity.limit;
+        entityProps.retryAttempts = entity.retryAttempts;
 
         const newIntervalId = setInterval(() => {
+          log.debug(`${origin}: Populating cache for entity type '${entity.entityType}'.`);
           this.populateCache(entity.entityType);
         }, entity.frequency * 60000);
 
         const sort = Object.prototype.hasOwnProperty.call(entity, 'sort') ? entity.sort : true; // default true
         this.cache.push(createCacheEntity(entity.entityType, null, newIntervalId, sort));
-        this.populateCache(entity.entityType).then((result) => {
-          if (result && result[0] === 'error') {
-            retryPopulate(entity.entityType, this, entity.retryAttempts).then((nextResult) => {
-              log.info(nextResult);
-            });
-          }
-        }).catch((error) => {
-          log.error('Failed populate cache!');
-          if (error.icode === 'AD.301') {
-            log.error(`Destroying interval, check path and call in properties for ${entity.entityType}`);
-            clearInterval(newIntervalId);
-            this.cache.removeCacheEntry(this.cache, entity.entityType);
-          }
-        });
+
+        this.populateCache(entity.entityType)
+          .then((result) => {
+            if (result && result[0] === 'error') {
+              log.warn(`${origin}: Populate failed for '${entity.entityType}'. Retrying...`);
+              retryPopulate(entity.entityType, this, entity.retryAttempts).then((nextResult) => {
+                log.info(`${origin}: Retry result for '${entity.entityType}': ${nextResult}`);
+              });
+            }
+          })
+          .catch((error) => {
+            log.error(`${origin}: Populate cache failed for '${entity.entityType}'.`);
+            if (error.icode === 'AD.301') {
+              log.error(`${origin}: Clearing interval and removing cache entity '${entity.entityType}' due to error.`);
+              clearInterval(newIntervalId);
+              this.cache.removeCacheEntry(this.cache, entity.entityType);
+            }
+          });
       } else {
-        // entity props frequency updated
-        if (entity.frequency !== this.propertiesMap.get(entity.entityType).frequency) {
+        log.debug(`${origin}: Updating frequency and properties for existing entity type '${entity.entityType}'.`);
+        const entityProps = this.propertiesMap.get(entity.entityType);
+
+        if (entity.frequency !== entityProps.frequency) {
+          log.info(`${origin}: Updating update frequency for '${entity.entityType}' from '${entityProps.frequency}' to '${entity.frequency}'.`);
           changeUpdateFrequency(this.cache, entity.entityType, entity.frequency, this);
         }
 
-        this.propertiesMap.get(entity.entityType).frequency = entity.frequency;
-        this.propertiesMap.get(entity.entityType).flushOnFail = entity.flushOnFail;
-        this.propertiesMap.get(entity.entityType).populate = entity.populate;
-        this.propertiesMap.get(entity.entityType).limit = entity.limit;
-        this.propertiesMap.get(entity.entityType).retryAttempts = entity.retryAttempts;
+        entityProps.frequency = entity.frequency;
+        entityProps.flushOnFail = entity.flushOnFail;
+        entityProps.populate = entity.populate;
+        entityProps.limit = entity.limit;
+        entityProps.retryAttempts = entity.retryAttempts;
       }
     });
   }
@@ -563,37 +607,37 @@ class CacheHandler {
     log.trace(origin);
 
     if (!this.enabled) {
+      log.info(`${origin}: Cache is not enabled. Populate operation aborted.`);
       return Promise.reject(new Error('Cache is not enabled!'));
     }
 
-    log.info('Populating cache.');
+    log.info(`${origin}: Starting cache population.`);
 
-    // support string and array input
+    // Support string and array input
     let entityArr = entities;
     if (!Array.isArray(entities)) {
       entityArr = [entities];
     }
 
-    // need all properties to make iap call
+    // Ensure all entities are tracked
     for (let i = 0; i < entityArr.length; i += 1) {
       const entityType = entityArr[i];
       if (!this.propertiesMap.has(entityType)) {
-        log.error(`${entityType} is an untracked entity type! Check properties.`);
+        log.error(`${origin}: ${entityType} is an untracked entity type! Check properties.`);
         return Promise.reject(new Error(`${entityType} is an untracked entity type! Check properties.`));
       }
     }
 
     try {
       const promiseArr = [];
-      // for each entityType need to populate
+      // Populate each entity type
       for (let j = 0; j < entityArr.length; j += 1) {
         const entityType = entityArr[j];
-        // try to find current entityType in cache
         for (let i = 0; i < this.cache.length; i += 1) {
-          if (this.cache[i].entityType === entityType) { // will always be found
+          if (this.cache[i].entityType === entityType) {
             promiseArr.push(new Promise((resolve, reject) => {
               makeIAPCall(this.propertiesMap.get(entityType).populate, this.requestHandler, (cacheData, error) => {
-                // error message if applicable
+                // Error handling
                 let errorMsg = null;
                 if (error) {
                   errorMsg = `${origin}: ${entityType} failed with error ${error.IAPerror.displayString}.`;
@@ -602,17 +646,12 @@ class CacheHandler {
                 } else if (cacheData.length === 0) {
                   errorMsg = `${origin}: ${entityType} failed. Nothing found.`;
                 }
-                // handle error
-                if (errorMsg !== null) {
-                  /**
-                   * removed unnecessary check if cache[i].list is null here
-                   * setting null var to null again is fine and shortens critical section
-                   * */
 
+                if (errorMsg !== null) {
                   if (this.propertiesMap.get(entityType).flushOnFail) {
                     lock.acquire(this.cache[i].lockKey, (done) => {
                       this.cache[i].list = null;
-                      done(`${errorMsg} Flushed.`);
+                      done(`${errorMsg} Cache flushed.`);
                     }, (ret) => {
                       log.error(ret);
                     });
@@ -620,24 +659,22 @@ class CacheHandler {
                     log.error(`${errorMsg} Keeping old data.`);
                   }
 
-                  // bad path
                   if (error && error.icode === 'AD.301') {
                     return reject(error);
                   }
                   return resolve('error');
                 }
-                // sort cache data, default true
+
+                // Sort and update cache
                 if (this.cache[i].sort) {
                   cacheData.sort(compareByName);
                 }
-
-                // no error, edit cache
                 lock.acquire(this.cache[i].lockKey, (done) => {
-                  if (this.enabled) { // in case properties changes during iap call
+                  if (this.enabled) {
                     this.cache[i].list = cacheData;
-                    done(`${entityType}: cache updated.`);
+                    done(`${origin}: ${entityType} cache updated successfully.`);
                   } else {
-                    done('Populate cancelled due to disabled cache!');
+                    done(`${origin}: Populate cancelled due to disabled cache.`);
                   }
                 }, (ret) => {
                   log.info(ret);
@@ -649,6 +686,8 @@ class CacheHandler {
           }
         }
       }
+
+      // Resolve all promises
       const arr = await Promise.allSettled(promiseArr);
       return new Promise((resolve, reject) => {
         const valueArray = [];
@@ -661,7 +700,7 @@ class CacheHandler {
         resolve(valueArray);
       });
     } catch (e) {
-      // re-throw any exception
+      log.error(`${origin}: An exception occurred during cache population - ${e.message}`);
       throw new Error(e);
     }
   }
@@ -684,47 +723,56 @@ class CacheHandler {
     log.trace(origin);
 
     if (!this.enabled) {
-      log.warn(`${origin}: Cache is not enabled!`);
+      log.info(`${origin}: Cache is not enabled!`);
       return callback(null, 'Cache is not enabled.');
     }
 
     if (typeof entityType !== 'string') {
-      log.error(`${entityType} is not of type String`);
+      log.error(`${origin}: Invalid entityType - ${entityType} is not of type String.`);
       return callback(null, `${entityType} is not of type String`);
     }
 
     try {
       const options = validateOptions(opts); // may throw error
-      // go through the cache to find the entity we care about
+
+      log.debug(`${origin}: Searching cache for entityType: ${entityType}.`);
+      // Search for the specified entityType in the cache
       for (let i = 0; i < this.cache.length; i += 1) {
-        // check if entity type we care about
         if (this.cache[i].entityType === entityType) {
-          // Lock the cache for the entity so we can take what is in the cache
-          // Lock and instant unlock as wait until lock is free
+          log.info(`${origin}: Found cache entry for entityType: ${entityType}.`);
+
+          // Lock the cache entry for safe access
           return lock.acquire(this.cache[i].lockKey, (done) => {
-            // return the entity's list and free the lock
+            log.debug(`${origin}: Retrieved cache list for entityType: ${entityType}.`);
             done(this.cache[i].list);
           }, (ret) => {
-            // last iap call failed and flushed, attempt new iap call
             if (!ret) {
-              // this returns a promise but below we return a callback...
+              log.warn(`${origin}: Last IAP call failed and flushed cache for ${entityType}. Attempting to repopulate.`);
+
+              // Repopulate cache and retry retrieval
               return this.populateCache(entityType).then((result) => {
                 if (result && result[0] === 'success') {
+                  log.info(`${origin}: Repopulation succeeded for ${entityType}. Retrieving updated entries.`);
                   return retrieveCacheEntriesHelper(this.cache, entityType, options, callback);
                 }
-                return callback(null, `Retrieve call for ${entityType} failed, and populate re-attempt failed`);
+                log.error(`${origin}: Repopulation failed for ${entityType}.`);
+                return callback(null, `Retrieve call for ${entityType} failed, and populate re-attempt failed.`);
+              }).catch((err) => {
+                log.error(`${origin}: Error during repopulation for ${entityType} - ${err.message}`);
+                return callback(null, `Retrieve call for ${entityType} failed due to an error during repopulation.`);
               });
             }
 
-            // normal retrieve
+            log.debug(`${origin}: Retrieved entries successfully for entityType: ${entityType}.`);
             return retrieveCacheEntriesHelper(this.cache, entityType, options, callback);
           });
         }
       }
-      log.error(`${origin}: Failed to find ${entityType} in retrieve!`);
+
+      log.error(`${origin}: Cache entry not found for entityType: ${entityType}.`);
       return callback(null, `Retrieve call for ${entityType} failed.`);
     } catch (e) {
-      // re-throw any exception
+      log.error(`${origin}: Exception occurred during retrieval - ${e.message}`);
       throw new Error(e);
     }
   }
@@ -742,68 +790,72 @@ class CacheHandler {
   isEntityCached(entityType, entityNames, callback) {
     const origin = `${id}-cacheHandler-isEntityCached`;
     log.trace(origin);
-    // Possibly supporting checking if entityType is cache? (set entityId = null)
+
     if (!this.enabled) {
-      log.warn(`${origin}: Cache is not enabled!`);
+      log.info(`${origin}: Cache is not enabled!`);
       return callback(null, 'Cache is not enabled!');
     }
 
-    let names = entityNames;
-    if (!Array.isArray(entityNames)) {
-      names = [entityNames];
-    }
+    const names = Array.isArray(entityNames) ? entityNames : [entityNames];
 
     try {
+      log.debug(`${origin}: Checking cache for entityType: ${entityType}, entityNames: ${names}.`);
+
       for (let i = 0; i < this.cache.length; i += 1) {
         if (this.cache[i].entityType === entityType) {
+          log.info(`${origin}: Cache entry found for entityType: ${entityType}.`);
+
           const returnVals = [];
+
+          // Lock the cache entry to safely access the list
           return lock.acquire(this.cache[i].lockKey, (done) => {
+            log.debug(`${origin}: Acquired lock for cache entry of entityType: ${entityType}.`);
             done(this.cache[i].list);
           }, (ret) => {
-            // null list means previously flushed or failed called
             if (!ret) {
-              log.info(`Did not find ${entityType}, attempting populate in isEntityCached`);
-              return this.populateCache(entityType).then((result) => { // populate will re-acquire lock
+              log.warn(`${origin}: Cache list is null or empty for ${entityType}. Attempting to repopulate.`);
+
+              return this.populateCache(entityType).then((result) => {
                 if (result && result[0] === 'success') {
-                  // re-acquire lock to read list
-                  lock.acquire(this.cache[i].lockKey, (done) => {
+                  log.info(`${origin}: Cache repopulation succeeded for ${entityType}. Rechecking cache.`);
+
+                  // Reacquire lock to access the updated cache list
+                  return lock.acquire(this.cache[i].lockKey, (done) => {
                     names.forEach((name) => {
-                      for (let j = 0; j < this.cache[i].list.length; j += 1) {
-                        if (this.cache[i].list[j].name === name) {
-                          returnVals.push('found');
-                          return; // forEach
-                        }
-                      }
-                      returnVals.push('notfound');
+                      const isFound = this.cache[i].list.some((item) => item.name === name);
+                      returnVals.push(isFound ? 'found' : 'notfound');
                     });
                     done(returnVals);
                   }, (retVals) => {
-                    log.info(retVals);
+                    log.debug(`${origin}: Final cache check results: ${retVals}`);
                     return callback(retVals);
                   });
                 }
+
+                log.error(`${origin}: Cache repopulation failed for ${entityType}.`);
                 return callback(null, `isEntityCached call for ${entityType} failed.`);
+              }).catch((err) => {
+                log.error(`${origin}: Error during cache repopulation for ${entityType} - ${err.message}`);
+                return callback(null, `isEntityCached call for ${entityType} failed due to repopulation error.`);
               });
             }
 
+            log.debug(`${origin}: Processing cached list for entityType: ${entityType}.`);
             names.forEach((curName) => {
-              for (let j = 0; j < ret.length; j += 1) {
-                if (ret[j].name === curName) {
-                  returnVals.push('found');
-                  return; // continue the forEach
-                }
-              }
-              returnVals.push('notfound');
+              const isFound = ret.some((item) => item.name === curName);
+              returnVals.push(isFound ? 'found' : 'notfound');
             });
-            log.info(returnVals);
+
+            log.debug(`${origin}: Cache check results: ${returnVals}`);
             return callback(returnVals);
           }); // end of lock acquire
         }
       }
-      log.error(`${entityType} not found in cache.`);
+
+      log.error(`${origin}: No cache entry found for entityType: ${entityType}.`);
       return callback(false);
     } catch (e) {
-      log.error(e);
+      log.error(`${origin}: Exception occurred during cache check - ${e.message}`);
       return callback(false);
     }
   }
@@ -817,14 +869,16 @@ class CacheHandler {
    */
   isEntityTypeToBeCached(entityType, callback) {
     const origin = `${id}-cacheHandler-isEntityTypeToBeCached`;
-    log.trace(origin);
+    log.trace(`${origin}: Checking if entityType should be cached.`);
 
     if (!this.enabled) {
-      log.error('Cache is not enabled!');
+      log.info(`${origin}: Cache is not enabled.`);
       return callback(null, 'Cache is not enabled!');
     }
 
-    return callback(this.propertiesMap.has(entityType));
+    const isCached = this.propertiesMap.has(entityType);
+    log.debug(`${origin}: entityType "${entityType}" is ${isCached ? '' : 'not '}to be cached.`);
+    return callback(isCached);
   }
 
   /**
@@ -836,28 +890,38 @@ class CacheHandler {
    */
   isTaskCached(entityType, task) {
     const origin = `${id}-cacheHandler-isTaskCached`;
-    log.trace(origin);
+    log.trace(`${origin}: Checking if task "${task}" is cached under entityType "${entityType}".`);
 
-    // do not bother with callbacks here
-    if (!this.enabled || !this.propertiesMap.has(entityType)) {
+    // If cache is disabled or the entityType is not tracked, return false early
+    if (!this.enabled) {
+      log.info(`${origin}: Cache is not enabled.`);
       return false;
     }
 
-    // find entity type
-    for (let i = 0; i < this.props.cache.entities.length; i += 1) {
-      if (this.props.cache.entities[i].entityType === entityType) {
-        // check if contains task
-        for (let c = 0; c < this.props.cache.entities[i].cachedTasks.length; c += 1) {
-          if (this.props.cache.entity[i].cachedTasks[c].name === task) {
-            return true;
-          }
-        }
-        // does not have task under that entityType
-        return false;
-      }
+    if (!this.propertiesMap.has(entityType)) {
+      log.warn(`${origin}: entityType "${entityType}" is not configured in propertiesMap.`);
+      return false;
+    }
+
+    const cachedEntity = this.props.cache.entities.find(
+      (entity) => entity.entityType === entityType
+    );
+
+    if (!cachedEntity) {
+      log.error(`${origin}: entityType "${entityType}" not found in cache.`);
+      return false;
     }
-    // entityType not cached, should never reach here
-    log.error(`${origin}: EntityType not found in cache, should never reach here.`);
+
+    const isTaskFound = cachedEntity.cachedTasks.some(
+      (cachedTask) => cachedTask.name === task
+    );
+
+    if (isTaskFound) {
+      log.debug(`${origin}: Task "${task}" is cached under entityType "${entityType}".`);
+      return true;
+    }
+
+    log.debug(`${origin}: Task "${task}" is not cached under entityType "${entityType}".`);
     return false;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itentialopensource/adapter-utils",
-  "version": "5.10.6",
+  "version": "5.10.7",
   "description": "Itential Adapter Utility Libraries",
   "scripts": {
     "postinstall": "node utils/setup.js",