@forter/georg

georg

georg (named after Georg Friedrich Bernhard Riemann) is a nodejs library that acts as an in-process riemann agent. The library can send nodejs specific and application specific metrics to riemann. Riemann (riemann.io) is a monitoring event hub, that can process event streams and forward to various data stores and visualization products.

Installation

npm install georg

Initialization

georg must be initialized once in the code. The initialization method receives the address and port of the riemann server, and a list of boolean variables, each representing a feature to be activated.

var georg = require('georg');
georg.init({

  host: '127.0.0.1',
  port: 5555,

  service: "my-service-name",

  //optional logger for logging mundane (i.e. non-exception related) events
  //currently, this only logs information about the status of the riemann connection
  logger: function(message) {
    process.stdout.write(message);
  }

  exceptions: {
    killTimeoutMS: 1000,
    //optional logger for integration with winston logging framework
    logger: function(err,done) {
      logger.error("Unhandled exception: %s", err.stack, done);
    }
    //optional function to suppress exception-exit, exception-log and exception-sendToRiemann. You can use any of the functions.
    suppressor : function(ex) {
        return new georg.Suppressor().suppressLog().suppressExit().suppressRiemann();
    }
  },
  latencies: {}
});

Unhandled Exceptions

georg supports detection of unhandled exceptions and sending them to riemann. The JSON contains a kill timeout, a logging function (which receives an exception and a callback. the function logs the exception and calls the callback), and a suppress function ( which receives an exception, and returns a

Latency Recording

georg supports recording service latencies and monitoring them via riemann. The feature variable name is 'latencies'. Record each latency using the startLatency and endLatency method:

var x = georg.startLatency(serviceName);
longLatencyFunction();
x.checkpointLatency(x, "afterFirstFunctionLatency")
longLatencyFunction();
var latency = georg.endLatency(x);

riemann.config includes an example of triggering an alert based on statistics of latency events and latency threshold

Custom Events

georg supports sending custom events to riemann. The feature variable name id 'events' Send an event using the sendEvent method:

georg.init({service: "worker-manager-instance",
    host: "127.0.0.1",
    port: 5555});
georg.sendEvent({
    description: 'number of workers in the system'
    metric: 0
    tags: ['critical', 'availability']})

Additional Features

• georg auto-reconnects with riemann if a network failure occurred.

Release History

• 0.15 Added logger that isn't necessarily related to exceptions.
• 0.14 First version where we started documenting our own version numbers. Contains everything below.

Release History for wherever this code originally came from

• 0.2.30 Return latency from endLatency method
• 0.2.16 Changed reporting of 'unexpected-exception' to 'exception'
• 0.2.15 Current Version. Added custom attributes sending.
• 0.2.0 Added latency recording feature, minor bug fixes.
• 0.1.0 Support unhandled exceptions and reconnect.