delayed_job_prevent_duplicate 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb905b0a47328215027e975ba4e64abae6bb3f9cdeeabffb711c3dfefefd2f5e
-  data.tar.gz: 77ced18194a083efd6442f88c8597d0242b66123b2eef6c12d8d8080fa8071f9
+  metadata.gz: de83fe452a89cce8af86bad6d543b0b564a48a8c097e34283f9b13bac1c22b0d
+  data.tar.gz: 3d4419ae6d770c137d146914e51e09d0ba88d7f38bbda751036763a64dc470d5
 SHA512:
-  metadata.gz: c03851f146bcc64ef3fd5d1ac3d3cdb6f7d86c71045d249be667e6deb24ccb14365063039c37f06e7ad0aec96dd77379b4a4da9076577ef3f09c08f597c3a528
-  data.tar.gz: 0af816c92fc30a3aa78b57be51bace5106ecc0b5bf0c268b3792c5bdb1ad2ee947afa1d9eaa8e1caf3587482ce4b5bf6fd2226671207c2454c39a820af08f385
+  metadata.gz: ab4227f7e5ec6c6be4a0012fdea1aa1cd864022f7798c81a0c97d8f7131c0643c84fa4b80bd295414fd9e08e76c1b0b6ad95d23eb7e57c67334c657ae5dc569f
+  data.tar.gz: 951f714521b654d1f09b3e024d27f2d50f5e3fb83e6f3ff4d642c2da16968c0c0f198d55ec361ec46f56103c0a7199f868cae99b87f45d6d66387cb2ed3f6b06

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    delayed_job_prevent_duplicate (0.2.0)
+      delayed_job (>= 3.0, < 5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.1.3.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    base64 (0.2.0)
+    bigdecimal (3.1.7)
+    concurrent-ruby (1.2.3)
+    connection_pool (2.4.1)
+    delayed_job (4.1.11)
+      activesupport (>= 3.0, < 8.0)
+    drb (2.2.1)
+    i18n (1.14.4)
+      concurrent-ruby (~> 1.0)
+    minitest (5.22.3)
+    mutex_m (0.2.0)
+    rake (13.2.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  arm64-darwin-23
+  ruby
+
+DEPENDENCIES
+  delayed_job_prevent_duplicate!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.5.6

data/README.md

@@ -1,12 +1,14 @@
-# DelayedJobPreventDuplicate
+# Delayed Job Prevent Duplicate
 
-The purpose of this gem is to prevent to re-enqueue on DelayedJob a task already enqueued.  
-So we set a "signature" attached to every task enqueued which is a composite from the class and the id of the object, and the method called.  
-And then when creating a new job we look in the "pending" jobs if there is another one with the same signature (not in the "working" one because a task can be executed and yet you want to re-excute it because of any change). 
+[![Maintainability](https://api.codeclimate.com/v1/badges/a7d6801105cc0df16e37/maintainability)](https://codeclimate.com/github/noesya/delayed_job_prevent_duplicate/maintainability)
+
+The purpose of this gem is to prevent to re-enqueue on DelayedJob a task already enqueued.
+So we set a "signature" attached to every task enqueued which is a composite from the class and the id of the object, and the method called.
+And then when creating a new job we look in the "pending" jobs if there is another one with the same signature (not in the "working" one because a task can be executed and yet you want to re-excute it because of any change).
 
 ## Note
 
-This gem is based on the [synth](https://github.com/synth) work: https://gist.github.com/synth/fba7baeffd083a931184
+This gem is based on the work of [synth](https://github.com/synth): https://gist.github.com/synth/fba7baeffd083a931184
 
 ## Installation
 
@@ -22,13 +24,13 @@ And then execute:
 
     $ bundle install
 
-Next, you need to run the generator: 
+Next, you need to run the generator:
 
 ```ruby
-rails g delayed_job_prevent_duplicate
+rails g delayed_job_prevent_duplicate:install
 ```
-  
-All should be fine now!  
+
+All should be fine now!
 
 
 ## Contributing

data/lib/delayed_job_prevent_duplicate/duplicate_checker.rb

@@ -0,0 +1,21 @@
+module DelayedJobPreventDuplicate
+  class DuplicateChecker
+    attr_reader :job
+
+    def self.duplicate?(job)
+      new(job).duplicate?
+    end
+
+    def initialize(job)
+      @job = job
+    end
+
+    def duplicate?
+      # Looking for jobs with the same signature.
+      # Only jobs not started, otherwise it would never compute a real change if the job is currently running
+      duplicates = Delayed::Job.where(locked_at: nil, signature: job.signature)
+      duplicates = duplicates.where.not(id: job.id) if job.id.present?
+      duplicates.exists?
+    end
+  end
+end

data/lib/delayed_job_prevent_duplicate/signature_concern.rb

@@ -0,0 +1,76 @@
+require_relative "duplicate_checker"
+
+module DelayedJobPreventDuplicate
+  module SignatureConcern
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :generate_signature
+      validate :prevent_duplicate
+    end
+
+    private
+
+    def generate_signature
+      self.signature = signature_from_denormalized_data || random_signature
+    end
+
+    def signature_from_denormalized_data
+      begin
+        Digest::MD5.hexdigest(denormalized_data.to_json)
+      rescue
+        puts "DelayedJobPreventDuplicate could not generate the signature correctly."
+        nil
+      end
+    end
+
+    def random_signature
+      SecureRandom.uuid
+    end
+
+    def denormalized_data
+      @denormalize_data ||= begin
+        if payload_object.is_a?(Delayed::PerformableMethod)
+          denormalized_data_for_performable_method
+        else
+          denormalized_data_for_job_wrapper
+        end
+      end
+    end
+
+    # Methods tagged with handle_asynchronously
+    def denormalized_data_for_performable_method
+      {
+        object: payload_object.object.to_global_id.to_s,
+        method_name: payload_object.method_name,
+        args: stringify_arguments(payload_object.args)
+      }
+    end
+
+    # Regular Job
+    def denormalized_data_for_job_wrapper
+      {
+        job_class: payload_object.job_data["job_class"],
+        args: stringify_arguments(payload_object.job_data["arguments"])
+      }
+    end
+
+    def stringify_arguments(arguments)
+      serialize_arguments(arguments).join('|')
+    end
+
+    def serialize_arguments(arguments)
+      arguments.map { |argument|
+        argument.is_a?(ActiveRecord::Base)  ? argument.to_global_id.to_s
+                                            : argument.to_json
+      }
+    end
+
+    def prevent_duplicate
+      if DuplicateChecker.duplicate?(self)
+        Rails.logger.warn "Found duplicate job(#{self.signature}), ignoring..."
+        errors.add(:base, "This is a duplicate")
+      end
+    end
+  end
+end

data/lib/delayed_job_prevent_duplicate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DelayedJobPreventDuplicate
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/delayed_job_prevent_duplicate.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
+require "delayed_job"
+
+require_relative "delayed_job_prevent_duplicate/signature_concern"
 require_relative "delayed_job_prevent_duplicate/version"
 
 module DelayedJobPreventDuplicate
   class Error < StandardError; end
- 
-  require 'delayed_duplicate_prevention_plugin'
 
-  Delayed::Backend::ActiveRecord::Job.send(:include, DelayedDuplicatePreventionPlugin::SignatureConcern)
-  Delayed::Worker.plugins << DelayedDuplicatePreventionPlugin
+  Delayed::Backend::ActiveRecord::Job.send(:include, SignatureConcern)
 end

data/lib/generators/delayed_job_prevent_duplicate/install_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require "rails/generators/active_record/migration"
+
+module DelayedJobPreventDuplicate
+  class InstallGenerator < ::Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+    source_root File.expand_path("../../templates", __FILE__)
+
+    def copy_migration
+      migration_template "migration.rb", File.join(db_migrate_path, "add_signature_to_delayed_job.rb")
+    end
+
+  end
+end

data/lib/generators/templates/migration.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddSignatureToDelayedJob < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    add_column :delayed_jobs, :signature, :string
+  end
+end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_prevent_duplicate
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - pabois
 - arnaudlevy
 - SebouChu
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-10 00:00:00.000000000 Z
+date: 2024-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -42,18 +42,19 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - delayed_job_prevent_duplicate.gemspec
-- lib/.DS_Store
-- lib/delayed_duplicate_prevention_plugin.rb
 - lib/delayed_job_prevent_duplicate.rb
+- lib/delayed_job_prevent_duplicate/duplicate_checker.rb
+- lib/delayed_job_prevent_duplicate/signature_concern.rb
 - lib/delayed_job_prevent_duplicate/version.rb
-- lib/generators/delayed_job_prevent_duplicate_generator.rb
-- lib/generators/templates/migration.rb
+- lib/generators/delayed_job_prevent_duplicate/install_generator.rb
+- lib/generators/templates/migration.rb.tt
 homepage: https://github.com/noesya/delayed_job_prevent_duplicate
 licenses:
 - MIT
@@ -61,7 +62,7 @@ metadata:
   homepage_uri: https://github.com/noesya/delayed_job_prevent_duplicate
   source_code_uri: https://github.com/noesya/delayed_job_prevent_duplicate
   changelog_uri: https://github.com/noesya/delayed_job_prevent_duplicate/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -76,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.5.6
+signing_key:
 specification_version: 4
 summary: Prevent delayed_job to enqueue a task already enqueued
 test_files: []

data/lib/delayed_duplicate_prevention_plugin.rb

@@ -1,106 +0,0 @@
-# based on https://gist.github.com/synth/fba7baeffd083a931184
-
-require 'delayed_job'
-
-class DelayedDuplicatePreventionPlugin < Delayed::Plugin
-
-  module SignatureConcern
-    extend ActiveSupport::Concern
-
-    included do
-      before_validation :add_signature
-      validate :prevent_duplicate
-    end
-
-    private
-
-    def add_signature
-      # If signature fails, id will keep everything working (though deduplication will not work)
-      self.signature = generate_signature || generate_signature_random
-      self.args = get_args
-    end
-
-    def generate_signature
-      begin
-        if payload_object.is_a?(Delayed::PerformableMethod)
-          generate_signature_for_performable_method
-        else
-          generate_signature_random
-        end
-      rescue
-        generate_signature_failed
-      end
-    end
-
-    # Methods tagged with handle_asynchronously
-    def generate_signature_for_performable_method
-      if payload_object.object.respond_to?(:id) and payload_object.object.id.present?
-        sig = "#{payload_object.object.class}:#{payload_object.object.id}"
-      else
-        sig = "#{payload_object.object}"
-      end
-      sig += "##{payload_object.method_name}"
-      sig
-    end
-
-    # # Regular Job
-    # def generate_signature_for_job_wrapper
-    #   sig = "#{payload_object.job_data["job_class"]}"
-    #   payload_object.job_data["arguments"].each do |job_arg|
-    #     string_job_arg = job_arg.is_a?(String) ? job_arg : job_arg.to_json
-    #   end
-    #   sig += "#{payload_object.job_data["job_class"]}"
-    #   sig
-    # end
-
-    def generate_signature_random
-      SecureRandom.uuid
-    end
-
-    def generate_signature_failed
-      puts "DelayedDuplicatePreventionPlugin could not generate the signature correctly."
-    end
-
-    def get_args
-      self.payload_object.respond_to?(:args) ? self.payload_object.args : []
-    end
-
-    def prevent_duplicate
-      if DuplicateChecker.duplicate?(self)
-        Rails.logger.warn "Found duplicate job(#{self.signature}), ignoring..."
-        errors.add(:base, "This is a duplicate")
-      end
-    end
-  end
-
-  class DuplicateChecker
-    attr_reader :job
-
-    def self.duplicate?(job)
-      new(job).duplicate?
-    end
-
-    def initialize(job)
-      @job = job
-    end
-
-    def duplicate?
-      possible_dupes.any? { |possible_dupe| args_match?(possible_dupe, job) }
-    end
-
-    private
-
-    def possible_dupes
-      possible_dupes = Delayed::Job.where(attempts: 0, locked_at: nil)  # Only jobs not started, otherwise it would never compute a real change if the job is currently running
-                                   .where(signature: job.signature)     # Same signature
-      possible_dupes = possible_dupes.where.not(id: job.id) if job.id.present?
-      possible_dupes
-    end
-
-    def args_match?(job1, job2)
-      job1.payload_object.args == job2.payload_object.args
-    rescue
-      false
-    end
-  end
-end

data/lib/generators/delayed_job_prevent_duplicate_generator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails'
-
-module DelayedJobPreventDuplicate
-  class DelayedJobPreventDuplicateGenerator < ::Rails::Generators::Base
-
-    include Rails::Generators::Migration
-    source_root File.expand_path("../templates", __FILE__)
-
-    def self.next_migration_number(path)
-      unless @prev_migration_nr
-        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
-      else
-        @prev_migration_nr += 1
-      end
-     @prev_migration_nr.to_s
-    end
-
-    def copy_migration
-      migration_template "migration.rb", "db/migrate/add_signature_to_delayed_job.rb", migration_version: migration_version
-    end
-
-    def migration_version
-      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
-    end
-
-  end
-end

data/lib/generators/templates/migration.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class AddSignatureToDelayedJob < ActiveRecord::Migration<%= migration_version %>
-  def change
-    add_column :delayed_jobs, :signature, :string
-    add_column :delayed_jobs, :args, :text
-  end
-end