@mojaloop/central-services-shared 18.35.3 → 18.36.0-infitx.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojaloop/central-services-shared",
-  "version": "18.35.3",
+  "version": "18.36.0-infitx.1",
   "description": "Shared code for mojaloop central services",
   "license": "Apache-2.0",
   "author": "ModusBox",
@@ -48,6 +48,7 @@
     "test:endpoints": "npx tape 'test/unit/util/endpoints.test.js'",
     "test:mysql": "npx tape 'test/unit/mysql/**/*.test.js'",
     "test:participants": "npx tape 'test/unit/util/participants.test.js'",
+    "test:request": "npx tape 'test/unit/util/request.test.js'",
     "test:trans": "npx tape 'test/unit/util/headers/transformer.test.js'",
     "test:unit": "npx tape 'test/unit/**/*.test.js' | tap-spec",
     "test:xunit": "npx tape 'test/unit/**/**.test.js' | tap-xunit > ./test/results/xunit.xml",
@@ -71,12 +72,13 @@
     "@hapi/joi-date": "2.0.1",
     "@mojaloop/inter-scheme-proxy-cache-lib": "2.9.0",
     "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/semantic-conventions": "1.39.0",
     "async-exit-hook": "2.0.1",
     "async-retry": "1.3.3",
-    "axios": "1.13.4",
+    "axios": "1.13.5",
     "clone": "2.1.2",
     "convict": "^6.2.4",
-    "dotenv": "17.2.3",
+    "dotenv": "17.3.1",
     "env-var": "7.5.0",
     "event-stream": "4.0.1",
     "fast-safe-stringify": "2.1.1",
@@ -96,14 +98,14 @@
     "yaml": "2.8.2"
   },
   "devDependencies": {
-    "@mojaloop/central-services-error-handling": "13.1.5",
-    "@mojaloop/central-services-logger": "11.10.3",
-    "@mojaloop/central-services-metrics": "12.8.3",
+    "@mojaloop/central-services-error-handling": "13.1.6",
+    "@mojaloop/central-services-logger": "11.11.0-infitx.0",
+    "@mojaloop/central-services-metrics": "12.8.4",
     "@mojaloop/event-sdk": "14.8.2",
-    "@mojaloop/sdk-standard-components": "19.18.6",
+    "@mojaloop/sdk-standard-components": "19.18.7",
     "@opentelemetry/auto-instrumentations-node": "^0.69.0",
     "@types/hapi__joi": "17.1.15",
-    "ajv": "^8.17.1",
+    "ajv": "^8.18.0",
     "ajv-formats": "^3.0.1",
     "ajv-keywords": "^5.1.0",
     "audit-ci": "7.1.0",
@@ -125,7 +127,8 @@
     "tapes": "4.1.0"
   },
   "overrides": {
-    "axios": "1.13.4",
+    "@mojaloop/central-services-logger": "$@mojaloop/central-services-logger",
+    "axios": "1.13.5",
     "qs": "6.14.1",
     "brace-expansion": "2.0.2",
     "form-data": "4.0.4",

package/src/config.js

@@ -9,6 +9,13 @@ const config = convict({
     env: 'SHARED_CACHE_LOG_LEVEL'
   },
 
+  httpLogLevel: {
+    doc: 'Log level for HTTP wrapper.',
+    format: logLevelValues,
+    default: logLevelsMap.warn,
+    env: 'LOG_LEVEL_HTTP'
+  },
+
   defaultTtlSec: {
     doc: 'Default cache TTL.',
     format: Number,

package/src/index.d.ts

@@ -1,6 +1,7 @@
 import { Utils as HapiUtil, Server } from '@hapi/hapi'
 import { ILogger } from '@mojaloop/central-services-logger/src/contextLogger'
 import { Knex } from 'knex';
+import { AxiosRequestConfig, AxiosResponse, ResponseType as AxiosResponseType } from 'axios'
 import IORedis from 'ioredis';
 
 declare namespace CentralServicesShared {
@@ -763,9 +764,27 @@ declare namespace CentralServicesShared {
     accept: string
   }
 
-  type RequestParams = { url: string, headers: HapiUtil.Dictionary<string>, source: string, destination: string, hubNameRegex: RegExp, method?: RestMethodsEnum, payload?: any, responseType?: string, span?: any, jwsSigner?: any, protocolVersions?: ProtocolVersionsType }
-  interface Request {
-    sendRequest(params: RequestParams): Promise<any>
+  type RequestParams = {
+    url: string,
+    headers: HapiUtil.Dictionary<string>,
+    source: string,
+    destination?: string,
+    hubNameRegex: RegExp,
+    method?: RestMethodsEnum,
+    payload?: any,
+    params?: AxiosRequestConfig['params'],
+    responseType?: AxiosResponseType,
+    span?: any,
+    jwsSigner?: any,
+    protocolVersions?: ProtocolVersionsType,
+    apiType?: ApiTypeValues,
+    axiosRequestOptionsOverride?: Partial<AxiosRequestConfig>,
+    logger?: ILogger,
+    peerService?: string
+  }
+  export interface Request {
+    sendRequest(params: RequestParams): Promise<AxiosResponse>
+    sendBaseRequest(params?: AxiosRequestConfig & { logger?: ILogger, peerService?: string }): Promise<AxiosResponse>
   }
 
   interface Kafka {

package/src/util/hapi/plugins/loggingPlugin.js

@@ -30,6 +30,7 @@
 const { env } = require('node:process')
 const { asyncStorage } = require('@mojaloop/central-services-logger/src/contextLogger')
 const { logger } = require('../../../logger')
+const { incomingRequestAttributesDto } = require('../../otelDto')
 
 const INTERNAL_ROUTES = env.LOG_INTERNAL_ROUTES ? env.LOG_INTERNAL_ROUTES.split(',') : ['/health', '/metrics', '/live']
 const TRACE_ID_HEADER = env.LOG_TRACE_ID_HEADER ?? 'traceid'
@@ -61,13 +62,11 @@ const loggingPlugin = {
     server.ext({
       type: 'onRequest',
       method: (request, h) => {
-        const { path, method, headers, payload, query } = request
-        const { remoteAddress } = request.info
-        const requestId = request.info.id = `${request.info.id}__${headers[traceIdHeader]}`
+        const requestId = request.info.id = `${request.info.id}__${request.headers[traceIdHeader]}`
         asyncStorage.enterWith({ requestId })
 
-        if (shouldLog(path)) {
-          log.info(`[==> req] ${method.toUpperCase()} ${path}`, { headers, payload, query, remoteAddress })
+        if (shouldLog(request.path)) {
+          logRequest(request, log)
         }
         return h.continue
       }
@@ -77,16 +76,7 @@ const loggingPlugin = {
       type: 'onPreResponse',
       method: (request, h) => {
         if (shouldLog(request.path)) {
-          const { path, method, payload, response } = request
-          const { received } = request.info
-
-          const statusCode = response instanceof Error
-            ? response.output?.statusCode
-            : response.statusCode
-          const { output } = response
-          const respTimeSec = ((Date.now() - received) / 1000).toFixed(1)
-
-          log.info(`[<== ${statusCode}] ${method.toUpperCase()} ${path} [${respTimeSec} sec]`, { payload, output })
+          logResponse(request, log)
         }
         return h.continue
       }
@@ -94,4 +84,69 @@ const loggingPlugin = {
   }
 }
 
+/**
+ * @param {import('@hapi/hapi').Request} request
+ * @param {ILogger} log
+ * @returns OTelAttributes
+ */
+const logRequest = (request, log) => {
+  log.info(`[==> req] ${request.method.toUpperCase()} ${request.path} `, {
+    headers: extractHeadersForLogs(request.headers),
+    // payload is not parsed yet
+    ...extractAttributes({ request })
+  })
+}
+
+/**
+ * @param {import('@hapi/hapi').Request} request
+ * @param {ILogger} log
+ * @returns OTelAttributes
+ */
+const logResponse = (request, log) => {
+  const { method, path, response } = request
+
+  const statusCode = response instanceof Error
+    ? response.output?.statusCode
+    : response?.statusCode
+
+  const errorType = response instanceof Error
+    ? response.output?.payload?.error
+    : undefined
+
+  const durationSec = (Date.now() - request.info.received) / 1000
+
+  log.info(`[<== ${statusCode}] ${method.toUpperCase()} ${path}  [${durationSec} s]`, {
+    headers: extractHeadersForLogs(response?.output?.headers),
+    payload: response?.output?.payload, // think if we need to log payload only with debug severity
+    ...extractAttributes({ request, durationSec, statusCode, errorType })
+  })
+}
+
+const extractAttributes = ({ request, durationSec, statusCode, errorType }) => {
+  return incomingRequestAttributesDto({
+    method: request.method,
+    path: request.path,
+    url: getFullUrl(request),
+    route: request.route.path,
+    serverAddress: request.info.hostname,
+    clientAddress: request.info.remoteAddress,
+    userAgent: request.headers['user-agent'],
+    requestId: request.info.id,
+    durationSec,
+    statusCode,
+    errorType
+  })
+}
+
+/** @param {import('@hapi/hapi').Request} req */
+const getFullUrl = (req) => {
+  const search = req.url?.search || ''
+  return `${req.server.info.protocol}://${req.info.host}${req.path}${search}`
+}
+
+const extractHeadersForLogs = (headers = {}) => {
+  // todo: add impl.
+  return headers
+}
+
 module.exports = loggingPlugin

package/src/util/otelDto.js

@@ -0,0 +1,75 @@
+/*****
+ License
+ --------------
+ Copyright © 2020-2025 Mojaloop Foundation
+ The Mojaloop files are made available by the Mojaloop Foundation under the Apache License, Version 2.0 (the "License") and you may not use these files except in compliance with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, the Mojaloop files are distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+ Contributors
+ --------------
+ This is the official list of the Mojaloop project contributors for this file.
+ Names of the original copyright holders (individuals or organizations)
+ should be listed with a '*' in the first column. People who have
+ contributed from an organization can be listed under the organization
+ that actually holds the copyright for their contributions (see the
+ Mojaloop Foundation for an example). Those individuals should have
+ their names indented and be marked with a '-'. Email address can be added
+ optionally within square brackets <email>.
+
+ * Mojaloop Foundation
+ * Eugen Klymniuk <eugen.klymniuk@infitx.com>
+
+ --------------
+ ******/
+/* istanbul ignore file */
+
+const otel = require('@opentelemetry/semantic-conventions')
+
+const ATTR_SERVICE_PEER_NAME = 'service.peer.name' // using string literal because ATTR_SERVICE_PEER_NAME is only available in @opentelemetry/semantic-conventions/incubating as of now
+const CUSTOM_REQUEST_ID = 'request.id'
+
+/** @typedef { attributes: Record<string, any> } OTelAttributes */
+
+/** @returns OTelAttributes */
+const outgoingRequestAttributesDto = ({
+  method, url, durationSec, statusCode, errorType, peerService
+}) => ({
+  attributes: {
+    [otel.ATTR_HTTP_REQUEST_METHOD]: method,
+    [otel.ATTR_URL_FULL]: url,
+    [otel.METRIC_HTTP_CLIENT_REQUEST_DURATION]: durationSec, // 'duration.ms' is a custom attribute
+    ...(statusCode && { [otel.ATTR_HTTP_RESPONSE_STATUS_CODE]: statusCode }),
+    ...(errorType && { [otel.ATTR_ERROR_TYPE]: errorType }),
+    ...(peerService && { [ATTR_SERVICE_PEER_NAME]: peerService })
+    // peerService - logical service name, must be explicitly provided by caller (not derived from URL hostname)
+    //               think if we should extract it for internal http://... calls from url hostname
+  }
+})
+
+/** @returns OTelAttributes */
+const incomingRequestAttributesDto = ({
+  method, url, path, route,
+  serverAddress, clientAddress, userAgent, durationSec, requestId, statusCode, errorType
+}) => ({
+  attributes: {
+    [otel.ATTR_HTTP_REQUEST_METHOD]: method,
+    [otel.ATTR_URL_FULL]: url,
+    [otel.ATTR_URL_PATH]: path,
+    [otel.ATTR_HTTP_ROUTE]: route,
+    [otel.ATTR_SERVER_ADDRESS]: serverAddress,
+    [otel.ATTR_CLIENT_ADDRESS]: clientAddress,
+    [otel.ATTR_USER_AGENT_ORIGINAL]: userAgent,
+    [CUSTOM_REQUEST_ID]: requestId,
+    ...(durationSec && { [otel.METRIC_HTTP_SERVER_REQUEST_DURATION]: durationSec }), // 'duration.ms' is a custom attribute
+    ...(statusCode && { [otel.ATTR_HTTP_RESPONSE_STATUS_CODE]: statusCode }),
+    ...(errorType && { [otel.ATTR_ERROR_TYPE]: errorType })
+  }
+})
+
+module.exports = {
+  outgoingRequestAttributesDto,
+  incomingRequestAttributesDto
+}

package/src/util/request.js

@@ -30,29 +30,31 @@
 'use strict'
 
 const http = require('node:http')
-const request = require('axios')
+const axios = require('axios')
 const stringify = require('fast-safe-stringify')
 const EventSdk = require('@mojaloop/event-sdk')
 const ErrorHandler = require('@mojaloop/central-services-error-handling')
 const Metrics = require('@mojaloop/central-services-metrics')
-const Headers = require('./headers/transformer')
-const enums = require('../enums')
-const { logger } = require('../logger')
+
+const { logger: globalLogger } = require('../logger')
 const { API_TYPES } = require('../constants')
 const config = require('../config')
+const enums = require('../enums')
+const Headers = require('./headers/transformer')
+const { outgoingRequestAttributesDto } = require('./otelDto')
 
 const MISSING_FUNCTION_PARAMETERS = 'Missing parameters for function'
 
 // Delete the default headers that the `axios` module inserts as they can brake our conventions.
 // By default it would insert `"Accept":"application/json, text/plain, */*"`.
-delete request.defaults.headers.common.Accept
+delete axios.defaults.headers.common.Accept
 
 const keepAlive = (process.env.HTTP_AGENT_KEEP_ALIVE ?? 'true') === 'true'
-logger.verbose('http keepAlive:', { keepAlive })
+globalLogger.verbose('http keepAlive:', { keepAlive })
 
 // Enable keepalive for http
-request.defaults.httpAgent = new http.Agent({ keepAlive })
-request.defaults.httpAgent.toJSON = () => ({})
+axios.defaults.httpAgent = new http.Agent({ keepAlive })
+axios.defaults.httpAgent.toJSON = () => ({})
 
 /**
  * @function sendRequest
@@ -77,11 +79,12 @@ request.defaults.httpAgent.toJSON = () => ({})
  * @param {SendRequestProtocolVersions | undefined} protocolVersions the config for Protocol versions to be used
  * @param {'fspiop' | 'iso20022'} apiType the API type of the request being sent
  * @param {object} axiosRequestOptionsOverride axios request options to override https://axios-http.com/docs/req_config
+ * @param {ILogger} [logger] ContextLogger instance with specific context
+ * @param {string} [peerService] Logical service name to call (for OTel)
  * @param {regex} hubNameRegex hubName Regex
  *
  *@return {Promise<any>} The response for the request being sent or error object with response included
  */
-
 const sendRequest = async ({
   url,
   headers,
@@ -96,6 +99,8 @@ const sendRequest = async ({
   protocolVersions = undefined,
   apiType = API_TYPES.fspiop,
   axiosRequestOptionsOverride = {},
+  logger = createHttpLogger(),
+  peerService = '',
   hubNameRegex
 }) => {
   const histTimerEnd = Metrics.getHistogram(
@@ -113,6 +118,9 @@ const sendRequest = async ({
     // think, if we can just avoid checking "destination"
     throw ErrorHandler.Factory.createInternalServerFSPIOPError(MISSING_FUNCTION_PARAMETERS)
   }
+
+  const log = logger.child({ component: 'httpRequest' })
+
   try {
     const transformedHeaders = Headers.transformHeaders(headers, {
       httpMethod: method,
@@ -126,9 +134,10 @@ const sendRequest = async ({
       url,
       method,
       headers: transformedHeaders,
-      data: payload, // todo: think, if it's better to transform to ISO format here (based on apiType)
+      data: payload,
       params,
       responseType,
+      peerService,
       timeout: config.get('httpRequestTimeoutMs'),
       ...axiosRequestOptionsOverride
     }
@@ -149,14 +158,18 @@ const sendRequest = async ({
       }
       span.audit({ ...rest, payload }, EventSdk.AuditEventAction.egress)
     }
-    logger.debug('sendRequest::requestOptions:', { requestOptions })
-    const response = await request(requestOptions)
+
+    const response = await sendBaseRequest({
+      ...requestOptions,
+      logger: log,
+      peerService
+    })
 
     !!sendRequestSpan && await sendRequestSpan.finish()
     histTimerEnd({ success: true, source, destination, method })
     return response
   } catch (error) {
-    logger.error('error in request.sendRequest:', {
+    log.error('error in request.sendRequest:', {
       code: error.code,
       message: error.message,
       stack: error.stack,
@@ -247,6 +260,62 @@ const sendRequest = async ({
   }
 }
 
+// todo: think better name
+//       it's for http calls without params validation and transformHeaders
+const sendBaseRequest = async ({
+  logger = createHttpLogger(),
+  peerService = '',
+  ...reqOptions
+} = {}) => {
+  const log = logger.child({ component: 'sendBaseRequest' })
+  const { method, url } = reqOptions
+  const methodUrl = `${method?.toUpperCase()} ${url}`
+  const startTime = Date.now()
+
+  let statusCode
+  let errorType
+
+  try {
+    log.debug(`[-->] options for ${methodUrl}: `, { reqOptions })
+
+    const response = await axios(reqOptions)
+
+    statusCode = response?.status
+    log.verbose(`[<--] details of ${methodUrl}: `, {
+      data: response?.data,
+      headers: response?.headers, // todo: extract only needed headers
+      statusCode,
+      reqOptions
+    })
+
+    return response
+  } catch (error) {
+    statusCode = error.response?.status
+    errorType = error.code
+    throw error // todo: think, if we need to rethrow our custom error here
+  } finally {
+    const severity = typeof statusCode === 'number'
+      ? (statusCode >= 200 && statusCode < 300 ? 'info' : 'warn')
+      : 'error'
+    const durationSec = (Date.now() - startTime) / 1000
+    log[severity](`[<-- ${statusCode || errorType || ''}] ${methodUrl}  [${durationSec} s]:`, outgoingRequestAttributesDto({
+      method,
+      url,
+      statusCode,
+      durationSec,
+      errorType,
+      peerService
+    }))
+  }
+}
+
+const createHttpLogger = () => {
+  const logger = globalLogger.child()
+  logger.setLevel(config.get('httpLogLevel'))
+  return logger
+}
+
 module.exports = {
-  sendRequest
+  sendRequest,
+  sendBaseRequest
 }

package/test/unit/util/hapi/plugins/loggingPlugin.test.js

@@ -134,7 +134,7 @@ Tape('loggingPlugin Tests -->', (pluginTests) => {
     t.true(statusCode === 500, 'handler failed')
     t.true(log.info.callCount === 2, 'log request/response')
     t.true(log.info.lastCall.firstArg.startsWith('[<== 500]'), 'error code is logged')
-    t.ok(log.info.lastCall.lastArg.output.payload, 'error output is logged')
+    t.ok(log.info.lastCall.lastArg.payload, 'error output is logged')
   }))
 
   pluginTests.test('should not log requests on internal routes', tryCatchEndTest(async t => {