account-lookup-service 15.6.0-snapshot.2 → 16.1.0-iso.0

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -87,19 +87,24 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     'Get party by Type and Id',
     ['success']
   ).startTimer()
+  const errorCounter = Metrics.getCounter('errorCount')
   const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
   const type = params.Type
   const partySubId = params.SubId
+  const callbackEndpointType = utils.getPartyCbType(partySubId)
   const source = headers[Headers.FSPIOP.SOURCE]
   const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
-  const callbackEndpointType = utils.getPartyCbType(partySubId)
+  let destination = headers[Headers.FSPIOP.DESTINATION]
+  // see https://github.com/mojaloop/design-authority/issues/79
+  // the requester has specified a destination routing header. We should respect that and forward the request directly to the destination
+  // without consulting any oracles.
 
   const childSpan = span ? span.getChild('getPartiesByTypeAndID') : undefined
-  log.info('parties::getPartiesByTypeAndID::begin', { source, proxy, params })
+  log.info('parties::getPartiesByTypeAndID::begin', { source, destination, proxy, params })
 
   let requester
   let fspiopError
-
+  let step
   try {
     requester = await validateRequester({ source, proxy, proxyCache })
 
@@ -109,22 +114,22 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
       ...(partySubId && { partySubIdOrType: partySubId })
     }
 
-    let destination = headers[Headers.FSPIOP.DESTINATION]
-    // see https://github.com/mojaloop/design-authority/issues/79
-    // the requester has specified a destination routing header. We should respect that and forward the request directly to the destination
-    // without consulting any oracles.
     if (destination) {
+      step = 'validateParticipant-1'
       const destParticipantModel = await participant.validateParticipant(destination)
       if (!destParticipantModel) {
+        step = 'lookupProxyByDfspId-2'
         const proxyId = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
 
         if (!proxyId) {
+          log.warn('no destination participant, and no dfsp-to-proxy mapping', { destination })
           const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
           throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
         }
         destination = proxyId
       }
       // all ok, go ahead and forward the request
+      step = 'sendRequest-3'
       await participant.sendRequest(headers, destination, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
 
       histTimerEnd({ success: true })
@@ -132,6 +137,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
       return
     }
 
+    step = 'oracleRequest-4'
     const response = await oracle.oracleRequest(headers, method, params, query, undefined, cache)
     if (Array.isArray(response?.data?.partyList) && response.data.partyList.length > 0) {
       // Oracle's API is a standard rest-style end-point Thus a GET /party on the oracle will return all participant-party records. We must filter the results based on the callbackEndpointType to make sure we remove records containing partySubIdOrType when we are in FSPIOP_CALLBACK_URL_PARTIES_GET mode:
@@ -159,6 +165,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
         if (!destination) {
           clonedHeaders[Headers.FSPIOP.DESTINATION] = fspId
         }
+        step = 'validateParticipant-5'
         const schemeParticipant = await participant.validateParticipant(fspId)
         if (schemeParticipant) {
           sentCount++
@@ -169,6 +176,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
         // If the participant is not in the scheme and proxy routing is enabled,
         // we should check if there is a proxy for it and send the request to the proxy
         if (proxyEnabled) {
+          step = 'lookupProxyByDfspId-6'
           const proxyName = await proxyCache.lookupProxyByDfspId(fspId)
           if (!proxyName) {
             log.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
@@ -180,6 +188,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
           }
         }
       })
+      step = 'sendRequests-7'
       await Promise.all(sending)
       log.info('participant.sendRequests to filtered oracle partyList are done', { sentCount })
       // todo: think what if sentCount === 0 here
@@ -188,6 +197,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
       let filteredProxyNames = []
 
       if (proxyEnabled) {
+        step = 'getAllProxiesNames-8'
         const proxyNames = await Util.proxies.getAllProxiesNames(Config.SWITCH_ENDPOINT)
         filteredProxyNames = proxyNames.filter(name => name !== proxy)
       }
@@ -203,16 +213,19 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
         })
         fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
         const errorCallbackEndpointType = utils.errorPartyCbType(partySubId)
+        step = 'sendErrorToParticipant-9'
         await participant.sendErrorToParticipant(requester, errorCallbackEndpointType,
           fspiopError.toApiErrorObject(config.ERROR_HANDLING), callbackHeaders, params, childSpan)
       } else {
         const alsReq = utils.alsRequestDto(source, params)
         log.info('starting setSendToProxiesList flow: ', { filteredProxyNames, alsReq, proxyCacheTtlSec })
+        step = 'setSendToProxiesList-10'
         const isCached = await proxyCache.setSendToProxiesList(alsReq, filteredProxyNames, proxyCacheTtlSec)
         if (!isCached) {
           throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.failedToCacheSendToProxiesList)
         }
 
+        step = 'sending-11'
         const sending = filteredProxyNames.map(
           proxyName => participant.sendRequest(headers, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
             .then(({ status, data } = {}) => ({ status, data }))
@@ -232,6 +245,14 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
   } catch (err) {
     fspiopError = await handleErrorOnSendingCallback(err, headers, params, requester)
     histTimerEnd({ success: false })
+    const extensions = err.extensions || []
+    const system = extensions.find((element) => element.key === 'system')?.value || ''
+    errorCounter.inc({
+      code: fspiopError?.apiErrorCode?.code,
+      system,
+      operation: 'getPartiesByTypeAndID',
+      step
+    })
   } finally {
     await utils.finishSpanWithError(childSpan, fspiopError)
   }

package/src/domain/parties/parties.js

@@ -38,13 +38,13 @@ const Metrics = require('@mojaloop/central-services-metrics')
 const oracle = require('../../models/oracle/facade')
 const participant = require('../../models/participantEndpoint/facade')
 const { ERROR_MESSAGES } = require('../../constants')
-const { loggerFactory } = require('../../lib')
+const { logger } = require('../../lib')
 const Config = require('../../lib/config')
 const utils = require('./utils')
 const getPartiesByTypeAndID = require('./getPartiesByTypeAndID')
 
-const logger = loggerFactory('domain:put-parties')
-const handleErrorOnSendingCallback = utils.createErrorHandlerOnSendingCallback(Config, logger)
+const log = logger.child('domain:put-parties')
+const handleErrorOnSendingCallback = utils.createErrorHandlerOnSendingCallback(Config, log)
 
 /**
  * @function putPartiesByTypeAndID
@@ -65,44 +65,51 @@ const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri,
     'Put parties by type and id',
     ['success']
   ).startTimer()
+  const errorCounter = Metrics.getCounter('errorCount')
   const type = params.Type
   const partySubId = params.SubId
   const source = headers[Headers.FSPIOP.SOURCE]
   const destination = headers[Headers.FSPIOP.DESTINATION]
   const proxy = headers[Headers.FSPIOP.PROXY]
   const proxyEnabled = !!(Config.PROXY_CACHE_CONFIG.enabled && proxyCache)
-  logger.info('parties::putPartiesByTypeAndID::begin', { source, destination, proxy, params })
+  log.info('parties::putPartiesByTypeAndID::begin', { source, destination, proxy, params })
 
   let sendTo
+  let step
   try {
+    step = 'validateParticipant-1'
     const requesterParticipant = await participant.validateParticipant(source)
     if (!requesterParticipant) {
       if (!proxyEnabled || !proxy) {
         const errMessage = ERROR_MESSAGES.partySourceFspNotFound
         throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, errMessage)
       }
+      step = 'addDfspIdToProxyMapping-1'
       const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
       // think,if we should throw error if isCached === false?
-      logger.info('addDfspIdToProxyMapping is done', { source, proxy, isCached })
+      log.info('addDfspIdToProxyMapping is done', { source, proxy, isCached })
     }
 
     if (proxyEnabled && proxy) {
       const alsReq = utils.alsRequestDto(destination, params) // or source?
+      step = 'receivedSuccessResponse-2'
       const isExists = await proxyCache.receivedSuccessResponse(alsReq)
       if (!isExists) {
-        logger.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
+        log.warn('destination is NOT in scheme, and no cached sendToProxiesList', { destination, alsReq })
         // think, if we need to throw an error here
       } else {
         const mappingPayload = {
           fspId: source
         }
+        step = 'oracleRequest-3'
         await oracle.oracleRequest(headers, RestMethods.POST, params, null, mappingPayload, cache)
-        logger.info('oracle was updated with mappingPayload', { mappingPayload, params })
+        log.info('oracle was updated with mappingPayload', { mappingPayload, params })
       }
     }
-
+    step = 'validateParticipant-4'
     const destinationParticipant = await participant.validateParticipant(destination)
     if (!destinationParticipant) {
+      step = 'lookupProxyByDfspId-5'
       const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
       if (!proxyName) {
         const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
@@ -120,12 +127,21 @@ const putPartiesByTypeAndID = async (headers, params, method, payload, dataUri,
       partyIdentifier: params.ID,
       ...(partySubId && { partySubIdOrType: partySubId })
     }
+    step = 'sendRequest-6'
     await participant.sendRequest(headers, sendTo, callbackEndpointType, RestMethods.PUT, decodedPayload.body.toString(), options)
 
-    logger.info('parties::putPartiesByTypeAndID::callback was sent', { sendTo, options })
+    log.info('parties::putPartiesByTypeAndID::callback was sent', { sendTo, options })
     histTimerEnd({ success: true })
   } catch (err) {
-    await handleErrorOnSendingCallback(err, headers, params, sendTo)
+    const fspiopError = await handleErrorOnSendingCallback(err, headers, params, sendTo)
+    const extensions = err.extensions || []
+    const system = extensions.find((element) => element.key === 'system')?.value || ''
+    errorCounter.inc({
+      code: fspiopError?.apiErrorCode?.code,
+      system,
+      operation: 'putPartiesByTypeAndID',
+      step
+    })
     histTimerEnd({ success: false })
   }
 }
@@ -149,6 +165,7 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
     'Put parties error by type and id',
     ['success']
   ).startTimer()
+  const errorCounter = Metrics.getCounter('errorCount')
   const partySubId = params.SubId
   const destination = headers[Headers.FSPIOP.DESTINATION]
   const callbackEndpointType = utils.errorPartyCbType(partySubId)
@@ -158,33 +175,37 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
 
   let sendTo
   let fspiopError
+  let step
 
   try {
     const proxy = proxyEnabled && headers[Headers.FSPIOP.PROXY]
     if (proxy) {
       if (isNotValidPayeeCase(payload)) {
         const swappedHeaders = utils.swapSourceDestinationHeaders(headers)
+        step = 'oracleRequest-1'
         await oracle.oracleRequest(swappedHeaders, RestMethods.DELETE, params, null, null, cache)
         getPartiesByTypeAndID(swappedHeaders, params, RestMethods.GET, {}, span, cache, proxyCache)
         // todo: - think if we need to send errorCallback?
         //       - or sentCallback after getPartiesByTypeAndID is done
-        logger.info('notValidPayee case - deleted Participants and run getPartiesByTypeAndID:', { proxy, params, payload })
+        log.info('notValidPayee case - deleted Participants and run getPartiesByTypeAndID:', { proxy, params, payload })
         return
       }
 
       const alsReq = utils.alsRequestDto(destination, params) // or source?
+      step = 'receivedErrorResponse-2'
       const isLast = await proxyCache.receivedErrorResponse(alsReq, proxy)
       if (!isLast) {
-        logger.info('got NOT last error callback from proxy:', { proxy, alsReq })
+        log.info('got NOT last error callback from proxy:', { proxy, alsReq })
         return
       }
     }
-
+    step = 'validateParticipant-3'
     const destinationParticipant = await participant.validateParticipant(destination)
 
     if (destinationParticipant) {
       sendTo = destination
     } else {
+      step = 'lookupProxyByDfspId-4'
       const proxyName = proxyEnabled && await proxyCache.lookupProxyByDfspId(destination)
       if (!proxyName) {
         const errMessage = ERROR_MESSAGES.partyDestinationFspNotFound
@@ -195,10 +216,18 @@ const putPartiesErrorByTypeAndID = async (headers, params, payload, dataUri, spa
     const decodedPayload = decodePayload(dataUri, { asParsed: false })
     await participant.sendErrorToParticipant(sendTo, callbackEndpointType, decodedPayload.body.toString(), headers, params, childSpan)
 
-    logger.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
+    log.info('putPartiesErrorByTypeAndID callback was sent', { sendTo })
     histTimerEnd({ success: true })
   } catch (err) {
     fspiopError = await handleErrorOnSendingCallback(err, headers, params, sendTo)
+    const extensions = err.extensions || []
+    const system = extensions.find((element) => element.key === 'system')?.value || ''
+    errorCounter.inc({
+      code: fspiopError?.apiErrorCode?.code,
+      system,
+      operation: 'putPartiesErrorByTypeAndID',
+      step
+    })
     histTimerEnd({ success: false })
   } finally {
     await utils.finishSpanWithError(childSpan, fspiopError)

package/src/domain/timeout/index.js

@@ -57,20 +57,31 @@ const sendTimeoutCallback = async (cacheKey) => {
     'Egress - Interscheme parties lookup timeout callback',
     ['success']
   ).startTimer()
-
+  const errorCounter = Metrics.getCounter('errorCount')
+  let step
   const [, destination, partyType, partyId] = cacheKey.split(':')
   const { errorInformation, params, headers, endpointType, span } = await timeoutCallbackDto({ destination, partyId, partyType })
   logger.debug('sendTimeoutCallback details:', { destination, partyType, partyId, cacheKey })
 
   try {
+    step = 'validateParticipant-1'
     await validateParticipant(destination)
     await span.audit({ headers, errorInformation }, AuditEventAction.start)
+    step = 'sendErrorToParticipant-2'
     await Participant.sendErrorToParticipant(destination, endpointType, errorInformation, headers, params, undefined, span)
     histTimerEnd({ success: true })
   } catch (err) {
     logger.warn('error in sendTimeoutCallback: ', err)
     histTimerEnd({ success: false })
     const fspiopError = reformatFSPIOPError(err)
+    const extensions = err.extensions || []
+    const system = extensions.find((element) => element.key === 'system')?.value || ''
+    errorCounter.inc({
+      code: fspiopError?.apiErrorCode?.code,
+      system,
+      operation: 'sendTimeoutCallback',
+      step
+    })
     await finishSpan(span, fspiopError)
     throw fspiopError
   }

package/src/handlers/index.js

@@ -35,7 +35,7 @@ const Package = require('../../package.json')
 const Server = require('../server')
 const { HANDLER_TYPES } = require('../constants')
 const Config = require('../lib/config')
-const logger = require('../lib').loggerFactory('ALS-timeout-handler')
+const log = require('../lib').logger.child('ALS-timeout-handler')
 
 const Program = new Command()
 
@@ -51,16 +51,16 @@ Program.command('handlers')
     const handlers = []
 
     if (args.timeout) {
-      logger.debug('CLI: Executing --timeout')
+      log.debug('CLI: Executing --timeout')
       handlers.push(HANDLER_TYPES.TIMEOUT)
     }
 
     if (handlers.length === 0) {
-      logger.debug('CLI: No handlers specified')
+      log.debug('CLI: No handlers specified')
       return
     }
 
-    module.exports = await Server.initializeHandlers(handlers, Config, logger)
+    module.exports = await Server.initializeHandlers(handlers, Config, log)
   })
 
 if (Array.isArray(process.argv) && process.argv.length > 2) {

package/src/handlers/monitoring/index.js

@@ -18,7 +18,7 @@
 const Hapi = require('@hapi/hapi')
 const Metrics = require('@mojaloop/central-services-metrics')
 const { plugin: HealthPlugin } = require('./plugins/health')
-const { plugin: MetricsPlugin } = require('./plugins/metrics')
+const MetricsPlugin = require('@mojaloop/central-services-metrics').plugin
 const { logger } = require('../../lib')
 
 let server

package/src/interface/api-swagger-iso20022-parties.yaml

@@ -890,13 +890,14 @@ components:
   schemas:
     CorrelationId:
       title: CorrelationId
-      pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
       type: string
-      description: Identifier that correlates all messages of the same sequence. The
-        API data type UUID (Universally Unique Identifier) is a JSON String in canonical
-        format, conforming to RFC 4122, that is restricted by a regular expression
-        for interoperability reasons. An UUID is always 36 characters long, 32 hexadecimal
-        symbols and 4 dashes (‘-‘).
+      pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$|^[0-9A-HJKMNP-TV-Z]{26}$
+      description: >-
+        Identifier that correlates all messages of the same sequence.
+        The supported identifiers formats are for
+        lowercase [UUID](https://datatracker.ietf.org/doc/html/rfc9562) and
+        uppercase [ULID](https://github.com/ulid/spec)
+      example: 'b51ec534-ee48-4575-b6a9-ead2955b8069'
     Currency:
       title: CurrencyEnum
       maxLength: 3

package/src/interface/api-swagger.yaml

@@ -889,13 +889,14 @@ components:
   schemas:
     CorrelationId:
       title: CorrelationId
-      pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
       type: string
-      description: Identifier that correlates all messages of the same sequence. The
-        API data type UUID (Universally Unique Identifier) is a JSON String in canonical
-        format, conforming to RFC 4122, that is restricted by a regular expression
-        for interoperability reasons. An UUID is always 36 characters long, 32 hexadecimal
-        symbols and 4 dashes (‘-‘).
+      pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$|^[0-9A-HJKMNP-TV-Z]{26}$
+      description: >-
+        Identifier that correlates all messages of the same sequence.
+        The supported identifiers formats are for
+        lowercase [UUID](https://datatracker.ietf.org/doc/html/rfc9562) and
+        uppercase [ULID](https://github.com/ulid/spec)
+      example: 'b51ec534-ee48-4575-b6a9-ead2955b8069'
     Currency:
       title: CurrencyEnum
       maxLength: 3

package/src/lib/config.js

@@ -117,6 +117,7 @@ const config = {
       password: RC.DATABASE.PASSWORD,
       database: RC.DATABASE.DATABASE
     },
+    maxPendingAcquire: RC.DATABASE.MAX_PENDING_ACQUIRE,
     pool: {
       // minimum size
       min: getOrDefault(RC.DATABASE.POOL_MIN_SIZE, 2),
@@ -167,7 +168,7 @@ const config = {
   INSTRUMENTATION_METRICS_LABELS: RC.INSTRUMENTATION.METRICS.labels,
   INSTRUMENTATION_METRICS_CONFIG: RC.INSTRUMENTATION.METRICS.config,
   JWS_SIGN: RC.ENDPOINT_SECURITY.JWS.JWS_SIGN,
-  FSPIOP_SOURCE_TO_SIGN: RC.HUB_NAME,
+  FSPIOP_SOURCE_TO_SIGN: RC.HUB_PARTICIPANT.NAME,
   JWS_SIGNING_KEY_PATH: RC.ENDPOINT_SECURITY.JWS.JWS_SIGNING_KEY_PATH,
   API_DOC_ENDPOINTS_ENABLED: RC.API_DOC_ENDPOINTS_ENABLED || false,
   FEATURE_ENABLE_EXTENDED_PARTY_ID_TYPE: RC.FEATURE_ENABLE_EXTENDED_PARTY_ID_TYPE || false,

package/src/lib/db.js

@@ -23,4 +23,5 @@
  ******/
 'use strict'
 
-module.exports = require('@mojaloop/database-lib').Db
+const Database = require('@mojaloop/database-lib/src/database')
+module.exports = new Database()

package/src/models/currency/currency.js

@@ -39,7 +39,16 @@ const getCurrencyById = async (currencyId) => {
   try {
     return Db.from('currency').findOne({ currencyId, isActive: true })
   } catch (err) {
-    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+    const extensions = [{
+      key: 'system',
+      value: '["db"]'
+    }]
+    throw ErrorHandler.Factory.reformatFSPIOPError(
+      err,
+      undefined,
+      undefined,
+      extensions
+    )
   }
 }
 

package/src/models/endpointType/endpointType.js

@@ -39,7 +39,16 @@ const getEndpointTypeByType = async (type) => {
   try {
     return Db.from('endpointType').findOne({ type, isActive: true })
   } catch (err) {
-    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+    const extensions = [{
+      key: 'system',
+      value: '["db"]'
+    }]
+    throw ErrorHandler.Factory.reformatFSPIOPError(
+      err,
+      undefined,
+      undefined,
+      extensions
+    )
   }
 }
 

package/src/models/oracle/facade.js

@@ -47,10 +47,11 @@ const { hubNameRegex } = require('../../lib/util').hubNameConfig
  * @param {object} params - uri parameters of the http request
  * @param {object} query - the query parameter on the uri of the http request
  * @param {object} payload - payload of the request being sent out
+ * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
  * @returns {object} returns the response from the oracle
  */
-exports.oracleRequest = async (headers, method, params = {}, query = {}, payload = undefined, cache) => {
+exports.oracleRequest = async (headers, method, params = {}, query = {}, payload = undefined, cache, assertPendingAcquire) => {
   try {
     let url
     const partyIdType = params.Type
@@ -59,13 +60,13 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
     const partySubIdOrType = (params && params.SubId) ? params.SubId : (query && query.partySubIdOrType) ? query.partySubIdOrType : undefined
     const isGetRequest = method.toUpperCase() === Enums.Http.RestMethods.GET
     if (currency && partySubIdOrType && isGetRequest) {
-      url = await _getOracleEndpointByTypeCurrencyAndSubId(partyIdType, partyIdentifier, currency, partySubIdOrType)
+      url = await _getOracleEndpointByTypeCurrencyAndSubId(partyIdType, partyIdentifier, currency, partySubIdOrType, assertPendingAcquire)
     } else if (currency && isGetRequest) {
-      url = await _getOracleEndpointByTypeAndCurrency(partyIdType, partyIdentifier, currency)
+      url = await _getOracleEndpointByTypeAndCurrency(partyIdType, partyIdentifier, currency, assertPendingAcquire)
     } else if (partySubIdOrType && isGetRequest) {
-      url = await _getOracleEndpointByTypeAndSubId(partyIdType, partyIdentifier, partySubIdOrType)
+      url = await _getOracleEndpointByTypeAndSubId(partyIdType, partyIdentifier, partySubIdOrType, assertPendingAcquire)
     } else {
-      url = await _getOracleEndpointByType(partyIdType, partyIdentifier)
+      url = await _getOracleEndpointByType(partyIdType, partyIdentifier, assertPendingAcquire)
       if (partySubIdOrType) {
         payload = { ...payload, partySubIdOrType }
       }
@@ -123,6 +124,10 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
       throw err
     }
   } catch (err) {
+    const extensions = [{
+      key: 'system',
+      value: '["@hapi/catbox-memory","http"]'
+    }]
     Logger.isErrorEnabled && Logger.error(`error in oracleRequest: ${err?.stack}`)
     // If the error was a 400 from the Oracle, we'll modify the error to generate a response to the
     // initiator of the request.
@@ -131,15 +136,32 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
       err.apiErrorCode.code === ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_COMMUNICATION_ERROR.code
     ) {
       if (err.extensions.some(ext => (ext.key === 'status' && ext.value === Enums.Http.ReturnCodes.BADREQUEST.CODE))) {
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND)
+        throw ErrorHandler.Factory.createFSPIOPError(
+          ErrorHandler.Enums.FSPIOPErrorCodes.PARTY_NOT_FOUND,
+          undefined,
+          undefined,
+          undefined,
+          extensions
+        )
         // Added error 404 to cover a special case of the Mowali implementation
         // which uses mojaloop/als-oracle-pathfinder and currently returns 404
         // and in which case the Mowali implementation expects back `DESTINATION_FSP_ERROR`.
       } else if (err.extensions.some(ext => (ext.key === 'status' && ext.value === Enums.Http.ReturnCodes.NOTFOUND.CODE))) {
-        throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR)
+        throw ErrorHandler.Factory.createFSPIOPError(
+          ErrorHandler.Enums.FSPIOPErrorCodes.DESTINATION_FSP_ERROR,
+          undefined,
+          undefined,
+          undefined,
+          extensions
+        )
       }
     }
-    throw ErrorHandler.Factory.reformatFSPIOPError(err)
+    throw ErrorHandler.Factory.reformatFSPIOPError(
+      err,
+      undefined,
+      undefined,
+      extensions
+    )
   }
 }
 
@@ -151,12 +173,13 @@ exports.oracleRequest = async (headers, method, params = {}, query = {}, payload
  * @param {string} partyIdType - party ID type (e.g MSISDN)
  * @param {string} partyIdentifier - party ID
  * @param {string} currency - currency ID
+ * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
  * @returns {string} returns the endpoint to the oracle
  */
-const _getOracleEndpointByTypeAndCurrency = async (partyIdType, partyIdentifier, currency) => {
+const _getOracleEndpointByTypeAndCurrency = async (partyIdType, partyIdentifier, currency, assertPendingAcquire) => {
   let url
-  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByTypeAndCurrency(partyIdType, currency)
+  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByTypeAndCurrency(partyIdType, currency, assertPendingAcquire)
   if (oracleEndpointModel.length > 0) {
     if (oracleEndpointModel.length > 1) {
       const defautOracle = oracleEndpointModel.filter(oracle => oracle.isDefault).pop()
@@ -186,12 +209,13 @@ const _getOracleEndpointByTypeAndCurrency = async (partyIdType, partyIdentifier,
  *
  * @param {string} partyIdType - party ID type (e.g MSISDN)
  * @param {string} partyIdentifier - party ID
+ * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
  * @returns {string} returns the endpoint to the oracle
  */
-const _getOracleEndpointByType = async (partyIdType, partyIdentifier) => {
+const _getOracleEndpointByType = async (partyIdType, partyIdentifier, assertPendingAcquire) => {
   let url
-  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByType(partyIdType)
+  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByType(partyIdType, assertPendingAcquire)
   if (oracleEndpointModel.length > 0) {
     if (oracleEndpointModel.length > 1) {
       const defaultOracle = oracleEndpointModel.filter(oracle => oracle.isDefault).pop()
@@ -222,12 +246,13 @@ const _getOracleEndpointByType = async (partyIdType, partyIdentifier) => {
  * @param {string} partyIdType - party ID type (e.g MSISDN)
  * @param {string} partyIdentifier - party ID
  * @param {string} partySubIdOrType - party subId
+ * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
  * @returns {string} returns the endpoint to the oracle
  */
-const _getOracleEndpointByTypeAndSubId = async (partyIdType, partyIdentifier, partySubIdOrType) => {
+const _getOracleEndpointByTypeAndSubId = async (partyIdType, partyIdentifier, partySubIdOrType, assertPendingAcquire) => {
   let url
-  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByType(partyIdType)
+  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByType(partyIdType, assertPendingAcquire)
   if (oracleEndpointModel.length > 0) {
     if (oracleEndpointModel.length > 1) {
       const defautOracle = oracleEndpointModel.filter(oracle => oracle.isDefault).pop()
@@ -259,12 +284,13 @@ const _getOracleEndpointByTypeAndSubId = async (partyIdType, partyIdentifier, pa
  * @param {string} partyIdentifier - party ID
  * @param {string} currency - currency ID
  * @param {string} partySubIdOrType - party subId
+ * @param {object} assertPendingAcquire - flag to check DB pool pending acquire limit
  *
  * @returns {string} returns the endpoint to the oracle
  */
-const _getOracleEndpointByTypeCurrencyAndSubId = async (partyIdType, partyIdentifier, currency, partySubIdOrType) => {
+const _getOracleEndpointByTypeCurrencyAndSubId = async (partyIdType, partyIdentifier, currency, partySubIdOrType, assertPendingAcquire) => {
   let url
-  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByTypeAndCurrency(partyIdType, currency)
+  const oracleEndpointModel = await oracleEndpointCached.getOracleEndpointByTypeAndCurrency(partyIdType, currency, assertPendingAcquire)
   if (oracleEndpointModel.length > 0) {
     if (oracleEndpointModel.length > 1) {
       const defautOracle = oracleEndpointModel.filter(oracle => oracle.isDefault).pop()