tr_resque 1.20.1

data/lib/resque/errors.rb

@@ -0,0 +1,10 @@
+module Resque
+  # Raised whenever we need a queue but none is provided.
+  class NoQueueError < RuntimeError; end
+
+  # Raised when trying to create a job without a class
+  class NoClassError < RuntimeError; end
+
+  # Raised when a worker was killed while processing a job.
+  class DirtyExit < RuntimeError; end
+end

data/lib/resque/failure.rb

@@ -0,0 +1,96 @@
+module Resque
+  # The Failure module provides an interface for working with different
+  # failure backends.
+  #
+  # You can use it to query the failure backend without knowing which specific
+  # backend is being used. For instance, the Resque web app uses it to display
+  # stats and other information.
+  module Failure
+    # Creates a new failure, which is delegated to the appropriate backend.
+    #
+    # Expects a hash with the following keys:
+    #   :exception - The Exception object
+    #   :worker    - The Worker object who is reporting the failure
+    #   :queue     - The string name of the queue from which the job was pulled
+    #   :payload   - The job's payload
+    def self.create(options = {})
+      backend.new(*options.values_at(:exception, :worker, :queue, :payload)).save
+    end
+
+    #
+    # Sets the current backend. Expects a class descendent of
+    # `Resque::Failure::Base`.
+    #
+    # Example use:
+    #   require 'resque/failure/hoptoad'
+    #   Resque::Failure.backend = Resque::Failure::Hoptoad
+    def self.backend=(backend)
+      @backend = backend
+    end
+
+    # Returns the current backend class. If none has been set, falls
+    # back to `Resque::Failure::Redis`
+    def self.backend
+      return @backend if @backend
+      require 'resque/failure/redis'
+      @backend = Failure::Redis
+    end
+
+    # Returns the int count of how many failures we have seen.
+    def self.count
+      backend.count
+    end
+
+    # Returns an array of all the failures, paginated.
+    #
+    # `start` is the int of the first item in the page, `count` is the
+    # number of items to return.
+    def self.all(start = 0, count = 1)
+      backend.all(start, count)
+    end
+
+    # The string url of the backend's web interface, if any.
+    def self.url
+      backend.url
+    end
+
+    # Clear all failure jobs
+    def self.clear
+      backend.clear
+    end
+
+    def self.requeue(index)
+      backend.requeue(index)
+    end
+
+    def self.remove(index)
+      backend.remove(index)
+    end
+    
+    # Requeues all failed jobs in a specific queue.
+    # Queue name should be a string.
+    def self.requeue_queue(queue)
+      i=0
+      while job = Resque::Failure.all(i)
+        if job['queue'] == queue
+          Resque::Failure.requeue(i)
+        end  
+        i+=1
+      end
+    end
+
+    # Removes all failed jobs in a specific queue.
+    # Queue name should be a string.
+    def self.remove_queue(queue)
+      i=0
+      while job = Resque::Failure.all(i)
+        if job['queue'] == queue
+          # This will remove the failure from the array so do not increment the index.
+          Resque::Failure.remove(i)
+        else
+          i+=1    
+        end
+      end
+    end
+  end
+end

data/lib/resque/failure/airbrake.rb

@@ -0,0 +1,17 @@
+begin
+  require 'airbrake'
+rescue LoadError
+  raise "Can't find 'airbrake' gem. Please add it to your Gemfile or install it."
+end
+
+require 'resque/failure/thoughtbot'
+
+module Resque
+  module Failure
+    class Airbrake < Base
+      include Resque::Failure::Thoughtbot
+
+      @klass = ::Airbrake
+    end
+  end
+end

data/lib/resque/failure/base.rb

@@ -0,0 +1,64 @@
+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
+        0
+      end
+
+      # Returns a paginated array of failure objects.
+      def self.all(start = 0, count = 1)
+        []
+      end
+
+      # A URL where someone can go to view failures.
+      def self.url
+      end
+      
+      # Clear all failure objects
+      def self.clear
+      end
+      
+      def self.requeue(index)
+      end
+
+      def self.remove(index)
+      end
+
+      # Logging!
+      def log(message)
+        @worker.log(message)
+      end
+    end
+  end
+end

data/lib/resque/failure/hoptoad.rb

@@ -0,0 +1,33 @@
+begin
+  require 'hoptoad_notifier'
+rescue LoadError
+  raise "Can't find 'hoptoad_notifier' gem. Please add it to your Gemfile or install it."
+end
+
+require 'resque/failure/thoughtbot'
+
+module Resque
+  module Failure
+    # A Failure backend that sends exceptions raised by jobs to Hoptoad.
+    #
+    # To use it, put this code in an initializer, Rake task, or wherever:
+    #
+    #   require 'resque/failure/hoptoad'
+    #
+    #   Resque::Failure::Multiple.classes = [Resque::Failure::Redis, Resque::Failure::Hoptoad]
+    #   Resque::Failure.backend = Resque::Failure::Multiple
+    #
+    # Once you've configured resque to use the Hoptoad failure backend,
+    # you'll want to setup an initializer to configure the Hoptoad.
+    #
+    # HoptoadNotifier.configure do |config|
+    #   config.api_key = 'your_key_here'
+    # end
+    # For more information see https://github.com/thoughtbot/hoptoad_notifier
+    class Hoptoad < Base
+      include Resque::Failure::Thoughtbot
+
+      @klass = ::HoptoadNotifier
+    end
+  end
+end

data/lib/resque/failure/multiple.rb

@@ -0,0 +1,54 @@
+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
+        classes.first.count
+      end
+
+      # Returns a paginated array of failure objects.
+      def self.all(start = 0, count = 1)
+        classes.first.all(start,count)
+      end
+
+      # A URL where someone can go to view failures.
+      def self.url
+        classes.first.url
+      end
+
+      # Clear all failure objects
+      def self.clear
+        classes.first.clear
+      end
+
+      def self.requeue(*args)
+        classes.first.requeue(*args)
+      end
+
+      def self.remove(index)
+        classes.each { |klass| klass.remove(index) }
+      end
+    end
+  end
+end

data/lib/resque/failure/redis.rb

@@ -0,0 +1,51 @@
+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 save
+        data = {
+          :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S %Z"),
+          :payload   => payload,
+          :exception => exception.class.to_s,
+          :error     => exception.to_s,
+          :backtrace => filter_backtrace(Array(exception.backtrace)),
+          :worker    => worker.to_s,
+          :queue     => queue
+        }
+        data = Resque.encode(data)
+        Resque.redis.rpush(:failed, data)
+      end
+
+      def self.count
+        Resque.redis.llen(:failed).to_i
+      end
+
+      def self.all(start = 0, count = 1)
+        Resque.list_range(:failed, start, count)
+      end
+
+      def self.clear
+        Resque.redis.del(:failed)
+      end
+
+      def self.requeue(index)
+        item = all(index)
+        item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
+        Resque.redis.lset(:failed, index, Resque.encode(item))
+        Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
+      end
+
+      def self.remove(index)
+        id = rand(0xffffff)
+        Resque.redis.lset(:failed, index, id)
+        Resque.redis.lrem(:failed, 1, id)
+      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/thoughtbot.rb

@@ -0,0 +1,33 @@
+module Resque
+  module Failure
+    module Thoughtbot
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :klass
+
+        def configure(&block)
+          Resque::Failure.backend = self
+          klass.configure(&block)
+        end
+
+        def count
+          # We can't get the total # of errors from Hoptoad so we fake it
+          # by asking Resque how many errors it has seen.
+          Stat[:failed]
+        end
+      end
+
+      def save
+        self.class.klass.notify_or_ignore(exception,
+          :parameters => {
+            :payload_class => payload['class'].to_s,
+            :payload_args => payload['args'].inspect
+          }
+        )
+      end
+    end
+  end
+end

data/lib/resque/helpers.rb

@@ -0,0 +1,94 @@
+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
+      Resque.redis
+    end
+
+    # Given a Ruby object, returns a string suitable for storage in a
+    # queue.
+    def encode(object)
+      if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
+        MultiJson.dump object
+      else
+        MultiJson.encode object
+      end
+
+    end
+
+    # Given a string, returns a Ruby object.
+    def decode(object)
+      return unless object
+
+      begin
+        if MultiJson.respond_to?(:dump) && MultiJson.respond_to?(:load)
+          MultiJson.load object
+        else
+          MultiJson.decode object
+        end
+      rescue ::MultiJson::DecodeError => e
+        raise DecodeException, e.message, e.backtrace
+      end
+    end
+
+    # Given a word with dashes, returns a camel cased version of it.
+    #
+    # classify('job-name') # => 'JobName'
+    def classify(dashed_word)
+      dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+    end
+
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    # constantize("Module") # => Module
+    # constantize("Test::Unit") # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    # C = 'outside'
+    # module M
+    #   C = 'inside'
+    #   C # => 'inside'
+    #   constantize("C") # => 'outside', same as ::C
+    # end
+    #
+    # NameError is raised when the constant is unknown.
+    def constantize(camel_cased_word)
+      camel_cased_word = camel_cased_word.to_s
+
+      if camel_cased_word.include?('-')
+        camel_cased_word = classify(camel_cased_word)
+      end
+
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        args = Module.method(:const_get).arity != 1 ? [false] : []
+
+        if constant.const_defined?(name, *args)
+          constant = constant.const_get(name)
+        else
+          constant = constant.const_missing(name)
+        end
+      end
+      constant
+    end
+  end
+end