Merge pull request #18 from aletorrado/master

Moved cache queue before of the store get function. (up to 2x performance boost).

lib/caching.js

@@ -1,4 +1,6 @@
 /*jshint maxcomplexity:15*/
+var domain = require('domain');
+
 var caching = function (args) {
     args = args || {};
     var self = {};
@@ -40,38 +42,43 @@ var caching = function (args) {
             ttl = undefined;
         }
 
+        if (self.queues[key]) {
+            self.queues[key].push({cb: cb, domain: process.domain});
+            return;
+        }
+
+        self.queues[key] = [{cb: cb, domain: process.domain}];
+
+        function fillCallbacks(err, data) {
+            self.queues[key].forEach(function(task) {
+                var taskDomain = task.domain || domain.create();
+                taskDomain.bind(task.cb)(err, data);
+            });
+            delete self.queues[key];
+        }
+
         self.store.get(key, function (err, result) {
             if (err && (!self.ignoreCacheErrors)) {
-                cb(err);
+                fillCallbacks(err);
             } else if (result) {
-                cb.call(cb, null, result);
+                fillCallbacks(null, result);
-            } else if (self.queues[key]) {
-                self.queues[key].push(cb);
             } else {
-                self.queues[key] = [cb];
+                domain
-
+                .create()
-                work(function () {
+                .on('error', function(err) {
-                    var work_args = Array.prototype.slice.call(arguments, 0);
+                    fillCallbacks(err);
-                    if (work_args[0]) { // assume first arg is an error
+                })
-                        self.queues[key].forEach(function (done) {
+                .bind(work)(function (err, data) {
-                            done.call(null, work_args[0]);
+                    if (err) {
-                        });
+                        fillCallbacks(err);
-                        delete self.queues[key];
                         return;
                     }
-                    // Subsequently assume second arg is result.
+                    self.store.set(key, data, ttl, function (err) {
-                    self.store.set(key, work_args[1], ttl, function (err) {
                         if (err && (!self.ignoreCacheErrors)) {
-                            self.queues[key].forEach(function (done) {
+                            fillCallbacks(err);
-                                done.call(null, err);
-                            });
                         } else {
-                            self.queues[key].forEach(function (done) {
+                            fillCallbacks(null, data);
-                                done.apply(null, work_args);
-                            });
                         }
-
-                        delete self.queues[key];
                     });
                 });
             }

lib/multi_caching.js

@@ -1,4 +1,5 @@
 var async = require('async');
+var domain = require('domain');
 
 /**
  * Module that lets you specify a hierarchy of caches.
@@ -47,9 +48,24 @@ var multi_caching = function (caches) {
             ttl = undefined;
         }
 
+        if (self.queues[key]) {
+            self.queues[key].push({cb: cb, domain: process.domain});
+            return;
+        }
+
+        self.queues[key] = [{cb: cb, domain: process.domain}];
+
+        function fillCallbacks(err, data) {
+            self.queues[key].forEach(function(task) {
+                var taskDomain = task.domain || domain.create();
+                taskDomain.bind(task.cb)(err, data);
+            });
+            delete self.queues[key];
+        }
+
         get_from_highest_priority_cache(key, function (err, result, index) {
             if (err) {
-                return cb(err);
+                return fillCallbacks(err);
             } else if (result) {
                 var caches_to_update = caches.slice(0, index);
                 var opts = {
@@ -58,38 +74,30 @@ var multi_caching = function (caches) {
                     ttl: ttl
                 };
                 set_in_multiple_caches(caches_to_update, opts, function (err) {
-                    cb(err, result);
+                    fillCallbacks(err, result);
                 });
-            } else if (self.queues[key]) {
-                self.queues[key].push(cb);
             } else {
-                self.queues[key] = [cb];
+                domain
-                work(function () {
+                .create()
-                    var work_args = Array.prototype.slice.call(arguments, 0);
+                .on('error', function(err) {
-                    if (work_args[0]) { // assume first arg is an error
+                    fillCallbacks(err);
-                        self.queues[key].forEach(function (done) {
+                })
-                            done.call(null, work_args[0]);
+                .bind(work)(function (err, data) {
-                        });
+                    if (err) {
-                        delete self.queues[key];
+                        fillCallbacks(err);
                         return;
                     }
                     var opts = {
                         key: key,
-                        value: work_args[1],
+                        value: data,
                         ttl: ttl
                     };
                     set_in_multiple_caches(caches, opts, function (err) {
                         if (err) {
-                            self.queues[key].forEach(function (done) {
+                            fillCallbacks(err);
-                                done.call(null, err);
+                        } else {
-                            });
+                            fillCallbacks(null, data);
-                            delete self.queues[key];
-                            return;
                         }
-                        self.queues[key].forEach(function (done) {
-                            done.apply(null, work_args);
-                        });
-                        delete self.queues[key];
                     });
                 });
             }

test/caching.unit.js

@@ -357,6 +357,23 @@ describe("caching", function () {
                 });
             });
 
+            context("when an error is thrown in the work function", function () {
+                var fake_error;
+
+                beforeEach(function() {
+                    fake_error = new Error(support.random.string());
+                });
+
+                it("bubbles up that error", function (done) {
+                    cache.wrap(key, function () {
+                        throw fake_error;
+                    }, ttl, function (err) {
+                        assert.equal(err, fake_error);
+                        done();
+                    });
+                });
+            });
+
             context("when store.get() calls back with an error", function () {
                 context("and ignoreCacheErrors is not set (default is false)", function () {
                     it("bubbles up that error", function (done) {

test/multi_caching.unit.js

@@ -449,6 +449,23 @@ describe("multi_caching", function () {
                 memory_store.create.restore();
             });
 
+            context("when an error is thrown in the work function", function () {
+                var fake_error;
+
+                beforeEach(function() {
+                    fake_error = new Error(support.random.string());
+                });
+
+                it("bubbles up that error", function (done) {
+                    multi_cache.wrap(key, function () {
+                        throw fake_error;
+                    }, ttl, function (err) {
+                        assert.equal(err, fake_error);
+                        done();
+                    });
+                });
+            });
+
             context("when store.get() calls back with an error", function () {
                 it("bubbles up that error", function (done) {
                     var fake_error = new Error(support.random.string());