Update code after refactoring

Author: eduardoemery

packages/opencensus-core/src/internal/cls.ts

@@ -16,16 +16,20 @@
 
 import * as CLS from 'continuation-local-storage'
 import * as semver from 'semver'
+import { debug } from './util'
 
 export type Namespace = CLS.Namespace;
 export type Func<T> = CLS.Func<T>;
 
 const useAsyncHooks: boolean = semver.satisfies(process.version, '>=8') ;//&&
    // !!process.env.GCLOUD_TRACE_NEW_CONTEXT;
 
+debug('useAsyncHooks = %s',useAsyncHooks);
+
 const cls: typeof CLS =
     useAsyncHooks ? require('./cls-ah') : require('continuation-local-storage');
 
+
 const TRACE_NAMESPACE = 'opencensus.io';
 
 /**
@@ -48,19 +52,4 @@ export function getNamespace(): CLS.Namespace {
   return cls.getNamespace(TRACE_NAMESPACE);
 }
 
-/*
-export function set(name:string, trace:any) {
-    getNamespace().set(name, trace);
-}
 
-export function get(name:string): any {
-  // First getNamespace check is necessary in case any
-  // patched closures escaped before the agent was stopped and the
-  // namespace was destroyed.
-  var result: any = null;
-  if (getNamespace() && getNamespace().get(name)) {
-    result = getNamespace().get(name);
-  }
-  return result;
-}
-*/

…opencensus-core/src/trace/model/trace.ts …census-core/src/trace/model/root-span.tspackages/opencensus-core/src/trace/model/trace.ts renamed to packages/opencensus-core/src/trace/model/root-span.ts packages/opencensus-core/src/trace/model/trace.ts renamed to packages/opencensus-core/src/trace/model/root-span.ts

@@ -14,34 +14,37 @@
  * limitations under the License.
  */
 
-import * as uuid from 'uuid'
-
 import { Span } from './span'
 import { Clock } from '../../internal/clock'
+import * as uuid from 'uuid';
 import { debug } from '../../internal/util'
-import { TraceBaseModel } from '../types/tracetypes'
+import { SpanBaseModel, TraceContext, OnEndSpanEventListener } from '../types/tracetypes'
+import { Tracer } from './tracer';
 
-export class Trace extends TraceBaseModel {
+export class RootSpan extends SpanBaseModel implements OnEndSpanEventListener {
 
-    private _spans: Span[] = [];
+    private tracer: Tracer;
+    private _spans: Span[];
     private _traceId: string;
 
-    constructor() {
+    constructor(tracer: Tracer, context?: TraceContext ) {
         super()
-        this._traceId = (uuid.v4().split('-').join(''));
+        this.tracer = tracer;
+        this._traceId = context&&context.traceId?context.traceId:(uuid.v4().split('-').join(''));
+        this._spans = [];
     }
 
-    public get spans(): Span[] {
+    public get spans() {
         return this._spans;
     }
 
-    public get traceId(): string {
+    public get traceId() {
         return this._traceId;
     }
 
     public start() {
         super.start()
-        debug('starting trace  %o', { traceId: this.traceId })
+        debug('starting %s  %o', this._className, { traceId: this.traceId, id: this.id })
     }
 
     public end() {
@@ -53,14 +56,20 @@ export class Trace extends TraceBaseModel {
             span.truncate()
         })
 
-        debug('ending trace  %o',
-            {
-                id: this.id,
+        debug('ending %s  %o',
+            this._className,
+            {   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})
     }
 
     public startSpan(name: string, type: string) {

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

@@ -15,30 +15,30 @@
  */
 
 import { Clock } from '../../internal/clock'
-import { Trace } from './trace'
+import { RootSpan } from './rootspan'
 import { debug, randomSpanId } from '../../internal/util'
-import { TraceBaseModel } from '../types/tracetypes'
+import { SpanBaseModel, TraceContext } from '../types/tracetypes'
 
 
-export class Span extends TraceBaseModel {
+export class Span extends SpanBaseModel {
 
-    private trace: TraceBaseModel;
-    // private _parentSpanId: string;
+    private root: RootSpan;
+  //  private _parentSpanId: string;
 
-    constructor(trace: TraceBaseModel) {
+    constructor(root: RootSpan) {
         super()
-        this.trace = trace;
+        this.root = root;
     }
 
     public get traceId(): string {
-        return this.trace.traceId;
+        return this.root.traceId;
     }
 
     public get parentSpanId(): string {
-        return this.trace.id;
+        return this.root.id;
     }
 
-    public get traceContext() {
+    public get traceContext(): TraceContext {
         return {
             traceId: this.traceId.toString(),
             spanId: this.id.toString(),
@@ -50,18 +50,23 @@ export class Span extends TraceBaseModel {
         super.start();
         debug('starting span  %o',
             {
-                id: this.id,
                 traceId: this.traceId,
+                spanId: this.id,
                 name: this.name
             })
     }
 
+    private notifyEnd () {
+        this.root.onEndSpan(this);
+    }
+
     public end(): void {
         super.end();
+        this.notifyEnd();
         debug('ending span  %o',
             {
                 spanId: this.id,
-                traceId: this.trace.id,
+                traceId: this.traceId,
                 name: this.name,
                 startTime: this.startTime,
                 endTime: this.endTime,

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

@@ -15,92 +15,109 @@
  */
 
 import * as cls from '../../internal/cls'
-import { Trace } from './trace'
+import { RootSpan } from './rootspan'
 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';
 
 export type Func<T> = (...args: any[]) => T;
 
-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: Trace[] = [];
+    private endedTraces: RootSpan[] = [];
 
     constructor() {
         this._active = false;
         this.contextManager = cls.createNamespace();
     }
 
-    public get currentTrace(): Trace {
-        return this.contextManager.get('trace');
+    public get currentRootSpan(): RootSpan {
+        return this.contextManager.get('rootspan');
     }
 
-    private setCurrentTrace(trace: Trace) {
-        this.contextManager.set('trace', trace);
+    private setCurrentRootSpan(root: RootSpan) {
+        this.contextManager.set('rootspan', root);
     }
 
-    public start(config?: Object): Tracer {
+    public start(config?: TracerConfig): Tracer {
         this._active = true;
+        this.config = config || defaultConfig;
         return this;
     }
 
+    public stop() {
+        this._active = false;
+    }
+
     public get active(): boolean {
         return this._active;
     }
 
-    public startTrace(): Trace {
-        let newTrace = new Trace();
-        this.setCurrentTrace(newTrace);
+    public startRootSpan(context?: TraceContext): RootSpan {
+        let newTrace = new RootSpan(this, context);
+        this.setCurrentRootSpan(newTrace);
         newTrace.start();
         return newTrace;
     }
 
-    public endTrace(): void {
-        if (!this.currentTrace) {
+
+    public onEndSpan(root:RootSpan): void {
+        if (!this.currentRootSpan) {
             return debug('cannot end trace - no active trace found')
         }
-        this.currentTrace.end();
-        this.addEndedTrace(this.currentTrace);
+        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);
+    }
+
+    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')
+        }
+    }
+
     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: Trace) {
-        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;
@@ -121,10 +138,6 @@ export class Tracer {
         namespace.bindEmitter(emitter);
     }
 
-    public registerExporter(exporter: Exporter) {
-        this.exporter = exporter;
-    }
-
 }
 
 

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

@@ -21,22 +21,32 @@ import { debug, randomSpanId } from '../../internal/util'
 export interface MapLabels { [propName: string]: string; }
 export interface MapObjects { [propName: string]: any; }
 
-export abstract class TraceBaseModel {
+export interface TraceContext {
+        traceId: string,
+        spanId: string,
+        options?: number  
+}
+
+export interface OnEndSpanEventListener {
+    onEndSpan(span: SpanBaseModel): void; 
+}
+
+export abstract class SpanBaseModel {
 
-    private _className: string;
+    protected _className: string;
     private _id: string;
     private clock: Clock;
-    //------
+    //--Tra----
     private _remoteParent: string;
-    private attributes: MapLabels = {};
-    private annotations: MapObjects = {};
-    //messageEvents
-    //links
     private _name: string;
     private _started: boolean;
     private _ended: boolean;
     private _type: string;
     private _status: number;
+    private attributes: MapLabels = {};
+    private annotations: MapObjects = {};
+    //messageEvents
+    //links
     //TODO truncated 
     private _truncated: boolean;
 
@@ -113,7 +123,7 @@ export abstract class TraceBaseModel {
         return this.clock.duration;
     }
 
-    public get traceContext() {
+    public get traceContext(): TraceContext {
         return {
             traceId: this.traceId.toString(),
             spanId: this.id.toString(),
@@ -157,7 +167,6 @@ export abstract class TraceBaseModel {
         this._started = false;
         this._ended = true;
         this.clock.end();
-
     }