overleaf/libraries/metrics/timeAsyncMethod.js

/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS201: Simplify complex destructure assignments
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */

module.exports = function(obj, methodName, prefix, logger) {
  let modifedMethodName
  const metrics = require('./index')

  if (typeof obj[methodName] !== 'function') {
    throw new Error(
      `[Metrics] expected object property '${methodName}' to be a function`
    )
  }

  const key = `${prefix}.${methodName}`

  const realMethod = obj[methodName]

  const splitPrefix = prefix.split('.')
  const startPrefix = splitPrefix[0]

  if (splitPrefix[1] != null) {
    modifedMethodName = `${splitPrefix[1]}_${methodName}`
  } else {
    modifedMethodName = methodName
  }
  return (obj[methodName] = function(...originalArgs) {
    const adjustedLength = Math.max(originalArgs.length, 1)
    const firstArgs = originalArgs.slice(0, adjustedLength - 1)
    const callback = originalArgs[adjustedLength - 1]

    if (callback == null || typeof callback !== 'function') {
      if (logger != null) {
        logger.log(
          `[Metrics] expected wrapped method '${methodName}' to be invoked with a callback`
        )
      }
      return realMethod.apply(this, originalArgs)
    }

    const timer = new metrics.Timer(startPrefix, 1, {
      method: modifedMethodName
    })

    return realMethod.call(this, ...Array.from(firstArgs), function(
      ...callbackArgs
    ) {
      const elapsedTime = timer.done()
      const possibleError = callbackArgs[0]
      if (possibleError != null) {
        metrics.inc(`${startPrefix}_result`, 1, {
          status: 'failed',
          method: modifedMethodName
        })
      } else {
        metrics.inc(`${startPrefix}_result`, 1, {
          status: 'success',
          method: modifedMethodName
        })
      }
      if (logger != null) {
        const loggableArgs = {}
        try {
          for (let idx = 0; idx < firstArgs.length; idx++) {
            const arg = firstArgs[idx]
            if (arg.toString().match(/^[0-9a-f]{24}$/)) {
              loggableArgs[`${idx}`] = arg
            }
          }
        } catch (error) {}
        logger.log(
          { key, args: loggableArgs, elapsedTime },
          '[Metrics] timed async method call'
        )
      }
      return callback.apply(this, callbackArgs)
    })
  })
}