Centralize createSpan code into core-tracing, update the minimum need…

…ed for core-tracing to compile and test

sdk/core/core-tracing/package.json

@@ -88,6 +88,8 @@
     "rollup-plugin-visualizer": "^4.0.4",
     "typescript": "4.1.2",
     "util": "^0.12.1",
-    "typedoc": "0.15.2"
+    "typedoc": "0.15.2",
+    "sinon": "^9.0.2",
+    "@types/sinon": "^9.0.4"
   }
 }

sdk/core/core-tracing/review/core-tracing.api.md

@@ -16,6 +16,16 @@ import { TimeInput } from '@opentelemetry/api';
 import { Tracer } from '@opentelemetry/api';
 import { TracerBase } from '@opencensus/web-types';
 
+// Warning: (ae-forgotten-export) The symbol "SpanConfig" needs to be exported by the entry point index.d.ts
+//
+// @public
+export function createSpanFunction({ packagePrefix, namespace }: SpanConfig): <T extends {
+    tracingOptions?: OperationTracingOptionsLike | undefined;
+}>(operationName: string, operationOptions: T) => {
+    span: Span;
+    updatedOptions: T;
+};
+
 // @public
 export function extractSpanContextFromTraceParentHeader(traceParentHeader: string): SpanContext | undefined;
 
@@ -79,6 +89,11 @@ export interface OperationTracingOptions {
     spanOptions?: SpanOptions;
 }
 
+// @public
+export interface OperationTracingOptionsLike {
+    spanOptions?: OTSpanOptions;
+}
+
 export { OTSpanContext }
 
 export { OTSpanOptions }

sdk/core/core-http/src/createSpan.ts → sdk/core/core-tracing/src/createSpan.ts

@@ -2,13 +2,22 @@
 // Licensed under the MIT license.
 
 import { Span, SpanOptions, SpanKind } from "@opentelemetry/api";
-import { getTracer } from "@azure/core-tracing";
-import { OperationOptions } from "./coreHttp";
+import { getTracer } from "../src/tracerProxy";
 
-type OperationTracingOptions = OperationOptions["tracingOptions"];
+/**
+ * Tracing options to set on an operation.
+ * @hidden
+ */
+export interface OperationTracingOptionsLike {
+  /**
+   * OpenTelemetry SpanOptions used to create a span when tracing is enabled.
+   */
+  spanOptions?: SpanOptions;
+}
 
 /**
  * Configuration for creating a new Tracing Span
+ * @hidden
  */
 export interface SpanConfig {
   /**
@@ -28,7 +37,7 @@ export interface SpanConfig {
  * @param tracingOptions - The options for the underlying http request.
  */
 export function createSpanFunction({ packagePrefix, namespace }: SpanConfig) {
-  return function<T extends OperationOptions>(
+  return function<T extends { tracingOptions?: OperationTracingOptionsLike }>(
     operationName: string,
     operationOptions: T
   ): { span: Span; updatedOptions: T } {
@@ -55,9 +64,10 @@ export function createSpanFunction({ packagePrefix, namespace }: SpanConfig) {
       };
     }
 
-    const newTracingOptions: OperationTracingOptions = {
+    const newTracingOptions: OperationTracingOptionsLike = {
       ...tracingOptions,
       spanOptions: newSpanOptions
+      // TODO: .context soon.
     };
 
     const newOperationOptions: T = {

sdk/core/core-tracing/src/index.ts

@@ -10,6 +10,7 @@ export { OpenCensusSpanWrapper } from "./tracers/opencensus/openCensusSpanWrappe
 export { OpenCensusTracerWrapper } from "./tracers/opencensus/openCensusTracerWrapper";
 export { TestTracer, SpanGraph, SpanGraphNode } from "./tracers/test/testTracer";
 export { TestSpan } from "./tracers/test/testSpan";
+export { OperationTracingOptionsLike, createSpanFunction } from "./createSpan";
 
 // Shared interfaces
 export { SpanContext, SpanOptions, TraceFlags } from "./interfaces";

sdk/core/core-http/test/createSpan.spec.ts → sdk/core/core-tracing/test/createSpan.spec.ts

@@ -1,14 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import { assert } from "chai";
-import { SpanKind, TraceFlags } from "@opentelemetry/api";
-import { setTracer, TestSpan, TestTracer } from "@azure/core-tracing";
+import * as assert from "assert";
 import sinon from "sinon";
+import { SpanKind, TraceFlags } from "@opentelemetry/api";
 
-import { OperationOptions } from "../src/coreHttp";
+import { setTracer } from "../src/tracerProxy";
+import { TestTracer } from "../src/tracers/test/testTracer";
+import { TestSpan } from "../src/tracers/test/testSpan";
+import { createSpanFunction, OperationTracingOptionsLike } from "../src/createSpan";
 
-import { createSpanFunction } from "../src/createSpan";
 const createSpan = createSpanFunction({ namespace: "Microsoft.Test", packagePrefix: "Azure.Test" });
 
 describe("createSpan", () => {
@@ -24,21 +25,44 @@ describe("createSpan", () => {
     const startSpanStub = sinon.stub(tracer, "startSpan");
     startSpanStub.returns(testSpan);
     setTracer(tracer);
-    const { span } = createSpan("testMethod", {});
+    const { span, updatedOptions } = createSpan("testMethod", {
+      tracingOptions: ({
+        // validate that we dumbly just copy any fields (this makes future upgrades easier)
+        someOtherField: "someOtherFieldValue",
+        context: { someContext: "some Context" }
+      } as OperationTracingOptionsLike) as any
+    });
     assert.strictEqual(span, testSpan, "Should return mocked span");
-    assert.isTrue(startSpanStub.calledOnce);
+    assert.ok(startSpanStub.calledOnce);
     const [name, options] = startSpanStub.firstCall.args;
     assert.strictEqual(name, "Azure.Test.testMethod");
     assert.deepEqual(options, { kind: SpanKind.INTERNAL });
-    assert.isTrue(setAttributeSpy.calledOnceWithExactly("az.namespace", "Microsoft.Test"));
+    assert.ok(setAttributeSpy.calledOnceWithExactly("az.namespace", "Microsoft.Test"));
+
+    assert.deepEqual(updatedOptions.tracingOptions, {
+      someOtherField: "someOtherFieldValue",
+      // TODO: note, this will be incorrect (and break) when we get to the next opentelemetry
+      // upgrade (and that'll be a good reminder to fix it)
+      context: { someContext: "some Context" },
+      spanOptions: {
+        attributes: {
+          'az.namespace': 'Microsoft.Test'
+        },
+        parent: {
+          spanId: '',
+          traceFlags: 0,
+          traceId: ''
+        }
+      }
+    });
   });
 
   it("returns updated SpanOptions", () => {
-    const options: OperationOptions = {};
+    const options: { tracingOptions?: OperationTracingOptionsLike } = {};
     const { span, updatedOptions } = createSpan("testMethod", options);
-    assert.isEmpty(options, "original options should not be modified");
+    assert.deepStrictEqual(options, {}, "original options should not be modified");
     assert.notStrictEqual(updatedOptions, options, "should return new object");
-    const expected: OperationOptions = {
+    const expected: { tracingOptions?: OperationTracingOptionsLike } = {
       tracingOptions: {
         spanOptions: {
           parent: span.context(),
@@ -52,7 +76,7 @@ describe("createSpan", () => {
   });
 
   it("preserves existing attributes", () => {
-    const options: OperationOptions = {
+    const options: { tracingOptions?: OperationTracingOptionsLike } = {
       tracingOptions: {
         spanOptions: {
           attributes: {
@@ -63,7 +87,7 @@ describe("createSpan", () => {
     };
     const { span, updatedOptions } = createSpan("testMethod", options);
     assert.notStrictEqual(updatedOptions, options, "should return new object");
-    const expected: OperationOptions = {
+    const expected: { tracingOptions?: OperationTracingOptionsLike } = {
       tracingOptions: {
         spanOptions: {
           parent: span.context(),