duron 0.3.0-beta.10 → 0.3.0-beta.12

package/src/action-manager.ts

@@ -1,15 +1,15 @@
+import type { Tracer } from '@opentelemetry/api'
 import fastq from 'fastq'
 import type { Logger } from 'pino'
 
 import type { Action } from './action.js'
 import { ActionJob } from './action-job.js'
 import type { Adapter, Job } from './adapters/adapter.js'
-import type { TelemetryAdapter } from './telemetry/adapter.js'
 
 export interface ActionManagerOptions<TAction extends Action<any, any, any>> {
   action: TAction
   database: Adapter
-  telemetry: TelemetryAdapter
+  tracer: Tracer
   variables: Record<string, unknown>
   logger: Logger
   concurrencyLimit: number
@@ -24,7 +24,7 @@ export interface ActionManagerOptions<TAction extends Action<any, any, any>> {
 export class ActionManager<TAction extends Action<any, any, any>> {
   #action: TAction
   #database: Adapter
-  #telemetry: TelemetryAdapter
+  #tracer: Tracer
   #variables: Record<string, unknown>
   #logger: Logger
   #queue: fastq.queueAsPromised<Job, void>
@@ -44,7 +44,7 @@ export class ActionManager<TAction extends Action<any, any, any>> {
   constructor(options: ActionManagerOptions<TAction>) {
     this.#action = options.action
     this.#database = options.database
-    this.#telemetry = options.telemetry
+    this.#tracer = options.tracer
     this.#variables = options.variables
     this.#logger = options.logger
     this.#concurrencyLimit = options.concurrencyLimit
@@ -153,7 +153,7 @@ export class ActionManager<TAction extends Action<any, any, any>> {
       },
       action: this.#action,
       database: this.#database,
-      telemetry: this.#telemetry,
+      tracer: this.#tracer,
       variables: this.#variables,
       logger: this.#logger,
     })

package/src/action.ts

@@ -1,7 +1,7 @@
 import type { Logger } from 'pino'
 import * as z from 'zod'
 
-import type { ObserveContext } from './telemetry/adapter.js'
+import type { TelemetryContext } from './step-manager.js'
 import generateChecksum from './utils/checksum.js'
 
 export type RetryOptions = z.infer<typeof RetryOptionsSchema>
@@ -16,10 +16,10 @@ export interface ActionHandlerContext<TInput extends z.ZodObject, TVariables = R
   logger: Logger
 
   /**
-   * Observability context for recording metrics and span data.
-   * Allows recording custom metrics, span attributes, and events.
+   * Telemetry context for recording metrics and span data.
+   * Provides access to OpenTelemetry APIs for recording traces and metrics.
    */
-  observe: ObserveContext
+  telemetry: TelemetryContext
 
   /**
    * Execute an inline step within the action.
@@ -71,10 +71,10 @@ export interface StepHandlerContext {
   parentStepId: string | null
 
   /**
-   * Observability context for recording metrics and span data.
-   * Allows recording custom metrics, span attributes, and events.
+   * Telemetry context for recording metrics and span data.
+   * Provides access to OpenTelemetry APIs for recording traces and metrics.
    */
-  observe: ObserveContext
+  telemetry: TelemetryContext
 
   /**
    * Create a nested child step.

package/src/adapters/adapter.ts

@@ -24,7 +24,7 @@ import type {
   DelayJobStepOptions,
   DeleteJobOptions,
   DeleteJobsOptions,
-  DeleteMetricsOptions,
+  DeleteSpansOptions,
   FailJobOptions,
   FailJobStepOptions,
   FetchOptions,
@@ -33,9 +33,9 @@ import type {
   GetJobStepsResult,
   GetJobsOptions,
   GetJobsResult,
-  GetMetricsOptions,
-  GetMetricsResult,
-  InsertMetricOptions,
+  GetSpansOptions,
+  GetSpansResult,
+  InsertSpanOptions,
   Job,
   JobStatusResult,
   JobStep,
@@ -56,7 +56,7 @@ import {
   DelayJobStepOptionsSchema,
   DeleteJobOptionsSchema,
   DeleteJobsOptionsSchema,
-  DeleteMetricsOptionsSchema,
+  DeleteSpansOptionsSchema,
   FailJobOptionsSchema,
   FailJobStepOptionsSchema,
   FetchOptionsSchema,
@@ -65,9 +65,9 @@ import {
   GetJobStepsResultSchema,
   GetJobsOptionsSchema,
   GetJobsResultSchema,
-  GetMetricsOptionsSchema,
-  GetMetricsResultSchema,
-  InsertMetricOptionsSchema,
+  GetSpansOptionsSchema,
+  GetSpansResultSchema,
+  InsertSpanOptionsSchema,
   JobIdResultSchema,
   JobSchema,
   JobStatusResultSchema,
@@ -93,7 +93,7 @@ export type {
   DelayJobStepOptions,
   DeleteJobOptions,
   DeleteJobsOptions,
-  DeleteMetricsOptions,
+  DeleteSpansOptions,
   FailJobOptions,
   FailJobStepOptions,
   FetchOptions,
@@ -102,9 +102,9 @@ export type {
   GetJobStepsResult,
   GetJobsOptions,
   GetJobsResult,
-  GetMetricsOptions,
-  GetMetricsResult,
-  InsertMetricOptions,
+  GetSpansOptions,
+  GetSpansResult,
+  InsertSpanOptions,
   Job,
   JobFilters,
   JobSort,
@@ -112,14 +112,16 @@ export type {
   JobStatusResult,
   JobStep,
   JobStepStatusResult,
-  Metric,
-  MetricFilters,
-  MetricSort,
-  MetricSortField,
-  MetricType,
   RecoverJobsOptions,
   RetryJobOptions,
   SortOrder,
+  Span,
+  SpanEvent,
+  SpanFilters,
+  SpanKind,
+  SpanSort,
+  SpanSortField,
+  SpanStatusCode,
   TimeTravelJobOptions,
 } from './schemas.js'
 
@@ -993,100 +995,98 @@ export abstract class Adapter extends EventEmitter<AdapterEvents> {
   protected abstract _getActions(): Promise<GetActionsResult>
 
   // ============================================================================
-  // Metrics Methods
+  // Span Methods (OpenTelemetry)
   // ============================================================================
 
   /**
-   * Insert multiple metric records in a single batch operation.
-   * Note: This method bypasses telemetry tracing to prevent infinite loops.
+   * Insert multiple span records in a single batch operation.
+   * Used by LocalSpanExporter to store spans from the OpenTelemetry SDK.
    *
-   * @param metrics - Array of metric data to insert
-   * @returns Promise resolving to the number of metrics inserted
+   * @param spans - Array of span data to insert
+   * @returns Promise resolving to the number of spans inserted
    */
-  async insertMetrics(metrics: InsertMetricOptions[]): Promise<number> {
+  async insertSpans(spans: InsertSpanOptions[]): Promise<number> {
     try {
-      if (metrics.length === 0) {
+      if (spans.length === 0) {
         return 0
       }
       await this.start()
-      const parsedMetrics = metrics.map((m) => InsertMetricOptionsSchema.parse(m))
-      const result = await this._insertMetrics(parsedMetrics)
+      const parsedSpans = spans.map((s) => InsertSpanOptionsSchema.parse(s))
+      const result = await this._insertSpans(parsedSpans)
       return NumberResultSchema.parse(result)
     } catch (error) {
-      this.#logger?.error(error, 'Error in Adapter.insertMetrics()')
+      this.#logger?.error(error, 'Error in Adapter.insertSpans()')
       throw error
     }
   }
 
   /**
-   * Get metrics for a job or step.
-   * Note: This method bypasses telemetry tracing to prevent infinite loops.
+   * Get spans for a job or step.
    *
-   * @param options - Query options including jobId/stepId, filters, sort, and pagination
-   * @returns Promise resolving to metrics result with pagination info
+   * @param options - Query options including jobId/stepId, filters, and sort
+   * @returns Promise resolving to spans result
    */
-  async getMetrics(options: GetMetricsOptions): Promise<GetMetricsResult> {
+  async getSpans(options: GetSpansOptions): Promise<GetSpansResult> {
     try {
       await this.start()
-      const parsedOptions = GetMetricsOptionsSchema.parse(options)
+      const parsedOptions = GetSpansOptionsSchema.parse(options)
       // Validate that at least one of jobId or stepId is provided
       if (!parsedOptions.jobId && !parsedOptions.stepId) {
         throw new Error('At least one of jobId or stepId must be provided')
       }
-      const result = await this._getMetrics(parsedOptions)
-      return GetMetricsResultSchema.parse(result)
+      const result = await this._getSpans(parsedOptions)
+      return GetSpansResultSchema.parse(result)
     } catch (error) {
-      this.#logger?.error(error, 'Error in Adapter.getMetrics()')
+      this.#logger?.error(error, 'Error in Adapter.getSpans()')
       throw error
     }
   }
 
   /**
-   * Delete all metrics for a job.
-   * Note: This method bypasses telemetry tracing to prevent infinite loops.
+   * Delete all spans for a job.
    *
    * @param options - Options containing the jobId
-   * @returns Promise resolving to the number of metrics deleted
+   * @returns Promise resolving to the number of spans deleted
    */
-  async deleteMetrics(options: DeleteMetricsOptions): Promise<number> {
+  async deleteSpans(options: DeleteSpansOptions): Promise<number> {
     try {
       await this.start()
-      const parsedOptions = DeleteMetricsOptionsSchema.parse(options)
-      const result = await this._deleteMetrics(parsedOptions)
+      const parsedOptions = DeleteSpansOptionsSchema.parse(options)
+      const result = await this._deleteSpans(parsedOptions)
       return NumberResultSchema.parse(result)
     } catch (error) {
-      this.#logger?.error(error, 'Error in Adapter.deleteMetrics()')
+      this.#logger?.error(error, 'Error in Adapter.deleteSpans()')
       throw error
     }
   }
 
   // ============================================================================
-  // Private Metrics Methods (to be implemented by adapters)
+  // Private Span Methods (to be implemented by adapters)
   // ============================================================================
 
   /**
-   * Internal method to insert multiple metric records in a single batch.
+   * Internal method to insert multiple span records in a single batch.
    *
-   * @param metrics - Array of validated metric data
-   * @returns Promise resolving to the number of metrics inserted
+   * @param spans - Array of validated span data
+   * @returns Promise resolving to the number of spans inserted
    */
-  protected abstract _insertMetrics(metrics: InsertMetricOptions[]): Promise<number>
+  protected abstract _insertSpans(spans: InsertSpanOptions[]): Promise<number>
 
   /**
-   * Internal method to get metrics for a job or step.
+   * Internal method to get spans for a job or step.
    *
    * @param options - Validated query options
-   * @returns Promise resolving to metrics result with pagination info
+   * @returns Promise resolving to spans result
    */
-  protected abstract _getMetrics(options: GetMetricsOptions): Promise<GetMetricsResult>
+  protected abstract _getSpans(options: GetSpansOptions): Promise<GetSpansResult>
 
   /**
-   * Internal method to delete all metrics for a job.
+   * Internal method to delete all spans for a job.
    *
    * @param options - Validated options containing the jobId
-   * @returns Promise resolving to the number of metrics deleted
+   * @returns Promise resolving to the number of spans deleted
    */
-  protected abstract _deleteMetrics(options: DeleteMetricsOptions): Promise<number>
+  protected abstract _deleteSpans(options: DeleteSpansOptions): Promise<number>
 
   // ============================================================================
   // Protected Abstract Methods (to be implemented by adapters)

package/src/adapters/postgres/base.ts

@@ -24,7 +24,7 @@ import {
   type DelayJobStepOptions,
   type DeleteJobOptions,
   type DeleteJobsOptions,
-  type DeleteMetricsOptions,
+  type DeleteSpansOptions,
   type FailJobOptions,
   type FailJobStepOptions,
   type FetchOptions,
@@ -33,17 +33,17 @@ import {
   type GetJobStepsResult,
   type GetJobsOptions,
   type GetJobsResult,
-  type GetMetricsOptions,
-  type GetMetricsResult,
-  type InsertMetricOptions,
+  type GetSpansOptions,
+  type GetSpansResult,
+  type InsertSpanOptions,
   type Job,
   type JobSort,
   type JobStatusResult,
   type JobStep,
   type JobStepStatusResult,
-  type MetricSort,
   type RecoverJobsOptions,
   type RetryJobOptions,
+  type SpanSort,
   type TimeTravelJobOptions,
 } from '../adapter.js'
 import createSchema from './schema.js'
@@ -788,7 +788,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       step_existed AS (
         SELECT EXISTS(
           SELECT 1 FROM ${this.tables.jobStepsTable} s
-          WHERE s.job_id = ${jobId} 
+          WHERE s.job_id = ${jobId}
             AND s.name = ${name}
             AND s.parent_step_id IS NOT DISTINCT FROM ${parentStepId}
         ) AS existed
@@ -1011,26 +1011,38 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
    * Internal method to get a job by its ID. Does not include step information.
    */
   protected async _getJobById(jobId: string): Promise<Job | null> {
+    const jobsTable = this.tables.jobsTable
+
+    // Calculate duration as a SQL expression (finishedAt - startedAt in milliseconds)
+    const durationMs = sql<number | null>`
+      CASE
+        WHEN ${jobsTable.started_at} IS NOT NULL AND ${jobsTable.finished_at} IS NOT NULL
+        THEN EXTRACT(EPOCH FROM (${jobsTable.finished_at} - ${jobsTable.started_at})) * 1000
+        ELSE NULL
+      END
+    `.as('duration_ms')
+
     const [job] = await this.db
       .select({
-        id: this.tables.jobsTable.id,
-        actionName: this.tables.jobsTable.action_name,
-        groupKey: this.tables.jobsTable.group_key,
-        input: this.tables.jobsTable.input,
-        output: this.tables.jobsTable.output,
-        error: this.tables.jobsTable.error,
-        status: this.tables.jobsTable.status,
-        timeoutMs: this.tables.jobsTable.timeout_ms,
-        expiresAt: this.tables.jobsTable.expires_at,
-        startedAt: this.tables.jobsTable.started_at,
-        finishedAt: this.tables.jobsTable.finished_at,
-        createdAt: this.tables.jobsTable.created_at,
-        updatedAt: this.tables.jobsTable.updated_at,
-        concurrencyLimit: this.tables.jobsTable.concurrency_limit,
-        clientId: this.tables.jobsTable.client_id,
+        id: jobsTable.id,
+        actionName: jobsTable.action_name,
+        groupKey: jobsTable.group_key,
+        input: jobsTable.input,
+        output: jobsTable.output,
+        error: jobsTable.error,
+        status: jobsTable.status,
+        timeoutMs: jobsTable.timeout_ms,
+        expiresAt: jobsTable.expires_at,
+        startedAt: jobsTable.started_at,
+        finishedAt: jobsTable.finished_at,
+        createdAt: jobsTable.created_at,
+        updatedAt: jobsTable.updated_at,
+        concurrencyLimit: jobsTable.concurrency_limit,
+        clientId: jobsTable.client_id,
+        durationMs,
       })
-      .from(this.tables.jobsTable)
-      .where(eq(this.tables.jobsTable.id, jobId))
+      .from(jobsTable)
+      .where(eq(jobsTable.id, jobId))
       .limit(1)
 
     return job ?? null
@@ -1194,6 +1206,15 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       }
     }
 
+    // Calculate duration as a SQL expression (finishedAt - startedAt in milliseconds)
+    const durationMs = sql<number | null>`
+      CASE
+        WHEN ${jobsTable.started_at} IS NOT NULL AND ${jobsTable.finished_at} IS NOT NULL
+        THEN EXTRACT(EPOCH FROM (${jobsTable.finished_at} - ${jobsTable.started_at})) * 1000
+        ELSE NULL
+      END
+    `.as('duration_ms')
+
     const sortFieldMap: Record<JobSort['field'], any> = {
       createdAt: jobsTable.created_at,
       startedAt: jobsTable.started_at,
@@ -1201,6 +1222,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
       status: jobsTable.status,
       actionName: jobsTable.action_name,
       expiresAt: jobsTable.expires_at,
+      duration: durationMs,
     }
 
     const jobs = await this.db
@@ -1220,6 +1242,7 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
         updatedAt: jobsTable.updated_at,
         concurrencyLimit: jobsTable.concurrency_limit,
         clientId: jobsTable.client_id,
+        durationMs,
       })
       .from(jobsTable)
       .where(where)
@@ -1362,54 +1385,60 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
   // ============================================================================
 
   /**
-   * Internal method to insert multiple metric records in a single batch.
+   * Internal method to insert multiple span records in a single batch.
    */
-  protected async _insertMetrics(metrics: InsertMetricOptions[]): Promise<number> {
-    if (metrics.length === 0) {
+  protected async _insertSpans(spans: InsertSpanOptions[]): Promise<number> {
+    if (spans.length === 0) {
       return 0
     }
 
-    const values = metrics.map((m) => ({
-      job_id: m.jobId,
-      step_id: m.stepId ?? null,
-      name: m.name,
-      value: m.value,
-      attributes: m.attributes ?? {},
-      type: m.type,
+    const values = spans.map((s) => ({
+      trace_id: s.traceId,
+      span_id: s.spanId,
+      parent_span_id: s.parentSpanId,
+      job_id: s.jobId,
+      step_id: s.stepId,
+      name: s.name,
+      kind: s.kind,
+      start_time_unix_nano: s.startTimeUnixNano,
+      end_time_unix_nano: s.endTimeUnixNano,
+      status_code: s.statusCode,
+      status_message: s.statusMessage,
+      attributes: s.attributes ?? {},
+      events: s.events ?? [],
     }))
 
     const result = await this.db
-      .insert(this.tables.metricsTable)
+      .insert(this.tables.spansTable)
       .values(values)
-      .returning({ id: this.tables.metricsTable.id })
+      .returning({ id: this.tables.spansTable.id })
 
     return result.length
   }
 
   /**
-   * Internal method to get metrics for a job or step.
+   * Internal method to get spans for a job or step.
    */
-  protected async _getMetrics(options: GetMetricsOptions): Promise<GetMetricsResult> {
-    const metricsTable = this.tables.metricsTable
+  protected async _getSpans(options: GetSpansOptions): Promise<GetSpansResult> {
+    const spansTable = this.tables.spansTable
     const filters = options.filters ?? {}
 
     // Build WHERE clause
-    const where = this._buildMetricsWhereClause(options.jobId, options.stepId, filters)
+    const where = this._buildSpansWhereClause(options.jobId, options.stepId, filters)
 
     // Build sort
-    const sortInput = options.sort ?? { field: 'timestamp', order: 'desc' }
-    const sortFieldMap: Record<MetricSort['field'], any> = {
-      name: metricsTable.name,
-      value: metricsTable.value,
-      timestamp: metricsTable.timestamp,
-      createdAt: metricsTable.created_at,
+    const sortInput = options.sort ?? { field: 'startTimeUnixNano', order: 'asc' }
+    const sortFieldMap: Record<SpanSort['field'], any> = {
+      name: spansTable.name,
+      startTimeUnixNano: spansTable.start_time_unix_nano,
+      endTimeUnixNano: spansTable.end_time_unix_nano,
     }
 
     // Get total count
-    const total = await this.db.$count(metricsTable, where)
+    const total = await this.db.$count(spansTable, where)
     if (!total) {
       return {
-        metrics: [],
+        spans: [],
         total: 0,
       }
     }
@@ -1417,62 +1446,96 @@ export class PostgresBaseAdapter<Database extends DrizzleDatabase, Connection> e
     const sortField = sortFieldMap[sortInput.field]
     const orderByClause = sortInput.order === 'asc' ? asc(sortField) : desc(sortField)
 
-    const metrics = await this.db
+    const rows = await this.db
       .select({
-        id: metricsTable.id,
-        jobId: metricsTable.job_id,
-        stepId: metricsTable.step_id,
-        name: metricsTable.name,
-        value: metricsTable.value,
-        attributes: metricsTable.attributes,
-        type: metricsTable.type,
-        timestamp: metricsTable.timestamp,
-        createdAt: metricsTable.created_at,
+        id: spansTable.id,
+        traceId: spansTable.trace_id,
+        spanId: spansTable.span_id,
+        parentSpanId: spansTable.parent_span_id,
+        jobId: spansTable.job_id,
+        stepId: spansTable.step_id,
+        name: spansTable.name,
+        kind: spansTable.kind,
+        startTimeUnixNano: spansTable.start_time_unix_nano,
+        endTimeUnixNano: spansTable.end_time_unix_nano,
+        statusCode: spansTable.status_code,
+        statusMessage: spansTable.status_message,
+        attributes: spansTable.attributes,
+        events: spansTable.events,
       })
-      .from(metricsTable)
+      .from(spansTable)
       .where(where)
       .orderBy(orderByClause)
 
+    // Cast kind and statusCode to proper types, convert BigInt to string for JSON serialization
+    const spans = rows.map((row) => ({
+      ...row,
+      kind: row.kind as 0 | 1 | 2 | 3 | 4,
+      statusCode: row.statusCode as 0 | 1 | 2,
+      // Convert BigInt to string for JSON serialization
+      startTimeUnixNano: row.startTimeUnixNano?.toString() ?? null,
+      endTimeUnixNano: row.endTimeUnixNano?.toString() ?? null,
+    }))
+
     return {
-      metrics,
+      spans,
       total,
     }
   }
 
   /**
-   * Internal method to delete all metrics for a job.
+   * Internal method to delete all spans for a job.
    */
-  protected async _deleteMetrics(options: DeleteMetricsOptions): Promise<number> {
+  protected async _deleteSpans(options: DeleteSpansOptions): Promise<number> {
     const result = await this.db
-      .delete(this.tables.metricsTable)
-      .where(eq(this.tables.metricsTable.job_id, options.jobId))
-      .returning({ id: this.tables.metricsTable.id })
+      .delete(this.tables.spansTable)
+      .where(eq(this.tables.spansTable.job_id, options.jobId))
+      .returning({ id: this.tables.spansTable.id })
 
     return result.length
   }
 
   /**
-   * Build WHERE clause for metrics queries.
+   * Build WHERE clause for spans queries.
+   * When querying by jobId or stepId, we find all spans that share the same trace_id
+   * as spans with that job/step. This includes spans from external libraries that
+   * don't have the duron.job.id attribute but are part of the same trace.
    */
-  protected _buildMetricsWhereClause(jobId?: string, stepId?: string, filters?: GetMetricsOptions['filters']) {
-    const metricsTable = this.tables.metricsTable
+  protected _buildSpansWhereClause(jobId?: string, stepId?: string, filters?: GetSpansOptions['filters']) {
+    const spansTable = this.tables.spansTable
+
+    // Build condition for finding spans by trace_id (includes external spans)
+    let traceCondition: ReturnType<typeof eq> | undefined
+
+    if (jobId) {
+      // Find all spans that share a trace_id with any span that has this job_id
+      // This includes external spans (like from AI SDK) that don't have duron.job.id
+      traceCondition = inArray(
+        spansTable.trace_id,
+        this.db.select({ traceId: spansTable.trace_id }).from(spansTable).where(eq(spansTable.job_id, jobId)),
+      )
+    } else if (stepId) {
+      // Find all spans that share a trace_id with any span that has this step_id
+      traceCondition = inArray(
+        spansTable.trace_id,
+        this.db.select({ traceId: spansTable.trace_id }).from(spansTable).where(eq(spansTable.step_id, stepId)),
+      )
+    }
 
     return and(
-      jobId ? eq(metricsTable.job_id, jobId) : undefined,
-      stepId ? eq(metricsTable.step_id, stepId) : undefined,
+      traceCondition,
       filters?.name
         ? Array.isArray(filters.name)
-          ? or(...filters.name.map((n) => ilike(metricsTable.name, `%${n}%`)))
-          : ilike(metricsTable.name, `%${filters.name}%`)
-        : undefined,
-      filters?.type
-        ? inArray(metricsTable.type, Array.isArray(filters.type) ? filters.type : [filters.type])
+          ? or(...filters.name.map((n) => ilike(spansTable.name, `%${n}%`)))
+          : ilike(spansTable.name, `%${filters.name}%`)
         : undefined,
-      filters?.timestampRange && filters.timestampRange.length === 2
-        ? between(metricsTable.timestamp, filters.timestampRange[0]!, filters.timestampRange[1]!)
+      filters?.kind ? inArray(spansTable.kind, Array.isArray(filters.kind) ? filters.kind : [filters.kind]) : undefined,
+      filters?.statusCode
+        ? inArray(spansTable.status_code, Array.isArray(filters.statusCode) ? filters.statusCode : [filters.statusCode])
         : undefined,
+      filters?.traceId ? eq(spansTable.trace_id, filters.traceId) : undefined,
       ...(filters?.attributesFilter && Object.keys(filters.attributesFilter).length > 0
-        ? this.#buildJsonbWhereConditions(filters.attributesFilter, metricsTable.attributes)
+        ? this.#buildJsonbWhereConditions(filters.attributesFilter, spansTable.attributes)
         : []),
     )
   }

package/src/adapters/postgres/schema.default.ts

@@ -1,5 +1,5 @@
 import createSchema from './schema.js'
 
-const { schema, jobsTable, jobStepsTable, metricsTable } = createSchema('duron')
+const { schema, jobsTable, jobStepsTable, spansTable } = createSchema('duron')
 
-export { schema, jobsTable, jobStepsTable, metricsTable }
+export { schema, jobsTable, jobStepsTable, spansTable }