Create the rootSpan and send the trace

Author: crdgonzalezca

examples/user_interaction/client/src/App.js

@@ -97,7 +97,7 @@ class App extends React.Component {
         and calculate the amount of prime numbers in between 1 and 100000. These
         calculations are done using slow methods in order to measure the traces.</p>
 
-        <button onClick={this.handleClick}>Trace user interaction</button>
+        <button id='trace_interaction' data-ocweb-id='Trace user interaction' onClick={this.handleClick}>Trace user interaction</button>
 
         <p>The value of Pi is: <code>{this.state.pi.value}</code> and it took
         <code> {this.state.pi.time} ms </code> to compute this.</p>

packages/opencensus-web-all/package-lock.json

@@ -26,7 +26,7 @@ module.exports = (config) => {
     browsers: ['ChromeHeadless'],
     frameworks: ['jasmine'],
     reporters: ['spec', 'coverage-istanbul'],
-    files: ['test/index.ts'],
+    files: ['test/index.ts', 'node_modules/zone.js/dist/zone.js'],
     preprocessors: {'test/index.ts': ['webpack']},
     // Use webpack so that tree-shaking will remove all Node.js dependencies of
     // the `@opencensus/web-types` library, since they are not actually used in this

packages/opencensus-web-core/karma.conf.js

@@ -54,5 +54,5 @@ export * from './common/id-util';
 
 // Export global tracing instance.
 import { Tracing } from './trace/model/tracing';
-const tracing = new Tracing();
+const tracing = Tracing.instance;
 export { tracing };

packages/opencensus-web-core/src/index.ts

@@ -136,6 +136,6 @@ export class TracerBase implements webTypes.TracerBase {
 
   /** Sets the current root span. */
   setCurrentRootSpan(root: webTypes.Span) {
-    // no-op, this is only required in case of tracer with cls.
+    // no-op, this is only required in case of tracer with Zones.
   }
 }

packages/opencensus-web-core/src/trace/model/tracer-base.ts

@@ -18,25 +18,65 @@ import * as webTypes from '@opencensus/web-types';
 import { RootSpan } from './root-span';
 import { Span } from './span';
 import { TracerBase } from './tracer-base';
+import { randomTraceId } from '../../common/id-util';
 
 /** Tracer manages the current root span and trace header propagation. */
 export class Tracer extends TracerBase implements webTypes.Tracer {
-  /** Get and set the currentRootSpan of the tracer. */
-  currentRootSpan: Span = new RootSpan(this);
+  /**
+   * Gets the current root span associated to Zone.current.
+   * If the current zone does not have a root span (e.g. root zone),
+   * create a new root.
+   */
+  get currentRootSpan(): Span {
+    if (Zone.current.get('data')) {
+      return Zone.current.get('data').rootSpan;
+    }
+    return new RootSpan(this);
+  }
+
+  /**
+   * Sets the current root span to the current Zone.
+   * If the current zone does not have a 'data' property (e.g. root zone)
+   * do not set the root span.
+   */
+  set currentRootSpan(root: Span) {
+    if (Zone.current.get('data')) {
+      Zone.current.get('data')['rootSpan'] = root;
+    }
+  }
 
   /**
-   * Start a new RootSpan to currentRootSpan. Currently opencensus-web only
-   * supports a single root span at a time, so this just sets `currentRootSpan`
-   * to a new root span based on the given options and invokes the passed
-   * function. Currently no sampling decisions are propagated or made here.
+   * Creates a new Zone and start a new RootSpan to `currentRootSpan` associating
+   * the new RootSpan to the new Zone. Thus, there might be several root spans
+   * at the same time.
+   * Currently no sampling decisions are propagated or made here.
    * @param options Options for tracer instance
    * @param fn Callback function
    * @returns The callback return
    */
   startRootSpan<T>(options: webTypes.TraceOptions, fn: (root: Span) => T): T {
-    return super.startRootSpan(options, root => {
-      this.currentRootSpan = root;
-      return fn(root);
+    let traceId = randomTraceId();
+    if (options.spanContext && options.spanContext.traceId) {
+      traceId = options.spanContext.traceId;
+    }
+    // Create the new zone.
+    const zoneSpec = {
+      name: traceId,
+      properties: {
+        data: {
+          isTracingZone: true,
+          traceId,
+        },
+      },
+    };
+    const newZone = Zone.root.fork(zoneSpec);
+
+    return newZone.run(() => {
+      super.startRootSpan(options, root => {
+        // Set the currentRootSpan to the new created root span.
+        this.currentRootSpan = root;
+        return fn(root);
+      });
     });
   }
 

packages/opencensus-web-core/src/trace/model/tracer.ts

@@ -31,6 +31,14 @@ export class Tracing implements webTypes.Tracing {
   /** Whether tracing is active - always true for opencensus-web. */
   active = true;
 
+  /** Singleton instance */
+  private static singletonInstance: Tracing;
+
+  /** Gets the tracing instance. */
+  static get instance(): Tracing {
+    return this.singletonInstance || (this.singletonInstance = new this());
+  }
+
   /** Sets tracer and exporter config. */
   start(config?: webTypes.Config): webTypes.Tracing {
     this.tracer.start(config || {});

packages/opencensus-web-core/src/trace/model/tracing.ts

@@ -20,6 +20,7 @@ import { Tracer } from '../src/trace/model/tracer';
 describe('Tracer', () => {
   let tracer: Tracer;
   let listener: webTypes.SpanEventListener;
+  const options = { name: 'test' };
 
   beforeEach(() => {
     tracer = new Tracer();
@@ -30,19 +31,38 @@ describe('Tracer', () => {
     tracer.eventListeners = [listener];
   });
 
+  /** Should get/set the current RootSpan from tracer instance */
+  describe('get/set currentRootSpan()', () => {
+    it('should get the current RootSpan from tracer instance', () => {
+      tracer.startRootSpan(options, root => {
+        expect(root).toBeTruthy();
+        expect(root).toBe(tracer.currentRootSpan);
+      });
+    });
+  });
+
   describe('startRootSpan', () => {
-    it('sets current root span and calls function with it', () => {
-      const onStartFn = jasmine.createSpy('onStartFn');
+    it('should create a new RootSpan instance', () => {
+      tracer.startRootSpan(options, rootSpan => {
+        expect(rootSpan).toBeTruthy();
+      });
+    });
+    it('sets current root span', () => {
       const oldRoot = tracer.currentRootSpan;
 
-      tracer.startRootSpan({ name: 'root1' }, onStartFn);
-
-      expect(onStartFn).toHaveBeenCalled();
-      const onStartRoot = onStartFn.calls.argsFor(0)[0];
-      expect(onStartRoot.name).toBe('root1');
-      expect(onStartRoot).not.toBe(oldRoot);
-      expect(tracer.currentRootSpan).toBe(onStartRoot);
-      expect(listener.onStartSpan).toHaveBeenCalledWith(onStartRoot);
+      tracer.startRootSpan(options, rootSpan => {
+        expect(rootSpan.name).toBe('test');
+        expect(rootSpan).not.toBe(oldRoot);
+        expect(tracer.currentRootSpan).toBe(rootSpan);
+        expect(listener.onStartSpan).toHaveBeenCalledWith(rootSpan);
+      });
+    });
+    it('should create a new Zone and RootSpan an associated to the zone', () => {
+      tracer.startRootSpan(options, rootSpan => {
+        expect(rootSpan).toBeTruthy();
+        expect(Zone.current).not.toBe(Zone.root);
+        expect(Zone.current.get('data').rootSpan).toBe(rootSpan);
+      });
     });
   });
 
@@ -55,14 +75,19 @@ describe('Tracer', () => {
   });
 
   describe('startChildSpan', () => {
+    let rootSpanLocal: webTypes.Span;
+    let span: webTypes.Span;
     it('starts a child span of the current root span', () => {
-      spyOn(tracer.currentRootSpan, 'startChildSpan');
-      tracer.startChildSpan({ name: 'child1', kind: webTypes.SpanKind.CLIENT });
-      expect(tracer.currentRootSpan.startChildSpan).toHaveBeenCalledWith({
-        childOf: tracer.currentRootSpan,
-        name: 'child1',
-        kind: webTypes.SpanKind.CLIENT,
+      tracer.startRootSpan(options, rootSpan => {
+        rootSpanLocal = rootSpan;
+        span = tracer.startChildSpan({
+          name: 'child1',
+          kind: webTypes.SpanKind.CLIENT,
+        });
       });
+      expect(span).toBeTruthy();
+      expect(rootSpanLocal.numberOfChildren).toBe(1);
+      expect(rootSpanLocal.spans[0]).toBe(span);
     });
   });
 

packages/opencensus-web-core/test/test-tracer.ts

@@ -17,6 +17,5 @@
       "test/*": ["./test/*"]
     }
   },
-  "exclude": ["node_modules"],
-  "include": ["src/**/*.ts", "test/**/*.ts"]
+  "include": ["src/**/*.ts", "test/**/*.ts", "node_modules/zone.js/dist/zone.js.d.ts"]
 }

packages/opencensus-web-core/tsconfig.json

@@ -65,7 +65,8 @@
     "zone.js": "~0.9.1"
   },
   "dependencies": {
-    "@opencensus/web-core": "^0.0.2"
+    "@opencensus/web-core": "^0.0.2",
+    "@opencensus/web-exporter-ocagent": "^0.0.2"
   },
   "peerDependencies": {
     "zone.js": "~0.9.1"