fiber_job 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b63b1dfdccf756e958f7cce41e450ad36ac82333a4d4a4231fe80e71cb86483
-  data.tar.gz: '014148d099b5aa2a52d76d0cc2fdd3b26c427c3e978769bd6bdaaa0f9dbd34c9'
+  metadata.gz: 2a6d673a0a6c62ea5c97e63e64b19d29934fc363ea2ebbf6e181acbc919e90a7
+  data.tar.gz: 77aece8ed8222b313efb850b921d129f3cb515b935f2d61afcb0035118057d40
 SHA512:
-  metadata.gz: f0ead6722ddbc4c8ee6d8247f2d68d5ebd06307c1628873c66df7dbffb095f27cd21f2e26bbde00c12949a4ff5f2447cde609f635a13eff5ea225a3c70155c84
-  data.tar.gz: bcc920d7436747ca15366a9277ebdd76a3e2d29736a4f6529a0f078c6c74165cdd2fae1996a7621f7bdc846fa3cbb8fecc23e30fa5a17fec9cb4a4d448e13427
+  metadata.gz: e52875a8ca6776d98ce3c54be8d530613322c8b8f8c2a2a8d3d78ec3347cc7aba06ef45bf25de335931d8f1197059ccf3f0fc2d11300a0330d364a749f8a0f51
+  data.tar.gz: 5beb000f04496a73cd33f9ccffde20462f2f74aff2a58ebc3f180bbb526e70635cdc91835335c74ba1f68639ef212d96527b7415a4d05bae4f0510e57e44edf0

data/lib/fiber_job/client.rb

@@ -31,7 +31,9 @@ module FiberJob
     #
     # @raise [ArgumentError] If job_class is not a valid job class
     def self.enqueue(job_class, *args)
+      jid = JID.generate
       payload = {
+        'jid' => jid,
         'class' => job_class.name,
         'args' => args,
         'enqueued_at' => Time.now.to_f
@@ -39,6 +41,8 @@ module FiberJob
 
       queue_name = job_class.queue
       Queue.push(queue_name, payload)
+
+      jid
     end
 
     # Enqueues a job for execution after a specified delay.
@@ -56,8 +60,10 @@ module FiberJob
     #
     # @raise [ArgumentError] If delay_seconds is negative or job_class is invalid
     def self.enqueue_in(delay_seconds, job_class, *args)
+      jid = JID.generate
       scheduled_at = Time.now.to_f + delay_seconds
       payload = {
+        'jid' => jid,
         'class' => job_class.name,
         'args' => args,
         'enqueued_at' => Time.now.to_f
@@ -66,7 +72,9 @@ module FiberJob
       queue_name = job_class.queue
       Queue.schedule(queue_name, payload, scheduled_at)
 
-      FiberJob.logger.info "Scheduled #{job_class.name} to run in #{delay_seconds}s"
+      FiberJob.logger.info "Scheduled #{job_class.name} (#{jid}) to run in #{delay_seconds}s"
+
+      jid
     end
 
     # Enqueues a job for execution at a specific time.
@@ -86,7 +94,9 @@ module FiberJob
     #
     # @raise [ArgumentError] If timestamp is in the past or job_class is invalid
     def self.enqueue_at(timestamp, job_class, *args)
+      jid = JID.generate
       payload = {
+        'jid' => jid,
         'class' => job_class.name,
         'args' => args,
         'enqueued_at' => Time.now.to_f
@@ -95,7 +105,9 @@ module FiberJob
       queue_name = job_class.queue
       Queue.schedule(queue_name, payload, timestamp.to_f)
 
-      FiberJob.logger.info "Scheduled #{job_class.name} to run at #{Time.at(timestamp)}"
+      FiberJob.logger.info "Scheduled #{job_class.name} (#{jid}) to run at #{Time.at(timestamp)}"
+
+      jid
     end
   end
 end

data/lib/fiber_job/cron.rb

@@ -3,19 +3,19 @@
 module FiberJob
   class Cron
     def self.redis
-      @redis ||= Redis.new(url: FiberJob.config.redis_url)
+      @redis ||= RedisClient.new(url: FiberJob.config.redis_url)
     end
 
     def self.register(cron_job_class)
       job_name = cron_job_class.name
       cron_expression = cron_job_class.cron_expression
 
-      redis.hset('cron:jobs', job_name, JSON.dump({ 'class' => job_name,
+      redis.call('HSET', 'cron:jobs', job_name, JSON.dump({ 'class' => job_name,
                                                     'cron' => cron_expression,
                                                     'queue' => cron_job_class.new.queue,
                                                     'registered_at' => Time.now.to_f }))
 
-      unless redis.exists?("cron:next_run:#{job_name}")
+      unless redis.call('EXISTS', "cron:next_run:#{job_name}") > 0
         next_time = cron_job_class.next_run_time
         schedule_job(cron_job_class, next_time)
       end
@@ -27,35 +27,39 @@ module FiberJob
       job_name = cron_job_class.name
 
       # Set next run time
-      redis.set("cron:next_run:#{job_name}", run_time.to_f)
+      redis.call('SET', "cron:next_run:#{job_name}", run_time.to_f)
 
       # Add to sorted set for efficient scanning
-      redis.zadd('cron:schedule', run_time.to_f, job_name)
+      redis.call('ZADD', 'cron:schedule', run_time.to_f, job_name)
 
       FiberJob.logger.debug "Scheduled #{job_name} for #{run_time}"
     end
 
     def self.due_jobs(current_time = Time.now)
-      job_names = redis.zrangebyscore('cron:schedule', 0, current_time.to_f)
+      job_names = redis.call('ZRANGEBYSCORE', 'cron:schedule', 0, current_time.to_f)
 
       job_names.map do |job_name|
-        job_data = JSON.parse(redis.hget('cron:jobs', job_name))
+        job_data_raw = redis.call('HGET', 'cron:jobs', job_name)
+        job_data = job_data_raw ? JSON.parse(job_data_raw) : nil
         next unless job_data
 
-        redis.zrem('cron:schedule', job_name)
+        redis.call('ZREM', 'cron:schedule', job_name)
 
         job_data
       end.compact
     end
 
     def self.registered_jobs
-      jobs = redis.hgetall('cron:jobs')
+      jobs = redis.call('HGETALL', 'cron:jobs')
+      # Convert array response to hash
+      jobs = Hash[*jobs] if jobs.is_a?(Array)
       jobs.transform_values { |data| JSON.parse(data) }
     end
 
     def self.clear_all
-      redis.del('cron:jobs', 'cron:schedule')
-      redis.keys('cron:next_run:*').each { |key| redis.del(key) }
+      redis.call('DEL', 'cron:jobs', 'cron:schedule')
+      keys = redis.call('KEYS', 'cron:next_run:*')
+      keys.each { |key| redis.call('DEL', key) } unless keys.empty?
     end
   end
 end

data/lib/fiber_job/jid.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module FiberJob
+  # JID (Job ID) generation utilities for unique job identification.
+  # Provides methods to generate unique, sortable, and URL-safe job identifiers
+  # that can be used for tracking, logging, and job management operations.
+  #
+  # @example Generate a JID
+  #   jid = FiberJob::JID.generate
+  #   # => "01J4X8K2V3N9QRSTUVWXYZ1234"
+  #
+  # @example Extract timestamp from JID
+  #   timestamp = FiberJob::JID.timestamp(jid)
+  #   # => 2024-08-17 15:30:25 UTC
+  #
+  # @author FiberJob Team
+  # @since 1.1.0
+  class JID
+    # Base32 alphabet for ULID encoding (Crockford's Base32)
+    # Excludes ambiguous characters: 0, 1, I, L, O, U
+    ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'
+
+    # Length of the timestamp component in the JID (10 characters)
+    TIMESTAMP_LENGTH = 10
+
+    # Length of the random component in the JID (16 characters)  
+    RANDOM_LENGTH = 16
+
+    # Total length of a JID
+    TOTAL_LENGTH = TIMESTAMP_LENGTH + RANDOM_LENGTH
+
+    class << self
+      # Generates a new unique Job ID (JID).
+      # 
+      # JIDs are 26-character strings that combine:
+      # - 10-character timestamp component (millisecond precision)
+      # - 16-character random component
+      #
+      # This format ensures:
+      # - Lexicographical sortability by creation time
+      # - URL-safe characters only
+      # - Extremely low collision probability
+      # - Easy visual identification
+      #
+      # @param time [Time, nil] Optional time to use for timestamp (defaults to current time)
+      # @return [String] A 26-character unique job identifier
+      #
+      # @example Generate a JID
+      #   jid = FiberJob::JID.generate
+      #   # => "01J4X8K2V3N9QRSTUVWXYZ1234"
+      #
+      # @example Generate with specific time
+      #   specific_time = Time.parse("2024-01-01 00:00:00 UTC")
+      #   jid = FiberJob::JID.generate(specific_time)
+      #   # => "01HKPNQ2V3ABCDEFGHIJKLMNOP"
+      def generate(time = nil)
+        time ||= Time.now
+        timestamp_ms = (time.to_f * 1000).to_i
+
+        # Encode timestamp as 10-character base32 string
+        timestamp_part = encode_timestamp(timestamp_ms)
+        
+        # Generate 16-character random component
+        random_part = encode_random(16)
+
+        "#{timestamp_part}#{random_part}"
+      end
+
+      # Extracts the timestamp from a JID.
+      # 
+      # @param jid [String] The job ID to extract timestamp from
+      # @return [Time] The timestamp when the JID was generated
+      # @raise [ArgumentError] If JID format is invalid
+      #
+      # @example Extract timestamp
+      #   jid = "01J4X8K2V3N9QRSTUVWXYZ1234"
+      #   timestamp = FiberJob::JID.timestamp(jid)
+      #   # => 2024-08-17 15:30:25 UTC
+      def timestamp(jid)
+        validate_format!(jid)
+        
+        timestamp_part = jid[0, TIMESTAMP_LENGTH]
+        timestamp_ms = decode_timestamp(timestamp_part)
+        
+        Time.at(timestamp_ms / 1000.0)
+      end
+
+      # Validates JID format.
+      # 
+      # @param jid [String] The job ID to validate
+      # @return [Boolean] True if valid, false otherwise
+      #
+      # @example Validate JID
+      #   FiberJob::JID.valid?("01J4X8K2V3N9QRSTUVWXYZ1234")  # => true
+      #   FiberJob::JID.valid?("invalid")                      # => false
+      def valid?(jid)
+        return false unless jid.is_a?(String)
+        return false unless jid.length == TOTAL_LENGTH
+        return false unless jid.match?(/\A[#{ENCODING}]+\z/)
+        
+        # Additional validation: timestamp should be reasonable
+        begin
+          ts = timestamp(jid)
+          # JID timestamp should be within reasonable bounds
+          ts > Time.new(2020, 1, 1) && ts < Time.now + 86400 # Not more than 1 day in future
+        rescue ArgumentError
+          false
+        end
+      end
+
+      # Generates a batch of unique JIDs efficiently.
+      # Ensures no duplicates within the batch by incrementing timestamp
+      # microseconds when necessary.
+      #
+      # @param count [Integer] Number of JIDs to generate
+      # @param time [Time, nil] Base time for generation (defaults to current time)
+      # @return [Array<String>] Array of unique JIDs
+      #
+      # @example Generate batch of JIDs
+      #   jids = FiberJob::JID.generate_batch(5)
+      #   # => ["01J4X8K2V3...", "01J4X8K2V4...", ...]
+      def generate_batch(count, time = nil)
+        base_time = time || Time.now
+        jids = []
+
+        count.times do |i|
+          # Ensure uniqueness by adding microseconds offset
+          jid_time = Time.at(base_time.to_f + (i * 0.001))
+          jids << generate(jid_time)
+        end
+
+        jids
+      end
+
+      private
+
+      # Encodes a timestamp (in milliseconds) to a base32 string
+      def encode_timestamp(timestamp_ms)
+        encode_number(timestamp_ms, TIMESTAMP_LENGTH)
+      end
+
+      # Encodes a number to base32 with fixed length
+      def encode_number(number, length)
+        result = ''
+        
+        length.times do
+          result = ENCODING[number % 32] + result
+          number /= 32
+        end
+        
+        result
+      end
+
+      # Generates random base32 string of specified length
+      def encode_random(length)
+        result = ''
+        
+        length.times do
+          result += ENCODING[SecureRandom.random_number(32)]
+        end
+        
+        result
+      end
+
+      # Decodes timestamp from base32 string
+      def decode_timestamp(timestamp_str)
+        result = 0
+        
+        timestamp_str.each_char do |char|
+          result = result * 32 + ENCODING.index(char)
+        end
+        
+        result
+      end
+
+      # Validates JID format and raises error if invalid
+      def validate_format!(jid)
+        raise ArgumentError, "JID must be #{TOTAL_LENGTH} characters" unless jid.length == TOTAL_LENGTH
+        raise ArgumentError, "JID contains invalid characters" unless jid.match?(/\A[#{ENCODING}]+\z/)
+      end
+    end
+  end
+end

data/lib/fiber_job/job.rb

@@ -43,9 +43,11 @@ module FiberJob
     #   @return [Integer] Job priority (higher numbers = higher priority)
     # @!attribute [rw] timeout
     #   @return [Integer] Maximum execution time in seconds before timeout
+    # @!attribute [rw] jid
+    #   @return [String, nil] Unique job identifier
     # @!attribute [r] config
     #   @return [FiberJob::Config] Configuration object for this job instance
-    attr_accessor :queue, :retry_count, :max_retries, :priority, :timeout
+    attr_accessor :queue, :retry_count, :max_retries, :priority, :timeout, :jid
     attr_reader :config
 
     # Initializes a new job instance with default configuration.

data/lib/fiber_job/queue.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'redis'
+require 'redis_client'
 require 'connection_pool'
 
 module FiberJob
@@ -43,7 +43,7 @@ module FiberJob
     # @return [ConnectionPool] The Redis connection pool
     def self.redis_pool
       @redis_pool ||= ConnectionPool.new(size: config.pool_size, timeout: 5) do
-        Redis.new(url: config.redis_url)
+        RedisClient.new(url: config.redis_url)
       end
     end
 
@@ -51,19 +51,19 @@ module FiberJob
     # @deprecated Use redis_pool.with { |redis| ... } instead for better performance
     # Creates a new connection if one doesn't exist.
     #
-    # @return [Redis] The shared Redis connection
+    # @return [RedisClient] The shared Redis connection
     def self.redis
-      @redis ||= Redis.new(url: config.redis_url)
+      @redis ||= RedisClient.new(url: config.redis_url)
     end
 
     # Creates a new Redis connection for fiber-safe operations.
     # @deprecated Use redis_pool.with { |redis| ... } instead for better performance
     # Used when concurrent operations need separate connections.
     #
-    # @return [Redis] A new Redis connection instance
+    # @return [RedisClient] A new Redis connection instance
     def self.redis_connection
       # Create a new Redis connection for fiber-safe operations
-      Redis.new(url: config.redis_url)
+      RedisClient.new(url: config.redis_url)
     end
 
     # Adds a job to the specified queue for immediate processing.
@@ -78,7 +78,7 @@ module FiberJob
     #   payload = { 'class' => 'EmailJob', 'args' => [123, 'message'] }
     #   FiberJob::Queue.push(:default, payload)
     def self.push(queue_name, payload)
-      redis_pool.with { |redis| redis.lpush("queue:#{queue_name}", JSON.dump(payload)) }
+      redis_pool.with { |redis| redis.call("LPUSH", "queue:#{queue_name}", JSON.dump(payload)) }
     end
 
     # Adds a job to the head of the queue for priority processing.
@@ -92,7 +92,7 @@ module FiberJob
     #   FiberJob::Queue.push_priority(:default, urgent_job_data)
     def self.push_priority(queue_name, payload)
       # Add to the head of the queue for priority execution
-      redis_pool.with { |redis| redis.rpush("queue:#{queue_name}", JSON.dump(payload)) }
+      redis_pool.with { |redis| redis.call("RPUSH", "queue:#{queue_name}", JSON.dump(payload)) }
     end
 
     # Removes and returns a job from the specified queue.
@@ -101,7 +101,7 @@ module FiberJob
     #
     # @param queue_name [String, Symbol] Name of the source queue
     # @param timeout [Float] Maximum time to wait for a job (default: 0.1)
-    # @param redis_conn [Redis, nil] Optional Redis connection to use (bypasses pool)
+    # @param redis_conn [RedisClient, nil] Optional Redis connection to use (bypasses pool)
     # @return [Hash, nil] Job data hash or nil if timeout reached
     #
     # @example Pop from queue with timeout
@@ -112,10 +112,10 @@ module FiberJob
     def self.pop(queue_name, timeout: 0.1, redis_conn: nil)
       data = if redis_conn
                # Use provided connection (for legacy compatibility)
-               redis_conn.brpop("queue:#{queue_name}", timeout: timeout)
+               redis_conn.call("BRPOP", "queue:#{queue_name}", timeout)
              else
                # Use connection pool for better performance
-               redis_pool.with { |redis| redis.brpop("queue:#{queue_name}", timeout: timeout) }
+               redis_pool.with { |redis| redis.call("BRPOP", "queue:#{queue_name}", timeout) }
              end
       data ? JSON.parse(data[1]) : nil
     end
@@ -133,7 +133,7 @@ module FiberJob
     #   future_time = Time.now.to_f + 3600  # 1 hour from now
     #   FiberJob::Queue.schedule(:default, job_data, future_time)
     def self.schedule(queue_name, payload, scheduled_at)
-      redis_pool.with { |redis| redis.zadd("schedule:#{queue_name}", scheduled_at, JSON.dump(payload)) }
+      redis_pool.with { |redis| redis.call("ZADD", "schedule:#{queue_name}", scheduled_at, JSON.dump(payload)) }
     end
 
     # Schedules a job with priority for execution at a specific time.
@@ -146,7 +146,7 @@ module FiberJob
     def self.schedule_priority(queue_name, payload, scheduled_at)
       # Mark as priority retry for head-of-queue execution
       priority_payload = payload.merge('priority_retry' => true)
-      redis_pool.with { |redis| redis.zadd("schedule:#{queue_name}", scheduled_at, JSON.dump(priority_payload)) }
+      redis_pool.with { |redis| redis.call("ZADD", "schedule:#{queue_name}", scheduled_at, JSON.dump(priority_payload)) }
     end
 
     # Processes scheduled jobs that are ready for execution.
@@ -162,22 +162,22 @@ module FiberJob
     def self.scheduled_jobs(queue_name)
       redis_pool.with do |redis|
         now = Time.now.to_f
-        jobs = redis.zrangebyscore("schedule:#{queue_name}", 0, now)
+        jobs = redis.call("ZRANGEBYSCORE", "schedule:#{queue_name}", 0, now)
 
         return 0 if jobs.empty?
 
         # Use pipeline for better performance with multiple operations
         redis.pipelined do |pipeline|
           jobs.each do |job_json|
-            pipeline.zrem("schedule:#{queue_name}", job_json)
+            pipeline.call("ZREM", "schedule:#{queue_name}", job_json)
             job_data = JSON.parse(job_json)
 
             # Use priority queue for retries
             if job_data['priority_retry']
               job_data.delete('priority_retry') # Clean up the flag
-              pipeline.rpush("queue:#{queue_name}", JSON.dump(job_data))
+              pipeline.call("RPUSH", "queue:#{queue_name}", JSON.dump(job_data))
             else
-              pipeline.lpush("queue:#{queue_name}", JSON.dump(job_data))
+              pipeline.call("LPUSH", "queue:#{queue_name}", JSON.dump(job_data))
             end
           end
         end
@@ -199,9 +199,9 @@ module FiberJob
     def self.stats(queue_name)
       redis_pool.with do |redis|
         results = redis.pipelined do |pipeline|
-          pipeline.llen("queue:#{queue_name}")
-          pipeline.zcard("schedule:#{queue_name}")
-          pipeline.get("processing:#{queue_name}")
+          pipeline.call("LLEN", "queue:#{queue_name}")
+          pipeline.call("ZCARD", "schedule:#{queue_name}")
+          pipeline.call("GET", "processing:#{queue_name}")
         end
 
         {
@@ -231,7 +231,7 @@ module FiberJob
                                          'error' => error.message,
                                          'backtrace' => error.backtrace&.first(10)
                                        })
-      redis_pool.with { |redis| redis.lpush('failed', JSON.dump(failed_job_data)) }
+      redis_pool.with { |redis| redis.call("LPUSH", 'failed', JSON.dump(failed_job_data)) }
     end
 
     # Retrieves all failed jobs for inspection and debugging.
@@ -243,8 +243,165 @@ module FiberJob
     #   failed.each { |job| puts "Failed: #{job['class']} - #{job['error']}" }
     def self.failed_jobs
       redis_pool.with do |redis|
-        redis.lrange('failed', 0, -1).map { |job_json| JSON.parse(job_json) }
+        redis.call("LRANGE", 'failed', 0, -1).map { |job_json| JSON.parse(job_json) }
       end
     end
+
+    # Finds a job by its JID across all queues and scheduled jobs.
+    # Searches through active queues, scheduled jobs, and failed jobs.
+    #
+    # @param jid [String] The job ID to search for
+    # @return [Hash, nil] Job data if found, nil otherwise
+    #
+    # @example Find job by JID
+    #   job = FiberJob::Queue.find_job("01J4X8K2V3N9QRSTUVWXYZ1234")
+    #   if job
+    #     puts "Found job: #{job['class']} in #{job['status']}"
+    #   end
+    def self.find_job(jid)
+      return nil unless jid
+
+      redis_pool.with do |redis|
+        # Search in all known queues
+        config.queues.each do |queue_name|
+          # Check active queue
+          queue_jobs = redis.call("LRANGE", "queue:#{queue_name}", 0, -1)
+          queue_jobs.each do |job_json|
+            job_data = JSON.parse(job_json)
+            if job_data['jid'] == jid
+              return job_data.merge('status' => 'queued', 'queue' => queue_name)
+            end
+          end
+
+          # Check scheduled jobs
+          scheduled_jobs = redis.call("ZRANGE", "schedule:#{queue_name}", 0, -1)
+          scheduled_jobs.each do |job_json|
+            job_data = JSON.parse(job_json)
+            if job_data['jid'] == jid
+              return job_data.merge('status' => 'scheduled', 'queue' => queue_name)
+            end
+          end
+        end
+
+        # Check failed jobs
+        failed_jobs = redis.call("LRANGE", 'failed', 0, -1)
+        failed_jobs.each do |job_json|
+          job_data = JSON.parse(job_json)
+          if job_data['jid'] == jid
+            return job_data.merge('status' => 'failed')
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Cancels a job by removing it from queues.
+    # Can cancel jobs that are queued or scheduled, but not currently processing.
+    #
+    # @param jid [String] The job ID to cancel
+    # @return [Boolean] True if job was found and cancelled, false otherwise
+    #
+    # @example Cancel a job
+    #   success = FiberJob::Queue.cancel_job("01J4X8K2V3N9QRSTUVWXYZ1234")
+    #   puts success ? "Job cancelled" : "Job not found or already processing"
+    def self.cancel_job(jid)
+      return false unless jid
+
+      redis_pool.with do |redis|
+        # Search and remove from all known queues
+        config.queues.each do |queue_name|
+          # Check active queue
+          queue_jobs = redis.call("LRANGE", "queue:#{queue_name}", 0, -1)
+          queue_jobs.each_with_index do |job_json, index|
+            job_data = JSON.parse(job_json)
+            if job_data['jid'] == jid
+              # Remove from queue by index (note: LREM removes by value)
+              redis.call("LREM", "queue:#{queue_name}", 1, job_json)
+              return true
+            end
+          end
+
+          # Check scheduled jobs
+          scheduled_jobs = redis.call("ZRANGE", "schedule:#{queue_name}", 0, -1)
+          scheduled_jobs.each do |job_json|
+            job_data = JSON.parse(job_json)
+            if job_data['jid'] == jid
+              redis.call("ZREM", "schedule:#{queue_name}", job_json)
+              return true
+            end
+          end
+        end
+      end
+
+      false
+    end
+
+    # Gets the status of a job by its JID.
+    # Possible statuses: 'queued', 'scheduled', 'failed', 'not_found'
+    #
+    # @param jid [String] The job ID to check
+    # @return [String] Job status
+    #
+    # @example Check job status
+    #   status = FiberJob::Queue.job_status("01J4X8K2V3N9QRSTUVWXYZ1234")
+    #   case status
+    #   when 'queued'
+    #     puts "Job is waiting to be processed"
+    #   when 'scheduled'
+    #     puts "Job is scheduled for future execution"
+    #   when 'failed'
+    #     puts "Job failed permanently"
+    #   when 'not_found'
+    #     puts "Job not found (may have completed successfully)"
+    #   end
+    def self.job_status(jid)
+      job = find_job(jid)
+      job ? job['status'] : 'not_found'
+    end
+
+    # Lists all jobs with their JIDs and statuses.
+    # Useful for debugging and monitoring.
+    #
+    # @param limit [Integer] Maximum number of jobs to return per status (default: 100)
+    # @return [Hash] Hash with status as keys and arrays of job data as values
+    #
+    # @example List all jobs
+    #   jobs = FiberJob::Queue.list_jobs(limit: 50)
+    #   jobs['queued'].each { |job| puts "Queued: #{job['class']} [#{job['jid']}]" }
+    def self.list_jobs(limit: 100)
+      result = {
+        'queued' => [],
+        'scheduled' => [],
+        'failed' => []
+      }
+
+      redis_pool.with do |redis|
+        # Get queued jobs
+        config.queues.each do |queue_name|
+          queue_jobs = redis.call("LRANGE", "queue:#{queue_name}", 0, limit - 1)
+          queue_jobs.each do |job_json|
+            job_data = JSON.parse(job_json)
+            result['queued'] << job_data.merge('queue' => queue_name)
+          end
+
+          # Get scheduled jobs
+          scheduled_jobs = redis.call("ZRANGE", "schedule:#{queue_name}", 0, limit - 1)
+          scheduled_jobs.each do |job_json|
+            job_data = JSON.parse(job_json)
+            result['scheduled'] << job_data.merge('queue' => queue_name)
+          end
+        end
+
+        # Get failed jobs
+        failed_jobs = redis.call("LRANGE", 'failed', 0, limit - 1)
+        failed_jobs.each do |job_json|
+          job_data = JSON.parse(job_json)
+          result['failed'] << job_data
+        end
+      end
+
+      result
+    end
   end
 end

data/lib/fiber_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FiberJob
-  VERSION = '0.2.4'
+  VERSION = '0.2.6'
 end

data/lib/fiber_job/worker.rb

@@ -116,6 +116,10 @@ module FiberJob
       job = job_class.new
 
       job.retry_count = job_data['retry_count'] || 0
+      job.jid = job_data['jid']
+
+      jid_info = job.jid ? " [#{job.jid}]" : ""
+      FiberJob.logger.info "Starting #{job_class.name}#{jid_info}"
 
       begin
         Timeout.timeout(job.timeout) do
@@ -123,7 +127,10 @@ module FiberJob
           args << job_data['enqueued_at'] if job_data['enqueued_at']
           job.perform(*args)
         end
+        
+        FiberJob.logger.info "Completed #{job_class.name}#{jid_info}"
       rescue => e
+        FiberJob.logger.error "Failed #{job_class.name}#{jid_info}: #{e.message}"
         handle_failure(job, job_data, e)
       end
     end
@@ -146,6 +153,8 @@ module FiberJob
     end
 
     def handle_failure(job, job_data, error)
+      jid_info = job.jid ? " [#{job.jid}]" : ""
+      
       if job.retry_count < job.max_retries
         job.retry_count += 1
         delay = job.retry_delay(job.retry_count)
@@ -153,7 +162,7 @@ module FiberJob
         retry_job_data = job_data.dup
         retry_job_data['retry_count'] = job.retry_count
 
-        message = "#{job.class} failed: #{error.message}. "
+        message = "#{job.class}#{jid_info} failed: #{error.message}. "
         message += "Retrying in #{delay.round(1)}s (attempt #{job.retry_count}/#{job.max_retries})"
         FiberJob.logger.warn message
 
@@ -163,7 +172,7 @@ module FiberJob
           Queue.schedule(job.queue, retry_job_data, Time.now.to_f + delay)
         end
       else
-        FiberJob.logger.error "#{job.class} permanently failed after #{job.max_retries} retries: #{error.message}"
+        FiberJob.logger.error "#{job.class}#{jid_info} permanently failed after #{job.max_retries} retries: #{error.message}"
         Queue.store_failed_job(job_data, error)
       end
     end

data/lib/fiber_job.rb

@@ -3,6 +3,7 @@
 require_relative 'fiber_job/version'
 require_relative 'fiber_job/config'
 require_relative 'fiber_job/logger'
+require_relative 'fiber_job/jid'
 require_relative 'fiber_job/job'
 require_relative 'fiber_job/queue'
 require_relative 'fiber_job/worker'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fiber_job
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Caio Mendonca
@@ -14,6 +14,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.26'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.26.0
   type: :runtime
@@ -21,36 +24,71 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.26'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.26.0
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: connection_pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.4.1
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.4.1
+        version: '2.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
-  name: connection_pool
+  name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.3
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.5.3
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+- !ruby/object:Gem::Dependency
+  name: hiredis-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.24'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.24.0
 executables:
 - fiber_job
 extensions: []
@@ -66,6 +104,7 @@ files:
 - lib/fiber_job/cron.rb
 - lib/fiber_job/cron_job.rb
 - lib/fiber_job/cron_parser.rb
+- lib/fiber_job/jid.rb
 - lib/fiber_job/job.rb
 - lib/fiber_job/logger.rb
 - lib/fiber_job/process_manager.rb
@@ -92,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Experimental High-performance, Redis-based background job processing library
   for Ruby built on fiber-based concurrency