feat: more general config interface

Author: silva-fabio

packages/opencensus-core/src/exporters/buffer.ts

@@ -21,11 +21,8 @@ import {RootSpan} from '../trace/model/types';
 import {OnEndSpanEventListener} from '../trace/model/types';
 
 import {Exporter} from './types';
-import {ExporterOptions} from './types';
+import {Config, BufferConfig} from '../trace/config/types';
 
-// TODO: Implement default size based on application size
-const DEFAULT_BUFFER_SIZE = 3;
-const DEFAULT_BUFFER_TIMEOUT = 20000;  // time in milliseconds
 
 /**
  * Controls the sending of traces to exporters
@@ -42,10 +39,10 @@ export class Buffer {
   /** Indicates when the buffer timeout is running */
   private bufferTimeoutInProgress: boolean = false;
 
-  constructor(exporter: Exporter, bufferSize?: number, bufferTimeout?: number) {
-    this.bufferSize = bufferSize || DEFAULT_BUFFER_SIZE;
-    this.bufferTimeout = bufferTimeout || DEFAULT_BUFFER_TIMEOUT;
+  constructor(exporter: Exporter, config: BufferConfig) {
     this.exporter = exporter;
+    this.bufferSize = config.bufferSize;
+    this.bufferTimeout = config.bufferTimeout;
     return this;
   }
 

packages/opencensus-core/src/exporters/console-exporter.ts

@@ -14,12 +14,12 @@
  * limitations under the License.
  */
 
-import {Exporter, ExporterOptions} from '../exporters/types';
+import {Exporter, ExporterConfig} from '../exporters/types';
 import {RootSpan} from '../trace/model/types';
-
 import {Buffer} from './buffer';
 
 
+
 /** Do not send span data */
 export class NoopExporter implements Exporter {
   onEndSpan(root: RootSpan) {}
@@ -30,8 +30,8 @@ export class NoopExporter implements Exporter {
 export class ConsoleLogExporter implements Exporter {
   private buffer: Buffer;
 
-  constructor(options: ExporterOptions) {
-    this.buffer = new Buffer(this, options.bufferSize, options.bufferTimeout);
+  constructor(config: ExporterConfig) {
+    this.buffer = new Buffer(this, config);
   }
 
   onEndSpan(root: RootSpan) {

packages/opencensus-core/src/exporters/types.ts

@@ -16,15 +16,10 @@
 
 
 import {OnEndSpanEventListener, RootSpan} from '../trace/model/types';
+import { BufferConfig } from '../trace/config/types';
 
 export interface Exporter extends OnEndSpanEventListener {
   publish(rootSpans: RootSpan[]);
 }
 
-/**
- * TODO: Interface to exporters options
- */
-export interface ExporterOptions {
-  bufferSize?: number;
-  bufferTimeout?: number;
-}
+export type  ExporterConfig = BufferConfig;

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

@@ -1,18 +1,5 @@
-/**
- * Copyright 2018 Google Inc. All Rights Reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+import {Exporter} from '../../exporters/types';
+import {PluginNames} from '../instrumentation/types';
 
 /**
  * This interface represent the probability of a tracer.
@@ -49,3 +36,31 @@ export interface Sampler {
    */
   shouldSample(traceId: string): boolean;
 }
+
+/**
+ * Interface configuration for a buffer 
+ */
+export interface BufferConfig {
+  bufferSize?: number;
+  bufferTimeout?: number
+}
+
+/** Defines tracer configuration parameters */
+export interface TracerConfig {
+  /** Determines the samplin rate. Ranges from 0.0 to 1.0 */
+  samplingRate?: number;
+  /** Determines the ignored (or blacklisted) URLs */
+  ignoreUrls?: Array<string|RegExp>;
+}
+
+/** Available configuration options. */
+export interface TracingConfig {
+  logLevel?: number;
+  maximumLabelValueSize?: number;
+  plugins?: PluginNames;
+  exporter?: Exporter;
+}
+
+export type Config = TracingConfig&TracerConfig&BufferConfig;
+
+

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

@@ -23,3 +23,5 @@ export interface Plugin {
   applyPatch(module: {}, tracer: Tracer, version: string): any;
   applyUnpatch(): void;
 }
+
+export type PluginNames = {[pluginName: string]: string;};

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

@@ -51,8 +51,6 @@ export abstract class SpanBaseModel implements Span {
     type: string = null;
     /** A final status for this span */
     status: number;
-    /** A sampler that will decide if the span will be sampled or not */
-    sampler: Sampler;
 
     /** Constructs a new SpanBaseModel instance. */
     constructor() {

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

@@ -17,9 +17,10 @@
 import * as cls from '../../internal/cls';
 import {debug} from '../../internal/util';
 import {RootSpan, Span} from './types';
-import {TraceOptions, TracerConfig, defaultConfig, Tracer} from './types';
+import {TraceOptions, Tracer} from './types';
 import {OnEndSpanEventListener, Func } from './types';
-import {Sampler} from '../config/types';
+import {Sampler, TracerConfig} from '../config/types';
+import {Config} from '../config/types';
 import {SpanImpl} from './span';
 import {SamplerImpl} from '../config/sampler'
 import {RootSpanImpl} from './rootspan';
@@ -31,12 +32,14 @@ export class TracerImpl implements Tracer {
     private activeLocal: boolean;
     private contextManager: cls.Namespace;
     private config: TracerConfig;
+    sampler: Sampler;
 
     //TODO: simple solution - to be rewied in future
     private eventListenersLocal: OnEndSpanEventListener[] = [];
     //TODO: temp solution 
     private endedTraces: RootSpan[] = [];
-
+      
+ 
     samplingRate: number;
 
     constructor() {
@@ -52,9 +55,10 @@ export class TracerImpl implements Tracer {
         this.contextManager.set('rootspan', root);
     }
 
-    start(config?: TracerConfig): Tracer {
+    start(config: TracerConfig): Tracer {
         this.activeLocal = true;
-        this.config = config || defaultConfig;
+        this.config = config;
+        this.sampler = new SamplerImpl().probability(config.samplingRate);
         return this;
     }
 
@@ -72,22 +76,19 @@ export class TracerImpl implements Tracer {
 
     startRootSpan<T>(options: TraceOptions, fn: (root: RootSpan) => T): T {
         return this.contextManager.runAndReturn((root) => {
-            const newRoot = new RootSpanImpl (this, options);
-            this.currentRootSpan = newRoot;
-            if (!options) {
-                options = {} as TraceOptions;
-            }
-            // if (!options.sampler) {
-            //     options.sampler = new SamplerImpl(newRoot.traceId);
-            //     options.sampler.always();
-            // }
-            // newRoot.sampler = options.sampler;
-            newRoot.sampler = new SamplerImpl().probability(this.samplingRate);
-            if (newRoot.sampler.shouldSample(newRoot.traceId)) {
-                newRoot.start();
-                return fn(newRoot);
+            let newRoot = null;
+            if(this.active) {
+                newRoot = new RootSpanImpl (this, options);
+                this.currentRootSpan = newRoot;
+
+                if (this.sampler.shouldSample(newRoot.traceId)) {
+                    newRoot.start();
+                    return fn(newRoot);
+                }
+            } else {
+                debug("Tracer is inactive, can't start new RootSpan")
             }
-            return fn(null);
+            return fn(newRoot);
         });
     }
 

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { Sampler } from '../config/types';
+import { Sampler, Config, TracerConfig } from '../config/types';
 
 /** Default type for functions */
 export type Func<T> = (...args: any[]) => T;
@@ -55,27 +55,13 @@ export interface Link {
   attributes: Attributes
 }
 
-/** Defines tracer configuration parameters */
-export interface TracerConfig {
-  /** Determines the samplin rate. Ranges from 0.0 to 1.0 */
-  sampleRate?: number;
-  /** Determines the ignored (or blacklisted) URLs */
-  ignoreUrls?: Array<string|RegExp>;
-}
-
-/** Defines a default tracer configuration */
-export const defaultConfig: TracerConfig = {
-  sampleRate: 1.0
-};
 
 /** Defines the trace options */
 export interface TraceOptions {
   /** Root span name */
   name: string;
   /** Trace context */
   traceContext?: TraceContext;
-  /** Sampler */
-  sampler?: Sampler;
   /** Span type */
   type?: string;
 }
@@ -124,8 +110,6 @@ export interface Span  {
     messageEvents: MessageEvent[];
     /** Pointers from the current span to another span */
     links: Link[];
-    /** A sampler that will decide if the span will be sampled or not */
-    sampler: Sampler;
     /** Constructs a new SpanBaseModel instance. */
     readonly traceId: string;
     /** Indicates if span was started. */
@@ -202,10 +186,12 @@ export interface RootSpan extends Span, OnEndSpanEventListener {
 
 /** Interface for Tracer */
 export interface Tracer  {
+  
     /** Get and set the currentRootSpan to tracer instance */
     currentRootSpan: RootSpan;
-    
-    samplingRate: number;
+
+    /** A sampler that will decide if the span will be sampled or not */
+    sampler: Sampler;    
 
     /** Get the eventListeners from tracer instance */
     readonly eventListeners: OnEndSpanEventListener[];
@@ -217,7 +203,7 @@ export interface Tracer  {
      * @param config Configuration for tracer instace
      * @returns A tracer instance started
      */
-    start(config?: TracerConfig): Tracer;
+    start(config: TracerConfig): Tracer;
 
     /** Stop the tracer instance */ 
     stop(): void;

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

@@ -17,15 +17,15 @@
 import {Tracer} from './model/types';
 import {Sampler} from './config/types';
 import {Exporter} from '../exporters/types';
+import {Config} from './config/types';
 
 
 export interface Tracing {
   readonly tracer: Tracer;
   // readonly sampler: Sampler;
   readonly exporter: Exporter;
-  start(opstion?:OptionsTracing): Tracing;
+  start(config?:Config): Tracing;
   stop(): void;
+  registerExporter(exporter: Exporter): Tracing;
 }
-export interface OptionsTracing {
-  samplingRate ?: number;
-}
+

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

@@ -18,10 +18,15 @@ import * as assert from 'assert';
 import * as mocha from 'mocha';
 
 import {Span,RootSpan,Tracer} from '../src/trace/model/types';
-import { Exporter } from '../src/exporters/types';
-import { TracerImpl } from '../src/trace/model/tracer';
-import { RootSpanImpl } from '../src/trace/model/rootspan';
-import { SpanImpl } from '../src/trace/model/span';
+import {Exporter} from '../src/exporters/types';
+import {TracerImpl} from '../src/trace/model/tracer';
+import {RootSpanImpl} from '../src/trace/model/rootspan';
+import {SpanImpl} from '../src/trace/model/span';
+import {TracerConfig} from '../src/trace/config/types';
+
+ const defaultConfig: TracerConfig = {
+  samplingRate: 1
+}
 
 
 describe('Tracer', function () {
@@ -38,13 +43,13 @@ describe('Tracer', function () {
   describe('start()', function () {
     it('should return a tracer instance', function () {
       let tracer = new TracerImpl();
-      let tracerStarted = tracer.start();
+      let tracerStarted = tracer.start(defaultConfig);
       assert.ok(tracerStarted instanceof TracerImpl);
     });
 
     it('the trace was started', function () {
       let tracer = new TracerImpl();
-      let tracerStarted = tracer.start();
+      let tracerStarted = tracer.start(defaultConfig);
       assert.ok(tracerStarted.active);
     });
   });
@@ -53,7 +58,7 @@ describe('Tracer', function () {
 
     it('should start the rootSpan', function () {
       let tracer = new TracerImpl();
-      tracer.start();
+      tracer.start(defaultConfig);
       let rootSpan = tracer.startRootSpan(options, callback);
 
       assert.ok(rootSpan.started);