resque-metrics 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa7c797cdfa6560213452323b8342776c660999d
-  data.tar.gz: fb437d501c22eb5092ba201460ab8bcce56d91a5
+  metadata.gz: 4b37d0748facc9e0f08c5dc0b3998df4c1463ff4
+  data.tar.gz: 1e6970ac0a11ddc2eb25afabec738cbce63c5696
 SHA512:
-  metadata.gz: 60ec3b407be33f70cf96737e5334d1ce0c707f8c6c5e82314be33e66f56de8231ff905c93c23000ac91478e9d99660e4c22d5e0652310c1e76f69a68ed77feb3
-  data.tar.gz: d26228715c7c892779c3a09b59b126046f3743f955db5243af381aa68812393395c51b222ff7a66085179ea44652b9e1fce0aed3ff0b14522ff7aba16170d7cb
+  metadata.gz: 6c4f87485e96a5bbf1c9fbbb608d8d5c2dd7478e2600d5c0dd84cbb1601ef79d916848e4efd21c16b17c1bdec7990db986f851a4d6b66160e5deadf538fd9913
+  data.tar.gz: 807ec5bad744cd89f1e92bdf2fbbd5f69bfa8af4b4fd19687d70e2d4c906af338d44c598da2fc071736b77b40b36222fbd54c13cf493c81e84d95d459a8e4f0c

data/README.rdoc

@@ -8,6 +8,14 @@ mechanism for recording/sending the metrics to your favorite tool (AKA statsd/gr
 
     gem install resque-metrics
 
+If you are using bundler add this to your Gemfile
+
+    gem "resque-metrics"
+
+And if you want the web-ui extensions
+
+    gem "resque-metrics", :require => "resque/metrics/server"
+
 == Usage
 
 Given a job, extend the job class with Resque::Metrics.
@@ -23,8 +31,8 @@ Given a job, extend the job class with Resque::Metrics.
 
     end
 
-By default this will record the total job count, the total count of jobs enqueued, the total time the jobs took, the avg time the jobs took. It 
-will also record each of these per-queue and per-bob class. So for the job above it will record values and you will be able to fetch them
+By default this will record the total job count, the total count of jobs enqueued, the total time the jobs took, the avg time the jobs took. It will also record the total number of job failures.
+These metrics are also tracked by queue and job class. So for the job above, it will record values and you will be able to fetch them
 with module methods:
 
     Resque::Metrics.total_job_count #=> 1
@@ -36,12 +44,15 @@ with module methods:
     Resque::Metrics.avg_job_time #=> 1000
     Resque::Metrics.avg_job_time_by_job(SomeJob) #=> 1000
     Resque::Metrics.avg_job_time_by_queue(:jobs) #=> 1000
+    Resque::Metrics.failed_job_count #=> 1
+    Resque::Metrics.failed_job_count_by_job(SomeJob) #=> 0
+    Resque::Metrics.failed_job_count_by_queue(:jobs) #=> 0
 
 All values are recorded and returned as integers. For times, values are in milliseconds.
 
 === Forking Metrics
 
-Resque::Metrics can also record forking metrics but these are not on by default as `before_fork` and `after_fork` are singluar hooks. 
+Resque::Metrics can also record forking metrics but these are not on by default as `before_fork` and `after_fork` are singluar hooks.
 If you don't need to define your own fork hooks you can simply add a line to an initializer:
 
     Resque::Metrics.watch_fork
@@ -52,28 +63,101 @@ If you do define you're own fork hooks:
       # my own fork code
       Resque::Metrics.before_fork.call(job)
     end
-    
+
     # Resque::Metrics.(before/after)_fork just returns a lambda so just assign it if you like
     Resque.after_fork = Resque::Metrics.after_fork
 
-Once enabled this will add `.*_fork_*` methods like `avg_fork_time`, etc. 
+Once enabled this will add `.*_fork_*` methods like `avg_fork_time`, etc.
 Latest Resque is required for fork recording to work.
 
+=== Queue Depth Metrics
+
+Resque::Metrics can also record queue depth metrics. These are not on by default,
+as they need to run on an interval to be useful. You can record them manually
+by running in a console:
+
+    Resque::Metrics.record_depth
+
+You can imagine placing this in a small script, and using cron to run it. Once you'll have access to:
+
+    Resque::Metrics.failed_depth #=> 1
+    Resque::Metrics.pending_depth #=> 1
+    Resque::Metrics.depth_by_queue(:jobs) #=> 1
+
+=== Metric Backends
+
+By default, Resque::Metrics keeps all it's metrics in Resque's redis instance, but supports plugging in other backends. Resque::Metrics itself supports redis and statsd. Here's how you would enable statsd:
+
+    # list current backends
+    Resque::Metrics.backends
+    # build your statsd instance
+    statsd = Statsd.new 'localhost', 8125
+    # add a Resque::Metrics::Backend
+    Resque::Metrics.backends.append Resque::Metrics::Backends::Statsd.new(statsd)
+
+==== Statsd
+
+If you have already have a statsd object for you application, just pass it to Resque::Metrics::Backends::Statsd. The statsd client already supports namespacing, and in addition, Resque::Metrics all its metrics under 'resque' under that namespace.
+
+Here's a list of metrics emitted:
+
+  resque.job.<job>.complete.count
+  resque.job.<job>.complete.time
+  resque.queue.<queue>.complete.count
+  resque.queue.<queue>.complete.time
+  resque.complete.count
+  resque.complete.time
+
+  resque.job.<job>.enqueue.count
+  resque.job.<job>.enqueue.time
+  resque.queue.<queue>.enqueue.count
+  resque.queue.<queue>.enqueue.time
+  resque.enqueue.count
+  resque.enqueue.time
+
+  resque.job.<job>.fork.count
+  resque.job.<job>.fork.time
+  resque.queue.<queue>.fork.count
+  resque.queue.<queue>.fork.time
+  resque.fork.count
+  resque.fork.time
+
+  resque.job.<job>.failure.count
+  resque.queue.<queue>.failure.count
+  resque.failure.count
+
+  resque.depth.failed
+  resque.depth.pending
+  resque.depth.queue.<queue>
+
+==== Writing your own
+
+To write your own, you create your own class, and then implmement the following that you care about:
+
+* increment_metric(metric, by = 1)
+* set_metric(metric, val)
+* set_avg(metric, num, total)
+* get_metric(metric)
+
+Resque::Metrics will in turn call each of these methods for each of it's backend
+if it responds_to? it. For get_metric, since it returns a value, only will use
+the first backend that responds_to? it.
+
 === Callbacks/Hooks
 
 Resque::Metrics also has a simple callback/hook system so you can send data to your favorite agent. All hooks are passed the job class,
-the queue, and the time of the metric. 
+the queue, and the time of the metric.
 
-    # Also `on_job_fork` and `on_job_enqueue`
-    Resque::Metric.on_job_complete do |job_class, queue, time|
+    # Also `on_job_fork`, `on_job_enqueue`, and `on_job_failure` (`on_job_failure does not include `time`)
+    Resque::Metrics.on_job_complete do |job_class, queue, time|
       # send to your metrics agent
       Statsd.timing "resque.#{job_class}.complete_time", time
       Statsd.increment "resque.#{job_class}.complete"
       # etc
     end
-    
+
 == Contributing to resque-metrics
- 
+
 * 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

data/Rakefile

@@ -24,7 +24,7 @@ you could build some simple auto-scaling mechanism based on the speed and ETA of
 mechanism for recording/sending the metrics to your favorite tool (AKA statsd/graphite).
 desc
   gem.email = "aaron@quirkey.com"
-  gem.authors = ["Aaron Quint"]
+  gem.authors = ["Aaron Quint", "Josh Nichols", "Michael Smith", "Tomas Varaneckas"]  
   # dependencies defined in Gemfile
 end
 Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.1.0

data/lib/resque/metrics/backends/redis.rb

@@ -0,0 +1,38 @@
+module Resque
+  module Metrics
+    module Backends
+      class Redis
+        attr_accessor :redis
+
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def increment_metric(metric, by = 1)
+          redis.incrby("_metrics_:#{metric}", by)
+        end
+
+        def set_metric(metric, val)
+          redis.set("_metrics_:#{metric}", val)
+        end
+
+        def set_avg(metric, num, total)
+          val = total < 1 ? 0 : num / total
+          set_metric(metric, val)
+        end
+
+        def get_metric(metric)
+          redis.get("_metrics_:#{metric}").to_i
+        end
+
+        def register_job(job)
+          redis.sadd('_metrics_:known_jobs', job)
+        end
+
+        def known_jobs
+          redis.smembers('_metrics_:known_jobs')
+        end
+      end
+    end
+  end
+end

data/lib/resque/metrics/backends/statsd.rb

@@ -0,0 +1,66 @@
+module Resque
+  module Metrics
+    module Backends
+      class Statsd
+        attr_accessor :statsd, :metric_prefix
+
+        def initialize(statsd, metric_prefix = 'resque')
+          @statsd = statsd
+          @metric_prefix = metric_prefix
+        end
+
+        def increment_metric(metric, by = 1)
+          if metric =~ /^(.+)(?:_job)?_(time|count)(?::(queue|job):(.*))?$/
+            event = $1
+            event = 'complete' if event == 'job'
+
+            time_or_count = $2
+            queue_or_job = $3
+            queue_or_job_name = $4
+            key = if queue_or_job && queue_or_job_name
+                    # ie resque.complete.queue.high.count, resque.failed.job.Index.timing
+                    "#{metric_prefix}.#{event}.#{queue_or_job}.#{queue_or_job_name}.#{time_or_count}"
+                  else
+
+                    # ie resque.complete.time
+                    "#{metric_prefix}.#{event}.#{time_or_count}"
+                  end
+            case time_or_count
+            when 'time'
+              statsd.timing key, by
+            when 'count'
+              statsd.increment key, by
+            else
+              raise "Not sure how to increment_metric for a #{time_or_count} metric (#{metric})"
+            end
+          elsif metric =~ /^payload_size(?::(queue|job):(.*))?$/
+            queue_or_job = $1
+            queue_or_job_name = $2
+            key = if queue_or_job && queue_or_job_name
+                    # ie resque.complete.queue.high.count, resque.failed.job.Index.timing
+                    "#{metric_prefix}.payload_size.#{queue_or_job}.#{queue_or_job_name}.#{time_or_count}"
+                  else
+                    "#{metric_prefix}.payload_size.#{time_or_count}"
+                  end
+            statsd.increment key, by
+          else
+            raise "Not sure how to increment_metric #{metric}"
+          end
+        end
+
+        def set_metric(metric, val)
+          if metric =~ /^depth(?::(failed|pending|queue)(?::(.+))?)?$/
+            key = "#{metric_prefix}.#{metric.gsub(':', '.')}"
+            statsd.gauge key, val
+          else
+            raise "Not sure how to set_metric #{metric}"
+          end
+        end
+        
+        # set_avg: let statsd & graphite handle that
+        # get_metric: would have to talk to graphite. but man, complicated
+      end
+    end
+  end
+end
+

data/lib/resque/metrics/backends.rb

@@ -0,0 +1,2 @@
+require 'resque/metrics/backends/redis'
+require 'resque/metrics/backends/statsd'

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

@@ -0,0 +1,88 @@
+<h1>All your metrics are belong to Resque</h1>
+
+<table class="queues">
+  <tbody>
+    <tr>
+      <th>Queue</th>
+      <th>Jobs completed</th>
+    </tr>
+
+    <% resque.queues.each do |queue| %>
+      <tr>
+        <td class="queue"><a href="<%=u "queues/#{queue}" %>"><%= queue %></a></td>
+        <td class="size"><%= Resque::Metrics.total_job_count_by_queue(queue) %></td>
+      </tr>
+    <% end %>
+
+    <tr class="failed">
+      <td class="queue failed"></td>
+      <td class="size"><%= Resque::Metrics.total_job_count %></td>
+    </tr>
+  </tbody>
+</table>
+
+<table class="queues">
+  <tbody>
+    <tr>
+      <th>Queue</th>
+      <th>Average job time</th>
+    </tr>
+
+    <% resque.queues.each do |queue| %>
+      <tr>
+        <td class="queue"><a href="<%=u "queues/#{queue}" %>"><%= queue %></a></td>
+        <td class="size"><%= metrics_formatted_ms(Resque::Metrics.avg_job_time_by_queue(queue)) %></td>
+      </tr>
+    <% end %>
+
+    <tr class="failed">
+      <td class="queue failed"></td>
+      <td class="size"><%= metrics_formatted_ms(Resque::Metrics.avg_job_time) %></td>
+    </tr>
+  </tbody>
+</table>
+
+<table class="queues">
+  <tbody>
+    <tr>
+      <th>Queue</th>
+      <th>Total job time</th>
+    </tr>
+
+    <% resque.queues.each do |queue| %>
+      <tr>
+        <td class="queue"><a href="<%=u "queues/#{queue}" %>"><%= queue %></a></td>
+        <td class="size"><%= metrics_formatted_ms(Resque::Metrics.total_job_time_by_queue(queue)) %></td>
+      </tr>
+    <% end %>
+
+    <tr class="failed">
+      <td class="queue failed"></td>
+      <td class="size"><%= metrics_formatted_ms(Resque::Metrics.total_job_time) %></td>
+    </tr>
+  </tbody>
+</table>
+
+<h2>Individual job metrics</h2>
+
+<table class="workers">
+  <tbody>
+    <tr>
+      <th>Job</th>
+      <th>Total count</th>
+      <th>Failed count</th>
+      <th>Average duration</th>
+      <th>Total duration</th>
+    </tr>
+
+    <% Resque::Metrics.known_jobs.each do |job| %>
+      <tr>
+        <td class="queues queue"><%= job %></td>
+        <td class="queues queue"><%= Resque::Metrics.total_job_count_by_job(job) %></td>
+        <td class="queues queue"><%= Resque::Metrics.failed_job_count_by_job(job) %></td>
+        <td class="queues queue"><%= metrics_formatted_ms(Resque::Metrics.avg_job_time_by_job(job)) %></td>
+        <td class="process"><%= metrics_formatted_ms(Resque::Metrics.total_job_time_by_job(job)) %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/lib/resque/metrics/server.rb

@@ -0,0 +1,47 @@
+require 'resque/server'
+require 'resque/metrics'
+
+# Extend Resque::Server to add tabs
+module Resque
+  module Metrics
+    module Server
+      def self.included(base)
+        base.class_eval do
+          helpers do
+            # reads a 'local' template file.
+            def local_template(path)
+              # Is there a better way to specify alternate template locations with sinatra?
+              File.read(File.join(File.dirname(__FILE__), "server/views/#{path}"))
+            end
+
+            def metrics_formatted_ms(milliseconds)
+              seconds = milliseconds / 1000
+              hours = (seconds / 3600).floor
+              minutes = (seconds % 3600) / 60
+              seconds = seconds % 60
+              millis = (milliseconds - (milliseconds / 1000) * 1000)
+
+              str = []
+              str << "#{hours} hours" if hours > 0
+              str << "#{minutes} min" if minutes > 0
+              str << "#{seconds} sec" if seconds > 0
+              str << "#{millis} ms" if millis > 0
+
+              str.join(" ")
+            end
+          end
+
+          get "/metrics" do
+            erb local_template("metrics.erb")
+          end
+        end
+      end
+
+      Resque::Server.tabs << 'Metrics'
+    end
+  end
+end
+
+Resque::Server.class_eval do
+  include Resque::Metrics::Server
+end

data/lib/resque/metrics.rb

@@ -1,4 +1,5 @@
 require 'resque'
+require 'resque/metrics/backends'
 
 module Resque
   module Metrics
@@ -8,7 +9,11 @@ module Resque
     end
 
     def self.redis
-      ::Resque.redis
+      @_redis ||= ::Resque.redis
+    end
+
+    def self.redis=(redis)
+      @_redis = redis
     end
 
     def self.use_multi=(multi)
@@ -19,6 +24,36 @@ module Resque
       @_use_multi
     end
 
+    def self.backends
+      @_backends ||= begin
+                       self.backends = [Resque::Metrics::Backends::Redis.new(redis)]
+                     end
+    end
+
+    def self.backends=(new_backends)
+      @_backends = new_backends
+    end
+
+    def self.run_backends(method, *args)
+      ran_any = false
+
+      backends.each do |backend|
+        if backend.respond_to?(method)
+          ran_any = true
+          backend.send method, *args
+        end
+      end
+
+      raise "No backend responded to #{method}: #{backends.inspect}" unless ran_any
+    end
+
+    def self.run_first_backend(method, *args)
+      backend = backends.detect {|backend| backend.respond_to?(method)}
+      raise "No backend responds to #{method}: #{backends.inspect}" unless backend
+
+      backend.send method, *args
+    end
+
     def self.watch_fork
       ::Resque.before_fork = before_fork
       ::Resque.after_fork = after_fork
@@ -36,6 +71,10 @@ module Resque
       set_callback(:on_job_enqueue, &block)
     end
 
+    def self.on_job_failure(&block)
+      set_callback(:on_job_failure, &block)
+    end
+
     def self.set_callback(callback_name, &block)
       @callbacks ||= {}
       @callbacks[callback_name] ||= []
@@ -71,6 +110,17 @@ module Resque
       end
     end
 
+    def self.record_depth
+      set_metric 'depth:failed', Resque::Failure.count
+      set_metric 'depth:pending', Resque.info[:pending]
+
+      Resque.queues.each do |queue|
+        set_metric "depth:queue:#{queue}", Resque.size(queue)
+      end
+
+      true
+    end
+
     def self.record_job_fork(job, time)
       job_class = job.payload_class
       queue = job.queue
@@ -93,6 +143,7 @@ module Resque
       increment_metric "enqueue_count"
       increment_metric "enqueue_count:job:#{job_class}"
       increment_metric "enqueue_count:queue:#{queue}"
+      run_first_backend(:register_job, job_class)
 
       size = Resque.encode(args).length
       multi do
@@ -123,25 +174,40 @@ module Resque
       run_callback(:on_job_complete, job_class, queue, time)
     end
 
+    def self.record_job_failure(job_class, e)
+      queue = Resque.queue_from_class(job_class)
+
+      multi do
+        increment_metric "failed_job_count"
+        increment_metric "failed_job_count:queue:#{queue}"
+        increment_metric "failed_job_count:job:#{job_class}"
+      end
+
+      run_callback(:on_job_failure, job_class, queue)
+    end
+
     def self.multi(&block)
       use_multi? ? redis.multi(&block) : yield
     end
 
     def self.increment_metric(metric, by = 1)
-      redis.incrby("_metrics_:#{metric}", by)
+      run_backends(:increment_metric, metric, by)
     end
 
     def self.set_metric(metric, val)
-      redis.set("_metrics_:#{metric}", val)
+      run_backends(:set_metric, metric, val)
     end
 
     def self.set_avg(metric, num, total)
-      val = total < 1 ? 0 : num / total
-      set_metric(metric, val)
+      run_backends(:set_avg, metric, num, total)
+    end
+
+    def self.known_jobs
+      run_first_backend(:known_jobs)
     end
 
     def self.get_metric(metric)
-      redis.get("_metrics_:#{metric}").to_i
+      run_first_backend(:get_metric, metric)
     end
 
     def self.total_enqueue_count
@@ -192,6 +258,18 @@ module Resque
       get_metric "job_count:job:#{job}"
     end
 
+    def self.failed_job_count
+      get_metric "failed_job_count"
+    end
+
+    def self.failed_job_count_by_queue(queue)
+      get_metric "failed_job_count:queue:#{queue}"
+    end
+
+    def self.failed_job_count_by_job(job)
+      get_metric "failed_job_count:job:#{job}"
+    end
+
     def self.total_payload_size
       get_metric "payload_size"
     end
@@ -252,6 +330,18 @@ module Resque
       get_metric "fork_count:job:#{job}"
     end
 
+    def self.failed_depth
+      get_metric "depth:failed"
+    end
+
+    def self.pending_depth
+      get_metric "depth:pending"
+    end
+
+    def self.depth_by_queue(queue)
+      get_metric "depth:queue:#{queue}"
+    end
+
     module Hooks
 
       def after_enqueue_metrics(*args)
@@ -265,6 +355,10 @@ module Resque
         Resque::Metrics.record_job_completion(self, finish)
       end
 
+      def on_failure_metrics(e, *args)
+        Resque::Metrics.record_job_failure(self, e)
+      end
+
     end
 
   end

data/resque-metrics.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: resque-metrics 0.0.6 ruby lib
+# stub: resque-metrics 0.1.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "resque-metrics"
-  s.version = "0.0.6"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
-  s.authors = ["Aaron Quint"]
-  s.date = "2014-02-12"
+  s.authors = ["Aaron Quint", "Josh Nichols", "Michael Smith", "Tomas Varaneckas"]
+  s.date = "2014-10-19"
   s.description = "A simple Resque plugin that times and saves some simple metrics for Resque jobs back into redis. Based on this system\nyou could build some simple auto-scaling mechanism based on the speed and ETA of queues. Also includes a hook/callback\nmechanism for recording/sending the metrics to your favorite tool (AKA statsd/graphite).\n"
   s.email = "aaron@quirkey.com"
   s.extra_rdoc_files = [
@@ -28,6 +28,11 @@ Gem::Specification.new do |s|
     "VERSION",
     "lib/resque-metrics.rb",
     "lib/resque/metrics.rb",
+    "lib/resque/metrics/backends.rb",
+    "lib/resque/metrics/backends/redis.rb",
+    "lib/resque/metrics/backends/statsd.rb",
+    "lib/resque/metrics/server.rb",
+    "lib/resque/metrics/server/views/metrics.erb",
     "resque-metrics.gemspec",
     "test/helper.rb",
     "test/redis-test.conf",
@@ -35,7 +40,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/quirkey/resque-metrics"
   s.licenses = ["MIT"]
-  s.rubygems_version = "2.2.1"
+  s.rubygems_version = "2.2.2"
   s.summary = "A Resque plugin for recording simple metrics for your jobs"
 
   if s.respond_to? :specification_version then

data/test/helper.rb

@@ -20,36 +20,42 @@ require 'resque/metrics'
 # make sure we can run redis
 #
 
-if !system("which redis-server")
-  puts '', "** can't find `redis-server` in your path"
-  puts "** try running `sudo rake install`"
-  abort ''
-end
+if ENV['BOXEN_REDIS_PORT']
+  redis_port = ENV['BOXEN_REDIS_PORT']
+else
+  if !system("which redis-server")
+    puts '', "** can't find `redis-server` in your path"
+    puts "** try running `sudo rake install`"
+    abort ''
+  end
 
-#
-# start our own redis when the tests start,
-# kill it when they end
-#
+  #
+  # start our own redis when the tests start,
+  # kill it when they end
+  #
 
-at_exit do
-  next if $!
+  at_exit do
+    next if $!
 
-  if defined?(MiniTest)
-    exit_code = MiniTest::Unit.new.run(ARGV)
-  else
-    exit_code = Test::Unit::AutoRunner.run
+    if defined?(MiniTest)
+      exit_code = MiniTest::Unit.new.run(ARGV)
+    else
+      exit_code = Test::Unit::AutoRunner.run
+    end
+
+    pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+    puts "Killing test redis server..."
+    Process.kill("KILL", pid.to_i)
+    FileUtils.rm_rf("#{dir}/dump.rdb")
+    exit exit_code
   end
 
-  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server..."
-  Process.kill("KILL", pid.to_i)
-  FileUtils.rm_rf("#{dir}/dump.rdb")
-  exit exit_code
-end
+  puts "Starting redis for testing at localhost:9736..."
+  `redis-server #{dir}/redis-test.conf`
 
-puts "Starting redis for testing at localhost:9736..."
-`redis-server #{dir}/redis-test.conf`
-Resque.redis = 'localhost:9736:2'
+  redis_port = 9736
+end
+Resque.redis = "localhost:#{redis_port}:2"
 
 class SomeJob
   extend Resque::Metrics
@@ -61,3 +67,13 @@ class SomeJob
   end
 
 end
+
+class FailureJob
+  extend Resque::Metrics
+
+  @queue = :jobs
+
+  def self.perform
+    raise "failing lol"
+  end
+end

data/test/test_resque-metrics.rb

@@ -13,6 +13,11 @@ class TestResqueMetrics < MiniTest::Unit::TestCase
     @num_jobs.times do
       work_job
     end
+
+    @num_failed_jobs = 2
+    @num_failed_jobs.times do 
+      fail_job
+    end
   end
 
   def test_should_pass_resque_plugin_lint
@@ -30,9 +35,10 @@ class TestResqueMetrics < MiniTest::Unit::TestCase
   end
 
   def test_should_record_enqueue_count
-    assert_equal @num_jobs, Resque::Metrics.total_enqueue_count
-    assert_equal @num_jobs, Resque::Metrics.total_enqueue_count_by_queue(:jobs)
+    assert_equal @num_jobs + @num_failed_jobs, Resque::Metrics.total_enqueue_count
+    assert_equal @num_jobs + @num_failed_jobs, Resque::Metrics.total_enqueue_count_by_queue(:jobs)
     assert_equal @num_jobs, Resque::Metrics.total_enqueue_count_by_job(SomeJob)
+    assert_equal @num_failed_jobs, Resque::Metrics.total_enqueue_count_by_job(FailureJob)
   end
 
   def test_should_record_job_count
@@ -41,6 +47,12 @@ class TestResqueMetrics < MiniTest::Unit::TestCase
     assert Resque::Metrics.total_job_count_by_job(SomeJob) > 0
   end
 
+  def test_should_record_failed_job_count
+    assert Resque::Metrics.failed_job_count > 0, "Expected #{Resque::Metrics.failed_job_count} to be > 0, but wasn't"
+    assert Resque::Metrics.failed_job_count_by_queue(:jobs) > 0
+    assert Resque::Metrics.failed_job_count_by_job(FailureJob) > 0
+  end
+
   def test_should_record_payload_size
     assert Resque::Metrics.total_payload_size > 0
     assert Resque::Metrics.total_payload_size_by_queue(:jobs) > 0
@@ -53,28 +65,56 @@ class TestResqueMetrics < MiniTest::Unit::TestCase
     assert Resque::Metrics.avg_job_time_by_job(SomeJob) > 0
   end
 
-  def test_should_call_callbacks
+  def test_should_call_job_complete_callbacks
     recorded = []
     recorded_count = 0
     Resque::Metrics.on_job_complete do |klass, queue, time|
-      recorded << [klass, queue, time]
+      recorded << {:klass => klass, :queue => queue, :time => time }
     end
     Resque::Metrics.on_job_complete do |klass, queue, time|
       recorded_count += 1
     end
+
     work_job
     work_job
+
     assert_equal 2, recorded.length
-    assert_equal SomeJob, recorded[0][0]
-    assert_equal :jobs, recorded[0][1]
-    assert recorded[0][2] > 0
+    assert_equal SomeJob, recorded[0][:klass]
+    assert_equal :jobs, recorded[0][:queue]
+    assert recorded[0][:time] > 0, "Expected #{recorded[0][:time]} to be > 0, but wasn't"
     assert_equal 2, recorded_count
   end
 
+  def test_should_call_job_failure_callbacks
+    recorded = []
+    recorded_count = 0
+    Resque::Metrics.on_job_failure do |klass, queue|
+      recorded << {:klass => klass, :queue => queue}
+    end
+    Resque::Metrics.on_job_failure do |klass, queue|
+      recorded_count += 1
+    end
+
+    fail_job
+    fail_job
+    fail_job
+
+    assert_equal 3, recorded.length
+    assert_equal FailureJob, recorded[0][:klass]
+    assert_equal :jobs, recorded[0][:queue]
+    assert_equal 3, recorded_count
+  end
+
   private
+
   def work_job
     Resque.enqueue(SomeJob, 20, '/tmp')
     @worker.work(0)
   end
 
+  def fail_job
+    Resque.enqueue(FailureJob)
+    @worker.work(0)
+  end
+
 end

metadata

@@ -1,14 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: resque-metrics
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Aaron Quint
+- Josh Nichols
+- Michael Smith
+- Tomas Varaneckas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-12 00:00:00.000000000 Z
+date: 2014-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -100,6 +103,11 @@ files:
 - VERSION
 - lib/resque-metrics.rb
 - lib/resque/metrics.rb
+- lib/resque/metrics/backends.rb
+- lib/resque/metrics/backends/redis.rb
+- lib/resque/metrics/backends/statsd.rb
+- lib/resque/metrics/server.rb
+- lib/resque/metrics/server/views/metrics.erb
 - resque-metrics.gemspec
 - test/helper.rb
 - test/redis-test.conf
@@ -124,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A Resque plugin for recording simple metrics for your jobs