JSPM

Log and track all traffic and errors in a node.js application. Tracks uncaught promise rejection errors as well as any errors detected by specifc configuration.

The script can be set up directly in the main node.js file where you create your server, however since the configuration give you a lot of options and is very detailed we recommend putting it in a separate configure.js file.

1. Install grackle_trackling

npm i grackle_tracking@latest --save

2. create a new configuration file for the script configure.js

const grackle_tracking = require("grackle_tracking");
const config = require('./config');

grackle_tracking.configure({
  errors: {
    log_to_console: true, // errors less frequent - can log to server
    log_to_database: {
      log: true, /// for consistency, however parent could be null instead of log: false
      connection: {
        url: config.TRACKING_DB, // REQUIRED
        driver: grackle_tracking.types.drivers.mogodb, //REQUIRED
        field_mapping: {
          //url, user_id, body, referring ip address, method
          "Errors.request_url": grackle_tracking.types.request.original_url,
          "Errors.request_body": grackle_tracking.types.request.body,
          "Errors.request_method": grackle_tracking.types.request.method,
          "Errors.request_raw": grackle_tracking.types.request.full_request,
          "Errors.request_ip": grackle_tracking.types.request.ip,
          "Errors.error_full": grackle_tracking.types.error.stack_trace,
          "Errors.error_message": grackle_tracking.types.error.message,
          "Errors.breaking_error": grackle_tracking.types.error.breaking_error,
          "Errors.user_id": (request, error) => {
            if( request.hasOwnProperty('headers') && request.headers.hasOwnProperty('authorization') ) {
              try {
                  if(request.originalUrl.indexOf('eapi') !== -1) {
                    let authorization = request.headers['authorization'];
                    authorization = authorization.replace("Basic ", "")
        
                    let buff = Buffer.from(authorization, 'base64');
                    let user_name_pass_string = buff.toString('ascii').split(':');
                    
                    let username = user_name_pass_string[0];
                    var mongoose = require('mongoose');
                    mongoose.models["ExternalUsers"].findOne({username}).then((user)=>{
                      return user._id;
                    }).catch(err => {throw { message: "User does not exist." }});
                  } else {
                    let jwt = require('jsonwebtoken');
                    let config = require(__dirname + "/config.js");
                    let user = jwt.verify(request.headers['authorization'], config.secret);
                    return user.user_id;
                  }
              } catch(err) {
                console.log('Error in tracking', err);
                return null;
              }
            }
          }
        }
      }
    },
    track_caught_errors: {
      track: true, // for easy toggling between true/false, however parent can also just be left as null
      get_error_by: (response) => {
        if(typeof response === 'string') response = JSON.parse(response);
        if(!response.success) {
          return {
            message: response.data.system_error,
            stack_trace: response.error
          }
        } else {
          return false;
        }
      },
      error_message_mapping: "response.error"
    },
    on_uncaught_error: (res, grackle_error_data) => {
      res.json({
        success: false,
        error: grackle_error_data.message,
        stack_trace: grackle_error_data.stack_trace
      })
    }
  },
  traffic: {
    log_to_console: true, // don't want to blow up logs on the server
    log_to_database: {
      log_request: false, // for easy toggling between true/false, however parent can also just be left as null
      log_response: true,
      connection: {
        url: null,//config.TRACKING_DB, // REQUIRED
        driver: grackle_tracking.types.drivers.mongodb, //REQUIRED
        field_mapping: {
          //url, user_id, body, referring ip address, method
          "Traffic.url": grackle_tracking.types.request.original_url,
          "Traffic.body": grackle_tracking.types.request.body,
          "Traffic.method": grackle_tracking.types.request.method,
          "Traffic.raw": grackle_tracking.types.request.full_request,
          "Traffic.ip": grackle_tracking.types.request.ip,
          "Traffic.user_id": (request) => {
            if( request.hasOwnProperty('headers') && request.headers.hasOwnProperty('authorization') ) {
              try {
                  if(request.originalUrl.indexOf('eapi') !== -1) {
                    let authorization = request.headers['authorization'];
                    authorization = authorization.replace("Basic ", "")
        
                    let buff = Buffer.from(authorization, 'base64');
                    let user_name_pass_string = buff.toString('ascii').split(':');
                    
                    let username = user_name_pass_string[0];
                    var mongoose = require('mongoose');
                    mongoose.models["ExternalUsers"].findOne({username}).then((user)=>{
                      return user._id;
                    }).catch(err => {throw { message: "User does not exist." }});
                  } else {
                    let jwt = require('jsonwebtoken');
                    let config = require(__dirname + "/config.js");
                    let user = jwt.verify(request.headers['authorization'], config.secret);
                    return user.user_id;
                  }
              } catch(err) {
                console.log('Error in tracking', err);
                return null;
              }
            }
          }
          }
      }
    }
  }
});

exports.track = grackle_tracking.track

3. include the settup in your server.js or index.js where you create

const grackle_tracking = require('./configure');
app.use(grackle_tracking.track);