resque-job-stats-promptcloud 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5769ba71b39f54f345d77c40404fdee78785c473
+  data.tar.gz: c6ca1858ee91ba5b3d79e1724b70d406f87a80d6
+SHA512:
+  metadata.gz: 3b9d4fb2b1ef9c452f245950af0ff1f53838432a0ab0c2b4c15cf745bc03e359c1a623a13ea19dacfbb6a63216c02e2232ba1442f0990cfd2cf894a87c181849
+  data.tar.gz: 517878d9328f92b898289d7a011f7ff1119b76b48d87bfb9d0ab8575f2f889f870f76538d749ac156151b0b785825aa050e1b91cf09fd0771a4dd31a6e5610aa

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## Master
+
+* Add example app (#27, 158f466)
+
+## 0.4.2
+
+* Fix missing ERB files in gemspec (e30e599)
+
+## 0.4.1
+
+* Remove `date` from gemspec (31e054b)
+
+## 0.4.0
+
+* Add stats and UI for individual job histories (#24, f10d9b6) -- @emilong
+* Modernize the gem, and add Travis CI testing for newer rubies (#23, cbac34d)
+
+Changelog started on Oct 20, 2016.

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Alan Peabody
+
+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.md

@@ -0,0 +1,154 @@
+# resque-job-stats
+
+[![Build Status](https://travis-ci.org/alanpeabody/resque-job-stats.svg)](http://travis-ci.org/alanpeabody/resque-job-stats)
+
+Job centric stats for Resque.
+
+Stats are tracked per Job type (class/module) in addition to the worker based stats Resque provides.
+
+Stats tracked are:
+
+* Jobs performed
+* Jobs enqueued
+* Jobs failed
+* Duration of last x jobs completed
+* Average job duration over last 100 jobs completed
+* Longest job duration over last 100 jobs completed
+* Jobs enqueued as timeseries data (minute, hourly)
+* Jobs performed as timeseries data (minute, hourly)
+
+This information can be used to help track performance and diagnose specific bottlenecks.
+
+We are sending this information to Nagios for graphing and alerts (via a custom rake task).
+
+## Installation
+
+Requires resque '~> 1.17.0'
+
+In your Gemfile add:
+
+```ruby
+gem 'resque-job-stats'
+```
+
+## Usage
+
+Simply extend your class
+
+```ruby
+class MyJob
+  extend Resque::Plugins::JobStats
+
+  @queue = :my_job
+  def self.perform(*args)
+    # ..
+  end
+end
+```
+
+And you will have a set of keys starting with `'stats:jobs:my_job'` inside your Resque redis namespace.
+
+Alternatively you can include just the metric you wish to record.
+
+```ruby
+class MyVerboseJob
+  extend Resque::Plugins::JobStats::Performed
+  extend Resque::Plugins::JobStats::Enqueued
+  extend Resque::Plugins::JobStats::Failed
+  extend Resque::Plugins::JobStats::Duration
+  extend Resque::Plugins::JobStats::Timeseries::Enqueued
+  extend Resque::Plugins::JobStats::Timeseries::Performed
+
+  @queue = :my_job
+  def self.perform(*args)
+    # ...
+  end
+end
+```
+
+### Duration module
+
+The duration module provides two metrics, the longest job and the job rolling avg.
+
+These are accessible via two singleton methods, `MyJob.job_rolling_avg` and `MyJob.longest_job`.
+
+By default the last 100 jobs durations are stored and used to provide the above metrics.
+
+You may set the number of jobs to include by setting the `@durations_recorded` variable.
+
+
+```ruby
+class MyJob
+  extend Resque::Plugins::JobStats::Duration
+
+  @queue = :my_job
+  @durations_recorded = 1000
+
+  def self.perform(*payload)
+    # ...
+  end
+end
+```
+
+### Timeseries module
+
+The timeseries module provides timeseries counts of jobs performed. The metrics are rolling and kept for a period of time before being expired.
+The timestamp used for the timeseries data is UTC.
+
+## Resque Web Tab
+
+The Resque web page for showing the statistics will only display jobs that extend Resque::Plugins::JobStats (in other words, just
+the jobs that include all of the metrics):
+
+```ruby
+class MyJob
+  extend Resque::Plugins::JobStats
+  ...
+end
+```
+
+The interface can be included in your app like this:
+
+```ruby
+require 'resque-job-stats/server'
+```
+
+If you wish to display only certain metrics, you can filter the metrics accordingly.  The default metrics can be found in Resque::Plugins::JobStats::Statistic.
+
+```ruby
+  Resque::Server.job_stats_to_display = [:jobs_enqueued, :job_rolling_avg]
+```
+
+## Screenshots
+
+### Overview
+
+![overview stats](docs/images/stats-overview.png)
+
+### Individual Job Histories
+
+![individual stats](docs/images/stats-individual.png)
+
+## TODO
+
+* Find clean way to add queue wait time stats.
+
+## Contributing to resque-job-stats
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Contributers
+
+* [damonmorgan](https://github.com/damonmorgan)
+* [unclebilly](https://github.com/unclebilly)
+
+## Copyright
+
+Copyright (c) 2011-2012 Alan Peabody. See LICENSE.txt for further details.
+

data/lib/resque-job-stats.rb

@@ -0,0 +1 @@
+require 'resque/plugins/job_stats'

data/lib/resque-job-stats/server.rb

@@ -0,0 +1,87 @@
+require 'resque/server'
+
+module Resque
+  module Plugins
+    module JobStats
+      module Server
+        VIEW_PATH = File.join(File.dirname(__FILE__), 'server', 'views')
+
+        def job_stats_to_display
+          @job_stats_to_display ||= Resque::Plugins::JobStats::Statistic::DEFAULT_STATS
+        end
+
+        # Set this to an array of the public accessor names in Resque::Plugins::JobStats::Statistic
+        # that you wish to display.  The default is [:jobs_enqueued, :jobs_performed, :jobs_failed, :job_rolling_avg, :longest_job]
+        # Examples:
+        #   Resque::Server.job_stats_to_display = [:jobs_performed, :job_rolling_avg]
+        def job_stats_to_display=(stats)
+          @job_stats_to_display = stats
+        end
+
+        module Helpers
+          def display_stat?(stat_name)
+            self.class.job_stats_to_display == :all ||
+              [self.class.job_stats_to_display].flatten.map(&:to_sym).include?(stat_name.to_sym)
+          end
+
+          def time_display(float)
+            float.zero? ? "" : ("%.2f" % float.to_s) + "s"
+          end
+
+          def number_display(num)
+            num.zero? ? "" : num
+          end
+
+          def stat_header(stat_name)
+            if(display_stat?(stat_name))
+              "<th>" + stat_name.to_s.gsub(/_/,' ').capitalize + "</th>"
+            end
+          end
+
+          def display_stat(stat, stat_name, format)
+            if(display_stat?(stat_name))
+              formatted_stat = self.send(format, stat.send(stat_name))
+              "<td>#{formatted_stat}</td>"
+            end
+          end
+
+          def check_or_cross_stat(value)
+            value ? "&#x2713;" : "&#x2717;"
+          end
+        end
+
+        class << self
+          def registered(app)
+            app.get '/job_stats' do
+              @jobs = Resque::Plugins::JobStats::Statistic.find_all(self.class.job_stats_to_display).sort
+              erb(File.read(File.join(VIEW_PATH, 'job_stats.erb')))
+            end
+            # We have little choice in using this funky name - Resque
+            # already has a "Stats" tab, and it doesn't like
+            # tab names with spaces in it (it translates the url as job%20stats)
+            app.tabs << "Job_Stats"
+
+            app.get '/job_history/:job_class' do
+              @job_class = Resque::Plugins::JobStats.measured_jobs.find { |j| j.to_s == params[:job_class] }
+              pass unless @job_class
+
+              @start = 0
+              @start = params[:start].to_i if params[:start]
+              @limit = 100
+              @limit = params[:limit].to_i if params[:limit]
+
+              @histories = @job_class.job_histories(@start,@limit)
+              @size = @job_class.histories_recorded
+
+              erb(File.read(File.join(VIEW_PATH, 'job_histories.erb')))
+            end
+
+            app.helpers(Helpers)
+          end
+        end
+      end
+    end
+  end
+end
+
+Resque::Server.register Resque::Plugins::JobStats::Server

data/lib/resque-job-stats/server/views/job_histories.erb

@@ -0,0 +1,38 @@
+<h1>Resque Job Histories</h1>
+
+<p class="intro">
+  This page displays histories of jobs that have been executed.
+</p>
+
+<h2><%= @job_class %></h2>
+
+<table>
+  <tr>
+    <th>Start time</th>
+    <th>Duration</th>
+    <th>Arguments</th>
+    <th>Success</th>
+    <th>Exception</th>
+  </tr>
+  <% @histories.each do |history| %>
+    <tr>
+      <td><span class="time"><%= history["run_at"] %></span></td>
+      <td><%= history["duration"] %></td>
+      <td><%= history["args"].inspect %></td>
+      <td><%= check_or_cross_stat(history["success"]) %></td>
+      <td><%= history["exception"]["name"] if history["exception"] %></td>
+    </tr>
+  <% end %>
+</table>
+
+<%if @start > 0 || @start + @limit <= @size %>
+<p class='pagination'>
+  <% if @start - @limit >= 0 %>
+    <a href="<%= current_page %>?start=<%= [0, @start - @limit].max %>&limit=<%= @limit %>" class='less'>&laquo; less</a>
+  <% end %>
+  <% if @start + @limit <= @size %>
+    <a href="<%= current_page %>?start=<%= @start + @limit %>&limit=<%= @limit %>" class='more'>more &raquo;</a>
+  <% end %>
+</p>
+<%end%>
+

data/lib/resque-job-stats/server/views/job_stats.erb

@@ -0,0 +1,32 @@
+<h1>Resque Job Stats</h1>
+
+<p class="intro">
+  This page displays statistics about jobs that have been executed.
+</p>
+
+<table>
+  <tr>
+    <th>Name</th>
+    <%= stat_header(:jobs_enqueued) %>
+    <%= stat_header(:jobs_performed) %>
+    <%= stat_header(:jobs_failed) %>
+    <%= stat_header(:job_rolling_avg) %>
+    <%= stat_header(:longest_job) %>
+  </tr>
+  <% @jobs.each do |job| %>
+    <tr>
+      <td>
+        <%= job.name %>
+        <% if job.job_class <= Resque::Plugins::JobStats::History ||
+              job.job_class.is_a?(Resque::Plugins::JobStats::History) %>
+          <a href='<%= url "/job_history/#{job.name}" %>'>[history]</a>
+        <% end %>
+      </td>
+      <%= display_stat(job, :jobs_enqueued,   :number_display) %>
+      <%= display_stat(job, :jobs_performed,  :number_display) %>
+      <%= display_stat(job, :jobs_failed,     :number_display) %>
+      <%= display_stat(job, :job_rolling_avg, :time_display) %>
+      <%= display_stat(job, :longest_job,     :time_display) %>
+    </tr>
+  <% end %>
+</table>

data/lib/resque/plugins/job_stats.rb

@@ -0,0 +1,36 @@
+require 'resque'
+require 'resque/plugins/job_stats/measured_hook'
+require 'resque/plugins/job_stats/performed'
+require 'resque/plugins/job_stats/enqueued'
+require 'resque/plugins/job_stats/failed'
+require 'resque/plugins/job_stats/duration'
+require 'resque/plugins/job_stats/timeseries'
+require 'resque/plugins/job_stats/statistic'
+require 'resque/plugins/job_stats/history'
+
+module Resque
+  module Plugins
+    module JobStats
+      extend Resque::Plugins::JobStats::MeasuredHook
+      include Resque::Plugins::JobStats::Performed
+      include Resque::Plugins::JobStats::Enqueued
+      include Resque::Plugins::JobStats::Failed
+      include Resque::Plugins::JobStats::Duration
+      include Resque::Plugins::JobStats::Timeseries::Enqueued
+      include Resque::Plugins::JobStats::Timeseries::Performed
+      include Resque::Plugins::JobStats::History
+      
+      def self.add_measured_job(name)
+        Resque.redis.sadd("stats:jobs", name)
+      end
+
+      def self.rem_measured_job(name)
+        Resque.redis.srem("stats:jobs", name)
+      end
+
+      def self.measured_jobs
+        Resque.redis.smembers("stats:jobs").collect { |c| Object.const_get(c) rescue nil }.compact
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/duration.rb

@@ -0,0 +1,49 @@
+module Resque
+  module Plugins
+    module JobStats
+      module Duration
+        extend Resque::Plugins::JobStats::MeasuredHook
+
+        # Resets all job durations
+        def reset_job_durations
+          Resque.redis.del(jobs_duration_key)
+        end
+
+        # Returns the number of jobs failed
+        def job_durations
+          Resque.redis.lrange(jobs_duration_key,0,durations_recorded - 1).map(&:to_f)
+        end
+
+        # Returns the key used for tracking job durations
+        def jobs_duration_key
+          "stats:jobs:#{self.name}:duration"
+        end
+
+        # Increments the failed count when job is complete
+        def around_perform_job_stats_duration(*args)
+          start = Time.now
+          yield
+          duration = Time.now - start
+
+          Resque.redis.lpush(jobs_duration_key, duration)
+          Resque.redis.ltrim(jobs_duration_key, 0, durations_recorded)
+        end
+
+        def durations_recorded
+          @durations_recorded || 100
+        end
+
+        def job_rolling_avg
+          job_times = job_durations
+          return 0.0 if job_times.size == 0.0
+          job_times.inject(0.0) {|s,j| s + j} / job_times.size
+        end
+
+        def longest_job
+          job_durations.max.to_f
+        end
+
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/enqueued.rb

@@ -0,0 +1,34 @@
+module Resque
+  module Plugins
+    module JobStats
+
+      # Extend your job with this module to track how many
+      # jobs are queued successfully
+      module Enqueued
+        extend Resque::Plugins::JobStats::MeasuredHook
+
+        # Sets the number of jobs queued
+        def jobs_enqueued=(int)
+          Resque.redis.set(jobs_enqueued_key,int)
+        end
+
+        # Returns the number of jobs enqueued
+        def jobs_enqueued
+          Resque.redis.get(jobs_enqueued_key).to_i
+        end
+
+        # Returns the key used for tracking jobs enqueued
+        def jobs_enqueued_key
+          "stats:jobs:#{self.name}:enqueued"
+        end
+
+        # Increments the enqueued count when job is queued
+        def after_enqueue_job_stats_enqueued(*args)
+          Resque.redis.incr(jobs_enqueued_key)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/resque/plugins/job_stats/failed.rb

@@ -0,0 +1,35 @@
+module Resque
+  module Plugins
+    module JobStats
+
+      # Extend your job with this module to track how many
+      # jobs fail
+      module Failed
+        extend Resque::Plugins::JobStats::MeasuredHook
+
+        # Sets the number of jobs failed
+        def jobs_failed=(int)
+          Resque.redis.set(jobs_failed_key,int)
+        end
+
+        # Returns the number of jobs failed
+        def jobs_failed
+          jobs_failed = Resque.redis.get(jobs_failed_key).to_i
+          return jobs_failed / 2 if Resque::VERSION == '1.20.0'
+          jobs_failed
+        end
+
+        # Returns the key used for tracking jobs failed
+        def jobs_failed_key
+          "stats:jobs:#{self.name}:failed"
+        end
+
+        # Increments the failed count when job is complete
+        def on_failure_job_stats_failed(e,*args)
+          Resque.redis.incr(jobs_failed_key)
+        end
+
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/history.rb

@@ -0,0 +1,55 @@
+module Resque
+  module Plugins
+    module JobStats
+      module History
+        include Resque::Helpers
+
+        def job_histories(start=0, limit=histories_recordable)
+          Resque.redis.lrange(jobs_history_key, start, start + limit - 1).map { |h| decode(h) }
+        end
+
+        # Returns the key used for tracking job histories
+        def jobs_history_key
+          "stats:jobs:#{self.name}:history"
+        end
+
+        def around_perform_job_stats_history(*args)
+          # we collect our own duration and start time rather
+          # than correlate with the duration stat to make sure
+          # we're associating them with the right job arguments
+          start = Time.now
+          begin
+            yield
+            duration = Time.now - start
+            push_history "success" => true, "args" => args, "run_at" => start, "duration" => duration
+          rescue Exception => e
+            duration = Time.now - start
+            exception = { "name" => e.to_s, "backtrace" => e.backtrace }
+            push_history "success" => false, "exception" => exception, "args" => args, "run_at" => start, "duration" => duration
+            raise e
+          end
+        end
+
+        def histories_recordable
+          @histories_recordable || 100
+        end
+
+        def histories_recorded
+          Resque.redis.llen(jobs_history_key)
+        end
+
+        def reset_job_histories
+          Resque.redis.del(jobs_history_key)
+        end
+
+        private
+
+        def push_history(history)
+          Resque.redis.lpush(jobs_history_key, encode(history))
+          Resque.redis.ltrim(jobs_history_key, 0, histories_recordable)
+        end
+      end
+    end
+  end
+end
+

data/lib/resque/plugins/job_stats/measured_hook.rb

@@ -0,0 +1,13 @@
+module Resque
+  module Plugins
+    module JobStats
+      module MeasuredHook
+
+        def extended(base)
+          Resque.redis.sadd("stats:jobs", base)
+        end
+
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/performed.rb

@@ -0,0 +1,33 @@
+module Resque
+  module Plugins
+    module JobStats
+
+      # Extend your job with this module to track how many
+      # jobs are performed successfully
+      module Performed
+        extend Resque::Plugins::JobStats::MeasuredHook
+
+        # Sets the number of jobs performed
+        def jobs_performed=(int)
+          Resque.redis.set(jobs_performed_key,int)
+        end
+
+        # Returns the number of jobs performed
+        def jobs_performed
+          Resque.redis.get(jobs_performed_key).to_i
+        end
+
+        # Returns the key used for tracking jobs performed
+        def jobs_performed_key
+          "stats:jobs:#{self.name}:performed"
+        end
+
+        # Increments the performed count when job is complete
+        def after_perform_job_stats_performed(*args)
+          Resque.redis.incr(jobs_performed_key)
+        end
+
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/statistic.rb

@@ -0,0 +1,43 @@
+module Resque
+  module Plugins
+    module JobStats
+      # A class composed of a job class and the various job statistics
+      # collected for the given job.
+      class Statistic
+        include Comparable
+
+        # An array of the default statistics that will be displayed in the web tab
+        DEFAULT_STATS = [:jobs_enqueued, :jobs_performed, :jobs_failed, :job_rolling_avg, :longest_job]
+
+        attr_accessor *[:job_class].concat(DEFAULT_STATS)
+
+        class << self
+          # Find and load a Statistic for all resque jobs that are in the Resque::Plugins::JobStats.measured_jobs collection
+          def find_all(metrics)
+            Resque::Plugins::JobStats.measured_jobs.map{|j| new(j, metrics)}
+          end
+        end
+
+        # A series of metrics describing one job class.
+        def initialize(job_class, metrics)
+          self.job_class = job_class
+          self.load(metrics)
+        end
+
+        def load(metrics)
+          metrics.each do |metric|
+            self.send("#{metric}=", job_class.send(metric))
+          end
+        end
+
+        def name
+          self.job_class.name
+        end
+
+        def <=>(other)
+          self.name <=> other.name
+        end
+      end
+    end
+  end
+end

data/lib/resque/plugins/job_stats/timeseries.rb

@@ -0,0 +1,97 @@
+require 'time'
+
+module Resque
+  module Plugins
+    module JobStats
+
+      # Extend your job with this module to track how many
+      # jobs are performed over a period of time
+      module Timeseries
+
+        module Common
+          # A timestamp rounded to the lowest minute
+          def timestamp
+            time = Time.now.utc
+            Time.at(time.to_i - time.sec).utc   # to_i removes usecs
+          end
+
+          private
+
+          TIME_FORMAT = {:minutes => "%d:%H:%M", :hours => "%d:%H"}
+          FACTOR = {:minutes => 1, :hours => 60}
+
+          def range(sample_size, time_unit, end_time) # :nodoc:
+            (0..sample_size).map { |n| end_time - (n * 60 * FACTOR[time_unit])}
+          end
+
+          def timeseries_data(type, sample_size, time_unit) # :nodoc:
+            timeseries_range = range(sample_size, time_unit, timestamp)
+            timeseries_keys = timeseries_range.map { |time| jobs_timeseries_key(type, time, time_unit)}
+            timeseries_data = Resque.redis.mget(*(timeseries_keys))
+
+            return Hash[(0..sample_size).map { |i| [timeseries_range[i], timeseries_data[i].to_i]}]
+          end
+
+          def jobs_timeseries_key(type, key_time, time_unit) # :nodoc:
+            "#{prefix}:#{type}:#{key_time.strftime(TIME_FORMAT[time_unit])}"
+          end
+
+          def prefix # :nodoc:
+            "stats:jobs:#{self.name}:timeseries"
+          end
+
+          def incr_timeseries(type) # :nodoc:
+            increx(jobs_timeseries_key(type, timestamp, :minutes), (60 * 61)) # 1h + 1m for some buffer
+            increx(jobs_timeseries_key(type, timestamp, :hours), (60 * 60 * 25)) # 24h + 60m for some buffer
+          end
+
+          # Increments a key and sets its expiry time
+          def increx(key, ttl)
+            Resque.redis.incr(key)
+            Resque.redis.expire(key, ttl)
+          end
+        end
+      end
+    end
+  end
+end
+
+module Resque::Plugins::JobStats::Timeseries::Enqueued
+  extend Resque::Plugins::JobStats::MeasuredHook
+  include Resque::Plugins::JobStats::Timeseries::Common
+
+  # Increments the enqueued count for the timestamp when job is queued
+  def after_enqueue_job_stats_timeseries(*args)
+    incr_timeseries(:enqueued)
+  end
+
+  # Hash of timeseries data over the last 60 minutes for queued jobs
+  def queued_per_minute
+    timeseries_data(:enqueued, 60, :minutes)
+  end
+
+  # Hash of timeseries data over the last 24 hours for queued jobs
+  def queued_per_hour
+    timeseries_data(:enqueued, 24, :hours)
+  end
+end
+
+module Resque::Plugins::JobStats::Timeseries::Performed
+  extend Resque::Plugins::JobStats::MeasuredHook
+  include Resque::Plugins::JobStats::Timeseries::Common
+
+  # Increments the performed count for the timestamp when job is complete
+  def after_perform_job_stats_timeseries(*args)
+    incr_timeseries(:performed)
+  end
+
+  # Hash of timeseries data over the last 60 minutes for completed jobs
+  def performed_per_minute
+    timeseries_data(:performed, 60, :minutes)
+  end
+
+  # Hash of timeseries data over the last 24 hours for completed jobs
+  def performed_per_hour
+    timeseries_data(:performed, 24, :hours)
+  end
+end

data/lib/resque/plugins/job_stats/version.rb

@@ -0,0 +1,7 @@
+module Resque
+  module Plugins
+    module JobStats
+      VERSION = '0.4.2'
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: resque-job-stats-promptcloud
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- alanpeabody
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tracks jobs performed, failed, and the duration of the last 100 jobs
+  for each job type.
+email: gapeabody@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/resque-job-stats.rb
+- lib/resque-job-stats/server.rb
+- lib/resque-job-stats/server/views/job_histories.erb
+- lib/resque-job-stats/server/views/job_stats.erb
+- lib/resque/plugins/job_stats.rb
+- lib/resque/plugins/job_stats/duration.rb
+- lib/resque/plugins/job_stats/enqueued.rb
+- lib/resque/plugins/job_stats/failed.rb
+- lib/resque/plugins/job_stats/history.rb
+- lib/resque/plugins/job_stats/measured_hook.rb
+- lib/resque/plugins/job_stats/performed.rb
+- lib/resque/plugins/job_stats/statistic.rb
+- lib/resque/plugins/job_stats/timeseries.rb
+- lib/resque/plugins/job_stats/version.rb
+homepage: http://github.com/alanpeabody/resque-job-stats
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Job-centric stats for Resque
+test_files: []