Refactoring: rename class and file Trace to RootSpan, add TraceConfig interface, add TraceContext interface

Author: silva-fabio

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

@@ -18,16 +18,16 @@ 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 } from '../types/tracetypes'
 
-export class Trace extends TraceBaseModel {
+export class RootSpan extends SpanBaseModel {
 
     private _spans: Span[];
     private _traceId: string;
 
-    constructor() {
+    constructor(context?: TraceContext ) {
         super()
-        this.setId((uuid.v4().split('-').join('')));
+        this._traceId = context&&context.traceId?context.traceId:(uuid.v4().split('-').join(''));
         this._spans = [];
     }
 
@@ -41,7 +41,7 @@ export class Trace extends TraceBaseModel {
 
     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 +53,14 @@ 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 })
     }
 
     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: SpanBaseModel;
+  //  private _parentSpanId: string;
 
-    constructor(trace: TraceBaseModel) {
+    constructor(root: SpanBaseModel) {
         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,8 +50,8 @@ export class Span extends TraceBaseModel {
         super.start();
         debug('starting span  %o',
             {
-                id: this.id,
                 traceId: this.traceId,
+                spanId: this.id,
                 name: this.name
             })
     }
@@ -61,7 +61,7 @@ export class Span extends TraceBaseModel {
         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,56 +15,80 @@
  */
 
 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 { Exporter, NoopExporter } from '../../exporters/exporter'
+import { TraceContext } from '../types/tracetypes';
 
 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 {
 
     readonly PLUGINS = ['http', 'https', 'mongodb-core', 'express'];
 
     private _active: boolean;
     private contextManager: cls.Namespace;
     private exporter: Exporter;
+    private config: TracerConfig;
 
     //TODO: temp solution 
-    private endedTraces: Trace[] = [];
+    private endedTraces: RootSpan[] = [];
 
     constructor() {
         this._active = false;
         this.contextManager = cls.createNamespace();
     }
 
-    public get currentTrace(): Trace {
+    public get currentTrace(): RootSpan {
         return this.contextManager.get('trace');
     }
 
-    private setCurrentTrace(trace: Trace) {
+    private setCurrentTrace(trace: RootSpan) {
         this.contextManager.set('trace', trace);
     }
 
-    public start(config?: Object): Tracer {
+    public start(config?: TracerConfig): Tracer {
         this._active = true;
+        this.config = config || defaultConfig;
+        this.exporter = this.config.exporter;
         return this;
     }
 
+    public stop() {
+        this._active = false;
+    }
+
     public get active(): boolean {
         return this._active;
     }
 
-    public startTrace(): Trace {
-        let newTrace = new Trace();
+    public startRootSpan(context?: TraceContext): RootSpan {
+        let newTrace = new RootSpan(context);
         this.setCurrentTrace(newTrace);
         newTrace.start();
         return newTrace;
     }
 
-    public endTrace(): void {
+    //TODO: review
+    public runInContex<T>(fn: Func<T>): T {
+        return this.contextManager.runAndReturn (fn)
+    }
+
+    public endRootSpan(): void {
         if (!this.currentTrace) {
             return debug('cannot end trace - no active trace found')
         }
@@ -93,7 +117,7 @@ export class Tracer {
         this.exporter.emit(this.currentTrace);
     }*/
 
-    private addEndedTrace(trace: Trace) {
+    private addEndedTrace(trace: RootSpan) {
         if (this.active) {
             //TODO: temp solution
             //this.endedTraces.push(trace);

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

@@ -21,22 +21,28 @@ 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 abstract class SpanBaseModel {
 
-    private _className: string;
+    protected _className: string;
     private _id: string;
     private clock: Clock;
     //------
     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 +119,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(),

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

@@ -15,23 +15,23 @@
  */
 
 import { Span } from '../src/trace/model/span';
-import { Trace } from '../src/trace/model/trace';
+import { RootSpan } from '../src/trace/model/rootspan';
 
 var assert = require('assert');
 
 describe('Span creation', function () {
 
-    let trace;
+    let root;
     let span;
 
     before(function () {
-        trace = new Trace();
-        span = trace.startSpan('spanName', 'typeSpan');
+        root = new RootSpan();
+        span = root.startSpan('spanName', 'typeSpan');
     });
 
     it('should create an span on the trace', function () {
-        assert.ok(trace instanceof Trace);
-        span = trace.startSpan('spanName', 'typeSpan');
+        assert.ok(root instanceof RootSpan);
+        span = root.startSpan('spanName', 'typeSpan');
         assert.ok(span instanceof Span);
         assert.ok(span.id);
     });
@@ -49,12 +49,12 @@ describe('Span creation', function () {
 
 describe('Span checking creation', function () {
 
-    let trace;
+    let root;
     let span;
 
     before(function () {
-        trace = new Trace();
-        span = trace.startSpan('spanName', 'typeSpan');
+        root = new RootSpan();
+        span = root.startSpan('spanName', 'typeSpan');
     });
 
     it('should not start span after it ended', function () {
@@ -65,16 +65,16 @@ describe('Span checking creation', function () {
 
 describe('Span data', function () {
 
-    let trace;
+    let root;
 
     before(function () {
-        trace = new Trace();
+        root = new RootSpan();
     });
 
     it('generates unique numeric span ID strings', function () {
         var numberOfSpansToCheck = 5;
         for (var i = 0; i < numberOfSpansToCheck; i++) {
-            var span = trace.startSpan('spanName' + i, 'typeSpan' + i);
+            var span = root.startSpan('spanName' + i, 'typeSpan' + i);
             var spanId = span.id;
             assert.ok(typeof spanId === 'string');
             assert.ok(spanId.match(/\d+/));