# Hawk

[![codecov](https://codecov.io/gh/SoinLabs/hawk/branch/master/graph/badge.svg?token=MZVEAVIQDC)](https://codecov.io/gh/SoinLabs/hawk)
[![npm version](https://badgen.net/npm/v/@soinlabs/hawk)](https://www.npmjs.com/package/@soinlabs/hawk)
[![npm downloads](https://badgen.net/npm/dm/@soinlabs/hawk)](https://www.npmjs.com/package/@soinlabs/hawk)

Error and logs framework for Soin Labs projects.

# How to use

For getting a simple use of Hawk, follow the steps bellow:

1. Export the Hawk constructor and make an instance:

   ```js
   // your index.js to handle hawk singleton configuration

   const { Hawk } = require("@soinlabs/hawk");

   const customizedHawk = new Hawk({
     logsPath: "yourWorkspace/route/example/logsDirectory",
     slackToken: "yourWebhookChannelURL",
     appName: "yourApplicationName",
     optionalSign: "optionalBenchmark",
   });
   ```

2. Use your Hawk instance to perform your logs

   ```js
   customizedHawk.log("My first log");

   const newError = customizedHawk.CreateElasticError("message", 300);
   customizedHawk.log(newError);

   // It is possible to perform a simple log with logging level
   const { Logger } = require("@soinlabs/hawk");
   customizedHawk.log("My first log", Logger.SILLY);
   ```

3. Some error and logs handling utilities

   ```js
   // Some error and logs handling utilities:

   const { Logger, LoggedError } = require('@soinlabs/hawk')

   const LoggingLevels = {
       error: Logger.ERROR,
       warn: Logger.WARN,
       info: Logger.INFO,
       http: Logger.HTTP,
       verbose: Logger.VERBOSE,
       debug: Logger.DEBUG,
       silly: Logger.SILLY,
   };

   const ErrorLevels = {
       low: LoggedError.LOW_LEVEL,
       medium: LoggedError.MEDIUM_LEVEL,
       high: LoggedError.HIGH_LEVEL,
   };

   /**
   * It creates an Elastic Error with message and code, after, it makes log with this error
   * and throw the created error as an exception
   * @param {String} message what happened?
   * @param {Number} status status code
   * @param {Number} errorLevel optional
   */
   function sendError(message, status, errorLevel = ErrorLevels.low) {
       const error = customizedHawk.CreateElasticError(message, status);
       error.setErrorLevel(errorLevel);
       customizedHawk.log(error, LoggingLevels.error);
       throw error;
   }

   /**
   * It performs a log with this message at warning level
   * @param {String} msg
   */
   function sendWarning(msg) {
       customizedHawk.log(
           { message: msg, referenceCode: customizedHawk.getReferenceCode() },
           LoggingLevels.warn
       )
   }

   /**
    * It creates an Elastic Error with message and code, after, it makes log with this error
   * @param {String} message
   * @param {Number} code
   * @param {Number} errorLevel optional
   */
   function logError(message, code, errorLevel = ErrorLevels.low) {
       const error = customizedHawk.CreateElasticError(message, code)
       customizedHawk.log(error, LoggingLevels.error)
   }

   ...
   // Use your utilies

   // This throw an exception
   sendError("No id provided", 400);

   // It performs a warning level log
   sendWarning('Bad request')
   ```

# Another alternatives

You could do some things like these:

1. Throw LoggedError

   ```js
   // Use builder pattern

   throw new LoggedError()
     .setMessage(`Error captured by hawk: ${message}`)
     .setReferenceCode("myFile.js")
     .setErrorLevel(LoggedError.HIGH_LEVEL)
     .setToLog(true)
     .setToSlack(true);

   // Another way

   throw new LoggedError({
     message: `Error captured by hawk: ${message}`,
     status: 401,
     toLog: true,
     toElastic: false,
     toSlack: true,
     newField: "yourNewFieldValue",
   });
   ```