dd-trace 4.18.0 → 5.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.18.0",
+  "version": "5.6.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/src/appsec/**/*.js\" -- npm run test:appsec:plugins",
-    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,encode,exporters,opentelemetry,opentracing,plugins,service-naming,telemetry}/**/*.spec.js\"",
+    "test:trace:core": "tap packages/dd-trace/test/*.spec.js \"packages/dd-trace/test/{ci-visibility,datastreams,encode,exporters,opentelemetry,opentracing,plugins,service-naming,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",
@@ -36,6 +36,7 @@
     "test:integration:cucumber": "mocha --colors --timeout 30000 \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --colors --timeout 30000 \"integration-tests/cypress/*.spec.js\"",
     "test:integration:playwright": "mocha --colors --timeout 30000 \"integration-tests/playwright/*.spec.js\"",
+    "test:integration:profiler": "mocha --colors --timeout 90000 \"integration-tests/profiler/*.spec.js\"",
     "test:integration:serverless": "mocha --colors --timeout 30000 \"integration-tests/serverless/*.spec.js\"",
     "test:integration:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/integration-test/**/*.spec.js\"",
     "test:unit:plugins": "mocha --colors --exit -r \"packages/dd-trace/test/setup/mocha.js\" \"packages/datadog-instrumentations/test/@($(echo $PLUGINS)).spec.js\" \"packages/datadog-plugin-@($(echo $PLUGINS))/test/**/*.spec.js\" --exclude \"packages/datadog-plugin-@($(echo $PLUGINS))/test/integration-test/**/*.spec.js\"",
@@ -65,31 +66,28 @@
   },
   "homepage": "https://github.com/DataDog/dd-trace-js#readme",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
-    "@datadog/native-appsec": "^4.0.0",
-    "@datadog/native-iast-rewriter": "2.2.1",
-    "@datadog/native-iast-taint-tracking": "1.6.3",
+    "@datadog/native-appsec": "7.1.0",
+    "@datadog/native-iast-rewriter": "2.2.3",
+    "@datadog/native-iast-taint-tracking": "1.7.0",
     "@datadog/native-metrics": "^2.0.0",
-    "@datadog/pprof": "4.0.1",
+    "@datadog/pprof": "5.1.0",
     "@datadog/sketches-js": "^2.1.0",
     "@opentelemetry/api": "^1.0.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
-    "diagnostics_channel": "^1.1.0",
+    "dc-polyfill": "^0.1.4",
     "ignore": "^5.2.4",
-    "import-in-the-middle": "^1.4.2",
+    "import-in-the-middle": "^1.7.3",
     "int64-buffer": "^0.1.9",
     "ipaddr.js": "^2.1.0",
     "istanbul-lib-coverage": "3.2.0",
     "jest-docblock": "^29.7.0",
     "koalas": "^1.0.2",
-    "limiter": "^1.1.4",
-    "lodash.kebabcase": "^4.1.1",
-    "lodash.pick": "^4.4.0",
+    "limiter": "1.1.5",
     "lodash.sortby": "^4.7.0",
-    "lodash.uniq": "^4.5.0",
     "lru-cache": "^7.14.0",
     "methods": "^1.1.2",
     "module-details-from-path": "^1.0.3",
@@ -97,15 +95,18 @@
     "node-abort-controller": "^3.1.1",
     "opentracing": ">=0.12.1",
     "path-to-regexp": "^0.1.2",
-    "protobufjs": "^7.2.4",
+    "pprof-format": "^2.0.7",
+    "protobufjs": "^7.2.5",
     "retry": "^0.13.1",
-    "semver": "^7.5.4"
+    "semver": "^7.5.4",
+    "shell-quote": "^1.8.1",
+    "tlhunter-sorted-set": "^0.1.0"
   },
   "devDependencies": {
-    "@types/node": ">=16",
+    "@types/node": ">=18",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
-    "axios": "^0.21.2",
+    "axios": "^1.6.7",
     "benchmark": "^2.1.4",
     "body-parser": "^1.20.2",
     "chai": "^4.3.7",
@@ -129,11 +130,10 @@
     "jszip": "^3.5.0",
     "knex": "^2.4.2",
     "mkdirp": "^3.0.1",
-    "mocha": "8",
+    "mocha": "^9",
     "multer": "^1.4.5-lts.1",
     "nock": "^11.3.3",
     "nyc": "^15.1.0",
-    "pprof-format": "^2.0.7",
     "proxyquire": "^1.8.0",
     "rimraf": "^3.0.0",
     "sinon": "^15.2.0",

package/packages/datadog-core/src/storage/async_resource.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { createHook, executionAsyncResource } = require('async_hooks')
-const { channel } = require('../../../diagnostics_channel')
+const { channel } = require('dc-polyfill')
 
 const beforeCh = channel('dd-trace:storage:before')
 const afterCh = channel('dd-trace:storage:after')

package/packages/datadog-core/src/utils/src/get.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = (object, path) => {
+  const pathArr = path.split('.')
+  let val = object
+  for (const p of pathArr) {
+    if (val === undefined) return val
+    val = val[p]
+  }
+  return val
+}

package/packages/datadog-core/src/utils/src/has.js

@@ -0,0 +1,14 @@
+'use strict'
+
+module.exports = (object, path) => {
+  const pathArr = path.split('.')
+  let property = object
+  for (const n of pathArr) {
+    if (property.hasOwnProperty(n)) {
+      property = property[n]
+    } else {
+      return false
+    }
+  }
+  return true
+}

package/packages/datadog-core/src/utils/src/kebabcase.js

@@ -0,0 +1,16 @@
+'use strict'
+
+module.exports = str => {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string')
+  }
+
+  return str
+    .trim()
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/\s+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/_/g, '-')
+    .replace(/-{2,}/g, '-')
+    .toLowerCase()
+}

package/packages/datadog-core/src/utils/src/pick.js

@@ -0,0 +1,11 @@
+'use strict'
+
+module.exports = (object, props) => {
+  const result = {}
+  props.forEach(prop => {
+    if (prop in object) {
+      result[prop] = object[prop]
+    }
+  })
+  return result
+}

package/packages/datadog-core/src/utils/src/set.js

@@ -0,0 +1,16 @@
+'use strict'
+
+module.exports = (object, path, value) => {
+  const pathArr = path.split('.')
+  let property = object
+  let i
+  for (i = 0; i < pathArr.length - 1; i++) {
+    const n = pathArr[i]
+    if (property.hasOwnProperty(n)) {
+      property = property[n]
+    } else {
+      property[n] = property = {}
+    }
+  }
+  property[pathArr[i]] = value
+}

package/packages/datadog-core/src/utils/src/uniq.js

@@ -0,0 +1,5 @@
+'use strict'
+
+module.exports = function (arr) {
+  return [...new Set(arr)]
+}

package/packages/datadog-esbuild/index.js

@@ -5,8 +5,6 @@
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations.js')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks.js')
 
-warnIfUnsupported()
-
 for (const hook of Object.values(hooks)) {
   hook()
 }
@@ -144,7 +142,7 @@ module.exports.setup = function (build) {
         ${fileCode}
       })(...arguments);
       {
-        const dc = require('diagnostics_channel');
+        const dc = require('dc-polyfill');
         const ch = dc.channel('${CHANNEL}');
         const mod = module.exports
         const payload = {
@@ -167,23 +165,6 @@ module.exports.setup = function (build) {
   })
 }
 
-// Currently esbuild support requires Node.js >=v16.17 or >=v18.7
-// Better yet it would support Node >=v14.17 or >=v16
-// Of course, the most ideal would be to support all versions of Node that dd-trace supports.
-// Version constraints based on Node's diagnostics_channel support
-function warnIfUnsupported () {
-  const [major, minor] = process.versions.node.split('.').map(Number)
-  if (
-    major < 16 ||
-    (major === 16 && minor < 17) ||
-    (major === 18 && minor < 7)) {
-    console.error('WARNING: Esbuild support isn\'t available for older versions of Node.js.')
-    console.error(`Expected: Node.js >=v16.17 or >=v18.7. Actual: Node.js = ${process.version}.`)
-    console.error('This application may build properly with this version of Node.js, but unless a')
-    console.error('more recent version is used at runtime, third party packages won\'t be instrumented.')
-  }
-}
-
 // @see https://github.com/nodejs/node/issues/47000
 function dotFriendlyResolve (path, directory) {
   if (path === '.') {

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

@@ -0,0 +1,47 @@
+'use strict'
+
+const {
+  addHook
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const tracingChannel = require('dc-polyfill').tracingChannel
+const ch = tracingChannel('apm:aerospike:command')
+
+function wrapCreateCommand (createCommand) {
+  if (typeof createCommand !== 'function') return createCommand
+
+  return function commandWithTrace () {
+    const CommandClass = createCommand.apply(this, arguments)
+
+    if (!CommandClass) return CommandClass
+
+    shimmer.wrap(CommandClass.prototype, 'process', wrapProcess)
+
+    return CommandClass
+  }
+}
+
+function wrapProcess (process) {
+  return function (...args) {
+    const cb = args[0]
+    if (typeof cb !== 'function') return process.apply(this, args)
+
+    const ctx = {
+      commandName: this.constructor.name,
+      commandArgs: this.args,
+      clientConfig: this.client.config
+    }
+
+    return ch.traceCallback(process, -1, ctx, this, ...args)
+  }
+}
+
+addHook({
+  name: 'aerospike',
+  file: 'lib/commands/command.js',
+  versions: ['^3.16.2', '4', '5']
+},
+commandFactory => {
+  return shimmer.wrap(commandFactory, wrapCreateCommand(commandFactory))
+})

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

@@ -5,7 +5,7 @@ const {
   addHook,
   AsyncResource
 } = require('./helpers/instrument')
-const kebabCase = require('lodash.kebabcase')
+const kebabCase = require('../../datadog-core/src/utils/src/kebabcase')
 const shimmer = require('../../datadog-shimmer')
 
 const startCh = channel('apm:amqplib:command:start')
@@ -28,7 +28,7 @@ addHook({ name: 'amqplib', file: 'lib/channel.js', versions: ['>=0.5'] }, channe
   })
 
   shimmer.wrap(channel.Channel.prototype, 'sendMessage', sendMessage => function (fields) {
-    return instrument(sendMessage, this, arguments, 'basic.publish', fields)
+    return instrument(sendMessage, this, arguments, 'basic.publish', fields, arguments[2])
   })
 
   shimmer.wrap(channel.BaseChannel.prototype, 'dispatchMessage', dispatchMessage => function (fields, message) {

package/packages/datadog-instrumentations/src/apollo-server-core.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { AbortController } = require('node-abort-controller')
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const dc = require('dc-polyfill')
+
+const requestChannel = dc.tracingChannel('datadog:apollo-server-core:request')
+
+addHook({ name: 'apollo-server-core', file: 'dist/runHttpQuery.js', versions: ['>3.0.0'] }, runHttpQueryModule => {
+  const HttpQueryError = runHttpQueryModule.HttpQueryError
+
+  shimmer.wrap(runHttpQueryModule, 'runHttpQuery', function wrapRunHttpQuery (originalRunHttpQuery) {
+    return async function runHttpQuery () {
+      if (!requestChannel.start.hasSubscribers) {
+        return originalRunHttpQuery.apply(this, arguments)
+      }
+
+      const abortController = new AbortController()
+      const abortData = {}
+
+      const runHttpQueryResult = requestChannel.tracePromise(
+        originalRunHttpQuery,
+        { abortController, abortData },
+        this,
+        ...arguments)
+
+      const abortPromise = new Promise((resolve, reject) => {
+        abortController.signal.addEventListener('abort', (event) => {
+          // runHttpQuery callbacks are writing the response on resolve/reject.
+          // We should return blocking data in the apollo-server-core HttpQueryError object
+          reject(new HttpQueryError(abortData.statusCode, abortData.message, true, abortData.headers))
+        }, { once: true })
+      })
+
+      return Promise.race([runHttpQueryResult, abortPromise])
+    }
+  })
+
+  return runHttpQueryModule
+})

package/packages/datadog-instrumentations/src/apollo-server.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { AbortController } = require('node-abort-controller')
+const dc = require('dc-polyfill')
+
+const { addHook } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const graphqlMiddlewareChannel = dc.tracingChannel('datadog:apollo:middleware')
+
+const requestChannel = dc.tracingChannel('datadog:apollo:request')
+
+let HeaderMap
+
+function wrapExecuteHTTPGraphQLRequest (originalExecuteHTTPGraphQLRequest) {
+  return async function executeHTTPGraphQLRequest () {
+    if (!HeaderMap || !requestChannel.start.hasSubscribers) {
+      return originalExecuteHTTPGraphQLRequest.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+    const abortData = {}
+
+    const graphqlResponseData = requestChannel.tracePromise(
+      originalExecuteHTTPGraphQLRequest,
+      { abortController, abortData },
+      this,
+      ...arguments)
+
+    const abortPromise = new Promise((resolve, reject) => {
+      abortController.signal.addEventListener('abort', (event) => {
+        // This method is expected to return response data
+        // with headers, status and body
+        const headers = new HeaderMap()
+        Object.keys(abortData.headers).forEach(key => {
+          headers.set(key, abortData.headers[key])
+        })
+
+        resolve({
+          headers: headers,
+          status: abortData.statusCode,
+          body: {
+            kind: 'complete',
+            string: abortData.message
+          }
+        })
+      }, { once: true })
+    })
+
+    return Promise.race([abortPromise, graphqlResponseData])
+  }
+}
+
+function apolloExpress4Hook (express4) {
+  shimmer.wrap(express4, 'expressMiddleware', function wrapExpressMiddleware (originalExpressMiddleware) {
+    return function expressMiddleware (server, options) {
+      const originalMiddleware = originalExpressMiddleware.apply(this, arguments)
+
+      return shimmer.wrap(originalMiddleware, function (req, res, next) {
+        if (!graphqlMiddlewareChannel.start.hasSubscribers) {
+          return originalMiddleware.apply(this, arguments)
+        }
+
+        return graphqlMiddlewareChannel.traceSync(originalMiddleware, { req }, this, ...arguments)
+      })
+    }
+  })
+  return express4
+}
+
+function apolloHeaderMapHook (headerMap) {
+  HeaderMap = headerMap.HeaderMap
+  return headerMap
+}
+
+function apolloServerHook (apolloServer) {
+  shimmer.wrap(apolloServer.ApolloServer.prototype, 'executeHTTPGraphQLRequest', wrapExecuteHTTPGraphQLRequest)
+  return apolloServer
+}
+
+addHook({ name: '@apollo/server', file: 'dist/cjs/ApolloServer.js', versions: ['>=4.0.0'] }, apolloServerHook)
+addHook({ name: '@apollo/server', file: 'dist/cjs/express4/index.js', versions: ['>=4.0.0'] }, apolloExpress4Hook)
+addHook({ name: '@apollo/server', file: 'dist/cjs/utils/HeaderMap.js', versions: ['>=4.0.0'] }, apolloHeaderMapHook)

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

@@ -0,0 +1,150 @@
+'use strict'
+
+const util = require('util')
+
+const {
+  addHook,
+  AsyncResource
+} = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+const dc = require('dc-polyfill')
+
+const childProcessChannel = dc.tracingChannel('datadog:child_process:execution')
+
+// ignored exec method because it calls to execFile directly
+const execAsyncMethods = ['execFile', 'spawn']
+const execSyncMethods = ['execFileSync', 'spawnSync']
+
+const names = ['child_process', 'node:child_process']
+
+// child_process and node:child_process returns the same object instance, we only want to add hooks once
+let patched = false
+names.forEach(name => {
+  addHook({ name }, childProcess => {
+    if (!patched) {
+      patched = true
+      shimmer.massWrap(childProcess, execAsyncMethods, wrapChildProcessAsyncMethod())
+      shimmer.massWrap(childProcess, execSyncMethods, wrapChildProcessSyncMethod())
+      shimmer.wrap(childProcess, 'execSync', wrapChildProcessSyncMethod(true))
+    }
+
+    return childProcess
+  })
+})
+
+function normalizeArgs (args, shell) {
+  const childProcessInfo = {
+    command: args[0]
+  }
+
+  if (Array.isArray(args[1])) {
+    childProcessInfo.command = childProcessInfo.command + ' ' + args[1].join(' ')
+    if (args[2] != null && typeof args[2] === 'object') {
+      childProcessInfo.options = args[2]
+    }
+  } else if (args[1] != null && typeof args[1] === 'object') {
+    childProcessInfo.options = args[1]
+  }
+  childProcessInfo.shell = shell ||
+    childProcessInfo.options?.shell === true ||
+    typeof childProcessInfo.options?.shell === 'string'
+
+  return childProcessInfo
+}
+
+function wrapChildProcessSyncMethod (shell = false) {
+  return function wrapMethod (childProcessMethod) {
+    return function () {
+      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
+        return childProcessMethod.apply(this, arguments)
+      }
+
+      const childProcessInfo = normalizeArgs(arguments, shell)
+
+      return childProcessChannel.traceSync(
+        childProcessMethod,
+        {
+          command: childProcessInfo.command,
+          shell: childProcessInfo.shell
+        },
+        this,
+        ...arguments)
+    }
+  }
+}
+
+function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
+  return function () {
+    if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
+      return customPromisifyMethod.apply(this, arguments)
+    }
+
+    const childProcessInfo = normalizeArgs(arguments, shell)
+
+    return childProcessChannel.tracePromise(
+      customPromisifyMethod,
+      {
+        command: childProcessInfo.command,
+        shell: childProcessInfo.shell
+      },
+      this,
+      ...arguments)
+  }
+}
+
+function wrapChildProcessAsyncMethod (shell = false) {
+  return function wrapMethod (childProcessMethod) {
+    function wrappedChildProcessMethod () {
+      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
+        return childProcessMethod.apply(this, arguments)
+      }
+
+      const childProcessInfo = normalizeArgs(arguments, shell)
+
+      const innerResource = new AsyncResource('bound-anonymous-fn')
+      return innerResource.runInAsyncScope(() => {
+        childProcessChannel.start.publish({ command: childProcessInfo.command, shell: childProcessInfo.shell })
+
+        const childProcess = childProcessMethod.apply(this, arguments)
+        if (childProcess) {
+          let errorExecuted = false
+
+          childProcess.on('error', (e) => {
+            errorExecuted = true
+            childProcessChannel.error.publish(e)
+          })
+
+          childProcess.on('close', (code) => {
+            code = code || 0
+            if (!errorExecuted && code !== 0) {
+              childProcessChannel.error.publish()
+            }
+            childProcessChannel.asyncEnd.publish({
+              command: childProcessInfo.command,
+              shell: childProcessInfo.shell,
+              result: code
+            })
+          })
+        }
+
+        return childProcess
+      })
+    }
+
+    if (childProcessMethod[util.promisify.custom]) {
+      const wrapedChildProcessCustomPromisifyMethod =
+        shimmer.wrap(childProcessMethod[util.promisify.custom],
+          wrapChildProcessCustomPromisifyMethod(childProcessMethod[util.promisify.custom]), shell)
+
+      // should do it in this way because the original property is readonly
+      const descriptor = Object.getOwnPropertyDescriptor(childProcessMethod, util.promisify.custom)
+      Object.defineProperty(wrappedChildProcessMethod,
+        util.promisify.custom,
+        {
+          ...descriptor,
+          value: wrapedChildProcessCustomPromisifyMethod
+        })
+    }
+    return wrappedChildProcessMethod
+  }
+}

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

@@ -252,9 +252,10 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.
   return Cluster
 })
 
-// semver >=3.2.0
+// semver >=3.2.2
+// NOTE: <3.2.2 segfaults on cluster.close() https://issues.couchbase.com/browse/JSCBC-936
 
-addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }, collection => {
+addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }, collection => {
   const Collection = collection.Collection
 
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
@@ -264,7 +265,7 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.0'] }
   return collection
 })
 
-addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bucket => {
+addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
     return function () {
@@ -278,7 +279,7 @@ addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.0'] }, bu
   return bucket
 })
 
-addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['3.2.0 - 3.2.1', '>=3.2.2'] }, (cluster) => {
+addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)

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

@@ -11,8 +11,9 @@ const cryptoCipherCh = channel('datadog:crypto:cipher:start')
 
 const hashMethods = ['createHash', 'createHmac', 'createSign', 'createVerify', 'sign', 'verify']
 const cipherMethods = ['createCipheriv', 'createDecipheriv']
+const names = ['crypto', 'node:crypto']
 
-addHook({ name: 'crypto' }, crypto => {
+addHook({ name: names }, crypto => {
   shimmer.massWrap(crypto, hashMethods, wrapCryptoMethod(cryptoHashCh))
   shimmer.massWrap(crypto, cipherMethods, wrapCryptoMethod(cryptoCipherCh))
   return crypto