fix(aws-durable-execution-sdk-js): [SVLS-8588] set span type to serverless (#9162)

* fix(aws-durable-execution-sdk-js): treat FAILED checkpoints as replays

A durable operation served from a FAILED checkpoint on replay (the SDK
re-raises the stored error without running the body) was not recognized as a
replay: both `aws.durable.replayed` and the `aws.durable.operation_attempt`
normalization keyed only on `Status === 'SUCCEEDED'`.

As a result a caught-then-replayed failed operation reported
`replayed=false` and a 1-indexed `operation_attempt` (e.g. 2 for a step whose
2nd attempt failed) — one higher than, and inconsistent with, the live final
attempt (1). This is the same off-by-one #8595 fixed for SUCCEEDED, still open
for FAILED.

Treat a terminal checkpoint (SUCCEEDED or FAILED) as a replay for both tags, so
the replay agrees with the live run (replayed=true, operation_attempt=1).
Verified in production on a durable Lambda.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(aws-durable-execution-sdk-js): set span type to serverless

The durable plugins declare `static type = 'serverless'`, but
`TracingPlugin.startSpan` only defaults `component` from the class —
`type` and `kind` have no `this.constructor.*` fallback. The plugins
forwarded `kind: this.constructor.kind` but omitted `type`, so every
durable span was emitted with an empty `span.type`.

Forward `type: this.constructor.type` in both bindStart calls so the
spans carry `type: serverless`, matching the dd-trace-py integration.
This lets serverless UIs (e.g. the Lambda trace panel's Durable
Function Execution section) recognize the spans as Lambda/function
spans.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: 2 people

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

@@ -50,6 +50,7 @@ class BaseContextPlugin extends TracingPlugin {
 
     this.startSpan(spanName, {
       resource,
+      type: this.constructor.type,
       kind: this.constructor.kind,
       meta,
       metrics,

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

@@ -52,6 +52,7 @@ class AwsDurableExecutionSdkJsHandlerPlugin extends TracingPlugin {
 
     this.startSpan(this.operationName(), {
       resource: handler?.name,
+      type: this.constructor.type,
       kind: this.constructor.kind,
       meta,
     }, ctx)

packages/datadog-plugin-aws-durable-execution-sdk-js/test/index.spec.js

@@ -219,6 +219,17 @@ createIntegrationTestSuite('aws-durable-execution-sdk-js', '@aws/durable-executi
     return tracePromise
   })
 
+  it('sets span type to serverless on execute and operation spans', async () => {
+    const tracePromise = agent.assertSomeTraces(traces => {
+      // handler.js (execute span) and context.js (operation spans) both declare
+      // `static type = 'serverless'`; assert it reaches the emitted span.type.
+      assertSpanByName(traces, { name: 'aws.durable.execute', type: 'serverless' })
+      assertSpanByName(traces, { name: 'aws.durable.step', type: 'serverless' })
+    })
+    await invokeHandler(async (event, ctx) => ctx.step(async () => {}))
+    return tracePromise
+  })
+
   for (const { span, errorMessage, run } of [
     {
       span: 'aws.durable.step',