tasker-engine 0.1.0 → 1.0.2

data/lib/tasker/telemetry/metrics_backend.rb

@@ -476,8 +476,8 @@ module Tasker
         }
 
         # Override with telemetry configuration if available
-        if defined?(Tasker::Configuration.configuration) && Tasker::Configuration.configuration.telemetry
-          telemetry_config = Tasker::Configuration.configuration.telemetry
+        if defined?(Tasker.configuration) && Tasker.configuration.telemetry
+          telemetry_config = Tasker.configuration.telemetry
           base_config[:retention_window] = (telemetry_config.metrics_retention_hours || 1).hours
         end
 
@@ -1074,7 +1074,7 @@ module Tasker
       # @return [Hash] Versioned snapshot data
       def create_versioned_snapshot
         {
-          version: Tasker::Version,
+          version: Tasker::VERSION,
           timestamp: Time.current.iso8601,
           instance_id: @instance_id,
           cache_strategy: @sync_strategy,

data/lib/tasker/telemetry/metrics_export_service.rb

@@ -325,7 +325,7 @@ module Tasker
       #
       # @return [Hash] Default Prometheus configuration
       def default_prometheus_config
-        Tasker::Configuration.configuration.telemetry.prometheus
+        Tasker.configuration.telemetry.prometheus
       rescue StandardError
         {}
       end

data/lib/tasker/telemetry/prometheus_exporter.rb

@@ -212,9 +212,9 @@ module Tasker
       #
       # @return [Boolean] True if telemetry is enabled
       def telemetry_enabled?
-        return false unless defined?(Tasker::Configuration.configuration)
+        return false unless defined?(Tasker.configuration)
 
-        Tasker::Configuration.configuration.telemetry.metrics_enabled
+        Tasker.configuration.telemetry.metrics_enabled
       end
 
       # Log export error with structured logging

data/lib/tasker/types/telemetry_config.rb

@@ -41,7 +41,7 @@ module Tasker
       #
       # @!attribute [r] service_version
       #   @return [String] Service version for telemetry
-      attribute :service_version, Types::String.default('0.1.0', shared: true)
+      attribute :service_version, Types::String.default(proc { Tasker::VERSION }.freeze, shared: true)
 
       # Parameters to filter from logs and telemetry
       # Can contain symbols, strings, or regex patterns as supported by Rails

data/lib/tasker/version.rb

@@ -3,6 +3,5 @@
 # typed: false
 
 module Tasker
-  VERSION = '0.1.0'
-  Version = '0.1.0' # rubocop:disable Naming/ConstantName
+  VERSION = '1.0.2'
 end

data/lib/tasks/tasker_tasks.rake

@@ -12,9 +12,6 @@ namespace :tasker do
 
       puts 'Installing Tasker database objects...'
 
-      # Check and configure SQL schema format
-      check_and_configure_sql_schema_format
-
       # Find the Tasker gem path using multiple methods for reliability
       tasker_gem_path = find_tasker_gem_path
 
@@ -115,84 +112,6 @@ namespace :tasker do
         puts '      This may indicate an incomplete Tasker installation'
       end
     end
-
-    # Check if SQL schema format is configured and offer to fix it if needed
-    def check_and_configure_sql_schema_format
-      application_rb_path = Rails.root.join('config/application.rb')
-
-      unless File.exist?(application_rb_path)
-        puts "⚠️  Application file not found: #{application_rb_path}"
-        puts '   This is unexpected for a Rails application.'
-        return
-      end
-
-      application_content = File.read(application_rb_path)
-
-      if application_content.include?('config.active_record.schema_format = :sql')
-        puts '✅ SQL schema format already configured'
-        return
-      end
-
-      puts ''
-      puts '⚠️  IMPORTANT: SQL Schema Format Configuration Required'
-      puts ''
-      puts '   Tasker uses database functions and views that are not preserved'
-      puts "   in Rails' default schema.rb file. To ensure these database objects"
-      puts '   are properly recreated during test database drops/recreates, you'
-      puts '   need to configure Rails to use structure.sql instead.'
-      puts ''
-      puts '   This requires adding the following line to config/application.rb:'
-      puts '   config.active_record.schema_format = :sql'
-      puts ''
-      print '   Would you like me to add this configuration automatically? (y/n): '
-
-      response = $stdin.gets.chomp.downcase
-
-      if %w[y yes].include?(response)
-        if update_application_rb_schema_format(application_rb_path, application_content)
-          puts '✅ SQL schema format configured successfully!'
-          puts '   Your application will now use db/structure.sql instead of db/schema.rb'
-        else
-          puts '❌ Failed to update application.rb automatically'
-          puts '   Please manually add: config.active_record.schema_format = :sql'
-          puts '   to your config/application.rb file inside the Application class'
-        end
-      else
-        puts '⚠️  Skipping automatic configuration.'
-        puts '   WARNING: Database functions and views may not work correctly'
-        puts '   in test environments without this configuration.'
-        puts ''
-        puts '   To configure manually, add this line to config/application.rb:'
-        puts '   config.active_record.schema_format = :sql'
-      end
-      puts ''
-    end
-
-    # Update application.rb to include SQL schema format configuration
-    #
-    # @param application_rb_path [String] Path to application.rb file
-    # @param application_content [String] Current content of application.rb
-    # @return [Boolean] Success status
-    def update_application_rb_schema_format(application_rb_path, application_content)
-      if application_content.include?('class Application < Rails::Application')
-        # Add SQL schema format configuration
-        new_application_content = application_content.gsub(
-          /(class Application < Rails::Application\s*\n)/,
-          "\\1    # Configure SQL schema format to preserve database functions and views\n    config.active_record.schema_format = :sql\n\n"
-        )
-
-        begin
-          File.write(application_rb_path, new_application_content)
-          true
-        rescue StandardError => e
-          puts "   Error writing to application.rb: #{e.message}"
-          false
-        end
-      else
-        puts '   Could not find Application class in application.rb'
-        false
-      end
-    end
   end
 
   # @!method setup
@@ -221,9 +140,9 @@ namespace :tasker do
     end
 
     # Create necessary directories based on configuration
-    task_handler_dir = Rails.root.join('app', Tasker::Configuration.configuration.engine.task_handler_directory)
-    task_config_dir = Rails.root.join('config', Tasker::Configuration.configuration.engine.task_config_directory)
-    task_spec_dir = Rails.root.join('spec', Tasker::Configuration.configuration.engine.task_handler_directory)
+    task_handler_dir = Rails.root.join('app', Tasker.configuration.engine.task_handler_directory)
+    task_config_dir = Rails.root.join('config', Tasker.configuration.engine.task_config_directory)
+    task_spec_dir = Rails.root.join('spec', Tasker.configuration.engine.task_handler_directory)
 
     [task_handler_dir, task_config_dir, task_spec_dir].each do |dir|
       unless File.directory?(dir)
@@ -359,7 +278,7 @@ namespace :tasker do
       end
 
       # Configuration
-      config = Tasker::Configuration.configuration.telemetry
+      config = Tasker.configuration.telemetry
       puts "\nTelemetry Configuration:"
       puts "  Enabled: #{config.enabled}"
       puts "  Metrics Enabled: #{config.metrics_enabled}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tasker-engine
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Pete Taylor
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-13 00:00:00.000000000 Z
+date: 2025-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: 7.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: 7.2.2
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -417,14 +417,12 @@ files:
 - db/functions/get_slowest_steps_v01.sql
 - db/functions/get_slowest_tasks_v01.sql
 - db/functions/get_step_readiness_status_batch_v01.sql
-- db/functions/get_step_readiness_status_single_and_batch_v02.sql
 - db/functions/get_step_readiness_status_v01.sql
 - db/functions/get_system_health_counts_v01.sql
 - db/functions/get_task_execution_context_v01.sql
 - db/functions/get_task_execution_contexts_batch_v01.sql
 - db/init/schema.sql
 - db/migrate/20250701165431_initial_tasker_schema.rb
-- db/migrate/20250710110830_step_readiness_sql_functions_v02.rb
 - db/views/tasker_step_dag_relationships_v01.sql
 - docs/APPLICATION_GENERATOR.md
 - docs/AUTH.md
@@ -440,7 +438,6 @@ files:
 - docs/QUICK_START.md
 - docs/REGISTRY_SYSTEMS.md
 - docs/REST_API.md
-- docs/REVERSIONING.md
 - docs/ROADMAP.md
 - docs/SQL_FUNCTIONS.md
 - docs/TASK_EXECUTION_CONTROL_FLOW.md

data/db/functions/get_step_readiness_status_single_and_batch_v02.sql

@@ -1,223 +0,0 @@
--- Fix step readiness logic for NULL attempts
--- When attempts is NULL, it should be treated as 0 for comparison purposes
-
--- Update get_step_readiness_status function
-CREATE OR REPLACE FUNCTION get_step_readiness_status(input_task_id bigint, step_ids bigint[] DEFAULT NULL::bigint[]) RETURNS TABLE(workflow_step_id bigint, task_id bigint, named_step_id integer, name text, current_state text, dependencies_satisfied boolean, retry_eligible boolean, ready_for_execution boolean, last_failure_at timestamp without time zone, next_retry_at timestamp without time zone, total_parents integer, completed_parents integer, attempts integer, retry_limit integer, backoff_request_seconds integer, last_attempted_at timestamp without time zone)
-    LANGUAGE plpgsql STABLE
-    AS $$
-BEGIN
-  RETURN QUERY
-  SELECT
-    ws.workflow_step_id,
-    ws.task_id,
-    ws.named_step_id,
-    ns.name::TEXT,
-
-    -- Current State Information (optimized using most_recent flag)
-    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
-
-    -- Dependency Satisfaction Analysis
-    CASE
-      WHEN dep_edges.to_step_id IS NULL OR
-           COUNT(dep_edges.from_step_id) = 0 THEN true
-      ELSE
-        COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id)
-    END as dependencies_satisfied,
-
-    -- Retry Eligibility
-    CASE
-      WHEN COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3) THEN true
-      ELSE false
-    END as retry_eligible,
-
-    -- Overall Ready for Execution (complex business logic)
-    CASE
-      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
-      AND (ws.processed = false OR ws.processed IS NULL)  -- CRITICAL: Only unprocessed steps can be ready
-      AND (dep_edges.to_step_id IS NULL OR
-           COUNT(dep_edges.from_step_id) = 0 OR
-           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
-      AND (COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3))  -- FIXED: Handle NULL attempts
-      AND (COALESCE(ws.retryable, true) = true)
-      AND (ws.in_process = false OR ws.in_process IS NULL)
-      AND (
-        -- Check explicit backoff timing (most restrictive)
-        -- If backoff is set, the backoff period must have expired
-        CASE
-          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
-            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
-          ELSE true  -- No explicit backoff set
-        END
-        AND
-        -- Then check failure-based backoff
-        (last_failure.created_at IS NULL OR
-         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
-      )
-      THEN true
-      ELSE false
-    END as ready_for_execution,
-
-    -- Timing Information
-    last_failure.created_at as last_failure_at,
-    CASE
-      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
-        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
-      WHEN last_failure.created_at IS NOT NULL THEN
-        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
-      ELSE NULL
-    END as next_retry_at,
-
-    -- Dependency Context (calculated from joins)
-    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
-    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
-
-    -- Retry Context
-    COALESCE(ws.attempts, 0)::INTEGER as attempts,  -- FIXED: Return 0 instead of NULL
-    COALESCE(ws.retry_limit, 3) as retry_limit,
-    ws.backoff_request_seconds,
-    ws.last_attempted_at
-
-  FROM tasker_workflow_steps ws
-  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
-
-  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
-  LEFT JOIN tasker_workflow_step_transitions current_state
-    ON current_state.workflow_step_id = ws.workflow_step_id
-    AND current_state.most_recent = true
-
-  -- OPTIMIZED: Dependency check using direct joins (no subquery)
-  LEFT JOIN tasker_workflow_step_edges dep_edges
-    ON dep_edges.to_step_id = ws.workflow_step_id
-  LEFT JOIN tasker_workflow_step_transitions parent_states
-    ON parent_states.workflow_step_id = dep_edges.from_step_id
-    AND parent_states.most_recent = true
-
-  -- OPTIMIZED: Last failure using index-optimized approach
-  LEFT JOIN tasker_workflow_step_transitions last_failure
-    ON last_failure.workflow_step_id = ws.workflow_step_id
-    AND last_failure.to_state = 'error'
-    AND last_failure.most_recent = true
-
-  -- KEY PERFORMANCE IMPROVEMENT: Filter by task first, then optionally by step IDs
-  -- CRITICAL FIX: Include ALL steps for task execution context calculation
-  -- Only filter by processed status when specifically querying for ready steps
-  WHERE ws.task_id = input_task_id
-    AND (step_ids IS NULL OR ws.workflow_step_id = ANY(step_ids))
-
-  GROUP BY
-    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
-    current_state.to_state, last_failure.created_at,
-    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
-    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id,
-    current_state.workflow_step_id, last_failure.workflow_step_id;
-END;
-$$;
-
--- Also update the batch version
-CREATE OR REPLACE FUNCTION get_step_readiness_status_batch(input_task_ids bigint[]) RETURNS TABLE(workflow_step_id bigint, task_id bigint, named_step_id integer, name text, current_state text, dependencies_satisfied boolean, retry_eligible boolean, ready_for_execution boolean, last_failure_at timestamp without time zone, next_retry_at timestamp without time zone, total_parents integer, completed_parents integer, attempts integer, retry_limit integer, backoff_request_seconds integer, last_attempted_at timestamp without time zone)
-    LANGUAGE plpgsql STABLE
-    AS $$
-BEGIN
-  RETURN QUERY
-  SELECT
-    ws.workflow_step_id,
-    ws.task_id,
-    ws.named_step_id,
-    ns.name::TEXT,
-
-    -- Current State Information (optimized using most_recent flag)
-    COALESCE(current_state.to_state, 'pending')::TEXT as current_state,
-
-    -- Dependency Satisfaction Analysis
-    CASE
-      WHEN dep_edges.to_step_id IS NULL OR
-           COUNT(dep_edges.from_step_id) = 0 THEN true
-      ELSE
-        COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id)
-    END as dependencies_satisfied,
-
-    -- Retry Eligibility
-    CASE
-      WHEN COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3) THEN true
-      ELSE false
-    END as retry_eligible,
-
-    -- Overall Ready for Execution (complex business logic)
-    CASE
-      WHEN COALESCE(current_state.to_state, 'pending') IN ('pending', 'error')
-      AND (ws.processed = false OR ws.processed IS NULL)
-      AND (dep_edges.to_step_id IS NULL OR
-           COUNT(dep_edges.from_step_id) = 0 OR
-           COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END) = COUNT(dep_edges.from_step_id))
-      AND (COALESCE(ws.attempts, 0) < COALESCE(ws.retry_limit, 3))  -- FIXED: Handle NULL attempts
-      AND (COALESCE(ws.retryable, true) = true)
-      AND (ws.in_process = false OR ws.in_process IS NULL)
-      AND (
-        -- Check explicit backoff timing (most restrictive)
-        -- If backoff is set, the backoff period must have expired
-        CASE
-          WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
-            ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second') <= NOW()
-          ELSE true  -- No explicit backoff set
-        END
-        AND
-        -- Then check failure-based backoff
-        (last_failure.created_at IS NULL OR
-         last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds')) <= NOW())
-      )
-      THEN true
-      ELSE false
-    END as ready_for_execution,
-
-    -- Timing Information
-    last_failure.created_at as last_failure_at,
-    CASE
-      WHEN ws.backoff_request_seconds IS NOT NULL AND ws.last_attempted_at IS NOT NULL THEN
-        ws.last_attempted_at + (ws.backoff_request_seconds * interval '1 second')
-      WHEN last_failure.created_at IS NOT NULL THEN
-        last_failure.created_at + (LEAST(power(2, COALESCE(ws.attempts, 1)) * interval '1 second', interval '30 seconds'))
-      ELSE NULL
-    END as next_retry_at,
-
-    -- Dependency Context (calculated from joins)
-    COALESCE(COUNT(dep_edges.from_step_id), 0)::INTEGER as total_parents,
-    COALESCE(COUNT(CASE WHEN parent_states.to_state IN ('complete', 'resolved_manually') THEN 1 END), 0)::INTEGER as completed_parents,
-
-    -- Retry Context
-    COALESCE(ws.attempts, 0)::INTEGER as attempts,  -- FIXED: Return 0 instead of NULL
-    COALESCE(ws.retry_limit, 3) as retry_limit,
-    ws.backoff_request_seconds,
-    ws.last_attempted_at
-
-  FROM tasker_workflow_steps ws
-  JOIN tasker_named_steps ns ON ns.named_step_id = ws.named_step_id
-
-  -- OPTIMIZED: Current State using most_recent flag instead of DISTINCT ON
-  LEFT JOIN tasker_workflow_step_transitions current_state
-    ON current_state.workflow_step_id = ws.workflow_step_id
-    AND current_state.most_recent = true
-
-  -- OPTIMIZED: Dependency check using direct joins (no subquery)
-  LEFT JOIN tasker_workflow_step_edges dep_edges
-    ON dep_edges.to_step_id = ws.workflow_step_id
-  LEFT JOIN tasker_workflow_step_transitions parent_states
-    ON parent_states.workflow_step_id = dep_edges.from_step_id
-    AND parent_states.most_recent = true
-
-  -- OPTIMIZED: Last failure using index-optimized approach
-  LEFT JOIN tasker_workflow_step_transitions last_failure
-    ON last_failure.workflow_step_id = ws.workflow_step_id
-    AND last_failure.to_state = 'error'
-    AND last_failure.most_recent = true
-
-  -- KEY PERFORMANCE IMPROVEMENT: Filter by task first, then optionally by step IDs
-  WHERE ws.task_id = ANY(input_task_ids)
-
-  GROUP BY
-    ws.workflow_step_id, ws.task_id, ws.named_step_id, ns.name,
-    current_state.to_state, last_failure.created_at,
-    ws.attempts, ws.retry_limit, ws.backoff_request_seconds, ws.last_attempted_at,
-    ws.in_process, ws.processed, ws.retryable, dep_edges.to_step_id,
-    current_state.workflow_step_id, last_failure.workflow_step_id;
-END;
-$$;

data/db/migrate/20250710110830_step_readiness_sql_functions_v02.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-class StepReadinessSqlFunctionsV02 < ActiveRecord::Migration[7.2]
-  def up
-    if defined?(Tasker::Engine)
-      # When running in engine context, look in the engine root
-      engine_root = Tasker::Engine.root
-      sql_file = engine_root.join('db', 'functions', 'get_step_readiness_status_single_and_batch_v02.sql')
-    else
-      # When running standalone, use Rails.root
-      sql_file = Rails.root.join('db/functions/get_step_readiness_status_single_and_batch_v02.sql')
-    end
-
-    unless File.exist?(sql_file)
-      raise "SQL file not found at #{sql_file}. Please ensure db/functions/get_step_readiness_status_single_and_batch_v02.sql exists."
-    end
-
-    execute(File.read(sql_file))
-  end
-
-  def down
-    path_root = if defined?(Tasker::Engine)
-                  # When running in engine context, look in the engine root
-                  Tasker::Engine.root
-                else
-                  # When running standalone, use Rails.root
-                  Rails.root
-                end
-    original_sql_files = [
-      'get_step_readiness_status_v01.sql',
-      'get_step_readiness_status_batch_v01.sql'
-    ]
-
-    original_sql_files.each do |file|
-      sql_file = File.read(path_root.join('db', 'functions', file))
-      execute(sql_file)
-    end
-  end
-end