duron 0.3.0-beta.11 → 0.3.0-beta.13

package/dist/step-manager.js

@@ -1,42 +1,84 @@
+import { context, SpanKind, SpanStatusCode, trace, } from '@opentelemetry/api';
 import fastq from 'fastq';
 import { StepOptionsSchema, } from './action.js';
 import { STEP_STATUS_CANCELLED, STEP_STATUS_COMPLETED, STEP_STATUS_FAILED } from './constants.js';
 import { ActionCancelError, isCancelError, isNonRetriableError, isTimeoutError, NonRetriableError, StepAlreadyExecutedError, StepTimeoutError, serializeError, UnhandledChildStepsError, } from './errors.js';
-// ============================================================================
-// Noop Tracer (for fallback observe context)
-// ============================================================================
-const noopTracerSpan = {
-    setAttribute() {
-        // No-op
-    },
-    setAttributes() {
-        // No-op
-    },
-    addEvent() {
-        // No-op
-    },
-    recordException() {
-        // No-op
-    },
-    setStatusOk() {
-        // No-op
-    },
-    setStatusError() {
-        // No-op
-    },
-    end() {
-        // No-op
-    },
-    isRecording() {
-        return false;
-    },
-};
-const createNoopTracer = (name) => ({
-    name,
-    startSpan() {
-        return noopTracerSpan;
-    },
-});
+/**
+ * Inject parent span into a context if we have one.
+ */
+function injectParentSpan(ctx, parentSpan) {
+    return parentSpan ? trace.setSpan(ctx, parentSpan) : ctx;
+}
+/**
+ * Create a context-aware tracer wrapper that automatically injects the parent span.
+ * This ensures spans created by external libraries (like AI SDK) are properly linked
+ * to the current job/step trace hierarchy.
+ */
+function createContextAwareTracer(tracer, parentSpan) {
+    return {
+        startSpan(name, options, ctx) {
+            // Always inject our parent span into the context, regardless of what context is passed.
+            // This is necessary because without global registration, context.active() returns
+            // ROOT_CONTEXT, so external libraries (like AI SDK) that pass context.active()
+            // would otherwise create orphan spans.
+            const baseContext = ctx ?? context.active();
+            const effectiveContext = injectParentSpan(baseContext, parentSpan);
+            return tracer.startSpan(name, options, effectiveContext);
+        },
+        // startActiveSpan has multiple overloads, we need to handle them all
+        startActiveSpan(name, optionsOrFn, ctxOrFn, fn) {
+            // Parse the overloaded arguments
+            let options;
+            let ctx;
+            let callback;
+            if (typeof optionsOrFn === 'function') {
+                // startActiveSpan(name, fn)
+                callback = optionsOrFn;
+            }
+            else if (typeof ctxOrFn === 'function') {
+                // startActiveSpan(name, options, fn)
+                options = optionsOrFn;
+                callback = ctxOrFn;
+            }
+            else {
+                // startActiveSpan(name, options, context, fn)
+                options = optionsOrFn;
+                ctx = ctxOrFn;
+                callback = fn;
+            }
+            const baseContext = ctx ?? context.active();
+            const effectiveContext = injectParentSpan(baseContext, parentSpan);
+            return tracer.startActiveSpan(name, options ?? {}, effectiveContext, callback);
+        },
+    };
+}
+/**
+ * Create a TelemetryContext that wraps an OTel span.
+ */
+function createTelemetryContext(span, tracer) {
+    return {
+        getActiveSpan() {
+            return span ?? undefined;
+        },
+        getTracer(_name) {
+            // Return a context-aware tracer that automatically links spans to the current trace
+            return createContextAwareTracer(tracer, span);
+        },
+        startSpan(name, options) {
+            // Create a child span linked to the current span (job or step)
+            const parentContext = span ? trace.setSpan(context.active(), span) : context.active();
+            return tracer.startSpan(name, { attributes: options?.attributes }, parentContext);
+        },
+        recordMetric(name, value, attributes) {
+            if (span) {
+                span.addEvent(`metric:${name}`, {
+                    'metric.value': value,
+                    ...attributes,
+                });
+            }
+        },
+    };
+}
 import pRetry from './utils/p-retry.js';
 import waitForAbort from './utils/wait-for-abort.js';
 /**
@@ -128,7 +170,7 @@ export class StepManager {
     #jobId;
     #actionName;
     #stepStore;
-    #telemetry;
+    #tracer;
     #queue;
     #logger;
     // each step name should be executed only once per parent (name + parentStepId)
@@ -136,7 +178,7 @@ export class StepManager {
     // Store step spans for nested step tracking
     #stepSpans = new Map();
     // Store the job span for creating step spans
-    #jobSpan = null;
+    #jobSpan;
     // Factory function to create run functions with the correct parent step ID and abort signal
     #runFnFactory = null;
     // ============================================================================
@@ -151,7 +193,7 @@ export class StepManager {
         this.#jobId = options.jobId;
         this.#actionName = options.actionName;
         this.#logger = options.logger;
-        this.#telemetry = options.telemetry;
+        this.#tracer = options.tracer;
         this.#stepStore = new StepStore(options.adapter);
         this.#queue = fastq.promise(async (task) => {
             // Create composite key: name + parentStepId (allows same name under different parents)
@@ -191,39 +233,22 @@ export class StepManager {
      * @param variables - Variables available to the action
      * @param abortSignal - Abort signal for cancelling the action
      * @param logger - Pino child logger for this job
-     * @param observeContext - Observability context for telemetry
      * @returns ActionHandlerContext instance
      */
-    createActionContext(job, action, variables, abortSignal, logger, observeContext) {
-        return new ActionContext(this, job, action, variables, abortSignal, logger, observeContext);
+    createActionContext(job, action, variables, abortSignal, logger) {
+        const telemetryContext = createTelemetryContext(this.#jobSpan, this.#tracer);
+        return new ActionContext(this, job, action, variables, abortSignal, logger, telemetryContext);
     }
     /**
-     * Create an observe context for a step.
+     * Create a telemetry context for a step.
      */
-    createStepObserveContext(stepId) {
+    createStepTelemetryContext(stepId) {
         const stepSpan = this.#stepSpans.get(stepId);
         if (stepSpan) {
-            return this.#telemetry.createObserveContext(this.#jobId, stepId, stepSpan);
+            return createTelemetryContext(stepSpan, this.#tracer);
         }
         // Fallback to job span if step span not found
-        if (this.#jobSpan) {
-            return this.#telemetry.createObserveContext(this.#jobId, stepId, this.#jobSpan);
-        }
-        // No-op observe context
-        return {
-            recordMetric: () => {
-                // No-op
-            },
-            addSpanAttribute: () => {
-                // No-op
-            },
-            addSpanEvent: () => {
-                // No-op
-            },
-            getTracer: (name) => {
-                return createNoopTracer(name);
-            },
-        };
+        return createTelemetryContext(this.#jobSpan, this.#tracer);
     }
     /**
      * Queue a step task for execution.
@@ -283,15 +308,18 @@ export class StepManager {
                     throw new NonRetriableError(`Failed to create step "${name}" for job "${this.#jobId}" action "${this.#actionName}"`, { cause: 'step not created' });
                 }
                 step = newStep;
-                // Start step telemetry span
+                // Start step span - uses no-op tracer if no SDK is configured
                 const parentSpan = parentStepId ? this.#stepSpans.get(parentStepId) : this.#jobSpan;
-                const stepSpan = await this.#telemetry.startStepSpan({
-                    jobId: this.#jobId,
-                    stepId: step.id,
-                    stepName: name,
-                    parentSpan: parentSpan ?? undefined,
-                    parentStepId,
-                });
+                const parentContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : context.active();
+                const stepSpan = this.#tracer.startSpan(`step:${name}`, {
+                    kind: SpanKind.INTERNAL,
+                    attributes: {
+                        'duron.job.id': this.#jobId,
+                        'duron.step.id': step.id,
+                        'duron.step.name': name,
+                        'duron.step.parent_id': parentStepId ?? undefined,
+                    },
+                }, parentContext);
                 this.#stepSpans.set(step.id, stepSpan);
                 if (abortSignal.aborted) {
                     throw new ActionCancelError(this.#actionName, this.#jobId, { cause: 'step cancelled after create step' });
@@ -329,14 +357,14 @@ export class StepManager {
             // Create abort controller for child steps (used when parent returns with pending children)
             const childAbortController = new AbortController();
             const childSignal = AbortSignal.any([stepSignal, childAbortController.signal]);
-            // Create observe context for this step
-            const stepObserveContext = this.createStepObserveContext(step.id);
+            // Create telemetry context for this step
+            const stepTelemetryContext = this.createStepTelemetryContext(step.id);
             // Create StepHandlerContext with nested step support
             const stepContext = {
                 signal: stepSignal,
                 stepId: step.id,
                 parentStepId,
-                observe: stepObserveContext,
+                telemetry: stepTelemetryContext,
                 step: (childName, childCb, childOptions = {}) => {
                     // Inherit parent step options EXCEPT parallel (each step's parallel status is independent)
                     const { parallel: _parentParallel, ...inheritableOptions } = options;
@@ -377,7 +405,10 @@ export class StepManager {
             try {
                 // Race between abort signal and callback execution
                 const abortPromise = waitForAbort(stepSignal);
-                const callbackPromise = cb(stepContext);
+                // Execute callback within the span context so that child spans inherit the trace
+                const currentStepSpan = step?.id ? this.#stepSpans.get(step.id) : undefined;
+                const spanContext = currentStepSpan ? trace.setSpan(context.active(), currentStepSpan) : context.active();
+                const callbackPromise = context.with(spanContext, () => cb(stepContext));
                 let result = null;
                 let aborted = false;
                 let callbackError = null;
@@ -445,10 +476,11 @@ export class StepManager {
                 if (!completed) {
                     throw new Error(`Failed to complete step "${name}" for job "${this.#jobId}" action "${this.#actionName}"`);
                 }
-                // End step telemetry span successfully
+                // End step span successfully
                 const stepSpan = this.#stepSpans.get(step.id);
                 if (stepSpan) {
-                    await this.#telemetry.endStepSpan(stepSpan, { status: 'ok' });
+                    stepSpan.setStatus({ code: SpanStatusCode.OK });
+                    stepSpan.end();
                     this.#stepSpans.delete(step.id);
                 }
                 // Log step completion
@@ -514,15 +546,22 @@ export class StepManager {
             },
         }).catch(async (error) => {
             if (step) {
-                // End step telemetry span with error/cancelled status
+                // End step span with error/cancelled status
                 const stepSpan = this.#stepSpans.get(step.id);
                 if (stepSpan) {
                     if (isCancelError(error)) {
-                        await this.#telemetry.endStepSpan(stepSpan, { status: 'cancelled' });
+                        stepSpan.setStatus({ code: SpanStatusCode.ERROR, message: 'Step cancelled' });
                     }
                     else {
-                        await this.#telemetry.endStepSpan(stepSpan, { status: 'error', error });
+                        stepSpan.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: error instanceof Error ? error.message : String(error),
+                        });
+                        if (error instanceof Error) {
+                            stepSpan.recordException(error);
+                        }
                     }
+                    stepSpan.end();
                     this.#stepSpans.delete(step.id);
                 }
                 if (isCancelError(error)) {
@@ -564,11 +603,11 @@ class ActionContext {
     #jobId;
     #groupKey = '@default';
     #action;
-    #observeContext;
+    #telemetryContext;
     // ============================================================================
     // Constructor
     // ============================================================================
-    constructor(stepManager, job, action, variables, abortSignal, logger, observeContext) {
+    constructor(stepManager, job, action, variables, abortSignal, logger, telemetryContext) {
         this.#stepManager = stepManager;
         this.#variables = variables;
         this.#abortSignal = abortSignal;
@@ -576,7 +615,7 @@ class ActionContext {
         this.#action = action;
         this.#jobId = job.id;
         this.#groupKey = job.groupKey ?? '@default';
-        this.#observeContext = observeContext;
+        this.#telemetryContext = telemetryContext;
         if (action.input) {
             this.#input = action.input.parse(job.input, {
                 error: () => 'Error parsing action input',
@@ -629,10 +668,10 @@ class ActionContext {
         return this.#logger;
     }
     /**
-     * Get the observability context for recording metrics and span data.
+     * Get the telemetry context for recording metrics and span data.
      */
-    get observe() {
-        return this.#observeContext;
+    get telemetry() {
+        return this.#telemetryContext;
     }
     /**
      * Execute a step within the action.

package/dist/telemetry/index.d.ts

@@ -1,5 +1,2 @@
-export { type AddSpanAttributeOptions, type AddSpanEventOptions, type EndSpanOptions, type ObserveContext, type RecordMetricOptions, type Span, type StartDatabaseSpanOptions, type StartJobSpanOptions, type StartSpanOptions, type StartStepSpanOptions, TelemetryAdapter, type Tracer, type TracerSpan, } from './adapter.js';
-export { LocalTelemetryAdapter, type LocalTelemetryAdapterOptions, localTelemetryAdapter } from './local.js';
-export { NoopTelemetryAdapter, noopTelemetryAdapter } from './noop.js';
-export { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions, openTelemetryAdapter } from './opentelemetry.js';
+export { LocalSpanExporter, type LocalSpanExporterOptions } from './local-span-exporter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,IAAI,EACT,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,gBAAgB,EAChB,KAAK,MAAM,EACX,KAAK,UAAU,GAChB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,qBAAqB,EAAE,KAAK,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAC5G,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAA;AACtE,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/telemetry/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/telemetry/index.js

@@ -1,5 +1,2 @@
-// Re-export telemetry adapters and types
-export { TelemetryAdapter, } from './adapter.js';
-export { LocalTelemetryAdapter, localTelemetryAdapter } from './local.js';
-export { NoopTelemetryAdapter, noopTelemetryAdapter } from './noop.js';
-export { OpenTelemetryAdapter, openTelemetryAdapter } from './opentelemetry.js';
+// OpenTelemetry-based span exporter for local database persistence
+export { LocalSpanExporter } from './local-span-exporter.js';

package/dist/telemetry/local-span-exporter.d.ts

@@ -0,0 +1,56 @@
+import { type ExportResult } from '@opentelemetry/core';
+import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import type { Adapter } from '../adapters/adapter.js';
+/**
+ * Configuration options for the LocalSpanExporter.
+ */
+export interface LocalSpanExporterOptions {
+    /**
+     * The database adapter to use for storing spans.
+     * This is the same adapter used by the Duron Client.
+     */
+    adapter: Adapter;
+}
+/**
+ * A custom OpenTelemetry SpanExporter that stores spans locally in the database.
+ *
+ * This exporter converts OpenTelemetry ReadableSpan objects into database records
+ * and inserts them via the Duron Adapter interface.
+ *
+ * It extracts `duron.job.id` and `duron.step.id` from span attributes to link
+ * spans to Duron jobs and steps.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSpanExporter } from 'duron/telemetry'
+ * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
+ *
+ * const exporter = new LocalSpanExporter({ adapter })
+ * const processor = new BatchSpanProcessor(exporter)
+ * ```
+ */
+export declare class LocalSpanExporter implements SpanExporter {
+    #private;
+    constructor(options: LocalSpanExporterOptions);
+    /**
+     * Export spans to the local database.
+     *
+     * Converts ReadableSpan objects to database records and inserts them.
+     * Follows OpenTelemetry exporter rules:
+     * - Does not throw exceptions
+     * - Does not modify received spans
+     * - Does not implement queuing/batching (handled by SpanProcessor)
+     */
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    /**
+     * Shutdown the exporter.
+     * After shutdown, no more spans will be exported.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Force flush any pending exports.
+     * Since we export synchronously to the database, this is a no-op.
+     */
+    forceFlush(): Promise<void>;
+}
+//# sourceMappingURL=local-span-exporter.d.ts.map

package/dist/telemetry/local-span-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-span-exporter.d.ts","sourceRoot":"","sources":["../../src/telemetry/local-span-exporter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,qBAAqB,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAE/E,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,wBAAwB,CAAA;AAExE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,iBAAkB,YAAW,YAAY;;gBAIxC,OAAO,EAAE,wBAAwB;IAI7C;;;;;;;;OAQG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE,cAAc,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAAG,IAAI;IAenF;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAoElC"}

package/dist/telemetry/local-span-exporter.js

@@ -0,0 +1,118 @@
+import { ExportResultCode } from '@opentelemetry/core';
+/**
+ * A custom OpenTelemetry SpanExporter that stores spans locally in the database.
+ *
+ * This exporter converts OpenTelemetry ReadableSpan objects into database records
+ * and inserts them via the Duron Adapter interface.
+ *
+ * It extracts `duron.job.id` and `duron.step.id` from span attributes to link
+ * spans to Duron jobs and steps.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSpanExporter } from 'duron/telemetry'
+ * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
+ *
+ * const exporter = new LocalSpanExporter({ adapter })
+ * const processor = new BatchSpanProcessor(exporter)
+ * ```
+ */
+export class LocalSpanExporter {
+    #adapter;
+    #shutdown = false;
+    constructor(options) {
+        this.#adapter = options.adapter;
+    }
+    /**
+     * Export spans to the local database.
+     *
+     * Converts ReadableSpan objects to database records and inserts them.
+     * Follows OpenTelemetry exporter rules:
+     * - Does not throw exceptions
+     * - Does not modify received spans
+     * - Does not implement queuing/batching (handled by SpanProcessor)
+     */
+    export(spans, resultCallback) {
+        if (this.#shutdown) {
+            resultCallback({ code: ExportResultCode.FAILED, error: new Error('Exporter has been shutdown') });
+            return;
+        }
+        this.#exportSpans(spans)
+            .then(() => {
+            resultCallback({ code: ExportResultCode.SUCCESS });
+        })
+            .catch((error) => {
+            resultCallback({ code: ExportResultCode.FAILED, error });
+        });
+    }
+    /**
+     * Shutdown the exporter.
+     * After shutdown, no more spans will be exported.
+     */
+    async shutdown() {
+        this.#shutdown = true;
+    }
+    /**
+     * Force flush any pending exports.
+     * Since we export synchronously to the database, this is a no-op.
+     */
+    async forceFlush() {
+        // No-op: we don't buffer spans, they're exported immediately
+    }
+    /**
+     * Internal method to export spans to the database.
+     */
+    async #exportSpans(spans) {
+        if (spans.length === 0) {
+            return;
+        }
+        const records = spans.map((span) => this.#readableSpanToRecord(span));
+        await this.#adapter.insertSpans(records);
+    }
+    /**
+     * Convert a ReadableSpan to an InsertSpanOptions record.
+     */
+    #readableSpanToRecord(span) {
+        const spanContext = span.spanContext();
+        // Extract Duron-specific attributes
+        const jobId = span.attributes['duron.job.id'];
+        const stepId = span.attributes['duron.step.id'];
+        // Convert attributes to plain object, excluding only job.id and step.id
+        // (those are stored in separate columns)
+        const attributes = {};
+        for (const [key, value] of Object.entries(span.attributes)) {
+            if (key !== 'duron.job.id' && key !== 'duron.step.id') {
+                attributes[key] = value;
+            }
+        }
+        // Convert events
+        const events = span.events.map((event) => ({
+            name: event.name,
+            timeUnixNano: this.#hrTimeToNanos(event.time).toString(),
+            attributes: event.attributes,
+        }));
+        // Get parent span ID from parentSpanContext if available
+        const parentSpanId = span.parentSpanContext?.spanId || null;
+        return {
+            traceId: spanContext.traceId,
+            spanId: spanContext.spanId,
+            parentSpanId,
+            jobId: jobId || null,
+            stepId: stepId || null,
+            name: span.name,
+            kind: span.kind,
+            startTimeUnixNano: this.#hrTimeToNanos(span.startTime),
+            endTimeUnixNano: span.endTime ? this.#hrTimeToNanos(span.endTime) : null,
+            statusCode: span.status.code,
+            statusMessage: span.status.message || null,
+            attributes,
+            events,
+        };
+    }
+    /**
+     * Convert HrTime [seconds, nanoseconds] to bigint nanoseconds.
+     */
+    #hrTimeToNanos(hrTime) {
+        return BigInt(hrTime[0]) * BigInt(1_000_000_000) + BigInt(hrTime[1]);
+    }
+}

package/migrations/postgres/{20260119153838_flimsy_thor_girl → 20260120154151_mean_magdalene}/migration.sql

@@ -43,17 +43,23 @@ CREATE TABLE "duron"."jobs" (
 	CONSTRAINT "jobs_status_check" CHECK ("status" IN ('created','active','completed','failed','cancelled'))
 );
 --> statement-breakpoint
-CREATE TABLE "duron"."metrics" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
-	"job_id" uuid NOT NULL,
+CREATE TABLE "duron"."spans" (
+	"id" bigserial PRIMARY KEY,
+	"trace_id" text NOT NULL,
+	"span_id" text NOT NULL,
+	"parent_span_id" text,
+	"job_id" uuid,
 	"step_id" uuid,
 	"name" text NOT NULL,
-	"value" double precision NOT NULL,
+	"kind" integer DEFAULT 0 NOT NULL,
+	"start_time_unix_nano" bigint NOT NULL,
+	"end_time_unix_nano" bigint,
+	"status_code" integer DEFAULT 0 NOT NULL,
+	"status_message" text,
 	"attributes" jsonb DEFAULT '{}' NOT NULL,
-	"type" text NOT NULL,
-	"timestamp" timestamp with time zone DEFAULT now() NOT NULL,
-	"created_at" timestamp with time zone DEFAULT now() NOT NULL,
-	CONSTRAINT "metrics_type_check" CHECK ("type" IN ('metric', 'span_event', 'span_attribute'))
+	"events" jsonb DEFAULT '[]' NOT NULL,
+	CONSTRAINT "spans_kind_check" CHECK ("kind" IN (0, 1, 2, 3, 4)),
+	CONSTRAINT "spans_status_code_check" CHECK ("status_code" IN (0, 1, 2))
 );
 --> statement-breakpoint
 CREATE INDEX "idx_job_steps_job_id" ON "duron"."job_steps" ("job_id");--> statement-breakpoint
@@ -77,15 +83,17 @@ CREATE INDEX "idx_jobs_action_status" ON "duron"."jobs" ("action_name","status")
 CREATE INDEX "idx_jobs_action_group" ON "duron"."jobs" ("action_name","group_key");--> statement-breakpoint
 CREATE INDEX "idx_jobs_input_fts" ON "duron"."jobs" USING gin (to_tsvector('english', "input"::text));--> statement-breakpoint
 CREATE INDEX "idx_jobs_output_fts" ON "duron"."jobs" USING gin (to_tsvector('english', "output"::text));--> statement-breakpoint
-CREATE INDEX "idx_metrics_job_id" ON "duron"."metrics" ("job_id");--> statement-breakpoint
-CREATE INDEX "idx_metrics_step_id" ON "duron"."metrics" ("step_id");--> statement-breakpoint
-CREATE INDEX "idx_metrics_name" ON "duron"."metrics" ("name");--> statement-breakpoint
-CREATE INDEX "idx_metrics_type" ON "duron"."metrics" ("type");--> statement-breakpoint
-CREATE INDEX "idx_metrics_timestamp" ON "duron"."metrics" ("timestamp");--> statement-breakpoint
-CREATE INDEX "idx_metrics_job_step" ON "duron"."metrics" ("job_id","step_id");--> statement-breakpoint
-CREATE INDEX "idx_metrics_job_name" ON "duron"."metrics" ("job_id","name");--> statement-breakpoint
-CREATE INDEX "idx_metrics_job_type" ON "duron"."metrics" ("job_id","type");--> statement-breakpoint
-CREATE INDEX "idx_metrics_attributes" ON "duron"."metrics" USING gin ("attributes");--> statement-breakpoint
+CREATE INDEX "idx_spans_trace_id" ON "duron"."spans" ("trace_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_span_id" ON "duron"."spans" ("span_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_job_id" ON "duron"."spans" ("job_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_step_id" ON "duron"."spans" ("step_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_name" ON "duron"."spans" ("name");--> statement-breakpoint
+CREATE INDEX "idx_spans_kind" ON "duron"."spans" ("kind");--> statement-breakpoint
+CREATE INDEX "idx_spans_status_code" ON "duron"."spans" ("status_code");--> statement-breakpoint
+CREATE INDEX "idx_spans_job_step" ON "duron"."spans" ("job_id","step_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_trace_parent" ON "duron"."spans" ("trace_id","parent_span_id");--> statement-breakpoint
+CREATE INDEX "idx_spans_attributes" ON "duron"."spans" USING gin ("attributes");--> statement-breakpoint
+CREATE INDEX "idx_spans_events" ON "duron"."spans" USING gin ("events");--> statement-breakpoint
 ALTER TABLE "duron"."job_steps" ADD CONSTRAINT "job_steps_job_id_jobs_id_fkey" FOREIGN KEY ("job_id") REFERENCES "duron"."jobs"("id") ON DELETE CASCADE;--> statement-breakpoint
-ALTER TABLE "duron"."metrics" ADD CONSTRAINT "metrics_job_id_jobs_id_fkey" FOREIGN KEY ("job_id") REFERENCES "duron"."jobs"("id") ON DELETE CASCADE;--> statement-breakpoint
-ALTER TABLE "duron"."metrics" ADD CONSTRAINT "metrics_step_id_job_steps_id_fkey" FOREIGN KEY ("step_id") REFERENCES "duron"."job_steps"("id") ON DELETE CASCADE;
+ALTER TABLE "duron"."spans" ADD CONSTRAINT "spans_job_id_jobs_id_fkey" FOREIGN KEY ("job_id") REFERENCES "duron"."jobs"("id") ON DELETE CASCADE;--> statement-breakpoint
+ALTER TABLE "duron"."spans" ADD CONSTRAINT "spans_step_id_job_steps_id_fkey" FOREIGN KEY ("step_id") REFERENCES "duron"."job_steps"("id") ON DELETE CASCADE;