periodically 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40bd21a33a97cc9cdb4574144a800b5462a06a5ee84a2e4a4ec490e1f0a586e4
-  data.tar.gz: c6041deccfe452abfdaad7e17f5f6213b3e7351df0f1993fda5feceb0788b116
+  metadata.gz: ac09a96f805828da8099e478e54d2aefed9678bb2027385c3e0992a46d27b969
+  data.tar.gz: '08ab0c0976bc83a740b520a0b1d8d0b17c90b405087c9a158950fa8611d02b64'
 SHA512:
-  metadata.gz: 9fe6a0efc6673dca98e2f1760ae0b5a592782379384a1548bed762c83955c9d752caa7fea47545c6a771ecf9fd00e53446d46a112347b87f4e3536549f4dd37a
-  data.tar.gz: 8a7d3447ae0aa78938086c1aab6002445c519c3d395ea71fa821c818be123056f5cb5ffa2648fb4d43da079a09ee46d2a3859f8a7a9d4487dabb33ca44c324e2
+  metadata.gz: 9a437e37fecd4fad68edf42263a9d0b086c8b60afbe6d949074f11d89d17adc7704126d5a78359a29b106a453fc35bf46eb979dda77077bfe20851b599296300
+  data.tar.gz: a085ecdec1308cd7a276ac9c4a0c2a47038c45943456d2a7f7c73d9a4a4f03e987430f119ce1971f1a3b6a8a6b5d8810fbb83a17d28a81f179f8670aff3fcbf8

data/README.md

@@ -1,9 +1,8 @@
 # periodically
 
-Redis-backed Ruby library for tasks that need to run once in a while. "Once in a while" is defined more accurately by a custom lambda
-block by the library user.
+Redis-backed Ruby library for tasks that need to run once in a while. "Once in a while" is intentionally vague and should be defined more accurately by a custom lambda block by the library user.
 
-Since task execution is done in a single threa using non-accurate and non-time-based conditions, periodically is best for
+Since task execution is done in a single thread using non-accurate and non-time-based conditions, periodically is best for
 infrequent and noncritical jobs, such as weekly syncs.
 
 Example usecases:
@@ -32,7 +31,7 @@ Periodically.start
 
 In Rails, Periodically jobs are only registered when the class is loaded.
 In production mode Rails (by default) eagerly loads all classes, meaning that everything is fine.
-However, in development mode you might want to either disable eager mode with `config.eager_load = false`
+However, in development mode you might want to disable eager mode with `config.eager_load = false`
 
 **Utilize Periodically in e.g. a Model**
 
@@ -79,7 +78,7 @@ include Periodically::Model
 
 # Enqueue a Periodically job
 periodically :update_method, # call instance method "update_method" for found instances
-  on: -> { where("last_synced < ?", 7.days.ago) }, # Condition that must be true for update method to be called
+  on: -> { Item.where("last_synced < ?", 7.days.ago) }, # (Optional) Iterator/Array of instances to update. Empty array to skip update
   min_class_interval: 5.minutes, # (Optional) The minimum interval between calls to this specific class (TODO not implemented)
   max_retries: 25, # (Optional) Maximum number of retries. Periodically uses exponential backoff (TODO not implemented)
   instance_id: -> { cache_key_with_version }, # (Optional) Returns this instance's unique identifying key. Used for e.g. deferring jobs and marking them as erroring (TODO not implemented)

data/lib/periodically.rb

@@ -2,11 +2,14 @@
 
 require "logger"
 
-require "periodically/job"
 require "periodically/debug"
 require "periodically/defer"
-require "periodically/redis"
+require "periodically/error_counts"
+require "periodically/error_messages"
+require "periodically/job"
+require "periodically/locks"
 require "periodically/model"
+require "periodically/redis"
 
 module Periodically
   @@registered = []

data/lib/periodically/debug.rb

@@ -4,11 +4,11 @@ module Periodically
   module Debug
     def self.total_debug_dump
       error_counts = Periodically.redis do |conn|
-        keys = conn.scan_each(:match => "errors:*").to_a
+        keys = conn.keys("errors:*").to_a
         if keys.length == 0
           {}
         else
-          values = conn.mget(keys)
+          values = conn.mget(keys).map(&:to_i)
           Hash[keys.zip(values)]
         end
       end

data/lib/periodically/error_counts.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Periodically
+  module ErrorCounts
+    def self.get(key)
+      Periodically.redis {|conn| conn.get(error_count_key(key))}.to_i
+    end
+
+    def self.increment(key)
+      Periodically.redis {|conn| conn.incr(error_count_key(key))}
+    end
+
+    def self.reset(key)
+      Periodically.redis {|conn| conn.del(error_count_key(key))}
+    end
+
+    def self.reset_all
+      Periodically.redis do |conn|
+        keys = conn.keys("errors:*")
+        conn.del(keys)
+      end
+    end
+
+    private
+
+    def self.error_count_key(key)
+      "errors:#{key}"
+    end
+  end
+end

data/lib/periodically/error_messages.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Periodically
+  module ErrorMessages
+    def self.store(key, err)
+      stored_error = "#{err.message}\n#{err.backtrace.join("\n")}"
+      Periodically.redis {|conn| conn.set(error_message_key(key), stored_error)}
+    end
+
+    def self.get_latest(key)
+      Periodically.redis {|conn| conn.get(error_message_key(key))}
+    end
+
+    def self.clear_all
+      Periodically.redis do |conn|
+        keys = conn.keys("error_messages:*")
+        conn.del(keys)
+      end
+    end
+
+    private
+
+    def self.error_message_key(key)
+      "error_messages:#{key}"
+    end
+  end
+end

data/lib/periodically/job.rb

@@ -13,11 +13,11 @@ module Periodically
     end
 
     def poll_next_instance
-      return if job_or_class_locked?
+      return if Periodically::Locks.locked?(@job_key, @class_key)
 
       where = @opts[:on].call()
       where.to_a.find do |obj|
-        !instance_locked?(obj)
+        !Periodically::Locks.locked?(instance_key(obj))
       end
     end
 
@@ -26,23 +26,22 @@ module Periodically
         begin
           instance.send(@method)
         rescue => e
-          stored_error = "#{e.message}\n#{e.backtrace.join("\n")}"
-          Periodically.logger.error("Job instance[#{instance}] execution raised an exception\n#{stored_error}")
-          new_error_count = increase_instance_error_count(instance)
-          lock_instance(instance, DEFAULT_ERROR_DELAY.call(new_error_count))
-          store_instance_error(instance, stored_error)
+          Periodically.logger.error("Job instance[#{instance}] execution raised an exception\n#{e.message}")
+          new_error_count = Periodically::ErrorCounts.increment(instance_key(instance))
+          Periodically::Locks.lock(instance_key(instance), DEFAULT_ERROR_DELAY.call(new_error_count))
+          Periodically::ErrorMessages.store(instance_key(instance), e)
           return
         end
 
       if return_value.is_a?(Periodically::Defer::DeferInstance)
-        lock_instance(instance, return_value.duration)
+        Periodically::Locks.lock(instance_key(instance), return_value.duration)
       elsif return_value.is_a?(Periodically::Defer::DeferJob)
-        Job.lock_key("locks:#{@job_key}", return_value.duration)
+        Periodically::Locks.lock(@job_key, return_value.duration)
       elsif return_value.is_a?(Periodically::Defer::DeferClass)
-        Job.lock_key("locks:#{@class_key}", return_value.duration)
+        Periodically::Locks.lock(@class_key, return_value.duration)
       end
 
-      clear_instance_error_count(instance)
+      Periodically::ErrorCounts.reset(instance_key(instance))
     end
 
     private
@@ -50,44 +49,5 @@ module Periodically
     def instance_key(instance)
       "#{@job_key}/#{instance.id}"
     end
-
-    def increase_instance_error_count(instance)
-      error_count_key = "errors:#{instance_key(instance)}"
-      Periodically.redis {|conn| conn.incr(error_count_key)}
-    end
-
-    def clear_instance_error_count(instance)
-      error_count_key = "errors:#{instance_key(instance)}"
-      Periodically.redis {|conn| conn.del(error_count_key)}
-    end
-
-    def store_instance_error(instance, error)
-      error_message_key = "errormessages:#{instance_key(instance)}"
-      Periodically.redis {|conn| conn.set(error_message_key, error)}
-    end
-
-    def job_or_class_locked?
-      Periodically.redis do |conn|
-        # TODO can this be optimized with exists?(Array)
-        conn.exists("locks:#{@job_key}") || conn.exists("locks:#{@class_key}")
-      end
-    end
-
-    def instance_locked?(instance)
-      Periodically.redis {|conn| conn.exists("locks:#{instance_key(instance)}")}
-    end
-
-    def lock_instance(instance, seconds)
-      Job.lock_key("locks:#{instance_key(instance)}", seconds)
-    end
-
-    def self.lock_key(key, seconds)
-      Periodically.redis do |conn|
-        conn.multi do |multi|
-          multi.set(key, "1")
-          multi.expire(key, seconds)
-        end
-      end
-    end
   end
 end

data/lib/periodically/locks.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Periodically
+  module Locks
+    def self.locked?(*keys)
+      return false if keys.empty?
+      lkeys = keys.map { |key| lock_key(key) }
+
+      Periodically.redis do |conn|
+        lkeys.any? { |lkey| conn.exists(lkey) }
+      end
+    end
+
+    def self.lock(key, seconds)
+      lkey = lock_key(key)
+
+      Periodically.redis do |conn|
+        conn.multi do |multi|
+          multi.set(lkey, "1")
+          multi.expire(lkey, seconds)
+        end
+      end
+    end
+
+    def self.remaining(key)
+      lkey = lock_key(key)
+
+      Periodically.redis do |conn|
+        remaining = conn.ttl(lkey)
+        return nil if remaining == -1
+        remaining
+      end
+    end
+
+    def self.reset_all
+      Periodically.redis do |conn|
+        keys = conn.keys("locks:*")
+        conn.del(keys)
+      end
+    end
+
+    private
+
+    def self.lock_key(key)
+      "locks:#{key}"
+    end
+  end
+end

data/periodically.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |gem|
 
   gem.files = `git ls-files | grep -Ev '^(test|myapp|examples)'`.split("\n")
   gem.name = "periodically"
-  gem.version = "0.0.7"
+  gem.version = "0.0.8"
   gem.required_ruby_version = ">= 2.5.0"
 
   gem.add_dependency "redis", ">= 4.1.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: periodically
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - wyozi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-10 00:00:00.000000000 Z
+date: 2020-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -68,7 +68,10 @@ files:
 - lib/periodically/cli.rb
 - lib/periodically/debug.rb
 - lib/periodically/defer.rb
+- lib/periodically/error_counts.rb
+- lib/periodically/error_messages.rb
 - lib/periodically/job.rb
+- lib/periodically/locks.rb
 - lib/periodically/model.rb
 - lib/periodically/redis.rb
 - periodically.gemspec