Update types to commit 92edaa9 (#79)

Author: crdgonzalezca

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

@@ -22,7 +22,7 @@ import { Span } from './span';
 export class RootSpan extends Span {
   constructor(
     /** Trace associated with this root span. */
-    private readonly tracer: webTypes.Tracer,
+    private readonly tracer: webTypes.TracerBase,
     /** A trace options object to build the root span. */
     context?: webTypes.TraceOptions
   ) {

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

@@ -0,0 +1,117 @@
+/**
+ * Copyright 2019, OpenCensus Authors
+ *
+ * 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 * as webTypes from '@opencensus/web-types';
+import { NoHeadersPropagation } from '../propagation/no_headers_propagation';
+import { AlwaysSampler } from '../sampler/sampler';
+import { RootSpan } from './root-span';
+import { Span } from './span';
+
+const NO_HEADERS_PROPAGATION = new NoHeadersPropagation();
+
+/** TracerBase represents a tracer */
+export class TracerBase implements webTypes.TracerBase {
+  /**
+   * A sampler used to make trace sample decisions. In the case of
+   * opencensus-web, ultimate sampling decisions will likely be made by the
+   * server or agent/collector. So this defaults to sampling every trace.
+   */
+  sampler = new AlwaysSampler();
+
+  /** An object to log information to. Logs to the JS console by default. */
+  logger: webTypes.Logger = console;
+
+  /** Trace context header propagation behavior. */
+  propagation = NO_HEADERS_PROPAGATION;
+
+  /** Event listeners for spans managed by the tracer. */
+  eventListeners: webTypes.SpanEventListener[] = [];
+
+  /**
+   * Active status from tracer instance - this is always true for
+   * opencensus-web for code simplicity purposes.
+   */
+  active = true;
+
+  /**
+   * Trace parameter configuration. Not used by OpenCensus Web, but
+   * kept for interface compatibility with @opencensus/web-types.
+   */
+  readonly activeTraceParams = {};
+
+  /**
+   * Starts the tracer. This makes the tracer active and sets `logger` and
+   * `propagation` based on the given config. The `samplingRate` property of
+   * `config` is currently ignored.
+   */
+  start(config: webTypes.TracerConfig): this {
+    this.logger = config.logger || console;
+    this.propagation = config.propagation || NO_HEADERS_PROPAGATION;
+    return this;
+  }
+
+  /** Stops the tracer. This is a no-op with opencensus-web. */
+  stop(): this {
+    return this;
+  }
+
+  /**
+   * Start a new RootSpan to currentRootSpan. Currently no sampling decisions are propagated or made here.
+   * @param options Options for tracer instance
+   * @param fn Callback function
+   * @returns The callback return
+   */
+  startRootSpan<T>(options: webTypes.TraceOptions, fn: (root: Span) => T): T {
+    const rootSpan = new RootSpan(this, options);
+    rootSpan.start();
+    return fn(rootSpan);
+  }
+
+  /** Notifies listeners of the span start. */
+  onStartSpan(root: webTypes.Span) {
+    for (const listener of this.eventListeners) {
+      listener.onStartSpan(root);
+    }
+  }
+
+  /** Notifies listeners of the span end. */
+  onEndSpan(root: webTypes.Span) {
+    for (const listener of this.eventListeners) {
+      listener.onEndSpan(root);
+    }
+  }
+
+  registerSpanEventListener(listener: webTypes.SpanEventListener) {
+    this.eventListeners.push(listener);
+  }
+
+  unregisterSpanEventListener(listener: webTypes.SpanEventListener) {
+    this.eventListeners = this.eventListeners.filter(l => l !== listener);
+  }
+
+  /**
+   * Start a new Span.
+   * @param name SpanOptions object.
+   * @returns The new Span instance started
+   */
+  startChildSpan(options?: webTypes.SpanOptions): Span {
+    let span = new Span();
+    if (options && options.childOf) {
+      span = options.childOf as Span;
+    }
+    return span.startChildSpan(options);
+  }
+}

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

@@ -15,62 +15,15 @@
  */
 
 import * as webTypes from '@opencensus/web-types';
-import { NoHeadersPropagation } from '../propagation/no_headers_propagation';
-import { AlwaysSampler } from '../sampler/sampler';
 import { RootSpan } from './root-span';
 import { Span } from './span';
-
-const NO_HEADERS_PROPAGATION = new NoHeadersPropagation();
+import { TracerBase } from './tracer-base';
 
 /** Tracer manages the current root span and trace header propagation. */
-export class Tracer implements webTypes.Tracer {
+export class Tracer extends TracerBase implements webTypes.Tracer {
   /** Get and set the currentRootSpan of the tracer. */
   currentRootSpan: Span = new RootSpan(this);
 
-  /**
-   * A sampler used to make trace sample decisions. In the case of
-   * opencensus-web, ultimate sampling decisions will likely be made by the
-   * server or agent/collector. So this defaults to sampling every trace.
-   */
-  sampler = new AlwaysSampler();
-
-  /** An object to log information to. Logs to the JS console by default. */
-  logger: webTypes.Logger = console;
-
-  /** Trace context header propagation behavior. */
-  propagation = NO_HEADERS_PROPAGATION;
-
-  /** Event listeners for spans managed by the tracer. */
-  eventListeners: webTypes.SpanEventListener[] = [];
-
-  /**
-   * Active status from tracer instance - this is always true for
-   * opencensus-web for code simplicity purposes.
-   */
-  active = true;
-
-  /**
-   * Trace parameter configuration. Not used by OpenCensus Web, but
-   * kept for interface compatibility with @opencensus/web-types.
-   */
-  readonly activeTraceParams = {};
-
-  /**
-   * Starts the tracer. This makes the tracer active and sets `logger` and
-   * `propagation` based on the given config. The `samplingRate` property of
-   * `config` is currently ignored.
-   */
-  start(config: webTypes.TracerConfig): Tracer {
-    this.logger = config.logger || console;
-    this.propagation = config.propagation || NO_HEADERS_PROPAGATION;
-    return this;
-  }
-
-  /** Stops the tracer. This is a no-op with opencensus-web. */
-  stop(): Tracer {
-    return this;
-  }
-
   /**
    * Start a new RootSpan to currentRootSpan. Currently opencensus-web only
    * supports a single root span at a time, so this just sets `currentRootSpan`
@@ -81,33 +34,13 @@ export class Tracer implements webTypes.Tracer {
    * @returns The callback return
    */
   startRootSpan<T>(options: webTypes.TraceOptions, fn: (root: Span) => T): T {
-    this.currentRootSpan = new RootSpan(this, options);
-    this.currentRootSpan.start();
-    return fn(this.currentRootSpan);
-  }
-
-  /** Notifies listeners of the span start. */
-  onStartSpan(root: webTypes.Span) {
-    for (const listener of this.eventListeners) {
-      listener.onStartSpan(root);
-    }
-  }
-
-  /** Notifies listeners of the span end. */
-  onEndSpan(root: webTypes.Span) {
-    for (const listener of this.eventListeners) {
-      listener.onEndSpan(root);
-    }
-  }
-
-  registerSpanEventListener(listener: webTypes.SpanEventListener) {
-    this.eventListeners.push(listener);
-  }
-
-  unregisterSpanEventListener(listener: webTypes.SpanEventListener) {
-    this.eventListeners = this.eventListeners.filter(l => l !== listener);
+    return super.startRootSpan(options, root => {
+      this.currentRootSpan = root;
+      return fn(root);
+    });
   }
 
+  /** Clears the current root span. */
   clearCurrentTrace() {
     this.currentRootSpan = new RootSpan(this);
   }
@@ -118,11 +51,10 @@ export class Tracer implements webTypes.Tracer {
    * @param kind Span kind
    * @returns The new Span instance started
    */
-  startChildSpan(
-    nameOrOptions?: string | webTypes.SpanOptions,
-    kind?: webTypes.SpanKind
-  ): Span {
-    return this.currentRootSpan.startChildSpan(nameOrOptions, kind);
+  startChildSpan(options?: webTypes.SpanOptions): Span {
+    return super.startChildSpan(
+      Object.assign({ childOf: this.currentRootSpan }, options)
+    );
   }
 
   /**

packages/opencensus-web-core/test/index.ts

@@ -25,3 +25,4 @@ import './test-trace-model-util';
 import './test-tracer';
 import './test-tracing';
 import './test-url-util';
+import './test-tracer-base';

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

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2019, OpenCensus Authors
+ *
+ * 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 * as webTypes from '@opencensus/web-types';
+import { RootSpan } from '../src/trace/model/root-span';
+import { TracerBase } from '../src/trace/model/tracer-base';
+
+describe('TracerBase', () => {
+  let tracer: TracerBase;
+  let listener: webTypes.SpanEventListener;
+
+  beforeEach(() => {
+    tracer = new TracerBase();
+    listener = jasmine.createSpyObj<webTypes.SpanEventListener>('listener', [
+      'onStartSpan',
+      'onEndSpan',
+    ]);
+    tracer.eventListeners = [listener];
+  });
+
+  describe('start', () => {
+    it('sets logger and propagation based on config', () => {
+      const mockLogger = jasmine.createSpyObj<webTypes.Logger>('logger', [
+        'info',
+      ]);
+      const mockPropagation = jasmine.createSpyObj<webTypes.Propagation>(
+        'propagation',
+        ['generate']
+      );
+
+      const result = tracer.start({
+        logger: mockLogger,
+        propagation: mockPropagation,
+      });
+
+      expect(result).toBe(tracer);
+      expect(tracer.logger).toBe(mockLogger);
+      expect(tracer.propagation).toBe(mockPropagation);
+    });
+  });
+
+  describe('onStartSpan', () => {
+    it('notifies span listeners', () => {
+      const newRoot = new RootSpan(tracer);
+      tracer.onStartSpan(newRoot);
+      expect(listener.onStartSpan).toHaveBeenCalledWith(newRoot);
+    });
+  });
+
+  describe('onEndSpan', () => {
+    it('notifies span listeners', () => {
+      const newRoot = new RootSpan(tracer);
+      tracer.onEndSpan(newRoot);
+      expect(listener.onEndSpan).toHaveBeenCalledWith(newRoot);
+    });
+  });
+
+  describe('registerSpanEventListener', () => {
+    it('adds to listeners', () => {
+      const newListener = jasmine.createSpyObj<webTypes.SpanEventListener>(
+        'newListener',
+        ['onStartSpan', 'onEndSpan']
+      );
+      tracer.registerSpanEventListener(newListener);
+      expect(tracer.eventListeners).toEqual([listener, newListener]);
+    });
+  });
+
+  describe('unregisterSpanEventListener', () => {
+    it('removes from listeners', () => {
+      tracer.unregisterSpanEventListener(listener);
+      expect(tracer.eventListeners).toEqual([]);
+    });
+  });
+});