@workflow/core 5.0.0-beta.5 → 5.0.0-beta.50

package/dist/telemetry/semantic-conventions.js

@@ -3,7 +3,7 @@
  *
  * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions
  * for instrumenting workflow execution, step processing, and related operations. Each exported function
- * creates a properly formatted attribute object that can be used with OpenTelemetry spans.
+ * creates a properly formatted attribute object for use with OpenTelemetry spans.
  *
  * The semantic conventions are organized into several categories:
  * - **Workflow attributes**: Track workflow lifecycle, status, and metadata
@@ -11,7 +11,7 @@
  * - **Queue attributes**: Instrument message queue operations
  * - **Deployment attributes**: Capture deployment environment information
  *
- * All attribute functions are type-safe and leverage existing backend types to ensure
+ * All attribute functions are type-safe and use existing backend types to ensure
  * consistency between telemetry data and actual system state.
  *
  * @example
@@ -57,12 +57,53 @@ export const WorkflowRunStatus = SemanticConvention('workflow.run.status');
 export const WorkflowStartedAt = SemanticConvention('workflow.started_at');
 /** Number of events processed during workflow execution */
 export const WorkflowEventsCount = SemanticConvention('workflow.events.count');
+/** Whether workflow execution starts with replay or resumes a retained VM */
+export const WorkflowExecutionMode = SemanticConvention('workflow.execution.mode');
+/** Whether the compiled application workflow bundle was cached. */
+export const WorkflowBundleCompileCacheHit = SemanticConvention('workflow.bundle.compile.cache_hit');
+export const WorkflowReplayLoadSource = SemanticConvention('workflow.replay.load.source');
+/**
+ * Events the replay walked past that no consumer claimed, still held when the
+ * replay stopped.
+ *
+ * A non-zero count on a suspension is ordinary: an out-of-band delivery that
+ * landed ahead of the code that reads it waits for the replay that gets there.
+ * From inside one replay that is indistinguishable from an event no replay will
+ * ever claim, because the two differ only in what the next replay does. So the
+ * count goes on the span instead of failing the run, and the case worth acting
+ * on is a query across a run's spans: the same
+ * {@link WorkflowParkedEventId} held on suspension after suspension.
+ */
+export const WorkflowParkedEventsCount = SemanticConvention('workflow.events.parked.count');
+/** Oldest event still held unclaimed when the replay stopped. */
+export const WorkflowParkedEventId = SemanticConvention('workflow.events.parked.event_id');
+/** Type of the oldest event still held unclaimed when the replay stopped. */
+export const WorkflowParkedEventType = SemanticConvention('workflow.events.parked.event_type');
 /** Number of arguments passed to the workflow */
 export const WorkflowArgumentsCount = SemanticConvention('workflow.arguments.count');
 /** Type of the workflow result */
 export const WorkflowResultType = SemanticConvention('workflow.result.type');
 /** Whether trace context was propagated to this workflow execution */
 export const WorkflowTracePropagated = SemanticConvention('workflow.trace.propagated');
+// QuickJS VM engine attributes
+/** The VM engine executing the workflow function for this invocation */
+export const WorkflowVm = SemanticConvention('workflow.vm');
+/** Outcome of a QuickJS VM workflow invocation */
+export const QuickJSOutcome = SemanticConvention('workflow.vm.outcome');
+/** Whether preloaded events from `events.create('run_started')` were used */
+export const QuickJSEventsPreloaded = SemanticConvention('workflow.vm.events.preloaded');
+/** Total number of events fetched from the world for this invocation */
+export const QuickJSEventsFetchedCount = SemanticConvention('workflow.vm.events.fetched_count');
+/** Number of pages required to fetch all events */
+export const QuickJSEventsFetchedPages = SemanticConvention('workflow.vm.events.fetched_pages');
+/** Number of pending VM operations captured at suspension */
+export const QuickJSPendingOpsCount = SemanticConvention('workflow.vm.pending_ops_count');
+/** Number of steps executed inline (live-VM continuation) this invocation */
+export const QuickJSInlineSteps = SemanticConvention('quickjs.inline_steps');
+/** Active trace-correlation mode for this invocation (linked or continuous) */
+export const WorkflowTraceMode = SemanticConvention('workflow.trace.mode');
+/** Whether this workflow invocation is using the turbo first-delivery path */
+export const WorkflowTurbo = SemanticConvention('workflow.turbo');
 /** Name of the error that caused workflow failure */
 export const WorkflowErrorName = SemanticConvention('workflow.error.name');
 /** Error message when workflow fails */
@@ -75,6 +116,42 @@ export const WorkflowStepsCreated = SemanticConvention('workflow.steps.created')
 export const WorkflowHooksCreated = SemanticConvention('workflow.hooks.created');
 /** Number of waits created during workflow execution */
 export const WorkflowWaitsCreated = SemanticConvention('workflow.waits.created');
+/**
+ * Number of steps this suspension finalized as failed because their
+ * arguments refused to serialize (step_created placeholder + step_failed
+ * carrying the SerializationError; see finalizeUnserializableStep).
+ */
+export const WorkflowStepsFailedSerialization = SemanticConvention('workflow.steps.failed_serialization');
+/**
+ * Number of inline-owned steps this invocation re-executed because it is a
+ * redelivery of their owning queue message (crash recovery for inline
+ * steps; see the inline step ownership changelog, workflow#2780).
+ */
+export const WorkflowOwnedRecoverySteps = SemanticConvention('workflow.inline_ownership.owned_recovery_steps');
+/**
+ * Number of pending steps for which this replay suppressed the immediate
+ * requeue (another invocation inline-owns them under a live lease) and
+ * ensured a delayed backstop wake instead.
+ */
+export const WorkflowBackstopWakesArmed = SemanticConvention('workflow.inline_ownership.backstop_wakes_armed');
+// Route attributes
+/** The workflow runtime route being handled */
+export const WorkflowRouteType = SemanticConvention('workflow.route.type');
+/** Whether this route invocation reused an already-created request handler */
+export const WorkflowRouteHandlerCached = SemanticConvention('workflow.route.handler_cached');
+/** Number of times this in-memory route handler has been invoked */
+export const WorkflowRouteInvocationCount = SemanticConvention('workflow.route.invocation_count');
+/** Time since this route entrypoint was constructed, in milliseconds */
+export const WorkflowRouteEntrypointAgeMs = SemanticConvention('workflow.route.entrypoint_age_ms');
+/** Time spent evaluating the generated route module body before creating the entrypoint */
+export const WorkflowRouteModuleBodyInitMs = SemanticConvention('workflow.route.module_body_init_ms');
+/**
+ * Compute instance handling this route: the synthesized `COMPUTE_INSTANCE_ID`.
+ * Uses OTEL `faas.instance` (execution-environment id, reused across
+ * invocations to the same function):
+ * https://opentelemetry.io/docs/specs/semconv/attributes-registry/faas/
+ */
+export const FaasInstance = SemanticConvention('faas.instance');
 // Step attributes
 /** Name of the step function being executed */
 export const StepName = SemanticConvention('step.name');
@@ -88,6 +165,45 @@ export const StepStatus = SemanticConvention('step.status');
 export const StepMaxRetries = SemanticConvention('step.max_retries');
 /** Whether trace context was propagated to this step execution */
 export const StepTracePropagated = SemanticConvention('step.trace.propagated');
+/**
+ * Client-measured time-to-first-step latency in milliseconds: run creation →
+ * this step's body beginning to execute, minus pre-step hook-creation time.
+ * Only present on the run's first step execution when it qualified for
+ * measurement (see runtime/step-latency.ts).
+ */
+export const StepTtfsMs = SemanticConvention('step.ttfs_ms');
+/**
+ * Client-measured step-to-step overhead in milliseconds: the previous step's
+ * terminal event → this step's body beginning to execute. Only present when
+ * the two steps ran back-to-back.
+ */
+export const StepStsoMs = SemanticConvention('step.stso_ms');
+/**
+ * Client-measured run_started-to-first-step latency in milliseconds: the
+ * `run_started` response landing (or, under turbo, the local run synthesis
+ * instant) → this step's start POST being issued. A sub-window of ttfs that
+ * isolates replay overhead from the run-creation queue hop. Only present on
+ * the run's first step execution when it qualified for measurement (see
+ * runtime/step-latency.ts).
+ */
+export const StepRsfsMs = SemanticConvention('step.rsfs_ms');
+/**
+ * Client-measured synchronous workflow-function replay duration in
+ * milliseconds, excluding awaited network I/O, of only the FINAL replay pass
+ * within the rsfs window: the pass that reached and scheduled the first
+ * step. Not accumulated across earlier pre-first-step passes (e.g. a
+ * workflow-body `setAttributes()` detour replays more than once, and a
+ * redelivery omits earlier invocations' work entirely), so this must not be
+ * read as "the replay portion of rsfs"; step.rsfs_ms covers the whole
+ * window. Only present alongside step.rsfs_ms and only for the run's first
+ * step (see runtime/step-latency.ts).
+ */
+export const StepFinalSchedulingReplayMs = SemanticConvention('step.final_scheduling_replay_ms');
+/**
+ * Runtime startup-latency optimizations active for the ttfs/stso measurement
+ * (e.g. 'turbo', 'lazyStepStart', 'optimisticStart').
+ */
+export const StepLatencyOptimizations = SemanticConvention('step.latency_optimizations');
 /** Whether the step was skipped during execution */
 export const StepSkipped = SemanticConvention('step.skipped');
 /** Reason why the step was skipped */
@@ -123,6 +239,12 @@ export const QueueOverheadMs = SemanticConvention('workflow.queue.overhead_ms');
 // Deployment attributes
 /** Unique identifier for the deployment environment */
 export const DeploymentId = SemanticConvention('deployment.id');
+/** The deployment a run is pinned to, set only on a misrouted delivery. */
+export const WorkflowRunPinnedDeploymentId = SemanticConvention('workflow.deployment.pinned_id');
+/** Re-route attempts for this misrouted delivery, including this one. */
+export const WorkflowDeploymentMismatchRetryCount = SemanticConvention('workflow.deployment_mismatch.retry_count');
+/** Whether the misrouted delivery was re-routed instead of failing the run. */
+export const WorkflowDeploymentMismatchRecovered = SemanticConvention('workflow.deployment_mismatch.recovered');
 // Hook attributes
 /** Token identifying a specific hook */
 export const HookToken = SemanticConvention('workflow.hook.token');
@@ -130,6 +252,148 @@ export const HookToken = SemanticConvention('workflow.hook.token');
 export const HookId = SemanticConvention('workflow.hook.id');
 /** Whether a hook was found by its token */
 export const HookFound = SemanticConvention('workflow.hook.found');
+/**
+ * Producer-side signal (on the `hook.resume` span) that the direct
+ * `hook_received` write failed transiently but the queue dispatch succeeded, so
+ * the resume is recovered via the consumer's re-ensure. Corresponds to
+ * `ResumedHook.resilientResume === true`.
+ *
+ * No longer emitted: current producers require the durable event write to
+ * succeed. Retained so dashboards and queries built on the attribute keep
+ * resolving while older producers are still deployed.
+ */
+export const HookResilientResume = SemanticConvention('workflow.hook.resilient_resume');
+/**
+ * Producer-side signal (on the `hook.resume` span) that the durable
+ * `hook_received` write COMMITTED. Stamped after the write resolves, so it
+ * distinguishes a committed resume from an attempted one — an entry-time
+ * attribute cannot, because a span that later records an exception may have
+ * failed either before or after the commit.
+ */
+export const HookResumeCommitted = SemanticConvention('workflow.hook.resume_committed');
+/**
+ * Producer-side signal (on the `hook.resume` span) that the workflow wake was
+ * ACCEPTED by the queue, stamped after the publish resolves.
+ *
+ * Together with {@link HookResumeCommitted} this makes stranded resumes
+ * queryable: `resume_committed=true` with `wake_published` absent is a resume
+ * whose durable event exists but whose wake publish failed (the caller was
+ * told, but nothing re-drives it), and `resume_committed=true` +
+ * `wake_published=true` with no subsequent workflow execution for the run is
+ * a wake the queue accepted but never delivered. Both are detection-only
+ * signals — nothing recovers such a run automatically today beyond a later
+ * wake from any other source.
+ */
+export const HookWakePublished = SemanticConvention('workflow.hook.wake_published');
+/**
+ * Consumer-side signal (on the workflow execution span) that this replay
+ * materialized the `hook_received` event from the queue message's `hookInput`
+ * because no committed event was found, which completes the recovery path
+ * {@link HookResilientResume} began.
+ *
+ * Legacy / non-atomic re-ensure signal only. Legacy atomic lazy resumes
+ * (resumeId + digest) go through the hoisted preload write instead, whose
+ * response cannot tell whether the producer or the consumer won the
+ * `(runId, resumeId)` claim, so this attribute is deliberately NOT emitted
+ * for them (emitting `true` unconditionally would count every producer-won
+ * resume as a recovery). The producer-begin ({@link HookResilientResume}) /
+ * consumer-materialized pairing is therefore no longer complete for atomic
+ * lazy resumptions; use {@link HookResumeSetupSource} to observe that path.
+ */
+export const HookResilientResumeMaterialized = SemanticConvention('workflow.hook.resilient_resume_materialized');
+/**
+ * Consumer-side signal (on the workflow execution span) of how a lazy hook
+ * resume initialized its replay state:
+ *
+ * - `hook_received_stream`: the hoisted `hook_received` write returned a
+ *   usable replay preload (run + complete event log), so the invocation
+ *   skipped both the `run_started` write and the initial `events.list`.
+ * - `hook_received_fallback`: the hoisted write succeeded but returned no
+ *   usable preload (a CBOR response from an older server, a World that
+ *   ignored the opt-in, a bounded `hasMore` page, or a preload that failed
+ *   validation); the invocation fell back to the `run_started` setup without
+ *   re-posting the hook.
+ *
+ * Absent on legacy hook deliveries (no resumeId/digest) and on every other
+ * delivery kind, which take the `run_started` setup unconditionally.
+ *
+ * This is a latency/setup-path signal: it says which requests initialized
+ * the invocation, NOT that this consumer created the `hook_received` event
+ * (the hoisted write may equally have converged on the producer's, since
+ * claim ownership is not observable client-side; cf.
+ * {@link HookResilientResumeMaterialized}).
+ */
+export const HookResumeSetupSource = SemanticConvention('workflow.resume_setup_source');
+/**
+ * Producer-side signal (on the suspension span) counting steps whose direct
+ * `step_created` write failed transiently while their `stepInput`-carrying
+ * queue publish succeeded, so step creation is recovered via the consumer's
+ * re-ensure. Mirrors {@link HookResilientResume}.
+ */
+export const StepResilientDispatchRecovered = SemanticConvention('workflow.step.resilient_dispatch_recovered');
+/**
+ * Consumer-side signal (on the workflow execution span) that this delivery
+ * materialized the `step_created` event from the queue message's `stepInput`
+ * because the producer's direct write had not landed, which completes the
+ * recovery path {@link StepResilientDispatchRecovered} began.
+ */
+export const StepResilientDispatchMaterialized = SemanticConvention('workflow.step.resilient_dispatch_materialized');
+// Hook-triggered time-to-resume (TTR) attributes
+//
+// Set on the `step.execute <name>` span of the FIRST durable step following a
+// hook resume, and only there: one resumption produces exactly one sample, so
+// a later step in the same invocation, a retry, or a redelivery never
+// re-reports it. The phases are non-overlapping and sum exactly to
+// {@link ResumeTotalMs}; see runtime/resume-latency.ts for the boundary
+// definitions and the emission gate.
+//
+// Deliberately carries no `resumeId`, run ID, or token: the metric is meant to
+// be aggregated across every resume, and high-cardinality keys would make that
+// prohibitive. Existing trace-correlation fields on the same span are
+// unchanged and still identify the individual run.
+/** Total TTR: entry into `resumeHook()` → immediately before `stepFn.apply()`. */
+export const ResumeTotalMs = SemanticConvention('workflow.resume.total_ms');
+/** Phase: `resumeHook()` entry → the queue publish being requested. */
+export const ResumeProducerPrepMs = SemanticConvention('workflow.resume.phase.producer_prep_ms');
+/** Phase: queue publish requested → the final consumer's handler being entered. */
+export const ResumeQueueDeliveryMs = SemanticConvention('workflow.resume.phase.queue_delivery_ms');
+/** Phase: consumer entry → replay beginning. */
+export const ResumeSetupMs = SemanticConvention('workflow.resume.phase.resume_setup_ms');
+/** Phase: replay beginning → the next durable step being encountered. */
+export const ResumeReplayMs = SemanticConvention('workflow.resume.phase.replay_ms');
+/** Phase: step encountered → the `step_started` request beginning. */
+export const ResumeStepDispatchMs = SemanticConvention('workflow.resume.phase.step_dispatch_ms');
+/**
+ * Phase: `step_started` request beginning → its response returning. Omitted
+ * under optimistic inline start, where the claim is not awaited before the
+ * body runs and therefore has no completion instant at that point; the time
+ * is then reported entirely as {@link ResumeStepPrepareMs}.
+ */
+export const ResumeStepClaimMs = SemanticConvention('workflow.resume.phase.step_claim_ms');
+/**
+ * Phase: claim returning → immediately before `stepFn.apply()`. Deliberately
+ * includes encryption-key resolution, argument hydration, and step-context
+ * setup; `workflow.queue.deserialize_time_ms` still isolates hydration.
+ */
+export const ResumeStepPrepareMs = SemanticConvention('workflow.resume.phase.step_prepare_ms');
+/** What triggered the measured resumption. */
+export const ResumeTrigger = SemanticConvention('workflow.resume.trigger');
+/**
+ * Which `resumeHook()` dispatch path produced this resume. `parallel` only
+ * appears for messages published by an older producer, which wrote
+ * `hook_received` itself in parallel with the publish.
+ */
+export const ResumeStrategy = SemanticConvention('workflow.resume.strategy');
+/**
+ * How the consuming invocation initialized replay state. Distinct from the
+ * pre-existing {@link HookResumeSetupSource} (`workflow.resume_setup_source`,
+ * on the workflow execution span), which reports the finer-grained
+ * hoisted-write outcome; this one is the TTR dimension and shares the metric's
+ * three-value vocabulary.
+ */
+export const ResumeSetupSource = SemanticConvention('workflow.resume.setup_source');
+/** Whether the measured step ran in the resuming invocation or a queued one. */
+export const ResumeStepExecution = SemanticConvention('workflow.resume.step_execution');
 // Webhook attributes
 /** Number of webhook handlers triggered */
 export const WebhookHandlersTriggered = SemanticConvention('webhook.handlers.triggered');
@@ -142,6 +406,8 @@ export const WorkflowSuspensionWaitCount = SemanticConvention('workflow.suspensi
 // See: https://opentelemetry.io/docs/specs/semconv/http/http-spans/
 /** HTTP request method (standard OTEL: http.request.method) */
 export const HttpRequestMethod = SemanticConvention('http.request.method');
+/** Route pattern for the request (standard OTEL: http.route) */
+export const HttpRoute = SemanticConvention('http.route');
 /** Full URL of the request (standard OTEL: url.full) */
 export const UrlFull = SemanticConvention('url.full');
 /** Server hostname (standard OTEL: server.address) */
@@ -165,6 +431,34 @@ export const QueueDeserializeTimeMs = SemanticConvention('workflow.queue.deseria
 export const QueueExecutionTimeMs = SemanticConvention('workflow.queue.execution_time_ms');
 /** Time spent serializing the response in milliseconds */
 export const QueueSerializeTimeMs = SemanticConvention('workflow.queue.serialize_time_ms');
+// Payload compression attributes (zstd preferred, gzip fallback; specVersion >= 5)
+//
+// Sizes are measured at the compression boundary: before encryption on the
+// write path and after decryption on the read path. They therefore reflect
+// compression's effect, not the at-rest size (which also includes the
+// ~28-byte `encr` envelope and, on some backends, base64 expansion).
+/** Whether this serialize/deserialize was a write or read. */
+export const SerializationOperation = SemanticConvention('workflow.serialization.operation');
+/** Whether a compression codec was applied (write) / present (read). */
+export const SerializationCompressed = SemanticConvention('workflow.serialization.compressed');
+/** Which compression codec applied / was present (`zstd`, `gzip`, or `none`). */
+export const SerializationCodec = SemanticConvention('workflow.serialization.codec');
+/** Logical (uncompressed, devalue-prefixed) payload size in bytes. */
+export const SerializationUncompressedBytes = SemanticConvention('workflow.serialization.uncompressed_bytes');
+/** Stored (post-compression, pre-encryption) payload size in bytes. */
+export const SerializationStoredBytes = SemanticConvention('workflow.serialization.stored_bytes');
+/** Fraction of bytes saved by compression (0..1); set only when compressed. */
+export const SerializationCompressionRatio = SemanticConvention('workflow.serialization.compression_ratio');
+/**
+ * Number of workflow (guest) code executions serialization could not avoid
+ * (getters, proxies, custom serializers); set only when non-zero.
+ */
+export const SerializationGuestCodeExecutions = SemanticConvention('workflow.serialization.guest_code_executions');
+/**
+ * Deduplicated `kind (detail)` descriptions of the guest-code executions;
+ * set only when non-zero.
+ */
+export const SerializationGuestCodeDetails = SemanticConvention('workflow.serialization.guest_code_details');
 // RPC/Peer Service attributes - For service maps and dependency tracking
 // See: https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/
 /** The remote service name for Datadog service maps (Datadog-specific: peer.service) */
@@ -181,4 +475,4 @@ export const RpcMethod = SemanticConvention('rpc.method');
 export const ErrorRetryable = SemanticConvention('error.retryable');
 /** Error category (workflow-specific: fatal, retryable, transient) */
 export const ErrorCategory = SemanticConvention('error.category');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semantic-conventions.js","sourceRoot":"","sources":["../../src/telemetry/semantic-conventions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenTelemetry semantic conventions for Vercel Workflow telemetry.\n *\n * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions\n * for instrumenting workflow execution, step processing, and related operations. Each exported function\n * creates a properly formatted attribute object that can be used with OpenTelemetry spans.\n *\n * The semantic conventions are organized into several categories:\n * - **Workflow attributes**: Track workflow lifecycle, status, and metadata\n * - **Step attributes**: Monitor individual step execution, retries, and results\n * - **Queue attributes**: Instrument message queue operations\n * - **Deployment attributes**: Capture deployment environment information\n *\n * All attribute functions are type-safe and leverage existing backend types to ensure\n * consistency between telemetry data and actual system state.\n *\n * @example\n * ```typescript\n * import * as Attribute from './telemetry/semantic-conventions.js';\n *\n * // Set workflow attributes on a span\n * span.setAttributes({\n *   ...Attribute.WorkflowName('my-workflow'),\n *   ...Attribute.WorkflowOperation('start'),\n *   ...Attribute.WorkflowRunStatus('running'),\n * });\n *\n * // Set step attributes\n * span.setAttributes({\n *   ...Attribute.StepName('process-data'),\n *   ...Attribute.StepStatus('completed'),\n *   ...Attribute.StepAttempt(1),\n * });\n * ```\n *\n * @see {@link https://opentelemetry.io/docs/specs/semconv/} OpenTelemetry Semantic Conventions\n * @packageDocumentation\n */\n\nimport type { MessageId, Step, WorkflowRun } from '@workflow/world';\n\n/**\n * Creates a semantic convention function that returns an attribute object.\n * @param name - The attribute name following OpenTelemetry semantic conventions\n * @returns A function that takes a value and returns an attribute object\n */\nfunction SemanticConvention<T>(...names: string[]) {\n  return (value: T) =>\n    Object.fromEntries(names.map((name) => [name, value] as const));\n}\n\n// Workflow attributes\n\n/** The name of the workflow being executed */\nexport const WorkflowName = SemanticConvention<string>('workflow.name');\n\n/** The operation being performed on the workflow */\nexport const WorkflowOperation = SemanticConvention<\n  'start' | 'execute' | 'execute_v2' | 'run'\n>('workflow.operation');\n\n/** Unique identifier for a specific workflow run instance */\nexport const WorkflowRunId = SemanticConvention<string>('workflow.run.id');\n\n/** Current status of the workflow run */\nexport const WorkflowRunStatus = SemanticConvention<\n  WorkflowRun['status'] | 'workflow_suspended'\n>('workflow.run.status');\n\n/** Timestamp when the workflow execution started (Unix timestamp) */\nexport const WorkflowStartedAt = SemanticConvention<number>(\n  'workflow.started_at'\n);\n\n/** Number of events processed during workflow execution */\nexport const WorkflowEventsCount = SemanticConvention<number>(\n  'workflow.events.count'\n);\n\n/** Number of arguments passed to the workflow */\nexport const WorkflowArgumentsCount = SemanticConvention<number>(\n  'workflow.arguments.count'\n);\n\n/** Type of the workflow result */\nexport const WorkflowResultType = SemanticConvention<string>(\n  'workflow.result.type'\n);\n\n/** Whether trace context was propagated to this workflow execution */\nexport const WorkflowTracePropagated = SemanticConvention<boolean>(\n  'workflow.trace.propagated'\n);\n\n/** Name of the error that caused workflow failure */\nexport const WorkflowErrorName = SemanticConvention<string>(\n  'workflow.error.name'\n);\n\n/** Error message when workflow fails */\nexport const WorkflowErrorMessage = SemanticConvention<string>(\n  'workflow.error.message'\n);\n\n/** Error classification code (USER_ERROR, RUNTIME_ERROR, etc.) */\nexport const WorkflowErrorCode = SemanticConvention<string>(\n  'workflow.error.code'\n);\n\n/** Number of steps created during workflow execution */\nexport const WorkflowStepsCreated = SemanticConvention<number>(\n  'workflow.steps.created'\n);\n\n/** Number of hooks created during workflow execution */\nexport const WorkflowHooksCreated = SemanticConvention<number>(\n  'workflow.hooks.created'\n);\n\n/** Number of waits created during workflow execution */\nexport const WorkflowWaitsCreated = SemanticConvention<number>(\n  'workflow.waits.created'\n);\n\n// Step attributes\n\n/** Name of the step function being executed */\nexport const StepName = SemanticConvention<string>('step.name');\n\n/** Unique identifier for the step instance */\nexport const StepId = SemanticConvention<string>('step.id');\n\n/** Current attempt number for step execution (starts at 1) */\nexport const StepAttempt = SemanticConvention<number>('step.attempt');\n\n/** Current status of the step */\nexport const StepStatus = SemanticConvention<Step['status']>('step.status');\n\n/** Maximum number of retries allowed for this step */\nexport const StepMaxRetries = SemanticConvention<number>('step.max_retries');\n\n/** Whether trace context was propagated to this step execution */\nexport const StepTracePropagated = SemanticConvention<boolean>(\n  'step.trace.propagated'\n);\n\n/** Whether the step was skipped during execution */\nexport const StepSkipped = SemanticConvention<boolean>('step.skipped');\n\n/** Reason why the step was skipped */\nexport const StepSkipReason =\n  SemanticConvention<Step['status']>('step.skip_reason');\n\n/** Number of arguments passed to the step function */\nexport const StepArgumentsCount = SemanticConvention<number>(\n  'step.arguments.count'\n);\n\n/** Type of the step result */\nexport const StepResultType = SemanticConvention<string>('step.result.type');\n\n/** Name of the error that caused step failure */\nexport const StepErrorName = SemanticConvention<string>('step.error.name');\n\n/** Error message when step fails */\nexport const StepErrorMessage =\n  SemanticConvention<string>('step.error.message');\n\n/** Whether the step failed with a fatal error (no retries) */\nexport const StepFatalError = SemanticConvention<boolean>('step.fatal_error');\n\n/** Whether all retry attempts have been exhausted */\nexport const StepRetryExhausted = SemanticConvention<boolean>(\n  'step.retry.exhausted'\n);\n\n/** Number of seconds to wait before next retry attempt */\nexport const StepRetryTimeoutSeconds = SemanticConvention<number>(\n  'step.retry.timeout_seconds'\n);\n\n/** Whether the step will be retried after this failure */\nexport const StepRetryWillRetry = SemanticConvention<boolean>(\n  'step.retry.will_retry'\n);\n\n// Queue/Messaging attributes - Standard OTEL messaging conventions\n// See: https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/\n\n/** Messaging system identifier (standard OTEL: messaging.system) */\nexport const MessagingSystem = SemanticConvention<string>('messaging.system');\n\n/** Destination name/queue name (standard OTEL: messaging.destination.name) */\nexport const MessagingDestinationName = SemanticConvention<string>(\n  'messaging.destination.name'\n);\n\n/** The message id being handled (standard OTEL: messaging.message.id) */\nexport const MessagingMessageId = SemanticConvention<MessageId>(\n  'messaging.message.id'\n);\n\n/** Operation type (standard OTEL: messaging.operation.type) */\nexport const MessagingOperationType = SemanticConvention<\n  'publish' | 'receive' | 'process'\n>('messaging.operation.type');\n\n/** Time taken to enqueue the message in milliseconds (workflow-specific) */\nexport const QueueOverheadMs = SemanticConvention<number>(\n  'workflow.queue.overhead_ms'\n);\n\n// Deployment attributes\n\n/** Unique identifier for the deployment environment */\nexport const DeploymentId = SemanticConvention<string>('deployment.id');\n\n// Hook attributes\n\n/** Token identifying a specific hook */\nexport const HookToken = SemanticConvention<string>('workflow.hook.token');\n\n/** Unique identifier for a hook instance */\nexport const HookId = SemanticConvention<string>('workflow.hook.id');\n\n/** Whether a hook was found by its token */\nexport const HookFound = SemanticConvention<boolean>('workflow.hook.found');\n\n// Webhook attributes\n\n/** Number of webhook handlers triggered */\nexport const WebhookHandlersTriggered = SemanticConvention<number>(\n  'webhook.handlers.triggered'\n);\n\n// Suspension attributes\n\nexport const WorkflowSuspensionState = SemanticConvention<'suspended'>(\n  'workflow.suspension.state'\n);\nexport const WorkflowSuspensionHookCount = SemanticConvention<number>(\n  'workflow.suspension.hook_count'\n);\nexport const WorkflowSuspensionStepCount = SemanticConvention<number>(\n  'workflow.suspension.step_count'\n);\nexport const WorkflowSuspensionWaitCount = SemanticConvention<number>(\n  'workflow.suspension.wait_count'\n);\n\n// World/Storage attributes - Standard OTEL HTTP conventions\n// See: https://opentelemetry.io/docs/specs/semconv/http/http-spans/\n\n/** HTTP request method (standard OTEL: http.request.method) */\nexport const HttpRequestMethod = SemanticConvention<string>(\n  'http.request.method'\n);\n\n/** Full URL of the request (standard OTEL: url.full) */\nexport const UrlFull = SemanticConvention<string>('url.full');\n\n/** Server hostname (standard OTEL: server.address) */\nexport const ServerAddress = SemanticConvention<string>('server.address');\n\n/** Server port (standard OTEL: server.port) */\nexport const ServerPort = SemanticConvention<number>('server.port');\n\n/** HTTP response status code (standard OTEL: http.response.status_code) */\nexport const HttpResponseStatusCode = SemanticConvention<number>(\n  'http.response.status_code'\n);\n\n/** Error type when request fails (standard OTEL: error.type) */\nexport const ErrorType = SemanticConvention<string>('error.type');\n\n// World-specific custom attributes (for workflow-specific context)\n\n/** Format used for parsing response body (cbor or json) */\nexport const WorldParseFormat = SemanticConvention<'cbor' | 'json'>(\n  'workflow.world.parse.format'\n);\n\n// Event loading attributes\n\n/** Number of pagination pages loaded when fetching workflow events */\nexport const WorkflowEventsPagesLoaded = SemanticConvention<number>(\n  'workflow.events.pages_loaded'\n);\n\n// Queue timing breakdown attributes (workflow-specific)\n\n/** Time spent deserializing the queue message in milliseconds */\nexport const QueueDeserializeTimeMs = SemanticConvention<number>(\n  'workflow.queue.deserialize_time_ms'\n);\n\n/** Time spent executing the handler logic in milliseconds */\nexport const QueueExecutionTimeMs = SemanticConvention<number>(\n  'workflow.queue.execution_time_ms'\n);\n\n/** Time spent serializing the response in milliseconds */\nexport const QueueSerializeTimeMs = SemanticConvention<number>(\n  'workflow.queue.serialize_time_ms'\n);\n\n// RPC/Peer Service attributes - For service maps and dependency tracking\n// See: https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/\n\n/** The remote service name for Datadog service maps (Datadog-specific: peer.service) */\nexport const PeerService = SemanticConvention<string>('peer.service');\n\n/** RPC system identifier (standard OTEL: rpc.system) */\nexport const RpcSystem = SemanticConvention<string>('rpc.system');\n\n/** RPC service name (standard OTEL: rpc.service) */\nexport const RpcService = SemanticConvention<string>('rpc.service');\n\n/** RPC method name (standard OTEL: rpc.method) */\nexport const RpcMethod = SemanticConvention<string>('rpc.method');\n\n// Error attributes - Standard OTEL error conventions\n// See: https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/\n\n/** Whether the error is retryable (workflow-specific) */\nexport const ErrorRetryable = SemanticConvention<boolean>('error.retryable');\n\n/** Error category (workflow-specific: fatal, retryable, transient) */\nexport const ErrorCategory = SemanticConvention<\n  'fatal' | 'retryable' | 'transient'\n>('error.category');\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semantic-conventions.js","sourceRoot":"","sources":["../../src/telemetry/semantic-conventions.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenTelemetry semantic conventions for Vercel Workflow telemetry.\n *\n * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions\n * for instrumenting workflow execution, step processing, and related operations. Each exported function\n * creates a properly formatted attribute object for use with OpenTelemetry spans.\n *\n * The semantic conventions are organized into several categories:\n * - **Workflow attributes**: Track workflow lifecycle, status, and metadata\n * - **Step attributes**: Monitor individual step execution, retries, and results\n * - **Queue attributes**: Instrument message queue operations\n * - **Deployment attributes**: Capture deployment environment information\n *\n * All attribute functions are type-safe and use existing backend types to ensure\n * consistency between telemetry data and actual system state.\n *\n * @example\n * ```typescript\n * import * as Attribute from './telemetry/semantic-conventions.js';\n *\n * // Set workflow attributes on a span\n * span.setAttributes({\n *   ...Attribute.WorkflowName('my-workflow'),\n *   ...Attribute.WorkflowOperation('start'),\n *   ...Attribute.WorkflowRunStatus('running'),\n * });\n *\n * // Set step attributes\n * span.setAttributes({\n *   ...Attribute.StepName('process-data'),\n *   ...Attribute.StepStatus('completed'),\n *   ...Attribute.StepAttempt(1),\n * });\n * ```\n *\n * @see {@link https://opentelemetry.io/docs/specs/semconv/} OpenTelemetry Semantic Conventions\n * @packageDocumentation\n */\n\nimport type { MessageId, Step, WorkflowRun } from '@workflow/world';\n\n/**\n * Creates a semantic convention function that returns an attribute object.\n * @param name - The attribute name following OpenTelemetry semantic conventions\n * @returns A function that takes a value and returns an attribute object\n */\nfunction SemanticConvention<T>(...names: string[]) {\n  return (value: T) =>\n    Object.fromEntries(names.map((name) => [name, value] as const));\n}\n\n// Workflow attributes\n\n/** The name of the workflow being executed */\nexport const WorkflowName = SemanticConvention<string>('workflow.name');\n\n/** The operation being performed on the workflow */\nexport const WorkflowOperation = SemanticConvention<\n  'start' | 'execute' | 'execute_v2' | 'run'\n>('workflow.operation');\n\n/** Unique identifier for a specific workflow run instance */\nexport const WorkflowRunId = SemanticConvention<string>('workflow.run.id');\n\n/** Current status of the workflow run */\nexport const WorkflowRunStatus = SemanticConvention<\n  WorkflowRun['status'] | 'workflow_suspended'\n>('workflow.run.status');\n\n/** Timestamp when the workflow execution started (Unix timestamp) */\nexport const WorkflowStartedAt = SemanticConvention<number>(\n  'workflow.started_at'\n);\n\n/** Number of events processed during workflow execution */\nexport const WorkflowEventsCount = SemanticConvention<number>(\n  'workflow.events.count'\n);\n\n/** Whether workflow execution starts with replay or resumes a retained VM */\nexport const WorkflowExecutionMode = SemanticConvention<'replay' | 'retained'>(\n  'workflow.execution.mode'\n);\n\n/** Whether the compiled application workflow bundle was cached. */\nexport const WorkflowBundleCompileCacheHit = SemanticConvention<boolean>(\n  'workflow.bundle.compile.cache_hit'\n);\n\n/** Operation that supplied events to the current replay. */\nexport type WorkflowReplayLoadSource =\n  | 'run_started'\n  | 'hook_preload'\n  | 'events_list'\n  | 'events_list_incremental';\nexport const WorkflowReplayLoadSource =\n  SemanticConvention<WorkflowReplayLoadSource>('workflow.replay.load.source');\n\n/**\n * Events the replay walked past that no consumer claimed, still held when the\n * replay stopped.\n *\n * A non-zero count on a suspension is ordinary: an out-of-band delivery that\n * landed ahead of the code that reads it waits for the replay that gets there.\n * From inside one replay that is indistinguishable from an event no replay will\n * ever claim, because the two differ only in what the next replay does. So the\n * count goes on the span instead of failing the run, and the case worth acting\n * on is a query across a run's spans: the same\n * {@link WorkflowParkedEventId} held on suspension after suspension.\n */\nexport const WorkflowParkedEventsCount = SemanticConvention<number>(\n  'workflow.events.parked.count'\n);\n\n/** Oldest event still held unclaimed when the replay stopped. */\nexport const WorkflowParkedEventId = SemanticConvention<string>(\n  'workflow.events.parked.event_id'\n);\n\n/** Type of the oldest event still held unclaimed when the replay stopped. */\nexport const WorkflowParkedEventType = SemanticConvention<string>(\n  'workflow.events.parked.event_type'\n);\n\n/** Number of arguments passed to the workflow */\nexport const WorkflowArgumentsCount = SemanticConvention<number>(\n  'workflow.arguments.count'\n);\n\n/** Type of the workflow result */\nexport const WorkflowResultType = SemanticConvention<string>(\n  'workflow.result.type'\n);\n\n/** Whether trace context was propagated to this workflow execution */\nexport const WorkflowTracePropagated = SemanticConvention<boolean>(\n  'workflow.trace.propagated'\n);\n\n// QuickJS VM engine attributes\n\n/** The VM engine executing the workflow function for this invocation */\nexport const WorkflowVm = SemanticConvention<'node' | 'quickjs'>('workflow.vm');\n\n/** Outcome of a QuickJS VM workflow invocation */\nexport const QuickJSOutcome = SemanticConvention<\n  'completed' | 'suspended' | 'failed'\n>('workflow.vm.outcome');\n\n/** Whether preloaded events from `events.create('run_started')` were used */\nexport const QuickJSEventsPreloaded = SemanticConvention<boolean>(\n  'workflow.vm.events.preloaded'\n);\n\n/** Total number of events fetched from the world for this invocation */\nexport const QuickJSEventsFetchedCount = SemanticConvention<number>(\n  'workflow.vm.events.fetched_count'\n);\n\n/** Number of pages required to fetch all events */\nexport const QuickJSEventsFetchedPages = SemanticConvention<number>(\n  'workflow.vm.events.fetched_pages'\n);\n\n/** Number of pending VM operations captured at suspension */\nexport const QuickJSPendingOpsCount = SemanticConvention<number>(\n  'workflow.vm.pending_ops_count'\n);\n\n/** Number of steps executed inline (live-VM continuation) this invocation */\nexport const QuickJSInlineSteps = SemanticConvention<number>(\n  'quickjs.inline_steps'\n);\n\n/** Active trace-correlation mode for this invocation (linked or continuous) */\nexport const WorkflowTraceMode = SemanticConvention<'linked' | 'continuous'>(\n  'workflow.trace.mode'\n);\n\n/** Whether this workflow invocation is using the turbo first-delivery path */\nexport const WorkflowTurbo = SemanticConvention<boolean>('workflow.turbo');\n\n/** Name of the error that caused workflow failure */\nexport const WorkflowErrorName = SemanticConvention<string>(\n  'workflow.error.name'\n);\n\n/** Error message when workflow fails */\nexport const WorkflowErrorMessage = SemanticConvention<string>(\n  'workflow.error.message'\n);\n\n/** Error classification code (USER_ERROR, RUNTIME_ERROR, etc.) */\nexport const WorkflowErrorCode = SemanticConvention<string>(\n  'workflow.error.code'\n);\n\n/** Number of steps created during workflow execution */\nexport const WorkflowStepsCreated = SemanticConvention<number>(\n  'workflow.steps.created'\n);\n\n/** Number of hooks created during workflow execution */\nexport const WorkflowHooksCreated = SemanticConvention<number>(\n  'workflow.hooks.created'\n);\n\n/** Number of waits created during workflow execution */\nexport const WorkflowWaitsCreated = SemanticConvention<number>(\n  'workflow.waits.created'\n);\n\n/**\n * Number of steps this suspension finalized as failed because their\n * arguments refused to serialize (step_created placeholder + step_failed\n * carrying the SerializationError; see finalizeUnserializableStep).\n */\nexport const WorkflowStepsFailedSerialization = SemanticConvention<number>(\n  'workflow.steps.failed_serialization'\n);\n\n/**\n * Number of inline-owned steps this invocation re-executed because it is a\n * redelivery of their owning queue message (crash recovery for inline\n * steps; see the inline step ownership changelog, workflow#2780).\n */\nexport const WorkflowOwnedRecoverySteps = SemanticConvention<number>(\n  'workflow.inline_ownership.owned_recovery_steps'\n);\n\n/**\n * Number of pending steps for which this replay suppressed the immediate\n * requeue (another invocation inline-owns them under a live lease) and\n * ensured a delayed backstop wake instead.\n */\nexport const WorkflowBackstopWakesArmed = SemanticConvention<number>(\n  'workflow.inline_ownership.backstop_wakes_armed'\n);\n\n// Route attributes\n\n/** The workflow runtime route being handled */\nexport const WorkflowRouteType = SemanticConvention<'flow'>(\n  'workflow.route.type'\n);\n\n/** Whether this route invocation reused an already-created request handler */\nexport const WorkflowRouteHandlerCached = SemanticConvention<boolean>(\n  'workflow.route.handler_cached'\n);\n\n/** Number of times this in-memory route handler has been invoked */\nexport const WorkflowRouteInvocationCount = SemanticConvention<number>(\n  'workflow.route.invocation_count'\n);\n\n/** Time since this route entrypoint was constructed, in milliseconds */\nexport const WorkflowRouteEntrypointAgeMs = SemanticConvention<number>(\n  'workflow.route.entrypoint_age_ms'\n);\n\n/** Time spent evaluating the generated route module body before creating the entrypoint */\nexport const WorkflowRouteModuleBodyInitMs = SemanticConvention<number>(\n  'workflow.route.module_body_init_ms'\n);\n\n/**\n * Compute instance handling this route: the synthesized `COMPUTE_INSTANCE_ID`.\n * Uses OTEL `faas.instance` (execution-environment id, reused across\n * invocations to the same function):\n * https://opentelemetry.io/docs/specs/semconv/attributes-registry/faas/\n */\nexport const FaasInstance = SemanticConvention<string>('faas.instance');\n\n// Step attributes\n\n/** Name of the step function being executed */\nexport const StepName = SemanticConvention<string>('step.name');\n\n/** Unique identifier for the step instance */\nexport const StepId = SemanticConvention<string>('step.id');\n\n/** Current attempt number for step execution (starts at 1) */\nexport const StepAttempt = SemanticConvention<number>('step.attempt');\n\n/** Current status of the step */\nexport const StepStatus = SemanticConvention<Step['status']>('step.status');\n\n/** Maximum number of retries allowed for this step */\nexport const StepMaxRetries = SemanticConvention<number>('step.max_retries');\n\n/** Whether trace context was propagated to this step execution */\nexport const StepTracePropagated = SemanticConvention<boolean>(\n  'step.trace.propagated'\n);\n\n/**\n * Client-measured time-to-first-step latency in milliseconds: run creation →\n * this step's body beginning to execute, minus pre-step hook-creation time.\n * Only present on the run's first step execution when it qualified for\n * measurement (see runtime/step-latency.ts).\n */\nexport const StepTtfsMs = SemanticConvention<number>('step.ttfs_ms');\n\n/**\n * Client-measured step-to-step overhead in milliseconds: the previous step's\n * terminal event → this step's body beginning to execute. Only present when\n * the two steps ran back-to-back.\n */\nexport const StepStsoMs = SemanticConvention<number>('step.stso_ms');\n\n/**\n * Client-measured run_started-to-first-step latency in milliseconds: the\n * `run_started` response landing (or, under turbo, the local run synthesis\n * instant) → this step's start POST being issued. A sub-window of ttfs that\n * isolates replay overhead from the run-creation queue hop. Only present on\n * the run's first step execution when it qualified for measurement (see\n * runtime/step-latency.ts).\n */\nexport const StepRsfsMs = SemanticConvention<number>('step.rsfs_ms');\n\n/**\n * Client-measured synchronous workflow-function replay duration in\n * milliseconds, excluding awaited network I/O, of only the FINAL replay pass\n * within the rsfs window: the pass that reached and scheduled the first\n * step. Not accumulated across earlier pre-first-step passes (e.g. a\n * workflow-body `setAttributes()` detour replays more than once, and a\n * redelivery omits earlier invocations' work entirely), so this must not be\n * read as \"the replay portion of rsfs\"; step.rsfs_ms covers the whole\n * window. Only present alongside step.rsfs_ms and only for the run's first\n * step (see runtime/step-latency.ts).\n */\nexport const StepFinalSchedulingReplayMs = SemanticConvention<number>(\n  'step.final_scheduling_replay_ms'\n);\n\n/**\n * Runtime startup-latency optimizations active for the ttfs/stso measurement\n * (e.g. 'turbo', 'lazyStepStart', 'optimisticStart').\n */\nexport const StepLatencyOptimizations = SemanticConvention<string[]>(\n  'step.latency_optimizations'\n);\n\n/** Whether the step was skipped during execution */\nexport const StepSkipped = SemanticConvention<boolean>('step.skipped');\n\n/** Reason why the step was skipped */\nexport const StepSkipReason =\n  SemanticConvention<Step['status']>('step.skip_reason');\n\n/** Number of arguments passed to the step function */\nexport const StepArgumentsCount = SemanticConvention<number>(\n  'step.arguments.count'\n);\n\n/** Type of the step result */\nexport const StepResultType = SemanticConvention<string>('step.result.type');\n\n/** Name of the error that caused step failure */\nexport const StepErrorName = SemanticConvention<string>('step.error.name');\n\n/** Error message when step fails */\nexport const StepErrorMessage =\n  SemanticConvention<string>('step.error.message');\n\n/** Whether the step failed with a fatal error (no retries) */\nexport const StepFatalError = SemanticConvention<boolean>('step.fatal_error');\n\n/** Whether all retry attempts have been exhausted */\nexport const StepRetryExhausted = SemanticConvention<boolean>(\n  'step.retry.exhausted'\n);\n\n/** Number of seconds to wait before next retry attempt */\nexport const StepRetryTimeoutSeconds = SemanticConvention<number>(\n  'step.retry.timeout_seconds'\n);\n\n/** Whether the step will be retried after this failure */\nexport const StepRetryWillRetry = SemanticConvention<boolean>(\n  'step.retry.will_retry'\n);\n\n// Queue/Messaging attributes - Standard OTEL messaging conventions\n// See: https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/\n\n/** Messaging system identifier (standard OTEL: messaging.system) */\nexport const MessagingSystem = SemanticConvention<string>('messaging.system');\n\n/** Destination name/queue name (standard OTEL: messaging.destination.name) */\nexport const MessagingDestinationName = SemanticConvention<string>(\n  'messaging.destination.name'\n);\n\n/** The message id being handled (standard OTEL: messaging.message.id) */\nexport const MessagingMessageId = SemanticConvention<MessageId>(\n  'messaging.message.id'\n);\n\n/** Operation type (standard OTEL: messaging.operation.type) */\nexport const MessagingOperationType = SemanticConvention<\n  'publish' | 'receive' | 'process'\n>('messaging.operation.type');\n\n/** Time taken to enqueue the message in milliseconds (workflow-specific) */\nexport const QueueOverheadMs = SemanticConvention<number>(\n  'workflow.queue.overhead_ms'\n);\n\n// Deployment attributes\n\n/** Unique identifier for the deployment environment */\nexport const DeploymentId = SemanticConvention<string>('deployment.id');\n\n/** The deployment a run is pinned to, set only on a misrouted delivery. */\nexport const WorkflowRunPinnedDeploymentId = SemanticConvention<string>(\n  'workflow.deployment.pinned_id'\n);\n\n/** Re-route attempts for this misrouted delivery, including this one. */\nexport const WorkflowDeploymentMismatchRetryCount = SemanticConvention<number>(\n  'workflow.deployment_mismatch.retry_count'\n);\n\n/** Whether the misrouted delivery was re-routed instead of failing the run. */\nexport const WorkflowDeploymentMismatchRecovered = SemanticConvention<boolean>(\n  'workflow.deployment_mismatch.recovered'\n);\n\n// Hook attributes\n\n/** Token identifying a specific hook */\nexport const HookToken = SemanticConvention<string>('workflow.hook.token');\n\n/** Unique identifier for a hook instance */\nexport const HookId = SemanticConvention<string>('workflow.hook.id');\n\n/** Whether a hook was found by its token */\nexport const HookFound = SemanticConvention<boolean>('workflow.hook.found');\n\n/**\n * Producer-side signal (on the `hook.resume` span) that the direct\n * `hook_received` write failed transiently but the queue dispatch succeeded, so\n * the resume is recovered via the consumer's re-ensure. Corresponds to\n * `ResumedHook.resilientResume === true`.\n *\n * No longer emitted: current producers require the durable event write to\n * succeed. Retained so dashboards and queries built on the attribute keep\n * resolving while older producers are still deployed.\n */\nexport const HookResilientResume = SemanticConvention<boolean>(\n  'workflow.hook.resilient_resume'\n);\n\n/**\n * Producer-side signal (on the `hook.resume` span) that the durable\n * `hook_received` write COMMITTED. Stamped after the write resolves, so it\n * distinguishes a committed resume from an attempted one — an entry-time\n * attribute cannot, because a span that later records an exception may have\n * failed either before or after the commit.\n */\nexport const HookResumeCommitted = SemanticConvention<boolean>(\n  'workflow.hook.resume_committed'\n);\n\n/**\n * Producer-side signal (on the `hook.resume` span) that the workflow wake was\n * ACCEPTED by the queue, stamped after the publish resolves.\n *\n * Together with {@link HookResumeCommitted} this makes stranded resumes\n * queryable: `resume_committed=true` with `wake_published` absent is a resume\n * whose durable event exists but whose wake publish failed (the caller was\n * told, but nothing re-drives it), and `resume_committed=true` +\n * `wake_published=true` with no subsequent workflow execution for the run is\n * a wake the queue accepted but never delivered. Both are detection-only\n * signals — nothing recovers such a run automatically today beyond a later\n * wake from any other source.\n */\nexport const HookWakePublished = SemanticConvention<boolean>(\n  'workflow.hook.wake_published'\n);\n\n/**\n * Consumer-side signal (on the workflow execution span) that this replay\n * materialized the `hook_received` event from the queue message's `hookInput`\n * because no committed event was found, which completes the recovery path\n * {@link HookResilientResume} began.\n *\n * Legacy / non-atomic re-ensure signal only. Legacy atomic lazy resumes\n * (resumeId + digest) go through the hoisted preload write instead, whose\n * response cannot tell whether the producer or the consumer won the\n * `(runId, resumeId)` claim, so this attribute is deliberately NOT emitted\n * for them (emitting `true` unconditionally would count every producer-won\n * resume as a recovery). The producer-begin ({@link HookResilientResume}) /\n * consumer-materialized pairing is therefore no longer complete for atomic\n * lazy resumptions; use {@link HookResumeSetupSource} to observe that path.\n */\nexport const HookResilientResumeMaterialized = SemanticConvention<boolean>(\n  'workflow.hook.resilient_resume_materialized'\n);\n\n/**\n * Consumer-side signal (on the workflow execution span) of how a lazy hook\n * resume initialized its replay state:\n *\n * - `hook_received_stream`: the hoisted `hook_received` write returned a\n *   usable replay preload (run + complete event log), so the invocation\n *   skipped both the `run_started` write and the initial `events.list`.\n * - `hook_received_fallback`: the hoisted write succeeded but returned no\n *   usable preload (a CBOR response from an older server, a World that\n *   ignored the opt-in, a bounded `hasMore` page, or a preload that failed\n *   validation); the invocation fell back to the `run_started` setup without\n *   re-posting the hook.\n *\n * Absent on legacy hook deliveries (no resumeId/digest) and on every other\n * delivery kind, which take the `run_started` setup unconditionally.\n *\n * This is a latency/setup-path signal: it says which requests initialized\n * the invocation, NOT that this consumer created the `hook_received` event\n * (the hoisted write may equally have converged on the producer's, since\n * claim ownership is not observable client-side; cf.\n * {@link HookResilientResumeMaterialized}).\n */\nexport const HookResumeSetupSource = SemanticConvention<string>(\n  'workflow.resume_setup_source'\n);\n\n/**\n * Producer-side signal (on the suspension span) counting steps whose direct\n * `step_created` write failed transiently while their `stepInput`-carrying\n * queue publish succeeded, so step creation is recovered via the consumer's\n * re-ensure. Mirrors {@link HookResilientResume}.\n */\nexport const StepResilientDispatchRecovered = SemanticConvention<number>(\n  'workflow.step.resilient_dispatch_recovered'\n);\n\n/**\n * Consumer-side signal (on the workflow execution span) that this delivery\n * materialized the `step_created` event from the queue message's `stepInput`\n * because the producer's direct write had not landed, which completes the\n * recovery path {@link StepResilientDispatchRecovered} began.\n */\nexport const StepResilientDispatchMaterialized = SemanticConvention<boolean>(\n  'workflow.step.resilient_dispatch_materialized'\n);\n\n// Hook-triggered time-to-resume (TTR) attributes\n//\n// Set on the `step.execute <name>` span of the FIRST durable step following a\n// hook resume, and only there: one resumption produces exactly one sample, so\n// a later step in the same invocation, a retry, or a redelivery never\n// re-reports it. The phases are non-overlapping and sum exactly to\n// {@link ResumeTotalMs}; see runtime/resume-latency.ts for the boundary\n// definitions and the emission gate.\n//\n// Deliberately carries no `resumeId`, run ID, or token: the metric is meant to\n// be aggregated across every resume, and high-cardinality keys would make that\n// prohibitive. Existing trace-correlation fields on the same span are\n// unchanged and still identify the individual run.\n\n/** Total TTR: entry into `resumeHook()` → immediately before `stepFn.apply()`. */\nexport const ResumeTotalMs = SemanticConvention<number>(\n  'workflow.resume.total_ms'\n);\n\n/** Phase: `resumeHook()` entry → the queue publish being requested. */\nexport const ResumeProducerPrepMs = SemanticConvention<number>(\n  'workflow.resume.phase.producer_prep_ms'\n);\n\n/** Phase: queue publish requested → the final consumer's handler being entered. */\nexport const ResumeQueueDeliveryMs = SemanticConvention<number>(\n  'workflow.resume.phase.queue_delivery_ms'\n);\n\n/** Phase: consumer entry → replay beginning. */\nexport const ResumeSetupMs = SemanticConvention<number>(\n  'workflow.resume.phase.resume_setup_ms'\n);\n\n/** Phase: replay beginning → the next durable step being encountered. */\nexport const ResumeReplayMs = SemanticConvention<number>(\n  'workflow.resume.phase.replay_ms'\n);\n\n/** Phase: step encountered → the `step_started` request beginning. */\nexport const ResumeStepDispatchMs = SemanticConvention<number>(\n  'workflow.resume.phase.step_dispatch_ms'\n);\n\n/**\n * Phase: `step_started` request beginning → its response returning. Omitted\n * under optimistic inline start, where the claim is not awaited before the\n * body runs and therefore has no completion instant at that point; the time\n * is then reported entirely as {@link ResumeStepPrepareMs}.\n */\nexport const ResumeStepClaimMs = SemanticConvention<number>(\n  'workflow.resume.phase.step_claim_ms'\n);\n\n/**\n * Phase: claim returning → immediately before `stepFn.apply()`. Deliberately\n * includes encryption-key resolution, argument hydration, and step-context\n * setup; `workflow.queue.deserialize_time_ms` still isolates hydration.\n */\nexport const ResumeStepPrepareMs = SemanticConvention<number>(\n  'workflow.resume.phase.step_prepare_ms'\n);\n\n/** What triggered the measured resumption. */\nexport const ResumeTrigger = SemanticConvention<'hook'>(\n  'workflow.resume.trigger'\n);\n\n/**\n * Which `resumeHook()` dispatch path produced this resume. `parallel` only\n * appears for messages published by an older producer, which wrote\n * `hook_received` itself in parallel with the publish.\n */\nexport const ResumeStrategy = SemanticConvention<\n  'lazy' | 'parallel' | 'sequential'\n>('workflow.resume.strategy');\n\n/**\n * How the consuming invocation initialized replay state. Distinct from the\n * pre-existing {@link HookResumeSetupSource} (`workflow.resume_setup_source`,\n * on the workflow execution span), which reports the finer-grained\n * hoisted-write outcome; this one is the TTR dimension and shares the metric's\n * three-value vocabulary.\n */\nexport const ResumeSetupSource = SemanticConvention<\n  'hook_preload' | 'run_started' | 'event_load'\n>('workflow.resume.setup_source');\n\n/** Whether the measured step ran in the resuming invocation or a queued one. */\nexport const ResumeStepExecution = SemanticConvention<'inline' | 'dispatched'>(\n  'workflow.resume.step_execution'\n);\n\n// Webhook attributes\n\n/** Number of webhook handlers triggered */\nexport const WebhookHandlersTriggered = SemanticConvention<number>(\n  'webhook.handlers.triggered'\n);\n\n// Suspension attributes\n\nexport const WorkflowSuspensionState = SemanticConvention<'suspended'>(\n  'workflow.suspension.state'\n);\nexport const WorkflowSuspensionHookCount = SemanticConvention<number>(\n  'workflow.suspension.hook_count'\n);\nexport const WorkflowSuspensionStepCount = SemanticConvention<number>(\n  'workflow.suspension.step_count'\n);\nexport const WorkflowSuspensionWaitCount = SemanticConvention<number>(\n  'workflow.suspension.wait_count'\n);\n\n// World/Storage attributes - Standard OTEL HTTP conventions\n// See: https://opentelemetry.io/docs/specs/semconv/http/http-spans/\n\n/** HTTP request method (standard OTEL: http.request.method) */\nexport const HttpRequestMethod = SemanticConvention<string>(\n  'http.request.method'\n);\n\n/** Route pattern for the request (standard OTEL: http.route) */\nexport const HttpRoute = SemanticConvention<string>('http.route');\n\n/** Full URL of the request (standard OTEL: url.full) */\nexport const UrlFull = SemanticConvention<string>('url.full');\n\n/** Server hostname (standard OTEL: server.address) */\nexport const ServerAddress = SemanticConvention<string>('server.address');\n\n/** Server port (standard OTEL: server.port) */\nexport const ServerPort = SemanticConvention<number>('server.port');\n\n/** HTTP response status code (standard OTEL: http.response.status_code) */\nexport const HttpResponseStatusCode = SemanticConvention<number>(\n  'http.response.status_code'\n);\n\n/** Error type when request fails (standard OTEL: error.type) */\nexport const ErrorType = SemanticConvention<string>('error.type');\n\n// World-specific custom attributes (for workflow-specific context)\n\n/** Format used for parsing response body (cbor or json) */\nexport const WorldParseFormat = SemanticConvention<'cbor' | 'json'>(\n  'workflow.world.parse.format'\n);\n\n// Event loading attributes\n\n/** Number of pagination pages loaded when fetching workflow events */\nexport const WorkflowEventsPagesLoaded = SemanticConvention<number>(\n  'workflow.events.pages_loaded'\n);\n\n// Queue timing breakdown attributes (workflow-specific)\n\n/** Time spent deserializing the queue message in milliseconds */\nexport const QueueDeserializeTimeMs = SemanticConvention<number>(\n  'workflow.queue.deserialize_time_ms'\n);\n\n/** Time spent executing the handler logic in milliseconds */\nexport const QueueExecutionTimeMs = SemanticConvention<number>(\n  'workflow.queue.execution_time_ms'\n);\n\n/** Time spent serializing the response in milliseconds */\nexport const QueueSerializeTimeMs = SemanticConvention<number>(\n  'workflow.queue.serialize_time_ms'\n);\n\n// Payload compression attributes (zstd preferred, gzip fallback; specVersion >= 5)\n//\n// Sizes are measured at the compression boundary: before encryption on the\n// write path and after decryption on the read path. They therefore reflect\n// compression's effect, not the at-rest size (which also includes the\n// ~28-byte `encr` envelope and, on some backends, base64 expansion).\n\n/** Whether this serialize/deserialize was a write or read. */\nexport const SerializationOperation = SemanticConvention<\n  'serialize' | 'deserialize'\n>('workflow.serialization.operation');\n\n/** Whether a compression codec was applied (write) / present (read). */\nexport const SerializationCompressed = SemanticConvention<boolean>(\n  'workflow.serialization.compressed'\n);\n\n/** Which compression codec applied / was present (`zstd`, `gzip`, or `none`). */\nexport const SerializationCodec = SemanticConvention<'zstd' | 'gzip' | 'none'>(\n  'workflow.serialization.codec'\n);\n\n/** Logical (uncompressed, devalue-prefixed) payload size in bytes. */\nexport const SerializationUncompressedBytes = SemanticConvention<number>(\n  'workflow.serialization.uncompressed_bytes'\n);\n\n/** Stored (post-compression, pre-encryption) payload size in bytes. */\nexport const SerializationStoredBytes = SemanticConvention<number>(\n  'workflow.serialization.stored_bytes'\n);\n\n/** Fraction of bytes saved by compression (0..1); set only when compressed. */\nexport const SerializationCompressionRatio = SemanticConvention<number>(\n  'workflow.serialization.compression_ratio'\n);\n\n/**\n * Number of workflow (guest) code executions serialization could not avoid\n * (getters, proxies, custom serializers); set only when non-zero.\n */\nexport const SerializationGuestCodeExecutions = SemanticConvention<number>(\n  'workflow.serialization.guest_code_executions'\n);\n\n/**\n * Deduplicated `kind (detail)` descriptions of the guest-code executions;\n * set only when non-zero.\n */\nexport const SerializationGuestCodeDetails = SemanticConvention<string[]>(\n  'workflow.serialization.guest_code_details'\n);\n\n// RPC/Peer Service attributes - For service maps and dependency tracking\n// See: https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/\n\n/** The remote service name for Datadog service maps (Datadog-specific: peer.service) */\nexport const PeerService = SemanticConvention<string>('peer.service');\n\n/** RPC system identifier (standard OTEL: rpc.system) */\nexport const RpcSystem = SemanticConvention<string>('rpc.system');\n\n/** RPC service name (standard OTEL: rpc.service) */\nexport const RpcService = SemanticConvention<string>('rpc.service');\n\n/** RPC method name (standard OTEL: rpc.method) */\nexport const RpcMethod = SemanticConvention<string>('rpc.method');\n\n// Error attributes - Standard OTEL error conventions\n// See: https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/\n\n/** Whether the error is retryable (workflow-specific) */\nexport const ErrorRetryable = SemanticConvention<boolean>('error.retryable');\n\n/** Error category (workflow-specific: fatal, retryable, transient) */\nexport const ErrorCategory = SemanticConvention<\n  'fatal' | 'retryable' | 'transient'\n>('error.category');\n"]}