sidekiq-benchmark 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sidekiq-benchmark.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Konstantin Kosmatov
+
+MIT License
+
+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,50 @@
+# Sidekiq::Benchmark
+ 
+Adds benchmarking methods to Sidekiq workers, keeps metrics and adds tab to Web UI to let you browse them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sidekiq-benchmark'
+
+And then execute:
+
+    $ bundle
+
+## Requirements
+
+Redis 2.6.0 or newer required
+
+## Usage
+
+```ruby
+class SampleWorker
+  include Sidekiq::Worker
+  include Sidekiq::Benchmark::Worker
+
+  def perform(id)
+    benchmark do |bm|
+      bm.some_metric do
+        100500.times do
+        end
+      end
+
+      bm.other_metric do
+        something_code
+      end
+    end
+  end
+
+end
+```
+## Web UI
+![Web UI](https://github.com/kosmatov/sidekiq-benchmark/raw/master/examples/web-ui.png)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+task default: :test
+
+Rake::TestTask.new :test do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/*_test.rb'
+end

data/lib/sidekiq-benchmark.rb

@@ -0,0 +1,12 @@
+require 'sidekiq/web'
+require 'sidekiq-benchmark/web'
+
+module Sidekiq
+  module Benchmark
+    autoload :Worker, 'sidekiq-benchmark/worker'
+    autoload :Version, 'sidekiq-benchmark/version'
+  end
+end
+
+Sidekiq::Web.register Sidekiq::Benchmark::Web
+Sidekiq::Web.tabs["Benchmarks"] = "benchmarks"

data/lib/sidekiq-benchmark/version.rb

@@ -0,0 +1,5 @@
+module Sidekiq
+  module Benchmark
+    VERSION = "0.1.0"
+  end
+end

data/lib/sidekiq-benchmark/web.rb

@@ -0,0 +1,61 @@
+require 'sinatra/assetpack'
+require 'chartkick'
+
+module Sidekiq
+  module Benchmark
+    module Web
+      def self.registered(app)
+        web_dir = File.expand_path("../../../web", __FILE__)
+        js_dir = File.join(web_dir, "assets", "javascripts")
+
+        app.helpers Chartkick::Helper
+        app.register Sinatra::AssetPack
+
+        app.assets {
+          serve '/js', from: js_dir
+
+          js 'chartkick', ['/js/chartkick.js']
+        }
+
+        app.get "/benchmarks" do
+          @charts = {}
+
+          Sidekiq.redis do |conn|
+            @types = conn.smembers "benchmark:types"
+            @types.each do |type|
+              @charts[type] = { total: [], stats: [] }
+
+              total_keys = conn.hkeys("benchmark:#{type}:total") -
+                ['start_time', 'job_time', 'finish_time']
+
+              total_time = conn.hget "benchmark:#{type}:total", :job_time
+              total_time = total_time.to_f
+              total_keys.each do |key|
+                value = conn.hget "benchmark:#{type}:total", key
+                @charts[type][:total] << [key, value.to_f.round(2)]
+              end
+
+              stats = conn.hgetall "benchmark:#{type}:stats"
+              stats.each do |key, value|
+                @charts[type][:stats] << [key.to_f, value.to_i]
+              end
+            end
+          end
+
+          view_path = File.join(web_dir, "views", "benchmarks.slim")
+          template = File.read view_path
+          render :slim, template
+        end
+
+        app.post "/benchmarks/remove" do
+          Sidekiq.redis do |conn|
+            keys = conn.keys "benchmark:*"
+            conn.del keys
+          end
+
+          redirect "#{root_path}benchmarks"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq-benchmark/worker.rb

@@ -0,0 +1,85 @@
+module Sidekiq
+  module Benchmark
+    module Worker
+
+      def benchmark(options = {})
+        bm = Benchmark.new Time.now
+
+        yield(bm)
+
+        bm.finish_time = Time.now
+        bm.save benchmark_redis_base_key, options
+
+        bm.set_redis_key benchmark_redis_type_key
+        bm
+      end
+
+      def benchmark_redis_type_key
+        @benchmark_redis_type_key ||= self.class.name.gsub('::', '_').downcase
+      end
+
+      def benchmark_redis_base_key
+        @benchmark_redis_base_key ||= "benchmark:#{benchmark_redis_type_key}"
+      end
+
+      class Benchmark
+        attr_reader :metrics, :start_time, :finish_time
+
+        def initialize(start_time)
+          @metrics = {}
+          @start_time = start_time.to_f
+        end
+
+        def finish_time=(value)
+          @finish_time = value.to_f
+          @metrics[:job_time] = @finish_time - start_time
+        end
+
+        def method_missing(name, *args)
+          if block_given?
+            start_time = Time.now
+
+            yield
+
+            finish_time = Time.now
+            value = finish_time.to_f - start_time.to_f
+          else
+            value = args[0].to_f
+          end
+
+          @metrics[name] = value
+        end
+
+        def set_redis_key(key)
+          Sidekiq.redis do |conn|
+            conn.sadd "benchmark:types", key
+          end
+        end
+
+        def save(redis_base_key, options = {})
+          options.merge! start_time: start_time, finish_time: finish_time
+          options.merge! @metrics
+
+          job_time_key = @metrics[:job_time].round(1)
+
+          Sidekiq.redis do |conn|
+            conn.multi do
+              # Isn't usefull at this moment
+              #conn.lpush "#{redis_base_key}:jobs", Sidekiq.dump_json(options)
+
+              @metrics.each do |key, value|
+                conn.hincrbyfloat "#{redis_base_key}:total", key, value
+                conn.hincrby "#{redis_base_key}:stats", job_time_key, 1
+              end
+
+              conn.hsetnx "#{redis_base_key}:total", "start_time", start_time
+              conn.hincrbyfloat "#{redis_base_key}:total", "job_time", @metrics[:job_time]
+              conn.hset "#{redis_base_key}:total", "finish_time", finish_time
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/sidekiq-benchmark.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sidekiq-benchmark/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "sidekiq-benchmark"
+  gem.version       = Sidekiq::Benchmark::VERSION
+  gem.authors       = ["Konstantin Kosmatov"]
+  gem.email         = ["key@kosmatov.ru"]
+  gem.description   = %q{Benchmarks for Sidekiq}
+  gem.summary       = %q{Adds benchmarking methods to Sidekiq workers, keeps metrics and adds tab to Web UI to let you browse them.}
+  gem.homepage      = "https://github.com/kosmatov/sidekiq-benchmark/"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "chartkick"
+  gem.add_dependency "sinatra-assetpack"
+
+  gem.add_development_dependency "sidekiq"
+  gem.add_development_dependency "slim"
+  gem.add_development_dependency "sinatra"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rack-test"
+  gem.add_development_dependency "minitest", "~> 5"
+end

data/test/lib/web_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Sidekiq
+  module Benchmark
+    module Test
+      describe "Web extention" do
+        include Rack::Test::Methods
+
+        def app
+          @app ||= Sidekiq::Web
+        end
+
+        before do
+          Test.flush_db
+        end
+
+        it "should display index without stats" do
+          get '/benchmarks'
+          last_response.status.must_equal 200
+        end
+
+        it "should display index with stats" do
+          WorkerMock.new
+
+          get '/benchmarks'
+          last_response.status.must_equal 200, last_response.body
+        end
+      end
+    end
+  end
+end

data/test/lib/worker_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+module Sidekiq
+  module Benchmark
+    module Test
+
+      class WorkerTest < Minitest::Spec
+        include Sidekiq::Benchmark::Worker
+
+        before do
+          Test.flush_db
+          @worker = WorkerMock.new
+        end
+
+        it "should collect metrics" do
+          metrics = @worker.bm_obj.metrics
+
+          @worker.metric_names.each do |metric_name|
+            assert metrics[metric_name]
+          end
+
+          assert @worker.bm_obj.start_time
+          assert @worker.bm_obj.finish_time
+        end
+
+        it "should save metrics to redis" do
+          Sidekiq.redis do |conn|
+            total_time = conn.hget("#{@worker.benchmark_redis_base_key}:total", :job_time)
+            assert total_time, "Total time: #{total_time.inspect}"
+
+            metrics = conn.hkeys("#{@worker.benchmark_redis_base_key}:stats")
+            assert metrics.any?, "Metrics: #{metrics.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,49 @@
+require 'minitest/pride'
+
+require 'bundler/setup'
+require 'rack/test'
+
+require 'sidekiq'
+require 'sidekiq/util'
+require 'sidekiq-benchmark'
+
+REDIS = Sidekiq::RedisConnection.create url: "redis://localhost/15", namespace: "testy"
+
+Bundler.require
+
+module Sidekiq
+  module Benchmark
+    module Test
+
+      class WorkerMock
+        include Sidekiq::Worker
+        include Sidekiq::Benchmark::Worker
+
+        attr_reader :bm_obj, :metric_names
+
+        def initialize
+          @bm_obj = benchmark do |bm|
+            bm.test_metric do
+              2.times do |i|
+                bm.send("nested_test_metric_#{i}") do
+                  100500.times do |i|
+                  end
+                end
+              end
+            end
+          end
+
+          @metric_names = [:test_metric, :nested_test_metric_1, :job_time]
+        end
+      end
+
+      def self.flush_db
+        Sidekiq.redis = REDIS
+        Sidekiq.redis do |conn|
+          conn.flushdb
+        end
+      end
+
+    end
+  end
+end

data/web/assets/javascripts/chartkick.js

@@ -0,0 +1,536 @@
+/*jslint browser: true, indent: 2, plusplus: true */
+/*global google, $*/
+
+(function() {
+  'use strict';
+
+  // http://stackoverflow.com/questions/728360/most-elegant-way-to-clone-a-javascript-object
+  function clone(obj) {
+    var copy, i, attr, len;
+
+    // Handle the 3 simple types, and null or undefined
+    if (null === obj || "object" !== typeof obj) {
+      return obj;
+    }
+
+    // Handle Date
+    if (obj instanceof Date) {
+      copy = new Date();
+      copy.setTime(obj.getTime());
+      return copy;
+    }
+
+    // Handle Array
+    if (obj instanceof Array) {
+      copy = [];
+      for (i = 0, len = obj.length; i < len; i++) {
+        copy[i] = clone(obj[i]);
+      }
+      return copy;
+    }
+
+    // Handle Object
+    if (obj instanceof Object) {
+      copy = {};
+      for (attr in obj) {
+        if (obj.hasOwnProperty(attr)) {
+          copy[attr] = clone(obj[attr]);
+        }
+      }
+      return copy;
+    }
+
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+  }
+
+  // https://github.com/Do/iso8601.js
+  var ISO8601_PATTERN = /(\d\d\d\d)(\-)?(\d\d)(\-)?(\d\d)(T)?(\d\d)(:)?(\d\d)?(:)?(\d\d)?([\.,]\d+)?($|Z|([\+\-])(\d\d)(:)?(\d\d)?)/i;
+  var DECIMAL_SEPARATOR = String(1.5).charAt(1);
+
+  function parseISO8601(input) {
+    var day, hour, matches, milliseconds, minutes, month, offset, result, seconds, type, year;
+    type = Object.prototype.toString.call(input);
+    if (type === '[object Date]') {
+      return input;
+    }
+    if (type !== '[object String]') {
+      return;
+    }
+    if (matches = input.match(ISO8601_PATTERN)) {
+      year = parseInt(matches[1], 10);
+      month = parseInt(matches[3], 10) - 1;
+      day = parseInt(matches[5], 10);
+      hour = parseInt(matches[7], 10);
+      minutes = matches[9] ? parseInt(matches[9], 10) : 0;
+      seconds = matches[11] ? parseInt(matches[11], 10) : 0;
+      milliseconds = matches[12] ? parseFloat(DECIMAL_SEPARATOR + matches[12].slice(1)) * 1000 : 0;
+      result = Date.UTC(year, month, day, hour, minutes, seconds, milliseconds);
+      if (matches[13] && matches[14]) {
+        offset = matches[15] * 60;
+        if (matches[17]) {
+          offset += parseInt(matches[17], 10);
+        }
+        offset *= matches[14] === '-' ? -1 : 1;
+        result -= offset * 60 * 1000;
+      }
+      return new Date(result);
+    }
+  }
+  // end iso8601.js
+
+  function negativeValues(series) {
+    var i, j, data;
+    for (i = 0; i < series.length; i++) {
+      data = series[i].data;
+      for (j = 0; j < data.length; j++) {
+        if (data[j][1] < 0) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  function jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax) {
+    return function(series, opts) {
+      var options = clone(defaultOptions);
+
+      // hide legend
+      if (series.length === 1) {
+        hideLegend(options);
+      }
+
+      // min
+      if ("min" in opts) {
+        setMin(options, opts.min);
+      }
+      else if (!negativeValues(series)) {
+        setMin(options, 0);
+      }
+
+      // max
+      if ("max" in opts) {
+        setMax(options, opts.max);
+      }
+
+      return options;
+    };
+  }
+
+  // only functions that need defined specific to charting library
+  var renderLineChart, renderPieChart, renderColumnChart;
+
+  if ("Highcharts" in window) {
+
+    var defaultOptions = {
+      xAxis: {
+        labels: {
+          style: {
+            fontSize: "12px"
+          }
+        }
+      },
+      yAxis: {
+        title: {
+          text: null
+        },
+        labels: {
+          style: {
+            fontSize: "12px"
+          }
+        }
+      },
+      title: {
+        text: null
+      },
+      credits: {
+        enabled: false
+      },
+      legend: {
+        borderWidth: 0
+      },
+      tooltip: {
+        style: {
+          fontSize: "12px"
+        }
+      }
+    };
+
+    var hideLegend = function(options) {
+      options.legend.enabled = false;
+    };
+
+    var setMin = function(options, min) {
+      options.yAxis.min = min;
+    };
+
+    var setMax = function(options, max) {
+      options.yAxis.max = max;
+    };
+
+    var jsOptions = jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax);
+
+    renderLineChart = function(element, series, opts) {
+      var options = jsOptions(series, opts), data, i, j;
+      options.xAxis.type = "datetime";
+      options.chart = {type: "spline"};
+
+      for (i = 0; i < series.length; i++) {
+        data = series[i].data;
+        for (j = 0; j < data.length; j++) {
+          data[j][0] = data[j][0].getTime();
+        }
+        series[i].marker = {symbol: "circle"};
+      }
+      options.series = series;
+      $(element).highcharts(options);
+    };
+
+    renderPieChart = function(element, series, opts) {
+      var options = clone(defaultOptions);
+      options.series = [{
+        type: "pie",
+        name: "Value",
+        data: series
+      }];
+      $(element).highcharts(options);
+    };
+
+    renderColumnChart = function(element, series, opts) {
+      var options = jsOptions(series, opts), i, j, s, d, rows = [];
+      options.chart = {type: "column"};
+
+      for (i = 0; i < series.length; i++) {
+        s = series[i];
+
+        for (j = 0; j < s.data.length; j++) {
+          d = s.data[j];
+          if (!rows[d[0]]) {
+            rows[d[0]] = new Array(series.length);
+          }
+          rows[d[0]][i] = d[1];
+        }
+      }
+
+      var categories = [];
+      for (i in rows) {
+        if (rows.hasOwnProperty(i)) {
+          categories.push(i);
+        }
+      }
+      options.xAxis.categories = categories;
+
+      var newSeries = [];
+      for (i = 0; i < series.length; i++) {
+        d = [];
+        for (j = 0; j < categories.length; j++) {
+          d.push(rows[categories[j]][i]);
+        }
+
+        newSeries.push({
+          name: series[i].name,
+          data: d
+        });
+      }
+      options.series = newSeries;
+
+      $(element).highcharts(options);
+    };
+  } else if ("google" in window) { // Google charts
+    // load from google
+    var loaded = false;
+    google.setOnLoadCallback(function() {
+      loaded = true;
+    });
+    google.load("visualization", "1.0", {"packages": ["corechart"]});
+
+    var waitForLoaded = function(callback) {
+      google.setOnLoadCallback(callback); // always do this to prevent race conditions (watch out for other issues due to this)
+      if (loaded) {
+        callback();
+      }
+    };
+
+    // Set chart options
+    var defaultOptions = {
+      fontName: "'Lucida Grande', 'Lucida Sans Unicode', Verdana, Arial, Helvetica, sans-serif",
+      pointSize: 6,
+      legend: {
+        textStyle: {
+          fontSize: 12,
+          color: "#444"
+        },
+        alignment: "center",
+        position: "right"
+      },
+      curveType: "function",
+      hAxis: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        },
+        gridlines: {
+          color: "transparent"
+        },
+        baselineColor: "#ccc"
+      },
+      vAxis: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        },
+        baselineColor: "#ccc",
+        viewWindow: {}
+      },
+      tooltip: {
+        textStyle: {
+          color: "#666",
+          fontSize: 12
+        }
+      }
+    };
+
+    var hideLegend = function(options) {
+      options.legend.position = "none";
+    };
+
+    var setMin = function(options, min) {
+      options.vAxis.viewWindow.min = min;
+    };
+
+    var setMax = function(options, max) {
+      options.vAxis.viewWindow.max = max;
+    };
+
+    var jsOptions = jsOptionsFunc(defaultOptions, hideLegend, setMin, setMax);
+
+    // cant use object as key
+    var createDataTable = function(series, columnType) {
+      var data = new google.visualization.DataTable();
+      data.addColumn(columnType, "");
+
+      var i, j, s, d, key, rows = [];
+      for (i = 0; i < series.length; i++) {
+        s = series[i];
+        data.addColumn("number", s.name);
+
+        for (j = 0; j < s.data.length; j++) {
+          d = s.data[j];
+          key = (columnType === "datetime") ? d[0].getTime() : d[0];
+          if (!rows[key]) {
+            rows[key] = new Array(series.length);
+          }
+          rows[key][i] = toFloat(d[1]);
+        }
+      }
+
+      var rows2 = [];
+      for (i in rows) {
+        if (rows.hasOwnProperty(i)) {
+          rows2.push([(columnType === "datetime") ? new Date(toFloat(i)) : i].concat(rows[i]));
+        }
+      }
+      data.addRows(rows2);
+
+      return data;
+    };
+
+    renderLineChart = function(element, series, opts) {
+      waitForLoaded(function() {
+        var options = jsOptions(series, opts);
+        var data = createDataTable(series, "datetime");
+        var chart = new google.visualization.LineChart(element);
+        chart.draw(data, options);
+      });
+    };
+
+    renderPieChart = function(element, series, opts) {
+      waitForLoaded(function() {
+        var options = clone(defaultOptions);
+        options.chartArea = {
+          top: "10%",
+          height: "80%"
+        };
+
+        var data = new google.visualization.DataTable();
+        data.addColumn("string", "");
+        data.addColumn("number", "Value");
+        data.addRows(series);
+
+        var chart = new google.visualization.PieChart(element);
+        chart.draw(data, options);
+      });
+    };
+
+    renderColumnChart = function(element, series, opts) {
+      waitForLoaded(function() {
+        var options = jsOptions(series, opts);
+        var data = createDataTable(series, "string");
+        var chart = new google.visualization.ColumnChart(element);
+        chart.draw(data, options);
+      });
+    };
+  } else { // no chart library installed
+    renderLineChart = renderPieChart = renderColumnChart = function() {
+      throw new Error("Please install Google Charts or Highcharts");
+    };
+  }
+
+  function setText(element, text) {
+    if (document.body.innerText) {
+      element.innerText = text;
+    } else {
+      element.textContent = text;
+    }
+  }
+
+  function chartError(element, message) {
+    setText(element, "Error Loading Chart: " + message);
+    element.style.color = "#ff0000";
+  }
+
+  function getJSON(element, url, success) {
+    $.ajax({
+      dataType: "json",
+      url: url,
+      success: success,
+      error: function(jqXHR, textStatus, errorThrown) {
+        var message = (typeof errorThrown === "string") ? errorThrown : errorThrown.message;
+        chartError(element, message);
+      }
+    });
+  }
+
+  function errorCatcher(element, data, opts, callback) {
+    try {
+      callback(element, data, opts);
+    } catch (err) {
+      chartError(element, err.message);
+      throw err;
+    }
+  }
+
+  function fetchDataSource(element, dataSource, opts, callback) {
+    if (typeof dataSource === "string") {
+      getJSON(element, dataSource, function(data, textStatus, jqXHR) {
+        errorCatcher(element, data, opts, callback);
+      });
+    } else {
+      errorCatcher(element, dataSource, opts, callback);
+    }
+  }
+
+  // helpers
+
+  function isArray(variable) {
+    return Object.prototype.toString.call(variable) === "[object Array]";
+  }
+
+  // type conversions
+
+  function toStr(n) {
+    return "" + n;
+  }
+
+  function toFloat(n) {
+    return parseFloat(n);
+  }
+
+  function toDate(n) {
+    if (typeof n !== "object") {
+      if (typeof n === "number") {
+        n = new Date(n * 1000); // ms
+      } else { // str
+        // try our best to get the str into iso8601
+        // TODO be smarter about this
+        var str = n.replace(/ /, "T").replace(" ", "").replace("UTC", "Z");
+        n = parseISO8601(str) || new Date(n);
+      }
+    }
+    return n;
+  }
+
+  function toArr(n) {
+    if (!isArray(n)) {
+      var arr = [], i;
+      for (i in n) {
+        if (n.hasOwnProperty(i)) {
+          arr.push([i, n[i]]);
+        }
+      }
+      n = arr;
+    }
+    return n;
+  }
+
+  // process data
+
+  function sortByTime(a, b) {
+    return a[0].getTime() - b[0].getTime();
+  }
+
+  function processSeries(series, time) {
+    var i, j, data, r, key;
+
+    // see if one series or multiple
+    if (!isArray(series) || typeof series[0] !== "object" || isArray(series[0])) {
+      series = [{name: "Value", data: series}];
+    }
+
+    // right format
+    for (i = 0; i < series.length; i++) {
+      data = toArr(series[i].data);
+      r = [];
+      for (j = 0; j < data.length; j++) {
+        key = data[j][0];
+        key = time ? toDate(key) : toStr(key);
+        r.push([key, toFloat(data[j][1])]);
+      }
+      if (time) {
+        r.sort(sortByTime);
+      }
+      series[i].data = r;
+    }
+
+    return series;
+  }
+
+  function processLineData(element, data, opts) {
+    renderLineChart(element, processSeries(data, true), opts);
+  }
+
+  function processColumnData(element, data, opts) {
+    renderColumnChart(element, processSeries(data, false), opts);
+  }
+
+  function processPieData(element, data, opts) {
+    var perfectData = toArr(data), i;
+    for (i = 0; i < perfectData.length; i++) {
+      perfectData[i] = [toStr(perfectData[i][0]), toFloat(perfectData[i][1])];
+    }
+    renderPieChart(element, perfectData, opts);
+  }
+
+  function setElement(element, data, opts, callback) {
+    if (typeof element === "string") {
+      element = document.getElementById(element);
+    }
+    fetchDataSource(element, data, opts || {}, callback);
+  }
+
+  // define classes
+
+  var Chartkick = {
+    LineChart: function(element, dataSource, opts) {
+      setElement(element, dataSource, opts, processLineData);
+    },
+    ColumnChart: function(element, dataSource, opts) {
+      setElement(element, dataSource, opts, processColumnData);
+    },
+    PieChart: function(element, dataSource, opts) {
+      setElement(element, dataSource, opts, processPieData);
+    }
+  };
+
+  window.Chartkick = Chartkick;
+})();

data/web/views/benchmarks.slim

@@ -0,0 +1,18 @@
+script src="//www.google.com/jsapi"
+==js :chartkick
+
+header.row
+  .span5
+    h3 Benchmarks
+
+section
+  - @types.each do |type|
+    section
+      h4= type
+      figure.row
+        .span5
+          h5 Count jobs by execution time
+          == column_chart @charts[type][:stats]
+        .span4
+          h5 Average execution time
+          == pie_chart @charts[type][:total]

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-benchmark
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Konstantin Kosmatov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chartkick
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-assetpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: slim
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Benchmarks for Sidekiq
+email:
+- key@kosmatov.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/web-ui.png
+- lib/sidekiq-benchmark.rb
+- lib/sidekiq-benchmark/version.rb
+- lib/sidekiq-benchmark/web.rb
+- lib/sidekiq-benchmark/worker.rb
+- sidekiq-benchmark.gemspec
+- test/lib/web_test.rb
+- test/lib/worker_test.rb
+- test/test_helper.rb
+- web/assets/javascripts/chartkick.js
+- web/views/benchmarks.slim
+homepage: https://github.com/kosmatov/sidekiq-benchmark/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Adds benchmarking methods to Sidekiq workers, keeps metrics and adds tab
+  to Web UI to let you browse them.
+test_files:
+- test/lib/web_test.rb
+- test/lib/worker_test.rb
+- test/test_helper.rb
+has_rdoc: