dd-trace 4.1.1 → 4.2.0

package/LICENSE-3rdparty.csv

@@ -5,6 +5,8 @@ require,@datadog/native-iast-rewriter,Apache license 2.0,Copyright 2018 Datadog
 require,@datadog/native-iast-taint-tracking,Apache license 2.0,Copyright 2018 Datadog Inc.
 require,@datadog/pprof,Apache license 2.0,Copyright 2019 Google Inc.
 require,@datadog/sketches-js,Apache license 2.0,Copyright 2020 Datadog Inc.
+require,@opentelemetry/api,Apache license 2.0,Copyright OpenTelemetry Authors
+require,@opentelemetry/core,Apache license 2.0,Copyright OpenTelemetry Authors
 require,crypto-randomuuid,MIT,Copyright 2021 Node.js Foundation and contributors
 require,diagnostics_channel,MIT,Copyright 2021 Simon D.
 require,ignore,MIT,Copyright 2013 Kael Zhang and contributors

package/index.d.ts

@@ -2,6 +2,7 @@ import { ClientRequest, IncomingMessage, OutgoingMessage, ServerResponse } from
 import { LookupFunction } from 'net';
 import * as opentracing from "opentracing";
 import { SpanOptions } from "opentracing/lib/tracer";
+import * as otel from "@opentelemetry/api";
 
 export { SpanOptions };
 
@@ -118,6 +119,8 @@ export declare interface Tracer extends opentracing.Tracer {
   setUser (user: User): Tracer;
 
   appsec: Appsec;
+
+  TracerProvider: opentelemetry.TracerProvider;
 }
 
 export declare interface TraceOptions extends Analyzable {
@@ -1579,6 +1582,277 @@ declare namespace plugins {
   interface winston extends Integration {}
 }
 
+export namespace opentelemetry {
+  /**
+   * A registry for creating named {@link Tracer}s.
+   */
+  export interface TracerProvider extends otel.TracerProvider {
+    /**
+     * Construct a new TracerProvider to register with @opentelemetry/api
+     *
+     * @returns TracerProvider A TracerProvider instance
+     */
+    new(): TracerProvider;
+
+    /**
+     * Returns a Tracer, creating one if one with the given name and version is
+     * not already created.
+     *
+     * This function may return different Tracer types (e.g.
+     * {@link NoopTracerProvider} vs. a functional tracer).
+     *
+     * @param name The name of the tracer or instrumentation library.
+     * @param version The version of the tracer or instrumentation library.
+     * @param options The options of the tracer or instrumentation library.
+     * @returns Tracer A Tracer with the given name and version
+     */
+    getTracer(name: string, version?: string): Tracer;
+
+    /**
+     * Register this tracer provider with @opentelemetry/api
+     */
+    register(): void;
+  }
+
+  /**
+   * Tracer provides an interface for creating {@link Span}s.
+   */
+  export interface Tracer extends otel.Tracer {
+    /**
+     * Starts a new {@link Span}. Start the span without setting it on context.
+     *
+     * This method do NOT modify the current Context.
+     *
+     * @param name The name of the span
+     * @param [options] SpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @returns Span The newly created span
+     * @example
+     *     const span = tracer.startSpan('op');
+     *     span.setAttribute('key', 'value');
+     *     span.end();
+     */
+    startSpan(name: string, options?: SpanOptions, context?: Context): Span;
+
+    /**
+     * Starts a new {@link Span} and calls the given function passing it the
+     * created span as first argument.
+     * Additionally the new span gets set in context and this context is activated
+     * for the duration of the function call.
+     *
+     * @param name The name of the span
+     * @param [options] SpanOptions used for span creation
+     * @param [context] Context to use to extract parent
+     * @param fn function called in the context of the span and receives the newly created span as an argument
+     * @returns return value of fn
+     * @example
+     *     const something = tracer.startActiveSpan('op', span => {
+     *       try {
+     *         do some work
+     *         span.setStatus({code: SpanStatusCode.OK});
+     *         return something;
+     *       } catch (err) {
+     *         span.setStatus({
+     *           code: SpanStatusCode.ERROR,
+     *           message: err.message,
+     *         });
+     *         throw err;
+     *       } finally {
+     *         span.end();
+     *       }
+     *     });
+     *
+     * @example
+     *     const span = tracer.startActiveSpan('op', span => {
+     *       try {
+     *         do some work
+     *         return span;
+     *       } catch (err) {
+     *         span.setStatus({
+     *           code: SpanStatusCode.ERROR,
+     *           message: err.message,
+     *         });
+     *         throw err;
+     *       }
+     *     });
+     *     do some more work
+     *     span.end();
+     */
+    startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;
+    startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;
+    startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, context: otel.Context, fn: F): ReturnType<F>;
+  }
+
+  /**
+   * An interface that represents a span. A span represents a single operation
+   * within a trace. Examples of span might include remote procedure calls or a
+   * in-process function calls to sub-components. A Trace has a single, top-level
+   * "root" Span that in turn may have zero or more child Spans, which in turn
+   * may have children.
+   *
+   * Spans are created by the {@link Tracer.startSpan} method.
+   */
+  export interface Span extends otel.Span {
+    /**
+     * Returns the {@link SpanContext} object associated with this Span.
+     *
+     * Get an immutable, serializable identifier for this span that can be used
+     * to create new child spans. Returned SpanContext is usable even after the
+     * span ends.
+     *
+     * @returns the SpanContext object associated with this Span.
+     */
+    spanContext(): SpanContext;
+
+    /**
+     * Sets an attribute to the span.
+     *
+     * Sets a single Attribute with the key and value passed as arguments.
+     *
+     * @param key the key for this attribute.
+     * @param value the value for this attribute. Setting a value null or
+     *              undefined is invalid and will result in undefined behavior.
+     */
+    setAttribute(key: string, value: SpanAttributeValue): this;
+
+    /**
+     * Sets attributes to the span.
+     *
+     * @param attributes the attributes that will be added.
+     *                   null or undefined attribute values
+     *                   are invalid and will result in undefined behavior.
+     */
+    setAttributes(attributes: SpanAttributes): this;
+
+    /**
+     * Adds an event to the Span.
+     *
+     * @param name the name of the event.
+     * @param [attributesOrStartTime] the attributes that will be added; these are
+     *     associated with this event. Can be also a start time
+     *     if type is {@type TimeInput} and 3rd param is undefined
+     * @param [startTime] start time of the event.
+     */
+    addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this;
+
+    /**
+     * Sets a status to the span. If used, this will override the default Span
+     * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value
+     * of previous calls to SetStatus on the Span.
+     *
+     * @param status the SpanStatus to set.
+     */
+    setStatus(status: SpanStatus): this;
+
+    /**
+     * Updates the Span name.
+     *
+     * This will override the name provided via {@link Tracer.startSpan}.
+     *
+     * Upon this update, any sampling behavior based on Span name will depend on
+     * the implementation.
+     *
+     * @param name the Span name.
+     */
+    updateName(name: string): this;
+
+    /**
+     * Marks the end of Span execution.
+     *
+     * Call to End of a Span MUST not have any effects on child spans. Those may
+     * still be running and can be ended later.
+     *
+     * Do not return `this`. The Span generally should not be used after it
+     * is ended so chaining is not desired in this context.
+     *
+     * @param [endTime] the time to set as Span's end time. If not provided,
+     *     use the current time as the span's end time.
+     */
+    end(endTime?: TimeInput): void;
+
+    /**
+     * Returns the flag whether this span will be recorded.
+     *
+     * @returns true if this Span is active and recording information like events
+     *     with the `AddEvent` operation and attributes using `setAttributes`.
+     */
+    isRecording(): boolean;
+
+    /**
+     * Sets exception as a span event
+     * @param exception the exception the only accepted values are string or Error
+     * @param [time] the time to set as Span's event time. If not provided,
+     *     use the current time.
+     */
+    recordException(exception: Exception, time?: TimeInput): void;
+  }
+
+  /**
+   * A SpanContext represents the portion of a {@link Span} which must be
+   * serialized and propagated along side of a {@link Baggage}.
+   */
+  export interface SpanContext extends otel.SpanContext {
+    /**
+     * The ID of the trace that this span belongs to. It is worldwide unique
+     * with practically sufficient probability by being made as 16 randomly
+     * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+     * 128 bits.
+     */
+    traceId: string;
+
+    /**
+     * The ID of the Span. It is globally unique with practically sufficient
+     * probability by being made as 8 randomly generated bytes, encoded as a 16
+     * lowercase hex characters corresponding to 64 bits.
+     */
+    spanId: string;
+
+    /**
+     * Only true if the SpanContext was propagated from a remote parent.
+     */
+    isRemote?: boolean;
+
+    /**
+     * Trace flags to propagate.
+     *
+     * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+     * sampled or not. When set, the least significant bit documents that the
+     * caller may have recorded trace data. A caller who does not record trace
+     * data out-of-band leaves this flag unset.
+     *
+     * see {@link TraceFlags} for valid flag values.
+     */
+    traceFlags: number;
+
+    /**
+     * Tracing-system-specific info to propagate.
+     *
+     * The tracestate field value is a `list` as defined below. The `list` is a
+     * series of `list-members` separated by commas `,`, and a list-member is a
+     * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs
+     * surrounding `list-members` are ignored. There can be a maximum of 32
+     * `list-members` in a `list`.
+     * More Info: https://www.w3.org/TR/trace-context/#tracestate-field
+     *
+     * Examples:
+     *     Single tracing system (generic format):
+     *         tracestate: rojo=00f067aa0ba902b7
+     *     Multiple tracing systems (with different formatting):
+     *         tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE
+     */
+    traceState?: TraceState;
+  }
+
+  export type Context = otel.Context;
+  export type Exception = otel.Exception;
+  export type SpanAttributes = otel.SpanAttributes;
+  export type SpanAttributeValue = otel.SpanAttributeValue;
+  export type SpanOptions = otel.SpanOptions;
+  export type SpanStatus = otel.SpanStatus;
+  export type TimeInput = otel.TimeInput;
+  export type TraceState = otel.TraceState;
+}
+
 /**
  * Singleton returned by the module. It has to be initialized before it will
  * start tracing. If not initialized, or initialized and disabled, it will use

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.1.1",
+  "version": "4.2.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -19,7 +19,7 @@
     "test:appsec:ci": "nyc --no-clean --include \"packages/dd-trace/src/appsec/**/*.js\" --exclude \"packages/dd-trace/test/appsec/**/*.plugin.spec.js\" -- npm run test:appsec",
     "test:appsec:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/dd-trace/test/appsec/**/*.@($(echo $PLUGINS)).plugin.spec.js\"",
     "test:appsec:plugins:ci": "yarn services && nyc --no-clean --include \"packages/dd-trace/test/appsec/**/*.@($(echo $PLUGINS)).plugin.spec.js\" -- npm run test:appsec:plugins",
-    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,encode,exporters,opentracing,plugins,telemetry}/**/*.spec.js\"",
+    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,encode,exporters,opentelemetry,opentracing,plugins,telemetry}/**/*.spec.js\"",
     "test:trace:core:ci": "npm run test:trace:core -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/**/*.js\"",
     "test:instrumentations": "mocha --colors -r 'packages/dd-trace/test/setup/mocha.js' 'packages/datadog-instrumentations/test/**/*.spec.js'",
     "test:instrumentations:ci": "nyc --no-clean --include 'packages/datadog-instrumentations/src/**/*.js' -- npm run test:instrumentations",
@@ -72,6 +72,8 @@
     "@datadog/native-metrics": "^2.0.0",
     "@datadog/pprof": "^2.2.1",
     "@datadog/sketches-js": "^2.1.0",
+    "@opentelemetry/api": "^1.0.0",
+    "@opentelemetry/core": "<1.4.0",
     "crypto-randomuuid": "^1.0.0",
     "diagnostics_channel": "^1.1.0",
     "ignore": "^5.2.0",

package/packages/datadog-plugin-cypress/src/plugin.js

@@ -133,6 +133,8 @@ module.exports = (on, config) => {
     'git.branch': branch
   } = testEnvironmentMetadata
 
+  const finishedTestsByFile = {}
+
   const testConfiguration = {
     repositoryUrl,
     sha,
@@ -158,6 +160,44 @@ module.exports = (on, config) => {
   let isCodeCoverageEnabled = false
   let testsToSkip = []
 
+  function getTestSpan (testName, testSuite) {
+    const testSuiteTags = {
+      [TEST_COMMAND]: command,
+      [TEST_COMMAND]: command,
+      [TEST_MODULE]: TEST_FRAMEWORK_NAME
+    }
+    if (testSuiteSpan) {
+      testSuiteTags[TEST_SUITE_ID] = testSuiteSpan.context().toSpanId()
+    }
+    if (testSessionSpan && testModuleSpan) {
+      testSuiteTags[TEST_SESSION_ID] = testSessionSpan.context().toTraceId()
+      testSuiteTags[TEST_MODULE_ID] = testModuleSpan.context().toSpanId()
+    }
+
+    const {
+      childOf,
+      resource,
+      ...testSpanMetadata
+    } = getTestSpanMetadata(tracer, testName, testSuite, config)
+
+    const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
+
+    if (codeOwners) {
+      testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
+    }
+
+    return tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test`, {
+      childOf,
+      tags: {
+        [COMPONENT]: TEST_FRAMEWORK_NAME,
+        [ORIGIN_KEY]: CI_APP_ORIGIN,
+        ...testSpanMetadata,
+        ...testEnvironmentMetadata,
+        ...testSuiteTags
+      }
+    })
+  }
+
   on('before:run', (details) => {
     return getItrConfig(tracer, testConfiguration).then(({ err, itrConfig }) => {
       if (err) {
@@ -203,6 +243,58 @@ module.exports = (on, config) => {
       })
     })
   })
+  on('after:spec', (spec, { tests, stats }) => {
+    const cypressTests = tests || []
+    const finishedTests = finishedTestsByFile[spec.relative] || []
+
+    // Get tests that didn't go through `dd:afterEach` and haven't been skipped by ITR
+    // and create a skipped test span for each of them
+    cypressTests.filter(({ title }) => {
+      const cypressTestName = title.join(' ')
+      const isSkippedByItr = testsToSkip.find(test =>
+        cypressTestName === test.name && spec.relative === test.suite
+      )
+      const isTestFinished = finishedTests.find(({ testName }) => cypressTestName === testName)
+
+      return !isSkippedByItr && !isTestFinished
+    }).forEach(({ title }) => {
+      const skippedTestSpan = getTestSpan(title.join(' '), spec.relative)
+      skippedTestSpan.setTag(TEST_STATUS, 'skip')
+      skippedTestSpan.finish()
+    })
+
+    // Make sure that reported test statuses are the same as Cypress reports.
+    // This is not always the case, such as when an `after` hook fails:
+    // Cypress will report the last run test as failed, but we don't know that yet at `dd:afterEach`
+    let latestError
+    finishedTests.forEach((finishedTest) => {
+      const cypressTest = cypressTests.find(test => test.title.join(' ') === finishedTest.testName)
+      if (!cypressTest) {
+        return
+      }
+      if (cypressTest.displayError) {
+        latestError = new Error(cypressTest.displayError)
+      }
+      const cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.state]
+      // update test status
+      if (cypressTestStatus !== finishedTest.testStatus) {
+        finishedTest.testSpan.setTag(TEST_STATUS, cypressTestStatus)
+        finishedTest.testSpan.setTag('error', latestError)
+      }
+      finishedTest.testSpan.finish(finishedTest.finishTime)
+    })
+
+    if (testSuiteSpan) {
+      const status = getSuiteStatus(stats)
+      testSuiteSpan.setTag(TEST_STATUS, status)
+
+      if (latestError) {
+        testSuiteSpan.setTag('error', latestError)
+      }
+      testSuiteSpan.finish()
+      testSuiteSpan = null
+    }
+  })
 
   on('after:run', (suiteStats) => {
     if (testSessionSpan && testModuleSpan) {
@@ -254,15 +346,6 @@ module.exports = (on, config) => {
       })
       return null
     },
-    'dd:testSuiteFinish': (stats) => {
-      if (testSuiteSpan) {
-        const status = getSuiteStatus(stats)
-        testSuiteSpan.setTag(TEST_STATUS, status)
-        testSuiteSpan.finish()
-        testSuiteSpan = null
-      }
-      return null
-    },
     'dd:beforeEach': (test) => {
       const { testName, testSuite } = test
       // skip test
@@ -272,47 +355,14 @@ module.exports = (on, config) => {
         return { shouldSkip: true }
       }
 
-      const testSuiteTags = {
-        [TEST_COMMAND]: command,
-        [TEST_COMMAND]: command,
-        [TEST_MODULE]: TEST_FRAMEWORK_NAME
-      }
-      if (testSuiteSpan) {
-        testSuiteTags[TEST_SUITE_ID] = testSuiteSpan.context().toSpanId()
-      }
-      if (testSessionSpan && testModuleSpan) {
-        testSuiteTags[TEST_SESSION_ID] = testSessionSpan.context().toTraceId()
-        testSuiteTags[TEST_MODULE_ID] = testModuleSpan.context().toSpanId()
-      }
-
-      const {
-        childOf,
-        resource,
-        ...testSpanMetadata
-      } = getTestSpanMetadata(tracer, testName, testSuite, config)
-
-      const codeOwners = getCodeOwnersForFilename(testSuite, codeOwnersEntries)
-
-      if (codeOwners) {
-        testSpanMetadata[TEST_CODE_OWNERS] = codeOwners
-      }
-
       if (!activeSpan) {
-        activeSpan = tracer.startSpan(`${TEST_FRAMEWORK_NAME}.test`, {
-          childOf,
-          tags: {
-            [COMPONENT]: TEST_FRAMEWORK_NAME,
-            [ORIGIN_KEY]: CI_APP_ORIGIN,
-            ...testSpanMetadata,
-            ...testEnvironmentMetadata,
-            ...testSuiteTags
-          }
-        })
+        activeSpan = getTestSpan(testName, testSuite)
       }
+
       return activeSpan ? { traceId: activeSpan.context().toTraceId() } : {}
     },
     'dd:afterEach': ({ test, coverage }) => {
-      const { state, error, isRUMActive, testSourceLine } = test
+      const { state, error, isRUMActive, testSourceLine, testSuite, testName } = test
       if (activeSpan) {
         if (coverage && tracer._tracer._exporter.exportCoverage && isCodeCoverageEnabled) {
           const coverageFiles = getCoveredFilenamesFromCoverage(coverage)
@@ -326,8 +376,9 @@ module.exports = (on, config) => {
           }
           tracer._tracer._exporter.exportCoverage(formattedCoverage)
         }
+        const testStatus = CYPRESS_STATUS_TO_TEST_STATUS[state]
+        activeSpan.setTag(TEST_STATUS, testStatus)
 
-        activeSpan.setTag(TEST_STATUS, CYPRESS_STATUS_TO_TEST_STATUS[state])
         if (error) {
           activeSpan.setTag('error', error)
         }
@@ -337,7 +388,18 @@ module.exports = (on, config) => {
         if (testSourceLine) {
           activeSpan.setTag(TEST_SOURCE_START, testSourceLine)
         }
-        activeSpan.finish()
+        const finishedTest = {
+          testName,
+          testStatus,
+          finishTime: activeSpan._getTime(), // we store the finish time here
+          testSpan: activeSpan
+        }
+        if (finishedTestsByFile[testSuite]) {
+          finishedTestsByFile[testSuite].push(finishedTest)
+        } else {
+          finishedTestsByFile[testSuite] = [finishedTest]
+        }
+        // test spans are finished at after:spec
       }
       activeSpan = null
       return null

package/packages/datadog-plugin-cypress/src/support.js

@@ -16,9 +16,10 @@ before(() => {
 })
 
 after(() => {
-  cy.task('dd:testSuiteFinish', Cypress.mocha.getRunner().stats)
   cy.window().then(win => {
-    win.dispatchEvent(new Event('beforeunload'))
+    if (win.DD_RUM) {
+      win.dispatchEvent(new Event('beforeunload'))
+    }
   })
 })
 

package/packages/dd-trace/src/appsec/iast/analyzers/weak-hash-analyzer.js

@@ -1,4 +1,7 @@
 'use strict'
+
+const path = require('path')
+
 const Analyzer = require('./vulnerability-analyzer')
 const { WEAK_HASH } = require('../vulnerabilities')
 
@@ -8,6 +11,17 @@ const INSECURE_HASH_ALGORITHMS = new Set([
   'RSA-SHA1', 'RSA-SHA1-2', 'sha1', 'md5-sha1', 'sha1WithRSAEncryption', 'ssl3-sha1'
 ].map(algorithm => algorithm.toLowerCase()))
 
+const EXCLUDED_LOCATIONS = [
+  path.join('node_modules', 'etag', 'index.js'),
+  path.join('node_modules', 'redlock', 'dist', 'cjs'),
+  path.join('node_modules', 'ws', 'lib', 'websocket-server.js'),
+  path.join('node_modules', 'mysql2', 'lib', 'auth_41.js'),
+  path.join('node_modules', '@mikro-orm', 'core', 'utils', 'Utils.js')
+]
+
+const EXCLUDED_PATHS_FROM_STACK = [
+  path.join('node_modules', 'object-hash', path.sep)
+]
 class WeakHashAnalyzer extends Analyzer {
   constructor () {
     super(WEAK_HASH)
@@ -20,6 +34,16 @@ class WeakHashAnalyzer extends Analyzer {
     }
     return false
   }
+
+  _isExcluded (location) {
+    return EXCLUDED_LOCATIONS.some(excludedLocation => {
+      return location.path.includes(excludedLocation)
+    })
+  }
+
+  _getExcludedPaths () {
+    return EXCLUDED_PATHS_FROM_STACK
+  }
 }
 
 module.exports = new WeakHashAnalyzer()

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { AsyncLocalStorage } = require('async_hooks')
+const { trace, ROOT_CONTEXT } = require('@opentelemetry/api')
+
+const SpanContext = require('./span_context')
+const tracer = require('../../')
+
+// Horrible hack to acquire the otherwise inaccessible SPAN_KEY so we can redirect it...
+// This is used for getting the current span context in OpenTelemetry, but the SPAN_KEY value is
+// not exposed as it's meant to be read-only from outside the module. We want to hijack this logic
+// so we can instead get the span context from the datadog context manager instead.
+let SPAN_KEY
+trace.getSpan({
+  getValue (key) {
+    SPAN_KEY = key
+  }
+})
+
+// Whenever a value is acquired from the context map we should mostly delegate to the real getter,
+// but when accessing the current span we should hijack that access to instead provide a fake span
+// which we can use to get an OTel span context wrapping the datadog active scope span context.
+function wrappedGetValue (target) {
+  return (key) => {
+    if (key === SPAN_KEY) {
+      return {
+        spanContext () {
+          const activeSpan = tracer.scope().active()
+          const context = activeSpan && activeSpan.context()
+          return new SpanContext(context)
+        }
+      }
+    }
+    return target.getValue(key)
+  }
+}
+
+class ContextManager {
+  constructor () {
+    this._store = new AsyncLocalStorage()
+  }
+
+  active () {
+    const active = this._store.getStore() || ROOT_CONTEXT
+
+    return new Proxy(active, {
+      get (target, key) {
+        return key === 'getValue' ? wrappedGetValue(target) : target[key]
+      }
+    })
+  }
+
+  with (context, fn, thisArg, ...args) {
+    const span = trace.getSpan(context)
+    const ddScope = tracer.scope()
+    return ddScope.activate(span._ddSpan, () => {
+      const cb = thisArg == null ? fn : fn.bind(thisArg)
+      return this._store.run(context, cb, ...args)
+    })
+  }
+
+  bind (context, target) {
+    const self = this
+    return function (...args) {
+      return self.with(context, target, this, args)
+    }
+  }
+
+  // Not part of the spec but the Node.js API expects these
+  enable () {}
+  disable () {}
+}
+
+module.exports = ContextManager

package/packages/dd-trace/src/opentelemetry/sampler.js

@@ -0,0 +1,18 @@
+'use strict'
+
+// This isn't used yet. We currently delegate to dd-trace core for sampling decisions.
+// Leaving here for future use.
+class Sampler {
+  shouldSample (context, traceId, spanName, spanKind, attributes, links) {
+    // 0 = no, 1 = record, 2 = record and sample
+    // TODO: Make this actually do sampling...
+    return { decision: 2 }
+  }
+
+  /** Returns the sampler name or short description with the configuration. */
+  toString () {
+    return 'DatadogSampler'
+  }
+}
+
+module.exports = Sampler

package/packages/dd-trace/src/opentelemetry/span.js

@@ -0,0 +1,151 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+
+const { performance } = require('perf_hooks')
+const { timeOrigin } = performance
+
+const { timeInputToHrTime } = require('@opentelemetry/core')
+
+const tracer = require('../../')
+const DatadogSpan = require('../opentracing/span')
+const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../constants')
+
+const SpanContext = require('./span_context')
+
+// The one built into OTel rounds so we lose sub-millisecond precision.
+function hrTimeToMilliseconds (time) {
+  return time[0] * 1e3 + time[1] / 1e6
+}
+
+class Span {
+  constructor (
+    parentTracer,
+    context,
+    spanName,
+    spanContext,
+    kind,
+    links = [],
+    timeInput
+  ) {
+    const { _tracer } = tracer
+
+    const hrStartTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const startTime = hrTimeToMilliseconds(hrStartTime)
+
+    this._ddSpan = new DatadogSpan(_tracer, _tracer._processor, _tracer._prioritySampler, {
+      operationName: spanName,
+      context: spanContext._ddContext,
+      startTime,
+      hostname: _tracer._hostname,
+      tags: {
+        'service.name': _tracer._service
+      }
+    }, _tracer._debug)
+
+    this._parentTracer = parentTracer
+    this._context = context
+
+    this._hasStatus = false
+
+    // NOTE: Need to grab the value before setting it on the span because the
+    // math for computing opentracing timestamps is apparently lossy...
+    this.startTime = hrStartTime
+    this.kind = kind
+    this.links = links
+    this._spanProcessor.onStart(this, context)
+  }
+
+  get parentSpanId () {
+    const { _parentId } = this._ddSpan.context()
+    return _parentId && _parentId.toString(16)
+  }
+
+  // Expected by OTel
+  get resource () {
+    return this._parentTracer.resource
+  }
+  get instrumentationLibrary () {
+    return this._parentTracer.instrumentationLibrary
+  }
+  get _spanProcessor () {
+    return this._parentTracer.getActiveSpanProcessor()
+  }
+
+  get name () {
+    return this._ddSpan.context()._name
+  }
+
+  spanContext () {
+    return new SpanContext(this._ddSpan.context())
+  }
+
+  setAttribute (key, value) {
+    this._ddSpan.setTag(key, value)
+    return this
+  }
+
+  setAttributes (attributes) {
+    this._ddSpan.addTags(attributes)
+    return this
+  }
+
+  addEvent (name, attributesOrStartTime, startTime) {
+    api.diag.warn('Events not supported')
+    return this
+  }
+
+  setStatus ({ code, message }) {
+    if (!this.ended && !this._hasStatus && code) {
+      this._hasStatus = true
+      if (code === 2) {
+        this._ddSpan.addTags({
+          [ERROR_MESSAGE]: message
+        })
+      }
+    }
+    return this
+  }
+
+  updateName (name) {
+    if (!this.ended) {
+      this._ddSpan.setOperationName(name)
+    }
+    return this
+  }
+
+  end (timeInput) {
+    if (this.ended) {
+      api.diag.error('You can only call end() on a span once.')
+      return
+    }
+
+    const hrEndTime = timeInputToHrTime(timeInput || (performance.now() + timeOrigin))
+    const endTime = hrTimeToMilliseconds(hrEndTime)
+
+    this._ddSpan.finish(endTime)
+    this._spanProcessor.onEnd(this)
+  }
+
+  isRecording () {
+    return this.ended === false
+  }
+
+  recordException (exception) {
+    this._ddSpan.addTags({
+      [ERROR_TYPE]: exception.name,
+      [ERROR_MESSAGE]: exception.message,
+      [ERROR_STACK]: exception.stack
+    })
+  }
+
+  get duration () {
+    return this._ddSpan._duration
+  }
+
+  get ended () {
+    return typeof this.duration !== 'undefined'
+  }
+}
+
+module.exports = Span

package/packages/dd-trace/src/opentelemetry/span_context.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { AUTO_KEEP } = require('../../../../ext/priority')
+const DatadogSpanContext = require('../opentracing/span_context')
+const id = require('../id')
+
+function newContext () {
+  const spanId = id()
+  return new DatadogSpanContext({
+    traceId: spanId,
+    spanId
+  })
+}
+
+class SpanContext {
+  constructor (context) {
+    if (!(context instanceof DatadogSpanContext)) {
+      context = context
+        ? new DatadogSpanContext(context)
+        : newContext()
+    }
+    this._ddContext = context
+  }
+
+  get traceId () {
+    return this._ddContext._traceId.toString(16)
+  }
+
+  get spanId () {
+    return this._ddContext._spanId.toString(16)
+  }
+
+  get traceFlags () {
+    return this._ddContext._sampling.priority >= AUTO_KEEP ? 1 : 0
+  }
+
+  get traceState () {
+    const ts = this._ddContext._tracestate
+    return api.createTraceState(ts ? ts.toString() : '')
+  }
+}
+
+module.exports = SpanContext

package/packages/dd-trace/src/opentelemetry/span_processor.js

@@ -0,0 +1,50 @@
+'use strict'
+
+class NoopSpanProcessor {
+  forceFlush () {
+    return Promise.resolve()
+  }
+
+  onStart (span, context) { }
+  onEnd (span) { }
+
+  shutdown () {
+    return Promise.resolve()
+  }
+}
+
+class MultiSpanProcessor extends NoopSpanProcessor {
+  constructor (spanProcessors) {
+    super()
+    this._processors = spanProcessors
+  }
+
+  forceFlush () {
+    return Promise.all(
+      this._processors.map(p => p.forceFlush())
+    )
+  }
+
+  onStart (span, context) {
+    for (const processor of this._processors) {
+      processor.onStart(span, context)
+    }
+  }
+
+  onEnd (span) {
+    for (const processor of this._processors) {
+      processor.onEnd(span)
+    }
+  }
+
+  shutdown () {
+    return Promise.all(
+      this._processors.map(p => p.shutdown())
+    )
+  }
+}
+
+module.exports = {
+  MultiSpanProcessor,
+  NoopSpanProcessor
+}

package/packages/dd-trace/src/opentelemetry/tracer.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const api = require('@opentelemetry/api')
+const { sanitizeAttributes } = require('@opentelemetry/core')
+
+const Sampler = require('./sampler')
+const Span = require('./span')
+const id = require('../id')
+const SpanContext = require('./span_context')
+
+class Tracer {
+  constructor (library, config, tracerProvider) {
+    this._sampler = new Sampler()
+    this._config = config
+    this._tracerProvider = tracerProvider
+    // Is there a reason this is public?
+    this.instrumentationLibrary = library
+  }
+
+  get resource () {
+    return this._tracerProvider.resource
+  }
+
+  startSpan (name, options = {}, context = api.context.active()) {
+    // remove span from context in case a root span is requested via options
+    if (options.root) {
+      context = api.trace.deleteSpan(context)
+    }
+    const parentSpan = api.trace.getSpan(context)
+    const parentSpanContext = parentSpan && parentSpan.spanContext()
+
+    let spanContext
+    // TODO: Need a way to get 128-bit trace IDs for the validity check API to work...
+    // if (parent && api.trace.isSpanContextValid(parent)) {
+    if (parentSpanContext && parentSpanContext.traceId) {
+      const parent = parentSpanContext._ddContext
+      spanContext = new SpanContext({
+        traceId: parent._traceId,
+        spanId: id(),
+        parentId: parent._spanId,
+        sampling: parent._sampling,
+        baggageItems: Object.assign({}, parent._baggageItems),
+        trace: parent._trace,
+        tracestate: parent._tracestate
+      })
+    } else {
+      spanContext = new SpanContext()
+    }
+
+    const spanKind = options.kind || api.SpanKind.INTERNAL
+    const links = (options.links || []).map(link => {
+      return {
+        context: link.context,
+        attributes: sanitizeAttributes(link.attributes)
+      }
+    })
+    const attributes = sanitizeAttributes(options.attributes)
+
+    // TODO: sampling API is not yet supported
+    // // make sampling decision
+    // const samplingResult = this._sampler.shouldSample(
+    //   context,
+    //   spanContext.traceId,
+    //   name,
+    //   spanKind,
+    //   attributes,
+    //   links
+    // )
+
+    // // Should use new span context
+    // spanContext._ddContext._sampling.priority =
+    //   samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED
+    //     ? AUTO_KEEP
+    //     : AUTO_REJECT
+
+    // if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
+    //   api.diag.debug('Recording is off, propagating context in a non-recording span')
+    //   return api.trace.wrapSpanContext(spanContext)
+    // }
+
+    const span = new Span(
+      this,
+      context,
+      name,
+      spanContext,
+      spanKind,
+      links,
+      options.startTime
+    )
+    // Set initial span attributes. The attributes object may have been mutated
+    // by the sampler, so we sanitize the merged attributes before setting them.
+    const initAttributes = sanitizeAttributes(
+      // Object.assign(attributes, samplingResult.attributes)
+      attributes
+    )
+    span.setAttributes(initAttributes)
+    return span
+  }
+
+  startActiveSpan (name, options, context, fn) {
+    if (arguments.length === 2) {
+      fn = options
+      context = undefined
+      options = undefined
+    } else if (arguments.length === 3) {
+      fn = context
+      context = undefined
+    } else if (arguments.length !== 4) {
+      return
+    }
+
+    const parentContext = context || api.context.active()
+    const span = this.startSpan(name, options, parentContext)
+    const contextWithSpanSet = api.trace.setSpan(parentContext, span)
+
+    return api.context.with(contextWithSpanSet, fn, undefined, span)
+  }
+
+  getActiveSpanProcessor () {
+    return this._tracerProvider.getActiveSpanProcessor()
+  }
+}
+
+module.exports = Tracer

package/packages/dd-trace/src/opentelemetry/tracer_provider.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { trace, context } = require('@opentelemetry/api')
+
+const tracer = require('../../')
+
+const ContextManager = require('./context_manager')
+const { MultiSpanProcessor, NoopSpanProcessor } = require('./span_processor')
+const Tracer = require('./tracer')
+
+class TracerProvider {
+  constructor (config = {}) {
+    this.config = config
+    this.resource = config.resource
+
+    this._processors = []
+    this._tracers = new Map()
+    this._activeProcessor = new NoopSpanProcessor()
+    this._contextManager = new ContextManager()
+  }
+
+  getTracer (name = 'opentelemetry', version = '0.0.0', options) {
+    const key = `${name}@${version}`
+    if (!this._tracers.has(key)) {
+      this._tracers.set(key, new Tracer(
+        { ...options, name, version },
+        this.config,
+        this
+      ))
+    }
+    return this._tracers.get(key)
+  }
+
+  addSpanProcessor (spanProcessor) {
+    if (!this._processors.length) {
+      this._activeProcessor.shutdown()
+    }
+    this._processors.push(spanProcessor)
+    this._activeProcessor = new MultiSpanProcessor(
+      this._processors
+    )
+  }
+
+  getActiveSpanProcessor () {
+    return this._activeProcessor
+  }
+
+  // Not actually required by the SDK spec, but the official Node.js SDK does
+  // this and the docs reflect that so we should do this too for familiarity.
+  register (config = {}) {
+    context.setGlobalContextManager(this._contextManager)
+    if (!trace.setGlobalTracerProvider(this)) {
+      trace.getTracerProvider().setDelegate(this)
+    }
+  }
+
+  forceFlush () {
+    const exporter = tracer._tracer._exporter
+    if (!exporter) {
+      return Promise.reject(new Error('Not started'))
+    }
+
+    exporter._writer.flush()
+    return this._activeProcessor.forceFlush()
+  }
+
+  shutdown () {
+    return this._activeProcessor.shutdown()
+  }
+}
+
+module.exports = TracerProvider

package/packages/dd-trace/src/opentracing/span.js

@@ -44,6 +44,8 @@ class DatadogSpan {
     this._spanContext._tags = tags
     this._spanContext._hostname = hostname
 
+    this._spanContext._trace.started.push(this)
+
     this._startTime = fields.startTime || this._getTime()
 
     if (DD_TRACE_EXPERIMENTAL_SPAN_COUNTS && finishedRegistry) {
@@ -147,8 +149,14 @@ class DatadogSpan {
 
   _createContext (parent, fields) {
     let spanContext
+    let startTime
 
-    if (parent) {
+    if (fields.context) {
+      spanContext = fields.context
+      if (!spanContext._trace.startTime) {
+        startTime = dateNow()
+      }
+    } else if (parent) {
       spanContext = new SpanContext({
         traceId: parent._traceId,
         spanId: id(),
@@ -160,11 +168,11 @@ class DatadogSpan {
       })
 
       if (!spanContext._trace.startTime) {
-        spanContext._trace.startTime = dateNow()
+        startTime = dateNow()
       }
     } else {
       const spanId = id()
-      const startTime = dateNow()
+      startTime = dateNow()
       spanContext = new SpanContext({
         traceId: spanId,
         spanId
@@ -178,8 +186,10 @@ class DatadogSpan {
       }
     }
 
-    spanContext._trace.started.push(this)
     spanContext._trace.ticks = spanContext._trace.ticks || now()
+    if (startTime) {
+      spanContext._trace.startTime = startTime
+    }
 
     return spanContext
   }

package/packages/dd-trace/src/proxy.js

@@ -76,6 +76,10 @@ class Tracer extends NoopProxy {
     this._pluginManager.configurePlugin(...arguments)
     return this
   }
+
+  get TracerProvider () {
+    return require('./opentelemetry/tracer_provider')
+  }
 }
 
 module.exports = Tracer