crono_trigger 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d3157a417d9c99b0da61ea75d9c9efc0af12a1f1f15cc3af121b4b3d673757
-  data.tar.gz: 52c3683c6e3116cfa34b41e83a6b830f63b0f65e4cf49377cc87548b4dc4c5f4
+  metadata.gz: 7a1befee8d18a2c52458baa240cc2b12a8d9fea015a53647c0f098cae21d062d
+  data.tar.gz: c6fad9a37fdf912c88712c93b64ace75386b9c2f37cdc9bcf609de711a7b8939
 SHA512:
-  metadata.gz: 63f1eee5323fd5c1fff137c4d4204b06b9aca648d97d82cc3168fecda11d95d65d771a4b063615dbe4e5ac7b5767e888b02b4f3cbbafd09c912a122601060391
-  data.tar.gz: b30388357a341e278474d410b5a907e690ac1c97986b4e779fda3a4430d73b76c1aee8ea505cd5852223a63e9983b81b50b2a8a80d97cb9b44825b0071afeb2b
+  metadata.gz: 7d383986c2c68d31dbe6fa681599816e564c07dfa3bba92c4edf9cb8b581b934293636446d97a85c2fec87f64af9cd2c81b7ec6edcfc89fe9c905dac6ce1eaf3
+  data.tar.gz: 4940e47e60802b4cf2caab3eee22069ba61e1f81b0178b1f696c485c330b5b5340d9d058764f70e40a608839cb2d35354ea877e3bbe32c9377d61fbbaa71233c

data/.travis.yml

@@ -2,8 +2,8 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5.1
-  - 2.4.3
+  - 2.6.1
+  - 2.5.2
 gemfile:
   - gemfiles/activerecord-51.gemfile
   - gemfiles/activerecord-52.gemfile
@@ -12,3 +12,5 @@ before_install:
 env:
   - DB=sqlite
   - DB=mysql MYSQL_RESTART_COMMAND="sudo service mysql restart"
+  - NO_TIMESTAMP=false
+  - NO_TIMESTAMP=true

data/README.md

@@ -70,7 +70,7 @@ class CreateMailNotifications < ActiveRecord::Migration
       t.datetime  :next_execute_at
       t.datetime  :last_executed_at
       t.integer   :execute_lock, limit: 8, default: 0, null: false
-      t.datetime  :started_at, null: false
+      t.datetime  :started_at
       t.datetime  :finished_at
       t.string    :last_error_name
       t.string    :last_error_reason
@@ -118,7 +118,7 @@ class MailNotification < ActiveRecord::Base
 end
 
 # one time schedule
-MailNotification.create(next_execute_at: Time.current.since(5.minutes))
+MailNotification.create.activate_schedule!(at: Time.current.since(5.minutes))
 
 # cron schedule
 MailNotification.create(cron: "0 12 * * *").activate_schedule!

data/Rakefile

@@ -10,11 +10,13 @@ pwd = File.expand_path('../', __FILE__)
 gemfiles = Dir.glob(File.join(pwd, "gemfiles", "*.gemfile")).map { |f| File.basename(f, ".*") }
 
 namespace :js do
+  desc "Cleanup built javascripts"
   task :clean do
     rm_r(File.join(pwd, "web", "app", "build")) if File.exist?(File.join(pwd, "web", "app", "build"))
     rm_r(File.join(pwd, "web", "public"))
   end
 
+  desc "build javascripts"
   task build: [:clean] do
     Dir.chdir(File.join(pwd, "web", "app"))
     sh({"PUBLIC_URL" => "<%= URI.parse(url('/')).path.chop %>"}, "npm run build") do |ok, res|

data/crono_trigger.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "oj"
   spec.add_dependency "activerecord", ">= 4.2"
 
-  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "sqlite3", "~> 1.3.6"
   spec.add_development_dependency "mysql2"
   spec.add_development_dependency "timecop"
   spec.add_development_dependency "rollbar"

data/lib/crono_trigger.rb

@@ -6,6 +6,7 @@ require "active_record"
 require "concurrent"
 require "crono_trigger/models/worker"
 require "crono_trigger/models/signal"
+require "crono_trigger/models/execution"
 require "crono_trigger/worker"
 require "crono_trigger/polling_thread"
 require "crono_trigger/schedulable"

data/lib/crono_trigger/execution_tracker.rb

@@ -0,0 +1,22 @@
+module CronoTrigger
+  class ExecutionTracker
+    def initialize(schedulable)
+      @schedulable = schedulable
+    end
+
+    def track(&pr)
+      if @schedulable.track_execution
+        begin
+          execution = @schedulable.crono_trigger_executions.create_with_timestamp!
+          pr.call
+          execution.complete!
+        rescue => e
+          execution.error!(e)
+          raise
+        end
+      else
+        pr.call
+      end
+    end
+  end
+end

data/lib/crono_trigger/models/execution.rb

@@ -0,0 +1,35 @@
+module CronoTrigger
+  module Models
+    class Execution < ActiveRecord::Base
+      self.table_name = "crono_trigger_executions"
+
+      belongs_to :schedule, polymorphic: true, inverse_of: :crono_trigger_executions
+
+      scope :recently, ->(schedule_type:) { where(schedule_type: schedule_type).order(executed_at: :desc) }
+
+      enum status: {
+        executing: "executing", 
+        completed: "completed",
+        failed: "failed",
+      }
+
+      def self.create_with_timestamp!
+        create!(executed_at: Time.current, status: :executing, worker_id: CronoTrigger.config.worker_id)
+      end
+
+      def complete!
+        update!(status: :completed, completed_at: Time.current)
+      end
+
+      def error!(exception)
+        update!(status: :failed, completed_at: Time.current, error_name: exception.class.to_s, error_reason: exception.message)
+      end
+
+      def retry!
+        return false if schedule.locking?
+
+        schedule.retry!
+      end
+    end
+  end
+end

data/lib/crono_trigger/polling_thread.rb

@@ -85,7 +85,9 @@ module CronoTrigger
 
     private def unlock_overflowed_records(model, overflowed_record_ids)
       model.connection_pool.with_connection do
-        model.where(id: overflowed_record_ids).crono_trigger_unlock_all!
+        unless overflowed_record_ids.empty?
+          model.where(id: overflowed_record_ids).crono_trigger_unlock_all!
+        end
       end
     rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::LockWaitTimeout, ActiveRecord::StatementTimeout, ActiveRecord::Deadlocked
       sleep 1

data/lib/crono_trigger/schedulable.rb

@@ -4,6 +4,7 @@ require "chrono"
 require "tzinfo"
 
 require "crono_trigger/exception_handler"
+require "crono_trigger/execution_tracker"
 
 module CronoTrigger
   module Schedulable
@@ -26,9 +27,12 @@ module CronoTrigger
 
     included do
       CronoTrigger::Schedulable.included_by << self
-      class_attribute :crono_trigger_options, :executable_conditions
+      class_attribute :crono_trigger_options, :executable_conditions, :track_execution
       self.crono_trigger_options ||= {}
       self.executable_conditions ||= []
+      self.track_execution ||= false
+
+      has_many :crono_trigger_executions, class_name: "CronoTrigger::Models::Execution", as: :schedule, inverse_of: :schedule
 
       define_model_callbacks :execute, :retry
 
@@ -36,7 +40,7 @@ module CronoTrigger
         t = arel_table
 
         rel = where(t[crono_trigger_column_name(:next_execute_at)].lteq(from))
-        rel = rel.where(t[crono_trigger_column_name(:execute_lock)].lteq(from.to_i - execute_lock_timeout)) unless including_locked
+        rel = rel.where(t[crono_trigger_column_name(:execute_lock)].lt(from.to_i - execute_lock_timeout)) unless including_locked
 
         rel = rel.where(t[crono_trigger_column_name(:started_at)].lteq(from)) if column_names.include?(crono_trigger_column_name(:started_at))
         rel = rel.where(t[crono_trigger_column_name(:finished_at)].gt(from).or(t[crono_trigger_column_name(:finished_at)].eq(nil)))  if column_names.include?(crono_trigger_column_name(:finished_at))
@@ -61,17 +65,18 @@ module CronoTrigger
 
     module ClassMethods
       def executables_with_lock(limit: CronoTrigger.config.executor_thread * 3 || 100)
-        records = nil
-        transaction do
-          records = executables(limit: limit).lock.to_a
-          unless records.empty?
-            where(id: records).update_all(
-              crono_trigger_column_name(:execute_lock) => Time.current.to_i,
-              crono_trigger_column_name(:locked_by) => CronoTrigger.config.worker_id
-            )
+        ids = executables(limit: limit).pluck(:id)
+        records = []
+        ids.each do |id|
+          transaction do
+            r = all.lock.find(id)
+            unless r.locking?
+              r.crono_trigger_lock!
+              records << r
+            end
           end
-          records
         end
+        records
       end
 
       def crono_trigger_column_name(name)
@@ -106,12 +111,15 @@ module CronoTrigger
     end
 
     def do_execute
+      execution_tracker = ExecutionTracker.new(self)
       run_callbacks :execute do
         catch(:ok_without_reset) do
           catch(:ok) do
             catch(:retry) do
               catch(:abort) do
-                execute
+                execution_tracker.track do
+                  execute
+                end
                 throw :ok
               end
               raise AbortExecution
@@ -151,16 +159,23 @@ module CronoTrigger
       if new_record?
         self.attributes = attributes
       else
+        merge_updated_at_for_crono_trigger!(attributes)
         update_columns(attributes)
       end
+
+      self
     end
 
-    def retry!
+    def retry!(immediately: false)
       run_callbacks :retry do
         logger.info "Retry #{self.class}-#{id}" if logger
 
         now = Time.current
-        wait = crono_trigger_options[:exponential_backoff] ? retry_interval * [2 * (retry_count - 1), 1].max : retry_interval
+        if immediately
+          wait = 0
+        else
+          wait = crono_trigger_options[:exponential_backoff] ? retry_interval * [2 * (retry_count - 1), 1].max : retry_interval
+        end
         attributes = {
           crono_trigger_column_name(:next_execute_at) => now + wait,
           crono_trigger_column_name(:execute_lock) => 0,
@@ -171,6 +186,7 @@ module CronoTrigger
           attributes.merge!(retry_count: retry_count.to_i + 1)
         end
 
+        merge_updated_at_for_crono_trigger!(attributes, now)
         update_columns(attributes)
       end
     end
@@ -184,22 +200,36 @@ module CronoTrigger
         crono_trigger_column_name(:locked_by) => nil,
       }
 
+      now = Time.current
+
       if update_last_executed_at && self.class.column_names.include?(crono_trigger_column_name(:last_executed_at))
-        attributes.merge!(crono_trigger_column_name(:last_executed_at) => Time.current)
+        attributes.merge!(crono_trigger_column_name(:last_executed_at) => now)
       end
 
       if self.class.column_names.include?("retry_count")
         attributes.merge!(retry_count: 0)
       end
 
+      merge_updated_at_for_crono_trigger!(attributes, now)
+      update_columns(attributes)
+    end
+
+    def crono_trigger_lock!
+      attributes = {
+        crono_trigger_column_name(:execute_lock) => Time.current.to_i,
+        crono_trigger_column_name(:locked_by) => CronoTrigger.config.worker_id
+      }
+      merge_updated_at_for_crono_trigger!(attributes)
       update_columns(attributes)
     end
 
     def crono_trigger_unlock!
-      update_columns(
+      attributes = {
         crono_trigger_column_name(:execute_lock) => 0,
         crono_trigger_column_name(:locked_by) => nil,
-      )
+      }
+      merge_updated_at_for_crono_trigger!(attributes)
+      update_columns(attributes)
     end
 
     def crono_trigger_status
@@ -223,7 +253,7 @@ module CronoTrigger
 
     def locking?(at: Time.now)
       self[crono_trigger_column_name(:execute_lock)] > 0 && 
-        self[crono_trigger_column_name(:execute_lock)] > at.to_i - self.class.execute_lock_timeout
+        self[crono_trigger_column_name(:execute_lock)] >= at.to_f - self.class.execute_lock_timeout
     end
 
     def assume_executing?
@@ -298,7 +328,14 @@ module CronoTrigger
         attributes.merge!(last_error_time: now)
       end
 
+      merge_updated_at_for_crono_trigger!(attributes)
       update_columns(attributes) unless attributes.empty?
     end
+
+    def merge_updated_at_for_crono_trigger!(attributes, time = Time.current)
+      if self.class.column_names.include?("updated_at")
+        attributes.merge!("updated_at" => time)
+      end
+    end
   end
 end

data/lib/crono_trigger/version.rb

@@ -1,3 +1,3 @@
 module CronoTrigger
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/crono_trigger/web.rb

@@ -1,6 +1,7 @@
 require "crono_trigger"
 require "sinatra/base"
 require "rack/contrib/post_body_content_type_parser"
+require "oj"
 
 module CronoTrigger
   class Web < Sinatra::Application
@@ -87,6 +88,13 @@ module CronoTrigger
       end
     end
 
+
+    post "/models/executions/:id/retry" do
+      CronoTrigger::Models::Execution.find(params[:id]).retry!
+      status 200
+      body ""
+    end
+
     post "/models/:name/:id/retry" do
       model_class = CronoTrigger::Schedulable.included_by.find { |c| c.name == params[:name] }
       if model_class
@@ -110,22 +118,22 @@ module CronoTrigger
           now = Time.now
           records = @scheduled_records.map do |r|
             {
-              "crono_trigger_status" => r.crono_trigger_status,
-              "id" => r.id,
-              "cron" => r[r.crono_trigger_column_name(:cron)],
-              "next_execute_at" => r[r.crono_trigger_column_name(:next_execute_at)],
-              "last_executed_at" => r[r.crono_trigger_column_name(:last_executed_at)],
-              "timezone" => r[r.crono_trigger_column_name(:timezone)],
-              "execute_lock" => r[r.crono_trigger_column_name(:execute_lock)],
-              "locked_by" => r[r.crono_trigger_column_name(:locked_by)],
-              "started_at" => r[r.crono_trigger_column_name(:started_at)],
-              "finished_at" => r[r.crono_trigger_column_name(:finished_at)],
-              "last_error_name" => r[r.crono_trigger_column_name(:last_error_name)],
-              "last_error_reason" => r[r.crono_trigger_column_name(:last_error_reason)],
-              "last_error_time" => r[r.crono_trigger_column_name(:last_error_time)],
-              "retry_count" => r[r.crono_trigger_column_name(:retry_count)],
-              "time_to_unlock" => [(r.class.execute_lock_timeout + r[r.crono_trigger_column_name(:execute_lock)]) - now.to_i, 0].max,
-              "delay_sec" => r.locking?(at: now) ? 0 : (now - r[r.crono_trigger_column_name(:next_execute_at)]).to_i,
+              -"crono_trigger_status" => r.crono_trigger_status,
+              -"id" => r.id,
+              -"cron" => r[r.crono_trigger_column_name(:cron)],
+              -"next_execute_at" => r[r.crono_trigger_column_name(:next_execute_at)],
+              -"last_executed_at" => r[r.crono_trigger_column_name(:last_executed_at)],
+              -"timezone" => r[r.crono_trigger_column_name(:timezone)],
+              -"execute_lock" => r[r.crono_trigger_column_name(:execute_lock)],
+              -"locked_by" => r[r.crono_trigger_column_name(:locked_by)],
+              -"started_at" => r[r.crono_trigger_column_name(:started_at)],
+              -"finished_at" => r[r.crono_trigger_column_name(:finished_at)],
+              -"last_error_name" => r[r.crono_trigger_column_name(:last_error_name)],
+              -"last_error_reason" => r[r.crono_trigger_column_name(:last_error_reason)],
+              -"last_error_time" => r[r.crono_trigger_column_name(:last_error_time)],
+              -"retry_count" => r[r.crono_trigger_column_name(:retry_count)],
+              -"time_to_unlock" => [(r.class.execute_lock_timeout + r[r.crono_trigger_column_name(:execute_lock)]) - now.to_i, 0].max,
+              -"delay_sec" => r.locking?(at: now) ? 0 : (now - r[r.crono_trigger_column_name(:next_execute_at)]).to_i,
             }
           end
           Oj.dump({
@@ -159,5 +167,38 @@ module CronoTrigger
     get "/models" do
       erb :index
     end
+
+    get "/models/:name/executions.:format" do
+      if params[:format] == "json"
+        model_class = CronoTrigger::Schedulable.included_by.find { |c| c.name == params[:name] }
+        if model_class
+          rel = CronoTrigger::Models::Execution.recently(schedule_type: model_class)
+          rel.where!("executed_at >= ?", Time.parse(params[:from])) if params[:from]
+          rel.where!("executed_at <= ?", Time.parse(params[:to])) if params[:to]
+          rel = rel.limit(params[:limit] || 100)
+          records = rel.map do |r|
+            {
+              -"id" => r.id,
+              -"schedule_id" => r.schedule_id,
+              -"schedule_type" => r.schedule_type,
+              -"worker_id" => r.worker_id,
+              -"executed_at" => r.executed_at,
+              -"completed_at" => r.completed_at,
+              -"status" => r.status,
+              -"error_name" => r.error_name,
+              -"error_reason" => r.error_reason,
+            }
+          end
+          Oj.dump({
+            records: records,
+          }, mode: :compat)
+        else
+          status 404
+          "Model Class is not found"
+        end
+      else
+        raise "unknown format"
+      end
+    end
   end
 end

data/lib/generators/crono_trigger/install/templates/install.rb

@@ -19,5 +19,20 @@ class CreateCronoTriggerSystemTables < ActiveRecord::Migration<%= Rails::VERSION
     end
 
     add_index :crono_trigger_signals, [:sent_at, :worker_id]
+
+    create_table :crono_trigger_executions do |t|
+      t.integer :schedule_id, null: false
+      t.string :schedule_type, null: false
+      t.string :worker_id, null: false
+      t.datetime :executed_at, null: false
+      t.datetime :completed_at
+      t.string :status, null: false, default: "executing"
+      t.string :error_name
+      t.string :error_reason
+    end
+
+    add_index :crono_trigger_executions, [:schedule_type, :schedule_id, :executed_at], name: "index_crono_trigger_executions_on_schtype_schid_executed_at"
+    add_index :crono_trigger_executions, [:schedule_type, :executed_at]
+    add_index :crono_trigger_executions, [:executed_at]
   end
 end