sidekiq-robust-job 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sidekiq/robust/job"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sidekiq-robust-job.rb

@@ -0,0 +1 @@
+require "sidekiq_robust_job"

data/lib/sidekiq/robust/job.rb

@@ -0,0 +1 @@
+require_relative "../../sidekiq-robust-job.rb"

data/lib/sidekiq/robust/job/version.rb

@@ -0,0 +1,7 @@
+module Sidekiq
+  module Robust
+    module Job
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/sidekiq_robust_job.rb

@@ -0,0 +1,64 @@
+require "sidekiq/robust/job/version"
+require "sidekiq_robust_job/configuration"
+require "sidekiq_robust_job/dependencies_container"
+require "sidekiq_robust_job/digest_generator"
+require "sidekiq_robust_job/enqueue_conflict_resolution_strategy"
+require "sidekiq_robust_job/enqueue_conflict_resolution_strategy/base"
+require "sidekiq_robust_job/enqueue_conflict_resolution_strategy/do_nothing"
+require "sidekiq_robust_job/enqueue_conflict_resolution_strategy/drop_self"
+require "sidekiq_robust_job/enqueue_conflict_resolution_strategy/replace"
+require "sidekiq_robust_job/missed_jobs"
+require "sidekiq_robust_job/missed_jobs_scheduler"
+require "sidekiq_robust_job/model"
+require "sidekiq_robust_job/perform_missed_jobs_job"
+require "sidekiq_robust_job/repository"
+require "sidekiq_robust_job/setter_proxy_job"
+require "sidekiq_robust_job/sidekiq_job_extensions"
+require "sidekiq_robust_job/sidekiq_job_manager"
+require "sidekiq_robust_job/uniqueness_strategy"
+require "sidekiq_robust_job/uniqueness_strategy/base"
+require "sidekiq_robust_job/uniqueness_strategy/no_uniqueness"
+require "sidekiq_robust_job/uniqueness_strategy/until_executed"
+require "sidekiq_robust_job/uniqueness_strategy/until_executing"
+require "sidekiq/cron/job"
+require "sidekiq"
+require "active_support/concern"
+
+class SidekiqRobustJob
+  def self.configuration
+    @configuration ||= SidekiqRobustJob::Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.perform_async(job_class, *arguments)
+    sidekiq_job_manager.perform_async(job_class, *arguments)
+  end
+
+  def self.perform_in(job_class, interval, *arguments)
+    sidekiq_job_manager.perform_in(job_class, interval, *arguments)
+  end
+
+  def self.perform_at(job_class, interval, *arguments)
+    sidekiq_job_manager.perform_at(job_class, interval, *arguments)
+  end
+
+  def self.set(job_class, options)
+    sidekiq_job_manager.set(job_class, options)
+  end
+
+  def self.perform(job_id)
+    sidekiq_job_manager.perform(job_id)
+  end
+
+  def self.schedule_missed_jobs_handling
+    SidekiqRobustJob::DependenciesContainer["missed_jobs_scheduler"].schedule
+  end
+
+  def self.sidekiq_job_manager
+    SidekiqRobustJob::DependenciesContainer["sidekiq_job_manager"]
+  end
+  private_class_method :sidekiq_job_manager
+end

data/lib/sidekiq_robust_job/configuration.rb

@@ -0,0 +1,48 @@
+class SidekiqRobustJob
+  class Configuration
+    DEFAULT_MISSED_JOB_CRON_EVERY_THREE_HOURS = "0 */3 * * *".freeze
+
+    attr_accessor :locker, :lock_ttl_proc, :memory_monitor, :clock, :digest_generator_backend, :sidekiq_job_model,
+                  :missed_job_policy, :missed_job_cron
+
+    def lock_ttl_proc=(val)
+      raise ArgumentError.new("must be lambda-like object!") if !val.respond_to?(:call)
+      @lock_ttl_proc = val
+    end
+
+    def lock_ttl_proc
+      @lock_ttl_proc ||= ->(_job) { 120_000 }
+    end
+
+    def clock
+      @clock ||= Time
+    end
+
+    def digest_generator_backend
+      @digest_generator_backend ||= Digest::MD5
+    end
+
+    def sidekiq_job_model
+      @sidekiq_job_model
+    end
+
+    def missed_job_policy=(val)
+      raise ArgumentError.new("must be lambda-like object!") if !val.respond_to?(:call)
+      @missed_job_policy = val
+    end
+
+    def missed_job_policy
+      @missed_job_policy || ->(job) { Time.current > (job.created_at + 3.hours) }
+    end
+
+    def missed_job_cron=(val)
+      Fugit.do_parse_cron(val)
+
+      @missed_job_cron = val
+    end
+
+    def missed_job_cron
+      @missed_job_cron || DEFAULT_MISSED_JOB_CRON_EVERY_THREE_HOURS
+    end
+  end
+end

data/lib/sidekiq_robust_job/dependencies_container.rb

@@ -0,0 +1,64 @@
+class SidekiqRobustJob
+  class DependenciesContainer
+    def self.[](method_name)
+      public_send(method_name)
+    end
+
+    def self.sidekiq_job_manager
+      SidekiqRobustJob::SidekiqJobManager.new(
+        jobs_repository: SidekiqRobustJob::DependenciesContainer["jobs_repository"],
+        clock: SidekiqRobustJob.configuration.clock,
+        digest_generator: SidekiqRobustJob::DependenciesContainer["digest_generator"],
+        memory_monitor: SidekiqRobustJob.configuration.memory_monitor
+      )
+    end
+
+    def self.jobs_repository
+      SidekiqRobustJob::Repository.new(
+        jobs_database: SidekiqRobustJob.configuration.sidekiq_job_model,
+        clock: SidekiqRobustJob.configuration.clock
+      )
+    end
+
+    def self.uniqueness_strategy_resolver
+      SidekiqRobustJob::UniquenessStrategy.new(
+        locker: SidekiqRobustJob.configuration.locker,
+        lock_ttl_proc: SidekiqRobustJob.configuration.lock_ttl_proc,
+        jobs_repository: SidekiqRobustJob::DependenciesContainer["jobs_repository"],
+        memory_monitor: SidekiqRobustJob.configuration.memory_monitor
+      )
+    end
+
+    def self.digest_generator
+      SidekiqRobustJob::DigestGenerator.new(
+        backend: SidekiqRobustJob.configuration.digest_generator_backend
+      )
+    end
+
+    def self.enqueue_conflict_resolution_resolver
+      SidekiqRobustJob::EnqueueConflictResolutionStrategy.new(
+        jobs_repository: SidekiqRobustJob::DependenciesContainer["jobs_repository"],
+        clock: SidekiqRobustJob.configuration.clock
+      )
+    end
+
+    def self.setter_proxy_job
+      SidekiqRobustJob::SetterProxyJob.new
+    end
+
+    def self.missed_jobs
+      SidekiqRobustJob::MissedJobs.new(
+        jobs_repository: SidekiqRobustJob::DependenciesContainer["jobs_repository"],
+        missed_job_policy: SidekiqRobustJob.configuration.missed_job_policy
+      )
+    end
+
+    def self.missed_jobs_scheduler
+      SidekiqRobustJob::MissedJobsScheduler.new(
+        cron: SidekiqRobustJob.configuration.missed_job_cron,
+        scheduled_jobs_repository: Sidekiq::Cron::Job,
+        job_class: SidekiqRobustJob::PerformMissedJobsJob
+      )
+    end
+  end
+end

data/lib/sidekiq_robust_job/digest_generator.rb

@@ -0,0 +1,14 @@
+class SidekiqRobustJob
+  class DigestGenerator
+    attr_reader :backend
+    private     :backend
+
+    def initialize(backend:)
+      @backend = backend
+    end
+
+    def generate(job_class, *arguments)
+      backend.hexdigest("#{job_class}-#{Array(arguments).join('-')}")
+    end
+  end
+end

data/lib/sidekiq_robust_job/enqueue_conflict_resolution_strategy.rb

@@ -0,0 +1,58 @@
+class SidekiqRobustJob
+  class EnqueueConflictResolutionStrategy
+    def self.do_nothing
+      :do_nothing
+    end
+
+    def self.drop_self
+      :drop_self
+    end
+
+    def self.replace
+      :replace
+    end
+
+    attr_reader :jobs_repository, :clock
+    private     :jobs_repository, :clock
+
+    def initialize(jobs_repository:, clock:)
+      @jobs_repository = jobs_repository
+      @clock = clock
+    end
+
+    def resolve(strategy)
+      case strategy.to_sym
+      when SidekiqRobustJob::EnqueueConflictResolutionStrategy.do_nothing
+        SidekiqRobustJob::EnqueueConflictResolutionStrategy::DoNothing.new(
+          jobs_repository: jobs_repository,
+          clock: clock
+        )
+      when SidekiqRobustJob::EnqueueConflictResolutionStrategy.drop_self
+        SidekiqRobustJob::EnqueueConflictResolutionStrategy::DropSelf.new(
+          jobs_repository: jobs_repository,
+          clock: clock
+        )
+      when SidekiqRobustJob::EnqueueConflictResolutionStrategy.replace
+        SidekiqRobustJob::EnqueueConflictResolutionStrategy::Replace.new(
+          jobs_repository: jobs_repository,
+          clock: clock
+        )
+      else
+        raise UnknownStrategyError.new(strategy)
+      end
+    end
+
+    class UnknownStrategyError < StandardError
+      attr_reader :strategy
+      private     :strategy
+
+      def initialize(strategy)
+        @strategy = strategy
+      end
+
+      def message
+        "unknown enqueue conflict resolution strategy: #{strategy}"
+      end
+    end
+  end
+end

data/lib/sidekiq_robust_job/enqueue_conflict_resolution_strategy/base.rb

@@ -0,0 +1,17 @@
+class SidekiqRobustJob
+  class EnqueueConflictResolutionStrategy
+    class Base
+      attr_reader :jobs_repository, :clock
+      private     :jobs_repository, :clock
+
+      def initialize(jobs_repository:, clock:)
+        @jobs_repository = jobs_repository
+        @clock = clock
+      end
+
+      def execute(_job)
+        raise "implement me"
+      end
+    end
+  end
+end

data/lib/sidekiq_robust_job/enqueue_conflict_resolution_strategy/do_nothing.rb

@@ -0,0 +1,8 @@
+class SidekiqRobustJob
+  class EnqueueConflictResolutionStrategy
+    class DoNothing < SidekiqRobustJob::EnqueueConflictResolutionStrategy::Base
+      def execute(_job)
+      end
+    end
+  end
+end

data/lib/sidekiq_robust_job/enqueue_conflict_resolution_strategy/drop_self.rb

@@ -0,0 +1,12 @@
+class SidekiqRobustJob
+  class EnqueueConflictResolutionStrategy
+    class DropSelf < SidekiqRobustJob::EnqueueConflictResolutionStrategy::Base
+      def execute(job)
+        if jobs_repository.unprocessed_for_digest(job.digest, exclude_id: job.id).any?
+          job.drop(dropped_by_job_id: job.id, clock: clock)
+          jobs_repository.save(job)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_robust_job/enqueue_conflict_resolution_strategy/replace.rb

@@ -0,0 +1,13 @@
+class SidekiqRobustJob
+  class EnqueueConflictResolutionStrategy
+    class Replace < SidekiqRobustJob::EnqueueConflictResolutionStrategy::Base
+      def execute(job)
+        jobs_repository.drop_unprocessed_jobs_by_digest(
+          dropped_by_job_id: job.id,
+          digest: job.digest,
+          exclude_id: job.id
+        )
+      end
+    end
+  end
+end

data/lib/sidekiq_robust_job/missed_jobs.rb

@@ -0,0 +1,26 @@
+require "forwardable"
+
+class SidekiqRobustJob
+  class MissedJobs
+    include Enumerable
+    extend Forwardable
+
+    def_delegator :all, :each
+
+    attr_reader :jobs_repository, :missed_job_policy
+    private     :jobs_repository, :missed_job_policy
+
+    def initialize(jobs_repository:, missed_job_policy:)
+      @jobs_repository = jobs_repository
+      @missed_job_policy = missed_job_policy
+    end
+
+    def all
+      @all ||= jobs_repository.missed_jobs(missed_job_policy: missed_job_policy)
+    end
+
+    def invoke
+      each(&:reschedule)
+    end
+  end
+end

data/lib/sidekiq_robust_job/missed_jobs_scheduler.rb

@@ -0,0 +1,56 @@
+class SidekiqRobustJob
+  class MissedJobsScheduler
+    attr_reader :serializer, :scheduled_jobs_repository
+    private     :serializer, :scheduled_jobs_repository
+
+    def initialize(cron:, scheduled_jobs_repository:, job_class:)
+      @serializer = MissedJobSerializer.new(cron, job_class)
+      @scheduled_jobs_repository = scheduled_jobs_repository
+    end
+
+    def schedule
+      scheduled_jobs_repository.new(serializer.serialize).tap do |job|
+        if job.valid?
+          job.save
+        else
+          raise_invalid_job(job)
+        end
+      end
+    end
+
+    private
+
+    def raise_invalid_job(job)
+      errors = job.errors.join(",")
+      raise "could not save job: #{errors}"
+    end
+
+    class MissedJobSerializer
+      NAME = "SidekiqRobustJob - MissedJobsScheduler".freeze
+      private_constant :NAME
+
+      attr_reader :cron, :job_class
+      private     :cron, :job_class
+
+      def initialize(cron, job_class)
+        @cron = cron
+        @job_class = job_class
+      end
+
+      def serialize
+        {
+          name: name,
+          cron: cron,
+          class: job_class,
+        }
+      end
+
+      private
+
+      def name
+        NAME
+      end
+    end
+    private_constant :MissedJobSerializer
+  end
+end

data/lib/sidekiq_robust_job/model.rb

@@ -0,0 +1,90 @@
+class SidekiqRobustJob
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      validates :job_class, :enqueued_at, :digest, :queue, presence: :true
+      validates :uniqueness_strategy, inclusion: {
+        in: [
+          SidekiqRobustJob::UniquenessStrategy.no_uniqueness,
+          SidekiqRobustJob::UniquenessStrategy.until_executing,
+          SidekiqRobustJob::UniquenessStrategy.until_executed,
+        ].map(&:to_s)
+      }, on: :create
+
+      validates :enqueue_conflict_resolution_strategy, inclusion: {
+        in: [
+          SidekiqRobustJob::EnqueueConflictResolutionStrategy.do_nothing,
+          SidekiqRobustJob::EnqueueConflictResolutionStrategy.drop_self,
+          SidekiqRobustJob::EnqueueConflictResolutionStrategy.replace,
+        ].map(&:to_s)
+      }, on: :create
+
+      def self.save(job)
+        job.save!
+      end
+    end
+
+    def unprocessable?
+      completed? || dropped?
+    end
+
+    def completed?
+      completed_at.present?
+    end
+
+    def dropped?
+      dropped_at.present?
+    end
+
+    def started(memory_monitor:, clock: SidekiqRobustJob.configuration.clock)
+      self.memory_usage_before_processing_in_megabytes = memory_monitor.mb
+      self.attempts += 1
+      self.started_at = clock.now
+    end
+
+    def completed(memory_monitor:, clock: SidekiqRobustJob.configuration.clock)
+      self.memory_usage_after_processing_in_megabytes = memory_monitor.mb
+      self.memory_usage_change_in_megabytes = memory_usage_after_processing_in_megabytes - memory_usage_before_processing_in_megabytes
+      self.completed_at = clock.now
+      self.dropped_at = nil
+      self.dropped_by_job_id = nil
+      self.error_type = nil
+      self.error_message = nil
+      self.failed_at = nil
+    end
+
+    def failed(error, clock: SidekiqRobustJob.configuration.clock)
+      self.error_type = error.class
+      self.error_message = error.message
+      self.failed_at = clock.now
+    end
+
+    def reschedule(job_class_resolver: Object)
+      sidekiq_job = job_class_resolver.const_get(job_class)
+      interval_in_seconds = sidekiq_job.sidekiq_options.fetch("reschedule_interval_in_seconds", 5)
+
+      sidekiq_job.original_perform_in(interval_in_seconds.seconds, id)
+    end
+
+    def drop(dropped_by_job_id:, clock: SidekiqRobustJob.configuration.clock)
+      self.dropped_at = clock.now
+      self.dropped_by_job_id = dropped_by_job_id
+    end
+
+    def execute
+      SidekiqRobustJob::DependenciesContainer["uniqueness_strategy_resolver"]
+        .resolve(uniqueness_strategy)
+        .execute(self)
+    end
+
+    def call(job_class_resolver: Object)
+      job_class_resolver.const_get(job_class).new.call(*arguments)
+    end
+
+    def assign_sidekiq_data(execute_at:, sidekiq_jid:)
+      self.execute_at = execute_at
+      self.sidekiq_jid = sidekiq_jid
+    end
+  end
+end