tasker-rb 0.1.3-x86_64-linux

data/lib/tasker_core/test_environment.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module TaskerCore
+  module TestEnvironment
+    # Test environment conditional loading that only activates when TASKER_ENV=test
+    # Loads example handlers and configures test-specific paths for template discovery
+    class ConditionalLoader
+      include Singleton
+
+      attr_reader :logger, :loaded, :example_handlers_path, :template_fixtures_path
+
+      def initialize
+        @logger = nil # Will be set when logger is available
+        @loaded = false
+        @example_handlers_path = File.expand_path('../../spec/handlers/examples', __dir__)
+        @template_fixtures_path = File.expand_path('../../spec/fixtures/templates', __dir__)
+      end
+
+      # Check if we should load test environment components
+      def should_load_test_environment?
+        test_env = ENV['TASKER_ENV']&.downcase == 'test'
+        rails_test_env = ENV['RAILS_ENV']&.downcase == 'test'
+        force_examples = ENV['TASKER_FORCE_EXAMPLE_HANDLERS'] == 'true'
+
+        test_env || rails_test_env || force_examples
+      end
+
+      # Load test environment components if appropriate
+      def load_if_test_environment!
+        return false unless should_load_test_environment?
+        return true if @loaded # Already loaded
+
+        # Defer logger initialization until after TaskerCore loads
+        @logger = TaskerCore::Logger.instance
+
+        log_info('🧪 Test environment detected, loading example handlers and templates')
+
+        # Set template path override for test fixtures
+        setup_test_template_path!
+
+        # Pre-load all example handler files
+        load_example_handler_files!
+
+        # Verify example handlers are available
+        verify_test_setup!
+
+        @loaded = true
+        log_info("✅ Test environment setup complete: #{loaded_handler_count} example handlers loaded")
+        true
+      end
+
+      # Get count of loaded handler classes for verification
+      def loaded_handler_count
+        return 0 unless @loaded
+
+        count = 0
+        ObjectSpace.each_object(Class) do |klass|
+          if klass.name&.end_with?('Handler') &&
+             klass.ancestors.any? { |ancestor| ancestor.name&.include?('StepHandler') }
+            count += 1
+          end
+        rescue StandardError
+          # Skip classes that can't be introspected
+          next
+        end
+        count
+      end
+
+      # Get list of loaded example handler class names
+      def loaded_handler_names
+        return [] unless @loaded
+
+        names = []
+        ObjectSpace.each_object(Class) do |klass|
+          if klass.name&.end_with?('Handler') &&
+             klass.ancestors.any? { |ancestor| ancestor.name&.include?('StepHandler') }
+            names << klass.name
+          end
+        rescue StandardError
+          # Skip classes that can't be introspected
+          next
+        end
+        names.sort
+      end
+
+      # Get template discovery info for debugging
+      def test_template_info
+        return {} unless @loaded
+
+        {
+          template_path: ENV.fetch('TASKER_TEMPLATE_PATH', nil),
+          fixtures_path: @template_fixtures_path,
+          fixtures_exist: Dir.exist?(@template_fixtures_path),
+          template_files: Dir.exist?(@template_fixtures_path) ? Dir.glob("#{@template_fixtures_path}/*.yaml").count : 0,
+          example_handlers_path: @example_handlers_path,
+          examples_exist: Dir.exist?(@example_handlers_path),
+          handler_files: Dir.exist?(@example_handlers_path) ? Dir.glob("#{@example_handlers_path}/**/*_handler.rb").count : 0,
+          subscriber_files: Dir.exist?(@example_handlers_path) ? Dir.glob("#{@example_handlers_path}/**/*_subscriber.rb").count : 0,
+          registered_subscribers: TaskerCore::DomainEvents::SubscriberRegistry.instance.count
+        }
+      end
+
+      # TAS-65: Get count of loaded subscriber classes
+      def loaded_subscriber_count
+        return 0 unless @loaded
+
+        count = 0
+        ObjectSpace.each_object(Class) do |klass|
+          if klass < TaskerCore::DomainEvents::BaseSubscriber &&
+             klass != TaskerCore::DomainEvents::BaseSubscriber
+            count += 1
+          end
+        rescue StandardError
+          next
+        end
+        count
+      end
+
+      # TAS-65: Get list of loaded subscriber class names
+      def loaded_subscriber_names
+        return [] unless @loaded
+
+        names = []
+        ObjectSpace.each_object(Class) do |klass|
+          if klass < TaskerCore::DomainEvents::BaseSubscriber &&
+             klass != TaskerCore::DomainEvents::BaseSubscriber
+            names << klass.name
+          end
+        rescue StandardError
+          next
+        end
+        names.sort
+      end
+
+      private
+
+      def log_info(message)
+        if @logger
+          @logger.info(message)
+        else
+          puts message # Fallback if logger not available yet
+        end
+      end
+
+      def log_debug(message)
+        if @logger.respond_to?(:debug)
+          @logger.debug(message)
+        elsif ENV['LOG_LEVEL'] == 'debug'
+          puts "[DEBUG] #{message}"
+        end
+      end
+
+      def log_warn(message)
+        if @logger
+          @logger.warn(message)
+        else
+          puts "[WARN] #{message}"
+        end
+      end
+
+      def setup_test_template_path!
+        # Override template path to use test fixtures if not already set
+        return if ENV['TASKER_TEMPLATE_PATH']
+
+        if Dir.exist?(@template_fixtures_path)
+          ENV['TASKER_TEMPLATE_PATH'] = @template_fixtures_path
+          log_debug("📁 Set TASKER_TEMPLATE_PATH to: #{@template_fixtures_path}")
+        else
+          log_warn("⚠️  Test template fixtures directory not found: #{@template_fixtures_path}")
+        end
+      end
+
+      def load_example_handler_files!
+        return unless Dir.exist?(@example_handlers_path)
+
+        handler_files = Dir.glob("#{@example_handlers_path}/**/*_handler.rb")
+        log_debug("🔍 Found #{handler_files.count} example handler files")
+
+        loaded_count = 0
+        handler_files.each do |handler_file|
+          # Use require instead of require_relative to avoid duplicate loading
+          require handler_file
+          loaded_count += 1
+          log_debug("✅ Loaded handler file: #{File.basename(handler_file)}")
+        rescue LoadError => e
+          log_warn("❌ Failed to load handler file #{handler_file}: #{e.message}")
+        rescue StandardError => e
+          log_warn("❌ Error loading handler file #{handler_file}: #{e.class} - #{e.message}")
+        end
+
+        log_info("📚 Loaded #{loaded_count}/#{handler_files.count} example handler files")
+
+        # TAS-65: Also load subscriber files
+        load_example_subscriber_files!
+      end
+
+      # TAS-65: Load example domain event subscriber files
+      def load_example_subscriber_files!
+        return unless Dir.exist?(@example_handlers_path)
+
+        subscriber_files = Dir.glob("#{@example_handlers_path}/**/*_subscriber.rb")
+        return if subscriber_files.empty?
+
+        log_debug("🔍 Found #{subscriber_files.count} example subscriber files")
+
+        loaded_count = 0
+        subscriber_files.each do |subscriber_file|
+          require subscriber_file
+          loaded_count += 1
+          log_debug("✅ Loaded subscriber file: #{File.basename(subscriber_file)}")
+        rescue LoadError => e
+          log_warn("❌ Failed to load subscriber file #{subscriber_file}: #{e.message}")
+        rescue StandardError => e
+          log_warn("❌ Error loading subscriber file #{subscriber_file}: #{e.class} - #{e.message}")
+        end
+
+        log_info("📚 Loaded #{loaded_count}/#{subscriber_files.count} example subscriber files")
+
+        # Auto-register loaded subscribers with the registry
+        register_loaded_subscribers!
+      end
+
+      # TAS-65: Auto-register any loaded subscriber classes with SubscriberRegistry
+      def register_loaded_subscribers!
+        registry = TaskerCore::DomainEvents::SubscriberRegistry.instance
+        registered_count = 0
+
+        ObjectSpace.each_object(Class) do |klass|
+          # Skip if not a BaseSubscriber subclass
+          next unless klass < TaskerCore::DomainEvents::BaseSubscriber
+          # Skip the BaseSubscriber itself
+          next if klass == TaskerCore::DomainEvents::BaseSubscriber
+
+          registry.register(klass)
+          registered_count += 1
+          log_debug("✅ Registered subscriber: #{klass.name}")
+        rescue StandardError => e
+          log_warn("❌ Failed to register subscriber #{klass}: #{e.message}")
+        end
+
+        log_info("📚 Registered #{registered_count} domain event subscribers") if registered_count.positive?
+      end
+
+      def verify_test_setup!
+        # Verify template path is set correctly
+        template_path = ENV.fetch('TASKER_TEMPLATE_PATH', nil)
+        if template_path.nil?
+          log_warn('⚠️  TASKER_TEMPLATE_PATH not set, template discovery may fail')
+        elsif !Dir.exist?(template_path)
+          log_warn("⚠️  TASKER_TEMPLATE_PATH directory does not exist: #{template_path}")
+        else
+          yaml_files = Dir.glob("#{template_path}/*.yaml").count
+          log_debug("📄 Found #{yaml_files} YAML template files in #{template_path}")
+        end
+
+        # Verify example handlers directory exists
+        unless Dir.exist?(@example_handlers_path)
+          log_warn("⚠️  Example handlers directory not found: #{@example_handlers_path}")
+          return
+        end
+
+        # Count available handler classes
+        handler_count = loaded_handler_count
+        if handler_count.zero?
+          log_warn('⚠️  No example handler classes found after loading')
+        else
+          log_debug("🎯 #{handler_count} example handler classes are available")
+        end
+      end
+    end
+
+    # Main interface - call this to conditionally load test environment
+    def self.load_if_test!
+      ConditionalLoader.instance.load_if_test_environment!
+    end
+
+    # Check if test environment is loaded
+    def self.loaded?
+      ConditionalLoader.instance.loaded
+    end
+
+    # Get test environment info for debugging
+    def self.info
+      loader = ConditionalLoader.instance
+      base_info = {
+        should_load: loader.should_load_test_environment?,
+        loaded: loader.loaded,
+        handler_count: loader.loaded_handler_count
+      }
+
+      if loader.loaded
+        base_info.merge(loader.test_template_info)
+      else
+        base_info
+      end
+    end
+
+    # Get loaded handler names for debugging
+    def self.handler_names
+      ConditionalLoader.instance.loaded_handler_names
+    end
+
+    # TAS-65: Get loaded subscriber names for debugging
+    def self.subscriber_names
+      ConditionalLoader.instance.loaded_subscriber_names
+    end
+
+    # TAS-65: Get subscriber count
+    def self.subscriber_count
+      ConditionalLoader.instance.loaded_subscriber_count
+    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