dd-trace 4.47.1 → 4.49.0

package/packages/dd-trace/src/debugger/devtools_client/snapshot/collector.js

@@ -0,0 +1,187 @@
+'use strict'
+
+const { collectionSizeSym, fieldCountSym } = require('./symbols')
+const session = require('../session')
+
+const LEAF_SUBTYPES = new Set(['date', 'regexp'])
+const ITERABLE_SUBTYPES = new Set(['map', 'set', 'weakmap', 'weakset'])
+
+module.exports = {
+  getRuntimeObject: getObject
+}
+
+// TODO: Can we speed up thread pause time by calling mutiple Runtime.getProperties in parallel when possible?
+// The most simple solution would be to swich from an async/await approach to a callback based approach, in which case
+// each lookup will just finish in its own time and traverse the child nodes when the event loop allows it.
+// Alternatively, use `Promise.all` or something like that, but the code would probably be more complex.
+
+async function getObject (objectId, opts, depth = 0, collection = false) {
+  const { result, privateProperties } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  if (collection) {
+    // Trim the collection if it's too large.
+    // Collections doesn't contain private properties, so the code in this block doesn't have to deal with it.
+    removeNonEnumerableProperties(result) // remove the `length` property
+    const size = result.length
+    if (size > opts.maxCollectionSize) {
+      result.splice(opts.maxCollectionSize)
+      result[collectionSizeSym] = size
+    }
+  } else if (result.length > opts.maxFieldCount) {
+    // Trim the number of properties on the object if there's too many.
+    const size = result.length
+    result.splice(opts.maxFieldCount)
+    result[fieldCountSym] = size
+  } else if (privateProperties) {
+    result.push(...privateProperties)
+  }
+
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+async function traverseGetPropertiesResult (props, opts, depth) {
+  // TODO: Decide if we should filter out non-enumerable properties or not:
+  // props = props.filter((e) => e.enumerable)
+
+  if (depth >= opts.maxReferenceDepth) return props
+
+  for (const prop of props) {
+    if (prop.value === undefined) continue
+    const { value: { type, objectId, subtype } } = prop
+    if (type === 'object') {
+      if (objectId === undefined) continue // if `subtype` is "null"
+      if (LEAF_SUBTYPES.has(subtype)) continue // don't waste time with these subtypes
+      prop.value.properties = await getObjectProperties(subtype, objectId, opts, depth)
+    } else if (type === 'function') {
+      prop.value.properties = await getFunctionProperties(objectId, opts, depth + 1)
+    }
+  }
+
+  return props
+}
+
+async function getObjectProperties (subtype, objectId, opts, depth) {
+  if (ITERABLE_SUBTYPES.has(subtype)) {
+    return getIterable(objectId, opts, depth)
+  } else if (subtype === 'promise') {
+    return getInternalProperties(objectId, opts, depth)
+  } else if (subtype === 'proxy') {
+    return getProxy(objectId, opts, depth)
+  } else if (subtype === 'arraybuffer') {
+    return getArrayBuffer(objectId, opts, depth)
+  } else {
+    return getObject(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
+  }
+}
+
+// TODO: The following extra information from `internalProperties` might be relevant to include for functions:
+// - Bound function: `[[TargetFunction]]`, `[[BoundThis]]` and `[[BoundArgs]]`
+// - Non-bound function: `[[FunctionLocation]]`, and `[[Scopes]]`
+async function getFunctionProperties (objectId, opts, depth) {
+  let { result } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  // For legacy reasons (I assume) functions has a `prototype` property besides the internal `[[Prototype]]`
+  result = result.filter(({ name }) => name !== 'prototype')
+
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+async function getIterable (objectId, opts, depth) {
+  // TODO: If the iterable has any properties defined on the object directly, instead of in its collection, they will
+  // exist in the return value below in the `result` property. We currently do not collect these.
+  const { internalProperties } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  let entry = internalProperties[1]
+  if (entry.name !== '[[Entries]]') {
+    // Currently `[[Entries]]` is the last of 2 elements, but in case this ever changes, fall back to searching
+    entry = internalProperties.findLast(({ name }) => name === '[[Entries]]')
+  }
+
+  // Skip the `[[Entries]]` level and go directly to the content of the iterable
+  const { result } = await session.post('Runtime.getProperties', {
+    objectId: entry.value.objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  removeNonEnumerableProperties(result) // remove the `length` property
+  const size = result.length
+  if (size > opts.maxCollectionSize) {
+    result.splice(opts.maxCollectionSize)
+    result[collectionSizeSym] = size
+  }
+
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+async function getInternalProperties (objectId, opts, depth) {
+  const { internalProperties } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  // We want all internal properties except the prototype
+  const props = internalProperties.filter(({ name }) => name !== '[[Prototype]]')
+
+  return traverseGetPropertiesResult(props, opts, depth)
+}
+
+async function getProxy (objectId, opts, depth) {
+  const { internalProperties } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  // TODO: If we do not skip the proxy wrapper, we can add a `revoked` boolean
+  let entry = internalProperties[1]
+  if (entry.name !== '[[Target]]') {
+    // Currently `[[Target]]` is the last of 2 elements, but in case this ever changes, fall back to searching
+    entry = internalProperties.findLast(({ name }) => name === '[[Target]]')
+  }
+
+  // Skip the `[[Target]]` level and go directly to the target of the Proxy
+  const { result } = await session.post('Runtime.getProperties', {
+    objectId: entry.value.objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+// Support for ArrayBuffer is a bit trickly because the internal structure stored in `internalProperties` is not
+// documented and is not straight forward. E.g. ArrayBuffer(3) will internally contain both Int8Array(3) and
+// UInt8Array(3), whereas ArrayBuffer(8) internally contains both Int8Array(8), Uint8Array(8), Int16Array(4), and
+// Int32Array(2) - all representing the same data in different ways.
+async function getArrayBuffer (objectId, opts, depth) {
+  const { internalProperties } = await session.post('Runtime.getProperties', {
+    objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  // Use Uint8 to make it easy to convert to a string later.
+  const entry = internalProperties.find(({ name }) => name === '[[Uint8Array]]')
+
+  // Skip the `[[Uint8Array]]` level and go directly to the content of the ArrayBuffer
+  const { result } = await session.post('Runtime.getProperties', {
+    objectId: entry.value.objectId,
+    ownProperties: true // exclude inherited properties
+  })
+
+  return traverseGetPropertiesResult(result, opts, depth)
+}
+
+function removeNonEnumerableProperties (props) {
+  for (let i = 0; i < props.length; i++) {
+    if (props[i].enumerable === false) {
+      props.splice(i--, 1)
+    }
+  }
+}

package/packages/dd-trace/src/debugger/devtools_client/snapshot/index.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { getRuntimeObject } = require('./collector')
+const { processRawState } = require('./processor')
+
+const DEFAULT_MAX_REFERENCE_DEPTH = 3
+const DEFAULT_MAX_COLLECTION_SIZE = 100
+const DEFAULT_MAX_FIELD_COUNT = 20
+const DEFAULT_MAX_LENGTH = 255
+
+module.exports = {
+  getLocalStateForCallFrame
+}
+
+async function getLocalStateForCallFrame (
+  callFrame,
+  {
+    maxReferenceDepth = DEFAULT_MAX_REFERENCE_DEPTH,
+    maxCollectionSize = DEFAULT_MAX_COLLECTION_SIZE,
+    maxFieldCount = DEFAULT_MAX_FIELD_COUNT,
+    maxLength = DEFAULT_MAX_LENGTH
+  } = {}
+) {
+  const rawState = []
+  let processedState = null
+
+  for (const scope of callFrame.scopeChain) {
+    if (scope.type === 'global') continue // The global scope is too noisy
+    rawState.push(...await getRuntimeObject(
+      scope.object.objectId,
+      { maxReferenceDepth, maxCollectionSize, maxFieldCount }
+    ))
+  }
+
+  // Deplay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
+  return () => {
+    processedState = processedState ?? processRawState(rawState, maxLength)
+    return processedState
+  }
+}

package/packages/dd-trace/src/debugger/devtools_client/snapshot/processor.js

@@ -0,0 +1,252 @@
+'use strict'
+
+const { collectionSizeSym, fieldCountSym } = require('./symbols')
+
+module.exports = {
+  processRawState: processProperties
+}
+
+// Matches classes in source code, no matter how it's written:
+// - Named:                          class MyClass {}
+// - Anonymous:                      class {}
+// - Named, with odd whitespace:     class\n\t MyClass\n{}
+// - Anonymous, with odd whitespace: class\n{}
+const CLASS_REGEX = /^class\s([^{]*)/
+
+function processProperties (props, maxLength) {
+  const result = {}
+
+  for (const prop of props) {
+    // TODO: Hack to avoid periods in keys, as EVP doesn't support that. A better solution can be implemented later
+    result[prop.name.replaceAll('.', '_')] = getPropertyValue(prop, maxLength)
+  }
+
+  return result
+}
+
+function getPropertyValue (prop, maxLength) {
+  // Special case for getters and setters which does not have a value property
+  if ('get' in prop) {
+    const hasGet = prop.get.type !== 'undefined'
+    const hasSet = prop.set.type !== 'undefined'
+    if (hasGet && hasSet) return { type: 'getter/setter' }
+    if (hasGet) return { type: 'getter' }
+    if (hasSet) return { type: 'setter' }
+  }
+
+  switch (prop.value?.type) {
+    case 'object':
+      return getObjectValue(prop.value, maxLength)
+    case 'function':
+      return toFunctionOrClass(prop.value, maxLength)
+    case undefined: // TODO: Add test for when a prop has no value. I think it's if it's defined after the breakpoint?
+    case 'undefined':
+      return { type: 'undefined' }
+    case 'string':
+      return toString(prop.value.value, maxLength)
+    case 'number':
+      return { type: 'number', value: prop.value.description } // use `descripton` to get it as string
+    case 'boolean':
+      return { type: 'boolean', value: prop.value.value === true ? 'true' : 'false' }
+    case 'symbol':
+      return { type: 'symbol', value: prop.value.description }
+    case 'bigint':
+      return { type: 'bigint', value: prop.value.description.slice(0, -1) } // remove trailing `n`
+    default:
+      // As of this writing, the Chrome DevTools Protocol doesn't allow any other types than the ones listed above, but
+      // in the future new ones might be added.
+      return { type: prop.value.type, notCapturedReason: 'Unsupported property type' }
+  }
+}
+
+function getObjectValue (obj, maxLength) {
+  switch (obj.subtype) {
+    case undefined:
+      return toObject(obj.className, obj.properties, maxLength)
+    case 'array':
+      return toArray(obj.className, obj.properties, maxLength)
+    case 'null':
+      return { type: 'null', isNull: true }
+    // case 'node': // TODO: What does this subtype represent?
+    case 'regexp':
+      return { type: obj.className, value: obj.description }
+    case 'date':
+      // TODO: This looses millisecond resolution, as that's not retained in the `.toString()` representation contained
+      // in the `description` field. Unfortunately that's all we get from the Chrome DevTools Protocol.
+      return { type: obj.className, value: `${new Date(obj.description).toISOString().slice(0, -5)}Z` }
+    case 'map':
+      return toMap(obj.className, obj.properties, maxLength)
+    case 'set':
+      return toSet(obj.className, obj.properties, maxLength)
+    case 'weakmap':
+      return toMap(obj.className, obj.properties, maxLength)
+    case 'weakset':
+      return toSet(obj.className, obj.properties, maxLength)
+    // case 'iterator': // TODO: I've not been able to trigger this subtype
+    case 'generator':
+      // Use `subtype` instead of `className` to make it obvious it's a generator
+      return toObject(obj.subtype, obj.properties, maxLength)
+    case 'error':
+      // TODO: Convert stack trace to array to avoid string trunctation or disable truncation in this case?
+      return toObject(obj.className, obj.properties, maxLength)
+    case 'proxy':
+      // Use `desciption` instead of `className` as the `type` to get type of target object (`Proxy(Error)` vs `proxy`)
+      return toObject(obj.description, obj.properties, maxLength)
+    case 'promise':
+      return toObject(obj.className, obj.properties, maxLength)
+    case 'typedarray':
+      return toArray(obj.className, obj.properties, maxLength)
+    case 'arraybuffer':
+      return toArrayBuffer(obj.className, obj.properties, maxLength)
+    // case 'dataview': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
+    // case 'webassemblymemory': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
+    // case 'wasmvalue': // TODO: I've not been able to trigger this subtype
+    default:
+      // As of this writing, the Chrome DevTools Protocol doesn't allow any other subtypes than the ones listed above,
+      // but in the future new ones might be added.
+      return { type: obj.subtype, notCapturedReason: 'Unsupported object type' }
+  }
+}
+
+function toFunctionOrClass (value, maxLength) {
+  const classMatch = value.description.match(CLASS_REGEX)
+
+  if (classMatch === null) {
+    // This is a function
+    // TODO: Would it make sense to detect if it's an arrow function or not?
+    return toObject(value.className, value.properties, maxLength)
+  } else {
+    // This is a class
+    const className = classMatch[1].trim()
+    return { type: className ? `class ${className}` : 'class' }
+  }
+}
+
+function toString (str, maxLength) {
+  const size = str.length
+
+  if (size <= maxLength) {
+    return { type: 'string', value: str }
+  }
+
+  return {
+    type: 'string',
+    value: str.substr(0, maxLength),
+    truncated: true,
+    size
+  }
+}
+
+function toObject (type, props, maxLength) {
+  if (props === undefined) return notCapturedDepth(type)
+
+  const result = {
+    type,
+    fields: processProperties(props, maxLength)
+  }
+
+  if (fieldCountSym in props) {
+    result.notCapturedReason = 'fieldCount'
+    result.size = props[fieldCountSym]
+  }
+
+  return result
+}
+
+function toArray (type, elements, maxLength) {
+  if (elements === undefined) return notCapturedDepth(type)
+
+  // Perf: Create array of expected size in advance (expect that it contains only one non-enumrable element)
+  const result = { type, elements: new Array(elements.length) }
+
+  setNotCaptureReasonOnCollection(result, elements)
+
+  let i = 0
+  for (const elm of elements) {
+    result.elements[i++] = getPropertyValue(elm, maxLength)
+  }
+
+  return result
+}
+
+function toMap (type, pairs, maxLength) {
+  if (pairs === undefined) return notCapturedDepth(type)
+
+  // Perf: Create array of expected size in advance
+  const result = { type, entries: new Array(pairs.length) }
+
+  setNotCaptureReasonOnCollection(result, pairs)
+
+  let i = 0
+  for (const pair of pairs) {
+    // The following code is based on assumptions made when researching the output of the Chrome DevTools Protocol.
+    // There doesn't seem to be any documentation to back it up:
+    //
+    // `pair.value` is a special wrapper-object with subtype `internal#entry`. This can be skipped and we can go
+    // directly to its children, of which there will always be exactly two, the first containing the key, and the
+    // second containing the value of this entry of the Map.
+    const key = getPropertyValue(pair.value.properties[0], maxLength)
+    const val = getPropertyValue(pair.value.properties[1], maxLength)
+    result.entries[i++] = [key, val]
+  }
+
+  return result
+}
+
+function toSet (type, values, maxLength) {
+  if (values === undefined) return notCapturedDepth(type)
+
+  // Perf: Create array of expected size in advance (expect that it contains only one non-enumrable element)
+  const result = { type, elements: new Array(values.length) }
+
+  setNotCaptureReasonOnCollection(result, values)
+
+  let i = 0
+  for (const value of values) {
+    // The following code is based on assumptions made when researching the output of the Chrome DevTools Protocol.
+    // There doesn't seem to be any documentation to back it up:
+    //
+    // `value.value` is a special wrapper-object with subtype `internal#entry`. This can be skipped and we can go
+    // directly to its children, of which there will always be exactly one, which contain the actual value in this entry
+    // of the Set.
+    result.elements[i++] = getPropertyValue(value.value.properties[0], maxLength)
+  }
+
+  return result
+}
+
+function toArrayBuffer (type, bytes, maxLength) {
+  if (bytes === undefined) return notCapturedDepth(type)
+
+  const size = bytes.length
+
+  if (size > maxLength) {
+    return {
+      type,
+      value: arrayBufferToString(bytes, maxLength),
+      truncated: true,
+      size: bytes.length
+    }
+  } else {
+    return { type, value: arrayBufferToString(bytes, size) }
+  }
+}
+
+function arrayBufferToString (bytes, size) {
+  const buf = Buffer.allocUnsafe(size)
+  for (let i = 0; i < size; i++) {
+    buf[i] = bytes[i].value.value
+  }
+  return buf.toString()
+}
+
+function setNotCaptureReasonOnCollection (result, collection) {
+  if (collectionSizeSym in collection) {
+    result.notCapturedReason = 'collectionSize'
+    result.size = collection[collectionSizeSym]
+  }
+}
+
+function notCapturedDepth (type) {
+  return { type, notCapturedReason: 'depth' }
+}

package/packages/dd-trace/src/debugger/devtools_client/snapshot/symbols.js

@@ -0,0 +1,6 @@
+'use stict'
+
+module.exports = {
+  collectionSizeSym: Symbol('datadog.collectionSize'),
+  fieldCountSym: Symbol('datadog.fieldCount')
+}

package/packages/dd-trace/src/debugger/devtools_client/state.js

@@ -2,7 +2,8 @@
 
 const session = require('./session')
 
-const scripts = []
+const scriptIds = []
+const scriptUrls = new Map()
 
 module.exports = {
   probes: new Map(),
@@ -25,10 +26,23 @@ module.exports = {
    * @param {string} path
    * @returns {[string, string] | undefined}
    */
-  getScript (path) {
-    return scripts
+  findScriptFromPartialPath (path) {
+    return scriptIds
       .filter(([url]) => url.endsWith(path))
       .sort(([a], [b]) => a.length - b.length)[0]
+  },
+
+  getStackFromCallFrames (callFrames) {
+    return callFrames.map((frame) => {
+      let fileName = scriptUrls.get(frame.location.scriptId)
+      if (fileName.startsWith('file://')) fileName = fileName.substr(7) // TODO: This might not be required
+      return {
+        fileName,
+        function: frame.functionName,
+        lineNumber: frame.location.lineNumber + 1, // Beware! lineNumber is zero-indexed
+        columnNumber: frame.location.columnNumber + 1 // Beware! columnNumber is zero-indexed
+      }
+    })
   }
 }
 
@@ -41,7 +55,8 @@ module.exports = {
 // - `` - Not sure what this is, but should just be ignored
 // TODO: Event fired for all files, every time debugger is enabled. So when we disable it, we need to reset the state
 session.on('Debugger.scriptParsed', ({ params }) => {
+  scriptUrls.set(params.scriptId, params.url)
   if (params.url.startsWith('file:')) {
-    scripts.push([params.url, params.scriptId])
+    scriptIds.push([params.url, params.scriptId])
   }
 })

package/packages/dd-trace/src/debugger/index.js

@@ -6,6 +6,7 @@ const log = require('../log')
 
 let worker = null
 let configChannel = null
+let ackId = 0
 
 const { NODE_OPTIONS, ...env } = process.env
 
@@ -24,13 +25,19 @@ function start (config, rc) {
   configChannel = new MessageChannel()
 
   rc.setProductHandler('LIVE_DEBUGGING', (action, conf, id, ack) => {
-    const ackId = `${id}-${conf.version}`
-    rcAckCallbacks.set(ackId, ack)
+    rcAckCallbacks.set(++ackId, ack)
     rcChannel.port2.postMessage({ action, conf, ackId })
   })
 
   rcChannel.port2.on('message', ({ ackId, error }) => {
-    rcAckCallbacks.get(ackId)(error)
+    const ack = rcAckCallbacks.get(ackId)
+    if (ack === undefined) {
+      // This should never happen, but just in case something changes in the future, we should guard against it
+      log.error(`Received an unknown ackId: ${ackId}`)
+      if (error) log.error(error)
+      return
+    }
+    ack(error)
     rcAckCallbacks.delete(ackId)
   })
   rcChannel.port2.on('messageerror', (err) => log.error(err))

package/packages/dd-trace/src/exporters/common/request.js

@@ -6,10 +6,9 @@
 const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
-// eslint-disable-next-line n/no-deprecated-api
-const { parse: urlParse } = require('url')
 const zlib = require('zlib')
 
+const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 const { storage } = require('../../../../datadog-core')
@@ -20,39 +19,14 @@ const containerId = docker.id()
 
 let activeRequests = 0
 
-// TODO: Replace with `url.urlToHttpOptions` when supported by all versions
-function urlToOptions (url) {
-  const agent = url.agent || http.globalAgent
-  const options = {
-    protocol: url.protocol || agent.protocol,
-    hostname: typeof url.hostname === 'string' && url.hostname.startsWith('[')
-      ? url.hostname.slice(1, -1)
-      : url.hostname ||
-      url.host ||
-      'localhost',
-    hash: url.hash,
-    search: url.search,
-    pathname: url.pathname,
-    path: `${url.pathname || ''}${url.search || ''}`,
-    href: url.href
-  }
-  if (url.port !== '') {
-    options.port = Number(url.port)
-  }
-  if (url.username || url.password) {
-    options.auth = `${url.username}:${url.password}`
-  }
-  return options
-}
+function parseUrl (urlObjOrString) {
+  if (typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
 
-function fromUrlString (urlString) {
-  const url = typeof urlToHttpOptions === 'function'
-    ? urlToOptions(new URL(urlString))
-    : urlParse(urlString)
+  const url = urlToHttpOptions(new URL(urlObjOrString))
 
-  // Add the 'hostname' back if we're using named pipes
-  if (url.protocol === 'unix:' && url.host === '.') {
-    const udsPath = urlString.replace(/^unix:/, '')
+  // Special handling if we're using named pipes on Windows
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    const udsPath = urlObjOrString.slice(5)
     url.path = udsPath
     url.pathname = udsPath
   }
@@ -66,7 +40,7 @@ function request (data, options, callback) {
   }
 
   if (options.url) {
-    const url = typeof options.url === 'object' ? urlToOptions(options.url) : fromUrlString(options.url)
+    const url = parseUrl(options.url)
     if (url.protocol === 'unix:') {
       options.socketPath = url.pathname
     } else {

package/packages/dd-trace/src/exporters/common/url-to-http-options-polyfill.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const { urlToHttpOptions } = require('url')
+
+// TODO: Remove `urlToHttpOptions` polyfill once we drop support for the older Cypress versions that uses a built-in
+// version of Node.js doesn't include that function.
+module.exports = {
+  urlToHttpOptions: urlToHttpOptions ?? function (url) {
+    const { hostname, pathname, port, username, password, search } = url
+    const options = {
+      __proto__: null,
+      ...url, // In case the url object was extended by the user.
+      protocol: url.protocol,
+      hostname: typeof hostname === 'string' && hostname.startsWith('[')
+        ? hostname.slice(1, -1)
+        : hostname,
+      hash: url.hash,
+      search,
+      pathname,
+      path: `${pathname || ''}${search || ''}`,
+      href: url.href
+    }
+    if (port !== '') {
+      options.port = Number(port)
+    }
+    if (username || password) {
+      options.auth = `${decodeURIComponent(username)}:${decodeURIComponent(password)}`
+    }
+    return options
+  }
+}