Sends Trace Context over http headers

Author: eduardoemery

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

@@ -27,10 +27,10 @@ export class RootSpan extends SpanBaseModel implements OnEndSpanEventListener {
     private _spans: Span[];
     private _traceId: string;
 
-    constructor(tracer: Tracer, context?: TraceContext ) {
+    constructor(tracer: Tracer, context?: TraceContext) {
         super()
         this.tracer = tracer;
-        this._traceId = context&&context.traceId?context.traceId:(uuid.v4().split('-').join(''));
+        this._traceId = context && context.traceId ? context.traceId : (uuid.v4().split('-').join(''));
         this._spans = [];
     }
 
@@ -58,24 +58,26 @@ export class RootSpan extends SpanBaseModel implements OnEndSpanEventListener {
 
         debug('ending %s  %o',
             this._className,
-            {   id: this.id,
+            {
+                id: this.id,
                 traceId: this.traceId,
                 name: this.name,
                 startTime: this.startTime,
                 endTime: this.endTime,
-                duration: this.duration })
-        
+                duration: this.duration
+            })
+
         this.tracer.onEndSpan(this)
     }
 
     public onEndSpan(span: Span) {
-        debug('%s notified ending by %o',{id: span.id, name: span.name})
+        debug('%s notified ending by %o', { id: span.id, name: span.name })
     }
 
-    public startSpan(name: string, type: string) {
+    public startSpan(name?: string, type?: string) {
         let newSpan = new Span(this);
-        newSpan.name = name
-        newSpan.type = type
+        if (name) { newSpan.name = name }
+        if (type) { newSpan.type = type }
         newSpan.start();
         this._spans.push(newSpan);
         return newSpan;

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

@@ -20,8 +20,10 @@ import { Span } from './span'
 import { debug } from '../../internal/util'
 import { Stackdriver } from '../../exporters/stackdriver/stackdriver'
 import { StackdriverOptions } from '../../exporters/stackdriver/options'
+import { Exporter } from '../../exporters/exporter'
 import { TraceContext, OnEndSpanEventListener } from '../types/tracetypes';
 import { TracerConfig, defaultConfig } from '../tracing';
+import { Buffer } from '../../exporters/buffer'
 
 export type Func<T> = (...args: any[]) => T;
 
@@ -30,12 +32,13 @@ export class Tracer implements OnEndSpanEventListener {
 
     readonly PLUGINS = ['http', 'https', 'mongodb-core', 'express'];
 
+    //public buffer: Buffer;
     private _active: boolean;
     private contextManager: cls.Namespace;
     private config: TracerConfig;
 
     //TODO: simple solution - to be rewied in future
-    private eventListeners: OnEndSpanEventListener[] = [];   
+    private eventListeners: OnEndSpanEventListener[] = [];
     //TODO: temp solution 
     private endedTraces: RootSpan[] = [];
 
@@ -58,6 +61,10 @@ export class Tracer implements OnEndSpanEventListener {
         return this;
     }
 
+    public getEventListeners(): OnEndSpanEventListener[] {
+        return this.eventListeners;
+    }
+
     public stop() {
         this._active = false;
     }
@@ -66,53 +73,61 @@ export class Tracer implements OnEndSpanEventListener {
         return this._active;
     }
 
-    public startRootSpan(context?: TraceContext): RootSpan {
+    public startRootSpan(name?: string, type?: string, context?: TraceContext): RootSpan {
         let newRootSpan = new RootSpan(this, context);
+        if (name) { newRootSpan.name = name }
+        if (type) { newRootSpan.type = type }
         this.setCurrentRootSpan(newRootSpan);
         newRootSpan.start();
         return newRootSpan;
     }
 
 
-    public onEndSpan(root:RootSpan): void {
+    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.') 
+        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)
+        return this.contextManager.runAndReturn(fn)
     }
-    
-    public registerEndSpanListener(listner: OnEndSpanEventListener) {
 
-            this.eventListeners.push(listner);
+    public registerEndSpanListener(listener: OnEndSpanEventListener) {
+        this.eventListeners.push(listener);
+        //this.buffer.registerExporter(exporter)
     }
 
+    /*public registerExporter(exporter: Exporter) {
+        //this.eventListeners.push(listner);
+        this.buffer.registerExporter(exporter)
+    }*/
+
     private notifyEndSpan(root: RootSpan) {
         if (this.active) {
-            if(this.eventListeners&&this.eventListeners.length >0) {
+            //this.buffer.onEndSpan(root);
+            if (this.eventListeners && this.eventListeners.length > 0) {
                 this.eventListeners.forEach((listener) => listener.onEndSpan(root))
             }
         } else {
-            debug ('this tracer is inactivate cant notify endspan')
+            debug('this tracer is inactivate cant notify endspan')
         }
     }
 
     public clearCurrentTrace() {
         this.setCurrentRootSpan(null);
     }
 
-    public startSpan(name: string, type: string): Span {
+    public startSpan(name?: string, type?: string): Span {
         let newSpan: Span = null;
         if (!this.currentRootSpan) {
-            debug('no current trace found - cannot start a new span');
+            debug('no current trace found - must start a new root span first');
         } else {
             newSpan = this.currentRootSpan.startSpan(name, type);
         }

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

@@ -95,7 +95,7 @@ export abstract class SpanBaseModel {
         this._type = type;
     }
 
-    public set remoteParente(remoteParent: string) {
+    public set remoteParent(remoteParent: string) {
         this._remoteParent = remoteParent;
     }