resqueue 1.0.0

data/lib/resque/failure/airbrake.rb

@@ -0,0 +1,33 @@
+begin
+  require 'airbrake'
+rescue LoadError
+  raise "Can't find 'airbrake' gem. Please add it to your Gemfile or install it."
+end
+
+module Resque
+  module Failure
+    class Airbrake < Base
+      def self.configure(&block)
+        Resque.logger.warn "This actually sets global Airbrake configuration, " \
+          "which is probably not what you want. This will be gone in 2.0."
+        Resque::Failure.backend = self
+        ::Airbrake.configure(&block)
+      end
+
+      def self.count(queue = nil, class_name = nil)
+        # We can't get the total # of errors from Airbrake so we fake it
+        # by asking Resque how many errors it has seen.
+        Stat[:failed]
+      end
+
+      def save
+        ::Airbrake.notify(exception,
+            :parameters => {
+            :payload_class => payload['class'].to_s,
+            :payload_args => payload['args'].inspect
+            }
+          )
+      end
+    end
+  end
+end

data/lib/resque/failure/base.rb

@@ -0,0 +1,73 @@
+module Resque
+  module Failure
+    # All Failure classes are expected to subclass Base.
+    #
+    # When a job fails, a new instance of your Failure backend is created
+    # and #save is called.
+    class Base
+      # The exception object raised by the failed job
+      attr_accessor :exception
+
+      # The worker object who detected the failure
+      attr_accessor :worker
+
+      # The string name of the queue from which the failed job was pulled
+      attr_accessor :queue
+
+      # The payload object associated with the failed job
+      attr_accessor :payload
+
+      def initialize(exception, worker, queue, payload)
+        @exception = exception
+        @worker    = worker
+        @queue     = queue
+        @payload   = payload
+      end
+
+      # When a job fails, a new instance of your Failure backend is created
+      # and #save is called.
+      #
+      # This is where you POST or PUT or whatever to your Failure service.
+      def save
+      end
+
+      # The number of failures.
+      def self.count(queue = nil, class_name = nil)
+        0
+      end
+
+      # Returns an array of all available failure queues
+      def self.queues
+        []
+      end
+
+      # Returns a paginated array of failure objects.
+      def self.all(offset = 0, limit = 1, queue = nil)
+        []
+      end
+
+      # Iterate across failed objects
+      def self.each(*args)
+      end
+
+      # A URL where someone can go to view failures.
+      def self.url
+      end
+
+      # Clear all failure objects
+      def self.clear(*args)
+      end
+
+      def self.requeue(*args)
+      end
+
+      def self.remove(*args)
+      end
+
+      # Logging!
+      def log(message)
+        @worker.log(message)
+      end
+    end
+  end
+end

data/lib/resque/failure/multiple.rb

@@ -0,0 +1,68 @@
+module Resque
+  module Failure
+    # A Failure backend that uses multiple backends
+    # delegates all queries to the first backend
+    class Multiple < Base
+
+      class << self
+        attr_accessor :classes
+      end
+
+      def self.configure
+        yield self
+        Resque::Failure.backend = self
+      end
+
+      def initialize(*args)
+        super
+        @backends = self.class.classes.map {|klass| klass.new(*args)}
+      end
+
+      def save
+        @backends.each(&:save)
+      end
+
+      # The number of failures.
+      def self.count(*args)
+        classes.first.count(*args)
+      end
+
+      # Returns an array of all available failure queues
+      def self.queues
+        classes.first.queues
+      end
+
+      # Returns a paginated array of failure objects.
+      def self.all(*args)
+        classes.first.all(*args)
+      end
+
+      # Iterate across failed objects
+      def self.each(*args, &block)
+        classes.first.each(*args, &block)
+      end
+
+      # A URL where someone can go to view failures.
+      def self.url
+        classes.first.url
+      end
+
+      # Clear all failure objects
+      def self.clear(*args)
+        classes.first.clear(*args)
+      end
+
+      def self.requeue(*args)
+        classes.first.requeue(*args)
+      end
+
+      def self.requeue_all
+        classes.first.requeue_all
+      end
+
+      def self.remove(index, queue)
+        classes.each { |klass| klass.remove(index) }
+      end
+    end
+  end
+end

data/lib/resque/failure/redis.rb

@@ -0,0 +1,128 @@
+module Resque
+  module Failure
+    # A Failure backend that stores exceptions in Redis. Very simple but
+    # works out of the box, along with support in the Resque web app.
+    class Redis < Base
+
+      def data_store
+        Resque.data_store
+      end
+
+      def self.data_store
+        Resque.data_store
+      end
+
+      def save
+        data = {
+          :failed_at => UTF8Util.clean(Time.now.strftime("%Y/%m/%d %H:%M:%S %Z")),
+          :payload   => payload,
+          :exception => exception.class.to_s,
+          :error     => UTF8Util.clean(exception.to_s),
+          :backtrace => filter_backtrace(Array(exception.backtrace)),
+          :worker    => worker.to_s,
+          :queue     => queue
+        }
+        data = Resque.encode(data)
+        data_store.push_to_failed_queue(data)
+      end
+
+      def self.count(queue = nil, class_name = nil)
+        check_queue(queue)
+
+        if class_name
+          n = 0
+          each(0, count(queue), queue, class_name) { n += 1 } 
+          n
+        else
+          data_store.num_failed
+        end
+      end
+
+      def self.queues
+        data_store.failed_queue_names
+      end
+
+      def self.all(offset = 0, limit = 1, queue = nil)
+        check_queue(queue)
+        Resque.list_range(:failed, offset, limit)
+      end
+
+      def self.each(offset = 0, limit = self.count, queue = :failed, class_name = nil, order = 'desc')
+        if class_name
+          original_limit = limit
+          limit = count
+        end
+        all_items = limit == 1 ? [all(offset,limit,queue)] : Array(all(offset, limit, queue))
+        reversed = false
+        if order.eql? 'desc'
+          all_items.reverse!
+          reversed = true
+        end
+        all_items.each_with_index do |item, i|
+          if !class_name || (item['payload'] && item['payload']['class'] == class_name && (original_limit -= 1) >= 0)
+            if reversed
+              id = (all_items.length - 1) + (offset - i)
+            else
+              id = offset + i
+            end
+            yield id, item
+          end
+        end
+      end
+
+      def self.clear(queue = nil)
+        check_queue(queue)
+        data_store.clear_failed_queue
+      end
+
+      def self.requeue(id, queue = nil)
+        check_queue(queue)
+        item = all(id)
+        item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
+        data_store.update_item_in_failed_queue(id,Resque.encode(item))
+        Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
+      end
+
+      def self.remove(id, queue = nil)
+        check_queue(queue)
+        data_store.remove_from_failed_queue(id, queue)
+      end
+
+      def self.requeue_queue(queue)
+        i = 0
+        while job = all(i)
+           requeue(i) if job['queue'] == queue
+           i += 1
+        end
+      end
+
+      def self.requeue_all
+        count.times do |num|
+          requeue(num)
+        end
+      end
+
+      def self.remove_queue(queue)
+        i = 0
+        while job = all(i)
+          if job['queue'] == queue
+            # This will remove the failure from the array so do not increment the index.
+            remove(i)
+          else
+            i += 1
+          end
+        end
+      end
+
+      def self.check_queue(queue)
+        raise ArgumentError, "invalid queue: #{queue}" if queue && queue.to_s != "failed"
+      end
+
+      def filter_backtrace(backtrace)
+        index = backtrace.index { |item| item.include?('/lib/resque/job.rb') }
+        backtrace.first(index.to_i)
+      end
+
+    end
+  end
+end

data/lib/resque/failure/redis_multi_queue.rb

@@ -0,0 +1,104 @@
+module Resque
+  module Failure
+    # A Failure backend that stores exceptions in Redis. Very simple but
+    # works out of the box, along with support in the Resque web app.
+    class RedisMultiQueue < Base
+
+      def data_store
+        Resque.data_store
+      end
+
+      def self.data_store
+        Resque.data_store
+      end
+
+      def save
+        data = {
+          :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S %Z"),
+          :payload   => payload,
+          :exception => exception.class.to_s,
+          :error     => UTF8Util.clean(exception.to_s),
+          :backtrace => filter_backtrace(Array(exception.backtrace)),
+          :worker    => worker.to_s,
+          :queue     => queue
+        }
+        data = Resque.encode(data)
+        data_store.push_to_failed_queue(data,Resque::Failure.failure_queue_name(queue))
+      end
+
+      def self.count(queue = nil, class_name = nil)
+        if queue
+          if class_name
+            n = 0
+            each(0, count(queue), queue, class_name) { n += 1 } 
+            n
+          else
+            data_store.num_failed(queue).to_i
+          end
+        else
+          total = 0
+          queues.each { |q| total += count(q) }
+          total
+        end
+      end
+
+      def self.all(offset = 0, limit = 1, queue = :failed)
+        Resque.list_range(queue, offset, limit)
+      end
+
+      def self.queues
+        data_store.failed_queue_names(:failed_queues)
+      end
+
+      def self.each(offset = 0, limit = self.count, queue = :failed, class_name = nil, order = 'desc')
+        items = all(offset, limit, queue)
+        items = [items] unless items.is_a? Array
+        reversed = false
+        if order.eql? 'desc'
+          items.reverse!
+          reversed = true
+        end
+        items.each_with_index do |item, i|
+          if !class_name || (item['payload'] && item['payload']['class'] == class_name)
+            id = reversed ? (items.length - 1) - (offset + i) : offset + i
+            yield id, item
+          end
+        end
+      end
+
+      def self.clear(queue = :failed)
+        queues = queue ? Array(queue) : self.queues
+        queues.each { |queue| data_store.clear_failed_queue(queue) }
+      end
+
+      def self.requeue(id, queue = :failed)
+        item = all(id, 1, queue)
+        item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
+        data_store.update_item_in_failed_queue(id,Resque.encode(item),queue)
+        Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
+      end
+
+      def self.remove(id, queue = :failed)
+        data_store.remove_from_queue(id,queue)
+      end
+
+      def self.requeue_queue(queue)
+        failure_queue = Resque::Failure.failure_queue_name(queue)
+        each(0, count(failure_queue), failure_queue) { |id, _| requeue(id, failure_queue) }
+      end
+
+      def self.requeue_all
+        queues.each { |queue| requeue_queue(Resque::Failure.job_queue_name(queue)) }
+      end
+
+      def self.remove_queue(queue)
+        data_store.remove_failed_queue(Resque::Failure.failure_queue_name(queue))
+      end
+
+      def filter_backtrace(backtrace)
+        index = backtrace.index { |item| item.include?('/lib/resque/job.rb') }
+        backtrace.first(index.to_i)
+      end
+    end
+  end
+end

data/lib/resque/helpers.rb

@@ -0,0 +1,48 @@
+require 'multi_json'
+
+# OkJson won't work because it doesn't serialize symbols
+# in the same way yajl and json do.
+if MultiJson.respond_to?(:adapter)
+  raise "Please install the yajl-ruby or json gem" if MultiJson.adapter.to_s == 'MultiJson::Adapters::OkJson'
+elsif MultiJson.respond_to?(:engine)
+  raise "Please install the yajl-ruby or json gem" if MultiJson.engine.to_s == 'MultiJson::Engines::OkJson'
+end
+
+module Resque
+  # Methods used by various classes in Resque.
+  module Helpers
+    class DecodeException < StandardError; end
+
+    # Direct access to the Redis instance.
+    def redis
+      # No infinite recursions, please.
+      # Some external libraries depend on Resque::Helpers being mixed into
+      # Resque, but this method causes recursions. If we have a super method,
+      # assume it is canonical. (see #1150)
+      return super if defined?(super)
+
+      Resque.redis
+    end
+
+    # Given a Ruby object, returns a string suitable for storage in a
+    # queue.
+    def encode(object)
+      Resque.encode(object)
+    end
+
+    # Given a string, returns a Ruby object.
+    def decode(object)
+      Resque.decode(object)
+    end
+
+    # Given a word with dashes, returns a camel cased version of it.
+    def classify(dashed_word)
+      Resque.classify(dashed_word)
+    end
+
+    # Tries to find a constant with the name specified in the argument string
+    def constantize(camel_cased_word)
+      Resque.constantize(camel_cased_word)
+    end
+  end
+end