resque-job_history 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4014d5408bda6f84a8e9779ebc7d1fe26d7f1a31
+  data.tar.gz: 080997bc6cb436dfd7efc0cb505ceb5d707e0f80
+SHA512:
+  metadata.gz: f6826cd3babf4b41a3cb40d3abd32fa6eaca66b0aed7a1190c97855476e386082b7dfc5a16c77ee5455d6bb1963714153e76599191b87c22b5fc478297926a5b
+  data.tar.gz: 5a279b25e700dcfda034517029f6b587224e6050a48e98c850778700bfd77bcbe4de87830f60a0d2707c59b03f861fb957c0a3c0b6f273263862b5a36088fd66

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 RealNobody
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= ResqueJobHistory
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "ResqueJobHistory"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/resque-job_history.rb

@@ -0,0 +1,7 @@
+require "resque"
+require File.expand_path(File.join("resque", "plugins", "job_history", "history_base"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "job_history", "history_list"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "job_history", "job_list"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "job_history", "job"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "job_history", "cleaner"), File.dirname(__FILE__))
+require File.expand_path(File.join("resque", "plugins", "job_history"), File.dirname(__FILE__))

data/lib/resque/job_history_server.rb

@@ -0,0 +1,189 @@
+require "resque"
+require "resque/server"
+require "resque-job_history"
+require "action_view/helpers/date_helper"
+
+module Resque
+  # Extends Resque Web Based UI.
+  # Structure has been borrowed from ResqueHistory.
+  module JobHistoryServer
+    include ActionView::Helpers::DateHelper
+
+    class << self
+      def erb_path(filename)
+        File.join(File.dirname(__FILE__), "server", "views", filename)
+      end
+
+      def public_path(filename)
+        File.join(File.dirname(__FILE__), "server", "public", filename)
+      end
+
+      def included(base)
+        add_page_views(base)
+        add_button_callbacks(base)
+        add_static_files(base)
+      end
+
+      private
+
+      def add_page_views(base)
+        job_history(base)
+        class_details(base)
+        job_details(base)
+      end
+
+      def job_history(base)
+        job_history_params(base)
+
+        base.class_eval do
+          get "/job history" do
+            set_job_history_params
+
+            erb File.read(Resque::JobHistoryServer.erb_path("job_history.erb"))
+          end
+        end
+      end
+
+      def job_history_params(base)
+        base.class_eval do
+          def set_job_history_params
+            @sort_by    = params[:sort] || "class_name"
+            @sort_order = params[:order] || "asc"
+            @page_num   = (params[:page_num] || 1).to_i
+            @page_size  = (params[:page_size] || Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE).to_i
+          end
+        end
+      end
+
+      def class_details(base)
+        class_details_params(base)
+        running_page_params(base)
+        finished_page_params(base)
+
+        base.class_eval do
+          get "/job history/job_class_details" do
+            set_class_details_params
+
+            erb File.read(Resque::JobHistoryServer.erb_path("job_class_details.erb"))
+          end
+        end
+      end
+
+      def class_details_params(base)
+        base.class_eval do
+          def set_class_details_params
+            @job_class_name = params[:class_name]
+            set_running_page_params
+            set_finished_page_params
+          end
+        end
+      end
+
+      def running_page_params(base)
+        base.class_eval do
+          def set_running_page_params
+            @running_page_num  = (params[:running_page_num] || 1).to_i
+            @running_page_size = (params[:running_page_size] ||
+                Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE).to_i
+          end
+        end
+      end
+
+      def finished_page_params(base)
+        base.class_eval do
+          def set_finished_page_params
+            @finished_page_num  = (params[:finished_page_num] || 1).to_i
+            @finished_page_size = (params[:finished_page_size] ||
+                Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE).to_i
+          end
+        end
+      end
+
+      def job_details(base)
+        base.class_eval do
+          get "/job history/job_details" do
+            @job_class_name = params[:class_name]
+            @job_id         = params[:job_id]
+
+            erb File.read(Resque::JobHistoryServer.erb_path("job_details.erb"))
+          end
+        end
+      end
+
+      def add_static_files(base)
+        base.class_eval do
+          get %r{job_history/public/([a-z_]+\.[a-z]+)} do
+            send_file Resque::JobHistoryServer.public_path(params[:captures].first)
+          end
+        end
+      end
+
+      def add_button_callbacks(base)
+        purge_all(base)
+        purge_class(base)
+        retry_job(base)
+        delete_job(base)
+        cancel_job(base)
+      end
+
+      def cancel_job(base)
+        base.class_eval do
+          post "/job history/cancel_job" do
+            Resque::Plugins::JobHistory::Job.new(params[:class_name], params[:job_id]).cancel
+
+            redirect u("job history/job_details?#{{ class_name: params[:class_name],
+                                                    job_id:     params[:job_id] }.to_param}")
+          end
+        end
+      end
+
+      def delete_job(base)
+        base.class_eval do
+          post "/job history/delete_job" do
+            Resque::Plugins::JobHistory::Job.new(params[:class_name], params[:job_id]).purge
+
+            redirect u("job history/job_class_details?#{{ class_name: params[:class_name] }.to_param}")
+          end
+        end
+      end
+
+      def retry_job(base)
+        base.class_eval do
+          post "/job history/retry_job" do
+            Resque::Plugins::JobHistory::Job.new(params[:class_name], params[:job_id]).retry
+
+            redirect u("job history/job_class_details?#{{ class_name: params[:class_name] }.to_param}")
+          end
+        end
+      end
+
+      def purge_class(base)
+        base.class_eval do
+          post "/job history/purge_class" do
+            Resque::Plugins::JobHistory::Cleaner.purge_class(params[:class_name])
+
+            redirect u("job history")
+          end
+        end
+      end
+
+      def purge_all(base)
+        base.class_eval do
+          post "/job history/purge_all" do
+            Resque::Plugins::JobHistory::Cleaner.purge_all_jobs
+
+            redirect u("job history")
+          end
+        end
+      end
+    end
+
+    Resque::Server.tabs << "Job History"
+  end
+end
+
+Resque.extend Resque::JobHistoryServer
+
+Resque::Server.class_eval do
+  include Resque::JobHistoryServer
+end

data/lib/resque/plugins/job_history.rb

@@ -0,0 +1,63 @@
+require "active_support/concern"
+
+module Resque
+  module Plugins
+    # Include in a Resque Job to keep a history of the execution of the job.
+    # Every job keeps its own independent history so that you can see when an individual job was run.
+    module JobHistory
+      extend ActiveSupport::Concern
+
+      # Redis mapp:
+      #   job_history - a set of all of the class names of all jobs
+      #   job_history.<class_name>.max_jobs - The maximum number of jobs that have run for this class.
+      #   job_history.<class_name>.total_finished_jobs - The maximum number of jobs that have run for
+      #                                                  this class.
+      #   job_history.<class_name>.running_jobs - a list of the IDs for all running jobs in the order
+      #                                          they were started.
+      #   job_history.<class_name>.finished_jobs - a list of rhe IDs for all finished jobs in the
+      #                                           order they completed.
+      #   job_history.<class_name>.<job_id> - a hash of values detailing the job
+      #     start_time
+      #     args - JSON encoded array of encoded args
+      #     end_time
+      #     error
+      MAX_JOB_HISTORY = 200
+
+      # The class methods added to the job class that is being enqueued and whose history is to be
+      # recorded.
+      module ClassMethods
+        attr_reader :running_job
+
+        def before_perform_job_history(*args)
+          running_job.cancel if running_job
+
+          @running_job = Resque::Plugins::JobHistory::Job.new(name, SecureRandom.uuid)
+
+          running_job.start(*args)
+        end
+
+        def after_perform_job_history(*_args)
+          running_job.try(:finish)
+          @running_job = nil
+        end
+
+        def on_failure_job_history(exception, *_args)
+          running_job.try(:failed, exception)
+          @running_job = nil
+        end
+
+        def job_history_len
+          @job_history_len || MAX_JOB_HISTORY
+        end
+
+        def purge_age
+          @purge_jobs_after || 24.hours
+        end
+
+        def page_size
+          @page_size || Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_history/cleaner.rb

@@ -0,0 +1,92 @@
+module Resque
+  module Plugins
+    module JobHistory
+      # JobHistory cleanup functions to allow the user to cleanup Redis for histories.
+      class Cleaner
+        class << self
+          def clean_all_old_running_jobs
+            job_classes.each do |class_name|
+              Resque::Plugins::JobHistory::Job.new(class_name, "").clean_old_running_jobs
+            end
+          end
+
+          def fixup_all_keys
+            job_classes.each do |class_name|
+              fixup_job_keys class_name
+            end
+          end
+
+          def fixup_job_keys(class_name)
+            keys = job_keys(class_name)
+            keys -= Resque::Plugins::JobHistory::HistoryList.new(class_name, "running").job_ids
+            keys -= Resque::Plugins::JobHistory::HistoryList.new(class_name, "finished").job_ids
+
+            keys.each do |stranded_key|
+              del_key(stranded_key, "Stranded job key deleted")
+            end
+          end
+
+          def purge_all_jobs
+            job_classes.each do |class_name|
+              purge_class class_name
+            end
+
+            del_key(Resque::Plugins::JobHistory::HistoryBase.new("").job_history_key,
+                    "Purging job_history_key")
+          end
+
+          def purge_invalid_jobs
+            viewer_klass.job_classes.each do |class_name|
+              next if Resque::Plugins::JobHistory::HistoryBase.new(class_name).class_name_valid?
+
+              purge_class(class_name)
+            end
+          end
+
+          def purge_class(class_name)
+            job_keys(class_name).each do |job_key|
+              del_key(job_key, "Purging job key")
+            end
+
+            job_support_keys(class_name).each do |support_key|
+              del_key(support_key, "Purging #{support_key}")
+            end
+          end
+
+          private
+
+          def job_classes
+            Resque::Plugins::JobHistory::JobList.new.job_classes
+          end
+
+          def job_keys(class_name)
+            history_base = Resque::Plugins::JobHistory::HistoryBase.new(class_name)
+
+            history_base.redis.keys("#{history_base.job_history_base_key}.*") - job_support_keys(history_base)
+          end
+
+          def job_support_keys(history_base)
+            if history_base.is_a?(String)
+              history_base = Resque::Plugins::JobHistory::HistoryBase.new(history_base)
+            end
+
+            ["#{history_base.job_history_base_key}.running_jobs",
+             "#{history_base.job_history_base_key}.total_running_jobs",
+             "#{history_base.job_history_base_key}.finished_jobs",
+             "#{history_base.job_history_base_key}.total_finished_jobs",
+             "#{history_base.job_history_base_key}.max_jobs"]
+          end
+
+          def redis
+            @redis ||= Resque::Plugins::JobHistory::HistoryBase.new("").redis
+          end
+
+          def del_key(key, message)
+            Resque.logger.warn("#{message} - #{key}")
+            redis.del key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_history/history_base.rb

@@ -0,0 +1,61 @@
+module Resque
+  module Plugins
+    module JobHistory
+      # A base class for job history classes which provides a base key and a few common functions.
+      class HistoryBase
+        attr_accessor :class_name
+
+        NAME_SPACE = "Resque::Plugins::ResqueJobHistory".freeze
+        PAGE_SIZE  = 25
+
+        def initialize(class_name)
+          @class_name = class_name
+        end
+
+        def redis
+          @redis ||= Redis::Namespace.new(NAME_SPACE, redis: Resque.redis)
+        end
+
+        def job_history_key
+          "job_history"
+        end
+
+        def job_history_base_key
+          "#{job_history_key}.#{class_name}"
+        end
+
+        def running_list
+          @running_list = HistoryList.new(class_name, "running")
+        end
+
+        def finished_list
+          @finished_list = HistoryList.new(class_name, "finished")
+        end
+
+        def class_name_valid?
+          described_class.present?
+        end
+
+        private
+
+        def described_class
+          class_name.constantize
+        rescue StandardError
+          nil
+        end
+
+        def class_purge_age
+          described_class.try(:purge_age) || 24.hours
+        end
+
+        def class_history_len
+          described_class.try(:job_history_len) || MAX_JOB_HISTORY
+        end
+
+        def class_page_size
+          described_class.try(:page_size) || Resque::Plugins::JobHistory::HistoryBase::PAGE_SIZE
+        end
+      end
+    end
+  end
+end