tasker-engine 0.1.0

data/db/functions/get_system_health_counts_v01.sql

@@ -0,0 +1,108 @@
+-- System Health Counts Function
+-- Returns comprehensive system health metrics in a single query
+-- No input parameters needed - returns system-wide counts
+-- Output: Single row with all health counts and metrics
+
+CREATE OR REPLACE FUNCTION get_system_health_counts_v01()
+RETURNS TABLE (
+    -- Task counts
+    total_tasks BIGINT,
+    pending_tasks BIGINT,
+    in_progress_tasks BIGINT,
+    complete_tasks BIGINT,
+    error_tasks BIGINT,
+    cancelled_tasks BIGINT,
+
+    -- Step counts
+    total_steps BIGINT,
+    pending_steps BIGINT,
+    in_progress_steps BIGINT,
+    complete_steps BIGINT,
+    error_steps BIGINT,
+
+    -- Retry-specific counts
+    retryable_error_steps BIGINT,
+    exhausted_retry_steps BIGINT,
+    in_backoff_steps BIGINT,
+
+    -- Database metrics
+    active_connections BIGINT,
+    max_connections BIGINT
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+    RETURN QUERY
+    WITH task_counts AS (
+        SELECT
+            COUNT(*) as total_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'pending') as pending_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'in_progress') as in_progress_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'complete') as complete_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'error') as error_tasks,
+            COUNT(*) FILTER (WHERE task_state.to_state = 'cancelled') as cancelled_tasks
+        FROM tasker_tasks t
+        LEFT JOIN tasker_task_transitions task_state ON task_state.task_id = t.task_id
+            AND task_state.most_recent = true
+    ),
+    step_counts AS (
+        SELECT
+            COUNT(*) as total_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'pending') as pending_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'in_progress') as in_progress_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'complete') as complete_steps,
+            COUNT(*) FILTER (WHERE step_state.to_state = 'error') as error_steps,
+
+            -- Retry-specific logic - retryable errors
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts < ws.retry_limit
+                AND COALESCE(ws.retryable, true) = true
+            ) as retryable_error_steps,
+
+            -- Exhausted retries
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts >= ws.retry_limit
+            ) as exhausted_retry_steps,
+
+            -- In backoff (error state but not exhausted retries and has last_attempted_at)
+            COUNT(*) FILTER (
+                WHERE step_state.to_state = 'error'
+                AND ws.attempts < ws.retry_limit
+                AND COALESCE(ws.retryable, true) = true
+                AND ws.last_attempted_at IS NOT NULL
+            ) as in_backoff_steps
+
+        FROM tasker_workflow_steps ws
+        LEFT JOIN tasker_workflow_step_transitions step_state ON step_state.workflow_step_id = ws.workflow_step_id
+            AND step_state.most_recent = true
+    ),
+    connection_info AS (
+        SELECT
+            COUNT(*) as active_connections,
+            COALESCE((SELECT setting::BIGINT FROM pg_settings WHERE name = 'max_connections'), 0) as max_connections
+        FROM pg_stat_activity
+        WHERE datname = current_database()
+            AND state = 'active'
+    )
+    SELECT
+        tc.total_tasks,
+        tc.pending_tasks,
+        tc.in_progress_tasks,
+        tc.complete_tasks,
+        tc.error_tasks,
+        tc.cancelled_tasks,
+        sc.total_steps,
+        sc.pending_steps,
+        sc.in_progress_steps,
+        sc.complete_steps,
+        sc.error_steps,
+        sc.retryable_error_steps,
+        sc.exhausted_retry_steps,
+        sc.in_backoff_steps,
+        ci.active_connections,
+        ci.max_connections
+    FROM task_counts tc
+    CROSS JOIN step_counts sc
+    CROSS JOIN connection_info ci;
+END;
+$$;

data/db/functions/get_task_execution_context_v01.sql

@@ -0,0 +1,108 @@
+-- Task Execution Context Function
+-- Uses the step readiness function to build aggregated task context
+-- Input: Single task_id
+-- Output: Single row with task execution context
+
+CREATE OR REPLACE FUNCTION get_task_execution_context(input_task_id BIGINT)
+RETURNS TABLE(
+  task_id BIGINT,
+  named_task_id INTEGER,
+  status TEXT,
+  total_steps BIGINT,
+  pending_steps BIGINT,
+  in_progress_steps BIGINT,
+  completed_steps BIGINT,
+  failed_steps BIGINT,
+  ready_steps BIGINT,
+  execution_status TEXT,
+  recommended_action TEXT,
+  completion_percentage DECIMAL,
+  health_status TEXT
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+  -- Use the step readiness function to get step data, then aggregate
+  -- The step readiness function handles the case where no steps exist
+  RETURN QUERY
+  WITH step_data AS (
+    SELECT * FROM get_step_readiness_status(input_task_id, NULL)
+  ),
+  task_info AS (
+    SELECT
+      t.task_id,
+      t.named_task_id,
+      COALESCE(task_state.to_state, 'pending')::TEXT as current_status
+    FROM tasker_tasks t
+    LEFT JOIN tasker_task_transitions task_state
+      ON task_state.task_id = t.task_id
+      AND task_state.most_recent = true
+    WHERE t.task_id = input_task_id
+  ),
+  aggregated_stats AS (
+    SELECT
+      COUNT(*) as total_steps,
+      COUNT(CASE WHEN sd.current_state = 'pending' THEN 1 END) as pending_steps,
+      COUNT(CASE WHEN sd.current_state = 'in_progress' THEN 1 END) as in_progress_steps,
+      COUNT(CASE WHEN sd.current_state IN ('complete', 'resolved_manually') THEN 1 END) as completed_steps,
+      COUNT(CASE WHEN sd.current_state = 'error' THEN 1 END) as failed_steps,
+      COUNT(CASE WHEN sd.ready_for_execution = true THEN 1 END) as ready_steps,
+      -- Count PERMANENTLY blocked failures (exhausted retries OR explicitly marked as not retryable)
+      COUNT(CASE WHEN sd.current_state = 'error'
+                  AND (sd.attempts >= sd.retry_limit) THEN 1 END) as permanently_blocked_steps
+    FROM step_data sd
+  )
+  SELECT
+    ti.task_id,
+    ti.named_task_id,
+    ti.current_status as status,
+
+    -- Step Statistics
+    COALESCE(ast.total_steps, 0) as total_steps,
+    COALESCE(ast.pending_steps, 0) as pending_steps,
+    COALESCE(ast.in_progress_steps, 0) as in_progress_steps,
+    COALESCE(ast.completed_steps, 0) as completed_steps,
+    COALESCE(ast.failed_steps, 0) as failed_steps,
+    COALESCE(ast.ready_steps, 0) as ready_steps,
+
+    -- FIXED: Execution State Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'has_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'processing'
+      -- OLD BUG: WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked_by_failures'
+      -- NEW FIX: Only blocked if failed steps are NOT retry-eligible
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked_by_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'all_complete'
+      ELSE 'waiting_for_dependencies'
+    END as execution_status,
+
+    -- FIXED: Recommended Action Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'execute_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'wait_for_completion'
+      -- OLD BUG: WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'handle_failures'
+      -- NEW FIX: Only handle failures if they're truly blocked
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'handle_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'finalize_task'
+      ELSE 'wait_for_dependencies'
+    END as recommended_action,
+
+    -- Progress Metrics
+    CASE
+      WHEN COALESCE(ast.total_steps, 0) = 0 THEN 0.0
+      ELSE ROUND((COALESCE(ast.completed_steps, 0)::decimal / COALESCE(ast.total_steps, 1)::decimal) * 100, 2)
+    END as completion_percentage,
+
+    -- FIXED: Health Status Logic
+    CASE
+      WHEN COALESCE(ast.failed_steps, 0) = 0 THEN 'healthy'
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) > 0 THEN 'recovering'
+      -- NEW FIX: Only blocked if failures are truly not retry-eligible
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked'
+      -- NEW: Waiting state for retry-eligible failures with backoff
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.permanently_blocked_steps, 0) = 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'recovering'
+      ELSE 'unknown'
+    END as health_status
+
+  FROM task_info ti
+  CROSS JOIN aggregated_stats ast;
+END;
+$$;

data/db/functions/get_task_execution_contexts_batch_v01.sql

@@ -0,0 +1,104 @@
+-- Batch Task Execution Context Function
+-- Gets execution context for multiple tasks in a single query
+-- Input: Array of task_ids
+-- Output: Multiple rows with task execution context data
+
+CREATE OR REPLACE FUNCTION get_task_execution_contexts_batch(input_task_ids BIGINT[])
+RETURNS TABLE(
+  task_id BIGINT,
+  named_task_id INTEGER,
+  status TEXT,
+  total_steps BIGINT,
+  pending_steps BIGINT,
+  in_progress_steps BIGINT,
+  completed_steps BIGINT,
+  failed_steps BIGINT,
+  ready_steps BIGINT,
+  execution_status TEXT,
+  recommended_action TEXT,
+  completion_percentage DECIMAL,
+  health_status TEXT
+) LANGUAGE plpgsql STABLE AS $$
+BEGIN
+  RETURN QUERY
+  WITH step_data AS (
+    -- Get step readiness data for all tasks at once using batch function
+    SELECT * FROM get_step_readiness_status_batch(input_task_ids)
+  ),
+  task_info AS (
+    SELECT
+      t.task_id,
+      t.named_task_id,
+      COALESCE(task_state.to_state, 'pending')::TEXT as current_status
+    FROM unnest(input_task_ids) AS task_list(task_id)
+    JOIN tasker_tasks t ON t.task_id = task_list.task_id
+    LEFT JOIN tasker_task_transitions task_state
+      ON task_state.task_id = t.task_id
+      AND task_state.most_recent = true
+  ),
+  aggregated_stats AS (
+    SELECT
+      sd.task_id,
+      COUNT(*) as total_steps,
+      COUNT(CASE WHEN sd.current_state = 'pending' THEN 1 END) as pending_steps,
+      COUNT(CASE WHEN sd.current_state = 'in_progress' THEN 1 END) as in_progress_steps,
+      COUNT(CASE WHEN sd.current_state IN ('complete', 'resolved_manually') THEN 1 END) as completed_steps,
+      COUNT(CASE WHEN sd.current_state = 'error' THEN 1 END) as failed_steps,
+      COUNT(CASE WHEN sd.ready_for_execution = true THEN 1 END) as ready_steps,
+      -- Count PERMANENTLY blocked failures (exhausted retries)
+      COUNT(CASE WHEN sd.current_state = 'error'
+                  AND (sd.attempts >= sd.retry_limit) THEN 1 END) as permanently_blocked_steps
+    FROM step_data sd
+    GROUP BY sd.task_id
+  )
+  SELECT
+    ti.task_id,
+    ti.named_task_id,
+    ti.current_status as status,
+
+    -- Step Statistics
+    COALESCE(ast.total_steps, 0) as total_steps,
+    COALESCE(ast.pending_steps, 0) as pending_steps,
+    COALESCE(ast.in_progress_steps, 0) as in_progress_steps,
+    COALESCE(ast.completed_steps, 0) as completed_steps,
+    COALESCE(ast.failed_steps, 0) as failed_steps,
+    COALESCE(ast.ready_steps, 0) as ready_steps,
+
+    -- Execution State Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'has_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'processing'
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked_by_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'all_complete'
+      ELSE 'waiting_for_dependencies'
+    END as execution_status,
+
+    -- Recommended Action Logic
+    CASE
+      WHEN COALESCE(ast.ready_steps, 0) > 0 THEN 'execute_ready_steps'
+      WHEN COALESCE(ast.in_progress_steps, 0) > 0 THEN 'wait_for_completion'
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'handle_failures'
+      WHEN COALESCE(ast.completed_steps, 0) = COALESCE(ast.total_steps, 0) AND COALESCE(ast.total_steps, 0) > 0 THEN 'finalize_task'
+      ELSE 'wait_for_dependencies'
+    END as recommended_action,
+
+    -- Progress Metrics
+    CASE
+      WHEN COALESCE(ast.total_steps, 0) = 0 THEN 0.0
+      ELSE ROUND((COALESCE(ast.completed_steps, 0)::decimal / COALESCE(ast.total_steps, 1)::decimal) * 100, 2)
+    END as completion_percentage,
+
+    -- Health Status Logic
+    CASE
+      WHEN COALESCE(ast.failed_steps, 0) = 0 THEN 'healthy'
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) > 0 THEN 'recovering'
+      WHEN COALESCE(ast.permanently_blocked_steps, 0) > 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'blocked'
+      WHEN COALESCE(ast.failed_steps, 0) > 0 AND COALESCE(ast.permanently_blocked_steps, 0) = 0 AND COALESCE(ast.ready_steps, 0) = 0 THEN 'recovering'
+      ELSE 'unknown'
+    END as health_status
+
+  FROM task_info ti
+  LEFT JOIN aggregated_stats ast ON ast.task_id = ti.task_id
+  ORDER BY ti.task_id;
+END;
+$$;