duron 0.3.0-beta.8 → 0.3.0

package/src/adapters/postgres/schema.ts

@@ -1,8 +1,9 @@
 import { sql } from 'drizzle-orm'
 import {
+  bigint,
+  bigserial,
   boolean,
   check,
-  doublePrecision,
   index,
   integer,
   jsonb,
@@ -25,6 +26,7 @@ export default function createSchema(schemaName: string) {
       id: uuid('id').primaryKey().defaultRandom(),
       action_name: text('action_name').notNull(),
       group_key: text('group_key').notNull(),
+      description: text('description'),
       status: text('status').$type<JobStatus>().notNull().default('created'),
       checksum: text('checksum').notNull(),
       input: jsonb('input').notNull().default({}),
@@ -35,7 +37,8 @@ export default function createSchema(schemaName: string) {
       started_at: timestamp('started_at', { withTimezone: true }),
       finished_at: timestamp('finished_at', { withTimezone: true }),
       client_id: text('client_id'),
-      concurrency_limit: integer('concurrency_limit').notNull().default(10),
+      concurrency_limit: integer('concurrency_limit').notNull(),
+      concurrency_step_limit: integer('concurrency_step_limit').notNull(),
       created_at: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
       updated_at: timestamp('updated_at', { withTimezone: true })
         .notNull()
@@ -52,12 +55,14 @@ export default function createSchema(schemaName: string) {
       index('idx_jobs_action_name').on(table.action_name),
       index('idx_jobs_status').on(table.status),
       index('idx_jobs_group_key').on(table.group_key),
+      index('idx_jobs_description').on(table.description),
       index('idx_jobs_started_at').on(table.started_at),
       index('idx_jobs_finished_at').on(table.finished_at),
       index('idx_jobs_expires_at').on(table.expires_at),
       index('idx_jobs_client_id').on(table.client_id),
       index('idx_jobs_checksum').on(table.checksum),
       index('idx_jobs_concurrency_limit').on(table.concurrency_limit),
+      index('idx_jobs_concurrency_step_limit').on(table.concurrency_step_limit),
       // Composite indexes
       index('idx_jobs_action_status').on(table.action_name, table.status),
       index('idx_jobs_action_group').on(table.action_name, table.group_key),
@@ -129,35 +134,58 @@ export default function createSchema(schemaName: string) {
     ],
   )
 
-  const metricsTable = schema.table(
-    'metrics',
+  /**
+   * OpenTelemetry spans table.
+   * Stores span data exported by PostgresSpanExporter.
+   *
+   * SpanKind values: 0=INTERNAL, 1=SERVER, 2=CLIENT, 3=PRODUCER, 4=CONSUMER
+   * StatusCode values: 0=UNSET, 1=OK, 2=ERROR
+   */
+  const spansTable = schema.table(
+    'spans',
     {
-      id: uuid('id').primaryKey().defaultRandom(),
-      job_id: uuid('job_id')
-        .notNull()
-        .references(() => jobsTable.id, { onDelete: 'cascade' }),
+      id: bigserial('id', { mode: 'number' }).primaryKey(),
+      // OpenTelemetry span identifiers
+      trace_id: text('trace_id').notNull(), // 32-char hex
+      span_id: text('span_id').notNull(), // 16-char hex
+      parent_span_id: text('parent_span_id'), // 16-char hex, null for root spans
+      // Duron-specific references (extracted from span attributes)
+      job_id: uuid('job_id').references(() => jobsTable.id, { onDelete: 'cascade' }),
       step_id: uuid('step_id').references(() => jobStepsTable.id, { onDelete: 'cascade' }),
+      // Span metadata
       name: text('name').notNull(),
-      value: doublePrecision('value').notNull(),
+      kind: integer('kind').notNull().default(0), // SpanKind enum
+      // Timing (stored as nanoseconds since epoch for precision)
+      start_time_unix_nano: bigint('start_time_unix_nano', { mode: 'bigint' }).notNull(),
+      end_time_unix_nano: bigint('end_time_unix_nano', { mode: 'bigint' }),
+      // Status
+      status_code: integer('status_code').notNull().default(0), // SpanStatusCode enum
+      status_message: text('status_message'),
+      // Span data
       attributes: jsonb('attributes').$type<Record<string, any>>().notNull().default({}),
-      type: text('type').$type<'metric' | 'span_event' | 'span_attribute'>().notNull(),
-      timestamp: timestamp('timestamp', { withTimezone: true }).notNull().defaultNow(),
-      created_at: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+      events: jsonb('events')
+        .$type<Array<{ name: string; timeUnixNano: string; attributes?: Record<string, any> }>>()
+        .notNull()
+        .default([]),
     },
     (table) => [
       // Single column indexes
-      index('idx_metrics_job_id').on(table.job_id),
-      index('idx_metrics_step_id').on(table.step_id),
-      index('idx_metrics_name').on(table.name),
-      index('idx_metrics_type').on(table.type),
-      index('idx_metrics_timestamp').on(table.timestamp),
+      index('idx_spans_trace_id').on(table.trace_id),
+      index('idx_spans_span_id').on(table.span_id),
+      index('idx_spans_job_id').on(table.job_id),
+      index('idx_spans_step_id').on(table.step_id),
+      index('idx_spans_name').on(table.name),
+      index('idx_spans_kind').on(table.kind),
+      index('idx_spans_status_code').on(table.status_code),
       // Composite indexes
-      index('idx_metrics_job_step').on(table.job_id, table.step_id),
-      index('idx_metrics_job_name').on(table.job_id, table.name),
-      index('idx_metrics_job_type').on(table.job_id, table.type),
-      // GIN index for JSONB attributes filtering
-      index('idx_metrics_attributes').using('gin', table.attributes),
-      check('metrics_type_check', sql`${table.type} IN ('metric', 'span_event', 'span_attribute')`),
+      index('idx_spans_job_step').on(table.job_id, table.step_id),
+      index('idx_spans_trace_parent').on(table.trace_id, table.parent_span_id),
+      // GIN indexes for JSONB querying
+      index('idx_spans_attributes').using('gin', table.attributes),
+      index('idx_spans_events').using('gin', table.events),
+      // Constraints
+      check('spans_kind_check', sql`${table.kind} IN (0, 1, 2, 3, 4)`),
+      check('spans_status_code_check', sql`${table.status_code} IN (0, 1, 2)`),
     ],
   )
 
@@ -165,6 +193,6 @@ export default function createSchema(schemaName: string) {
     schema,
     jobsTable,
     jobStepsTable,
-    metricsTable,
+    spansTable,
   }
 }

package/src/adapters/schemas.ts

@@ -34,6 +34,7 @@ export const JobSchema = z.object({
   id: z.string(),
   actionName: z.string(),
   groupKey: z.string(),
+  description: z.string().nullable().default(null),
   input: z.any(),
   output: z.any().nullable(),
   error: z.any().nullable(),
@@ -45,7 +46,10 @@ export const JobSchema = z.object({
   createdAt: DateSchema,
   updatedAt: DateSchema,
   concurrencyLimit: z.coerce.number(),
+  concurrencyStepLimit: z.coerce.number(),
   clientId: z.string().nullable().optional(),
+  /** Duration in milliseconds (finishedAt - startedAt). Null if job hasn't finished. */
+  durationMs: z.coerce.number().nullable().default(null),
 })
 
 // ============================================================================
@@ -85,7 +89,16 @@ export const JobStepWithoutOutputSchema = JobStepSchema.omit({ output: true })
 
 export const SortOrderSchema = z.enum(['asc', 'desc'])
 
-export const JobSortFieldSchema = z.enum(['createdAt', 'startedAt', 'finishedAt', 'status', 'actionName', 'expiresAt'])
+export const JobSortFieldSchema = z.enum([
+  'createdAt',
+  'startedAt',
+  'finishedAt',
+  'status',
+  'actionName',
+  'expiresAt',
+  'duration',
+  'description',
+])
 
 export const JobSortSchema = z.object({
   field: JobSortFieldSchema,
@@ -97,6 +110,7 @@ export const JobFiltersSchema = z.object({
   actionName: z.union([z.string(), z.array(z.string())]).optional(),
   groupKey: z.union([z.string(), z.array(z.string())]).optional(),
   clientId: z.union([z.string(), z.array(z.string())]).optional(),
+  description: z.string().optional(),
   createdAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
   startedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
   finishedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
@@ -136,6 +150,10 @@ export const CreateJobOptionsSchema = z.object({
   timeoutMs: z.number(),
   /** The concurrency limit for this job's group */
   concurrencyLimit: z.number(),
+  /** The concurrency limit for steps within this job */
+  concurrencyStepLimit: z.number(),
+  /** Optional description for the job */
+  description: z.string().nullable().optional(),
 })
 
 export const RecoverJobsOptionsSchema = z.object({
@@ -295,59 +313,94 @@ export const JobStepStatusResultSchema = z.object({
 })
 
 // ============================================================================
-// Metrics Schemas
+// Span Schemas (OpenTelemetry compatible)
 // ============================================================================
 
-export const MetricTypeSchema = z.enum(['metric', 'span_event', 'span_attribute'])
+/**
+ * SpanKind values (OpenTelemetry standard):
+ * 0 = INTERNAL - Default, internal operation
+ * 1 = SERVER - Server-side handling of RPC/HTTP request
+ * 2 = CLIENT - Client-side of RPC/HTTP request
+ * 3 = PRODUCER - Producer of async message
+ * 4 = CONSUMER - Consumer of async message
+ */
+export const SpanKindSchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4)])
+
+/**
+ * SpanStatusCode values (OpenTelemetry standard):
+ * 0 = UNSET - Status not set
+ * 1 = OK - Operation completed successfully
+ * 2 = ERROR - Operation failed
+ */
+export const SpanStatusCodeSchema = z.union([z.literal(0), z.literal(1), z.literal(2)])
+
+export const SpanEventSchema = z.object({
+  name: z.string(),
+  timeUnixNano: z.string(),
+  attributes: z.record(z.string(), z.any()).optional(),
+})
 
-export const MetricSchema = z.object({
-  id: z.string(),
-  jobId: z.string(),
+export const SpanSchema = z.object({
+  id: z.number(),
+  traceId: z.string(),
+  spanId: z.string(),
+  parentSpanId: z.string().nullable(),
+  jobId: z.string().nullable(),
   stepId: z.string().nullable(),
   name: z.string(),
-  value: z.number(),
+  kind: SpanKindSchema,
+  startTimeUnixNano: z.string().nullable(), // Stored as bigint but serialized as string for JSON
+  endTimeUnixNano: z.string().nullable(), // Stored as bigint but serialized as string for JSON
+  statusCode: SpanStatusCodeSchema,
+  statusMessage: z.string().nullable(),
   attributes: z.record(z.string(), z.any()),
-  type: MetricTypeSchema,
-  timestamp: DateSchema,
-  createdAt: DateSchema,
+  events: z.array(SpanEventSchema),
 })
 
-export const MetricSortFieldSchema = z.enum(['name', 'value', 'timestamp', 'createdAt'])
+export const SpanSortFieldSchema = z.enum(['name', 'startTimeUnixNano', 'endTimeUnixNano'])
 
-export const MetricSortSchema = z.object({
-  field: MetricSortFieldSchema,
+export const SpanSortSchema = z.object({
+  field: SpanSortFieldSchema,
   order: SortOrderSchema,
 })
 
-export const MetricFiltersSchema = z.object({
+export const SpanFiltersSchema = z.object({
   name: z.union([z.string(), z.array(z.string())]).optional(),
-  type: z.union([MetricTypeSchema, z.array(MetricTypeSchema)]).optional(),
+  kind: z.union([SpanKindSchema, z.array(SpanKindSchema)]).optional(),
+  statusCode: z.union([SpanStatusCodeSchema, z.array(SpanStatusCodeSchema)]).optional(),
+  traceId: z.string().optional(),
   attributesFilter: z.record(z.string(), z.any()).optional(),
-  timestampRange: z.array(DateSchema).length(2).optional(),
 })
 
-export const InsertMetricOptionsSchema = z.object({
-  jobId: z.string(),
-  stepId: z.string().optional(),
+export const InsertSpanOptionsSchema = z.object({
+  traceId: z.string(),
+  spanId: z.string(),
+  parentSpanId: z.string().nullable(),
+  jobId: z.string().nullable(),
+  stepId: z.string().nullable(),
   name: z.string(),
-  value: z.number(),
+  kind: SpanKindSchema,
+  startTimeUnixNano: z.bigint(),
+  endTimeUnixNano: z.bigint().nullable(),
+  statusCode: SpanStatusCodeSchema,
+  statusMessage: z.string().nullable(),
   attributes: z.record(z.string(), z.any()).optional(),
-  type: MetricTypeSchema,
+  events: z.array(SpanEventSchema).optional(),
 })
 
-export const GetMetricsOptionsSchema = z.object({
+export const GetSpansOptionsSchema = z.object({
   jobId: z.string().optional(),
   stepId: z.string().optional(),
-  filters: MetricFiltersSchema.optional(),
-  sort: MetricSortSchema.optional(),
+  filters: SpanFiltersSchema.optional(),
+  sort: SpanSortSchema.optional(),
 })
 
-export const GetMetricsResultSchema = z.object({
-  metrics: z.array(MetricSchema),
+export const GetSpansResultSchema = z.object({
+  spans: z.array(SpanSchema),
   total: z.number().int().nonnegative(),
 })
 
-export const DeleteMetricsOptionsSchema = z.object({
+export const DeleteSpansOptionsSchema = z.object({
   jobId: z.string(),
 })
 
@@ -386,12 +439,14 @@ export type DelayJobStepOptions = z.infer<typeof DelayJobStepOptionsSchema>
 export type CancelJobStepOptions = z.infer<typeof CancelJobStepOptionsSchema>
 export type CreateOrRecoverJobStepResult = z.infer<typeof CreateOrRecoverJobStepResultSchema>
 export type TimeTravelJobOptions = z.infer<typeof TimeTravelJobOptionsSchema>
-export type MetricType = z.infer<typeof MetricTypeSchema>
-export type Metric = z.infer<typeof MetricSchema>
-export type MetricSortField = z.infer<typeof MetricSortFieldSchema>
-export type MetricSort = z.infer<typeof MetricSortSchema>
-export type MetricFilters = z.infer<typeof MetricFiltersSchema>
-export type InsertMetricOptions = z.infer<typeof InsertMetricOptionsSchema>
-export type GetMetricsOptions = z.infer<typeof GetMetricsOptionsSchema>
-export type GetMetricsResult = z.infer<typeof GetMetricsResultSchema>
-export type DeleteMetricsOptions = z.infer<typeof DeleteMetricsOptionsSchema>
+export type SpanKind = z.infer<typeof SpanKindSchema>
+export type SpanStatusCode = z.infer<typeof SpanStatusCodeSchema>
+export type SpanEvent = z.infer<typeof SpanEventSchema>
+export type Span = z.infer<typeof SpanSchema>
+export type SpanSortField = z.infer<typeof SpanSortFieldSchema>
+export type SpanSort = z.infer<typeof SpanSortSchema>
+export type SpanFilters = z.infer<typeof SpanFiltersSchema>
+export type InsertSpanOptions = z.infer<typeof InsertSpanOptionsSchema>
+export type GetSpansOptions = z.infer<typeof GetSpansOptionsSchema>
+export type GetSpansResult = z.infer<typeof GetSpansResultSchema>
+export type DeleteSpansOptions = z.infer<typeof DeleteSpansOptionsSchema>