add synchronous scope manager

ext/scopes.d.ts

@@ -2,6 +2,7 @@ declare const scopes: {
   ASYNC_RESOURCE: 'async_resource',
   ASYNC_LOCAL_STORAGE: 'async_local_storage',
   ASYNC_HOOKS: 'async_hooks'
+  SYNC: 'sync'
   NOOP: 'noop'
 }
 

ext/scopes.js

@@ -4,5 +4,6 @@ module.exports = {
   ASYNC_RESOURCE: 'async_resource',
   ASYNC_LOCAL_STORAGE: 'async_local_storage',
   ASYNC_HOOKS: 'async_hooks',
+  SYNC: 'sync',
   NOOP: 'noop'
 }

index.d.ts

@@ -401,7 +401,7 @@ export declare interface TracerOptions {
    * implementation for the runtime. Only change this if you know what you are
    * doing.
    */
-  scope?: 'async_hooks' | 'async_local_storage' | 'async_resource' | 'noop'
+  scope?: 'async_hooks' | 'async_local_storage' | 'async_resource' | 'sync' | 'noop'
 
   /**
    * Whether to report the hostname of the service host. This is used when the agent is deployed on a different host and cannot determine the hostname automatically.

packages/dd-trace/src/scope.js

@@ -13,6 +13,8 @@ module.exports = name => {
 
   if (name === NOOP) {
     Scope = require('./scope/base')
+  } else if (name === scopes.SYNC) {
+    Scope = require('./scope/sync')
   } else if (name === scopes.ASYNC_LOCAL_STORAGE) {
     Scope = require('./scope/async_local_storage')
   } else if (name === scopes.ASYNC_RESOURCE || (!name && hasJavaScriptAsyncHooks)) {

packages/dd-trace/src/scope/sync.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const Base = require('./base')
+
+class Scope extends Base {
+  constructor () {
+    super()
+
+    this._stack = []
+    this._current = null
+  }
+
+  _active () {
+    return this._current || null
+  }
+
+  _activate (span, callback) {
+    this._stack.push(this._current)
+    this._current = span
+
+    try {
+      return callback()
+    } finally {
+      this._current = this._stack.pop()
+    }
+  }
+}
+
+module.exports = Scope

packages/dd-trace/test/scope/sync.spec.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const Scope = require('../../src/scope/sync')
+const testScope = require('./test')
+
+describe('Scope (sync)', () => {
+  let scope
+
+  beforeEach(() => {
+    scope = new Scope()
+  })
+
+  testScope(() => scope, false)
+})

packages/dd-trace/test/scope/test.js

@@ -2,7 +2,7 @@
 
 const Span = require('opentracing').Span
 
-module.exports = factory => {
+module.exports = (factory, supportsAsync = true) => {
   let scope
   let span
 
@@ -44,72 +44,74 @@ module.exports = factory => {
       expect(scope.active()).to.be.null
     })
 
-    it('should persist through setTimeout', done => {
-      scope.activate(span, () => {
-        setTimeout(() => {
-          expect(scope.active()).to.equal(span)
-          done()
-        }, 0)
+    if (supportsAsync) {
+      it('should persist through setTimeout', done => {
+        scope.activate(span, () => {
+          setTimeout(() => {
+            expect(scope.active()).to.equal(span)
+            done()
+          }, 0)
+        })
       })
-    })
 
-    it('should persist through setImmediate', done => {
-      scope.activate(span, () => {
-        setImmediate(() => {
-          expect(scope.active()).to.equal(span)
-          done()
-        }, 0)
+      it('should persist through setImmediate', done => {
+        scope.activate(span, () => {
+          setImmediate(() => {
+            expect(scope.active()).to.equal(span)
+            done()
+          }, 0)
+        })
       })
-    })
 
-    it('should persist through setInterval', done => {
-      scope.activate(span, () => {
-        let shouldReturn = false
-
-        const timer = setInterval(() => {
-          expect(scope.active()).to.equal(span)
+      it('should persist through setInterval', done => {
+        scope.activate(span, () => {
+          let shouldReturn = false
 
-          if (shouldReturn) {
-            clearInterval(timer)
-            return done()
-          }
+          const timer = setInterval(() => {
+            expect(scope.active()).to.equal(span)
 
-          shouldReturn = true
-        }, 0)
-      })
-    })
+            if (shouldReturn) {
+              clearInterval(timer)
+              return done()
+            }
 
-    if (global.process && global.process.nextTick) {
-      it('should persist through process.nextTick', done => {
-        scope.activate(span, () => {
-          process.nextTick(() => {
-            expect(scope.active()).to.equal(span)
-            done()
+            shouldReturn = true
           }, 0)
         })
       })
-    }
 
-    it('should persist through promises', () => {
-      const promise = Promise.resolve()
+      if (global.process && global.process.nextTick) {
+        it('should persist through process.nextTick', done => {
+          scope.activate(span, () => {
+            process.nextTick(() => {
+              expect(scope.active()).to.equal(span)
+              done()
+            }, 0)
+          })
+        })
+      }
 
-      return scope.activate(span, () => {
-        return promise.then(() => {
-          expect(scope.active()).to.equal(span)
+      it('should persist through promises', () => {
+        const promise = Promise.resolve()
+
+        return scope.activate(span, () => {
+          return promise.then(() => {
+            expect(scope.active()).to.equal(span)
+          })
         })
       })
-    })
 
-    it('should handle concurrency', done => {
-      scope.activate(span, () => {
-        setImmediate(() => {
-          expect(scope.active()).to.equal(span)
-          done()
+      it('should handle concurrency', done => {
+        scope.activate(span, () => {
+          setImmediate(() => {
+            expect(scope.active()).to.equal(span)
+            done()
+          })
         })
-      })
 
-      scope.activate(span, () => {})
-    })
+        scope.activate(span, () => {})
+      })
+    }
 
     it('should handle errors', () => {
       const error = new Error('boom')