ROC-3285 Integrate logging with Azure Application Insights (#28)

Author: dharmendra kumar

README.md

@@ -2,13 +2,14 @@
 
 [![Greenkeeper badge](https://badges.greenkeeper.io/hmcts/nodejs-logging.svg)](https://greenkeeper.io/)
 
-A logging component used by Reform's Node.js applications. Some background info:
-* there are 8 log levels: `ALL`, `TRACE`, `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL` and `OFF`.
-* a level can be set via an environment variable `LOG_LEVEL`, the default is `INFO`.
-* there are 3 types of logging output which is set via an environment variable `LOG_OUTPUT`, the default is `human`:
-  - `human` - single line of a human readable output
-  - `single` - a single line of JSON output
-  - `multi` - a multiline formatted JSON output
+A logging component used by Reform's Node.js applications.
+
+**This is not compatible with Reform tactical logging spec. Logger 2.x should be used for tactical applications.**
+
+Some background info:
+* there are 6 log levels: `silly` (5), `debug` (4), `verbose` (3), `info` (2), `warn` (1) and `error` (0).
+* log level can be set via an environment variable `LOG_LEVEL`, the default is `info`.
+* logging output in JSON format can be enabled by setting environment variable `JSON_PRINT` to `true`, the default is `false`:
 * by default logging is turned off when running the unit tests.
 
 ## Usage
@@ -25,82 +26,48 @@ Require it:
 const { Logger } = require('@hmcts/nodejs-logging')
 ```
 
-Set the logging configuration. Should be done once at application startup:
-
-```javascript
-Logger.config({ 
-    microservice: 'your-service-name', 
-    team: 'your-team',
-    environment: 'some-environemnt'
-})
-```
-
 Then you can create a logger instance and use it to log information:
 
 ```javascript
 const logger = Logger.getLogger('app.js') // app.js is just an example, can be anything that's meaningful to you
+```
 
+Usage are:
+
+```
 logger.info({
   message: 'Yay, logging!'
 })
 ```
 
-### Access logging for Express applications 
-
-Optionally you can use the built-in Express access logger:
-
-```javascript
-const { Express } = require('@hmcts/nodejs-logging')
-
-app.use(Express.accessLogger())
-```
-
-It will log all requests made against your application. For example, a typical HTTP 404 log error when encountering an error would look like the following:
+or
 
 ```
-{
-  responseCode: 404,
-  message: 'Not Found',
-  fields: [],
-  level: 'ERROR',
-  environment: 'some-environemnt',
-  hostname: 'My-MacBook-Pro.local',
-  rootRequestId: '',
-  requestId: '',
-  originRequestId: '',
-  type: 'nodejs',
-  microservice: 'your-service-name',
-  team: 'your-team',
-  timestamp: '2017-01-27T11:27:23+00:00'
-}
+logger.log({
+  level: 'info',
+  message: 'What time is the testing at?'
+});
 ```
 
-### Request tracing for Express applications
+Above will result in the following log printed (if JSON format is enabled).
 
-An Express middleware is provided which automatically populates request headers with request tracing IDs. Sample usage:
-
-```javascript
-const { RequestTracing } = require('@hmcts/nodejs-logging')
-
-app.use(RequestTracing.middleware)
+```
+{ level: 'info',
+  message: 'What time is the testing at?',
+  label: 'app.js',
+  timestamp: '2017-09-30T03:57:26.875Z' }
 ```
 
-Assuming your Express application servers as the system's entry point which serves user UI, this middleware will intercept user requests and set `Root-Request-Id` and `Request-Id` headers on it. If the incoming request comes from a different service which already populated those values, they will be forwarded.
+### Access logging for Express applications 
 
-Apart from populating the headers, access to request tracing information is available at any point during request processing, e.g.:
+Optionally you can use the built-in Express access logger:
 
 ```javascript
-const id = RequestTracing.getCurrentRequestId()
-```
-
-We can also access the original request:
+const { Express } = require('@hmcts/nodejs-logging')
 
-```javascript
-const request = RequestTracing.retrieveInitialRequest()
+app.use(Express.accessLogger())
 ```
 
-These features are enabled by [continuation-local-storage module](https://github.com/othiym23/node-continuation-local-storage).
-
 ## Units Tests
 
 Just do

index.js

@@ -2,8 +2,5 @@
 
 module.exports = {
   Logger: require('./log/Logger'),
-  LoggingConfig: require('./log/config'),
-  RequestTracing: require('./log/tracing/requestTracing'),
-  RequestTracingHeaders: require('./log/tracing/headers'),
   Express: require('./log/express')
 }

log/Logger.js

@@ -1,123 +1,26 @@
-const merge = require('lodash.merge');
-const moment = require('moment');
-const { logging, outputTypes } = require('./config');
-const levels = logging.log4js.levels;
+const moment = require('moment')
+const winston = require('winston')
 
-const RequestTracing = require('./tracing/requestTracing');
+const container = new winston.Container()
 
-let userConfig = {};
+function timestamp() {
+  return moment().format('YYYY-MM-DDTHH:mm:ssZ')
+}
 
-function isBlank (str) {
-  return !str || str.trim().length === 0;
+function transport(label) {
+  return new winston.transports.Console({
+    level: (process.env.LOG_LEVEL || 'INFO').toLowerCase(),
+    json: process.env.JSON_PRINT || false,
+    timestamp: timestamp,
+    label: label
+  })
 }
 
 class Logger {
 
-  //----------------------------------------------------
-  // Public functions
-  //----------------------------------------------------
-
-  constructor() {
-  }
-
-  trace(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.TRACE.toString();
-    return this._log(logEntry);
-  }
-
-  debug(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.DEBUG.toString();
-    return this._log(logEntry);
-  }
-
-  info(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.INFO.toString();
-    return this._log(logEntry);
-  }
-
-  warn(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.WARN.toString();
-    return this._log(logEntry);
-  }
-
-  error(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.ERROR.toString();
-    return this._log(logEntry);
-  }
-
-  fatal(logEntry) {
-    logEntry = this._wrap(logEntry);
-    logEntry.level = levels.FATAL.toString();
-    return this._log(logEntry);
-  }
-
-  //----------------------------------------------------
-  // Public static functions
-  //----------------------------------------------------
-
   static getLogger(name) {
-    const logger = new Logger();
-    logger.logger = logging.log4js.getLogger(name);
-
-    return logger;
-  }
-
-  static config(config) {
-    userConfig = config || {};
+    return container.add(name, {transports: [transport(name)]})
   }
-
-  //----------------------------------------------------
-  // Private functions
-  //----------------------------------------------------
-
-  _log(logEntry) {
-    logEntry = merge({ }, logging.defaultLogEntry, logEntry);
-    this._addTracingInformation(logEntry)
-    logEntry.timestamp = moment().format(logging.timestampFormat);
-    const level = logEntry.level.toLowerCase();
-
-    logEntry.microservice = userConfig.microservice || 'not-configured';
-    logEntry.team = userConfig.team || 'not-configured';
-    logEntry.environment = userConfig.environment || 'not-configured';
-
-    if (logging.output === outputTypes.single) {
-      this.logger[level](JSON.stringify(logEntry));
-    } else if (logging.output === outputTypes.multi) {
-      this.logger[level](logEntry);
-    } else {
-      this.logger[level](`${logEntry.timestamp} ${logEntry.level} ${this.logger.category}: ${logEntry.message}`)
-    }
-
-    return logEntry;
-  };
-
-  _addTracingInformation (logEntry) {
-    if (isBlank(logEntry.requestId)) {
-      logEntry.requestId = RequestTracing.getCurrentRequestId() || logging.defaultLogEntry.requestId;
-    }
-    if (isBlank(logEntry.originRequestId)) {
-      logEntry.originRequestId = RequestTracing.getOriginRequestId() || logging.defaultLogEntry.originRequestId;
-    }
-    if (isBlank(logEntry.rootRequestId)) {
-      logEntry.rootRequestId = RequestTracing.getRootRequestId() || logging.defaultLogEntry.rootRequestId;
-    }
-  }
-
-  _wrap(message) {
-    if (typeof message === 'string') {
-      return { message: message };
-    } else if (message instanceof String) {
-      return { message: message.toString() };
-    } else {
-      return message;
-    }
-  }
-
 }
 
-module.exports = Logger;
+module.exports = Logger