@mojaloop/central-services-shared 18.22.3 → 18.22.4

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [18.22.4](https://github.com/mojaloop/central-services-shared/compare/v18.22.3...v18.22.4) (2025-03-13)
+
+
+### Chore
+
+* **csi-1233:** improved participantEndpointCache logging ([#440](https://github.com/mojaloop/central-services-shared/issues/440)) ([94eb898](https://github.com/mojaloop/central-services-shared/commit/94eb898a0d3cb9152390162d5fefca24a6c6082e))
+
 ### [18.22.3](https://github.com/mojaloop/central-services-shared/compare/v18.22.2...v18.22.3) (2025-03-12)
 
 

package/audit-ci.jsonc

@@ -5,5 +5,6 @@
   "moderate": true,
   "allowlist": [ // NOTE: Please add as much information as possible to any items added to the allowList
     // e.g. Currently no fixes available for the following
+    "GHSA-968p-4wvh-cqc8" // https://github.com/advisories/GHSA-968p-4wvh-cqc8
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.22.3",
+  "version": "18.22.4",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",
@@ -85,7 +85,7 @@
     "yaml": "2.7.0"
   },
   "devDependencies": {
-    "@mojaloop/sdk-standard-components": "19.10.1",
+    "@mojaloop/sdk-standard-components": "19.10.3",
     "@types/hapi__joi": "17.1.15",
     "audit-ci": "7.1.0",
     "base64url": "3.0.1",

package/src/util/endpoints.js

@@ -29,7 +29,6 @@
 
 'use strict'
 
-const Logger = require('@mojaloop/central-services-logger')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Metrics = require('@mojaloop/central-services-metrics')
 const proxyLib = require('@mojaloop/inter-scheme-proxy-cache-lib')
@@ -38,6 +37,7 @@ const CatboxMemory = require('@hapi/catbox-memory')
 const Mustache = require('mustache')
 const { Map } = require('immutable')
 
+const logger = require('../logger').logger.child({ component: 'participantEndpointCache' })
 const Enum = require('../enums')
 const Http = require('./http')
 const request = require('./request')
@@ -66,8 +66,9 @@ const fetchEndpoints = async (fsp) => {
     'fetchParticipants - Metrics for fetchParticipants',
     ['success']
   ).startTimer()
+  const log = logger.child({ fsp, method: 'fetchEndpoints' })
   try {
-    Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ participantEndpointCache::fetchEndpoints := Refreshing the cache for FSP: ${fsp}`)
+    log.debug('refreshing the cache for FSP')
     if (!hubName) {
       throw Error('"hubName" is not initialized. Initialize the cache first.')
     }
@@ -76,7 +77,8 @@ const fetchEndpoints = async (fsp) => {
     }
     const defaultHeaders = Http.SwitchDefaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName)
     const url = Mustache.render(switchEndpoint + Enum.EndPoints.FspEndpointTemplates.PARTICIPANT_ENDPOINTS_GET, { fsp })
-    Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ participantEndpointCache::fetchEndpoints := URL for FSP: ${url}`)
+    log.verbose('url for PARTICIPANT_ENDPOINTS_GET', { url })
+
     const response = await request.sendRequest({
       url,
       headers: defaultHeaders,
@@ -84,8 +86,9 @@ const fetchEndpoints = async (fsp) => {
       destination: hubName,
       hubNameRegex
     })
-    Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ Model::participantEndpoint::fetchEndpoints := successful with body: ${JSON.stringify(response.data)}`)
     const endpoints = response.data
+    log.debug('fetchEndpoints raw response.data:', { endpoints })
+
     const endpointMap = {}
     if (Array.isArray(endpoints)) {
       endpoints.forEach(item => {
@@ -93,12 +96,12 @@ const fetchEndpoints = async (fsp) => {
         endpointMap[item.type] = item.value
       })
     }
-    Logger.isDebugEnabled && Logger.debug(`[fsp=${fsp}] ~ participantEndpointCache::fetchEndpoints := Returning the endpoints: ${JSON.stringify(endpointMap)}`)
+    log.verbose('fetchEndpoints is done', { endpointMap })
     histTimer({ success: true })
+
     return endpointMap
-  } catch (e) {
-    histTimer({ success: false })
-    Logger.isErrorEnabled && Logger.error(`participantEndpointCache::fetchEndpoints:: ERROR:'${e}'`)
+  } catch (err) {
+    log.error('error in fetchEndpoints: ', err)
   }
 }
 
@@ -116,18 +119,17 @@ const fetchEndpoints = async (fsp) => {
  */
 exports.initializeCache = async (policyOptions, config) => {
   try {
-    Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::initializeCache::start::clientOptions - ${JSON.stringify(clientOptions)}`)
+    logger.debug('initializeCache start', { clientOptions, policyOptions })
     client = new Catbox.Client(CatboxMemory, clientOptions)
     await client.start()
     policyOptions.generateFunc = fetchEndpoints
-    Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::initializeCache::start::policyOptions - ${JSON.stringify(policyOptions)}`)
     policy = new Catbox.Policy(policyOptions, client, partition)
-    Logger.isDebugEnabled && Logger.debug('participantEndpointCache::initializeCache::Cache initialized successfully')
     hubName = config.hubName
     hubNameRegex = config.hubNameRegex
+    logger.verbose('initializeCache is done successfully', { hubName, hubNameRegex })
     return true
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(`participantEndpointCache::Cache error:: ERROR:'${err}'`)
+    logger.error('error in initializeCache: ', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -152,9 +154,11 @@ exports.getEndpoint = async (switchUrl, fsp, endpointType, options = {}, renderO
     ['success', 'hit']
   ).startTimer()
   switchEndpoint = switchUrl
-  Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::getEndpoint::endpointType - ${endpointType}`)
+  const log = logger.child({ fsp, endpointType, method: 'getEndpoint' })
+  log.debug('getEndpoint start', { switchUrl })
   let proxyId
   const result = url => proxyConfig?.enabled ? { url, proxyId } : url
+
   try {
     // If a service passes in `getDecoratedValue` as true, then an object
     // { value, cached, report } is returned, where value is the cached value,
@@ -168,7 +172,11 @@ exports.getEndpoint = async (switchUrl, fsp, endpointType, options = {}, renderO
       proxyId = await proxy.lookupProxyByDfspId(fsp)
       endpoints = proxyId && await policy.get(proxyId)
     }
-    if (!endpoints) throw ErrorHandler.CreateFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
+    if (!endpoints) {
+      log.warn('no endpoints found for fsp')
+      throw ErrorHandler.CreateFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
+    }
+
     if ('value' in endpoints && 'cached' in endpoints) {
       if (endpoints.cached === null) {
         histTimer({ success: true, hit: false })
@@ -182,6 +190,7 @@ exports.getEndpoint = async (switchUrl, fsp, endpointType, options = {}, renderO
       }
       return result(Mustache.render(endpoint, options))
     }
+
     let endpoint = new Map(endpoints).get(endpointType)
     if (renderOptions.path) {
       endpoint = (endpoint === undefined) ? endpoint : endpoint + renderOptions.path
@@ -190,7 +199,7 @@ exports.getEndpoint = async (switchUrl, fsp, endpointType, options = {}, renderO
     return result(Mustache.render(endpoint, options))
   } catch (err) {
     histTimer({ success: false, hit: false })
-    Logger.isErrorEnabled && Logger.error(`participantEndpointCache::getEndpoint:: ERROR:'${err}'`)
+    log.error('error in getEndpoint: ', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -215,7 +224,8 @@ exports.getEndpointAndRender = async (switchUrl, fsp, endpointType, path = '', o
     ['success']
   ).startTimer()
   switchEndpoint = switchUrl
-  Logger.isDebugEnabled && Logger.debug(`participantEndpointCache::getEndpointAndRender::endpointType - ${endpointType}`)
+  const log = logger.child({ fsp, endpointType })
+  log.debug('getEndpointAndRender start', { switchUrl, path })
 
   try {
     const endpoint = exports.getEndpoint(switchUrl, fsp, endpointType, options, { path })
@@ -223,7 +233,7 @@ exports.getEndpointAndRender = async (switchUrl, fsp, endpointType, path = '', o
     return endpoint
   } catch (err) {
     histTimer({ success: false })
-    Logger.isErrorEnabled && Logger.error(`participantEndpointCache::getEndpointAndRender:: ERROR:'${err}'`)
+    log.error('error in getEndpointAndRender: ', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -236,7 +246,7 @@ exports.getEndpointAndRender = async (switchUrl, fsp, endpointType, path = '', o
  * @returns {boolean} - Returns the status
  */
 exports.stopCache = async () => {
-  Logger.isDebugEnabled && Logger.debug('participantEndpointCache::stopCache::Stopping the cache')
+  logger.verbose('stopping the cache')
   if (client) {
     return client.stop()
   }
@@ -252,6 +262,7 @@ exports.stopCache = async () => {
 exports.stopProxy = async () => {
   const result = await proxy?.disconnect()
   proxy = undefined
+  logger.verbose('proxy disconnected')
   return result
 }
 

package/src/util/participants.js

@@ -28,17 +28,19 @@
 
 'use strict'
 
-const Logger = require('@mojaloop/central-services-logger')
+const ErrorHandler = require('@mojaloop/central-services-error-handling')
+const Metrics = require('@mojaloop/central-services-metrics')
 const Catbox = require('@hapi/catbox')
 const CatboxMemory = require('@hapi/catbox-memory')
-const Http = require('./http')
+const Mustache = require('mustache')
+
+const logger = require('../logger').logger.child({ component: 'participantCache' })
 const Enum = require('../enums')
+const Http = require('./http')
+const request = require('./request')
+
 const partition = 'participant-cache'
 const clientOptions = { partition }
-const Mustache = require('mustache')
-const request = require('./request')
-const ErrorHandler = require('@mojaloop/central-services-error-handling')
-const Metrics = require('@mojaloop/central-services-metrics')
 
 let client
 let policy
@@ -61,8 +63,10 @@ const fetchParticipant = async (fsp) => {
     'fetchParticipant - Metrics for fetchParticipant',
     ['success']
   ).startTimer()
+  const log = logger.child({ fsp, method: 'fetchParticipant' })
+
   try {
-    Logger.isDebugEnabled && Logger.debug('participantCache::fetchParticipant := Refreshing participant cache')
+    log.debug('refreshing participant cache', { hubName })
     if (!hubName) {
       throw Error('"hubName" is not initialized. Initialize the cache first.')
     }
@@ -71,7 +75,8 @@ const fetchParticipant = async (fsp) => {
     }
     const defaultHeaders = Http.SwitchDefaultHeaders(hubName, Enum.Http.HeaderResources.PARTICIPANTS, hubName)
     const url = Mustache.render(switchEndpoint + Enum.EndPoints.FspEndpointTemplates.PARTICIPANTS_GET, { fsp })
-    Logger.isDebugEnabled && Logger.debug(`participantCache::fetchParticipant := URL: ${url}`)
+    log.verbose('url for PARTICIPANTS_GET', { url })
+
     const response = await request.sendRequest({
       url,
       headers: defaultHeaders,
@@ -80,12 +85,14 @@ const fetchParticipant = async (fsp) => {
       hubNameRegex
     })
     const participant = response.data
+    log.verbose('fetchParticipant is done', { participant })
     histTimer({ success: true })
+
     return participant
-  } catch (e) {
+  } catch (err) {
     histTimer({ success: false })
     // We're logging this as a "warning" rather than "error" because the participant might be a proxied participant
-    Logger.isWarnEnabled && Logger.warn(`participantCache::fetchParticipants:: WARNING:'${e}'`)
+    log.warn('error in fetchParticipants: ', err)
   }
 }
 
@@ -99,18 +106,17 @@ const fetchParticipant = async (fsp) => {
 */
 exports.initializeCache = async (policyOptions, config) => {
   try {
-    Logger.isDebugEnabled && Logger.debug(`participantCache::initializeCache::start::clientOptions - ${JSON.stringify(clientOptions)}`)
+    logger.debug('participantCache::initializeCache start', { clientOptions, policyOptions })
     client = new Catbox.Client(CatboxMemory, clientOptions)
     await client.start()
     policyOptions.generateFunc = fetchParticipant
-    Logger.isDebugEnabled && Logger.debug(`participantCache::initializeCache::start::policyOptions - ${JSON.stringify(policyOptions)}`)
     policy = new Catbox.Policy(policyOptions, client, partition)
-    Logger.isDebugEnabled && Logger.debug('participantCache::initializeCache::Cache initialized successfully')
     hubName = config.hubName
     hubNameRegex = config.hubNameRegex
+    logger.verbose('participantCache::initializeCache is done', { hubName })
     return true
   } catch (err) {
-    Logger.isErrorEnabled && Logger.error(`participantCache::Cache error:: ERROR:'${err}'`)
+    logger.error(`error in participantCache::initializeCache: ${err?.message}`, err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -132,7 +138,8 @@ exports.getParticipant = async (switchUrl, fsp) => {
     ['success', 'hit']
   ).startTimer()
   switchEndpoint = switchUrl
-  Logger.isDebugEnabled && Logger.debug('participantCache::getParticipant')
+  const log = logger.child({ fsp, method: 'getParticipant' })
+  log.debug('getParticipant start', { switchUrl })
   try {
     // If a service passes in `getDecoratedValue` as true, then an object
     // { value, cached, report } is returned, where value is the cached value,
@@ -140,11 +147,7 @@ exports.getParticipant = async (switchUrl, fsp) => {
     let participant = await policy.get(fsp)
 
     if ('value' in participant && 'cached' in participant) {
-      if (participant.cached === null) {
-        histTimer({ success: true, hit: false })
-      } else {
-        histTimer({ success: true, hit: true })
-      }
+      histTimer({ success: true, hit: participant.cached !== null })
       participant = participant.value
     } else {
       histTimer({ success: true, hit: false })
@@ -152,9 +155,10 @@ exports.getParticipant = async (switchUrl, fsp) => {
 
     /* istanbul ignore next */
     if (!participant) {
-      Logger.isWarnEnabled && Logger.warn('participantCache::getParticipant - no participant found')
+      log.warn('no participant found')
       return null
     }
+    log.verbose('getParticipant result:', { participant })
 
     if (participant.errorInformation) {
       // Drop error from cache
@@ -164,7 +168,7 @@ exports.getParticipant = async (switchUrl, fsp) => {
     return participant
   } catch (err) {
     histTimer({ success: false, hit: false })
-    Logger.isErrorEnabled && Logger.error(`participantCache::getParticipant:: ERROR:'${err}'`)
+    log.error('error in getParticipant: ', err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -176,8 +180,9 @@ exports.getParticipant = async (switchUrl, fsp) => {
 *
 * @returns {void}
 */
+/* istanbul ignore next */
 exports.invalidateParticipantCache = async (fsp) => {
-  Logger.isDebugEnabled && Logger.debug('participantCache::invalidateParticipantCache::Invalidating the cache')
+  logger.verbose('participantCache invalidateParticipantCache')
   if (policy) {
     return policy.drop(fsp)
   }
@@ -190,8 +195,9 @@ exports.invalidateParticipantCache = async (fsp) => {
 *
 * @returns {boolean} - Returns the status
 */
+/* istanbul ignore next */
 exports.stopCache = async () => {
-  Logger.isDebugEnabled && Logger.debug('participantCache::stopCache::Stopping the cache')
+  logger.verbose('participantCache stopCache')
   if (client) {
     return client.stop()
   }