account-lookup-service 15.6.0-iso.2 → 15.6.0-iso.21

package/src/domain/parties/getPartiesByTypeAndID.js

@@ -32,21 +32,22 @@ const oracle = require('../../models/oracle/facade')
 const participant = require('../../models/participantEndpoint/facade')
 const { createCallbackHeaders } = require('../../lib/headers')
 const { ERROR_MESSAGES } = require('../../constants')
-const { loggerFactory } = require('../../lib')
+const { logger } = require('../../lib')
 const Config = require('../../lib/config')
 const utils = require('./utils')
 
 const { FspEndpointTypes, FspEndpointTemplates } = Enum.EndPoints
 const { Headers, RestMethods } = Enum.Http
 
-const logger = loggerFactory('domain:get-parties')
+const log = logger.child('domain:get-parties')
+const handleErrorOnSendingCallback = utils.createErrorHandlerOnSendingCallback(Config, log)
 
 const proxyCacheTtlSec = 40 // todo: make configurable
 
 const validateRequester = async ({ source, proxy, proxyCache }) => {
   const sourceParticipant = await participant.validateParticipant(source)
   if (sourceParticipant) {
-    logger.debug('source is in scheme', { source })
+    log.debug('source is in scheme', { source })
     return source
   }
 
@@ -63,7 +64,7 @@ const validateRequester = async ({ source, proxy, proxyCache }) => {
 
   const isCached = await proxyCache.addDfspIdToProxyMapping(source, proxy)
   // think, what if isCached !== true?
-  logger.info('source is added to proxyMapping cache:', { source, proxy, isCached })
+  log.info('source is added to proxyMapping cache:', { source, proxy, isCached })
   return proxy
 }
 
@@ -86,6 +87,7 @@ 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
@@ -94,11 +96,11 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
   const callbackEndpointType = utils.getPartyCbType(partySubId)
 
   const childSpan = span ? span.getChild('getPartiesByTypeAndID') : undefined
-  logger.info('parties::getPartiesByTypeAndID::begin', { source, proxy, params })
+  log.info('parties::getPartiesByTypeAndID::begin', { source, proxy, params })
 
   let requester
   let fspiopError
-
+  let step
   try {
     requester = await validateRequester({ source, proxy, proxyCache })
 
@@ -113,8 +115,10 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     // 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) {
@@ -124,13 +128,15 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
         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 })
-      logger.info('discovery getPartiesByTypeAndID request was sent to destination', { destination })
+      log.info('discovery getPartiesByTypeAndID request was sent to destination', { destination })
       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:
@@ -158,35 +164,39 @@ 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++
-          logger.debug('participant is in scheme', { fspId })
+          log.debug('participant is in scheme', { fspId })
           return participant.sendRequest(clonedHeaders, party.fspId, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
         }
 
         // 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) {
-            logger.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
+            log.warn('no proxyMapping for participant!  TODO: Delete reference in oracle...', { fspId })
             // todo: delete reference in oracle
           } else {
             sentCount++
-            logger.debug('participant NOT is in scheme, use proxy name', { fspId, proxyName })
+            log.debug('participant NOT is in scheme, use proxy name', { fspId, proxyName })
             return participant.sendRequest(clonedHeaders, proxyName, callbackEndpointType, RestMethods.GET, undefined, options, childSpan)
           }
         }
       })
+      step = 'sendRequests-7'
       await Promise.all(sending)
-      logger.info('participant.sendRequests to filtered oracle partyList are done', { sentCount })
+      log.info('participant.sendRequests to filtered oracle partyList are done', { sentCount })
       // todo: think what if sentCount === 0 here
     } else {
-      logger.info('empty partyList form oracle, getting proxies list...', { proxyEnabled, params })
+      log.info('empty partyList form oracle, getting proxies list...', { proxyEnabled, params })
       let filteredProxyNames = []
 
       if (proxyEnabled) {
+        step = 'getAllProxiesNames-8'
         const proxyNames = await Util.proxies.getAllProxiesNames(Config.SWITCH_ENDPOINT)
         filteredProxyNames = proxyNames.filter(name => name !== proxy)
       }
@@ -202,16 +212,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)
-        logger.info('starting setSendToProxiesList flow: ', { filteredProxyNames, alsReq, proxyCacheTtlSec })
+        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 }))
@@ -221,7 +234,7 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
         // If, at least, one request is sent to proxy, we treat the whole flow as successful.
         // Failed requests should be handled by TTL expired/timeout handler
         // todo: - think, if we should handle failed requests here (e.g., by calling receivedErrorResponse)
-        logger.info('setSendToProxiesList flow is done:', { isOk, results, filteredProxyNames, alsReq })
+        log.info('setSendToProxiesList flow is done:', { isOk, results, filteredProxyNames, alsReq })
         if (!isOk) {
           throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.ID_NOT_FOUND, ERROR_MESSAGES.proxyConnectionError)
         }
@@ -229,8 +242,16 @@ const getPartiesByTypeAndID = async (headers, params, method, query, span, cache
     }
     histTimerEnd({ success: true })
   } catch (err) {
-    fspiopError = await utils.handleErrorOnSendingCallback(err, headers, params, requester)
+    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,
+      system,
+      operation: 'getPartiesByTypeAndID',
+      step
+    })
   } finally {
     await utils.finishSpanWithError(childSpan, fspiopError)
   }

package/src/domain/parties/parties.js

@@ -38,12 +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 log = logger.child('domain:put-parties')
+const handleErrorOnSendingCallback = utils.createErrorHandlerOnSendingCallback(Config, log)
 
 /**
  * @function putPartiesByTypeAndID
@@ -64,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
@@ -119,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 utils.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,
+      system,
+      operation: 'putPartiesByTypeAndID',
+      step
+    })
     histTimerEnd({ success: false })
   }
 }
@@ -148,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)
@@ -157,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
@@ -194,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 utils.handleErrorOnSendingCallback(err, headers, params, sendTo)
+    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,
+      system,
+      operation: 'putPartiesErrorByTypeAndID',
+      step
+    })
     histTimerEnd({ success: false })
   } finally {
     await utils.finishSpanWithError(childSpan, fspiopError)

package/src/domain/parties/utils.js

@@ -1,10 +1,9 @@
-const { Enum } = require('@mojaloop/central-services-shared')
+const { Enum, Util: { Hapi } } = require('@mojaloop/central-services-shared')
 const EventSdk = require('@mojaloop/event-sdk')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 
 const participant = require('../../models/participantEndpoint/facade')
-const Config = require('../../lib/config')
-const { logger } = require('../../lib')
+const { TransformFacades } = require('../../lib')
 
 const { FspEndpointTypes } = Enum.EndPoints
 const { Headers } = Enum.Http
@@ -33,6 +32,13 @@ const finishSpanWithError = async (childSpan, fspiopError) => {
   }
 }
 
+const makePutPartiesErrorPayload = async (config, fspiopError, headers, params) => {
+  const body = fspiopError.toApiErrorObject(config.ERROR_HANDLING)
+  return config.API_TYPE === Hapi.API_TYPES.iso20022
+    ? (await TransformFacades.FSPIOP.parties.putError({ body, headers, params })).body
+    : body
+}
+
 const alsRequestDto = (sourceId, params) => ({
   sourceId,
   type: params.Type,
@@ -54,13 +60,13 @@ const swapSourceDestinationHeaders = (headers) => {
 }
 
 // change signature to accept object
-const handleErrorOnSendingCallback = async (err, headers, params, requester) => {
+const createErrorHandlerOnSendingCallback = (config, logger) => async (err, headers, params, requester) => {
   try {
     logger.error('error in sending parties callback', err)
     const sendTo = requester || headers[Headers.FSPIOP.SOURCE]
     const errorCallbackEndpointType = errorPartyCbType(params.SubId)
     const fspiopError = ErrorHandler.Factory.reformatFSPIOPError(err)
-    const errInfo = fspiopError.toApiErrorObject(Config.ERROR_HANDLING)
+    const errInfo = await makePutPartiesErrorPayload(config, fspiopError, headers, params)
 
     await participant.sendErrorToParticipant(sendTo, errorCallbackEndpointType, errInfo, headers, params)
 
@@ -77,8 +83,9 @@ module.exports = {
   getPartyCbType,
   putPartyCbType,
   errorPartyCbType,
+  makePutPartiesErrorPayload,
   finishSpanWithError,
-  handleErrorOnSendingCallback,
+  createErrorHandlerOnSendingCallback,
   alsRequestDto,
   swapSourceDestinationHeaders
 }

package/src/domain/timeout/dto.js

@@ -8,18 +8,10 @@ const {
   EndPoints: { FspEndpointTypes }
 } = require('@mojaloop/central-services-shared').Enum
 const { Tracer } = require('@mojaloop/event-sdk')
-const { API_TYPES } = require('@mojaloop/central-services-shared').Util.Hapi
 
-const { TransformFacades } = require('../../lib')
 const LibUtil = require('../../lib/util')
 const Config = require('../../lib/config')
-
-const makeErrorPayload = async (headers, params) => {
-  const body = createFSPIOPError(FSPIOPErrorCodes.EXPIRED_ERROR).toApiErrorObject(Config.ERROR_HANDLING)
-  return Config.API_TYPE === API_TYPES.iso20022
-    ? (await TransformFacades.FSPIOP.parties.putError({ body, headers, params })).body
-    : body
-}
+const partiesUtils = require('../parties/utils')
 
 const timeoutCallbackDto = async ({ destination, partyId, partyType }) => {
   const headers = {
@@ -30,8 +22,10 @@ const timeoutCallbackDto = async ({ destination, partyId, partyType }) => {
     ID: partyId,
     Type: partyType
   }
+  const error = createFSPIOPError(FSPIOPErrorCodes.EXPIRED_ERROR)
+
   const dto = {
-    errorInformation: await makeErrorPayload(headers, params),
+    errorInformation: await partiesUtils.makePutPartiesErrorPayload(Config, error, headers, params),
     headers,
     params,
     endpointType: FspEndpointTypes.FSPIOP_CALLBACK_URL_PARTIES_PUT_ERROR

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,
+      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