dd-trace 6.15.0 → 6.17.0

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -20,67 +20,76 @@ const identifierPattern = /^[$A-Z_a-z][$\w]*$/
 
 module.exports = {
   awaitContextCallback,
-  awaitContextCallbackAtFunctionStart,
-  awaitContextCallbackAtTryStart,
   configureGraphqlJitCompileObject,
   configureGraphqlJitDeferredField,
   configureGraphqlJitExecute,
   configureGraphqlJitRuntime,
   configureGraphqlFastPath,
   configureMercuriusRequest,
+  publishDurableOrchestrationFailure,
   waitForAsyncEnd,
 }
 
 /**
- * Awaits an optional context callback at the start of the matched node's enclosing async function.
+ * Publishes the error captured by Durable Functions immediately before its
+ * executor converts that error into a serialized failed orchestration state.
  *
- * @param {Parameters<typeof awaitContextCallback>[0]} state
- * @param {import('estree').Node} node
+ * @param {{
+ *   channelName: string,
+ *   transforms: { tracingChannelDeclaration: Function }
+ * }} state
+ * @param {import('estree').FunctionExpression} node
  * @param {import('estree').Node} _parent
  * @param {import('estree').Node[]} ancestry
- * @returns {void}
  */
-function awaitContextCallbackAtFunctionStart (state, node, _parent, ancestry) {
-  let enclosingFunction = functionTypes.has(node.type)
-    ? node
-    : ancestry.find(ancestor => functionTypes.has(ancestor.type))
-  let callbackAncestry = ancestry
-
-  if (enclosingFunction === node) {
-    callbackAncestry = [node, ...ancestry]
-    if (!node.async) {
-      // Function queries create a synchronous trace wrapper before custom transforms run.
-      const [wrappedFunction] = query(node,
-        'VariableDeclarator[id.name="__apm$traced"] > ArrowFunctionExpression > BlockStatement > ' +
-        'VariableDeclaration > VariableDeclarator[id.name="__apm$wrapped"] > ' +
-        ':matches(FunctionDeclaration, FunctionExpression)[async=true]')
-      if (wrappedFunction) {
-        enclosingFunction = wrappedFunction
-        callbackAncestry.unshift(wrappedFunction)
-      }
-    }
-  }
-  assert(enclosingFunction?.async && enclosingFunction.body?.type === 'BlockStatement',
-    'awaitContextCallbackAtFunctionStart: expected an enclosing async function with a block body')
+function publishDurableOrchestrationFailure (state, node, _parent, ancestry) {
+  // Class queries also visit the owning ClassDeclaration so Orchestrion can
+  // synthesize missing methods. This transform targets the concrete method only.
+  if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') return
+
+  const failureBranches = query(node, 'IfStatement').filter(({ test }) =>
+    test.type === 'BinaryExpression' &&
+    test.operator === '!==' &&
+    test.left?.type === 'MemberExpression' &&
+    test.left.object?.type === 'ThisExpression' &&
+    test.left.property?.name === 'exception' &&
+    test.right?.type === 'Identifier' &&
+    test.right.name === 'undefined'
+  )
 
-  const generatedCallback = createAwaitedContextCallback(
-    state,
-    enclosingFunction.body,
-    callbackAncestry,
-    'awaitContextCallbackAtFunctionStart'
+  assert.strictEqual(
+    failureBranches.length,
+    1,
+    'publishDurableOrchestrationFailure: executor failure branch not found'
   )
-  if (!generatedCallback) return
+  assert.strictEqual(
+    failureBranches[0].consequent.type,
+    'BlockStatement',
+    'publishDurableOrchestrationFailure: expected a block failure branch'
+  )
+
+  const program = ancestry.at(-1)
+  state.transforms.tracingChannelDeclaration(state, program)
 
-  let insertionIndex = 0
-  while (typeof enclosingFunction.body.body[insertionIndex]?.directive === 'string') insertionIndex++
-  enclosingFunction.body.body.splice(insertionIndex, 0, ...generatedCallback.callbackStatements)
+  const channelVariable = `tr_ch_apm$${state.channelName.replaceAll(/[^\w]/g, '_')}`
+  const publishStatements = parse(`
+    if (${channelVariable}.end.hasSubscribers) {
+      ${channelVariable}.end.publish({
+        arguments: [context, history],
+        error: this.exception
+      })
+    }
+  `).body
+
+  failureBranches[0].consequent.body.unshift(...publishStatements)
 }
 
 /**
- * Awaits an optional context callback before continuing through a matched conditional branch.
+ * Awaits an optional context callback at the start of a matched function or block, or before continuing through a
+ * matched conditional branch.
  *
- * The branch condition is checked again after the callback settles so the
- * original body does not run against state that changed while awaiting.
+ * A matched conditional branch is checked again after the callback settles so its original body does not run
+ * against state that changed while awaiting.
  *
  * @param {{
  *   transformOptions?: {
@@ -89,14 +98,61 @@ function awaitContextCallbackAtFunctionStart (state, node, _parent, ancestry) {
  *     callbackThis?: boolean
  *   }
  * }} state
- * @param {import('estree').IfStatement} node
+ * @param {
+ *   import('estree').ArrowFunctionExpression|
+ *   import('estree').BlockStatement|
+ *   import('estree').FunctionDeclaration|
+ *   import('estree').FunctionExpression|
+ *   import('estree').IfStatement
+ * } node
  * @param {import('estree').Node} _parent
  * @param {import('estree').Node[]} ancestry
- * @returns {void}
  */
 function awaitContextCallback (state, node, _parent, ancestry) {
+  let insertionTarget
+  let callbackAncestry = ancestry
+
+  if (node.type === 'BlockStatement') {
+    insertionTarget = node
+  } else if (functionTypes.has(node.type)) {
+    let callbackFunction = node
+    callbackAncestry = [node, ...ancestry]
+
+    if (!node.async) {
+      // Built-in function transforms run before later custom transforms. Keep knowledge of their generated wrapper
+      // here so instrumentation queries can continue to target the original function.
+      const [wrappedFunction] = query(node,
+        'VariableDeclarator[id.name="__apm$traced"] > ArrowFunctionExpression > BlockStatement > ' +
+        'VariableDeclaration > VariableDeclarator[id.name="__apm$wrapped"] > ' +
+        ':matches(ArrowFunctionExpression, FunctionDeclaration, FunctionExpression)[async=true]')
+      if (wrappedFunction) {
+        callbackFunction = wrappedFunction
+        callbackAncestry.unshift(wrappedFunction)
+      }
+    }
+
+    assert(callbackFunction.async && callbackFunction.body?.type === 'BlockStatement',
+      'awaitContextCallback: expected an async function with a block body')
+    insertionTarget = callbackFunction.body
+  }
+
+  if (insertionTarget) {
+    const generatedCallback = createAwaitedContextCallback(
+      state,
+      insertionTarget,
+      callbackAncestry,
+      'awaitContextCallback'
+    )
+    if (!generatedCallback) return
+
+    let insertionIndex = 0
+    while (typeof insertionTarget.body[insertionIndex]?.directive === 'string') insertionIndex++
+    insertionTarget.body.splice(insertionIndex, 0, ...generatedCallback.callbackStatements)
+    return
+  }
+
   assert(node.type === 'IfStatement' && node.consequent?.type === 'BlockStatement',
-    'awaitContextCallback: expected an if statement with a block body')
+    'awaitContextCallback: expected a function, a block, or an if statement with a block body')
 
   const originalStatements = node.consequent.body
   const generatedCallback = createAwaitedContextCallback(
@@ -121,35 +177,6 @@ function awaitContextCallback (state, node, _parent, ancestry) {
   node.consequent.body = [...callbackStatements, callbackBranch]
 }
 
-/**
- * Awaits an optional context callback before entering the matched node's enclosing try block.
- *
- * @param {Parameters<typeof awaitContextCallback>[0]} state
- * @param {import('estree').Node} node
- * @param {import('estree').Node} _parent
- * @param {import('estree').Node[]} ancestry
- * @returns {void}
- */
-function awaitContextCallbackAtTryStart (state, node, _parent, ancestry) {
-  let tryStatement = node.type === 'TryStatement' ? node : undefined
-  for (const ancestor of ancestry) {
-    if (tryStatement || functionTypes.has(ancestor.type)) break
-    if (ancestor.type === 'TryStatement') tryStatement = ancestor
-  }
-  assert(tryStatement?.block?.type === 'BlockStatement',
-    'awaitContextCallbackAtTryStart: expected an enclosing try statement with a block body')
-
-  const generatedCallback = createAwaitedContextCallback(
-    state,
-    tryStatement.block,
-    ancestry,
-    'awaitContextCallbackAtTryStart'
-  )
-  if (!generatedCallback) return
-
-  tryStatement.block.body.unshift(...generatedCallback.callbackStatements)
-}
-
 /**
  * @param {Parameters<typeof awaitContextCallback>[0]} state
  * @param {import('estree').BlockStatement} insertionTarget
@@ -329,7 +356,6 @@ function replaceIdentifier (root, name, replacement) {
  * @param {import('estree').Node} root
  * @param {import('estree').Node} target
  * @param {import('estree').Node[]} statements
- * @returns {boolean}
  */
 function insertBeforeStatement (root, target, statements) {
   for (const key of Object.keys(root)) {
@@ -639,7 +665,6 @@ function configureMercuriusRequest (_state, node) {
  *
  * @param {object} _state
  * @param {import('estree').CallExpression} node
- * @returns {void}
  */
 function waitForAsyncEnd (_state, node) {
   const onFulfilled = node.arguments[0]
@@ -659,7 +684,6 @@ function waitForAsyncEnd (_state, node) {
  * @param {import('estree').BlockStatement} body
  * @param {'ReturnStatement'|'ThrowStatement'} exitType
  * @param {'resolveCallback'|'rejectCallback'} callbackProperty
- * @returns {void}
  */
 function injectAsyncEndCallbackWait (body, exitType, callbackProperty) {
   const callbackVariable = `__apm$${callbackProperty}`

package/packages/datadog-instrumentations/src/helpers/router-helper.js

@@ -141,7 +141,6 @@ function getRouterMountPaths (router) {
 /**
  * @param {object} layer
  * @param {LayerMeta} meta
- * @returns {void}
  */
 function setLayerMeta (layer, meta) {
   layerMeta.set(layer, meta)