pigeon-rb 0.1.0

data/lib/pigeon/monitoring.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Pigeon
+  # Monitoring-related functionality for Pigeon
+  module Monitoring
+    # Get the metrics collector
+    # @return [Pigeon::Metrics::Collector] Metrics collector instance
+    def self.metrics_collector
+      Core.config.metrics_collector ||= Pigeon::Metrics::Collector.new
+    end
+
+    # Get all metrics
+    # @return [Hash] All metrics
+    def self.metrics
+      metrics_collector.all_metrics
+    end
+
+    # Get metrics in a format suitable for monitoring systems
+    # @return [Hash] Formatted metrics
+    def self.metrics_for_monitoring
+      metrics_collector.metrics_for_monitoring
+    end
+
+    # Reset all metrics
+    # @return [void]
+    def self.reset_metrics
+      metrics_collector.reset
+    end
+
+    # Create a logger with additional context
+    # @param context [Hash] Additional context to include in all log entries
+    # @return [Pigeon::Logging::StructuredLogger] Logger with context
+    def self.logger_with_context(context = {})
+      Core.config.logger.with_context(context)
+    end
+
+    # Set the log level
+    # @param level [Symbol, String, Integer] Log level
+    # @return [Integer] New log level
+    def self.log_level=(level)
+      Core.config.logger.level = level
+    end
+
+    # Get the current log level
+    # @return [Integer] Current log level
+    def self.log_level
+      Core.config.logger.level
+    end
+
+    # Get the time when the processor was started
+    # @return [Time, nil] Start time or nil if not started
+    def self.processor_start_time
+      @processor_start_time
+    end
+
+    # Get the time of the last processing run
+    # @return [Time, nil] Last run time or nil if never run
+    def self.last_processing_run
+      @last_processing_run
+    end
+
+    # Get the time of the last successful processing run
+    # @return [Time, nil] Last successful run time or nil if never run
+    def self.last_successful_processing_run
+      @last_successful_processing_run
+    end
+
+    # Set the processor start time
+    # @param time [Time] Start time
+    # @return [Time] Start time
+    def self.processor_start_time=(time)
+      @processor_start_time = time
+    end
+
+    # Set the time of the last processing run
+    # @param time [Time] Last run time
+    # @return [Time] Last run time
+    def self.last_processing_run=(time)
+      @last_processing_run = time
+    end
+
+    # Set the time of the last successful processing run
+    # @param time [Time] Last successful run time
+    # @return [Time] Last successful run time
+    def self.last_successful_processing_run=(time)
+      @last_successful_processing_run = time
+    end
+
+    # Get the health status of the processor
+    # @return [Hash] Health status
+    def self.processor_health
+      HealthCheck.processor_health
+    end
+
+    # Get the health status of the queue
+    # @return [Hash] Health status
+    def self.queue_health
+      HealthCheck.queue_health
+    end
+
+    # Get the health status of Kafka connectivity
+    # @return [Hash] Health status
+    def self.kafka_health
+      HealthCheck.kafka_health
+    end
+
+    # Get the overall health status
+    # @return [Hash] Overall health status
+    def self.health_status
+      HealthCheck.status
+    end
+  end
+end

data/lib/pigeon/outbox.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Pigeon
+  # Outbox-related functionality for Pigeon
+  module Outbox
+    # Get the appropriate outbox message adapter based on the framework
+    # @return [Class] Adapter class
+    def self.outbox_message_adapter
+      if defined?(ActiveRecord)
+        Models::Adapters::ActiveRecordAdapter
+      elsif defined?(ROM) && defined?(Hanami)
+        Models::Adapters::RomAdapter
+      else
+        Models::OutboxMessage
+      end
+    end
+
+    # Create a new outbox message
+    # @param attributes [Hash] Message attributes
+    # @return [Pigeon::Models::OutboxMessage] New message instance
+    def self.create_outbox_message(attributes = {})
+      outbox_message_adapter.create(attributes)
+    end
+
+    # Find an outbox message by ID
+    # @param id [String, Integer] Message ID
+    # @return [Pigeon::Models::OutboxMessage, nil] Message instance or nil if not found
+    def self.find_outbox_message(id)
+      outbox_message_adapter.find(id)
+    end
+
+    # Find outbox messages by status
+    # @param status [String] Message status
+    # @param limit [Integer] Maximum number of messages to return
+    # @return [Array<Pigeon::Models::OutboxMessage>] Array of message instances
+    def self.find_outbox_messages_by_status(status, limit = 100)
+      outbox_message_adapter.find_by_status(status, limit)
+    end
+
+    # Find outbox messages ready for retry
+    # @param limit [Integer] Maximum number of messages to return
+    # @return [Array<Pigeon::Models::OutboxMessage>] Array of message instances
+    def self.find_outbox_messages_ready_for_retry(limit = 100)
+      outbox_message_adapter.find_ready_for_retry(limit)
+    end
+
+    # Count outbox messages by status
+    # @param status [String] Message status
+    # @return [Integer] Count of messages with the given status
+    def self.count_outbox_messages_by_status(status)
+      outbox_message_adapter.count_by_status(status)
+    end
+
+    # Find the oldest outbox message by status
+    # @param status [String] Message status
+    # @return [Pigeon::Models::OutboxMessage, nil] Oldest message or nil if none found
+    def self.find_oldest_outbox_message_by_status(status)
+      outbox_message_adapter.find_oldest_by_status(status)
+    end
+  end
+end

data/lib/pigeon/processor/background_processor.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Pigeon
+  class Processor
+    # Background processing functionality for the processor
+    module BackgroundProcessor
+      # Start processing pending messages in the background
+      # @param batch_size [Integer] Number of messages to process in one batch
+      # @param interval [Integer] Interval in seconds between processing batches
+      # @param thread_count [Integer] Number of threads to use for processing
+      # @return [Boolean] Whether processing was started
+      def start_background_processing(batch_size: 100, interval: 5, thread_count: 2)
+        return false if @processing.true?
+
+        @mutex.with_write_lock do
+          return false if @processing.true?
+
+          Pigeon.config.logger.info("Starting background processing of outbox messages")
+
+          # Process any pending messages immediately
+          process_startup_messages(batch_size)
+
+          # Create a thread pool for processing
+          @thread_pool = Concurrent::FixedThreadPool.new(thread_count)
+
+          # Set up periodic processing
+          @scheduler = Concurrent::TimerTask.new(execution_interval: interval) do
+            process_pending(batch_size: batch_size)
+          end
+
+          # Start the scheduler
+          @scheduler.execute
+
+          @processing.make_true
+        end
+
+        true
+      end
+
+      # Stop processing pending messages
+      # @return [Boolean] Whether processing was stopped
+      def stop_background_processing
+        return false unless @processing.true?
+
+        @mutex.with_write_lock do
+          return false unless @processing.true?
+
+          Pigeon.config.logger.info("Stopping background processing of outbox messages")
+
+          # Stop the scheduler
+          @scheduler&.shutdown
+
+          # Shutdown the thread pool
+          @thread_pool&.shutdown
+          @thread_pool&.wait_for_termination(10) # Wait up to 10 seconds for threads to finish
+
+          @processing.make_false
+        end
+
+        true
+      end
+
+      # Check if processing is running
+      # @return [Boolean] Whether processing is running
+      def processing?
+        @processing.true?
+      end
+
+      # Process pending messages on startup
+      # @param batch_size [Integer] Number of messages to process in one batch
+      # @return [Hash] Processing statistics
+      def process_startup_messages(batch_size = 100)
+        Pigeon.config.logger.info("Processing pending messages on startup")
+
+        # Process pending messages
+        stats = process_pending(batch_size: batch_size)
+
+        # Log the results
+        Pigeon.config.logger.info("Startup processing complete: #{stats[:processed]} messages processed")
+
+        stats
+      end
+
+      private
+
+      # Process messages in thread pool or synchronously
+      # @param messages [Array<Pigeon::Models::OutboxMessage>] Messages to process
+      # @param stats [Hash] Statistics hash to update
+      # @return [void]
+      def process_messages_batch(messages, stats)
+        messages.each do |message|
+          if @thread_pool && @processing.true?
+            # Process in thread pool if available
+            @thread_pool.post do
+              process_result = process_single_message(message)
+              update_stats(stats, process_result)
+            end
+          else
+            # Process synchronously
+            process_result = process_single_message(message)
+            update_stats(stats, process_result)
+          end
+        end
+      end
+    end
+  end
+end