resque-job_history 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b694b3138b29678d77992c3bd60b5a2dfeeac281
-  data.tar.gz: 6052e79345a6d3893268547f67226498381489b7
+  metadata.gz: 3e5bff0c1faf1c5b7320a96c5b085e8baf35b712
+  data.tar.gz: 4ada6c6a3fc999730bba715e840285e1e6b9dfd1
 SHA512:
-  metadata.gz: ede3b231cae7051dff2d3b0194a664acc49ceac54f031a6f968f21ebe90fc991778363075a375d38e18506cc909ac44143fc52dcc94bbe6b6dd3eb3723ff53c1
-  data.tar.gz: a485d45ac90bec11610da58dd6f7b862690665bcaab7f06dd0746d5ec70d24e0c79ddc1d6af0d087678f0ed6501deea81fadaf039adc06e37167496ef2e64d28
+  metadata.gz: 7510483ab78cdd4571de32e388235a654d7c1afa71eac5dc28f951eca1c34401b6dcd84b6715907c24346d7579146f198a7e3b885952733d592294d68f822c1a
+  data.tar.gz: e75083c6ae8aaf7141ad8541127bd44368876c7e797b0b930101f5d5da0243f8f26e611a31206f341eb0c3ee4feecdf09464137ec83db213d5e1bfffa585c41f

data/lib/resque/job_history_server.rb

@@ -32,6 +32,7 @@ module Resque
         job_history(base)
         class_details(base)
         job_details(base)
+        linear_list(base)
       end
 
       def job_history(base)
@@ -49,8 +50,8 @@ module Resque
       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"
+            @sort_by    = params[:sort] || "start_time"
+            @sort_order = params[:order] || "desc"
             @page_num   = (params[:page_num] || 1).to_i
             @page_size  = (params[:page_size] ||
                 Resque::Plugins::JobHistory::HistoryDetails.class_list_page_size).to_i
@@ -113,6 +114,18 @@ module Resque
         end
       end
 
+      def linear_list(base)
+        base.class_eval do
+          get "/job history/linear_history" do
+            @page_num  = (params[:page_num] || 1).to_i
+            @page_size = (params[:page_size] ||
+                Resque::Plugins::JobHistory::HistoryDetails.linear_page_size).to_i
+
+            erb File.read(Resque::JobHistoryServer.erb_path("linear_history.erb"))
+          end
+        end
+      end
+
       def add_static_files(base)
         base.class_eval do
           get %r{job_history/public/([a-z_]+\.[a-z]+)} do

data/lib/resque/plugins/job_history.rb

@@ -12,9 +12,14 @@ module Resque
 
       # Redis mapp:
       #   job_history - a set of all of the class names of all jobs
+      #   job_history..linear_jobs - a list of the IDs for all jobs that have run in the order
+      #                                          they were started.
+      #   job_history..total_linear_jobs - The total number of jobs added to the linear list.
+      #   job_history..linear_job_classes - The total number of jobs added to the linear list.
       #   job_history.<class_name>.max_jobs - The maximum number of jobs that have run concurrently
       #                                       for this class.
-      #   job_history.<class_name>.total_failed_jobs - The total number of jobs that have failed
+      #   job_history.<class_name>.total_failed_jobs - The total number of jobs that have failed.
+      #   job_history.<class_name>.total_running_jobs - The total number of jobs that have been run.
       #   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

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

@@ -16,12 +16,11 @@ module Resque
             job_classes.each do |class_name|
               fixup_job_keys class_name
             end
+            fixup_linear_keys
           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 = unknown_job_keys(class_name)
 
             keys.each do |stranded_key|
               Resque::Plugins::JobHistory::Job.new(class_name, stranded_key).purge
@@ -29,6 +28,21 @@ module Resque
             end
           end
 
+          def fixup_linear_keys
+            details  = Resque::Plugins::JobHistory::HistoryDetails.new("")
+            hash_key = details.linear_jobs.job_classes_key
+
+            classes = details.redis.hgetall hash_key
+            job_ids = details.linear_jobs.job_ids
+
+            classes.keys.each do |job_id|
+              next if job_ids.include?(job_id)
+
+              Resque.logger.warn("deleting missing job class - #{job_id}")
+              details.redis.hdel hash_key, job_id
+            end
+          end
+
           def purge_all_jobs
             job_classes.each do |class_name|
               purge_class class_name
@@ -52,6 +66,10 @@ module Resque
           def purge_class(class_name)
             return if similar_name?(class_name)
 
+            details = Resque::Plugins::JobHistory::HistoryDetails.new("class_name")
+            details.running_jobs.jobs.each(&:purge)
+            details.finished_jobs.jobs.each(&:purge)
+
             class_keys(class_name).each do |job_key|
               del_key(job_key, "Purging job key")
             end
@@ -75,21 +93,42 @@ module Resque
             history_base.redis.keys("#{history_base.job_history_base_key}*")
           end
 
+          def job_id_keys(class_name, job_ids)
+            job_ids.map do |job_id|
+              "#{Resque::Plugins::JobHistory::HistoryDetails.job_history_key}.#{class_name}.#{job_id}"
+            end
+          end
+
           def job_keys(class_name)
             history_base = Resque::Plugins::JobHistory::HistoryDetails.new(class_name)
 
-            history_base.redis.keys("#{history_base.job_history_base_key}.*") - job_support_keys(history_base)
+            history_base.redis.keys("#{history_base.job_history_base_key}*") - job_support_keys(history_base)
           end
 
           def job_support_keys(history_base)
             ["#{history_base.job_history_base_key}.running_jobs",
              "#{history_base.job_history_base_key}.total_running_jobs",
+             "#{history_base.job_history_base_key}.running_job_classes",
+             "#{history_base.job_history_base_key}.linear_jobs",
+             "#{history_base.job_history_base_key}.total_linear_jobs",
+             "#{history_base.job_history_base_key}.linear_job_classes",
              "#{history_base.job_history_base_key}.finished_jobs",
              "#{history_base.job_history_base_key}.total_finished_jobs",
+             "#{history_base.job_history_base_key}.finished_job_classes",
              "#{history_base.job_history_base_key}.max_jobs",
              "#{history_base.job_history_base_key}.total_failed"]
           end
 
+          def unknown_job_keys(class_name)
+            keys = job_keys(class_name)
+            keys -= job_id_keys(class_name,
+                                Resque::Plugins::JobHistory::HistoryList.new(class_name, "running").job_ids)
+            keys -= job_id_keys(class_name,
+                                Resque::Plugins::JobHistory::HistoryList.new(class_name, "finished").job_ids)
+            keys - job_id_keys(class_name,
+                               Resque::Plugins::JobHistory::HistoryList.new("", "linear").job_ids)
+          end
+
           def redis
             @redis ||= Resque::Plugins::JobHistory::HistoryDetails.new("").redis
           end

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

@@ -7,7 +7,8 @@ module Resque
       class HistoryDetails
         attr_accessor :class_name
 
-        NAME_SPACE = "Resque::Plugins::ResqueJobHistory"
+        NAME_SPACE         = "Resque::Plugins::ResqueJobHistory"
+        MAX_LINEAR_HISTORY = 500
 
         class << self
           def job_history_key
@@ -16,11 +17,34 @@ module Resque
 
           def class_list_page_size=(value)
             @class_list_page_size = value
+            @class_list_page_size = 1 if @class_list_page_size < 1
           end
 
           def class_list_page_size
             @class_list_page_size ||= Resque::Plugins::JobHistory::PAGE_SIZE
           end
+
+          def linear_page_size=(value)
+            @linear_page_size = value
+            @linear_page_size = 1 if @linear_page_size < 1
+          end
+
+          def linear_page_size
+            @linear_page_size ||= Resque::Plugins::JobHistory::PAGE_SIZE
+          end
+
+          def max_linear_jobs
+            @max_linear_jobs ||= MAX_LINEAR_HISTORY
+          end
+
+          def max_linear_jobs=(value)
+            @max_linear_jobs = value
+
+            return unless @max_linear_jobs.present?
+
+            @max_linear_jobs = @max_linear_jobs.to_i
+            @max_linear_jobs = nil if @max_linear_jobs.negative?
+          end
         end
 
         def initialize(class_name)
@@ -43,6 +67,11 @@ module Resque
           @finished_list ||= HistoryList.new(class_name, "finished")
         end
 
+        def linear_jobs
+          @linear_list ||= HistoryList.new("", "linear",
+                                           Resque::Plugins::JobHistory::HistoryDetails.max_linear_jobs)
+        end
+
         def max_concurrent_jobs
           redis.get(max_running_key).to_i
         end
@@ -85,11 +114,13 @@ module Resque
         end
 
         def class_history_len
-          described_class.try(:job_history_len) || MAX_JOB_HISTORY
+          hist_len = described_class.try(:job_history_len) || MAX_JOB_HISTORY
+          hist_len.negative? ? 0 : hist_len
         end
 
         def class_page_size
-          described_class.try(:page_size) || Resque::Plugins::JobHistory::PAGE_SIZE
+          pg_size = described_class.try(:page_size) || Resque::Plugins::JobHistory::PAGE_SIZE
+          pg_size < 1 ? 1 : pg_size
         end
 
         def total_failed_key

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

@@ -7,16 +7,18 @@ module Resque
       class HistoryList < HistoryDetails
         attr_accessor :list_name
 
-        def initialize(class_name, list_name)
+        def initialize(class_name, list_name, list_maximum = nil)
           super(class_name)
 
-          @list_name = list_name
+          @list_name    = list_name
+          @list_maximum = list_maximum
         end
 
-        def add_job(job_id)
-          add_to_history
+        def add_job(job_id, class_name)
+          add_to_job_history
 
           job_count = redis.lpush(job_list_key, job_id)
+          save_class_information(job_id, class_name)
           redis.incr(total_jobs_key)
 
           delete_old_jobs(job_count)
@@ -24,6 +26,7 @@ module Resque
 
         def remove_job(job_id)
           redis.lrem(job_list_key, 0, job_id)
+          remove_job_data(job_id)
         end
 
         def paged_jobs(page_num = 1, job_page_size = nil)
@@ -38,7 +41,7 @@ module Resque
 
         def jobs(start = 0, stop = -1)
           job_ids(start, stop).map do |job_id|
-            Resque::Plugins::JobHistory::Job.new(class_name, job_id)
+            Resque::Plugins::JobHistory::Job.new(job_class(job_id), job_id)
           end
         end
 
@@ -57,20 +60,37 @@ module Resque
         def latest_job
           job_id = redis.lrange(job_list_key, 0, 0).first
 
-          Resque::Plugins::JobHistory::Job.new(class_name, job_id) if job_id
+          Resque::Plugins::JobHistory::Job.new(job_class(job_id), job_id) if job_id
+        end
+
+        def includes_job?(job_id)
+          job_ids.include?(job_id)
+        end
+
+        def job_classes_key
+          "#{job_history_base_key}.#{list_name}_job_classes"
         end
 
         private
 
-        def add_to_history
+        def add_to_job_history
+          return if class_name.blank?
+
           redis.sadd(Resque::Plugins::JobHistory::HistoryDetails.job_history_key, class_name)
         end
 
-        def delete_old_jobs(job_count)
-          max_jobs = class_history_len
+        def max_jobs
+          @list_maximum ||= class_history_len
+          @list_maximum = 0 if @list_maximum.negative?
+          @list_maximum
+        end
 
+        def delete_old_jobs(job_count)
           while job_count > max_jobs
-            Resque::Plugins::JobHistory::Job.new(class_name, redis.rpop(job_list_key)).purge
+            job_id = redis.rpop(job_list_key)
+            remove_job_data(job_id)
+
+            Resque::Plugins::JobHistory::Job.new(job_class(job_id), job_id).safe_purge
 
             job_count -= 1
           end
@@ -85,6 +105,20 @@ module Resque
         def job_list_key
           "#{job_history_base_key}.#{list_name}_jobs"
         end
+
+        def job_class(job_id)
+          redis.hget(job_classes_key, job_id) || class_name
+        end
+
+        def save_class_information(job_id, job_class_name)
+          return unless class_name.blank? || job_class_name != class_name
+
+          redis.hset job_classes_key, job_id, job_class_name
+        end
+
+        def remove_job_data(job_id)
+          redis.hdel(job_classes_key, job_id)
+        end
       end
     end
   end

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

@@ -47,7 +47,8 @@ module Resque
         end
 
         def start(*args)
-          num_jobs = running_jobs.add_job(job_id)
+          num_jobs = running_jobs.add_job(job_id, class_name)
+          linear_jobs.add_job(job_id, class_name)
 
           record_job_start(*args)
           record_num_jobs(num_jobs)
@@ -56,7 +57,7 @@ module Resque
         def finish
           redis.hset(job_key, "end_time", Time.now.utc.to_s)
 
-          finished_jobs.add_job(job_id)
+          finished_jobs.add_job(job_id, class_name)
           running_jobs.remove_job(job_id)
 
           reset
@@ -85,18 +86,31 @@ module Resque
           Resque.enqueue described_class, *args
         end
 
+        def safe_purge
+          return if running_jobs.includes_job?(job_id)
+          return if finished_jobs.includes_job?(job_id)
+          return if linear_jobs.includes_job?(job_id)
+
+          purge
+        end
+
         def purge
           # To keep the counts honest...
           cancel unless finished?
 
-          running_jobs.remove_job(job_id)
-          finished_jobs.remove_job(job_id)
+          remove_from_job_lists
 
           redis.del(job_key)
 
           reset
         end
 
+        def remove_from_job_lists
+          running_jobs.remove_job(job_id)
+          finished_jobs.remove_job(job_id)
+          linear_jobs.remove_job(job_id)
+        end
+
         private
 
         def record_job_start(*args)

data/lib/resque/plugins/version.rb

@@ -3,7 +3,7 @@
 module Resque
   module Plugins
     module JobHistory
-      VERSION = "0.0.5"
+      VERSION = "0.0.6"
     end
   end
 end

data/lib/resque/server/public/job_history.css

@@ -31,4 +31,8 @@
 .table_container {
     width:      100%;
     overflow-x: scroll;
-}
+}
+
+.job_history_error {
+    background-color: lightcoral;
+}

data/lib/resque/server/views/_jobs_list.erb

@@ -21,7 +21,7 @@
         <th>Error</th>
       </tr>
       <% jobs.each do |job_details| %>
-        <tr>
+        <tr<%= job_details.succeeded? ? "" : " class=\"job_history_error\"" %>>
           <td>
             <a href="job_details?class_name=<%= job_details.class_name %>&job_id=<%= job_details.job_id %>">
               <%= time_ago_in_words(job_details.start_time) %> ago

data/lib/resque/server/views/_linear_pagination.erb

@@ -0,0 +1,57 @@
+<div class="job_history_pagination_block">
+  <% total_pages = linear_history.num_jobs / page_size %>
+  <% total_pages += 1 if linear_history.num_jobs % page_size > 0 %>
+  <% page_num = 1 if page_num > total_pages || page_num < 1 %>
+  <% first_page = [1, page_num - 3].max %>
+  <% last_page = [total_pages, page_num + 3].min %>
+  <% last_page = page_num < 4 ? [total_pages, last_page + (4 - page_num)].min : last_page %>
+  <% first_page = page_num > total_pages - 3 ? [1, first_page + ((total_pages - page_num) - 3)].max : first_page %>
+
+  <% if total_pages > 1 %>
+    <div class="job_history_prev_links">
+      <a href="linear_history?<%= { "page_size" => page_size,
+                                    "page_num"  => 1 }.to_param %>"
+         class="job_history_first_page"
+         disabled="<%= first_page > 1 %>">
+        &lt;&lt; First
+      </a>
+
+      <a href="linear_history?<%= { "page_size" => page_size,
+                                    "page_num"  => [1, page_num - 1].max }.to_param %>"
+         class="job_history_prev_page"
+         disabled="<%= page_num > 1 %>">
+        &lt; Prev
+      </a>
+    </div>
+
+    <div class="job_history_pages">
+      <% (first_page..last_page).each do |page_number| %>
+        <% if page_number != page_num %>
+          <a href="linear_history?<%= { "page_size" => page_size,
+                                        "page_num"  => page_number }.to_param %>"
+             class="job_history_page">
+            <%= page_number %>
+          </a>
+        <% else %>
+          <%= page_number %>
+        <% end %>
+      <% end %>
+    </div>
+
+    <div class="job_history_next_links">
+      <a href="linear_history?<%= { "page_size" => page_size,
+                                    "page_num"  => [total_pages, page_num + 1].min }.to_param %>"
+         class="job_history_next_page"
+         disabled="<%= page_num < last_page %>">
+        Next &gt;
+      </a>
+
+      <a href="linear_history?<%= { "page_size" => page_size,
+                                    "page_num"  => total_pages }.to_param %>"
+         class="job_history_last_page"
+         disabled="<%= last_page < total_pages %>">
+        Last &gt;&gt;
+      </a>
+    </div>
+  <% end %>
+</div>

data/lib/resque/server/views/job_class_details.erb

@@ -6,9 +6,11 @@
 <% history = Resque::Plugins::JobHistory::HistoryDetails.new(@job_class_name) %>
 <% class_info = job_list.job_class_summary(@job_class_name) %>
 
-<a href="<%= u("job history") %>">
-  Job History
-</a>
+<p>
+  <a href="<%= u("job history") %>">
+    Job History
+  </a>
+</p>
 
 <div class="table_container">
   <table>

data/lib/resque/server/views/job_details.erb

@@ -6,13 +6,15 @@
 
 <% job_details = Resque::Plugins::JobHistory::Job.new(@job_class_name, @job_id) %>
 
-<a href="<%= u("job history") %>">
-  Job History
-</a>
-|
-<a href="job_class_details?<%= { class_name: @job_class_name }.to_param %>">
-  <%= @job_class_name %>
-</a>
+<p>
+  <a href="<%= u("job history") %>">
+    Job History
+  </a>
+  |
+  <a href="job_class_details?<%= { class_name: @job_class_name }.to_param %>">
+    <%= @job_class_name %>
+  </a>
+</p>
 
 <div class="table_container">
   <table>
@@ -45,7 +47,7 @@
       </td>
     </tr>
     <% unless job_details.succeeded? %>
-      <tr>
+      <tr class="job_history_error">
         <td>
           Error
         </td>

data/lib/resque/server/views/job_history.erb

@@ -3,6 +3,13 @@
 <h1>Job Classes</h1>
 
 <% job_list = Resque::Plugins::JobHistory::JobList.new %>
+
+<p>
+  <a href="<%= u("job history/linear_history") %>">
+    Linear History
+  </a>
+</p>
+
 <%= erb(File.read(Resque::JobHistoryServer.erb_path("_job_class_pagination.erb")),
         locals: { job_list: job_list, page_num: @page_num, page_size: @page_size }) %>
 
@@ -23,6 +30,13 @@
                                            order_param("running_jobs", @sort_by, @sort_order) }.to_param %>">
         Running
       </a></th>
+      <th><a href="job%20history?<%= { sort:      "total_run_jobs",
+                                       page_size: @page_size,
+                                       page_num:  @page_num,
+                                       order:     job_list.
+                                           order_param("total_run_jobs", @sort_by, @sort_order) }.to_param %>">
+        Total Run
+      </a></th>
       <th><a href="job%20history?<%= { sort:      "total_finished_jobs",
                                        page_size: @page_size,
                                        page_num:  @page_num,
@@ -61,7 +75,7 @@
     </tr>
 
     <% job_list.job_summaries(@sort_by, @sort_order, @page_num, @page_size).each do |class_info| %>
-      <tr>
+      <tr<%= class_info[:last_run] && !class_info[:last_run].succeeded? ? " class=\"job_history_error\"" : "" %>>
         <td>
           <a href="job%20history/job_class_details?class_name=<%= class_info[:class_name] %>">
             <%= class_info[:class_name] %>
@@ -70,6 +84,9 @@
         <td>
           <%= class_info[:running_jobs].to_i %>
         </td>
+        <td>
+          <%= class_info[:total_run_jobs].to_i %>
+        </td>
         <td>
           <%= class_info[:total_finished_jobs].to_i %>
         </td>
@@ -93,7 +110,7 @@
           <% end %>
         </td>
         <td>
-          <% if class_info[:last_run] && class_info[:last_run].error %>
+          <% if class_info[:last_run] && !class_info[:last_run].succeeded? %>
             No
           <% else %>
             Yes

data/lib/resque/server/views/linear_history.erb

@@ -0,0 +1,61 @@
+<link href="job_history/public/job_history.css" media="screen" rel="stylesheet" type="text/css">
+
+<h1>Linear History</h1>
+
+<p>
+  <a href="<%= u("job history") %>">
+    Job History
+  </a>
+</p>
+
+<% linear_history = Resque::Plugins::JobHistory::JobList.new.linear_jobs %>
+
+<% if linear_history.num_jobs > 0 %>
+  <% jobs = linear_history.paged_jobs(@page_num, @page_size) %>
+  <%= erb(File.read(Resque::JobHistoryServer.erb_path("_linear_pagination.erb")),
+          locals: { linear_history: linear_history,
+                    page_num:       @page_num,
+                    page_size:      @page_size }) %>
+
+  <div class="table_container">
+    <table>
+      <tr>
+        <th>Class</th>
+        <th>Started</th>
+        <th>Duration</th>
+        <th>Parameters</th>
+        <th>Error</th>
+      </tr>
+      <% jobs.each do |job_details| %>
+        <tr<%= job_details.succeeded? ? "" : " class=\"job_history_error\"" %>>
+          <td>
+            <a href="job_details?class_name=<%= job_details.class_name %>&job_id=<%= job_details.job_id %>">
+              <%= job_details.class_name %>
+            </a>
+          </td>
+          <td>
+            <%= time_ago_in_words(job_details.start_time) %> ago
+            (<%= job_details.start_time %>)
+          </td>
+          <td>
+            <%= distance_of_time_in_words(job_details.start_time, (job_details.end_time || Time.now)) %>
+            <% if job_details.finished? %>
+              (<%= job_details.end_time %>)
+            <% end %>
+          </td>
+          <td>
+            <pre><code><%= "".html_safe + job_details.args.to_yaml %></code></pre>
+          </td>
+          <td>
+            <%= job_details.error %>
+          </td>
+        </tr>
+      <% end %>
+    </table>
+  </div>
+
+  <%= erb(File.read(Resque::JobHistoryServer.erb_path("_linear_pagination.erb")),
+          locals: { linear_history: linear_history,
+                    page_num:       @page_num,
+                    page_size:      @page_size }) %>
+<% end %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-job_history
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - RealNobody
@@ -186,9 +186,11 @@ files:
 - lib/resque/server/views/_job_class_pagination.erb
 - lib/resque/server/views/_job_pagination.erb
 - lib/resque/server/views/_jobs_list.erb
+- lib/resque/server/views/_linear_pagination.erb
 - lib/resque/server/views/job_class_details.erb
 - lib/resque/server/views/job_details.erb
 - lib/resque/server/views/job_history.erb
+- lib/resque/server/views/linear_history.erb
 - lib/tasks/resque-job_history_tasks.rake
 homepage: https://github.com/RealNobody
 licenses: