@iin-mdc/koa-utils/middleware/ctx-logger.js

"use strict"

const uuid                     = require("uuid/v4")
const { ErrorReporting }      = require("@google-cloud/error-reporting")

const reqIdHeader              = "X-Request-Id"

module.exports = function createCtxLogger(logger, options={}, fetchUser=null) {
  const gcloudErrorReporting = new ErrorReporting(gcloudOptions(options))
  const errorHandler         = initErrorHandler(gcloudErrorReporting, fetchUser || (async () => {}))
  const logMiddleware        = initLogMiddleware(logger, errorHandler)

  return logMiddleware
}

function initLogMiddleware(logger, errorHandler) {
  return async (ctx, next) => {
    let reqId        = ctx.reqId = ctx.request.get(reqIdHeader) || uuid()
    let log          = logger.child(reqId)
    let requestTimer = log.timer()

    ctx.log            = log
    ctx.requestTimer   = requestTimer
    ctx.errorReporting = errorHandler.gcloudErrorReporting

    try {
      await next()
    } catch (e) {
      await errorHandler(ctx, e)
    } finally {
      ctx.response.set("X-Server-Request-Id", ctx.reqId)
      ctx.requestTimer.end("%s %s > %d", ctx.request.method, ctx.request.url, ctx.response.status)
    }
  }
}

function initErrorHandler(gcloudErrorReporting, fetchUser) {
  const handler = async (ctx, e) => {
    if (e instanceof Error === false) {
      e = new Error(e)
    }

    if (!e.status)   e.status   = 500
    if (!e.jsonBody) e.jsonBody = {}

    ctx.type   = "json"
    ctx.status = e.status

    ctx.log.debug("%s %s < params: %O, body: %O", ctx.request.method, ctx.request.url, ctx.params, ctx.request.body)

    if (!e.expose) {
      let user = await fetchUser(ctx)

      let requestInformation = {
        method:        ctx.method,
        url:           ctx.url,
        userAgent:     ctx.request.get("user-agent"),
        referrer:      ctx.request.get("referrer"),
        statusCode:    ctx.status,
        remoteAddress: ctx.ip,
        requestId:     ctx.request.get("x-request-id") }

      let errorMessage = gcloudErrorReporting.event()
        .setMessage(`${e.stack}\n\nreqId:${ctx.reqId}`)
        .consumeRequestInformation(requestInformation)

      if (user) errorMessage.setUser(user)

      gcloudErrorReporting.report(errorMessage, (err) => {
        if (err) return ctx.log.trace(`Error ${err} while reporting to google cloud`)
        ctx.log.trace("Error reported to GCloud")
      })

      ctx.log.error(e)
    }

    e.jsonBody.status  = e.status
    e.jsonBody.message = e.expose ? e.message : "Error"

    ctx.body = {
      error: e.jsonBody,
      reqId: ctx.reqId
    }
  }

  handler.gcloudErrorReporting = gcloudErrorReporting
  return handler
}

function gcloudOptions(options) {
  let pckg           = require("package.json")
  let serviceContext = options.serviceContext || {
    service: pckg.name,
    version: pckg.version }

  let gcloudOptions  = {
    serviceContext,
    projectId:                 options.projectId,
    reportUnhandledRejections: true,
    logLevel:                  2                              || options.logLevel,
    reportMode:                options.reportMode || (options.ignoreEnvironmentCheck ? "always" : "production")
  }
  if (options.credentials) {
    gcloudOptions.credentials = options.credentials
  }

  return gcloudOptions
}