tasker-engine 1.0.0

data/lib/tasker/events/subscription_loader.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Tasker
+  module Events
+    # SubscriptionLoader loads event subscriptions from YAML configuration files
+    #
+    # This class enables developers to configure event subscriptions declaratively
+    # using YAML files in config/tasker/subscriptions/
+    #
+    # Example YAML structure:
+    #   subscriptions:
+    #     sentry_integration:
+    #       class: 'SentrySubscriber'
+    #       events:
+    #         - 'task.failed'
+    #         - 'step.failed'
+    #       config:
+    #         dsn: 'https://...'
+    #         environment: 'production'
+    #
+    class SubscriptionLoader
+      class << self
+        # Load all subscription configurations from YAML files
+        #
+        # @return [Hash] Loaded subscription configurations
+        def load_all
+          @load_all ||= load_subscription_files
+        end
+
+        # Load and instantiate all configured subscribers
+        #
+        # @return [Array<BaseSubscriber>] Array of instantiated subscribers
+        def load_subscribers
+          subscribers = []
+
+          load_all.each do |name, config|
+            subscriber = instantiate_subscriber(name, config)
+            subscribers << subscriber if subscriber
+          rescue StandardError => e
+            Rails.logger.warn "Failed to load subscriber #{name}: #{e.message}"
+          end
+
+          subscribers
+        end
+
+        # Register all loaded subscribers with the event system
+        #
+        # @return [void]
+        def register_all_subscribers
+          load_subscribers.each do |subscriber|
+            Rails.logger.info "Registering subscriber: #{subscriber.class.name}"
+            # Subscribers auto-register themselves when instantiated
+          end
+        end
+
+        # Reload subscription configurations (useful for development)
+        #
+        # @return [Hash] Reloaded subscription configurations
+        def reload!
+          @loaded_subscriptions = nil
+          load_all
+        end
+
+        private
+
+        # Load subscription configurations from all YAML files
+        #
+        # @return [Hash] Combined subscription configurations
+        def load_subscription_files
+          subscriptions = {}
+
+          subscription_files.each do |file_path|
+            file_subscriptions = load_subscription_file(file_path)
+            subscriptions.merge!(file_subscriptions)
+          rescue StandardError => e
+            Rails.logger.warn "Failed to load subscription file #{file_path}: #{e.message}"
+          end
+
+          subscriptions
+        end
+
+        # Load subscription configuration from a single YAML file
+        #
+        # @param file_path [String] Path to the YAML file
+        # @return [Hash] Subscription configurations from the file
+        def load_subscription_file(file_path)
+          yaml_data = YAML.load_file(file_path)
+          subscriptions_data = yaml_data['subscriptions'] || {}
+
+          # Validate and normalize subscription configurations
+          normalized = {}
+          subscriptions_data.each do |name, config|
+            normalized[name] = normalize_subscription_config(name, config)
+          end
+
+          normalized
+        end
+
+        # Normalize and validate a subscription configuration
+        #
+        # @param name [String] Subscription name
+        # @param config [Hash] Raw subscription configuration
+        # @return [Hash] Normalized subscription configuration
+        def normalize_subscription_config(name, config)
+          {
+            name: name,
+            class: config['class'] || config[:class],
+            events: Array(config['events'] || config[:events]),
+            config: config['config'] || config[:config] || {},
+            enabled: config.fetch('enabled', config.fetch(:enabled, true))
+          }
+        end
+
+        # Instantiate a subscriber from configuration
+        #
+        # @param name [String] Subscription name
+        # @param config [Hash] Subscription configuration
+        # @return [BaseSubscriber, nil] Instantiated subscriber or nil if disabled/failed
+        def instantiate_subscriber(_name, config)
+          return nil unless config[:enabled]
+
+          subscriber_class = resolve_subscriber_class(config[:class])
+          return nil unless subscriber_class
+
+          # Pass configuration to subscriber constructor
+          subscriber_class.new(
+            name: config[:name],
+            events: config[:events],
+            config: config[:config]
+          )
+        end
+
+        # Resolve subscriber class from string name
+        #
+        # @param class_name [String] Class name to resolve
+        # @return [Class, nil] Resolved class or nil if not found
+        def resolve_subscriber_class(class_name)
+          return nil unless class_name
+
+          # Try to constantize the class name
+          class_name.constantize
+        rescue NameError => e
+          Rails.logger.warn "Subscriber class not found: #{class_name} (#{e.message})"
+          nil
+        end
+
+        # Get all subscription YAML files
+        #
+        # @return [Array<String>] Array of file paths
+        def subscription_files
+          subscription_dir = Rails.root.join('config/tasker/subscriptions')
+          return [] unless subscription_dir.exist?
+
+          Dir.glob(subscription_dir.join('*.yml'))
+        end
+      end
+    end
+  end
+end

data/lib/tasker/events.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'events/catalog'
+require_relative 'events/publisher'
+require_relative 'events/subscribers/base_subscriber'
+
+module Tasker
+  module Events
+    # Delegate catalog methods to the Catalog class for clean developer API
+    class << self
+      delegate :catalog, :event_info, :task_events, :step_events, :workflow_events,
+               :observability_events, :custom_events, :complete_catalog,
+               :search_events, :events_by_namespace, :print_catalog, to: :catalog_instance
+
+      # Register a custom event
+      #
+      # @param name [String] Event name (must contain namespace, e.g., 'order.fulfilled')
+      # @param description [String] Human-readable description
+      # @param fired_by [Array<String>] Components that fire this event
+      # @return [void]
+      # @raise [ArgumentError] If event name is invalid or conflicts with system events
+      def register_custom_event(name, description: 'Custom event', fired_by: [])
+        Tasker::Events::CustomRegistry.instance.register_event(
+          name,
+          description: description,
+          fired_by: fired_by
+        )
+      end
+
+      private
+
+      def catalog_instance
+        @catalog_instance ||= Catalog
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_analytics_metrics.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Wrapper for the get_analytics_metrics_v01 SQL function
+    #
+    # This function provides comprehensive analytics metrics for performance monitoring,
+    # including system overview, performance metrics, and duration calculations.
+    #
+    # @example Basic usage
+    #   metrics = Tasker::Functions::FunctionBasedAnalyticsMetrics.call
+    #   puts metrics.system_health_score
+    #   puts metrics.completion_rate
+    #
+    # @example Time-bounded analysis
+    #   since_time = 4.hours.ago
+    #   metrics = Tasker::Functions::FunctionBasedAnalyticsMetrics.call(since_time)
+    #   puts metrics.task_throughput
+    #
+    class FunctionBasedAnalyticsMetrics < FunctionWrapper
+      # Analytics metrics result structure
+      class AnalyticsMetrics < Dry::Struct
+        # System overview metrics
+        attribute :active_tasks_count, Types::Integer
+        attribute :total_namespaces_count, Types::Integer
+        attribute :unique_task_types_count, Types::Integer
+        attribute :system_health_score, Types::Float
+
+        # Performance metrics since timestamp
+        attribute :task_throughput, Types::Integer
+        attribute :completion_count, Types::Integer
+        attribute :error_count, Types::Integer
+        attribute :completion_rate, Types::Float
+        attribute :error_rate, Types::Float
+
+        # Duration metrics (in seconds)
+        attribute :avg_task_duration, Types::Float
+        attribute :avg_step_duration, Types::Float
+        attribute :step_throughput, Types::Integer
+
+        # Metadata
+        attribute :analysis_period_start, Types::String
+        attribute :calculated_at, Types::String
+      end
+
+      # Call the get_analytics_metrics_v01 SQL function
+      #
+      # @param since_timestamp [Time, nil] Start time for analysis (defaults to 1 hour ago in SQL)
+      # @return [AnalyticsMetrics] Comprehensive analytics metrics
+      # @raise [ActiveRecord::StatementInvalid] If the SQL function fails
+      def self.call(since_timestamp = nil)
+        if since_timestamp
+          sql = 'SELECT * FROM get_analytics_metrics_v01($1)'
+          result = connection.select_all(sql, 'AnalyticsMetrics Load', [since_timestamp])
+        else
+          sql = 'SELECT * FROM get_analytics_metrics_v01()'
+          result = connection.select_all(sql, 'AnalyticsMetrics Load')
+        end
+
+        if result.empty?
+          # Return zero values if no data (shouldn't happen but defensive)
+          AnalyticsMetrics.new(
+            active_tasks_count: 0,
+            total_namespaces_count: 0,
+            unique_task_types_count: 0,
+            system_health_score: 1.0,
+            task_throughput: 0,
+            completion_count: 0,
+            error_count: 0,
+            completion_rate: 0.0,
+            error_rate: 0.0,
+            avg_task_duration: 0.0,
+            avg_step_duration: 0.0,
+            step_throughput: 0,
+            analysis_period_start: (since_timestamp || 1.hour.ago).to_s,
+            calculated_at: Time.current.to_s
+          )
+        else
+          # Convert the result to a structured AnalyticsMetrics object
+          row = result.first
+          AnalyticsMetrics.new(
+            active_tasks_count: row['active_tasks_count'].to_i,
+            total_namespaces_count: row['total_namespaces_count'].to_i,
+            unique_task_types_count: row['unique_task_types_count'].to_i,
+            system_health_score: row['system_health_score'].to_f,
+            task_throughput: row['task_throughput'].to_i,
+            completion_count: row['completion_count'].to_i,
+            error_count: row['error_count'].to_i,
+            completion_rate: row['completion_rate'].to_f,
+            error_rate: row['error_rate'].to_f,
+            avg_task_duration: row['avg_task_duration'].to_f,
+            avg_step_duration: row['avg_step_duration'].to_f,
+            step_throughput: row['step_throughput'].to_i,
+            analysis_period_start: row['analysis_period_start'].to_s,
+            calculated_at: row['calculated_at'].to_s
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_dependency_levels.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Function-based implementation of dependency level calculation
+    # Uses SQL function for performance-optimized dependency level calculation
+    class FunctionBasedDependencyLevels < FunctionWrapper
+      # Define attributes to match the SQL function output
+      attribute :workflow_step_id, :integer
+      attribute :dependency_level, :integer
+
+      # Class methods that use SQL functions
+      def self.for_task(task_id)
+        sql = 'SELECT * FROM calculate_dependency_levels($1::BIGINT)'
+        binds = [task_id]
+        from_sql_function(sql, binds, 'DependencyLevels Load')
+      end
+
+      def self.levels_hash_for_task(task_id)
+        for_task(task_id).each_with_object({}) do |level_data, hash|
+          hash[level_data.workflow_step_id] = level_data.dependency_level
+        end
+      end
+
+      def self.max_level_for_task(task_id)
+        for_task(task_id).map(&:dependency_level).max || 0
+      end
+
+      def self.steps_at_level(task_id, level)
+        for_task(task_id).select { |data| data.dependency_level == level }
+                         .map(&:workflow_step_id)
+      end
+
+      def self.root_steps_for_task(task_id)
+        steps_at_level(task_id, 0)
+      end
+
+      # Instance methods
+      def to_h
+        {
+          workflow_step_id: workflow_step_id,
+          dependency_level: dependency_level
+        }
+      end
+
+      # Associations (lazy-loaded)
+      def workflow_step
+        @workflow_step ||= Tasker::WorkflowStep.find(workflow_step_id)
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_slowest_steps.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Wrapper for the get_slowest_steps_v01 SQL function
+    #
+    # This function returns the slowest workflow steps within a specified time period
+    # with duration metrics and optional filtering by namespace, task name, and version.
+    #
+    # @example Basic usage
+    #   slowest_steps = Tasker::Functions::FunctionBasedSlowestSteps.call
+    #   slowest_steps.each { |step| puts "#{step.step_name}: #{step.duration_seconds}s" }
+    #
+    # @example With filters and time period
+    #   since_time = 24.hours.ago
+    #   filtered_steps = Tasker::Functions::FunctionBasedSlowestSteps.call(
+    #     since_timestamp: since_time,
+    #     limit_count: 15,
+    #     namespace_filter: 'inventory',
+    #     task_name_filter: 'update_stock'
+    #   )
+    #
+    class FunctionBasedSlowestSteps < FunctionWrapper
+      # Individual slowest step result structure
+      class SlowestStep < Dry::Struct
+        attribute :workflow_step_id, Types::Integer
+        attribute :task_id, Types::Integer
+        attribute :step_name, Types::String
+        attribute :task_name, Types::String
+        attribute :namespace_name, Types::String
+        attribute :version, Types::String
+        attribute :duration_seconds, Types::Float
+        attribute :attempts, Types::Integer
+        attribute :created_at, Types::Params::DateTime
+        attribute :completed_at, Types::Params::DateTime
+        attribute :retryable, Types::Bool
+        attribute :step_status, Types::String
+      end
+
+      # Call the get_slowest_steps_v01 SQL function
+      #
+      # @param since_timestamp [Time, nil] Start time for analysis (defaults to 24 hours ago in SQL)
+      # @param limit_count [Integer] Maximum number of results to return (default: 10)
+      # @param namespace_filter [String, nil] Filter by namespace name
+      # @param task_name_filter [String, nil] Filter by task name
+      # @param version_filter [String, nil] Filter by task version
+      # @return [Array<SlowestStep>] Array of slowest step results
+      # @raise [ActiveRecord::StatementInvalid] If the SQL function fails
+      def self.call(since_timestamp: nil, limit_count: 10, namespace_filter: nil, task_name_filter: nil,
+                    version_filter: nil)
+        # Build SQL with proper parameter binding
+        sql = 'SELECT * FROM get_slowest_steps_v01($1, $2, $3, $4, $5)'
+        binds = [
+          since_timestamp,
+          limit_count,
+          namespace_filter,
+          task_name_filter,
+          version_filter
+        ]
+
+        result = connection.select_all(sql, 'SlowestSteps Load', binds)
+
+        result.map do |row|
+          SlowestStep.new(
+            workflow_step_id: row['workflow_step_id'].to_i,
+            task_id: row['task_id'].to_i,
+            step_name: row['step_name'].to_s,
+            task_name: row['task_name'].to_s,
+            namespace_name: row['namespace_name'].to_s,
+            version: row['version'].to_s,
+            duration_seconds: row['duration_seconds'].to_f,
+            attempts: row['attempts'].to_i,
+            created_at: Time.zone.parse(row['created_at'].to_s),
+            completed_at: Time.zone.parse(row['completed_at'].to_s),
+            retryable: ['t', true].include?(row['retryable']),
+            step_status: row['step_status'].to_s
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_slowest_tasks.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Wrapper for the get_slowest_tasks_v01 SQL function
+    #
+    # This function returns the slowest tasks within a specified time period
+    # with performance metrics and optional filtering by namespace, task name, and version.
+    #
+    # @example Basic usage
+    #   slowest_tasks = Tasker::Functions::FunctionBasedSlowestTasks.call
+    #   slowest_tasks.each { |task| puts "#{task.task_name}: #{task.duration_seconds}s" }
+    #
+    # @example With filters and time period
+    #   since_time = 24.hours.ago
+    #   filtered_tasks = Tasker::Functions::FunctionBasedSlowestTasks.call(
+    #     since_timestamp: since_time,
+    #     limit_count: 5,
+    #     namespace_filter: 'payments',
+    #     task_name_filter: 'process_payment'
+    #   )
+    #
+    class FunctionBasedSlowestTasks < FunctionWrapper
+      # Individual slowest task result structure
+      class SlowestTask < Dry::Struct
+        attribute :task_id, Types::Integer
+        attribute :task_name, Types::String
+        attribute :namespace_name, Types::String
+        attribute :version, Types::String
+        attribute :duration_seconds, Types::Float
+        attribute :step_count, Types::Integer
+        attribute :completed_steps, Types::Integer
+        attribute :error_steps, Types::Integer
+        attribute :created_at, Types::Params::DateTime
+        attribute :completed_at, Types::Params::DateTime.optional
+        attribute :initiator, Types::String.optional
+        attribute :source_system, Types::String.optional
+      end
+
+      # Call the get_slowest_tasks_v01 SQL function
+      #
+      # @param since_timestamp [Time, nil] Start time for analysis (defaults to 24 hours ago in SQL)
+      # @param limit_count [Integer] Maximum number of results to return (default: 10)
+      # @param namespace_filter [String, nil] Filter by namespace name
+      # @param task_name_filter [String, nil] Filter by task name
+      # @param version_filter [String, nil] Filter by task version
+      # @return [Array<SlowestTask>] Array of slowest task results
+      # @raise [ActiveRecord::StatementInvalid] If the SQL function fails
+      def self.call(since_timestamp: nil, limit_count: 10, namespace_filter: nil, task_name_filter: nil,
+                    version_filter: nil)
+        # Build SQL with proper parameter binding
+        sql = 'SELECT * FROM get_slowest_tasks_v01($1, $2, $3, $4, $5)'
+        binds = [
+          since_timestamp,
+          limit_count,
+          namespace_filter,
+          task_name_filter,
+          version_filter
+        ]
+
+        result = connection.select_all(sql, 'SlowestTasks Load', binds)
+
+        result.map do |row|
+          SlowestTask.new(
+            task_id: row['task_id'].to_i,
+            task_name: row['task_name'].to_s,
+            namespace_name: row['namespace_name'].to_s,
+            version: row['version'].to_s,
+            duration_seconds: row['duration_seconds'].to_f,
+            step_count: row['step_count'].to_i,
+            completed_steps: row['completed_steps'].to_i,
+            error_steps: row['error_steps'].to_i,
+            created_at: Time.zone.parse(row['created_at'].to_s),
+            completed_at: row['completed_at'] ? Time.zone.parse(row['completed_at'].to_s) : nil,
+            initiator: row['initiator'],
+            source_system: row['source_system']
+          )
+        end
+      end
+    end
+  end
+end