@mojaloop/central-ledger 9.2.2 → 15.1.3-snapshot.2

package/src/handlers/positions/handler.js

@@ -41,7 +41,9 @@
 const Logger = require('@mojaloop/central-services-logger')
 const EventSdk = require('@mojaloop/event-sdk')
 const TransferService = require('../../domain/transfer')
+const TransferObjectTransform = require('../../domain/transfer/transform')
 const PositionService = require('../../domain/position')
+const SettlementModelCached = require('../../models/settlement/settlementModelCached')
 const Utility = require('@mojaloop/central-services-shared').Util
 const Kafka = require('@mojaloop/central-services-shared').Util.Kafka
 const Producer = require('@mojaloop/central-services-stream').Util.Producer
@@ -74,21 +76,23 @@ const fromSwitch = true
  *
  * @returns {object} - Returns a boolean: true if successful, or throws and error if failed
  */
+
 const positions = async (error, messages) => {
   const histTimerEnd = Metrics.getHistogram(
     'transfer_position',
     'Consume a prepare transfer message from the kafka topic and process it accordingly',
-    ['success', 'fspId']
+    ['success', 'fspId', 'action']
   ).startTimer()
 
   if (error) {
-    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId, action: 'error' })
     throw ErrorHandler.Factory.reformatFSPIOPError(error)
   }
   let message = {}
   let prepareBatch = []
   let contextFromMessage
   let span
+  let action
   try {
     if (Array.isArray(messages)) {
       prepareBatch = Array.from(messages)
@@ -102,87 +106,104 @@ const positions = async (error, messages) => {
     await span.audit(message, EventSdk.AuditEventAction.start)
     const payload = decodePayload(message.value.content.payload)
     const eventType = message.value.metadata.event.type
-    const action = message.value.metadata.event.action
+    action = message.value.metadata.event.action
     const transferId = payload.transferId || (message.value.content.uriParams && message.value.content.uriParams.id)
     if (!transferId) {
       const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError('transferId is null or undefined')
-      Logger.error(fspiopError)
+      Logger.isErrorEnabled && Logger.error(fspiopError)
       throw fspiopError
     }
     const kafkaTopic = message.topic
-    Logger.info(Utility.breadcrumb(location, { method: 'positions' }))
+    Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, { method: 'positions' }))
 
-    const actionLetter = action === Enum.Events.Event.Action.PREPARE ? Enum.Events.ActionLetter.prepare
-      : (action === Enum.Events.Event.Action.COMMIT ? Enum.Events.ActionLetter.commit
-        : (action === Enum.Events.Event.Action.REJECT ? Enum.Events.ActionLetter.reject
-          : (action === Enum.Events.Event.Action.ABORT ? Enum.Events.ActionLetter.abort
-            : (action === Enum.Events.Event.Action.TIMEOUT_RESERVED ? Enum.Events.ActionLetter.timeout
-              : (action === Enum.Events.Event.Action.BULK_PREPARE ? Enum.Events.ActionLetter.bulkPrepare
-                : (action === Enum.Events.Event.Action.BULK_COMMIT ? Enum.Events.ActionLetter.bulkCommit
-                  : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED ? Enum.Events.ActionLetter.bulkTimeoutReserved
-                    : Enum.Events.ActionLetter.unknown)))))))
+    const actionLetter = action === Enum.Events.Event.Action.PREPARE
+      ? Enum.Events.ActionLetter.prepare
+      : (action === Enum.Events.Event.Action.RESERVE
+          ? Enum.Events.ActionLetter.reserve
+          : (action === Enum.Events.Event.Action.COMMIT
+              ? Enum.Events.ActionLetter.commit
+              : (action === Enum.Events.Event.Action.REJECT
+                  ? Enum.Events.ActionLetter.reject
+                  : (action === Enum.Events.Event.Action.ABORT
+                      ? Enum.Events.ActionLetter.abort
+                      : (action === Enum.Events.Event.Action.TIMEOUT_RESERVED
+                          ? Enum.Events.ActionLetter.timeout
+                          : (action === Enum.Events.Event.Action.BULK_PREPARE
+                              ? Enum.Events.ActionLetter.bulkPrepare
+                              : (action === Enum.Events.Event.Action.BULK_COMMIT
+                                  ? Enum.Events.ActionLetter.bulkCommit
+                                  : (action === Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED
+                                      ? Enum.Events.ActionLetter.bulkTimeoutReserved
+                                      : (action === Enum.Events.Event.Action.BULK_ABORT
+                                          ? Enum.Events.ActionLetter.bulkAbort
+                                          : Enum.Events.ActionLetter.unknown)))))))))
     const params = { message, kafkaTopic, decodedPayload: payload, span, consumer: Consumer, producer: Producer }
     const eventDetail = { action }
-    if (![Enum.Events.Event.Action.BULK_PREPARE, Enum.Events.Event.Action.BULK_COMMIT, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED].includes(action)) {
+    if (![Enum.Events.Event.Action.BULK_PREPARE, Enum.Events.Event.Action.BULK_COMMIT, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED, Enum.Events.Event.Action.BULK_ABORT].includes(action)) {
       eventDetail.functionality = Enum.Events.Event.Type.NOTIFICATION
     } else {
       eventDetail.functionality = Enum.Events.Event.Type.BULK_PROCESSING
     }
 
     if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.PREPARE, Enum.Events.Event.Action.BULK_PREPARE].includes(action)) {
-      Logger.info(Utility.breadcrumb(location, { path: 'prepare' }))
+      Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, { path: 'prepare' }))
       const { preparedMessagesList, limitAlarms } = await PositionService.calculatePreparePositionsBatch(decodeMessages(prepareBatch))
       for (const limit of limitAlarms) {
         // Publish alarm message to KafkaTopic for the Hub to consume as it is the Hub
         // rather than the switch to manage this (the topic is an participantEndpoint)
-        Logger.info(`Limit alarm should be sent with ${limit}`)
+        Logger.isInfoEnabled && Logger.info(`Limit alarm should be sent with ${limit}`)
       }
-      for (const prepareMessage of preparedMessagesList) {
-        const { transferState } = prepareMessage
+      if (Array.isArray(preparedMessagesList) && preparedMessagesList.length > 0) {
+        const prepareMessage = preparedMessagesList[0]
+        const { transferState, fspiopError } = prepareMessage
         if (transferState.transferStateId === Enum.Transfers.TransferState.RESERVED) {
-          Logger.info(Utility.breadcrumb(location, `payer--${actionLetter}1`))
+          Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `payer--${actionLetter}1`))
           await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail })
-          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+          histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId, action })
           return true
         } else {
-          Logger.info(Utility.breadcrumb(location, `payerNotifyInsufficientLiquidity--${actionLetter}2`))
-          const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.PAYER_FSP_INSUFFICIENT_LIQUIDITY)
-          const fspiopApiError = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+          Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `payerNotifyInsufficientLiquidity--${actionLetter}2`))
+          const responseFspiopError = fspiopError || ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR)
+          const fspiopApiError = responseFspiopError.toApiErrorObject(Config.ERROR_HANDLING)
           await TransferService.logTransferError(transferId, fspiopApiError.errorInformation.errorCode, fspiopApiError.errorInformation.errorDescription)
           await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopApiError, eventDetail, fromSwitch })
-          throw fspiopError
+          throw responseFspiopError
         }
       }
-    } else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.COMMIT, Enum.Events.Event.Action.BULK_COMMIT].includes(action)) {
-      Logger.info(Utility.breadcrumb(location, { path: 'commit' }))
+    } else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.COMMIT, Enum.Events.Event.Action.RESERVE, Enum.Events.Event.Action.BULK_COMMIT].includes(action)) {
+      Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, { path: 'commit' }))
       const transferInfo = await TransferService.getTransferInfoToChangePosition(transferId, Enum.Accounts.TransferParticipantRoleType.PAYEE_DFSP, Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
       if (transferInfo.transferStateId !== Enum.Transfers.TransferInternalState.RECEIVED_FULFIL) {
-        Logger.info(Utility.breadcrumb(location, `validationFailed::notReceivedFulfilState1--${actionLetter}3`))
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `validationFailed::notReceivedFulfilState1--${actionLetter}3`))
         const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid State: ${transferInfo.transferStateId} - expected: ${Enum.Transfers.TransferInternalState.RECEIVED_FULFIL}`)
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
         throw fspiopError
       } else {
-        Logger.info(Utility.breadcrumb(location, `payee--${actionLetter}4`))
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `payee--${actionLetter}4`))
         const isReversal = false
         const transferStateChange = {
           transferId: transferInfo.transferId,
           transferStateId: Enum.Transfers.TransferState.COMMITTED
         }
         await PositionService.changeParticipantPosition(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange)
+        if (action === Enum.Events.Event.Action.RESERVE) {
+          const transfer = await TransferService.getById(transferInfo.transferId)
+          message.value.content.payload = TransferObjectTransform.toFulfil(transfer)
+        }
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail })
-        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+        histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId, action })
         return true
       }
-    } else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.REJECT, Enum.Events.Event.Action.ABORT].includes(action)) {
-      Logger.info(Utility.breadcrumb(location, { path: action }))
+    } else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.REJECT, Enum.Events.Event.Action.ABORT, Enum.Events.Event.Action.ABORT_VALIDATION, Enum.Events.Event.Action.BULK_ABORT].includes(action)) {
+      Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, { path: action }))
       const transferInfo = await TransferService.getTransferInfoToChangePosition(transferId, Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP, Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
       let transferStateId
 
       if (action === Enum.Events.Event.Action.REJECT) {
-        Logger.info(Utility.breadcrumb(location, `receivedReject--${actionLetter}5`))
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `receivedReject--${actionLetter}5`))
         transferStateId = Enum.Transfers.TransferInternalState.ABORTED_REJECTED
-      } else { // action === Enum.Events.Event.Action.ABORT
-        Logger.info(Utility.breadcrumb(location, `receivedError--${actionLetter}5`))
+      } else { // action === Enum.Events.Event.Action.ABORT || action === Enum.Events.Event.Action.BULK_ABORT
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `receivedError--${actionLetter}5`))
         transferStateId = Enum.Transfers.TransferInternalState.ABORTED_ERROR
       }
       const isReversal = true
@@ -193,17 +214,17 @@ const positions = async (error, messages) => {
       }
       await PositionService.changeParticipantPosition(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange)
       await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, eventDetail })
-      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+      histTimerEnd({ success: true, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId, action })
       return true
     } else if (eventType === Enum.Events.Event.Type.POSITION && [Enum.Events.Event.Action.TIMEOUT_RESERVED, Enum.Events.Event.Action.BULK_TIMEOUT_RESERVED].includes(action)) {
-      Logger.info(Utility.breadcrumb(location, { path: 'timeout' }))
+      Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, { path: 'timeout' }))
       span.setTags({ transactionId: transferId })
       const transferInfo = await TransferService.getTransferInfoToChangePosition(transferId, Enum.Accounts.TransferParticipantRoleType.PAYER_DFSP, Enum.Accounts.LedgerEntryType.PRINCIPLE_VALUE)
       if (transferInfo.transferStateId !== Enum.Transfers.TransferInternalState.RESERVED_TIMEOUT) {
-        Logger.info(Utility.breadcrumb(location, `validationFailed::notReceivedFulfilState2--${actionLetter}6`))
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `validationFailed::notReceivedFulfilState2--${actionLetter}6`))
         throw ErrorHandler.Factory.createInternalServerFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR.message)
       } else {
-        Logger.info(Utility.breadcrumb(location, `validationPassed2--${actionLetter}7`))
+        Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `validationPassed2--${actionLetter}7`))
         const isReversal = true
         const transferStateChange = {
           transferId: transferInfo.transferId,
@@ -211,23 +232,20 @@ const positions = async (error, messages) => {
           reason: ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED.message
         }
         await PositionService.changeParticipantPosition(transferInfo.participantCurrencyId, isReversal, transferInfo.amount, transferStateChange)
-        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.EXPIRED_ERROR, null, null, null, payload.extensionList)
-        if (action === Enum.Events.Event.Action.TIMEOUT_RESERVED) {
-          eventDetail.action = Enum.Events.Event.Action.ABORT
-        }
+        const fspiopError = ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.TRANSFER_EXPIRED, null, null, null, payload.extensionList)
         await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail })
         throw fspiopError
       }
     } else {
-      Logger.info(Utility.breadcrumb(location, `invalidEventTypeOrAction--${actionLetter}8`))
+      Logger.isInfoEnabled && Logger.info(Utility.breadcrumb(location, `invalidEventTypeOrAction--${actionLetter}8`))
       const fspiopError = ErrorHandler.Factory.createInternalServerFSPIOPError(`Invalid event action:(${action}) and/or type:(${eventType})`)
       const eventDetail = { functionality: Enum.Events.Event.Type.NOTIFICATION, action: Enum.Events.Event.Action.POSITION }
       await Kafka.proceed(Config.KAFKA_CONFIG, params, { consumerCommit, fspiopError: fspiopError.toApiErrorObject(Config.ERROR_HANDLING), eventDetail, fromSwitch })
       throw fspiopError
     }
   } catch (err) {
-    Logger.error(`${Utility.breadcrumb(location)}::${err.message}--0`)
-    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId })
+    Logger.isErrorEnabled && Logger.error(`${Utility.breadcrumb(location)}::${err.message}--0`)
+    histTimerEnd({ success: false, fspId: Config.INSTRUMENTATION_METRICS_LABELS.fspId, action })
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
     const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
     await span.error(fspiopError, state)
@@ -250,6 +268,7 @@ const positions = async (error, messages) => {
  */
 const registerPositionHandler = async () => {
   try {
+    await SettlementModelCached.initialize()
     const positionHandler = {
       command: positions,
       topicName: Kafka.transformGeneralTopicName(Config.KAFKA_CONFIG.TOPIC_TEMPLATES.GENERAL_TOPIC_TEMPLATE.TEMPLATE, Enum.Events.Event.Type.POSITION, Enum.Events.Event.Action.PREPARE),
@@ -259,6 +278,7 @@ const registerPositionHandler = async () => {
     await Consumer.createHandler(positionHandler.topicName, positionHandler.config, positionHandler.command)
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -275,6 +295,7 @@ const registerAllHandlers = async () => {
   try {
     return await registerPositionHandler()
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }

package/src/handlers/register.js

@@ -58,23 +58,22 @@ const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const registerAllHandlers = async () => {
   try {
     const modules = await requireGlob(['./**/handler.js'])
-    Logger.info(JSON.stringify(modules))
     for (const key in modules) {
-      Logger.info(`Registering handler module[${key}]: ${JSON.stringify(modules[key])}`)
+      Logger.isInfoEnabled && Logger.info(`Registering handler module[${key}]: ${JSON.stringify(modules[key])}`)
       if (Object.prototype.hasOwnProperty.call(modules[key], 'handler')) {
         const handlerObject = modules[key]
-        Logger.info(JSON.stringify(handlerObject.handler))
         await handlerObject.handler.registerAllHandlers()
       } else {
-        for (const i in modules[key]) {
-          const handlerObject = modules[key][i]
-          Logger.info(JSON.stringify(handlerObject.handler))
+        for (const subKey in modules[key]) {
+          const handlerObject = modules[key][subKey]
+          Logger.isInfoEnabled && Logger.info(` ⌙ Registering sub-handler module[${key}-${subKey}]: ${JSON.stringify(handlerObject)}`)
           await handlerObject.handler.registerAllHandlers()
         }
       }
     }
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -101,6 +100,7 @@ module.exports = {
   bulk: {
     registerBulkPrepareHandler: BulkHandlers.registerBulkPrepareHandler,
     registerBulkFulfilHandler: BulkHandlers.registerBulkFulfilHandler,
-    registerBulkProcessingHandler: BulkHandlers.registerBulkProcessingHandler
+    registerBulkProcessingHandler: BulkHandlers.registerBulkProcessingHandler,
+    registerBulkGetHandler: BulkHandlers.registerGetBulkTransferHandler
   }
 }

package/src/handlers/timeouts/handler.js

@@ -43,7 +43,8 @@ const Producer = require('@mojaloop/central-services-stream').Util.Producer
 const Utility = require('@mojaloop/central-services-shared').Util
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const EventSdk = require('@mojaloop/event-sdk')
-
+const resourceVersions = require('@mojaloop/central-services-shared').Util.resourceVersions
+const Logger = require('@mojaloop/central-services-logger')
 let timeoutJob
 let isRegistered
 
@@ -77,8 +78,8 @@ const timeout = async () => {
       try {
         const state = Utility.StreamingProtocol.createEventState(Enum.Events.EventStatus.FAILURE.status, fspiopError.errorInformation.errorCode, fspiopError.errorInformation.errorDescription)
         const metadata = Utility.StreamingProtocol.createMetadataWithCorrelatedEvent(result[i].transferId, Enum.Kafka.Topics.NOTIFICATION, Enum.Events.Event.Action.TIMEOUT_RECEIVED, state)
-        const headers = Utility.Http.SwitchDefaultHeaders(result[i].payerFsp, Enum.Http.HeaderResources.TRANSFERS, Enum.Http.Headers.FSPIOP.SWITCH.value)
-        const message = Utility.StreamingProtocol.createMessage(result[i].transferId, result[i].payeeFsp, result[i].payerFsp, metadata, headers, fspiopError, { id: result[i].transferId }, 'application/vnd.interoperability.transfers+json;version=1.0')
+        const headers = Utility.Http.SwitchDefaultHeaders(result[i].payerFsp, Enum.Http.HeaderResources.TRANSFERS, Enum.Http.Headers.FSPIOP.SWITCH.value, resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion)
+        const message = Utility.StreamingProtocol.createMessage(result[i].transferId, result[i].payeeFsp, result[i].payerFsp, metadata, headers, fspiopError, { id: result[i].transferId }, `application/vnd.interoperability.${Enum.Http.HeaderResources.TRANSFERS}+json;version=${resourceVersions[Enum.Http.HeaderResources.TRANSFERS].contentVersion}`)
         span.setTags(Utility.EventFramework.getTransferSpanTags({ payload: message.content.payload, headers }, Enum.Events.Event.Type.TRANSFER, Enum.Events.Event.Action.TIMEOUT_RECEIVED))
         await span.audit({
           state,
@@ -111,6 +112,7 @@ const timeout = async () => {
           }
         }
       } catch (err) {
+        Logger.isErrorEnabled && Logger.error(err)
         const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
         const state = new EventSdk.EventStateMetadata(EventSdk.EventStatusType.failed, fspiopError.apiErrorCode.code, fspiopError.apiErrorCode.message)
         await span.error(fspiopError, state)
@@ -129,6 +131,7 @@ const timeout = async () => {
       result
     }
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -175,13 +178,14 @@ const registerTimeoutHandler = async () => {
       cronTime: Config.HANDLERS_TIMEOUT_TIMEXP,
       onTick: timeout,
       start: false,
-      timeZone: Config.HANDLERS_CRON_TIMEZONE
+      timeZone: Config.HANDLERS_TIMEOUT_TIMEZONE
     })
     isRegistered = true
 
     await timeoutJob.start()
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }
@@ -201,6 +205,7 @@ const registerAllHandlers = async () => {
     }
     return true
   } catch (err) {
+    Logger.isErrorEnabled && Logger.error(err)
     throw ErrorHandler.Factory.reformatFSPIOPError(err)
   }
 }