dd-trace 4.1.0 → 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
@@ -51,6 +53,7 @@ dev,glob,ISC,Copyright Isaac Z. Schlueter and Contributors
 dev,graphql,MIT,Copyright 2015 Facebook Inc.
 dev,int64-buffer,MIT,Copyright 2015-2016 Yusuke Kawasaki
 dev,jszip,MIT,Copyright 2015-2016 Stuart Knightley and contributors
+dev,knex,MIT,Copyright (c) 2013-present Tim Griesser
 dev,mkdirp,MIT,Copyright 2010 James Halliday
 dev,mocha,MIT,Copyright 2011-2018 JS Foundation and contributors https://js.foundation
 dev,multer,MIT,Copyright 2014 Hage Yaapa

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.0",
+  "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",
@@ -120,6 +122,7 @@
     "graphql": "0.13.2",
     "int64-buffer": "^0.1.9",
     "jszip": "^3.5.0",
+    "knex": "^2.4.2",
     "mkdirp": "^0.5.1",
     "mocha": "8",
     "msgpack-lite": "^0.1.26",

package/packages/datadog-esbuild/index.js

@@ -39,7 +39,19 @@ module.exports.setup = function (build) {
 
     if (args.namespace === 'file' && packagesOfInterest.has(packageName)) {
       // The file namespace is used when requiring files from disk in userland
-      const pathToPackageJson = require.resolve(`${packageName}/package.json`, { paths: [ args.resolveDir ] })
+
+      let pathToPackageJson
+      try {
+        pathToPackageJson = require.resolve(`${packageName}/package.json`, { paths: [ args.resolveDir ] })
+      } catch (err) {
+        if (err.code === 'MODULE_NOT_FOUND') {
+          console.warn(`Unable to open "${packageName}/package.json". Is the "${packageName}" package dead code?`)
+          return
+        } else {
+          throw err
+        }
+      }
+
       const pkg = require(pathToPackageJson)
 
       if (DEBUG) {

package/packages/datadog-instrumentations/src/pg.js

@@ -31,16 +31,19 @@ function wrapQuery (query) {
     const asyncResource = new AsyncResource('bound-anonymous-fn')
     const processId = this.processID
 
-    let pgQuery = arguments[0] && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+    const pgQuery = arguments[0] && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+
+    // shallow clone the existing query to swap out .text field
+    let newQuery = { ...pgQuery }
 
     return asyncResource.runInAsyncScope(() => {
       startCh.publish({
         params: this.connectionParameters,
-        query: pgQuery,
+        query: newQuery,
         processId
       })
 
-      arguments[0] = pgQuery
+      arguments[0] = newQuery
 
       const finish = asyncResource.bind(function (error) {
         if (error) {
@@ -53,24 +56,24 @@ function wrapQuery (query) {
       const queryQueue = this.queryQueue || this._queryQueue
       const activeQuery = this.activeQuery || this._activeQuery
 
-      pgQuery = queryQueue[queryQueue.length - 1] || activeQuery
+      newQuery = queryQueue[queryQueue.length - 1] || activeQuery
 
-      if (!pgQuery) {
+      if (!newQuery) {
         return retval
       }
 
-      if (pgQuery.callback) {
-        const originalCallback = callbackResource.bind(pgQuery.callback)
-        pgQuery.callback = function (err, res) {
+      if (newQuery.callback) {
+        const originalCallback = callbackResource.bind(newQuery.callback)
+        newQuery.callback = function (err, res) {
           finish(err)
           return originalCallback.apply(this, arguments)
         }
-      } else if (pgQuery.once) {
-        pgQuery
+      } else if (newQuery.once) {
+        newQuery
           .once('error', finish)
           .once('end', () => finish())
       } else {
-        pgQuery.then(() => finish(), finish)
+        newQuery.then(() => finish(), finish)
       }
 
       try {

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/datadog-plugin-router/src/index.js

@@ -130,7 +130,7 @@ class RouterPlugin extends WebPlugin {
       route = context.stack.join('')
 
       // Longer route is more likely to be the actual route handler route.
-      if (route.length > context.route.length) {
+      if (isMoreSpecificThan(route, context.route)) {
         context.route = route
       }
     } else {
@@ -148,4 +148,15 @@ class RouterPlugin extends WebPlugin {
   }
 }
 
+function isMoreSpecificThan (routeA, routeB) {
+  if (!routeIsRegex(routeA) && routeIsRegex(routeB)) {
+    return true
+  }
+  return routeA.length > routeB.length
+}
+
+function routeIsRegex (route) {
+  return route.includes('(/') && route.includes('/)')
+}
+
 module.exports = RouterPlugin