kulesa-sidekiq 1.2.2

data/lib/sidekiq/middleware/client/unique_jobs.rb

@@ -0,0 +1,36 @@
+require 'digest'
+require 'multi_json'
+
+module Sidekiq
+  module Middleware
+    module Client
+      class UniqueJobs
+        HASH_KEY_EXPIRATION = 30 * 60
+
+        def call(worker_class, item, queue)
+          enabled = worker_class.get_sidekiq_options['unique']
+          if enabled
+            payload_hash = Digest::MD5.hexdigest(Sidekiq.dump_json(item))
+            unique = false
+
+            Sidekiq.redis do |conn|
+              conn.watch(payload_hash)
+
+              if conn.get(payload_hash)
+                conn.unwatch
+              else
+                unique = conn.multi do
+                  conn.setex(payload_hash, HASH_KEY_EXPIRATION, 1)
+                end
+              end
+            end
+            yield if unique
+          else
+            yield
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/active_record.rb

@@ -0,0 +1,13 @@
+module Sidekiq
+  module Middleware
+    module Server
+      class ActiveRecord
+        def call(*args)
+          yield
+        ensure
+          ::ActiveRecord::Base.clear_active_connections! if defined?(::ActiveRecord)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/exception_handler.rb

@@ -0,0 +1,38 @@
+require 'sidekiq/util'
+
+module Sidekiq
+  module Middleware
+    module Server
+      class ExceptionHandler
+        include Util
+        def call(*args)
+          yield
+        rescue => ex
+          logger.warn ex
+          logger.warn ex.backtrace.join("\n")
+          send_to_airbrake(args[1], ex) if defined?(::Airbrake)
+          send_to_exceptional(args[1], ex) if defined?(::Exceptional)
+          send_to_exception_notifier(args[1], ex) if defined?(::ExceptionNotifier)
+          raise
+        end
+
+        private
+
+        def send_to_airbrake(msg, ex)
+          ::Airbrake.notify(ex, :parameters => msg)
+        end
+
+        def send_to_exceptional(msg, ex)
+          if ::Exceptional::Config.should_send_to_api?
+            ::Exceptional.context(msg)
+            ::Exceptional::Remote.error(::Exceptional::ExceptionData.new(ex))
+          end
+        end
+
+        def send_to_exception_notifier(msg, ex)
+          ::ExceptionNotifier::Notifier.background_exception_notification(ex, :data => { :message => msg })
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/failure_jobs.rb

@@ -0,0 +1,25 @@
+require 'multi_json'
+
+module Sidekiq
+  module Middleware
+    module Server
+      class FailureJobs
+        def call(*args)
+          yield
+        rescue => e
+          data = {
+            :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S %Z"),
+            :payload => args[1],
+            :exception => e.class.to_s,
+            :error => e.to_s,
+            :backtrace => e.backtrace,
+            :worker => args[1]['class'],
+            :queue => args[2]
+          }
+          Sidekiq.redis {|conn| conn.rpush(:failed, Sidekiq.dump_json(data)) }
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/logging.rb

@@ -0,0 +1,31 @@
+module Sidekiq
+  module Middleware
+    module Server
+      class Logging
+
+        def call(*args)
+          Sidekiq::Logging.with_context("#{args[0].class.to_s} MSG-#{args[0].object_id.to_s(36)}") do
+            begin
+              start = Time.now
+              logger.info { "start" }
+              yield
+              logger.info { "done: #{elapsed(start)} sec" }
+            rescue
+              logger.info { "fail: #{elapsed(start)} sec" }
+              raise
+            end
+          end
+        end
+
+        def elapsed(start)
+          (Time.now - start).to_f.round(3)
+        end
+
+        def logger
+          Sidekiq.logger
+        end
+      end
+    end
+  end
+end
+

data/lib/sidekiq/middleware/server/retry_jobs.rb

@@ -0,0 +1,69 @@
+require 'multi_json'
+
+require 'sidekiq/retry'
+
+module Sidekiq
+  module Middleware
+    module Server
+      ##
+      # Automatically retry jobs that fail in Sidekiq.
+      # A message looks like:
+      #
+      #     { 'class' => 'HardWorker', 'args' => [1, 2, 'foo'] }
+      #
+      # We'll add a bit more data to the message to support retries:
+      #
+      #  * 'queue' - the queue to use
+      #  * 'retry_count' - number of times we've retried so far.
+      #  * 'error_message' - the message from the exception
+      #  * 'error_class' - the exception class
+      #  * 'failed_at' - the first time it failed
+      #  * 'retried_at' - the last time it was retried
+      #
+      # We don't store the backtrace as that can add a lot of overhead
+      # to the message and everyone is using Airbrake, right?
+      class RetryJobs
+        include Sidekiq::Util
+        include Sidekiq::Retry
+
+        def call(worker, msg, queue)
+          yield
+        rescue => e
+          raise unless msg['retry']
+
+          msg['queue'] = queue
+          msg['error_message'] = e.message
+          msg['error_class'] = e.class.name
+          count = if msg['retry_count']
+            msg['retried_at'] = Time.now.utc
+            msg['retry_count'] += 1
+          else
+            msg['failed_at'] = Time.now.utc
+            msg['retry_count'] = 0
+          end
+
+          if msg['backtrace'] == true
+            msg['error_backtrace'] = e.backtrace
+          elsif msg['backtrace'].to_i != 0
+            msg['error_backtrace'] = e.backtrace[0..msg['backtrace'].to_i]
+          end
+
+          if count <= MAX_COUNT
+            delay = DELAY.call(count)
+            logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
+            retry_at = Time.now.to_f + delay
+            payload = Sidekiq.dump_json(msg)
+            Sidekiq.redis do |conn|
+              conn.zadd('retry', retry_at.to_s, payload)
+            end
+          else
+            # Goodbye dear message, you (re)tried your best I'm sure.
+            logger.debug { "Dropping message after hitting the retry maximum: #{msg}" }
+          end
+          raise
+        end
+
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/timeout.rb

@@ -0,0 +1,21 @@
+require 'timeout'
+
+module Sidekiq
+  module Middleware
+    module Server
+      class Timeout
+
+        def call(worker, msg, queue)
+          if msg['timeout'] && msg['timeout'].to_i != 0
+            ::Timeout.timeout(msg['timeout'].to_i) do
+              yield
+            end
+          else
+            yield
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/server/unique_jobs.rb

@@ -0,0 +1,17 @@
+require 'multi_json'
+
+module Sidekiq
+  module Middleware
+    module Server
+      class UniqueJobs
+        def call(*args)
+          yield
+        ensure
+          json = Sidekiq.dump_json(args[1])
+          hash = Digest::MD5.hexdigest(json)
+          Sidekiq.redis {|conn| conn.del(hash) }
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/processor.rb

@@ -0,0 +1,92 @@
+require 'celluloid'
+require 'multi_json'
+require 'sidekiq/util'
+
+require 'sidekiq/middleware/server/active_record'
+require 'sidekiq/middleware/server/exception_handler'
+require 'sidekiq/middleware/server/retry_jobs'
+require 'sidekiq/middleware/server/logging'
+require 'sidekiq/middleware/server/timeout'
+
+module Sidekiq
+  class Processor
+    include Util
+    include Celluloid
+
+    def self.default_middleware
+      Middleware::Chain.new do |m|
+        m.add Middleware::Server::ExceptionHandler
+        m.add Middleware::Server::Logging
+        m.add Middleware::Server::RetryJobs
+        m.add Middleware::Server::ActiveRecord
+        m.add Middleware::Server::Timeout
+      end
+    end
+
+    def initialize(boss)
+      @boss = boss
+    end
+
+    def process(msg, queue)
+      klass  = constantize(msg['class'])
+      worker = klass.new
+      defer do
+        stats(worker, msg, queue) do
+          Sidekiq.server_middleware.invoke(worker, msg, queue) do
+            worker.perform(*msg['args'])
+          end
+        end
+      end
+      @boss.processor_done!(current_actor)
+    end
+
+    # See http://github.com/tarcieri/celluloid/issues/22
+    def inspect
+      "#<Processor #{to_s}>"
+    end
+
+    def to_s
+      @str ||= "#{hostname}:#{process_id}-#{Thread.current.object_id}:default"
+    end
+
+    private
+
+    def stats(worker, msg, queue)
+      redis do |conn|
+        conn.multi do
+          conn.sadd('workers', self)
+          conn.setex("worker:#{self}:started", EXPIRY, Time.now.to_s)
+          hash = {:queue => queue, :payload => msg, :run_at => Time.now.strftime("%Y/%m/%d %H:%M:%S %Z")}
+          conn.setex("worker:#{self}", EXPIRY, Sidekiq.dump_json(hash))
+        end
+      end
+
+      dying = false
+      begin
+        yield
+      rescue Exception
+        dying = true
+        redis do |conn|
+          conn.multi do
+            conn.incrby("stat:failed", 1)
+          end
+        end
+        raise
+      ensure
+        redis do |conn|
+          conn.multi do
+            conn.srem("workers", self)
+            conn.del("worker:#{self}")
+            conn.del("worker:#{self}:started")
+            conn.incrby("stat:processed", 1)
+          end
+        end
+      end
+
+    end
+
+    def hostname
+      @h ||= `hostname`.strip
+    end
+  end
+end

data/lib/sidekiq/rails.rb

@@ -0,0 +1,21 @@
+module Sidekiq
+  def self.hook_rails!
+    return unless Sidekiq.options[:enable_rails_extensions]
+    if defined?(ActiveRecord)
+      ActiveRecord::Base.extend(Sidekiq::Extensions::ActiveRecord)
+      ActiveRecord::Base.send(:include, Sidekiq::Extensions::ActiveRecord)
+    end
+
+    if defined?(ActionMailer)
+      ActionMailer::Base.extend(Sidekiq::Extensions::ActionMailer)
+    end
+  end
+
+  class Rails < ::Rails::Engine
+    config.autoload_paths << File.expand_path("#{config.root}/app/workers") if File.exist?("#{config.root}/app/workers")
+
+    initializer 'sidekiq' do
+      Sidekiq.hook_rails!
+    end
+  end if defined?(::Rails)
+end

data/lib/sidekiq/redis_connection.rb

@@ -0,0 +1,27 @@
+require 'connection_pool'
+require 'redis'
+require 'redis/namespace'
+
+module Sidekiq
+  class RedisConnection
+    def self.create(options={})
+      url = options[:url] || ENV['REDISTOGO_URL'] || 'redis://localhost:6379/0'
+      # need a connection for Fetcher and Retry
+      size = options[:size] || (Sidekiq.server? ? (Sidekiq.options[:concurrency] + 2) : 5)
+
+      ConnectionPool.new(:timeout => 1, :size => size) do
+        build_client(url, options[:namespace])
+      end
+    end
+
+    def self.build_client(url, namespace)
+      client = Redis.connect(:url => url)
+      if namespace
+        Redis::Namespace.new(namespace, :redis => client)
+      else
+        client
+      end
+    end
+    private_class_method :build_client
+  end
+end

data/lib/sidekiq/retry.rb

@@ -0,0 +1,59 @@
+require 'sidekiq'
+require 'sidekiq/util'
+require 'celluloid'
+require 'multi_json'
+
+module Sidekiq
+  ##
+  # Sidekiq's retry support assumes a typical development lifecycle:
+  # 0. push some code changes with a bug in it
+  # 1. bug causes message processing to fail, sidekiq's middleware captures
+  #    the message and pushes it onto a retry queue
+  # 2. sidekiq retries messages in the retry queue multiple times with
+  #    an exponential delay, the message continues to fail
+  # 3. after a few days, a developer deploys a fix.  the message is
+  #    reprocessed successfully.
+  # 4. if 3 never happens, sidekiq will eventually give up and throw the
+  #    message away.
+  module Retry
+
+    # delayed_job uses the same basic formula
+    MAX_COUNT = 25
+    DELAY = proc { |count| (count ** 4) + 15 }
+    POLL_INTERVAL = 15
+
+    ##
+    # The Poller checks Redis every N seconds for messages in the retry
+    # set have passed their retry timestamp and should be retried.  If so, it
+    # just pops the message back onto its original queue so the
+    # workers can pick it up like any other message.
+    class Poller
+      include Celluloid
+      include Sidekiq::Util
+
+      def poll
+        watchdog('retry poller thread died!') do
+
+          Sidekiq.redis do |conn|
+            # A message's "score" in Redis is the time at which it should be retried.
+            # Just check Redis for the set of messages with a timestamp before now.
+            messages = nil
+            now = Time.now.to_f.to_s
+            (messages, _) = conn.multi do
+              conn.zrangebyscore('retry', '-inf', now)
+              conn.zremrangebyscore('retry', '-inf', now)
+            end
+
+            messages.each do |message|
+              logger.debug { "Retrying #{message}" }
+              msg = Sidekiq.load_json(message)
+              conn.rpush("queue:#{msg['queue']}", message)
+            end
+          end
+
+          after(POLL_INTERVAL) { poll }
+        end
+      end
+    end
+  end
+end