tina4ruby 0.5.2 → 3.2.1

data/lib/tina4/queue.rb

@@ -38,25 +38,181 @@ module Tina4
 
   class Producer
     def initialize(backend: nil)
-      @backend = backend || Tina4::QueueBackends::LiteBackend.new
+      @backend = backend || Tina4::Queue.resolve_backend
     end
 
     def publish(topic, payload)
       message = QueueMessage.new(topic: topic, payload: payload)
       @backend.enqueue(message)
-      Tina4::Debug.debug("Message published to #{topic}: #{message.id}")
+      Tina4::Log.debug("Message published to #{topic}: #{message.id}")
       message
     end
 
     def publish_batch(topic, payloads)
       payloads.map { |p| publish(topic, p) }
     end
+
+    # Unified push method matching the cross-framework API.
+    def push(topic, payload)
+      publish(topic, payload)
+    end
+  end
+
+  # Queue — unified wrapper for queue management operations.
+  # Auto-detects backend from TINA4_QUEUE_BACKEND env var.
+  #
+  # Usage:
+  #   # Auto-detect from env (default: lite/file backend)
+  #   queue = Queue.new(topic: "tasks")
+  #
+  #   # Explicit backend
+  #   queue = Queue.new(topic: "tasks", backend: :rabbitmq)
+  #
+  #   # Or pass a backend instance directly (legacy)
+  #   queue = Queue.new(topic: "tasks", backend: my_backend)
+  class Queue
+    attr_reader :topic, :max_retries
+
+    def initialize(topic:, backend: nil, max_retries: 3)
+      @topic = topic
+      @max_retries = max_retries
+      @backend = resolve_backend_arg(backend)
+    end
+
+    # Push a job onto the queue. Returns the QueueMessage.
+    def push(payload)
+      message = QueueMessage.new(topic: @topic, payload: payload)
+      @backend.enqueue(message)
+      message
+    end
+
+    # Pop the next available job. Returns QueueMessage or nil.
+    def pop
+      @backend.dequeue(@topic)
+    end
+
+    # Get dead letter jobs — messages that exceeded max retries.
+    def dead_letters
+      return [] unless @backend.respond_to?(:dead_letters)
+      @backend.dead_letters(@topic, max_retries: @max_retries)
+    end
+
+    # Delete messages by status (completed, failed, dead).
+    def purge(status)
+      return 0 unless @backend.respond_to?(:purge)
+      @backend.purge(@topic, status)
+    end
+
+    # Re-queue failed messages (under max_retries) back to pending.
+    # Returns the number of jobs re-queued.
+    def retry_failed
+      return 0 unless @backend.respond_to?(:retry_failed)
+      @backend.retry_failed(@topic, max_retries: @max_retries)
+    end
+
+    # Get the number of pending messages.
+    def size
+      @backend.size(@topic)
+    end
+
+    # Get the underlying backend instance.
+    def backend
+      @backend
+    end
+
+    # Resolve the default backend from env vars.
+    # Class method so Producer can also use it.
+    def self.resolve_backend(name = nil)
+      chosen = name || ENV.fetch("TINA4_QUEUE_BACKEND", "lite").downcase.strip
+
+      case chosen.to_s
+      when "lite", "file", "default"
+        Tina4::QueueBackends::LiteBackend.new
+      when "rabbitmq"
+        config = resolve_rabbitmq_config
+        Tina4::QueueBackends::RabbitmqBackend.new(config)
+      when "kafka"
+        config = resolve_kafka_config
+        Tina4::QueueBackends::KafkaBackend.new(config)
+      else
+        raise ArgumentError, "Unknown queue backend: #{chosen.inspect}. Use 'lite', 'rabbitmq', or 'kafka'."
+      end
+    end
+
+    private
+
+    def resolve_backend_arg(backend)
+      # If a backend instance is passed directly (legacy), use it
+      return backend if backend && !backend.is_a?(Symbol) && !backend.is_a?(String)
+      # If a symbol or string name is passed, resolve it
+      Queue.resolve_backend(backend)
+    end
+
+    def self.resolve_rabbitmq_config
+      config = {}
+      url = ENV["TINA4_QUEUE_URL"]
+      if url
+        config = parse_amqp_url(url)
+      end
+      config[:host] ||= ENV.fetch("TINA4_RABBITMQ_HOST", "localhost")
+      config[:port] ||= (ENV["TINA4_RABBITMQ_PORT"] || 5672).to_i
+      config[:username] ||= ENV.fetch("TINA4_RABBITMQ_USERNAME", "guest")
+      config[:password] ||= ENV.fetch("TINA4_RABBITMQ_PASSWORD", "guest")
+      config[:vhost] ||= ENV.fetch("TINA4_RABBITMQ_VHOST", "/")
+      config
+    end
+
+    def self.resolve_kafka_config
+      config = {}
+      url = ENV["TINA4_QUEUE_URL"]
+      if url
+        config[:brokers] = url.sub("kafka://", "")
+      end
+      brokers = ENV["TINA4_KAFKA_BROKERS"]
+      config[:brokers] = brokers if brokers
+      config[:brokers] ||= "localhost:9092"
+      config[:group_id] = ENV.fetch("TINA4_KAFKA_GROUP_ID", "tina4_consumer_group")
+      config
+    end
+
+    def self.parse_amqp_url(url)
+      config = {}
+      url = url.sub("amqp://", "").sub("amqps://", "")
+
+      if url.include?("@")
+        creds, rest = url.split("@", 2)
+        if creds.include?(":")
+          config[:username], config[:password] = creds.split(":", 2)
+        else
+          config[:username] = creds
+        end
+      else
+        rest = url
+      end
+
+      if rest.include?("/")
+        hostport, vhost = rest.split("/", 2)
+        config[:vhost] = vhost.start_with?("/") ? vhost : "/#{vhost}" if vhost && !vhost.empty?
+      else
+        hostport = rest
+      end
+
+      if hostport.include?(":")
+        host, port = hostport.split(":", 2)
+        config[:host] = host
+        config[:port] = port.to_i
+      elsif hostport && !hostport.empty?
+        config[:host] = hostport
+      end
+
+      config
+    end
   end
 
   class Consumer
     def initialize(topic:, backend: nil, max_retries: 3)
       @topic = topic
-      @backend = backend || Tina4::QueueBackends::LiteBackend.new
+      @backend = backend || Tina4::Queue.resolve_backend
       @max_retries = max_retries
       @handlers = []
       @running = false
@@ -68,7 +224,7 @@ module Tina4
 
     def start(poll_interval: 1)
       @running = true
-      Tina4::Debug.info("Consumer started for topic: #{@topic}")
+      Tina4::Log.info("Consumer started for topic: #{@topic}")
 
       while @running
         message = @backend.dequeue(@topic)
@@ -82,7 +238,7 @@ module Tina4
 
     def stop
       @running = false
-      Tina4::Debug.info("Consumer stopped for topic: #{@topic}")
+      Tina4::Log.info("Consumer stopped for topic: #{@topic}")
     end
 
     def process_one
@@ -103,7 +259,7 @@ module Tina4
       message.status = :completed
       @backend.acknowledge(message)
     rescue => e
-      Tina4::Debug.error("Queue message failed: #{message.id} - #{e.message}")
+      Tina4::Log.error("Queue message failed: #{message.id} - #{e.message}")
       message.status = :failed
 
       if message.attempts < @max_retries

data/lib/tina4/queue_backends/lite_backend.rb

@@ -68,6 +68,94 @@ module Tina4
            .select { |d| File.directory?(File.join(@dir, d)) }
       end
 
+      # Get dead letter jobs for a topic — messages that exceeded max retries.
+      def dead_letters(topic, max_retries: 3)
+        return [] unless Dir.exist?(@dead_letter_dir)
+
+        files = Dir.glob(File.join(@dead_letter_dir, "*.json")).sort_by { |f| File.mtime(f) }
+        jobs = []
+
+        files.each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["topic"] == topic.to_s
+          data["status"] = "dead"
+          jobs << data
+        rescue JSON::ParserError
+          next
+        end
+
+        jobs
+      end
+
+      # Delete messages by status (completed, failed, dead).
+      # For 'dead', removes from the dead_letter directory.
+      # For 'failed', removes from the topic directory (re-queued failed messages).
+      # Returns the number of jobs purged.
+      def purge(topic, status)
+        count = 0
+
+        if status.to_s == "dead"
+          return 0 unless Dir.exist?(@dead_letter_dir)
+
+          Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
+            data = JSON.parse(File.read(file))
+            if data["topic"] == topic.to_s
+              File.delete(file)
+              count += 1
+            end
+          rescue JSON::ParserError
+            next
+          end
+        elsif status.to_s == "failed" || status.to_s == "completed" || status.to_s == "pending"
+          dir = topic_path(topic)
+          return 0 unless Dir.exist?(dir)
+
+          Dir.glob(File.join(dir, "*.json")).each do |file|
+            data = JSON.parse(File.read(file))
+            if data["status"] == status.to_s
+              File.delete(file)
+              count += 1
+            end
+          rescue JSON::ParserError
+            next
+          end
+        end
+
+        count
+      end
+
+      # Re-queue failed messages (under max_retries) back to pending.
+      # Returns the number of jobs re-queued.
+      def retry_failed(topic, max_retries: 3)
+        return 0 unless Dir.exist?(@dead_letter_dir)
+
+        dir = topic_path(topic)
+        FileUtils.mkdir_p(dir)
+        count = 0
+
+        # Dead letter directory contains messages that the Consumer moved there.
+        # Only retry those whose attempts are under max_retries.
+        Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
+          data = JSON.parse(File.read(file))
+          next unless data["topic"] == topic.to_s
+          next if (data["attempts"] || 0) >= max_retries
+
+          data["status"] = "pending"
+          msg = Tina4::QueueMessage.new(
+            topic: data["topic"],
+            payload: data["payload"],
+            id: data["id"]
+          )
+          enqueue(msg)
+          File.delete(file)
+          count += 1
+        rescue JSON::ParserError
+          next
+        end
+
+        count
+      end
+
       private
 
       def topic_path(topic)