@soinlabs/hawk/src/Hawk.js

Package to better manage errors, logs, and its notifications

const Logger = require('./Logger')
const ErrorBuilder = require('./ErrorBuilder')
const LoggedError = require('./LoggedError')

class Hawk {
  constructor(config) {
    this.context = ''
    this.setContext(config.appName, config.optionalSign)
    this.ToSlackError = ErrorBuilder.templateBuilder(
      ErrorBuilder.TO_SLACK_TEMPLATE
    )
    this.ToElasticError = ErrorBuilder.templateBuilder(
      ErrorBuilder.TO_ELASTIC_TEMPLATE
    )
    this.ToLogError = ErrorBuilder.templateBuilder(ErrorBuilder.TO_LOG_TEMPLATE)
    this.ToEmailError = ErrorBuilder.templateBuilder(
      ErrorBuilder.TO_EMAIL_ERROR
    )
    this.ToAllError = ErrorBuilder.templateBuilder(ErrorBuilder.TO_ALL_TEMPLATE)
    this.logger = new Logger({
      path: config.logsPath,
      slackToken: config.slackToken,
      referenceCode: this.context,
    })
  }

  setContext(appName, optionalSign) {
    if (
      appName !== null &&
      appName !== undefined &&
      optionalSign !== null &&
      optionalSign !== undefined
    ) {
      this.context = `${appName}-${optionalSign}`
    } else if (appName !== null && appName !== undefined) {
      this.context = appName
    }
  }

  getContext() {
    return this.context
  }

  /**
   * It checks if an received error is unhandle-unexpected error, and if it is, then logs the error
   * @param {Error} error
   * @param {String} context
   * @param {Object} options
   * {Object} logged value or null (error is an instance of LoggedError)
   */
  logUnexpectedError(error, context, options = {}) {
    const contextToSet = {
      value: context || this.context,
    }
    let newError = null
    if (!(error instanceof LoggedError) && error instanceof Error) {
      // if it is a unhandle error, then is not an LoggedError
      newError = new LoggedError()
        .setMessage(`Unhandle error captured by hawk: ${error.message}`)
        .setPreviousError(error)
        .setReferenceCode(contextToSet.value)
        .setErrorLevel(LoggedError.HIGH_LEVEL)
        .setToLog(true)
        .setToElastic(true)
        .setToSlack(true)
        .setToEmail(options.toEmail)
        .setEmailOptions(options.emailOptions)

      this.logger.log(newError, Logger.ERROR)
    }
    return newError
  }

  /**
   * Log objects who has toString() or has message property or objects that are simple strings
   * @param {Object} loggeableObject ({message:value}, Error, LoggedError, String)
   * @param {String} level
   * @returns {Object} logged value
   */
  log(loggeableObject, level) {
    let toLogValue = { message: null }
    if (!(loggeableObject instanceof LoggedError)) {
      toLogValue = { message: null, referenceCode: this.context }
      if (!loggeableObject.message) toLogValue.message = loggeableObject
      // assume that it is an string or is an object with toString()
      else toLogValue.message = loggeableObject.message
    } else {
      toLogValue = loggeableObject
    }
    this.logger.log(toLogValue, level)
    return toLogValue
  }

  CreateSlackError(message, code = 500) {
    return this.ToSlackError(message, this.context).setStatus(code)
  }

  CreateLogError(message, code = 500) {
    return this.ToLogError(message, this.context).setStatus(code)
  }

  CreateElasticError(message, code = 500) {
    return this.ToElasticError(message, this.context).setStatus(code)
  }

  CreateHawkError(message, code = 500) {
    return this.ToAllError(message, this.context).setStatus(code)
  }
}

module.exports = Hawk