nodejitsu · Dec 31, 2013 · Dec 31, 2013 · Dec 31, 2013 · Apr 7, 2014 · Apr 7, 2014
diff --git a/.gitignore b/.gitignore
@@ -12,4 +12,6 @@ logs
 results
 
 npm-debug.log
-node_modules/
+*.sublime-project
+*.sublime-workspace
+coverage/
diff --git a/.travis.yml b/.travis.yml
@@ -0,0 +1,11 @@
+language: node_js
+node_js:
+  - "6"
+  - "5"
+  - "4"
+  - "0.12"
+before_script:
+  - "npm run build"
+after_success:
+  - "npm run coverage-report"
+  - "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls"
diff --git a/LICENSE b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (C) 2013 Nodejitsu Inc.
+Copyright (C) 2013 Charlie Robbins, Jarrett Cruger, and the Contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

diff --git a/README.md b/README.md
@@ -1,6 +1,20 @@
-# godot
+# godot2
 
-Godot is a streaming real-time event processor based on [Riemann][riemann] written in Node.js
+[![Build Status][ci-nextorigin]][travis-ci]
+[![Coverage Status][coverage-nextorigin]][coveralls]
+[![Dependency Status][dependency]][david]
+[![devDependency Status][dev-dependency]][david-dev]
+[![Downloads][downloads]][npm-package]
+
+A streaming real-time event processor based on [Riemann][riemann] written in Node.js
+
+[![NPM][npm-stats]][npm-package]
+
+![](https://i.cloudup.com/zCF6jLRpLf.png)
+
+**Godot2** is a major rewrite for Node 6 and Streams2/Streams3 syntax, similar to as suggested in [nodejitsu/godot#64](https://github.com/nodejitsu/godot/issues/64).  The async patterns and inheritance are simplified with Iced CoffeeScript.
+
+Many thanks and much credit to the original authors at Nodejitsu, [@indexzero](https://github.com/indexzero) and [@jcrugzz](https://github.com/jcrugzz).
 
 * [Usage](#usage)
 * [Events](#events)
@@ -14,77 +28,84 @@ Godot is a streaming real-time event processor based on [Riemann][riemann] writt
 Here is a simple example of a [Reactor](#reactors) server that will send an email to `user@host.com` if the [Producer](#producer) server for `app.server` fails to send a heartbeat after 60 seconds.
 
 ``` js
-  var godot = require('../lib/godot');
+var godot = require('godot2'),
+    chain = godot.dsl.chain,
+    where = godot.dsl.where,
+    expire = godot.dsl.expire,
+    email = godot.dsl.email;
 
+//
+// Reactor server which will email `user@host.com`
+// whenever any service matching /.*\/health\/heartbeat/
+// fails to check in after 60 seconds.
+//
+godot.createServer({
   //
-  // Reactor server which will email `user@host.com`
-  // whenever any service matching /.*\/health\/heartbeat/
-  // fails to check in after 60 seconds.
+  // Defaults to UDP
   //
-  godot.createServer({
-    //
-    // Defaults to UDP
-    //
-    type: 'udp',
-    reactors: [
-      godot.reactor()
-        .where('service', '*/health/heartbeat')
-        .expire(1000 * 60)
-        .email({ to: 'user@host.com' })
-    ]
-  }).listen(1337);
+  type: 'udp',
+  reactors: [
+    chain([
+      where('service', '*/health/heartbeat'),
+      expire(1000 * 60),
+      email({ to: 'user@host.com' })
+    ])
+  ]
+}).listen(1337);
 
+//
+// Producer client which sends events for the service
+// `app.server/health/heartbeat` every 15 seconds.
+//
+godot.createClient({
   //
-  // Producer client which sends events for the service
-  // `app.server/health/heartbeat` every 15 seconds.
+  // Defaults to UDP
   //
-  godot.createClient({
-    //
-    // Defaults to UDP
-    //
-    type: 'udp',
-    producers: [
-      godot.producer({
-        host: 'app.server.com',
-        service: 'app.server/health/heartbeat',
-        ttl: 1000 * 15
-      })
-    ],
-    //
-    // Add Reconnect logic that uses `back`
-    //
-    reconnect: {
-      retries: 2,
-      minDelay: 100,
-      maxDelay: 300
-    }
-  }).connect(1337);
+  type: 'udp',
+  producers: [
+    godot.producer({
+      host: 'app.server.com',
+      service: 'app.server/health/heartbeat',
+      ttl: 1000 * 15
+    })
+  ],
+  //
+  // Add Reconnect logic that uses `back`
+  //
+  reconnect: {
+    retries: 2,
+    minDelay: 100,
+    maxDelay: 300
+  }
+}).connect(1337);
 ```
 
 ## Events
 Similar to [Riemann][riemann], events in `godot` are simply JSON sent over UDP or TCP. Each event has these optional fields:
 
 ``` js
-  {
-    host:         "A hostname, e.g. 'api1', 'foo.com'"
-    service:      "e.g. 'API port 8000 reqs/sec'",
-    state:        "Any string less than 255 bytes, e.g. 'ok', 'warning', 'critical'",
-    time:         "The time of the event, in unix epoch seconds",
-    description:  "Freeform text",
-    tags:         "Freeform list of strings, e.g. ['rate', 'fooproduct', 'transient']",
-    meta:         "Freeform set of key:value pairs e.g. { 'ewma': 12345 }",
-    metric:       "A number associated with this event, e.g. the number of reqs/sec.",
-    ttl:          "A floating-point time, in seconds, that this event is considered valid for."
-  }
+{
+  host:         "A hostname, e.g. 'api1', 'foo.com'"
+  service:      "e.g. 'API port 8000 reqs/sec'",
+  state:        "Any string less than 255 bytes, e.g. 'ok', 'warning', 'critical'",
+  time:         "The time of the event, in unix epoch seconds",
+  description:  "Freeform text",
+  tags:         "Freeform list of strings, e.g. ['rate', 'fooproduct', 'transient']",
+  meta:         "Freeform set of key:value pairs e.g. { 'ewma': 12345 }",
+  metric:       "A number associated with this event, e.g. the number of reqs/sec.",
+  ttl:          "A floating-point time, in seconds, that this event is considered valid for."
+}
 ```
 
 ## Reactors
-Reactors in Godot are **readable and writable** [Stream][stream] instances which consume [Events](#events) and produce actions or aggregate data flow.
+Reactors in Godot are **readable and writable** [Stream][stream] instances which consume [Events](#events) and produce actions or aggregate data flow. In the example above you may see that when we define the array of reactors by wrapping it with a simple function. This function has a single argument that represents the data coming over the wire. This data can be piped to any `godot` stream or any Transform stream you find on NPM!
 
 ### Primitives
 
 There are several core Reactor primitives available in `godot` which can be composed to create more complex behavior:
 
+**NOTE: This list is outdated and incomplete, see [`/src/godot/reactor`](https://github.com/nextorigin/godot2/tree/nextorigin/src/godot/reactor) for the complete list.**
+
 * `.aggregate()`: Aggregates `metric` property on events
 * `.change(key {from: x, to: y})`: Emits events when the key is changed, accepts optional `from` and `to` options for more specific changes.
 * `.email(options)`: Sends an email to the specified [options][email-options].
@@ -98,44 +119,68 @@ There are several core Reactor primitives available in `godot` which can be comp
 Here are two possible rollup examples:
 
 ```js
+var godot = require('godot2'),
+    chain = godot.dsl.chain,
+    rollup = godot.dsl.rollup,
+    email = godot.dsl.email;
+
 //
 // Rolls up 10,0000 events every 5 minute interval
+// then sends them in an email
 //
-var rollup =
-  reactor()
-    .rollup(1000 * 60 * 5, 10000)
+var rollup = chain([
+  rollup(1000 * 60 * 5, 10000),
+  email({ to: 'me@nodejitsu.com' })
+]);
 
 //
 // Scaling Rollup, rolls up 10,000 events every 5min interval for 1 hour,
-// then rolls up 10,000 events every 30mins
+// then rolls up 10,000 events every 30mins and emails them out
 //
 
-var scalingRollup =
-  reactor()
-    .rollup(function (period) {
+var scalingRollup = chain([
+  rollup(function (period) {
       if(period < 12) {
         return 1000 * 60 * 5;
       }
       return 1000 * 60 * 30;
-    }, 10000)
+    }, 10000),
+  email({ to: 'me@nodejitsu.com' })
+]);
 ```
 
 ## Producers
 Producers in Godot are **readable** [Stream][stream] instances which produce [Events](#events). Events will be emitted by a given Producer every `ttl` milliseconds.
 
 ## Tests
 
-All tests are written in [vows][vows] and can be run with [npm][npm]:
+All tests are written in [mocha][mocha] and can be run with [npm][npm]:
 
+```sh
+npm test
 ```
-  npm test
-```
 
-#### Copyright (C) 2012. Nodejitsu Inc.
+#### Copyright (C) 2012. Charlie Robbins, Jarrett Cruger, and the Contributors.
+#### License: MIT
+
+_Sound Wave designed by Alessandro Suraci from the thenounproject.com_
 
 [riemann]: http://aphyr.github.com/riemann/
 [stream]: http://nodejs.org/api/stream.html
 [email-options]: https://github.com/nodejitsu/godot/tree/master/lib/godot/reactor/email.js
 [sms-options]: https://github.com/nodejitsu/godot/blob/master/lib/godot/reactor/sms.js
 [npm]: https://npmjs.org
-[vows]: http://vowsjs.org/
+[mocha]: http://mochajs.org/
+
+
+  [ci-nextorigin]: https://img.shields.io/travis/nextorigin/godot2/nextorigin.svg?style=flat-square
+  [travis-ci]: https://travis-ci.org/nextorigin/godot2
+  [coverage-nextorigin]: https://img.shields.io/coveralls/nextorigin/godot2/nextorigin.svg?style=flat-square
+  [coveralls]: https://coveralls.io/r/nextorigin/godot2
+  [dependency]: https://img.shields.io/david/nextorigin/godot2.svg?style=flat-square
+  [david]: https://david-dm.org/nextorigin/godot2
+  [dev-dependency]: https://img.shields.io/david/dev/nextorigin/godot2.svg?style=flat-square
+  [david-dev]: https://david-dm.org/nextorigin/godot2?type=dev
+  [downloads]: https://img.shields.io/npm/dm/godot2.svg?style=flat-square
+  [npm-package]: https://www.npmjs.org/package/godot2
+  [npm-stats]: https://nodei.co/npm/godot2.png?downloads=true&downloadRank=true&stars=true
diff --git a/example/client.js b/example/client.js
@@ -1,7 +1,7 @@
 /*
  * client.js :: A client example showing 2 generic producers
  *
- * (C) 2013 Nodejitsu Inc.
+ * (C) 2013, Charlie Robbins, Jarrett Cruger, and the Contributors.
  *
  */
 

diff --git a/example/server.js b/example/server.js
@@ -1,26 +1,12 @@
-/*
- * server.js :: An example server with fun reactor things happening
- *
- * (C) 2013 Nodejits Inc.
- *
- */
 
-var godot = require('../lib/godot'),
-    expire = godot.reactor().expire(5000);
+var g = require('../');
 
-//
-// This example shows a way to meausre two separate clients on the same
-// `reactor` using the power of the `by` reactor. It will create a new reactor
-// pipe-chain for each different 'service' in this case to easily assess the
-// expiration of two separate `producers`.
-//
-godot.createServer({
+g.createServer({
   type: 'tcp',
   reactors: [
-    godot.reactor()
-      .by('service',
-        expire
-        .console()
-      )
+    function (socket) {
+      socket
+        .pipe(new g.console())
+    }
   ]
 }).listen(1337);
diff --git a/lib/godot.js b/lib/godot.js
@@ -1,7 +1,7 @@
 /*
  * godot.js: Top-level include for the `godot` module.
  *
- * (C) 2012, Nodejitsu Inc.
+ * (C) 2012, Charlie Robbins, Jarrett Cruger, and the Contributors.
  *
  */
 
@@ -17,7 +17,7 @@ exports.net = require('./godot/net');
 // Expose `reactor` module for processing and
 // reacting to events.
 //
-exports.reactor  = require('./godot/reactor');
+require('./godot/reactor')(exports);
 
 //
 // ### @producer {Object}
@@ -68,4 +68,4 @@ exports.createClient = function (options) {
   options.type = options.type || 'udp';
 
   return new exports.net.Client(options);
-};
+};
diff --git a/lib/godot/common/index.js b/lib/godot/common/index.js
diff --git a/lib/godot/common/math.js b/lib/godot/common/math.js
@@ -1,7 +1,7 @@
 /*
  * math.js: Simple math functions for godot windows.
  *
- * (C) 2012, Nodejitsu Inc.
+ * (C) 2012, Charlie Robbins, Jarrett Cruger, and the Contributors.
  *
  */