Add support for custom fields and custom field names

Author: Dogukan Erenel

README.md

@@ -32,8 +32,80 @@ You must add the following to the list of appenders in your `log4js.json` file:
   }
 }
  ```
+ You may substitute `INFO` with your own level above (for ex: `WARN`, `ERROR`, etc). Please check [log4js](https://www.npmjs.com/package/log4js) documentation for level based filtering since there might be some differences between versions.  
 
-You may substitute `INFO` with your own level above (for ex: `WARN`, `ERROR`, etc)
+To use custom fields to send logmet, you should define `eventMap` object under `options`. If it is not defined then default mapping is used. 
+
+Default Event object (object sending to Logmet) consists of `component`, `host-ip`, `instance-id`, `loglevel`, `logtime`, `message` values. 
+
+For custom fields, values can be map are given below:
+- `component`: The name of your component / service. 
+- `host-ip`: The cloudfoundary ip defined as environmental variable CF_INSTANCE_IP
+- `instance-id`: The cloudfounrday index defined as environmental variable CF_INSTANCE_INDEX
+- `loglevel`: Logging level string. (exp. TRACE, DEBUG, INFO, WARN, ERROR, FATAL)
+- `logtime`: Logging time as ISO string format (exp. 2011-10-05T14:48:00.000Z)
+- `message`: Log message based on log4js configuration. If log data is multiple string, then is is merged with ` | ` delimiter. 
+- `process.*` : To reach variables from `process` within two layer. (exp. process.pid, process.env.USER)
+- `data.*` : To reach variables from optional `object` type from log data within two layer. This is useful, if you want to pass a custom object and use the value in your logs withing a custom field. (exp. You can pass `{clientId: '123'}` object to log and map it as `CLIENT_ID: data.clientId`)
+
+Example `log4js.json` file given below (for log4js version 0.6.38 and below).
+```
+{
+  "appenders": [
+    {
+      "type": "console",
+      "layout": { "type": "coloured" }
+    },
+    { 
+      "type": "logLevelFilter", 
+      "level": "INFO", 
+      "appender": {
+        "type": "log4js-logmet-appender",
+        "options": {
+          "eventMap": {
+            "TIMESTAMP": "logtime",
+            "PRIORITY": "loglevel",
+            "MESSAGE": "message",
+            "SERVICE": "component",
+            "_PID": "process.pid",
+            "USER": "process.env.USER",
+            "CUSTOM_ENV": "process.env.CUSTOM_VARIABLE"
+            "TEST": "data.test",
+            "TEST12": "data.test1.test2"
+          }
+        }
+     }
+   }
+  ],
+  "replaceConsole": true
+}
+```
+And example `debug` logging call;
+```
+var log4js = require('log4js');
+log4js.configure('/path/to/log4js.json');
+var logger = log4js.getLogger();
+logger.level = 'debug';
+const objectToTest = { test: 'test 1 is good', test1: { test2: 'test 2 is better' } };
+logger.debug("Some debug messages", objectToTest);
+```
+This example prints coloured console log and filters `INFO` levels for `log4js-logmet-appender` appender. 
+`eventMap` determines the custom mapping for the object sending logmet. Values will be replaced based on event mapping and will send to logmet. 
+
+Example data to be sent to logmet based on given `log4js.json`
+```
+{
+    "TIMESTAMP": "2011-10-05T14:48:00.000Z",
+    "PRIORITY": "INFO",
+    "MESSAGE": "Your log message",
+    "SERVICE": "name of your component",
+    "_PID": 1234,
+    "USER": "Username of the process",
+    "CUSTOM_ENV": "Environmental value defined as CUSTOM_VARIABLE",
+    "TEST": "test 1 is good",
+    "TEST12": "test 2 is better"
+}
+```
 
 ## Pending work
 No automated tests currently

index.js

@@ -19,6 +19,16 @@ module.exports = {
     shutdown: shutdown
 };
 
+const messageSeperator = " | ";
+const defaultEventMap = {
+    'component': 'component',
+    'host-ip':  'host-ip',
+    'instance-id':'instance-id',
+    'loglevel': 'loglevel',
+    'logtime': 'logtime',
+    'message': 'message'
+};
+
 function sendData(level, options, tlsOpts, log) {
     var event = buildEvent(log, options);
     logmetConnection.producer.sendData(event, log.categoryName, options.space_id, function(/*error, status*/) {
@@ -28,20 +38,66 @@ function sendData(level, options, tlsOpts, log) {
 
 function buildEvent(log, options) {
     // build up message to send
-    var logData = log.data && log.data.join(' | ');
-
-    var event = {
-        'component': options.component,
-        'host-ip': process.env.CF_INSTANCE_IP,
-        'instance-id': process.env.CF_INSTANCE_INDEX,
-        'loglevel': log.level && log.level.levelStr,
-        'logtime': log.startTime && log.startTime.toISOString(),
-        'message': logData
-    };
-
+    var event = {};
+    if(options && options.event_map){
+        for (var key in options.event_map) {
+            if (!options.event_map.hasOwnProperty(key)) continue;
+            var value = options.event_map[key];
+            event[key] = getValueForMapping(value, options, log);
+        }
+    }
     return event;
 }
 
+function getValueForMapping(key, options, log){
+    var valueMapped;
+    if(key === 'component'){
+        valueMapped = options.component;
+    } else if(key === 'host-ip'){
+        valueMapped = process.env.CF_INSTANCE_IP;
+    } else if(key === 'instance-id'){
+        valueMapped = process.env.CF_INSTANCE_INDEX;
+    } else if(key === 'loglevel'){
+        valueMapped = log.level && log.level.levelStr;
+    } else if(key === 'logtime'){
+        valueMapped = log.startTime && log.startTime.toISOString();
+    } else if(key === 'message'){
+        valueMapped = log.data && log.data.reduce(function (a, b) {
+            return ((typeof(a)==="object" && JSON.stringify(a)) || a) + messageSeperator + ((typeof(b)==="object" && JSON.stringify(b)) || b);
+        });
+    } else if(key.startsWith('process.') && key.length > 8){
+        var processValue = key.substring(8).split('.');
+        if(processValue.length == 1){
+            valueMapped = process[processValue[0]];
+        } else if (processValue.length == 2){ 
+            valueMapped = process[processValue[0]] && process[processValue[0]][processValue[1]];
+        }
+        else{
+            //do nothing - currently only support for 2 layer process information
+        }
+    } else if(key.startsWith('data.') && key.length > 5){ //Custom data parsing using log data array's first `object` type element
+        var logDataObject = log.data && log.data.find(function(element) {
+            return (typeof(element)==="object");
+        });
+        if(logDataObject){
+            var dataValue = key.substring(5).split('.');
+            if(dataValue.length == 1){
+                valueMapped = logDataObject[dataValue[0]];
+            } else if (dataValue.length == 2){ 
+                valueMapped = logDataObject[dataValue[0]] && logDataObject[dataValue[0]][dataValue[1]];
+            } else {
+                 //do nothing - currently only support for 2 layer data information
+            }
+        }
+        else{
+            //do nothing - there is no data object
+        }
+    } else {
+        // No valid mapping found for given key.
+    }
+    return valueMapped;
+}
+
 function appender(level, options, tlsOpts) {
     logmetConnection.producer = new logmet.LogmetProducer(tlsOpts.host, tlsOpts.port, options.space_id, options.logging_token, false, {bufferSize: logmetConnection.BUFFER_SIZE});
     logmetConnection.producer.connect(function(error, status) {
@@ -60,7 +116,8 @@ function configure(config) {
     const options = {
         component: process.env.log4js_logmet_component || config.options && config.options.component,
         logging_token: process.env.log4js_logmet_logging_token || config.options && config.options.logging_token,
-        space_id: process.env.log4js_logmet_space_id || config.options && config.options.space_id
+        space_id: process.env.log4js_logmet_space_id || config.options && config.options.space_id,
+        event_map: (config.options && config.options.eventMap) || defaultEventMap
     };
 
     const tlsOpts = {