dd-trace 5.108.0 → 5.109.0

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

@@ -3,11 +3,52 @@
 const dc = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const { addHook } = require('./helpers/instrument')
-const aiGuard = require('./helpers/openai-ai-guard')
 
 const ch = dc.tracingChannel('apm:openai:request')
 const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
 
+// Provider lifecycle channels. Payloads stay OpenAI-native:
+// before { args, parentSpan, abortController, pending }
+// after  { args, body, parentSpan, abortController, pending }
+const chatCompletionsBeforeChannel = dc.channel('dd-trace:openai:chat.completions:before')
+const chatCompletionsAfterChannel = dc.channel('dd-trace:openai:chat.completions:after')
+const responsesBeforeChannel = dc.channel('dd-trace:openai:responses:before')
+const responsesAfterChannel = dc.channel('dd-trace:openai:responses:after')
+
+const LIFECYCLE_CHANNELS = {
+  'chat.completions': {
+    before: chatCompletionsBeforeChannel,
+    after: chatCompletionsAfterChannel,
+  },
+  responses: {
+    before: responsesBeforeChannel,
+    after: responsesAfterChannel,
+  },
+}
+
+/**
+ * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
+ *
+ * Subscribers push async work into `pending` synchronously during publication and
+ * abort `abortController` with an error before the pushed promise resolves to block.
+ *
+ * @param {object} channel
+ * @param {object} payload
+ * @returns {Promise<void>}
+ */
+function publishLifecycle (channel, payload) {
+  const abortController = new AbortController()
+  const ctx = { ...payload, abortController, pending: [] }
+
+  channel.publish(ctx)
+
+  return Promise.all(ctx.pending).then(() => {
+    if (abortController.signal.aborted) {
+      throw abortController.signal.reason
+    }
+  })
+}
+
 const V4_PACKAGE_SHIMS = [
   {
     file: 'resources/chat/completions',
@@ -217,17 +258,15 @@ for (const extension of extensions) {
 
       for (const methodName of methods) {
         shimmer.wrap(targetPrototype, methodName, methodFn => function (...args) {
-          if (!ch.start.hasSubscribers && !aiGuard.hasSubscribers()) {
-            return methodFn.apply(this, args)
-          }
           // The OpenAI library lets you set `stream: true` on the options arg to any method
           // However, we only want to handle streamed responses in specific cases
           // chat.completions and completions
           const stream = streamedResponse && getOption(args, 'stream', false)
 
-          const guard = aiGuard.createGuard(baseResource, args[0], stream)
+          const channels = stream ? null : LIFECYCLE_CHANNELS[baseResource]
+          const hasLifecycle = !!channels && (channels.before.hasSubscribers || channels.after.hasSubscribers)
 
-          if (!ch.start.hasSubscribers && !guard) {
+          if (!ch.start.hasSubscribers && !hasLifecycle) {
             return methodFn.apply(this, args)
           }
 
@@ -240,12 +279,22 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
-            // Explicit childOf rather than async-context: the _thenUnwrap/parse path
-            // decouples the lazy evaluation from the active scope at call time.
-            if (guard) guard.parentSpan = ctx.currentStore?.span
+            // Capture the parent span explicitly: the _thenUnwrap/parse path decouples
+            // the lazy evaluation from the active scope at call time.
+            const parentSpan = hasLifecycle ? ctx.currentStore?.span : undefined
 
             const apiProm = methodFn.apply(this, args)
 
+            const beforeChannel = hasLifecycle && channels.before.hasSubscribers ? channels.before : null
+            const afterChannel = hasLifecycle && channels.after.hasSubscribers ? channels.after : null
+            let beforeVerdict
+            const getBeforeVerdict = beforeChannel
+              ? function getBeforeVerdict () {
+                beforeVerdict ??= publishLifecycle(beforeChannel, { args, parentSpan })
+                return beforeVerdict
+              }
+              : null
+
             if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
               // this should only ever be invoked from a client.beta.chat.completions.parse call
               shimmer.wrap(apiProm, '_thenUnwrap', origApiPromThenUnwrap => function (...args) {
@@ -259,7 +308,9 @@ for (const extension of extensions) {
                   const parsedPromise = origApiPromParse.apply(this, args)
                     .then(body => Promise.all([this.responsePromise, body]))
 
-                  return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
+                  return handleUnwrappedAPIPromise(
+                    parsedPromise, ctx, stream, getBeforeVerdict, afterChannel, parentSpan
+                  )
                 })
 
                 return unwrappedPromise
@@ -272,10 +323,16 @@ for (const extension of extensions) {
               const parsedPromise = origApiPromParse.apply(this, args)
                 .then(body => Promise.all([this.responsePromise, body]))
 
-              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, guard)
+              return handleUnwrappedAPIPromise(parsedPromise, ctx, stream, getBeforeVerdict, afterChannel, parentSpan)
             })
 
-            if (guard) aiGuard.wrapAsResponse(apiProm, guard)
+            // Gate `.asResponse()` callers on the before verdict so raw-response paths still block.
+            if (beforeChannel && typeof apiProm.asResponse === 'function') {
+              shimmer.wrap(apiProm, 'asResponse', origAsResponse => function (...args) {
+                const responsePromise = origAsResponse.apply(this, args)
+                return Promise.all([getBeforeVerdict(), responsePromise]).then(([, response]) => response)
+              })
+            }
 
             ch.end.publish(ctx)
 
@@ -288,10 +345,12 @@ for (const extension of extensions) {
   }
 }
 
-function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
-  const guardedApiProm = guard ? aiGuard.gateParse(apiProm, guard) : apiProm
+function handleUnwrappedAPIPromise (apiProm, ctx, stream, getBeforeVerdict, afterChannel, parentSpan) {
+  const gatedApiProm = getBeforeVerdict
+    ? Promise.all([getBeforeVerdict(), apiProm]).then(([, result]) => result)
+    : apiProm
 
-  return guardedApiProm
+  return gatedApiProm
     .then(([{ response, options }, body]) => {
       if (stream) {
         if (body.iterator) {
@@ -313,14 +372,14 @@ function handleUnwrappedAPIPromise (apiProm, ctx, stream, guard) {
         },
       }
 
-      if (!guard) {
+      if (!afterChannel) {
         finish(ctx, responseData)
         return body
       }
 
       // Finish after evaluation so a block propagates the error to openai.request
-      // and the span wraps its ai_guard child instead of closing before it.
-      return aiGuard.evaluateOutput(guard, body).then(() => {
+      // and the span wraps its child instead of closing before it.
+      return publishLifecycle(afterChannel, { args: ctx.args, body, parentSpan }).then(() => {
         finish(ctx, responseData)
         return body
       })

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

@@ -147,7 +147,6 @@ function getStartCtx (client, command, args, argsStartIndex) {
   }
 
   return {
-    db: client.selected_db,
     command,
     args,
     argsStartIndex,

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

@@ -143,6 +143,8 @@ function getProvidedContext () {
       _ddTestSessionId: testSessionId,
       _ddTestModuleId: testModuleId,
       _ddTestCommand: testCommand,
+      _ddRepositoryRoot: repositoryRoot,
+      _ddCodeOwnersEntries: codeOwnersEntries,
     } = globalThis.__vitest_worker__.providedContext
 
     return {
@@ -162,6 +164,8 @@ function getProvidedContext () {
       testSessionId,
       testModuleId,
       testCommand,
+      repositoryRoot,
+      codeOwnersEntries,
     }
   } catch {
     log.error('Vitest workers could not parse provided context, so some features will not work.')
@@ -182,6 +186,8 @@ function getProvidedContext () {
       testSessionId: undefined,
       testModuleId: undefined,
       testCommand: undefined,
+      repositoryRoot: undefined,
+      codeOwnersEntries: undefined,
     }
   }
 }
@@ -472,7 +478,7 @@ async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications) {
   }
 
   if (testSessionConfigurationCh.hasSubscribers) {
-    const { testSessionId, testModuleId, testCommand } = await getChannelPromise(
+    const { testSessionId, testModuleId, testCommand, repositoryRoot, codeOwnersEntries } = await getChannelPromise(
       testSessionConfigurationCh,
       frameworkVersion
     )
@@ -480,6 +486,8 @@ async function runMainProcessSetup (ctx, frameworkVersion, testSpecifications) {
       _ddTestSessionId: testSessionId,
       _ddTestModuleId: testModuleId,
       _ddTestCommand: testCommand,
+      _ddRepositoryRoot: repositoryRoot,
+      _ddCodeOwnersEntries: codeOwnersEntries,
     }, 'Could not send test session configuration to workers.')
   }
 
@@ -653,15 +661,64 @@ function getCliOrStartVitestWrapper (frameworkVersion) {
   }
 }
 
+function isForkPool (pool) {
+  return pool === 'forks' || pool === 'vmForks'
+}
+
+function isThreadPool (pool) {
+  return pool === 'threads' || pool === 'vmThreads'
+}
+
+function getTestSpecificationPool (testSpecification) {
+  const project = Array.isArray(testSpecification) ? testSpecification[0] : testSpecification?.project
+  return project?.config?.pool || project?.serializedConfig?.pool || project?.pool || testSpecification?.pool
+}
+
+function hasForkPoolTestSpecification (testSpecifications) {
+  if (!Array.isArray(testSpecifications)) {
+    return false
+  }
+
+  for (const testSpecification of testSpecifications) {
+    if (isForkPool(getTestSpecificationPool(testSpecification))) {
+      return true
+    }
+  }
+
+  return false
+}
+
+function shouldMarkVitestWorkerEnv (pool, testSpecifications) {
+  return isForkPool(pool) || hasForkPoolTestSpecification(testSpecifications) ||
+    (!testSpecifications && !isThreadPool(pool))
+}
+
+function markVitestWorkerEnv (ctx, testSpecifications) {
+  const config = ctx?.config
+  if (!config || !shouldMarkVitestWorkerEnv(config.pool, testSpecifications)) {
+    return
+  }
+  config.env = config.env || {}
+  config.env.DD_VITEST_WORKER = '1'
+}
+
 function wrapVitestRunFiles (Vitest, frameworkVersion) {
   if (!Vitest?.prototype?.runFiles) {
     return
   }
 
   shimmer.wrap(Vitest.prototype, 'runFiles', runFiles => async function (testSpecifications) {
+    markVitestWorkerEnv(this, testSpecifications)
     await ensureMainProcessSetup(this, frameworkVersion, testSpecifications)
     return runFiles.apply(this, arguments)
   })
+
+  if (Vitest.prototype.collectTests) {
+    shimmer.wrap(Vitest.prototype, 'collectTests', collectTests => function () {
+      markVitestWorkerEnv(this)
+      return collectTests.apply(this, arguments)
+    })
+  }
 }
 
 function getCreateCliWrapper (vitestPackage, frameworkVersion) {
@@ -1393,6 +1450,8 @@ addHook({
       testSessionId: providedContext.testSessionId,
       testModuleId: providedContext.testModuleId,
       testCommand: providedContext.testCommand,
+      repositoryRoot: providedContext.repositoryRoot,
+      codeOwnersEntries: providedContext.codeOwnersEntries,
     }
     testSuiteStartCh.runStores(testSuiteCtx, () => {})
     const startTestsResponse = await startTests.apply(this, arguments)

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/checkpoint.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+
+// On retries the SDK suspends execution without firing error/asyncEnd; finish the span here.
+class AwsDurableExecutionSdkJsCheckpointPlugin extends TracingPlugin {
+  static id = 'aws-durable-execution-sdk-js'
+  static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:CheckpointManager_checkpoint'
+
+  start (ctx) {
+    const data = ctx.arguments?.[1]
+    if (data?.Action !== 'RETRY' || !data.Error) return
+
+    const span = this.activeSpan
+    if (!span || span.context().getTag('error')) return
+
+    const { ErrorMessage, ErrorType, StackTrace } = data.Error
+    span.setTag('error', 1)
+    if (ErrorMessage) span.setTag('error.message', ErrorMessage)
+    if (ErrorType) span.setTag('error.type', ErrorType)
+    if (Array.isArray(StackTrace)) span.setTag('error.stack', StackTrace.join('\n'))
+
+    ctx.retryStepSpan = span
+  }
+
+  asyncEnd (ctx) {
+    ctx.retryStepSpan?.finish()
+  }
+}
+
+module.exports = AwsDurableExecutionSdkJsCheckpointPlugin

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/client.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const ClientPlugin = require('../../dd-trace/src/plugins/client')
+const { addOpMeta, unwrapDurableError } = require('./util')
+
+class AwsDurableExecutionSdkJsClientPlugin extends ClientPlugin {
+  static id = 'aws-durable-execution-sdk-js'
+  static type = 'serverless'
+  static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_invoke'
+  static settleChannel = 'apm:aws-durable-execution-sdk-js:invoke:settle'
+
+  constructor (...args) {
+    super(...args)
+    this.addSub(this.constructor.settleChannel, ctx => this.settle(ctx))
+  }
+
+  // invoke has two overloads: invoke(name, funcId, ...) and invoke(funcId, ...).
+  // They're distinguished by whether args[1] is a string (named form) or not.
+  bindStart (ctx) {
+    const args = ctx.arguments || []
+    const isNamed = typeof args[1] === 'string'
+    const operationName = isNamed ? args[0] : undefined
+    const functionName = isNamed ? args[1] : args[0]
+
+    const meta = {}
+    if (functionName) {
+      meta['aws.durable.invoke.function_name'] = functionName
+    }
+    if (operationName) {
+      meta['aws.durable.operation_name'] = operationName
+    }
+    addOpMeta(meta, ctx.self)
+
+    this.startSpan(this.operationName(), {
+      resource: operationName,
+      kind: this.constructor.kind,
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  settle (ctx) {
+    if (ctx.error !== undefined) {
+      ctx.currentStore?.span?.setTag('error', unwrapDurableError(ctx))
+    }
+    this.finish(ctx)
+  }
+
+  error (ctxOrError) {
+    this.settle(ctxOrError)
+  }
+}
+
+module.exports = AwsDurableExecutionSdkJsClientPlugin

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/context.js

@@ -0,0 +1,114 @@
+'use strict'
+
+const { storage } = require('../../datadog-core')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { addOpMeta, unwrapDurableError } = require('./util')
+
+// Span names whose direct children must keep the default resource.
+// These can have very high cardinality which is undesireable in the resource.
+const HIGH_CARDINALITY_PARENT_SPAN_NAMES = new Set([
+  'aws.durable.map',
+  'aws.durable.parallel',
+])
+
+// The SDK emits these subTypes as internal scaffolding around map/parallel iterations
+// and waitForCallback; not user-visible operations.
+const SUPPRESSED_CHILD_CONTEXT_SUBTYPES = new Set([
+  'Map',
+  'Parallel',
+  'MapIteration',
+  'ParallelBranch',
+  'WaitForCallback',
+])
+
+class BaseContextPlugin extends TracingPlugin {
+  static id = 'aws-durable-execution-sdk-js'
+  static type = 'serverless'
+  static kind = 'internal'
+
+  constructor (...args) {
+    super(...args)
+    this.addSub(this.constructor.settleChannel, ctx => this.settle(ctx))
+  }
+
+  bindStart (ctx) {
+    const spanName = this.constructor.spanName
+    const parentName = this.activeSpan?.context()._name
+    const operationName = this.getOperationName(ctx)
+    const resource = HIGH_CARDINALITY_PARENT_SPAN_NAMES.has(parentName) ? undefined : operationName
+
+    const meta = {}
+    if (operationName) {
+      meta['aws.durable.operation_name'] = operationName
+    }
+    addOpMeta(meta, ctx.self)
+
+    this.startSpan(spanName, {
+      resource,
+      kind: this.constructor.kind,
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  // All context methods have two overloads: method(name, …) and method(…); args[0] is the name in the first form.
+  getOperationName (ctx) {
+    const args = ctx.arguments || []
+    return typeof args[0] === 'string' ? args[0] : undefined
+  }
+
+  settle (ctx) {
+    if (ctx.suppressed) return
+    if (ctx.error !== undefined) {
+      ctx.currentStore?.span?.setTag('error', unwrapDurableError(ctx))
+    }
+    this.finish(ctx)
+  }
+
+  error (ctxOrError) {
+    this.settle(ctxOrError)
+  }
+}
+
+function makeContextPlugin (method, spanName) {
+  return class extends BaseContextPlugin {
+    static prefix = `tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_${method}`
+    static settleChannel = `apm:aws-durable-execution-sdk-js:${method}:settle`
+    static spanName = spanName
+  }
+}
+
+class RunInChildContextPlugin extends BaseContextPlugin {
+  static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:DurableContextImpl_runInChildContext'
+  static settleChannel = 'apm:aws-durable-execution-sdk-js:runInChildContext:settle'
+  static spanName = 'aws.durable.child_context'
+
+  bindStart (ctx) {
+    if (SUPPRESSED_CHILD_CONTEXT_SUBTYPES.has(getRunInChildContextSubType(ctx))) {
+      // Pass the active store through unchanged so any nested spans
+      // remain parented to the surrounding map/parallel span
+      ctx.suppressed = true
+      return storage('legacy').getStore()
+    }
+    return super.bindStart(ctx)
+  }
+}
+
+// runInChildContext has two overloads: `(name, fn, options)` and `(fn, options)`.
+function getRunInChildContextSubType (ctx) {
+  const args = ctx.arguments || []
+  const opts = typeof args[0] === 'function' ? args[1] : args[2]
+  return opts?.subType
+}
+
+module.exports = {
+  step: makeContextPlugin('step', 'aws.durable.step'),
+  wait: makeContextPlugin('wait', 'aws.durable.wait'),
+  waitForCondition: makeContextPlugin('waitForCondition', 'aws.durable.wait_for_condition'),
+  waitForCallback: makeContextPlugin('waitForCallback', 'aws.durable.wait_for_callback'),
+  createCallback: makeContextPlugin('createCallback', 'aws.durable.create_callback'),
+  map: makeContextPlugin('map', 'aws.durable.map'),
+  parallel: makeContextPlugin('parallel', 'aws.durable.parallel'),
+  runInChildContext: RunInChildContextPlugin,
+}

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/handler.js

@@ -0,0 +1,128 @@
+'use strict'
+
+const log = require('../../dd-trace/src/log')
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const { saveTraceContextCheckpointIfUpdated } = require('./trace-checkpoint')
+
+// Termination reasons that indicate the execution is suspending rather than exiting permanently.
+// Sourced from (`@aws/durable-execution-sdk-js`'s termination-manager/types.ts).
+const PENDING_TERMINATION_REASONS = new Set([
+  'OPERATION_TERMINATED',
+  'RETRY_SCHEDULED',
+  'RETRY_INTERRUPTED_STEP',
+  'WAIT_SCHEDULED',
+  'CALLBACK_PENDING',
+  'CUSTOM',
+])
+
+const DEFAULT_TERMINATION_REASON = 'OPERATION_TERMINATED'
+
+// Published by the instrumentation when the SDK's terminationManager.terminate() is called.
+// The instrumentation owns the wrapping; this plugin only reacts.
+const TERMINATE_CHANNEL = 'apm:aws-durable-execution-sdk-js:terminate'
+
+class AwsDurableExecutionSdkJsHandlerPlugin extends TracingPlugin {
+  static id = 'aws-durable-execution-sdk-js'
+  static type = 'serverless'
+  static kind = 'internal'
+  static prefix = 'tracing:orchestrion:@aws/durable-execution-sdk-js:withDurableExecution'
+
+  constructor (...args) {
+    super(...args)
+    // Gate the subscription on the feature flag: the instrumentation only wraps terminate() while
+    // this channel has subscribers, so not subscribing keeps the wrapping off entirely.
+    if (this._tracerConfig.DD_DURABLE_CROSS_INVOCATION_TRACING_ENABLED) {
+      this.addSub(TERMINATE_CHANNEL, ctx => this.#onTerminate(ctx))
+    }
+  }
+
+  bindStart (ctx) {
+    const args = ctx.arguments || []
+    const event = args[0]
+    const durableExecutionMode = args[3]
+    const handler = args[5]
+
+    const meta = {
+      'aws.durable.replayed': durableExecutionMode === 'ReplayMode' ? 'true' : 'false',
+    }
+    const arn = event?.DurableExecutionArn
+    if (arn) {
+      meta['aws.durable.execution_arn'] = arn
+    }
+
+    this.startSpan(this.operationName(), {
+      resource: handler?.name,
+      kind: this.constructor.kind,
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+
+  // Fired (synchronously, before the SDK's terminate() runs) when the execution suspends. On a
+  // PENDING reason we persist the current trace context as a `_datadog` checkpoint, which
+  // subsequent invocations consume to extract the parent trace context. `ctx` is the shared
+  // withDurableExecution context: bindStart put the execute span on it, and the instrumentation
+  // put the captured durableContext and termination reason on it.
+  #onTerminate (ctx) {
+    const reason = ctx.terminationReason ?? DEFAULT_TERMINATION_REASON
+    if (!PENDING_TERMINATION_REASONS.has(reason)) return
+    void maybeSaveCheckpoint(this.tracer, ctx)
+  }
+
+  asyncEnd (ctx) {
+    const span = ctx?.currentStore?.span
+    const status = ctx?.result?.Status
+    if (span && typeof status === 'string') {
+      span.setTag('aws.durable.invocation_status', status.toLowerCase())
+    }
+    // Operation child spans rely on user code awaiting the returned DurablePromise to settle;
+    // suspended (PENDING) ops never settle, and fire-and-forget ops on terminal handler exits
+    // are never awaited at all. Finish any still-open owned children so the trace can flush.
+    if (span) finishOpenChildSpans(span)
+    super.finish(ctx)
+  }
+}
+
+function finishOpenChildSpans (executeSpan) {
+  const trace = executeSpan?._spanContext?._trace
+  if (!trace?.started) return
+
+  for (const span of trace.started) {
+    if (span === executeSpan) continue
+    if (span._integrationName !== AwsDurableExecutionSdkJsHandlerPlugin.id) continue
+    if (span._duration === undefined) {
+      span.finish()
+    }
+  }
+}
+
+// Save state is kept on the shared `ctx` so repeated terminate() calls within one execution
+// save at most once. The execute span is also the anchor we propagate, so its span id is the
+// `firstExecutionSpanId` passed downstream.
+function maybeSaveCheckpoint (tracer, ctx) {
+  if (ctx.checkpointSaved || ctx.checkpointSavePromise) return ctx.checkpointSavePromise
+
+  const span = ctx.currentStore?.span
+  const durableContext = ctx.durableContext
+  if (!span || !durableContext) return
+
+  // Fire-and-forget boundary (#onTerminate calls us with `void`): swallow every failure here so a
+  // rejected checkpoint-manager call can never surface as an unhandled rejection in customer code.
+  ctx.checkpointSavePromise = saveTraceContextCheckpointIfUpdated(
+    tracer,
+    span,
+    durableContext,
+    span.context?.()?.toSpanId?.(),
+    ctx.arguments?.[0],
+  ).catch(error => {
+    log.debug('Failed to save trace context checkpoint', error)
+  }).finally(() => {
+    ctx.checkpointSaved = true
+    ctx.checkpointSavePromise = undefined
+  })
+
+  return ctx.checkpointSavePromise
+}
+
+module.exports = AwsDurableExecutionSdkJsHandlerPlugin

package/packages/datadog-plugin-aws-durable-execution-sdk-js/src/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const checkpointPlugin = require('./checkpoint')
+const clientPlugin = require('./client')
+const contextPlugins = require('./context')
+const handlerPlugin = require('./handler')
+
+class AwsDurableExecutionSdkJsPlugin extends CompositePlugin {
+  static id = 'aws-durable-execution-sdk-js'
+  static plugins = {
+    handler: handlerPlugin,
+    client: clientPlugin,
+    checkpoint: checkpointPlugin,
+    ...contextPlugins,
+  }
+}
+
+module.exports = AwsDurableExecutionSdkJsPlugin