tasker-rb 0.1.1

data/lib/tasker_core/task_handler/base.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'logger'
+require 'securerandom'
+
+module TaskerCore
+  module TaskHandler
+    class Base
+      # Ruby task handler for pgmq-based orchestration
+      #
+      # This class provides a simplified interface for task processing using the new
+      # pgmq architecture. Instead of TCP commands, it uses direct pgmq communication
+      # and the embedded orchestrator for step enqueueing.
+      #
+      # Key changes from TCP architecture:
+      # - No command_client dependencies
+      # - Direct pgmq messaging for task initialization
+      # - Embedded orchestrator for step enqueueing
+      # - Simplified error handling and validation
+
+      attr_reader :logger, :task_config
+
+      def initialize(task_config_path: nil, task_config: nil)
+        @logger = TaskerCore::Logger.instance
+        @task_config = task_config || (task_config_path ? load_task_config_from_path(task_config_path) : {})
+        @pgmq_client = nil # Lazy initialization to avoid database connection during setup
+      end
+
+      # Get or create pgmq client (lazy initialization)
+      # @return [TaskerCore::Messaging::PgmqClient] pgmq client instance
+      def pgmq_client
+        @pgmq_client ||= TaskerCore::Messaging::PgmqClient.new
+      end
+
+      # Main task processing method - Rails engine signature: handle(task_uuid)
+      #
+      # Mode-aware processing: Uses embedded FFI orchestrator in embedded mode,
+      # or pure pgmq communication in distributed mode.
+      #
+      # @param task_uuid [Integer] ID of the task to process
+      # @return [Hash] Result of step enqueueing operation
+      def handle(task_uuid)
+        unless task_uuid.is_a?(Integer)
+          raise TaskerCore::Errors::ValidationError.new('task_uuid is required and must be an integer', :task_uuid)
+        end
+
+        mode = orchestration_mode
+        logger.info "🚀 Processing task #{task_uuid} with pgmq orchestration (#{mode} mode)"
+
+        case mode
+        when 'embedded'
+          handle_embedded_mode(task_uuid)
+        when 'distributed'
+          handle_distributed_mode(task_uuid)
+        else
+          raise TaskerCore::Errors::OrchestrationError,
+                "Unknown orchestration mode: #{mode}. Expected 'embedded' or 'distributed'"
+        end
+      rescue TaskerCore::Errors::OrchestrationError => e
+        logger.error "❌ Orchestration error for task #{task_uuid}: #{e.message}"
+        {
+          success: false,
+          task_uuid: task_uuid,
+          error: e.message,
+          error_type: 'OrchestrationError',
+          architecture: 'pgmq',
+          processed_at: Time.now.utc.iso8601
+        }
+      rescue StandardError => e
+        logger.error "❌ Unexpected error processing task #{task_uuid}: #{e.class.name}: #{e.message}"
+        {
+          success: false,
+          task_uuid: task_uuid,
+          error: e.message,
+          error_type: e.class.name,
+          architecture: 'pgmq',
+          processed_at: Time.now.utc.iso8601
+        }
+      end
+
+      # Initialize a new task with workflow steps
+      #
+      # In the pgmq architecture, this sends a task request message to the orchestration
+      # core monitored task_requests_queue, which will be processed by the Rust orchestrator
+      # to create the task record and enqueue initial steps.
+      #
+      # @param task_request [Hash] Task initialization data
+      # @return [void] No return value - operation is async via pgmq
+      def initialize_task(task_request)
+        logger.info '🚀 Initializing task with pgmq architecture'
+
+        task_request = TaskerCore::Types::TaskTypes::TaskRequest.from_hash(task_request)
+
+        # Prepare task request message for pgmq
+        task_request_message = {
+          message_type: 'task_request',
+          task_request: task_request.to_ffi_hash,
+          enqueued_at: Time.now.utc.iso8601,
+          message_id: SecureRandom.uuid
+        }
+
+        # Send message to task_requests_queue for orchestration core processing
+        begin
+          pgmq_client.send_message('task_requests_queue', task_request_message)
+          logger.info "✅ Task request sent to orchestration queue: #{task_request.namespace}/#{task_request.name}"
+
+          # Return void - this is now an async operation
+          nil
+        rescue StandardError => e
+          logger.error "❌ Failed to send task request to orchestration queue: #{e.message}"
+          raise TaskerCore::Errors::OrchestrationError, "Failed to send task request: #{e.message}"
+        end
+      rescue TaskerCore::Errors::ValidationError => e
+        logger.error "❌ Validation error initializing task: #{e.message}"
+        raise e
+      rescue StandardError => e
+        logger.error "❌ Unexpected error initializing task: #{e.class.name}: #{e.message}"
+        raise TaskerCore::Errors::OrchestrationError, "Task initialization failed: #{e.message}"
+      end
+
+      # Check if the pgmq orchestration system is available and ready
+      # @return [Boolean] true if system is ready for task processing
+      def orchestration_ready?
+        orchestrator = TaskerCore.embedded_orchestrator
+        orchestrator.running?
+      rescue StandardError => e
+        logger.warn "⚠️ Failed to check orchestration status: #{e.message}"
+        false
+      end
+
+      # Get status information for this task handler
+      # @return [Hash] Status information including mode and pgmq connectivity
+      def status
+        mode = orchestration_mode
+
+        # Check pgmq availability without forcing connection
+        pgmq_available = begin
+          !pgmq_client.nil?
+        rescue TaskerCore::Errors::Error => e
+          logger.debug "🔍 PGMQ not available: #{e.message}"
+          false
+        end
+
+        status_info = {
+          handler_type: 'TaskHandler::Base',
+          architecture: 'pgmq',
+          orchestration_mode: mode,
+          orchestration_ready: orchestration_ready?,
+          pgmq_available: pgmq_available,
+          task_config_loaded: !task_config.empty?,
+          checked_at: Time.now.utc.iso8601
+        }
+
+        # Include embedded orchestrator status only in embedded mode
+        status_info[:embedded_orchestrator] = embedded_orchestrator_status if mode == 'embedded'
+
+        status_info
+      end
+
+      private
+
+      def load_task_config_from_path(path)
+        return {} unless path && File.exist?(path)
+
+        YAML.load_file(path)
+      rescue StandardError => e
+        logger.warn "Error loading task configuration: #{e.message}"
+        {}
+      end
+
+      def embedded_orchestrator_status
+        orchestrator = TaskerCore.embedded_orchestrator
+        {
+          running: orchestrator.running?,
+          namespaces: orchestrator.namespaces,
+          started_at: orchestrator.started_at&.iso8601
+        }
+      rescue StandardError => e
+        logger.warn "⚠️ Failed to get embedded orchestrator status: #{e.message}"
+        { running: false, error: e.message }
+      end
+
+      # Determine orchestration mode from configuration
+      # @return [String] 'embedded' or 'distributed'
+      def orchestration_mode
+        config = TaskerCore::Config.instance
+        mode = config.orchestration_config.mode
+
+        # Default to embedded mode if not specified or in test environment
+        if mode.nil?
+          if config.test_environment?
+            'embedded'
+          else
+            'distributed'
+          end
+        else
+          mode
+        end
+      rescue StandardError => e
+        logger.warn "⚠️ Failed to determine orchestration mode: #{e.message}, defaulting to distributed"
+        'distributed'
+      end
+
+      # Handle task processing in embedded mode using FFI orchestrator
+      # @param task_uuid [Integer] ID of the task to process
+      # @return [Hash] Result of step enqueueing operation
+      def handle_embedded_mode(task_uuid)
+        # Use embedded orchestrator to enqueue ready steps for the task
+        orchestrator = TaskerCore.embedded_orchestrator
+
+        unless orchestrator.running?
+          raise TaskerCore::Errors::OrchestrationError,
+                'Embedded orchestration system not running. Call TaskerCore.start_embedded_orchestration! first.'
+        end
+
+        # Enqueue steps for the task - this will publish step messages to appropriate queues
+        result = orchestrator.enqueue_steps(task_uuid)
+
+        logger.info "✅ Task #{task_uuid} step enqueueing completed (embedded): #{result}"
+
+        {
+          success: true,
+          task_uuid: task_uuid,
+          message: result,
+          mode: 'embedded',
+          architecture: 'pgmq',
+          processed_at: Time.now.utc.iso8601
+        }
+      end
+
+      # Handle task processing in distributed mode using pure pgmq
+      # @param task_uuid [Integer] ID of the task to process
+      # @return [Hash] Result of step enqueueing operation
+      def handle_distributed_mode(task_uuid)
+        # In distributed mode, we don't directly enqueue steps via FFI
+        # Instead, we could publish a task processing request to a queue
+        # For now, return a message indicating distributed mode handling
+
+        logger.info "✅ Task #{task_uuid} queued for distributed processing"
+
+        {
+          success: true,
+          task_uuid: task_uuid,
+          message: 'Task queued for distributed orchestration processing',
+          mode: 'distributed',
+          architecture: 'pgmq',
+          processed_at: Time.now.utc.iso8601,
+          note: 'Phase 4.5 will complete distributed orchestration integration'
+        }
+      end
+    end
+  end
+end

data/lib/tasker_core/template_discovery.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module TaskerCore
+  module TemplateDiscovery
+    # Template path discovery following the same patterns as Rust TaskTemplateManager
+    # Finds task template configuration directory using environment variables and workspace detection
+    class TemplatePath
+      class << self
+        # Find the template configuration directory using the same logic as Rust
+        # Returns path to directory containing .yaml template files
+        def find_template_config_directory
+          # First try TASKER_TEMPLATE_PATH environment variable
+          return ENV['TASKER_TEMPLATE_PATH'] if ENV['TASKER_TEMPLATE_PATH'] && Dir.exist?(ENV['TASKER_TEMPLATE_PATH'])
+
+          # Try WORKSPACE_PATH environment variable (for compatibility)
+          if ENV['WORKSPACE_PATH']
+            template_dir = File.join(ENV['WORKSPACE_PATH'], 'config', 'tasks')
+            return template_dir if Dir.exist?(template_dir)
+          end
+
+          # Try workspace detection from current directory
+          workspace_root = find_workspace_root
+          if workspace_root
+            template_dir = File.join(workspace_root, 'config', 'tasks')
+            return template_dir if Dir.exist?(template_dir)
+          end
+
+          # Default fallback to current directory
+          default_dir = 'config/tasks'
+          return default_dir if Dir.exist?(default_dir)
+
+          # If nothing found, return nil
+          nil
+        end
+
+        # Discover all YAML template files in the template directory
+        def discover_template_files(template_dir = nil)
+          template_dir ||= find_template_config_directory
+          return [] unless template_dir
+
+          # Look for both .yaml and .yml file extensions
+          yaml_files = Dir.glob(File.join(template_dir, '**', '*.yaml'))
+          yml_files = Dir.glob(File.join(template_dir, '**', '*.yml'))
+          (yaml_files + yml_files).sort.uniq
+        end
+
+        private
+
+        # Find workspace root by looking for Cargo.toml or other workspace indicators
+        def find_workspace_root(start_dir = Dir.pwd)
+          current_dir = File.expand_path(start_dir)
+
+          loop do
+            # Look for workspace indicators
+            return current_dir if workspace_indicators.any? do |indicator|
+              File.exist?(File.join(current_dir, indicator))
+            end
+
+            parent_dir = File.dirname(current_dir)
+            break if parent_dir == current_dir # Reached filesystem root
+
+            current_dir = parent_dir
+          end
+
+          nil
+        end
+
+        def workspace_indicators
+          ['Cargo.toml', '.git', 'Gemfile', 'package.json', 'tasker-core.code-workspace']
+        end
+      end
+    end
+
+    # YAML template parser that extracts handler information
+    class TemplateParser
+      class << self
+        # Parse a YAML template file and extract handler callables
+        # Returns array of handler class names found in the template
+        def extract_handler_callables(template_file)
+          return [] unless File.exist?(template_file)
+
+          begin
+            template_data = YAML.load_file(template_file)
+            extract_handlers_from_template(template_data)
+          rescue StandardError => e
+            TaskerCore::Logger.instance.warn("Failed to parse template #{template_file}: #{e.message}")
+            []
+          end
+        end
+
+        # Extract handler callables from parsed template data
+        def extract_handlers_from_template(template_data)
+          handlers = []
+
+          # Add task handler if present
+          if template_data['task_handler'] && template_data['task_handler']['callable']
+            handlers << template_data['task_handler']['callable']
+          end
+
+          # Add step handlers
+          if template_data['steps'].is_a?(Array)
+            template_data['steps'].each do |step|
+              handlers << step['handler']['callable'] if step['handler'] && step['handler']['callable']
+            end
+          end
+
+          handlers.uniq
+        end
+
+        # Get template metadata for debugging/introspection
+        def extract_template_metadata(template_file)
+          return nil unless File.exist?(template_file)
+
+          begin
+            template_data = YAML.load_file(template_file)
+            {
+              name: template_data['name'],
+              namespace_name: template_data['namespace_name'],
+              version: template_data['version'],
+              description: template_data['description'],
+              file_path: template_file,
+              handlers: extract_handlers_from_template(template_data)
+            }
+          rescue StandardError => e
+            TaskerCore::Logger.instance.warn("Failed to extract metadata from #{template_file}: #{e.message}")
+            nil
+          end
+        end
+      end
+    end
+
+    # Main discovery coordinator that combines path and parsing logic
+    class HandlerDiscovery
+      class << self
+        # Discover all handlers from templates in the configured template directory
+        # Returns array of unique handler class names
+        def discover_all_handlers(template_dir = nil)
+          template_files = TemplatePath.discover_template_files(template_dir)
+
+          handlers = template_files.flat_map do |file|
+            TemplateParser.extract_handler_callables(file)
+          end
+
+          handlers.uniq.sort
+        end
+
+        # Get detailed information about discovered templates
+        # Returns array of template metadata hashes
+        def discover_template_metadata(template_dir = nil)
+          template_files = TemplatePath.discover_template_files(template_dir)
+
+          template_files.filter_map do |file|
+            TemplateParser.extract_template_metadata(file)
+          end
+        end
+
+        # Get handlers grouped by namespace
+        # Returns hash of namespace => [handler_names]
+        def discover_handlers_by_namespace(template_dir = nil)
+          metadata = discover_template_metadata(template_dir)
+
+          handlers_by_namespace = {}
+          metadata.each do |meta|
+            namespace = meta[:namespace_name] || 'default'
+            handlers_by_namespace[namespace] ||= []
+            handlers_by_namespace[namespace].concat(meta[:handlers])
+          end
+
+          # Remove duplicates and sort
+          handlers_by_namespace.each do |namespace, handlers|
+            handlers_by_namespace[namespace] = handlers.uniq.sort
+          end
+
+          handlers_by_namespace
+        end
+      end
+    end
+  end
+end

data/lib/tasker_core/tracing.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module TaskerCore
+  # Unified structured logging via Rust tracing FFI
+  #
+  # TAS-29 Phase 6: Replace Ruby's Logger with FFI calls to Rust's tracing
+  # infrastructure, enabling unified structured logging across Ruby and Rust.
+  #
+  # ## Architecture
+  #
+  #   Ruby Handler → Tracing.info() → FFI Bridge → Rust tracing → OpenTelemetry
+  #
+  # ## Usage
+  #
+  #   # Simple message
+  #   Tracing.info("Task initialized")
+  #
+  #   # With structured fields
+  #   Tracing.info("Step completed", {
+  #     correlation_id: correlation_id,
+  #     task_uuid: task.uuid,
+  #     step_uuid: step.uuid,
+  #     namespace: "order_fulfillment",
+  #     operation: "validate_inventory",
+  #     duration_ms: elapsed_ms
+  #   })
+  #
+  #   # Error logging
+  #   Tracing.error("Payment processing failed", {
+  #     correlation_id: correlation_id,
+  #     error_class: error.class.name,
+  #     error_message: error.message
+  #   })
+  #
+  # ## Structured Field Conventions (TAS-29 Phase 6.2)
+  #
+  # **Required fields** (when applicable):
+  # - correlation_id: Always include for distributed tracing
+  # - task_uuid: Include for task-level operations
+  # - step_uuid: Include for step-level operations
+  # - namespace: Include for namespace-specific operations
+  # - operation: Operation identifier (e.g., "validate_inventory")
+  #
+  # **Optional fields**:
+  # - duration_ms: For timed operations
+  # - error_class, error_message: For error context
+  # - entity_id: For domain entity operations
+  # - retry_count: For retryable operations
+  #
+  # ## Log Level Guidelines (TAS-29 Phase 6.1)
+  #
+  # - ERROR: Unrecoverable failures requiring intervention
+  # - WARN: Degraded operation, retryable failures
+  # - INFO: Lifecycle events, state transitions
+  # - DEBUG: Detailed diagnostic information
+  # - TRACE: Very verbose, hot-path entry/exit
+  #
+  class Tracing
+    include Singleton
+
+    # Log ERROR level message with structured fields
+    #
+    # @param message [String] Log message
+    # @param fields [Hash] Structured fields (correlation_id, task_uuid, etc.)
+    # @return [void]
+    def self.error(message, fields = {})
+      fields_hash = normalize_fields(fields)
+      TaskerCore::FFI.log_error(message.to_s, fields_hash)
+    rescue StandardError => e
+      # Fallback to stderr if FFI logging fails
+      warn "FFI logging failed: #{e.message}"
+      warn "#{message} | #{fields.inspect}"
+    end
+
+    # Log WARN level message with structured fields
+    #
+    # @param message [String] Log message
+    # @param fields [Hash] Structured fields
+    # @return [void]
+    def self.warn(message, fields = {})
+      fields_hash = normalize_fields(fields)
+      TaskerCore::FFI.log_warn(message.to_s, fields_hash)
+    rescue StandardError => e
+      warn "FFI logging failed: #{e.message}"
+      warn "#{message} | #{fields.inspect}"
+    end
+
+    # Log INFO level message with structured fields
+    #
+    # @param message [String] Log message
+    # @param fields [Hash] Structured fields
+    # @return [void]
+    def self.info(message, fields = {})
+      fields_hash = normalize_fields(fields)
+      TaskerCore::FFI.log_info(message.to_s, fields_hash)
+    rescue StandardError => e
+      warn "FFI logging failed: #{e.message}"
+      warn "#{message} | #{fields.inspect}"
+    end
+
+    # Log DEBUG level message with structured fields
+    #
+    # @param message [String] Log message
+    # @param fields [Hash] Structured fields
+    # @return [void]
+    def self.debug(message, fields = {})
+      fields_hash = normalize_fields(fields)
+      TaskerCore::FFI.log_debug(message.to_s, fields_hash)
+    rescue StandardError => e
+      warn "FFI logging failed: #{e.message}"
+      warn "#{message} | #{fields.inspect}"
+    end
+
+    # Log TRACE level message with structured fields
+    #
+    # @param message [String] Log message
+    # @param fields [Hash] Structured fields
+    # @return [void]
+    def self.trace(message, fields = {})
+      fields_hash = normalize_fields(fields)
+      TaskerCore::FFI.log_trace(message.to_s, fields_hash)
+    rescue StandardError => e
+      warn "FFI logging failed: #{e.message}"
+      warn "#{message} | #{fields.inspect}"
+    end
+
+    # Normalize fields to string keys and values for FFI
+    #
+    # @param fields [Hash] Input fields
+    # @return [Hash<String, String>] Normalized fields
+    # @api private
+    def self.normalize_fields(fields)
+      return {} if fields.nil? || fields.empty?
+
+      fields.transform_keys(&:to_s).transform_values { |v| normalize_value(v) }
+    end
+
+    # Normalize a value to string for FFI
+    #
+    # @param value [Object] Value to normalize
+    # @return [String] String representation
+    # @api private
+    def self.normalize_value(value)
+      case value
+      when nil
+        'nil'
+      when String
+        value
+      when Symbol
+        value.to_s
+      when Numeric, TrueClass, FalseClass
+        value.to_s
+      when Exception
+        "#{value.class}: #{value.message}"
+      else
+        value.to_s
+      end
+    rescue StandardError
+      '<serialization_error>'
+    end
+
+    private_class_method :normalize_fields, :normalize_value
+  end
+end