More refactorings, add endspan event listener, correct bug in zipkin exporter and others

Author: silva-fabio

packages/opencensus-core/src/trace/model/root-span.ts

@@ -18,15 +18,18 @@ import { Span } from './span'
 import { Clock } from '../../internal/clock'
 import * as uuid from 'uuid';
 import { debug } from '../../internal/util'
-import { SpanBaseModel, TraceContext } from '../types/tracetypes'
+import { SpanBaseModel, TraceContext, OnEndSpanEventListener } from '../types/tracetypes'
+import { Tracer } from './tracer';
 
-export class RootSpan extends SpanBaseModel {
+export class RootSpan extends SpanBaseModel implements OnEndSpanEventListener {
 
+    private tracer: Tracer;
     private _spans: Span[];
     private _traceId: string;
 
-    constructor(context?: TraceContext ) {
+    constructor(tracer: Tracer, context?: TraceContext ) {
         super()
+        this.tracer = tracer;
         this._traceId = context&&context.traceId?context.traceId:(uuid.v4().split('-').join(''));
         this._spans = [];
     }
@@ -61,6 +64,12 @@ export class RootSpan extends SpanBaseModel {
                 startTime: this.startTime,
                 endTime: this.endTime,
                 duration: this.duration })
+        
+        this.tracer.onEndSpan(this)
+    }
+
+    public onEndSpan(span: Span) {
+        debug('%s notified ending by %o',{id: span.id, name: span.name})
     }
 
     public startSpan(name: string, type: string) {

packages/opencensus-core/src/trace/model/span.ts

@@ -22,10 +22,10 @@ import { SpanBaseModel, TraceContext } from '../types/tracetypes'
 
 export class Span extends SpanBaseModel {
 
-    private root: SpanBaseModel;
+    private root: RootSpan;
   //  private _parentSpanId: string;
 
-    constructor(root: SpanBaseModel) {
+    constructor(root: RootSpan) {
         super()
         this.root = root;
     }
@@ -56,8 +56,13 @@ export class Span extends SpanBaseModel {
             })
     }
 
+    private notifyEnd () {
+        this.root.onEndSpan(this);
+    }
+
     public end(): void {
         super.end();
+        this.notifyEnd();
         debug('ending span  %o',
             {
                 spanId: this.id,

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

@@ -20,31 +20,22 @@ import { Span } from './span'
 import { debug } from '../../internal/util'
 import { Stackdriver } from '../../exporters/stackdriver/stackdriver'
 import { StackdriverOptions } from '../../exporters/stackdriver/options'
-import { Exporter, NoopExporter } from '../../exporters/exporter'
-import { TraceContext } from '../types/tracetypes';
+import { TraceContext, OnEndSpanEventListener } from '../types/tracetypes';
+import { TracerConfig, defaultConfig } from '../tracing';
 
 export type Func<T> = (...args: any[]) => T;
 
-export interface TracerConfig {
-        exporter?: Exporter,
-        sampleRate?: number;
-        ignoreUrls?:  Array<string|RegExp>;
-}
-
-export const defaultConfig: TracerConfig = {
-   exporter: new NoopExporter(),
-   sampleRate: 1.0
-}
 
-export class Tracer {
+export class Tracer implements OnEndSpanEventListener {
 
     readonly PLUGINS = ['http', 'https', 'mongodb-core', 'express'];
 
     private _active: boolean;
     private contextManager: cls.Namespace;
-    private exporter: Exporter;
     private config: TracerConfig;
 
+    //TODO: simple solution - to be rewied in future
+    private eventListeners: OnEndSpanEventListener[] = [];   
     //TODO: temp solution 
     private endedTraces: RootSpan[] = [];
 
@@ -53,18 +44,17 @@ export class Tracer {
         this.contextManager = cls.createNamespace();
     }
 
-    public get currentTrace(): RootSpan {
-        return this.contextManager.get('trace');
+    public get currentRootSpan(): RootSpan {
+        return this.contextManager.get('rootspan');
     }
 
-    private setCurrentTrace(trace: RootSpan) {
-        this.contextManager.set('trace', trace);
+    private setCurrentRootSpan(root: RootSpan) {
+        this.contextManager.set('rootspan', root);
     }
 
     public start(config?: TracerConfig): Tracer {
         this._active = true;
         this.config = config || defaultConfig;
-        this.exporter = this.config.exporter;
         return this;
     }
 
@@ -77,54 +67,57 @@ export class Tracer {
     }
 
     public startRootSpan(context?: TraceContext): RootSpan {
-        let newTrace = new RootSpan(context);
-        this.setCurrentTrace(newTrace);
+        let newTrace = new RootSpan(this, context);
+        this.setCurrentRootSpan(newTrace);
         newTrace.start();
         return newTrace;
     }
 
+
+    public onEndSpan(root:RootSpan): void {
+        if (!this.currentRootSpan) {
+            return debug('cannot end trace - no active trace found')
+        }
+        if(this.currentRootSpan != root) {
+            return debug('currentRootSpan != root on notifyEnd. Possbile implementation bug.') 
+        }
+        this.notifyEndSpan(this.currentRootSpan);
+        //this.clearCurrentTrace();
+    }
+
     //TODO: review
     public runInContex<T>(fn: Func<T>): T {
         return this.contextManager.runAndReturn (fn)
     }
+    
+    public registerEndSpanListener(listner: OnEndSpanEventListener) {
+            this.eventListeners.push(listner);
+    }
 
-    public endRootSpan(): void {
-        if (!this.currentTrace) {
-            return debug('cannot end trace - no active trace found')
+    private notifyEndSpan(root: RootSpan) {
+        if (this.active) {
+            if(this.eventListeners&&this.eventListeners.length >0) {
+                this.eventListeners.forEach((listener) => listener.onEndSpan(root))
+            }
+        } else {
+            debug ('this tracer is inactivate cant notify endspan')
         }
-        this.currentTrace.end();
-        this.addEndedTrace(this.currentTrace);
-        //this.clearCurrentTrace();
     }
 
     public clearCurrentTrace() {
-        this.setCurrentTrace(null);
+        this.setCurrentRootSpan(null);
     }
 
     public startSpan(name: string, type: string): Span {
         let newSpan: Span = null;
-        if (!this.currentTrace) {
+        if (!this.currentRootSpan) {
             debug('no current trace found - cannot start a new span');
         } else {
-            newSpan = this.currentTrace.startSpan(name, type);
+            newSpan = this.currentRootSpan.startSpan(name, type);
         }
         return newSpan;
     }
 
-    /*public endSpan(span: Span) {
-        debug('END SPAN', span);
-        span.end();
-        this.exporter.emit(this.currentTrace);
-    }*/
-
-    private addEndedTrace(trace: RootSpan) {
-        if (this.active) {
-            //TODO: temp solution
-            //this.endedTraces.push(trace);
-            this.exporter.writeTrace(this.currentTrace);
-        }
-    }
-
     public wrap<T>(fn: Func<T>): Func<T> {
         if (!this.active) {
             return fn;
@@ -145,10 +138,6 @@ export class Tracer {
         namespace.bindEmitter(emitter);
     }
 
-    public registerExporter(exporter: Exporter) {
-        this.exporter = exporter;
-    }
-
 }
 
 

packages/opencensus-core/src/trace/types/tracetypes.ts

@@ -27,12 +27,16 @@ export interface TraceContext {
         options?: number  
 }
 
+export interface OnEndSpanEventListener {
+    onEndSpan(span: SpanBaseModel): void; 
+}
+
 export abstract class SpanBaseModel {
 
     protected _className: string;
     private _id: string;
     private clock: Clock;
-    //------
+    //--Tra----
     private _remoteParent: string;
     private _name: string;
     private _started: boolean;
@@ -163,7 +167,6 @@ export abstract class SpanBaseModel {
         this._started = false;
         this._ended = true;
         this.clock.end();
-
     }
 
 

packages/opencensus-core/test/test-span.ts

@@ -16,21 +16,26 @@
 
 import { Span } from '../src/trace/model/span';
 import { RootSpan } from '../src/trace/model/rootspan';
+import { SpanBaseModel } from '../src/trace/types/tracetypes';
+import { Tracer } from '../src/trace/model/tracer';
+
 
 var assert = require('assert');
 
+let tracer = new Tracer()
+
 describe('Span creation', function () {
 
     let root;
     let span;
 
     before(function () {
-        root = new RootSpan();
+        root = new RootSpan(tracer);
         span = root.startSpan('spanName', 'typeSpan');
     });
 
     it('should create an span on the trace', function () {
-        assert.ok(root instanceof RootSpan);
+        assert.ok(root instanceof SpanBaseModel);
         span = root.startSpan('spanName', 'typeSpan');
         assert.ok(span instanceof Span);
         assert.ok(span.id);
@@ -53,7 +58,7 @@ describe('Span checking creation', function () {
     let span;
 
     before(function () {
-        root = new RootSpan();
+        root = new RootSpan(tracer);
         span = root.startSpan('spanName', 'typeSpan');
     });
 
@@ -68,7 +73,7 @@ describe('Span data', function () {
     let root;
 
     before(function () {
-        root = new RootSpan();
+        root = new RootSpan(tracer);
     });
 
     it('generates unique numeric span ID strings', function () {

packages/opencensus-core/test/test-trace.ts

@@ -16,27 +16,30 @@
 
 import { RootSpan } from '../src/trace/model/rootspan';
 import { Span } from '../src/trace/model/span';
+import { Tracer } from '../src/trace/model/tracer';
+import { SpanBaseModel } from '../src/trace/types/tracetypes';
 
 let assert = require('assert');
+let tracer = new Tracer()
 
 describe('Trace', function () {
   describe('new Trace()', function () {    
     it('should be a Trace instance', function () {
-      let root = new RootSpan();
-      assert.ok(root instanceof RootSpan);
+      let root = new RootSpan(tracer);
+      assert.ok(root instanceof SpanBaseModel);
     });
   });
 
   describe('start()', function () {
     it('the trace was started', function () {
-      let root = new RootSpan();
+      let root = new RootSpan(tracer);
       root.start();
       assert.ok(root.started);
     });
   });
 
   describe('startSpan()', function () {
-    let root = new RootSpan();
+    let root = new RootSpan(tracer);
     root.start()
     let span = root.startSpan("spanName", "spanType");
     it('should return a Span instance', function () {
@@ -50,7 +53,7 @@ describe('Trace', function () {
 
   describe('end()', function () {
     it('the trace was ended', function () {
-      let root = new RootSpan();
+      let root = new RootSpan(tracer);
       root.start()
       root.end();
       assert.ok(root.ended);
@@ -59,23 +62,23 @@ describe('Trace', function () {
 
   describe('end() before trace started', function () {
     it('the trace was not ended', function () {
-      let root = new RootSpan();
+      let root = new RootSpan(tracer);
       root.end();
       assert.ok(!root.ended);
     });
   });
 
   describe('startSpan() before trace started', function () {
     it('should return null', function () {
-      let root = new RootSpan();
+      let root = new RootSpan(tracer);
       let span = root.startSpan("spanName", "spanType");
       assert.ok(span == null);
     });
   });
 
   describe('startSpan() after trace ended', function () {
     it('should return null', function () {
-      let root = new RootSpan();
+      let root = new RootSpan(tracer);
       root.start()
       root.end();
       let span = root.startSpan("spanName", "spanType");