coverband 4.2.3 → 4.2.4

data/lib/coverband/utils/railtie.rb

@@ -11,22 +11,29 @@ module Coverband
 
   class Railtie < Rails::Railtie
     initializer 'coverband.configure' do |app|
-      app.middleware.use Coverband::BackgroundMiddleware
+      begin
+        app.middleware.use Coverband::BackgroundMiddleware
 
-      if Coverband.configuration.track_views
-        CoverbandViewTracker = Coverband::Collectors::ViewTracker.new
-        Coverband.configuration.view_tracker = CoverbandViewTracker
+        if Coverband.configuration.track_views
+          CoverbandViewTracker = Coverband::Collectors::ViewTracker.new
+          Coverband.configuration.view_tracker = CoverbandViewTracker
 
-        ActiveSupport::Notifications.subscribe(/render_partial.action_view|render_template.action_view/) do |name, start, finish, id, payload|
-          CoverbandViewTracker.track_views(name, start, finish, id, payload) unless name.include?('!')
+          ActiveSupport::Notifications.subscribe(/render_partial.action_view|render_template.action_view/) do |name, start, finish, id, payload|
+            CoverbandViewTracker.track_views(name, start, finish, id, payload) unless name.include?('!')
+          end
         end
+      rescue Redis::CannotConnectError => error
+        Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+        Coverband.configuration.logger.info 'If this is a setup task like assets:precompile feel free to ignore'
       end
     end
 
     config.after_initialize do
-      Coverband.eager_loading_coverage!
-      Coverband.report_coverage
-      Coverband.runtime_coverage!
+      unless Coverband.tasks_to_ignore?
+        Coverband.eager_loading_coverage!
+        Coverband.report_coverage
+        Coverband.runtime_coverage!
+      end
     end
 
     rake_tasks do

data/lib/coverband/utils/s3_report.rb

@@ -28,7 +28,6 @@ module Coverband
         rescue StandardError
           err_msg = 'Coverband requires aws-sdk in order use S3Report.'
           Coverband.configuration.logger&.error err_msg
-          return
         end
       end
 

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format '4.2.1.rc.1' ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = '4.2.3'
+  VERSION = '4.2.4'
 end

data/lib/coverband.rb

@@ -99,12 +99,17 @@ module Coverband
     Coverband::Collectors::Coverage.instance
   end
   unless ENV['COVERBAND_DISABLE_AUTO_START']
-    # Coverband should be setup as early as possible
-    # to capture usage of things loaded by initializers or other Rails engines
-    configure
-    start
-    require 'coverband/utils/railtie' if defined? ::Rails::Railtie
-    require 'coverband/integrations/resque' if defined? ::Resque
-    require 'coverband/integrations/bundler' if defined? ::Bundler
+    begin
+      # Coverband should be setup as early as possible
+      # to capture usage of things loaded by initializers or other Rails engines
+      configure
+      start
+      require 'coverband/utils/railtie' if defined? ::Rails::Railtie
+      require 'coverband/integrations/resque' if defined? ::Resque
+      require 'coverband/integrations/bundler' if defined? ::Bundler
+    rescue Redis::CannotConnectError => error
+      Coverband.configuration.logger.info "Redis is not available (#{error}), Coverband not configured"
+      Coverband.configuration.logger.info 'If this is a setup task like assets:precompile feel free to ignore'
+    end
   end
 end

data/lua/install.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+LUA_DIR="$HOME/lua51"
+LUA="$LUA_DIR/bin/lua"
+
+if [ ! -f $LUA ]; then
+  echo "Installing lua"
+  pip install hererocks
+  hererocks $LUA_DIR -l5.1 -rlatest
+fi
+source $LUA_DIR/bin/activate
+lua -v
+for i in luacov busted redis-lua inspect lua-cjson; do 
+  luarocks install $i;
+done

data/lua/lib/persist-coverage.lua

@@ -0,0 +1,28 @@
+local hmset = function (key, dict)
+  if next(dict) == nil then return nil end
+  local bulk = {}
+  for k, v in pairs(dict) do
+    table.insert(bulk, k)
+    table.insert(bulk, v)
+  end
+  return redis.call('HMSET', key, unpack(bulk))
+end
+local payload = cjson.decode(redis.call('get', (KEYS[1])))
+local ttl = payload.ttl
+local files_data = payload.files_data
+redis.call('DEL', KEYS[1])
+for _, file_data in ipairs(files_data) do
+
+  local hash_key = file_data.hash_key
+  local first_updated_at = file_data.meta.first_updated_at
+  file_data.meta.first_updated_at = nil
+
+  hmset(hash_key, file_data.meta)
+  redis.call('HSETNX', hash_key, 'first_updated_at', first_updated_at)
+  for line, coverage in pairs(file_data.coverage) do
+    redis.call("HINCRBY", hash_key, line, coverage)
+  end
+  if ttl and ttl ~= cjson.null then
+    redis.call("EXPIRE", hash_key, ttl)
+  end
+end

data/lua/test/bootstrap.lua

@@ -0,0 +1,5 @@
+inspect = require "inspect"
+cjson = require 'cjson'
+require './lua/test/redis-call'
+
+

data/lua/test/harness.lua

@@ -0,0 +1,19 @@
+require './lua/test/bootstrap'
+
+
+KEYS = {}
+ARGV = {}
+
+
+function call_redis_script(script, keys, argv)
+  -- This may not be strictly necessary
+  for k,v in pairs(ARGV) do ARGV[k] = nil end
+  for k,v in pairs(KEYS) do KEYS[k] = nil end
+
+  for k,v in pairs(keys) do table.insert(KEYS, v) end
+  for k,v in pairs(argv) do table.insert(ARGV, v)  end
+
+  return dofile('./lua/lib/' .. script)
+end
+
+return call_redis_script;

data/lua/test/redis-call.lua

@@ -0,0 +1,55 @@
+redis = require 'redis'
+
+-- If you have some different host/port change it here
+local host = "127.0.0.1"
+local port = 6379
+
+
+client = redis.connect(host, port)
+
+-- Workaround for absence of redis.call
+redis.call = function(cmd, ...)
+  local arg={...}
+  local args_string = ''
+  for i,v in ipairs(arg) do
+    args_string = args_string .. ' ' .. v
+  end
+  cmd = string.lower(cmd)
+  print(cmd .. args_string)
+  --local result = assert(load('return client:'.. cmd ..'(...)'))(...)
+  local result = assert(loadstring('return client:'.. cmd ..'(...)'))(...)
+
+  -- The redis-lua library returns some values differently to how `redis.call` works inside redis.
+  -- this makes the responses look like those from the builtin redis
+  local response_lookup = {
+    type = function() return { ["ok"]= result } end,
+    sadd = function() return tonumber(result) end,
+    zrange = function()
+      if type(result) == "table" and type(result[1]) == "table" then
+        -- Deal with WITHSCORES...
+        local new_result = {}
+        for k,v in pairs(result) do
+          table.insert(new_result, v[1])
+          table.insert(new_result, v[2])
+        end
+        return new_result;
+      end
+
+      return result;
+    end,
+    hgetall = function()
+      local new_result = {}
+      for key, value in pairs(result) do
+        table.insert(new_result, key)
+        table.insert(new_result, value)
+      end
+      return new_result
+    end
+  }
+
+  if response_lookup[cmd] then
+    return response_lookup[cmd]()
+  end
+
+  return result;
+end

data/lua/test/test-persist-coverage.lua

@@ -0,0 +1,132 @@
+local call_redis_script = require "./lua/test/harness";
+
+describe("persist-coverage", function()
+  local function hgetall(hash_key)
+    local flat_map = redis.call('HGETALL', hash_key)
+    local result = {}
+    for i = 1, #flat_map, 2 do
+      result[flat_map[i]] = flat_map[i + 1]
+    end
+    return result
+  end
+
+  local function clean_redis() 
+    redis.call('flushdb')
+  end
+
+  before_each(function()
+    clean_redis()
+  end)
+
+  after_each(function()
+    clean_redis()
+  end)
+
+  it("Adds data on multiple files", function()
+    local first_updated_at = "1569453853"
+    local last_updated_at = first_updated_at
+
+    local key = 'hash_key'
+    local json = cjson.encode({
+      ttl = nil,
+      files_data = {
+        {
+          hash_key = "coverband_hash_3_3.coverband_test.runtime../dog.rb.abcd",
+          meta = {
+            first_updated_at = first_updated_at, 
+            last_updated_at = last_updated_at, 
+            file = "./dog.rb",
+            file_hash = 'abcd', 
+            file_length = 3 
+          },
+          coverage = {
+            ['0'] = 0, 
+            ['1'] = 1, 
+            ['2'] = 2
+          }
+        },
+        {
+          hash_key = "coverband_hash_3_3.coverband_test.runtime../fish.rb.1234",
+          meta = {
+            first_updated_at = first_updated_at, 
+            last_updated_at = last_updated_at, 
+            file = "./fish.rb",
+            file_hash = '1234', 
+            file_length = 3
+          },
+          coverage = {
+            ['0'] = 1, 
+            ['1'] = 0, 
+            ['2'] = 1 
+          }
+        }
+      }
+    });
+    redis.call( 'set', key, json)
+
+    call_redis_script('persist-coverage.lua',  { key },  {});
+    local results = hgetall("coverband_hash_3_3.coverband_test.runtime../dog.rb.abcd")
+    assert.are.same({
+      ["0"] = "0",
+      ["1"] = "1",
+      ["2"] = "2",
+      file = "./dog.rb",
+      file_hash = "abcd",
+      file_length = "3",
+      first_updated_at = first_updated_at ,
+      last_updated_at = last_updated_at
+    }, results)
+
+    results = hgetall("coverband_hash_3_3.coverband_test.runtime../fish.rb.1234")
+    assert.are.same({
+      ["0"] = "1",
+      ["1"] = "0",
+      ["2"] = "1",
+      file = "./fish.rb",
+      file_hash = "1234",
+      file_length = "3",
+      first_updated_at = first_updated_at ,
+      last_updated_at = last_updated_at
+    }, results)
+
+    assert.is_false(false, redis.call('exists', key))
+
+    last_updated_at = "1569453953"
+    json = cjson.encode({
+      ttl = nil,
+      files_data = {
+        {
+          hash_key="coverband_hash_3_3.coverband_test.runtime../dog.rb.abcd",
+          meta = {
+            first_updated_at=first_updated_at, 
+            last_updated_at=last_updated_at, 
+            file="./dog.rb", 
+            file_hash='abcd', 
+            file_length=3
+          },
+          coverage = {
+            ['0']= 1, 
+            ['1']= 1, 
+            ['2']= 1
+          }
+        }
+      }
+    })
+    redis.call( 'set', key, json )
+
+    call_redis_script('persist-coverage.lua',  { key },  {} );
+    results = hgetall("coverband_hash_3_3.coverband_test.runtime../dog.rb.abcd")
+    assert.are.same({
+      ["0"] = "1",
+      ["1"] = "2",
+      ["2"] = "3",
+      file = "./dog.rb",
+      file_hash = "abcd",
+      file_length = "3",
+      first_updated_at = first_updated_at,
+      last_updated_at = last_updated_at 
+    }, results)
+
+    assert.is_false(false, redis.call('exists', key))
+  end)
+end)

data/test/coverband/adapters/hash_redis_store_test.rb

@@ -13,13 +13,12 @@ class HashRedisStoreTest < Minitest::Test
 
   def setup
     super
-    @redis = Redis.new
+    @redis = Coverband::Test.redis
     # FIXME: remove dependency on configuration and instead pass this in as an argument
     Coverband.configure do |config|
       config.root_paths = ['app_path/']
     end
     @store = Coverband::Adapters::HashRedisStore.new(@redis, redis_namespace: 'coverband_test', relative_file_converter: MockRelativeFileConverter)
-    @store.clear!
     Coverband.configuration.store = @store
   end
 
@@ -57,6 +56,7 @@ class HashRedisStoreTest < Minitest::Test
       {
         'first_updated_at' => yesterday.to_i,
         'last_updated_at' => yesterday.to_i,
+        'file_hash' => 'abcd',
         'data' => [0, 1, 2]
       },
       @store.coverage['./dog.rb']
@@ -69,6 +69,7 @@ class HashRedisStoreTest < Minitest::Test
       {
         'first_updated_at' => yesterday.to_i,
         'last_updated_at' => today.to_i,
+        'file_hash' => 'abcd',
         'data' => [1, 2, 2]
       },
       @store.coverage['./dog.rb']
@@ -107,6 +108,7 @@ class HashRedisStoreTest < Minitest::Test
       {
         'first_updated_at' => current_time.to_i,
         'last_updated_at' => current_time.to_i,
+        'file_hash' => 'abcd',
         'data' => [0, nil, 1, 2]
       }, @store.coverage['./dog.rb']
     )
@@ -121,7 +123,6 @@ class HashRedisStoreTest < Minitest::Test
     assert_equal [0, nil, 1, 2], @store.coverage['./dog.rb']['data']
     @store.instance_eval { @file_hash_cache = {} }
     mock_file_hash(hash: '123')
-    $debug = true
     assert_nil @store.coverage['./dog.rb']
   end
 

data/test/coverband/adapters/redis_store_test.rb

@@ -8,11 +8,8 @@ unless ENV['COVERBAND_HASH_REDIS_STORE']
 
     def setup
       super
-      Coverband.configuration.redis_namespace = 'coverband_test'
-      @redis = Redis.new
-      @store = Coverband::Adapters::RedisStore.new(@redis, redis_namespace: 'coverband_test')
-      Coverband.configuration.store = @store
-      @store.clear!
+      @store = Coverband.configuration.store
+      @redis = @store.instance_variable_get(:@redis)
     end
 
     def test_coverage
@@ -39,6 +36,14 @@ unless ENV['COVERBAND_HASH_REDIS_STORE']
       assert current_time <= @store.coverage['app_path/dog.rb']['last_updated_at']
     end
 
+    def test_file_hash_change
+      mock_file_hash(hash: 'abc')
+      @store.save_report('app_path/dog.rb' => [0, nil, 1, 2])
+      assert_equal [0, nil, 1, 2], @store.coverage['app_path/dog.rb']['data']
+      mock_file_hash(hash: '123')
+      assert_nil @store.coverage['app_path/dog.rb']
+    end
+
     def test_store_coverage_by_type
       mock_file_hash
       expected = basic_coverage

data/test/coverband/collectors/coverage_test.rb

@@ -7,10 +7,7 @@ class CollectorsCoverageTest < Minitest::Test
 
   def setup
     super
-    Coverband.configure do |config|
-      config.store = Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
-    end
-    @coverband = Coverband::Collectors::Coverage.instance.reset_instance
+    @coverband = Coverband::Collectors::Coverage.instance
     # preload first coverage hit
     @coverband.report_coverage
   end
@@ -85,6 +82,15 @@ class CollectorsCoverageTest < Minitest::Test
     assert_equal false, @coverband.send(:track_file?, heroku_build_file)
   end
 
+  # verifies a fix where we were storing, merging, and tracking ignored files
+  # then just filtering them out of the final report
+  test 'ignores uses regex same as reporter does' do
+    regex_file = Coverband.configuration.current_root + '/config/initializers/fake.rb'
+    assert_equal true, @coverband.send(:track_file?, regex_file)
+    @coverband.instance_variable_set(:@ignore_patterns, ['config/initializers/*'])
+    assert_equal false, @coverband.send(:track_file?, regex_file)
+  end
+
   test 'one shot line coverage disabled for ruby >= 2.6' do
     return unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
 

data/test/coverband/collectors/view_tracker_test.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require File.expand_path('../../test_helper', File.dirname(__FILE__))
 
 class ReporterTest < Minitest::Test
-
   def tracker_key
     'render_tracker_2'
   end
@@ -11,75 +12,95 @@ class ReporterTest < Minitest::Test
     fake_store.raw_store.del(tracker_key)
   end
 
-  test "init correctly" do
+  test 'init correctly' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
-    tracker = Coverband::Collectors::ViewTracker.new(:store => fake_store, :roots => 'dir')
+    tracker = Coverband::Collectors::ViewTracker.new(store: fake_store, roots: 'dir')
     assert_equal 'dir', tracker.roots.first
-    assert tracker.store != nil
+    assert !tracker.store.nil?
     assert_equal [], tracker.target
     assert_equal [], tracker.logged_views
   end
 
-  test "track partials" do
+  test 'track partials' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
     store.raw_store.expects(:hset).with(tracker_key, file_path, anything)
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
     tracker.report_views_tracked
     assert_equal [file_path], tracker.logged_views
   end
 
-  test "track layouts" do
+  test 'track partials that include the word vendor in the path' do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/vendor_relations/file"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
+    tracker.report_views_tracked
+    assert_equal [file_path], tracker.used_views.keys
+  end
+
+  test 'ignore partials that include the folder vendor in the path' do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/vendor/file"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
+    tracker.report_views_tracked
+    assert_equal Hash.new, tracker.used_views
+  end
+
+  test 'track layouts' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/layout"
     store.raw_store.expects(:hset).with(tracker_key, file_path, anything)
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', {:layout => file_path})
+    tracker.track_views('name', 'start', 'finish', 'id', layout: file_path)
     tracker.report_views_tracked
     assert_equal [file_path], tracker.logged_views
   end
 
-  test "report used partials" do
+  test 'report used partials' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
     tracker.report_views_tracked
     assert_equal [file_path], tracker.used_views.keys
   end
 
-  test "report unused partials" do
+  test 'report unused partials' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
     target = [file_path, 'not_used']
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir', target: target)
-    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
     tracker.report_views_tracked
     assert_equal ['not_used'], tracker.unused_views
   end
 
-  test "reset store" do
+  test 'reset store' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     store.raw_store.expects(:del).with(tracker_key)
     store.raw_store.expects(:del).with('render_tracker_time')
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => 'file'})
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: 'file')
     tracker.reset_recordings
   end
 
-  test "clear_file" do
+  test 'clear_file' do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
     file_path = "#{File.expand_path(Coverband.configuration.root)}/file"
     store.raw_store.expects(:hdel).with(tracker_key, file_path)
     tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: 'dir')
-    tracker.track_views('name', 'start', 'finish', 'id', {:identifier => file_path})
+    tracker.track_views('name', 'start', 'finish', 'id', identifier: file_path)
     tracker.clear_file!('file')
     assert_equal [], tracker.logged_views
   end
@@ -87,7 +108,6 @@ class ReporterTest < Minitest::Test
   protected
 
   def fake_store
-    @fake_store ||= Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: 'coverband_test')
   end
-
 end

data/test/coverband/configuration_test.rb

@@ -12,13 +12,13 @@ class BaseTest < Minitest::Test
       config.root_paths          = ['/app_path/']
       config.ignore              = ['config/envionments']
       config.reporter            = 'std_out'
-      config.store               = Coverband::Adapters::RedisStore.new(Redis.new, redis_namespace: 'coverband_test')
+      config.store               = Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: 'coverband_test')
     end
   end
 
   test 'ignore works with equal' do
     coverband = Coverband::Collectors::Coverage.instance.reset_instance
-    expected = ["vendor", ".erb$", ".slim$", "/tmp", "internal:prelude", "schema.rb", "config/envionments"]
+    expected = ['vendor/', '.erb$', '.slim$', '/tmp', 'internal:prelude', 'schema.rb', 'config/envionments']
     assert_equal expected, Coverband.configuration.ignore
   end
 
@@ -27,14 +27,14 @@ class BaseTest < Minitest::Test
       config.ignore += ['config/initializers']
     end
     coverband = Coverband::Collectors::Coverage.instance.reset_instance
-    expected = ["vendor",
-      ".erb$",
-      ".slim$",
-      "/tmp",
-      "internal:prelude",
-      "schema.rb",
-      "config/envionments",
-      "config/initializers"]
+    expected = ['vendor/',
+                '.erb$',
+                '.slim$',
+                '/tmp',
+                'internal:prelude',
+                'schema.rb',
+                'config/envionments',
+                'config/initializers']
     assert_equal expected, Coverband.configuration.ignore
   end
 

data/test/coverband/integrations/background_test.rb

@@ -19,6 +19,16 @@ class BackgroundTest < Minitest::Test
     2.times { Coverband::Background.start }
   end
 
+  def test_start_with_wiggle
+    Thread.expects(:new).yields.returns(ThreadDouble.new(true))
+    Coverband::Background.expects(:loop).yields
+    Coverband::Background.expects(:sleep).with(35)
+    Coverband::Background.expects(:rand).with(10).returns(5)
+    Coverband.configuration.reporting_wiggle = 10
+    Coverband::Collectors::Coverage.instance.expects(:report_coverage).once
+    2.times { Coverband::Background.start }
+  end
+
   def test_start_dead_thread
     Thread.expects(:new).yields.returns(ThreadDouble.new(false)).twice
     Coverband::Background.expects(:loop).yields.twice

data/test/coverband/integrations/resque_worker_test.rb

@@ -16,7 +16,6 @@ class ResqueWorkerTest < Minitest::Test
     Coverband.configure do |config|
       config.background_reporting_enabled = false
     end
-    Coverband.configuration.store.instance_variable_set(:@redis_namespace, 'coverband_test')
     Coverband.start
     redis = Coverband.configuration.store.instance_eval { @redis }
     Resque.redis = redis