sidekiq_sqs_processor 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0ff0052092b07dd5382e15eeb24602e1bdb03702d588a91fa0f5e374f705df4
-  data.tar.gz: 24e0fa2d29c6d3714ed747671bba3c09f712d9ad57fa0295a84db092af07404f
+  metadata.gz: fdadc44e3df0c0ff5d8a09102f83afedb6f0c571c988b228138e8134947e6338
+  data.tar.gz: 74101646e239ec7bbd8c57ef224f957c1c046be760600e6291e7573feae4c818
 SHA512:
-  metadata.gz: 7a455adcec4f646834b089ec75ab934b6be6bc238d2b570bd25499736fdb7ef7b75c68f6ad58aabd9f9f053a64222da4efb4388dddb031c4411141fca876fd79
-  data.tar.gz: 5f50146da3c8569ea44008a670446736139fdeace823fff3eb715c59b3748aa10c209cad8d433dc7a29c93fe52a1eca95f6a7f451e1f784235a24dd0666e1ca0
+  metadata.gz: 99da0bcadb9f8b16ad61fde81dc03623230e1f72904b62440b70bfc9f85e32cd7027774d747dcaf38596619a0d6d93ec39879da20bad0a18aae90e9fca6feb0c
+  data.tar.gz: e1c9755983ea3a5cadeae2e5ae82c29a0ee4fbba877005bc45a59695854259391b9031179abdffdae6d2a0379905c7ba7e76403f97a8b1f50d066e53cd585b6f

data/README.md

@@ -21,7 +21,7 @@ A Ruby gem that seamlessly integrates Amazon SQS with Sidekiq for efficient and
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sidekiq_sqs_processor'
+gem 'sidekiq-sqs-processor'
 ```
 
 And then execute:
@@ -67,9 +67,24 @@ SidekiqSqsProcessor.configure do |config|
   config.queue_urls = [
     'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue'
   ]
-  
+
   # Polling configuration
   config.polling_type = :continuous
+
+  # Map queue URLs to worker classes
+  config.queue_workers = {
+    'https://sqs.us-east-1.amazonaws.com/123456789012/queue1' => 'Queue1Worker',
+    'https://sqs.us-east-1.amazonaws.com/123456789012/queue2' => 'Queue2Worker'
+  }
+
+  # Optional: Set custom logger
+  config.logger = Rails.logger
+
+  # Optional: Set custom error handler
+  config.error_handler = ->(error, context) do
+    # Handle errors (e.g., report to monitoring service)
+    Rails.logger.error("SQS Error: #{error.message}\nContext: #{context.inspect}")
+  end
 end
 ```
 
@@ -88,13 +103,13 @@ SidekiqSqsProcessor.configure do |config|
   config.queue_urls = [
     'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue'
   ]
-  
+
   # Start polling when Sidekiq starts
   Sidekiq.configure_server do |sidekiq_config|
     sidekiq_config.on(:startup) do
       SidekiqSqsProcessor.start_continuous_poller
     end
-    
+
     sidekiq_config.on(:shutdown) do
       SidekiqSqsProcessor.stop_continuous_poller
     end
@@ -124,10 +139,10 @@ class MyWorker < SidekiqSqsProcessor::BaseWorker
   # Override the process_message method to handle your SQS messages
   def process_message(message_body)
     # message_body is already parsed from JSON if it was a JSON string
-    
+
     # Your processing logic here
     User.find_by(id: message_body['user_id'])&.notify(message_body['message'])
-    
+
     # Return a result (optional)
     { status: 'success' }
   end
@@ -148,9 +163,9 @@ class OrderProcessor < SidekiqSqsProcessor::BaseWorker
       logger.error("Invalid order message format: #{message_body.inspect}")
     end
   end
-  
+
   private
-  
+
   def process_order(order_id, items)
     # Your order processing logic
     Order.process(order_id, items)
@@ -174,7 +189,7 @@ class EventProcessor < SidekiqSqsProcessor::BaseWorker
       logger.warn("Unknown event type: #{message_body['event_type']}")
     end
   end
-  
+
   # ... processing methods ...
 end
 ```
@@ -188,7 +203,7 @@ class NotificationProcessor < SidekiqSqsProcessor::BaseWorker
   def process_message(message_body)
     # For an SNS message, the SNS envelope has been removed
     # and message_body is the parsed content of the SNS Message field
-    
+
     logger.info("Processing notification: #{message_body.inspect}")
     # ... your processing logic ...
   end
@@ -202,7 +217,7 @@ You can also enqueue messages directly to a worker without going through SQS:
 ```ruby
 # Enqueue a message to a specific worker
 SidekiqSqsProcessor.enqueue_message(
-  MyWorker, 
+  MyWorker,
   { order_id: 123, items: ['item1', 'item2'] }
 )
 ```
@@ -312,4 +327,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/yourus
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-

data/lib/sidekiq_sqs_processor/base_worker.rb

@@ -4,23 +4,6 @@ module SidekiqSqsProcessor
   class BaseWorker
     include Sidekiq::Worker
 
-    class << self
-      def process_message_automatically
-        return @process_message_automatically if defined?(@process_message_automatically)
-        @process_message_automatically = true
-      end
-
-      def process_message_automatically=(value)
-        @process_message_automatically = value
-      end
-
-      def inherited(subclass)
-        super
-        # Copy the process_message_automatically value to subclasses
-        subclass.process_message_automatically = process_message_automatically
-      end
-    end
-
     # Configure Sidekiq options with defaults
     sidekiq_options(
       retry: 25,     # Default retry count
@@ -28,55 +11,68 @@ module SidekiqSqsProcessor
     )
 
     def perform(message_data)
-      process_message_data(message_data) if self.class.process_message_automatically
-    end
-
-    # Override this method in your worker
-    def process_message(body)
-      raise NotImplementedError, "You must implement process_message in your worker"
-    end
-
-    private
-
-    def process_message_data(message_data)
       begin
-        # Parse and process the message
+        # Parse the SQS message body
         body = JSON.parse(message_data["body"])
-        process_message(body)
+
+        # Extract the actual message from the SQS message
+        # SNS messages are wrapped in a JSON structure with a "Message" field
+        actual_message = if body["Message"]
+          JSON.parse(body["Message"])
+        else
+          body
+        end
+
+        # Process the message
+        process_message(actual_message)
 
         # Delete the message from SQS after successful processing
         delete_sqs_message(message_data)
       rescue JSON::ParserError => e
-        handle_error(e, message_data, "Failed to parse message body")
+        SidekiqSqsProcessor.handle_error(e, {
+          worker: self.class.name,
+          message: message_data,
+          description: "Failed to parse message body"
+        })
+        raise # Re-raise to trigger Sidekiq retry
       rescue Aws::SQS::Errors::ServiceError => e
-        handle_error(e, message_data, "SQS service error")
+        SidekiqSqsProcessor.handle_error(e, {
+          worker: self.class.name,
+          message: message_data,
+          description: "SQS service error"
+        })
+        raise # Re-raise to trigger Sidekiq retry
       rescue StandardError => e
-        handle_error(e, message_data, "Error processing message")
+        SidekiqSqsProcessor.handle_error(e, {
+          worker: self.class.name,
+          message: message_data,
+          description: "Error processing message"
+        })
+        raise # Re-raise to trigger Sidekiq retry
       end
     end
 
+    # Override this method in your worker
+    def process_message(body)
+      raise NotImplementedError, "You must implement process_message in your worker"
+    end
+
+    private
+
     def delete_sqs_message(message_data)
       return unless message_data["queue_url"] && message_data["receipt_handle"]
-      
+
       SidekiqSqsProcessor.sqs_client.delete_message(
         queue_url: message_data["queue_url"],
         receipt_handle: message_data["receipt_handle"]
       )
     rescue Aws::SQS::Errors::ServiceError => e
-      handle_error(e, message_data, "Failed to delete message from SQS")
-    end
-
-    def handle_error(error, message_data, description)
-      SidekiqSqsProcessor.handle_error(error, {
+      SidekiqSqsProcessor.handle_error(e, {
         worker: self.class.name,
         message: message_data,
-        description: description
+        description: "Failed to delete message from SQS"
       })
       raise # Re-raise to trigger Sidekiq retry
     end
-
-    def logger
-      SidekiqSqsProcessor.configuration.logger || Sidekiq.logger
-    end
   end
 end

data/lib/sidekiq_sqs_processor/configuration.rb

@@ -1,182 +1,62 @@
+# frozen_string_literal: true
+
 module SidekiqSqsProcessor
   class Configuration
-    # AWS credentials
-    attr_accessor :aws_access_key_id, :aws_secret_access_key, :aws_credentials
-    attr_reader :aws_region, :queue_urls, :max_number_of_messages,
-                :visibility_timeout, :wait_time_seconds, :poller_thread_count,
-                :error_handler, :polling_enabled, :polling_type, :poll_on_startup,
-                :polling_frequency, :log_level
-
-    # Worker configuration
-    attr_accessor :worker_retry_count, :worker_queue_name, :logger
+    attr_accessor :aws_region,
+                  :aws_access_key_id,
+                  :aws_secret_access_key,
+                  :queue_workers,
+                  :logger,
+                  :error_handler
 
     def initialize
-      @aws_region = "us-east-1"
-      @queue_urls = []
-      @max_number_of_messages = 10
-      @visibility_timeout = 30
-      @wait_time_seconds = 20
-      @poller_thread_count = 1
-      @worker_retry_count = 25
-      @worker_queue_name = "default"
-      @error_handler = default_error_handler
-      @polling_enabled = true
-      @polling_type = :continuous
-      @poll_on_startup = true
-      @polling_frequency = 60 # seconds
-      @log_level = Logger::INFO
-    end
-
-    def aws_region=(region)
-      @aws_region = region&.strip
-    end
-
-    def queue_urls=(urls)
-      @queue_urls = Array(urls).map(&:strip)
+      puts "[SidekiqSqsProcessor] Initializing configuration..."
+      @aws_region = 'us-east-1'
+      @queue_workers = {}  # Hash of queue_url => worker_class_name
+      @logger = nil
+      @error_handler = nil
     end
 
-    def add_queue_url(url)
-      @queue_urls << url.strip
-      @queue_urls.uniq!
-    end
-
-    def max_number_of_messages=(value)
-      @max_number_of_messages = value.to_i
-    end
+    def validate!(strict: false)
+      puts "[SidekiqSqsProcessor] Validating configuration..."
+      puts "[SidekiqSqsProcessor] Current queue workers: #{@queue_workers.inspect}"
+      
+      raise ArgumentError, "AWS region is required" if @aws_region.nil?
 
-    def visibility_timeout=(value)
-      @visibility_timeout = value.to_i
+      # Only enforce queue workers in strict mode
+      if strict
+        raise ArgumentError, "At least one queue worker mapping is required" if @queue_workers.empty?
+        raise ArgumentError, "All queue URLs must have a corresponding worker class name" if @queue_workers.values.any?(&:nil?)
+      elsif @queue_workers.empty?
+        puts "[SidekiqSqsProcessor] WARNING: No queue workers configured yet"
+        return false
+      end
+      
+      puts "[SidekiqSqsProcessor] Configuration validation successful"
+      true
     end
 
-    def wait_time_seconds=(value)
-      @wait_time_seconds = value.to_i
+    def ready_for_polling?
+      !@queue_workers.empty? && validate!(strict: false)
     end
 
-    def poller_thread_count=(value)
-      @poller_thread_count = value.to_i
+    def queue_urls
+      @queue_workers.keys
     end
 
-    def error_handler=(handler)
-      if !handler.respond_to?(:call) && !handler.nil?
-        raise ArgumentError, "Error handler must be callable (respond to #call)"
-      end
-      @error_handler = handler
-    end
-    
-    def polling_enabled=(value)
-      @polling_enabled = !!value
-    end
-    
-    def polling_type=(value)
-      value = value.to_sym if value.respond_to?(:to_sym)
-      unless [:continuous, :scheduled].include?(value)
-        raise ArgumentError, "polling_type must be :continuous or :scheduled"
-      end
-      @polling_type = value
-    end
-    
-    def poll_on_startup=(value)
-      @poll_on_startup = !!value
-    end
-    
-    def polling_frequency=(value)
-      @polling_frequency = [value.to_i, 1].max
-    end
-    
-    def log_level=(level)
-      if level.is_a?(Integer) && (0..5).include?(level)
-        @log_level = level
-      elsif level.is_a?(Symbol) || level.is_a?(String)
-        level_map = {
-          debug: Logger::DEBUG,
-          info: Logger::INFO,
-          warn: Logger::WARN,
-          error: Logger::ERROR,
-          fatal: Logger::FATAL,
-          unknown: Logger::UNKNOWN
-        }
-        sym_level = level.to_sym.downcase
-        if level_map.key?(sym_level)
-          @log_level = level_map[sym_level]
-        else
-          raise ArgumentError, "Invalid log level: #{level}. Valid levels are: #{level_map.keys.join(', ')}"
-        end
-      else
-        raise ArgumentError, "Log level must be an Integer (0-5) or one of: debug, info, warn, error, fatal, unknown"
-      end
-    end
-    def handle_error(error, context = {})
-      if @error_handler
-        @error_handler.call(error, context)
-      else
-        default_error_handler.call(error, context)
-      end
+    def register_worker(queue_url, worker_class)
+      @queue_workers[queue_url] = worker_class
+      puts "[SidekiqSqsProcessor] Registered worker #{worker_class} for queue #{queue_url}"
     end
 
-    def validate!
-      errors = []
-
-      # AWS Config
-      if aws_region.nil? || aws_region.empty?
-        errors << "aws_region is not configured"
-      end
-
-      # Validate thread and message settings before queue URLs
-      if !poller_thread_count.positive?
-        errors << "poller_thread_count must be positive"
-      end
-
-      if !max_number_of_messages.between?(1, 10)
-        errors << "max_number_of_messages must be between 1 and 10"
-      end
-
-      if !wait_time_seconds.between?(0, 20)
-        errors << "wait_time_seconds must be between 0 and 20"
-      end
-
-      if !visibility_timeout.positive?
-        errors << "visibility_timeout must be positive"
-      end
-      
-      if ![:continuous, :scheduled].include?(polling_type)
-        errors << "polling_type must be :continuous or :scheduled"
-      end
+    def worker_class_for_queue(queue_url)
+      worker = @queue_workers[queue_url]
       
-      if !polling_frequency.positive?
-        errors << "polling_frequency must be positive"
+      if worker.nil?
+        puts "[SidekiqSqsProcessor] No worker found for queue #{queue_url}"
       end
       
-      # Queue URLs should be checked last
-      if queue_urls.empty?
-        errors << "queue_urls is empty"
-      end
-
-      # Raise first specific error for single-error tests
-      if errors.length == 1
-        raise ArgumentError, errors.first
-      end
-
-      # Raise all errors together
-      if errors.any?
-        raise ArgumentError, "Invalid configuration: #{errors.join(', ')}"
-      end
-
-      true
-    end
-
-    private
-
-    def default_error_handler
-      ->(error, context = {}) do
-        logger = self.logger || Sidekiq.logger
-        if error.is_a?(Exception)
-          logger.error(error.message)
-          logger.error(error.backtrace.join("\n")) if error.backtrace
-        else
-          logger.error(error.to_s)
-        end
-        logger.error("Context: #{context.inspect}") unless context.empty?
-      end
+      worker
     end
   end
 end

data/lib/sidekiq_sqs_processor/continuous_poller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 module SidekiqSqsProcessor
@@ -5,89 +7,103 @@ module SidekiqSqsProcessor
     include Singleton
 
     def initialize
+      puts "[SidekiqSqsProcessor] Initializing ContinuousPoller"
       @running = false
       @threads = []
       @mutex = Mutex.new
     end
 
     def start
+      puts "[SidekiqSqsProcessor] Starting ContinuousPoller"
+      puts "[SidekiqSqsProcessor] Current state: running=#{@running}, threads=#{@threads.count}"
+      
       return false if running?
 
       @mutex.synchronize do
-        @running = true
-        start_polling_threads
+        puts "[SidekiqSqsProcessor] Inside start mutex"
+        begin
+          @running = true
+          start_polling_threads
+          puts "[SidekiqSqsProcessor] Polling threads started successfully"
+          true
+        rescue => e
+          puts "[SidekiqSqsProcessor] ERROR starting polling threads: #{e.class} - #{e.message}"
+          puts "[SidekiqSqsProcessor] #{e.backtrace.join("\n")}"
+          @running = false
+          false
+        end
       end
-
-      true
     end
 
     def stop
+      puts "[SidekiqSqsProcessor] Stopping ContinuousPoller"
       return false unless running?
 
       @mutex.synchronize do
-        @running = false
-        stop_polling_threads
+        begin
+          @running = false
+          stop_polling_threads
+          puts "[SidekiqSqsProcessor] Polling threads stopped successfully"
+          true
+        rescue => e
+          puts "[SidekiqSqsProcessor] ERROR stopping polling threads: #{e.class} - #{e.message}"
+          puts "[SidekiqSqsProcessor] #{e.backtrace.join("\n")}"
+          false
+        end
       end
-
-      true
     end
 
     def running?
       @running
     end
 
-    def stats
-      {
-        running: running?,
-        threads: @threads.count,
-        queue_urls: SidekiqSqsProcessor.configuration.queue_urls
-      }
-    end
-
     private
 
     def start_polling_threads
+      puts "[SidekiqSqsProcessor] Starting polling threads"
+      puts "[SidekiqSqsProcessor] Queue URLs: #{SidekiqSqsProcessor.configuration.queue_urls.inspect}"
+      
       SidekiqSqsProcessor.configuration.queue_urls.each do |queue_url|
-        SidekiqSqsProcessor.configuration.poller_thread_count.times do
-          thread = Thread.new do
-            poll_queue(queue_url) while running?
-          end
-          @threads << thread
+        thread = Thread.new do
+          Thread.current.name = "SQS-Poller-#{queue_url}"
+          puts "[SidekiqSqsProcessor] Started polling thread for queue: #{queue_url}"
+          
+          poll_queue(queue_url) while running?
         end
+        @threads << thread
       end
     end
 
     def stop_polling_threads
+      puts "[SidekiqSqsProcessor] Stopping polling threads"
       @threads.each(&:exit)
       @threads.each(&:join)
       @threads.clear
     end
 
     def poll_queue(queue_url)
-      response = receive_messages(queue_url)
-      process_messages(response.messages, queue_url)
-    rescue StandardError => e
-      SidekiqSqsProcessor.handle_error(e, { queue_url: queue_url })
-      sleep(1) # Brief pause before retrying
+      begin
+        response = receive_messages(queue_url)
+        process_messages(response.messages, queue_url)
+      rescue StandardError => e
+        SidekiqSqsProcessor.handle_error(e, { queue_url: queue_url })
+      end
     end
 
     def receive_messages(queue_url)
       SidekiqSqsProcessor.sqs_client.receive_message(
         queue_url: queue_url,
-        max_number_of_messages: SidekiqSqsProcessor.configuration.max_number_of_messages,
-        visibility_timeout: SidekiqSqsProcessor.configuration.visibility_timeout,
-        wait_time_seconds: SidekiqSqsProcessor.configuration.wait_time_seconds,
+        max_number_of_messages: 10,
+        visibility_timeout: 30,
+        wait_time_seconds: 1,
         attribute_names: ["All"],
         message_attribute_names: ["All"]
       )
     end
+
     def process_messages(messages, queue_url)
       messages.each do |message|
-        message_data = nil
-        worker_class = nil
-        
         begin
-          # Convert to a hash for passing to the worker
           message_data = {
             "message_id" => message.message_id,
             "receipt_handle" => message.receipt_handle,
@@ -97,41 +113,35 @@ module SidekiqSqsProcessor
             "md5_of_body" => message.md5_of_body,
             "queue_url" => queue_url
           }
-          
-          worker_class = find_worker_for_message(message)
+
+          worker_class = find_worker_for_message(message, queue_url)
           if worker_class
-            # Simply call perform_async, which will be handled appropriately in test vs prod
             worker_class.perform_async(message_data)
+          else
+            SidekiqSqsProcessor.handle_error(
+              StandardError.new("No worker found for message"),
+              { message: message_data, queue_url: queue_url }
+            )
           end
         rescue StandardError => e
-          # Handle worker error without re-raising
-          data_to_pass = message_data || message
-          handle_worker_error(e, worker_class&.name, data_to_pass, queue_url)
+          SidekiqSqsProcessor.handle_error(e, { message: message, queue_url: queue_url })
         end
       end
     end
-    
-    def handle_worker_error(error, worker_name, message, queue_url)
-      context = {
-        queue_url: queue_url,
-        worker: worker_name || "Unknown",
-        message: message
-      }
-      SidekiqSqsProcessor.handle_error(error, context)
-    end
-    def find_worker_for_message(message)
-      # Default to using the queue name as the worker class name
-      # This can be overridden in subclasses for custom routing logic
+
+    def find_worker_for_message(message, queue_url)
+      # First try to get worker class from message attributes
       worker_name = message.message_attributes&.dig("worker_class", "string_value")
-      worker_name ||= queue_name_to_worker_name(message.queue_url)
-      
-      SidekiqSqsProcessor.find_worker_class(worker_name)
-    end
 
-    def queue_name_to_worker_name(queue_url)
-      # Convert 'my-queue-name' to 'MyQueueNameWorker'
-      queue_name = queue_url.split('/').last
-      "#{queue_name.split('-').map(&:capitalize).join}Worker"
+      # If not found in message, use the configured mapping
+      worker_name ||= SidekiqSqsProcessor.configuration.worker_class_for_queue(queue_url)
+
+      # Convert string to class if needed
+      if worker_name.is_a?(String)
+        worker_name.constantize
+      else
+        worker_name
+      end
     end
   end
 end

data/lib/sidekiq_sqs_processor/railtie.rb

@@ -5,98 +5,92 @@ module SidekiqSqsProcessor
   # Rails integration for SidekiqSqsProcessor
   # Handles initialization, configuration, and lifecycle management
   class Railtie < Rails::Railtie
-    initializer "sidekiq_sqs_processor.configure_rails_initialization" do |app|
+    config.before_initialize do |app|
+      puts "[SidekiqSqsProcessor] Loading Railtie..."
+    end
+
+    # Move initialization to after Rails has fully loaded to ensure
+    # all gems have had a chance to configure themselves
+    config.after_initialize do |app|
+      puts "[SidekiqSqsProcessor] Starting Rails initialization..."
+      
       # Set default logger to Rails logger if not specified
       SidekiqSqsProcessor.configuration.logger ||= Rails.logger
-      
-      # Disable polling in test environment by default
-      if Rails.env.test? && !ENV['ENABLE_SQS_POLLING_IN_TEST']
-        SidekiqSqsProcessor.configuration.polling_enabled = false
-      end
-      
-      # Disable polling in development by default unless explicitly enabled
-      if Rails.env.development? && !ENV['ENABLE_SQS_POLLING_IN_DEV']
-        SidekiqSqsProcessor.configuration.polling_enabled = false
-      end
-      
+
       # Configure Sidekiq server middleware and lifecycle hooks
       if defined?(Sidekiq)
+        puts "[SidekiqSqsProcessor] Configuring Sidekiq server..."
+        
         Sidekiq.configure_server do |config|
+          puts "[SidekiqSqsProcessor] Inside Sidekiq server configuration..."
+          
           # Start continuous poller when Sidekiq server starts
-          # Only if polling is enabled and type is continuous
           config.on(:startup) do
-            if SidekiqSqsProcessor.configuration.polling_type == :continuous && 
-               SidekiqSqsProcessor.configuration.polling_enabled &&
-               SidekiqSqsProcessor.configuration.poll_on_startup
-              
-              # Only run the poller in the scheduler process if using Sidekiq Enterprise
-              # For regular Sidekiq, this will run in every process
-              if !defined?(Sidekiq::Enterprise) || Sidekiq.schedule?
-                Rails.logger.info("Starting SidekiqSqsProcessor continuous poller")
-                SidekiqSqsProcessor.start_continuous_poller
+            puts "[SidekiqSqsProcessor] Sidekiq server starting up..."
+            
+            # Only run the poller in the scheduler process if using Sidekiq Enterprise
+            # For regular Sidekiq, this will run in every process
+            if !defined?(Sidekiq::Enterprise) || Sidekiq.schedule?
+              # Initialize poller in a non-blocking way
+              Thread.new do
+                # Name the thread for easier debugging
+                Thread.current.name = "SQSPollerInit"
+                begin
+                  puts "[SidekiqSqsProcessor] Initializing SQS poller in background thread..."
+                  
+                  # Wait for up to 30 seconds for configuration to be ready
+                  30.times do |i|
+                    if SidekiqSqsProcessor.configuration.ready_for_polling?
+                      puts "[SidekiqSqsProcessor] Configuration is ready, starting poller..."
+                      SidekiqSqsProcessor.start_continuous_poller
+                      puts "[SidekiqSqsProcessor] Poller started successfully"
+                      break
+                    else
+                      puts "[SidekiqSqsProcessor] Waiting for configuration to be ready... (#{i+1}/30)" if i % 5 == 0
+                      sleep 1
+                    end
+                  end
+
+                  # Final check after timeout
+                  unless SidekiqSqsProcessor.configuration.ready_for_polling?
+                    puts "[SidekiqSqsProcessor] WARNING: Configuration not ready after 30 seconds"
+                    puts "[SidekiqSqsProcessor] WARNING: SQS polling will not start"
+                    puts "[SidekiqSqsProcessor] WARNING: Current configuration state:"
+                    puts "[SidekiqSqsProcessor] Queue workers: #{SidekiqSqsProcessor.configuration.queue_workers.inspect}"
+                  end
+                rescue => e
+                  puts "[SidekiqSqsProcessor] ERROR: Failed to start poller: #{e.class} - #{e.message}"
+                  puts "[SidekiqSqsProcessor] ERROR: Backtrace: #{e.backtrace.join("\n")}"
+                  # Log the error but don't crash the thread
+                end
               end
+            else
+              puts "[SidekiqSqsProcessor] Skipping poller in non-scheduler process"
             end
           end
-          
+
           # Stop continuous poller when Sidekiq server shuts down
           config.on(:shutdown) do
             if SidekiqSqsProcessor.continuous_poller_running?
-              Rails.logger.info("Stopping SidekiqSqsProcessor continuous poller")
+              puts "[SidekiqSqsProcessor] Stopping continuous poller..."
               SidekiqSqsProcessor.stop_continuous_poller
             end
           end
         end
-      end
-      
-      # Set up scheduled polling if enabled
-      if defined?(Sidekiq::Cron) && 
-         SidekiqSqsProcessor.configuration.polling_type == :scheduled &&
-         SidekiqSqsProcessor.configuration.polling_enabled
-        
-        # Only set up in server mode
-        if Sidekiq.server?
-          frequency = SidekiqSqsProcessor.configuration.polling_frequency
-          
-          # Convert seconds to cron expression
-          # Minimum 1 minute for cron
-          minutes = [frequency / 60, 1].max
-          cron_expression = minutes == 1 ? "* * * * *" : "*/#{minutes} * * * *"
-          
-          # Create the cron job
-          Sidekiq::Cron::Job.create(
-            name: 'SQS Polling Job',
-            cron: cron_expression,
-            class: 'SidekiqSqsProcessor::ScheduledPoller',
-            queue: 'critical'
-          )
-          
-          Rails.logger.info("Registered SidekiqSqsProcessor scheduled poller with cron: #{cron_expression}")
-        end
+      else
+        puts "[SidekiqSqsProcessor] WARNING: Sidekiq is not defined!"
       end
     end
-    
+
     # Expose rake tasks if available
     rake_tasks do
       load "tasks/sidekiq_sqs_processor_tasks.rake" if File.exist?(File.join(File.dirname(__FILE__), "../tasks/sidekiq_sqs_processor_tasks.rake"))
     end
-    
+
     # Register Rails generators
     generators do
-      require_relative "../generators/sidekiq_sqs_processor/install_generator"
-      require_relative "../generators/sidekiq_sqs_processor/worker_generator"
-    end
-    
-    # Add local configuration options to Rails application configuration
-    config.after_initialize do |app|
-      # Validate configuration if in production
-      if Rails.env.production? && SidekiqSqsProcessor.configuration.polling_enabled
-        # Ensure configuration is valid
-        unless SidekiqSqsProcessor.configuration.valid?
-          Rails.logger.error("Invalid SidekiqSqsProcessor configuration")
-          SidekiqSqsProcessor.configuration.validate!  # This will raise an error with details
-        end
-      end
+      require_relative "../generators/sidekiq_sqs_processor/install_generator" if File.exist?(File.join(File.dirname(__FILE__), "../generators/sidekiq_sqs_processor/install_generator.rb"))
+      require_relative "../generators/sidekiq_sqs_processor/worker_generator" if File.exist?(File.join(File.dirname(__FILE__), "../generators/sidekiq_sqs_processor/worker_generator.rb"))
     end
   end
 end
-

data/lib/sidekiq_sqs_processor/version.rb

@@ -1,5 +1,5 @@
 
 module SidekiqSqsProcessor
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end
 

data/lib/sidekiq_sqs_processor.rb

@@ -9,7 +9,6 @@ require_relative 'sidekiq_sqs_processor/version'
 require_relative 'sidekiq_sqs_processor/configuration'
 require_relative 'sidekiq_sqs_processor/base_worker'
 require_relative 'sidekiq_sqs_processor/continuous_poller'
-require_relative 'sidekiq_sqs_processor/continuous_poller'
 require_relative 'sidekiq_sqs_processor/railtie' if defined?(Rails)
 
 # Main module for the SidekiqSqsProcessor gem
@@ -17,13 +16,13 @@ require_relative 'sidekiq_sqs_processor/railtie' if defined?(Rails)
 module SidekiqSqsProcessor
   class << self
     attr_writer :configuration
-    
+
     # Get the current configuration
     # @return [SidekiqSqsProcessor::Configuration]
     def configuration
       @configuration ||= Configuration.new
     end
-    
+
     # Configure the gem
     # @yield [config] Gives the configuration object to the block
     # @example
@@ -33,93 +32,79 @@ module SidekiqSqsProcessor
     #   end
     def configure
       yield(configuration)
+      configuration.validate!
     end
-    
+
     # Start the continuous poller
     # @return [Boolean] Whether the poller was started
     def start_continuous_poller
       ContinuousPoller.instance.start
     end
-    
+
     # Stop the continuous poller
     # @return [Boolean] Whether the poller was stopped
     def stop_continuous_poller
       ContinuousPoller.instance.stop
     end
-    
+
     # Check if the continuous poller is running
     # @return [Boolean] Whether the poller is running
     def continuous_poller_running?
       ContinuousPoller.instance.running?
     end
-    
+
     # Get statistics about the continuous poller
     # @return [Hash] Statistics about the poller threads
     def continuous_poller_stats
       ContinuousPoller.instance.stats
     end
-    
+
     # Get the AWS SQS client
     # @return [Aws::SQS::Client]
     def sqs_client
-      @sqs_client ||= create_sqs_client
-    end
-    
-    # Explicitly set the SQS client (primarily for testing)
-    # @param client [Aws::SQS::Client] The SQS client to use
-    def sqs_client=(client)
-      @sqs_client = client
-    end
-    
-    # Create a new SQS client based on configuration
-    # @return [Aws::SQS::Client] The AWS SQS client
-    def create_sqs_client
-      options = { region: configuration.aws_region }
-      
-      # Use custom credentials if provided
-      if configuration.aws_credentials
-        options[:credentials] = configuration.aws_credentials
-      elsif configuration.aws_access_key_id && configuration.aws_secret_access_key
-        options[:access_key_id] = configuration.aws_access_key_id
-        options[:secret_access_key] = configuration.aws_secret_access_key
-      end
-      
-      Aws::SQS::Client.new(options)
+      @sqs_client ||= Aws::SQS::Client.new(
+        region: configuration.aws_region,
+        access_key_id: configuration.aws_access_key_id,
+        secret_access_key: configuration.aws_secret_access_key
+      )
     end
-    
+
     # Get the logger
     # @return [Logger] The logger
     def logger
       configuration.logger || Sidekiq.logger
     end
-    
+
     # Reset the configuration and clients
     # Used primarily for testing
     def reset!
       @configuration = nil
       @sqs_client = nil
     end
-    
+
     # Validate the current configuration
     # @return [Boolean] Whether the configuration is valid
     # @raise [ArgumentError] If the configuration is invalid
     def validate_configuration!
       configuration.validate!
     end
-    
+
     # Find all worker classes that inherit from SidekiqSqsProcessor::BaseWorker
     # @return [Array<Class>] Array of worker classes
     def worker_classes
       ObjectSpace.each_object(Class).select { |c| c < BaseWorker rescue false }
     end
-    
+
     # Get a worker class by name
     # @param name [String] The worker class name
     # @return [Class, nil] The worker class or nil if not found
-    def find_worker_class(name)
-      Object.const_get(name) rescue nil
+    def find_worker_class(worker_name)
+      return nil unless worker_name
+      worker_name.constantize
+    rescue NameError
+      nil
     end
-    
+
     # Enqueue a message directly to a specific worker
     # @param worker_class [Class, String] The worker class or name
     # @param message_body [Hash, String] The message body
@@ -128,12 +113,12 @@ module SidekiqSqsProcessor
     def enqueue_message(worker_class, message_body, options = {})
       # If worker_class is a string, convert to actual class
       worker_class = Object.const_get(worker_class) if worker_class.is_a?(String)
-      
+
       # Ensure the worker is a SidekiqSqsProcessor::BaseWorker
       unless worker_class < BaseWorker
         raise ArgumentError, "Worker class must inherit from SidekiqSqsProcessor::BaseWorker"
       end
-      
+
       # Create a simulated SQS message
       message_data = {
         'message_id' => SecureRandom.uuid,
@@ -142,20 +127,25 @@ module SidekiqSqsProcessor
         'message_attributes' => options[:message_attributes] || {},
         'enqueued_at' => Time.now.to_f
       }
-      
+
       # Special handling for receipt_handle and queue_url if used for testing
       message_data['receipt_handle'] = options[:receipt_handle] if options[:receipt_handle]
       message_data['queue_url'] = options[:queue_url] if options[:queue_url]
-      
+
       # Enqueue to Sidekiq
       worker_class.perform_async(message_data)
     end
-    
+
     # Handle an error using the configured error handler
     # @param error [Exception] The error to handle
     # @param context [Hash] Additional context for the error
     def handle_error(error, context = {})
-      configuration.handle_error(error, context)
+      if configuration.error_handler
+        configuration.error_handler.call(error, context)
+      else
+        logger = configuration.logger || Sidekiq.logger
+        logger.error("SQS Error: #{error.message}\nContext: #{context.inspect}")
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_sqs_processor
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Unnikrishnan KP