src: continuation-local-storage-glue no longer necessary

Instead this module now depends on async-listener, a polyfill
intended to replicate the addAsyncListener API Trevor Norris is
presently experimenting with adding to Node core. As it's a pure
polyfill, CLS can just load it if necessary and include all of
the CLS functionality directly in the module.

Author: Forrest L Norvell

context.js

@@ -2,6 +2,9 @@
 
 var assert = require('assert');
 
+// load polyfill if native support is unavailable
+if (!process.addAsyncListener) require('async-listener');
+
 var namespaces = process.namespaces = Object.create(null);
 
 function Namespace (name) {
@@ -84,6 +87,22 @@ Namespace.prototype.exit = function (context) {
 };
 
 module.exports = {
-  createNamespace : function (name) { return new Namespace(name); },
+  createNamespace : function (name) {
+    var namespace = new Namespace(name);
+    process.addAsyncListener(
+      function () {
+        return namespace.active;
+      },
+      {
+        before: function (context) {
+          namespace.enter(context);
+        },
+        after: function (context) {
+          namespace.exit(context);
+        }
+      }
+    );
+    return namespace;
+  },
   getNamespace : getNamespace
 };

package.json

@@ -29,5 +29,8 @@
   "license": "BSD",
   "devDependencies": {
     "tap": "~0.4.2"
+  },
+  "optionalDependencies": {
+    "async-listener": "0.0.2"
   }
 }

test/async-context.tap.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var tap             = require('tap')
+  , test            = tap.test
+  , createNamespace = require('../context.js').createNamespace
+  ;
+
+test("asynchronously propagating state with local-context-domains", function (t) {
+  t.plan(2);
+
+  var namespace = createNamespace('namespace');
+  t.ok(process.namespaces.namespace, "namespace has been created");
+
+  namespace.set('test', 1337);
+  t.equal(namespace.get('test'), 1337, "namespace is working");
+});

test/bind.tap.js

@@ -6,7 +6,7 @@ var test = tap.test;
 var EventEmitter = require('events').EventEmitter;
 
 // module under test
-var context = require('../context');
+var context = require('../context.js');
 
 // multiple contexts in use
 var tracer = context.createNamespace('tracer');

test/crypto.tap.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var tap             = require('tap')
+  , test            = tap.test
+  , createNamespace = require('../context.js').createNamespace
+  ;
+
+var crypto;
+try { crypto = require('crypto'); }
+catch (err) {}
+if (crypto) {
+
+  test("continuation-local state with crypto.randomBytes", function (t) {
+    t.plan(1);
+
+    var namespace = createNamespace('namespace');
+    namespace.set('test', 0xabad1dea);
+
+    t.test("deflate", function (t) {
+      namespace.run(function () {
+        namespace.set('test', 42);
+        crypto.randomBytes(100, function (err, bytes) {
+          if (err) throw err;
+          t.equal(namespace.get('test'), 42, "mutated state was preserved");
+          t.end();
+        });
+      });
+    });
+  });
+
+  test("continuation-local state with crypto.pseudoRandomBytes", function (t) {
+    t.plan(1);
+
+    var namespace = createNamespace('namespace');
+    namespace.set('test', 0xabad1dea);
+
+    t.test("deflate", function (t) {
+      namespace.run(function () {
+        namespace.set('test', 42);
+        crypto.pseudoRandomBytes(100, function (err, bytes) {
+          if (err) throw err;
+          t.equal(namespace.get('test'), 42, "mutated state was preserved");
+          t.end();
+        });
+      });
+    });
+  });
+
+  test("continuation-local state with crypto.pbkdf2", function (t) {
+    t.plan(1);
+
+    var namespace = createNamespace('namespace');
+    namespace.set('test', 0xabad1dea);
+
+    t.test("deflate", function (t) {
+      namespace.run(function () {
+        namespace.set('test', 42);
+        crypto.pbkdf2("s3cr3tz", "451243", 10, 40, function (err, key) {
+          if (err) throw err;
+          t.equal(namespace.get('test'), 42, "mutated state was preserved");
+          t.end();
+        });
+      });
+    });
+  });
+
+}
+

test/dns.tap.js

@@ -0,0 +1,204 @@
+'use strict';
+
+var dns             = require('dns')
+  , tap             = require('tap')
+  , test            = tap.test
+  , createNamespace = require('../context.js').createNamespace
+  ;
+
+test("continuation-local state with MakeCallback and DNS module", function (t) {
+  t.plan(11);
+
+  var namespace = createNamespace('dns');
+  namespace.set('test', 0xabad1dea);
+
+  t.test("dns.lookup", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 808);
+      t.equal(namespace.get('test'), 808, "state has been mutated");
+
+      dns.lookup('www.newrelic.com', 4, function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 808,
+                "mutated state has persisted to dns.lookup's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolve", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 909);
+      t.equal(namespace.get('test'), 909, "state has been mutated");
+
+      dns.resolve('newrelic.com', 'NS', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 909,
+                "mutated state has persisted to dns.resolve's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolve4", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 303);
+      t.equal(namespace.get('test'), 303, "state has been mutated");
+
+      dns.resolve4('www.newrelic.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 303,
+                "mutated state has persisted to dns.resolve4's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolve6", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 101);
+      t.equal(namespace.get('test'), 101, "state has been mutated");
+
+      dns.resolve6('google.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 101,
+                "mutated state has persisted to dns.resolve6's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveCname", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 212);
+      t.equal(namespace.get('test'), 212, "state has been mutated");
+
+      dns.resolveCname('mail.newrelic.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 212,
+                "mutated state has persisted to dns.resolveCname's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveMx", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 707);
+      t.equal(namespace.get('test'), 707, "state has been mutated");
+
+      dns.resolveMx('newrelic.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 707,
+                "mutated state has persisted to dns.resolveMx's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveNs", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 717);
+      t.equal(namespace.get('test'), 717, "state has been mutated");
+
+      dns.resolveNs('newrelic.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 717,
+                "mutated state has persisted to dns.resolveNs's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveTxt", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 2020);
+      t.equal(namespace.get('test'), 2020, "state has been mutated");
+
+      dns.resolveTxt('newrelic.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 2020,
+                "mutated state has persisted to dns.resolveTxt's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveSrv", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 9000);
+      t.equal(namespace.get('test'), 9000, "state has been mutated");
+
+      dns.resolveSrv('_xmpp-server._tcp.google.com', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 9000,
+                "mutated state has persisted to dns.resolveSrv's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.resolveNaptr", function (t) {
+    // dns.resolveNaptr only in Node > 0.9.x
+    if (!dns.resolveNaptr) return t.end();
+
+    namespace.run(function () {
+      namespace.set('test', 'Polysix');
+      t.equal(namespace.get('test'), 'Polysix', "state has been mutated");
+
+      dns.resolveNaptr('columbia.edu', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 'Polysix',
+                "mutated state has persisted to dns.resolveNaptr's callback");
+
+        t.end();
+      });
+    });
+  });
+
+  t.test("dns.reverse", function (t) {
+    namespace.run(function () {
+      namespace.set('test', 1000);
+      t.equal(namespace.get('test'), 1000, "state has been mutated");
+
+      dns.reverse('204.93.223.144', function (err, addresses) {
+        t.notOk(err, "lookup succeeded");
+        t.ok(addresses.length > 0, "some results were found");
+
+        t.equal(namespace.get('test'), 1000,
+                "mutated state has persisted to dns.reverse's callback");
+
+        t.end();
+      });
+    });
+  });
+});

test/error-handling.tap.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var domain = require('domain')
+  , test   = require('tap').test
+  , cls    = require('../context.js')
+  ;
+
+test("continuation-local storage glue with a throw in the continuation chain",
+     function (t) {
+  var namespace = cls.createNamespace('test');
+  namespace.run(function () {
+    var d = domain.create();
+    namespace.set('outer', true);
+
+    d.on('error', function (blerg) {
+      t.equal(blerg.message, "explicitly nonlocal exit", "got the expected exception");
+      t.notOk(namespace.get('outer'), "outer context should have been exited by throw");
+      t.notOk(namespace.get('inner'), "inner context should have been exited by throw");
+      t.equal(namespace._stack.length, 0, "should be back to global state");
+
+      t.end();
+    });
+
+    // tap is only trying to help
+    process.nextTick(d.bind(function () {
+      t.ok(namespace.get('outer'), "outer mutation worked");
+      t.notOk(namespace.get('inner'), "inner mutation hasn't happened yet");
+
+      namespace.run(function () {
+        namespace.set('inner', true);
+        throw new Error("explicitly nonlocal exit");
+      });
+    }));
+  });
+});