@mojaloop/sdk-scheme-adapter 24.1.0 → 24.1.2

package/CHANGELOG.md

@@ -1,4 +1,18 @@
 # Changelog: [mojaloop/sdk-scheme-adapter](https://github.com/mojaloop/sdk-scheme-adapter)
+### [24.1.2](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.1.1...v24.1.2) (2025-02-25)
+
+
+### Chore
+
+* fixed logLevel ([#547](https://github.com/mojaloop/sdk-scheme-adapter/issues/547)) ([f88a464](https://github.com/mojaloop/sdk-scheme-adapter/commit/f88a4642cad323dca80bbfd57a590b8c8bae9d87))
+
+### [24.1.1](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.1.0...v24.1.1) (2025-02-25)
+
+
+### Chore
+
+* **csi-1237:** improved logging ([#546](https://github.com/mojaloop/sdk-scheme-adapter/issues/546)) ([41af8db](https://github.com/mojaloop/sdk-scheme-adapter/commit/41af8dbc23412514a241c635888920ff27edfa6e))
+
 ## [24.1.0](https://github.com/mojaloop/sdk-scheme-adapter/compare/v24.0.8...v24.1.0) (2025-02-21)
 
 

package/modules/api-svc/package.json

@@ -68,12 +68,12 @@
     "@mojaloop/central-services-error-handling": "^13.0.6",
     "@mojaloop/central-services-logger": "^11.5.5",
     "@mojaloop/central-services-metrics": "^12.4.5",
-    "@mojaloop/central-services-shared": "^18.18.1",
-    "@mojaloop/event-sdk": "^14.1.4",
+    "@mojaloop/central-services-shared": "^18.19.0",
+    "@mojaloop/event-sdk": "^14.1.5",
     "@mojaloop/logging-bc-client-lib": "0.5.8",
-    "@mojaloop/ml-schema-transformer-lib": "^2.5.3",
+    "@mojaloop/ml-schema-transformer-lib": "^2.5.4",
     "@mojaloop/sdk-scheme-adapter-private-shared-lib": "workspace:^",
-    "@mojaloop/sdk-standard-components": "19.6.6",
+    "@mojaloop/sdk-standard-components": "19.7.0",
     "ajv": "8.17.1",
     "axios": "^1.7.9",
     "body-parser": "^1.20.3",

package/modules/api-svc/src/OutboundServer/handlers.js

@@ -29,7 +29,6 @@
  ******/
 'use strict';
 
-const safeStringify = require('fast-safe-stringify');
 const {
     AccountsModel,
     OutboundTransfersModel,
@@ -54,7 +53,7 @@ const { ReturnCodes } = Enum.Http;
  * Error handling logic shared by outbound API handlers
  */
 const handleError = (method, err, ctx, stateField) => {
-    ctx.state.logger.isErrorEnabled && ctx.state.logger.error(`Error handling ${method}: ${safeStringify(err)}`);
+    ctx.state.logger.push({ err, stateField }).error(`Error handling ${method}`);
     ctx.response.status = err.httpStatusCode || ReturnCodes.INTERNALSERVERERRROR.CODE;
     ctx.response.body = {
         message: err.message || 'Unspecified error',
@@ -72,6 +71,7 @@ const handleError = (method, err, ctx, stateField) => {
         // the structure of the response object in depth to ascertain an underlying mojaloop API error code.
         const errorInformation = err[stateField].lastError.mojaloopError.errorInformation;
         ctx.response.body.statusCode = errorInformation.errorCode;
+        ctx.state.logger.warn('errorInformation - ', errorInformation);
 
         // if we have been configured to use an error extensionList item as status code, look for it and use
         // it if it is present...
@@ -125,13 +125,21 @@ const handleRequestSimpleTransfersInformationError = (method, err, ctx) =>
 
 const createOutboundTransfersModel = (ctx) => new OutboundTransfersModel({
     ...ctx.state.conf,
-    ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
+    ...(ctx.state.path?.params?.dfspId && { dfspId: ctx.state.path.params.dfspId }),
     cache: ctx.state.cache,
     logger: ctx.state.logger,
     wso2: ctx.state.wso2,
     metricsClient: ctx.state.metricsClient,
 });
 
+const createOutboundBulkTransfersModel = (ctx) => new OutboundBulkTransfersModel({
+    ...ctx.state.conf,
+    ...(ctx.state.path?.params?.dfspId && { dfspId: ctx.state.path.params.dfspId }),
+    cache: ctx.state.cache,
+    logger: ctx.state.logger,
+    wso2: ctx.state.wso2,
+});
+
 /**
  * Handler for outbound transfer request initiation
  */
@@ -222,13 +230,7 @@ const postBulkTransfers = async (ctx) => {
         };
 
         // use the bulk transfers model to execute asynchronous stages with the switch
-        const model = new OutboundBulkTransfersModel({
-            ...ctx.state.conf,
-            ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
-            cache: ctx.state.cache,
-            logger: ctx.state.logger,
-            wso2: ctx.state.wso2,
-        });
+        const model = createOutboundBulkTransfersModel(ctx);
 
         await model.initialize(bulkTransferRequest);
         const response = await model.run();
@@ -254,13 +256,7 @@ const getBulkTransfers = async (ctx) => {
         };
 
         // use the bulk transfers model to execute asynchronous stages with the switch
-        const model = new OutboundBulkTransfersModel({
-            ...ctx.state.conf,
-            ...ctx.state.path?.params?.dfspId && {dfspId: ctx.state.path.params.dfspId},
-            cache: ctx.state.cache,
-            logger: ctx.state.logger,
-            wso2: ctx.state.wso2,
-        });
+        const model = createOutboundBulkTransfersModel(ctx);
 
         await model.initialize(bulkTransferRequest);
         const response = await model.getBulkTransfer();

package/modules/api-svc/src/config.js

@@ -26,10 +26,11 @@
  ******/
 'use strict';
 
-const fs = require('fs');
 require('dotenv').config();
+const fs = require('node:fs');
 const yaml = require('js-yaml');
 const { from } = require('env-var');
+const { Logger } = require('@mojaloop/sdk-standard-components').Logger;
 const { API_TYPES, RESOURCE_VERSIONS_STRING } = require('./constants');
 
 function getFileContent (path) {
@@ -88,7 +89,7 @@ module.exports = {
         mgmtAPIWsPort: env.get('MGMT_API_WS_PORT').default('4005').asPortNumber()
     },
     idGenerator: env.get('ID_GENERATOR').default('{"type":"ulid"}').asJsonObject(),
-    logLevel: env.get('LOG_LEVEL').default('info').asEnum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']),
+    logLevel: env.get('LOG_LEVEL').default('info').asEnum(Logger.logLevels),
     inbound: {
         port: env.get('INBOUND_LISTEN_PORT').default('4000').asPortNumber(),
         tls: {

package/modules/api-svc/src/constants.js

@@ -38,11 +38,8 @@ const API_TYPES = Object.freeze({
     iso20022: 'iso20022',
 });
 
-const SDK_LOGGER_HIERARCHY = ['verbose', 'trace', 'debug', 'info', 'warn', 'error', 'fatal'];
-
 module.exports = {
     API_TYPES,
     ISO_20022_HEADER_PART,
     RESOURCE_VERSIONS_STRING,
-    SDK_LOGGER_HIERARCHY,
 };

package/modules/api-svc/src/index.js

@@ -26,10 +26,8 @@
  ******/
 'use strict';
 
-const { hostname } = require('os');
-const EventEmitter = require('events');
+const EventEmitter = require('node:events');
 const _ = require('lodash');
-const { Logger } = require('@mojaloop/sdk-standard-components');
 const { name, version } = require('../../../package.json');
 
 const config = require('./config');
@@ -50,8 +48,7 @@ const Router = require('./lib/router');
 const Validate = require('./lib/validate');
 const Cache = require('./lib/cache');
 const { SDKStateEnum } = require('./lib/model/common');
-const { createAuthClient } = require('./lib/utils');
-const { SDK_LOGGER_HIERARCHY } = require('./constants');
+const { createAuthClient, createLogger } = require('./lib/utils');
 
 const LOG_ID = {
     INBOUND:   { app: 'mojaloop-connector-inbound-api' },
@@ -65,19 +62,6 @@ const LOG_ID = {
     CACHE:     { component: 'cache' },
 };
 
-const createLogger = (conf) => new Logger.Logger({
-    context: {
-        // If we're running from a Mojaloop helm chart deployment, we'll have a SIM_NAME
-        simulator: process.env['SIM_NAME'],
-        hostname: hostname(),
-    },
-    opts: {
-        levels: SDK_LOGGER_HIERARCHY.slice(SDK_LOGGER_HIERARCHY.indexOf(conf.logLevel)),
-        isJsonOutput: conf.isJsonOutput,
-    },
-    stringify: Logger.buildStringify({ isJsonOutput: conf.isJsonOutput }),
-});
-
 const createCache = (config, logger) => new Cache({
     cacheUrl: config.cacheUrl,
     logger: logger.push(LOG_ID.CACHE),
@@ -376,9 +360,9 @@ class Server extends EventEmitter {
 async function _GetUpdatedConfigFromMgmtAPI(conf, logger, client) {
     logger.isInfoEnabled && logger.info(`Getting updated config from Management API at ${conf.control.mgmtAPIWsUrl}:${conf.control.mgmtAPIWsPort}...`);
     const clientSendResponse = await client.send(ControlAgent.build.CONFIGURATION.READ());
-    logger.isInfoEnabled && logger.info('client send returned:: ', clientSendResponse);
+    logger.isDebugEnabled && logger.debug('client send returned:: ', clientSendResponse);
     const responseRead = await client.receive();
-    logger.isInfoEnabled && logger.info('client receive returned:: ', responseRead);
+    logger.isDebugEnabled && logger.debug('client receive returned:: ', responseRead);
     return responseRead.data;
 }
 
@@ -387,16 +371,17 @@ async function start(config) {
 
     if (config.pm4mlEnabled) {
         const controlClient = await ControlAgent.Client.Create({
+            appConfig: config,
             address: config.control.mgmtAPIWsUrl,
             port: config.control.mgmtAPIWsPort,
-            logger: logger,
-            appConfig: config,
+            logger,
         });
         const updatedConfigFromMgmtAPI = await _GetUpdatedConfigFromMgmtAPI(config, logger, controlClient);
-        logger.isInfoEnabled && logger.push({ updatedConfigFromMgmtAPI }).info('updatedConfigFromMgmtAPI:');
+        logger.isInfoEnabled && logger.push({ updatedConfigFromMgmtAPIKeys: Object.keys(updatedConfigFromMgmtAPI) }).info('updatedConfigFromMgmtAPI keys:');
         _.merge(config, updatedConfigFromMgmtAPI);
         controlClient.terminate();
     }
+
     const svr = new Server(config, logger);
     svr.on('error', (err) => {
         logger.push({ err }).error('Unhandled server error');
@@ -405,7 +390,7 @@ async function start(config) {
 
     // handle SIGTERM to exit gracefully
     process.on('SIGTERM', async () => {
-        logger.isInfoEnabled && logger.info('SIGTERM received. Shutting down APIs...');
+        logger.info('SIGTERM received. Shutting down SDK...');
         await svr.stop();
         process.exit(0);
     });
@@ -415,7 +400,7 @@ async function start(config) {
         process.exit(1);
     });
 
-    logger.isInfoEnabled && logger.push({ name, version }).info('SDK server is started!');
+    logger.push({ name, version }).info('SDK server is started!');
 }
 
 if (require.main === module) {

package/modules/api-svc/src/lib/model/InboundTransfersModel.js

@@ -122,11 +122,10 @@ class InboundTransfersModel {
             return this._mojaloopRequests.putAuthorizations(transactionRequestId, mlAuthorization, sourceFspId);
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getOTP');
+            this._logger.isErrorEnabled && this._logger.push({ err, transactionRequestId }).error('Error in getOTP');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
-            return this._mojaloopRequests.putAuthorizationsError(transactionRequestId,
-                mojaloopError, sourceFspId);
+            return this._mojaloopRequests.putAuthorizationsError(transactionRequestId, mojaloopError, sourceFspId);
         }
     }
 
@@ -148,7 +147,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getParticipants');
+            this._logger.isErrorEnabled && this._logger.push({ err, idValue }).error('Error in getParticipants');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putParticipantsError(idType, idValue, idSubValue,
@@ -189,7 +188,7 @@ class InboundTransfersModel {
 
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getParties');
+            this._logger.isErrorEnabled && this._logger.push({ err, idValue }).error('Error in getParties');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putPartiesError(idType, idValue, idSubValue,
@@ -318,7 +317,7 @@ class InboundTransfersModel {
             await this._backendRequests.putRequestToPayNotification(internalForm, transactionRequestId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in putTransactionRequest');
+            this._logger.push({ err, transactionRequestId }).error('Error in putTransactionRequest');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return await this._mojaloopRequests.putQuotesError(transactionRequestId,
@@ -339,19 +338,17 @@ class InboundTransfersModel {
             if (!quoteResponse) {
                 const err = new Error('Quote Id not found');
                 const mojaloopError = await this._handleError(err, Errors.MojaloopApiErrorCodes.QUOTE_ID_NOT_FOUND);
-                this._logger.push({ mojaloopError }).error(`Sending error response to ${sourceFspId}`);
-                return await this._mojaloopRequests.putQuotesError(quoteId,
-                    mojaloopError, sourceFspId);
+                this._logger.push({ mojaloopError, quoteId }).warn(`Sending error response to ${sourceFspId}`);
+                return await this._mojaloopRequests.putQuotesError(quoteId, mojaloopError, sourceFspId);
             }
             // Make a PUT /quotes/{ID} callback to the source fsp with the quote response
             return this._mojaloopRequests.putQuotes(quoteId, quoteResponse, sourceFspId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in getQuoteRequest');
+            this._logger.push({ err, quoteId }).error('Error in getQuoteRequest');
             const mojaloopError = await this._handleError(err);
-            this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
-            return await this._mojaloopRequests.putQuotesError(quoteId,
-                mojaloopError, sourceFspId);
+            this._logger.isVerboseEnabled && this._logger.push({ mojaloopError }).verbose(`Sending error response to ${sourceFspId}`);
+            return await this._mojaloopRequests.putQuotesError(quoteId, mojaloopError, sourceFspId);
         }
     }
 
@@ -378,7 +375,7 @@ class InboundTransfersModel {
             return this._mojaloopRequests.putTransactionRequests(transactionRequest.transactionRequestId, mojaloopResponse, sourceFspId);
         }
         catch(err) {
-            this._logger.push({ err }).error('Error in transactionRequest');
+            this._logger.push({ err }).error(`Error in transactionRequest ${transactionRequest?.transactionRequestId}`);
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putTransactionRequestsError(transactionRequest.transactionRequestId,
@@ -491,7 +488,7 @@ class InboundTransfersModel {
             await this._save();
             return res;
         } catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in prepareTransfer');
+            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error in prepareTransfer: ${request?.body?.transferId}`);
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return await this._mojaloopRequests.putTransfersError(prepareRequest.transferId,
@@ -548,7 +545,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getTransfers');
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error in getTransfers');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putTransfersError(transferId,
@@ -773,7 +770,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getBulkQuote');
+            this._logger.isErrorEnabled && this._logger.push({ err, bulkQuoteId }).error('Error in getBulkQuote');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putBulkQuotesError(bulkQuoteId,
@@ -951,7 +948,7 @@ class InboundTransfersModel {
                 sourceFspId);
         }
         catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error in getBulkTransfer');
+            this._logger.isErrorEnabled && this._logger.push({ err, bulkTransferId }).error('Error in getBulkTransfer');
             const mojaloopError = await this._handleError(err);
             this._logger.isDebugEnabled && this._logger.push({ mojaloopError }).debug(`Sending error response to ${sourceFspId}`);
             return this._mojaloopRequests.putBulkTransfersError(bulkTransferId,
@@ -983,7 +980,7 @@ class InboundTransfersModel {
             const res = await this._backendRequests.patchFxTransfersNotification(this.data,conversionId);
             return res;
         } catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error notifying backend of final conversionId state equal to: ${body.conversionState} `);
+            this._logger.isErrorEnabled && this._logger.push({ err, conversionId }).error(`Error notifying backend of final conversionId state equal to: ${body.conversionState} `);
         }
     }
     /**
@@ -1022,7 +1019,7 @@ class InboundTransfersModel {
             const res = await this._backendRequests.putTransfersNotification(this.data, transferId);
             return res;
         } catch (err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error(`Error notifying backend of final transfer state equal to: ${body.transferState}`);
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error(`Error notifying backend of final transfer state equal to: ${body.transferState}`);
         }
     }
 
@@ -1097,7 +1094,7 @@ class InboundTransfersModel {
             return data;
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.push({ err }).error('Error loading transfer model');
+            this._logger.isErrorEnabled && this._logger.push({ err, transferId }).error('Error loading transfer model');
             throw err;
         }
     }
@@ -1105,13 +1102,13 @@ class InboundTransfersModel {
     async saveFxState() { // fxQuote + fxTransfer
         const key = this.makeFxQuoteCacheKey(this.data?.conversionId);
         const res = await this._cache.set(key, this.data, this._cacheTtl);
-        this._logger.push({ key, res }).log('fxState is saved in cache');
+        this._logger.push({ key, res }).debug('fxState is saved in cache');
     }
 
     async loadFxState(conversionId) {
         const key = this.makeFxQuoteCacheKey(conversionId);
         const data = await this._cache.get(key);
-        this._logger.push({ key, data }).log('fxState is loaded from cache');
+        this._logger.push({ key, data }).debug('fxState is loaded from cache');
         return data;
     }
 

package/modules/api-svc/src/lib/model/OutboundBulkQuotesModel.js

@@ -455,43 +455,44 @@ class OutboundBulkQuotesModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const log = this._logger.push({ bulkQuoteId: this.data.bulkQuoteId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     await this.stateMachine.requestBulkQuote();
-                    this._logger.isDebugEnabled && this._logger.debug(`Quotes resolved for bulk quote ${this.data.bulkQuoteId}`);
+                    log.isInfoEnabled && log.info('Quotes resolved for bulk quote');
                     break;
 
                 case 'getBulkQuote':
                     await this.stateMachine.getBulkQuote();
-                    this._logger.isDebugEnabled && this._logger.debug(`Get bulk quote ${this.data.bulkQuoteId} has been completed`);
+                    log.isInfoEnabled && log.info('Get bulk quote has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Bulk quoting completed successfully');
+                    log.isInfoEnabled && log.info('Bulk quoting completed successfully');
                     await this._save();
                     return this.getResponse();
 
                 case 'errored':
                     // stopped in errored state
-                    this._logger.isErrorEnabled && this._logger.error('State machine in errored state');
+                    log.isWarnEnabled && log.warn('State machine in errored state');
                     return;
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Bulk quote model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`Bulk quote model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running bulk quote model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.push({ err }).error(`Error running bulk quote model: ${err?.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a bulkQuoteState property here!
                 if(err.bulkQuoteState) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

package/modules/api-svc/src/lib/model/OutboundBulkTransfersModel.js

@@ -448,43 +448,44 @@ class OutboundBulkTransfersModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const log = this._logger.push({ bulkTransferId: this.data.bulkTransferId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     await this.stateMachine.executeBulkTransfer();
-                    this._logger.isDebugEnabled && this._logger.debug(`Bulk transfer ${this.data.bulkTransferId} has been completed`);
+                    log.isInfoEnabled && log.info('Bulk transfer has been started');
                     break;
 
                 case 'getBulkTransfer':
                     await this.stateMachine.getBulkTransfer();
-                    this._logger.isDebugEnabled && this._logger.debug(`Get bulk transfer ${this.data.bulkTransferId} has been completed`);
+                    log.isInfoEnabled && log.info('Get bulk transfer has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Bulk transfer completed successfully');
+                    log.isInfoEnabled && log.info('Bulk transfer completed successfully');
                     await this._save();
                     return this.getResponse();
 
                 case 'errored':
                     // stopped in errored state
-                    this._logger.isErrorEnabled && this._logger.error('State machine in errored state');
+                    log.isWarnEnabled && log.warn('State machine in errored state');
                     return;
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Bulk transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`Bulk transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running transfer model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.push({ err }).error(`Error running bulk transfer model: ${err.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a bulkTransferState property here!
                 if(err.bulkTransferState) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);

package/modules/api-svc/src/lib/model/OutboundRequestToPayModel.js

@@ -426,16 +426,19 @@ class OutboundRequestToPayModel {
      * Returns a promise that resolves when the state machine has reached a terminal state
      */
     async run() {
+        const { transferId, transactionRequestId } = this.data;
+        const log = this._logger.push({ transferId, transactionRequestId });
         try {
             // run transitions based on incoming state
             switch(this.data.currentState) {
                 case 'start':
                     // next transition is to resolvePayee
                     await this.stateMachine.resolvePayee();
-                    this._logger.isDebugEnabled && this._logger.debug(`Payee resolved for transfer ${this.data.transferId}`);
+                    log.isInfoEnabled && log.info('Payee resolved for RequestToPay transfer');
                     if(this.stateMachine.state === 'payeeResolved' && !this._autoAcceptR2PParty) {
                         //we break execution here and return the resolved party details to allow asynchronous accept or reject
                         //of the resolved party
+                        log.isInfoEnabled && log.info('Waiting for asynchronous accept or reject of resolved party');
                         await this._save();
                         return this.getResponse();
                     }
@@ -444,12 +447,12 @@ class OutboundRequestToPayModel {
                 case 'payeeResolved':
                     // next transition is to requestQuote
                     await this.stateMachine.executeTransactionRequest();
-                    this._logger.isDebugEnabled && this._logger.debug(`Transaction Request for ${this.data.transactionRequestId} has been completed`);
+                    log.isInfoEnabled && log.info('Transaction Request has been completed');
                     break;
 
                 case 'succeeded':
                     // all steps complete so return
-                    this._logger.isDebugEnabled && this._logger.debug('Transaction Request completed successfully');
+                    log.isInfoEnabled && log.info('Transaction Request completed successfully');
                     await this._save();
                     return this.getResponse();
 
@@ -460,17 +463,17 @@ class OutboundRequestToPayModel {
             }
 
             // now call ourselves recursively to deal with the next transition
-            this._logger.isDebugEnabled && this._logger.debug(`Transfer model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
+            log.isVerboseEnabled && log.verbose(`RequestToPay model state machine transition completed in state: ${this.stateMachine.state}. Recursing to handle next transition.`);
             return this.run();
         }
         catch(err) {
-            this._logger.isErrorEnabled && this._logger.error(`Error running transfer model: ${safeStringify(err)}`);
+            log.isErrorEnabled && log.error(`Error running RequestToPay model: ${err?.message}`);
 
             // as this function is recursive, we dont want to error the state machine multiple times
             if(this.data.currentState !== 'errored') {
                 // err should not have a lastError property here!
                 if(err.lastError) {
-                    this._logger.isErrorEnabled && this._logger.error(`State machine is broken: ${safeStringify(err)}`);
+                    log.isWarnEnabled && log.warn('State machine is broken');
                 }
                 // transition to errored state
                 await this.stateMachine.error(err);