Adding foundation for dtrace probe support

lib/dtrace.js

@@ -0,0 +1,66 @@
+// Load modules
+
+var Utils = require('./utils');
+// dtrace-provider loaded inline when installed
+
+
+// Declare internals
+
+var internals = {};
+
+
+internals.probes = {
+    'pre.start': ['char *'],
+    'pre.end': ['char *', 'json']
+};
+
+module.exports = internals.DTrace = function (name) {
+
+    Utils.assert(this.constructor === internals.DTrace, 'DTrace must be instantiated using new');
+
+    if (!internals.DTrace.isInstalled()) {
+        this.report = function () {};
+        return;
+    }
+
+    var dtrace = new internals.DTrace.Provider(name);
+    this._probes = {};
+    var keys = Object.keys(internals.probes);
+    for (var i = 0, il = keys.length; i < il; ++i) {
+        var key = keys[i];
+        var probe = dtrace.addProbe.apply(dtrace, [key].concat(internals.probes[key]));
+        this._probes[key] = probe;
+    }
+
+    dtrace.enable();
+};
+
+
+internals.DTrace.prototype.report = function (key/* arg1, arg2 */) {
+
+    var args = arguments;
+    this._probes[key].fire(function () {
+
+        return Array.prototype.slice.call(args, 1);
+    });
+};
+
+
+internals.DTrace.isInstalled = function () {
+
+    var result = false;
+    try {
+        result = !!require.resolve('dtrace-provider');
+    }
+    catch (err) {}
+
+    internals.DTrace.isInstalled = function () {
+
+        return result;
+    };
+
+    return result;
+};
+
+
+internals.DTrace.Provider = internals.DTrace.isInstalled() && require('dtrace-provider').DTraceProvider;

lib/request.js

@@ -436,11 +436,13 @@ internals.Request.bindPre = function (pre) {
                     request.pre[pre.assign] = result;
                 }
 
+                request.server._dtrace.report('pre.end', pre.assign, result);
                 return exit();
             };
 
             enter(function () {
 
+                request.server._dtrace.report('pre.start', pre.assign);
                 pre.method(request, finalize);
             });
         });

lib/server.js

@@ -9,6 +9,7 @@ var Boom = require('boom');
 var Catbox = require('catbox');
 var Auth = require('./auth');
 var Defaults = require('./defaults');
+var DTrace = require('./dtrace');
 var Request = require('./request');
 var Router = require('./router');
 var Schema = require('./schema');
@@ -83,6 +84,7 @@ module.exports = internals.Server = function (/* host, port, options */) {
     this._router = new Router(this);
     this._ext = new Ext();
     this._stateDefinitions = {};
+    this._dtrace = new DTrace('' + this._port);
 
     if (args.pack) {
         this.pack = args.pack;
@@ -246,7 +248,7 @@ internals.Server.prototype._stop = function (options, callback) {
     }, options.timeout);
 
     self.listener.close(function () {
-        
+
         self.listener.removeAllListeners();
         clearTimeout(timeoutId);
         callback();

test/integration/dtrace.js

@@ -0,0 +1,119 @@
+// Load modules
+
+var Lab = require('lab');
+var Hapi = require('../..');
+var DTrace = require('../../lib/dtrace');
+
+
+// Declare internals
+
+var internals = {};
+
+
+// Test shortcuts
+
+var expect = Lab.expect;
+var before = Lab.before;
+var after = Lab.after;
+var describe = Lab.experiment;
+var it = Lab.test;
+
+
+describe('DTrace', function () {
+
+    it('doesn\'t fire probes when dtrace provider isn\'t installed', function (done) {
+
+        var provider = DTrace.Provider;
+        var isInstalled = DTrace.isInstalled;
+        DTrace.Provider = function () {
+
+            return {
+                enable: function () {},
+                addProbe: function () {
+
+                    return {
+                        fire: function (fn) {
+
+                            expect(fn).to.not.exist;
+                        }
+                    };
+                }
+            };
+        };
+        DTrace.isInstalled = function () {
+
+            return false;
+        };
+
+        var server = new Hapi.Server();
+
+
+        var pre1 = function (request, next) {
+
+            next('Hello');
+        };
+
+        server.route({ method: '*', path: '/', config: {
+            handler: function () {
+
+                this.reply('OK');
+            },
+            pre: [
+                { method: pre1, assign: 'm1' }
+            ]
+        }});
+
+        server.inject({ url: '/' }, function () {
+
+            DTrace.Provider = provider;
+            DTrace.isInstalled = isInstalled;
+            done();
+        });
+    });
+
+    it('fires correct probe on prerequisites when dtrace-provider is installed', function (done) {
+
+        var provider = DTrace.Provider;
+        var isInstalled = DTrace.isInstalled;
+        DTrace.Provider = function () {
+
+            return {
+                enable: function () {},
+                addProbe: function () {
+
+                    return {
+                        fire: function (fn) {
+
+                            expect(fn()).to.contain('m1');
+                            DTrace.Provider = provider;
+                            DTrace.isInstalled = isInstalled;
+                            done();
+                        }
+                    };
+                }
+            };
+        };
+        DTrace.isInstalled = function () {
+
+            return true;
+        };
+
+        var server = new Hapi.Server();
+        var pre1 = function (request, next) {
+
+            next('Hello');
+        };
+
+        server.route({ method: '*', path: '/', config: {
+            handler: function () {
+
+                this.reply('OK');
+            },
+            pre: [
+                { method: pre1, assign: 'm1' }
+            ]
+        }});
+
+        server.inject({ url: '/' }, function () {});
+    });
+});