coverband 2.0.0.alpha1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9097c59aa4f5773c332fd293f69cb1d7df603dd1
-  data.tar.gz: 3a5ab7f04712143179dbad86eeb2ba277fbb774e
+SHA256:
+  metadata.gz: 104227eaef7c235ff16b13a0f80c5f29fe4117deac05acbed7553e3343be7ea9
+  data.tar.gz: dd5a621f881e955c52c1a2acf903f3bc5abd550bc015650851cb385ff76bf758
 SHA512:
-  metadata.gz: f6daa2f9049f8e78772c8a45b11f863183f97aa70b7663b571d522997ac04a7ff503e82409ce6c8c8b97927607fc035cf6e6e9b49bc82f31dd806972cc2e1809
-  data.tar.gz: 6331d8400cb90438b5c63bf5038077c9ba30f2ecbd652cdc8fa5481bae4dcf0ca1e1639b9aab54b3dda0db8707699feac83f5762da9eefb814900a26818b61e8
+  metadata.gz: 7a2c2041a887b5ac729a540489b20e48fba117e2d70e827f3b7c5fb6da21382fa6786a093e915232771abc7a0903f78b3484713e39394fdf3bbf6cda6f8f57c9
+  data.tar.gz: 38ed9c82a8a607d349f4edef901d7d348b128c9ff2f6ad6276df388f29ee25e98c6e9534f3e0d4d16d1902f958575f72aa6676c8499d81f6a44b72eaaef534fc

data/README.md

@@ -1,29 +1,33 @@
 # Coverband
 
-[![Build Status](https://travis-ci.org/danmayer/coverband.svg?branch=master)](https://travis-ci.org/danmayer/coverband)
+Build Status: [![Build Status](https://travis-ci.org/danmayer/coverband.svg?branch=master)](https://travis-ci.org/danmayer/coverband)
 
-A gem to measure production code usage, showing each line of code that is executed. Coverband allows easy configuration to collect and report on production code usage. It can be used as Rack middleware, wrapping a block with sampling, or manually configured to meet any need (like usage during background jobs). I like to think of this as production code coverage, but that implies test coverage to some folks, so being more explicit to say that it shows when a line of code is executed in a given environment is the most accurate way to describe it.
+<p align="center">
+  <a href="#key-features">Key Features</a> •
+  <a href="#how-to-use">How To Use</a> •
+  <a href="#installation">Installation</a> •
+  <a href="#configuration">Configuration</a> •
+  <a href="#usage">Usage</a> •
+  <a href="#license">License</a>
+</p>
 
-* Allow sampling to avoid the performance overhead on every request.
-* Ignore directories to avoid overhead data collection on vendor, lib, etc.
-* Take a baseline to get initial app execution during app initialization. (the baseline is important because some code is executed during app load, but might not be invoked during any requests, think prefetching, initial cache builds, setting constants, etc...)
-* Development mode for additional code usage details (number of LOC execution during single request, etc).
-* Coverband is not intended for test code coverage, for that just check out [SimpleCov](https://github.com/colszowka/simplecov).
-
-__Notes:__ Latest versions of Coverband drop support for anything less than Ruby 2.0, and Ruby 2.1+ is recommended.
+A gem to measure production code usage, showing each line of code that is executed. Coverband allows easy configuration to collect and report on production code usage. It can be used as Rack middleware, wrapping a block with sampling, or manually configured to meet any need (like usage during background jobs).
 
-###### Success:
+Note: Coverband is not intended for test code coverage, for that just check out [SimpleCov](https://github.com/colszowka/simplecov).
 
-After running in production for 30 minutes, we were able very easily delete 2000 LOC after looking through the data. We expect to be able to clean up much more after it has collected more data.
+## Key Features
 
-###### Performance Impact
+* Allows sampling to avoid the performance overhead on every request.
+* Ignore directories to avoid overhead data collection on vendor, lib, etc.
+* Take a baseline to get initial app execution during app initialization. (the baseline is important because some code is executed during app load, but might not be invoked during any requests, think prefetching, initial cache builds, setting constants, etc...)
+* Development mode for additional code usage details (number of LOC execution during single request, etc).
 
-The performance impact on Ruby 2.1+ is fairly small and no longer requires a C-extension. Look at the benchmark rake task for specific details.
+# How To Use
 
-## How I use Coverband
+Below is my Coverband workflow, which hopefully will help other best use this library.
 
 * install coverband.
-* take baseline: `rake coverband:baseline` (__note: never run baseline on production__)
+* take baseline measurment: `rake coverband:baseline` (__note: never run baseline on production__)
 * validate baseline with  `rake coverband:coverage`
 * test setup in development (hit endpoints and generate new report)
 * deploy to staging and verify functionality
@@ -38,7 +42,29 @@ The performance impact on Ruby 2.1+ is fairly small and no longer requires a C-e
    * there is a tradeoff on accuracy and data value
    * I recommend clearing after major code changes, significant releases, or some regular schedule.
 
-## Installation
+## Example Output
+
+Since Coverband is [Simplecov](https://github.com/colszowka/simplecov) output compatible it should work with any of the `SimpleCov::Formatter`'s available. The output below is produced using the default Simplecov HTML formatter.
+
+Index Page
+![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_index.png)
+
+Details on a example Sinatra app
+![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_details.png)
+
+
+# Installation
+
+Follow the below section to install and configure Coverband.
+
+![coverband installation](https://raw.githubusercontent.com/danmayer/coverband/feature/via_coverage/docs/coverband_install.gif?raw=true)
+
+## Prerequisites
+
+* Coverband requires Ruby 2.1 to run the older and slower implementation (TracePoint).
+* Modern Coverband Ruby 2.3+ is recommended, this runs the (Coverage) implementation.
+
+## Gem Installation
 
 Add this line to your application's Gemfile:
 
@@ -58,86 +84,45 @@ Or install it yourself as:
 $ gem install coverband
 ```
 
-That gives you the gem, but to get up and running then follow:
-
-* [Coverband Configuration](https://github.com/danmayer/coverband#configuration)
-  * Rake integration
-  * Coverband config setup
-  * Require Coverband
-  * Insert middleware in stack  
-* run `bundle exec rake coverband:baseline` ([what is baseline?](https://github.com/danmayer/coverband#coverband-baseline)) (__note: never run baseline on production__)
-* run `bundle exec rake coverband:coverage` this will show app initialization coverage
-* run app and hit a controller (hit at least +1 time over your `config.startup_delay` setting default is 0)
-* run `bundle exec rake coverband:coverage` and you should see coverage increasing for the endpoints you hit.
-
-
-## Example Output
-
-Since Coverband is [Simplecov](https://github.com/colszowka/simplecov) output compatible it should work with any of the `SimpleCov::Formatter`'s available. The output below is produced using the default Simplecov HTML formatter.
-
-Index Page
-![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_index.png)
-
-Details on a example Sinatra app
-![image](https://raw.github.com/danmayer/coverband/master/docs/coverband_details.png)
+# Configuration
 
-## Notes
+After you have the gem, you will want to setup the needed integration:
 
-* Coverband has been used on large scale production websites without large impacts on performance. Adjusting the sample rate to achieve an acceptable trade-off on detailed information vs performance impact. Coverband started as a Ruby 1.9 project and the performance impact has been reduced by each Ruby release since.
+1. Coverband Config File Setup
+2. Configure Rake
+3. Insert Coverband Rack Middleware
 
-## Coverband Baseline
+### 1. Coverband Config File Setup
 
-__TLDR:__ Baseline is app initialization coverage, not captured during runtime.
-
-The baseline seems to cause some confusion. Basically, when Coverband records code usage, it will not request initial startup code like method definition, it covers what it hit during run time. This would produce a fairly odd view of code usage. To cover things like defining routes, dynamic methods, and the like Coverband records a baseline. The baseline should capture coverage of app initialization and boot up, we don't want to do this on deploy as it can be slow. So we take a recording of boot up as a one time baseline Rake task `bundle exec rake coverband:baseline`.
-
-## Configuration
-
-### 1. Create Coverband config file
-
-You need to configure cover band you can either do that passing in all configuration options to `Coverband.configure` in block format, or a simpler style is to call `Coverband.configure` with nothing while will load `config/coverband.rb` expecting it to configure the app correctly. Below is an example config file for a Sinatra app:
+You need to configure cover band you can either do that passing in all configuration options to `Coverband.configure` in block format, or a simpler style is to call `Coverband.configure` with nothing while will load `config/coverband.rb` expecting it to configure the app correctly. Below is an example config file for a Rails 5 app:
 
 ```ruby
 #config/coverband.rb
 Coverband.configure do |config|
   config.root              = Dir.pwd
-  
-  if defined? Redis
-    config.redis           = Redis.new(:host => 'redis.host.com', :port => 49182, :db => 1)
-  end
-  # don't want to use redis, store to file system ;)
-  # config.coverage_file           = './tmp/coverband_coverage.json'
-  
-  # DEPRECATED now will use redis or file store
-  # config.coverage_baseline = Coverband.parse_baseline
-  
-  config.root_paths        = ['/app/'] # /app/ is needed for heroku deployments
-  # regex paths can help if you are seeing files duplicated for each capistrano deployment release
-  #config.root_paths       = ['/server/apps/my_app/releases/\d+/']
-  config.ignore            = ['vendor','lib/scrazy_i18n_patch_thats_hit_all_the_time.rb']
-  # Since rails and other frameworks lazy load code. I have found it is bad to allow
-  # initial requests to record with coverband. This ignores first 15 requests
-  # NOTE: If you are using a threaded webserver (example: Puma) this will ignore requests for each thread
-  config.startup_delay     = Rails.env.production? ? 5 : 0
-  # Percentage of requests recorded
-  config.percentage        = Rails.env.production? ? 30.0 : 100.0
-
+  config.collector         = 'coverage'
+  config.redis             = Redis.new(url: ENV['REDIS_URL']) if defined? Redis
+  config.ignore            = %w[vendor .erb$ .slim$]
+  # add paths that you deploy to that might be different than your local dev root path
+  config.root_paths        = []
+
+  # reporting frequency
+  # if you are debugging changes to coverband I recommend setting to 100.0
+  # otherwise it is find to report slowly over time with less performance impact
+  # with the Coverage collector coverage is ALWAYS captured this is just how frequently
+  # it is reported to your back end store.
+  config.percentage        = Rails.env.production? ? 1.0 : 100.0
   config.logger            = Rails.logger
 
-  #stats help you collect how often you are sampling requests and other info
-  if defined? Statsd
-    config.stats           = Statsd.new('statsd.host.com', 8125)
-  end
-  
   # config options false, true, or 'debug'. Always use false in production
   # true and debug can give helpful and interesting code usage information
   # they both increase the performance overhead of the gem a little.
   # they can also help with initially debugging the installation.
-  config.verbose           = Rails.env.production? ? false : true
+  # config.verbose           = 'debug'
 end
 ```
 
-### 2. Configuring Rake
+### 2. Configure Rake
 
 Either add the below to your `Rakefile` or to a file included in your Rakefile such as `lib/tasks/coverband.rake` if you want to break it up that way.
 
@@ -146,7 +131,7 @@ require 'coverband'
 Coverband.configure
 require 'coverband/tasks'
 ```
-This should give you access to a number of cover band tasks
+This should give you access to a number of Coverband tasks
 
 ```bash
 bundle exec rake -T coverband
@@ -155,27 +140,39 @@ rake coverband:clear         # reset coverband coverage data
 rake coverband:coverage      # report runtime coverband code coverage
 ```
 
-The default Coverband baseline task will try to detect your app as either Rack or Rails environment. It will load the app to take a baseline reading. The baseline coverage is important because some code is executed during app load, but might not be invoked during any requests, think prefetching, initial cache builds, setting constants, etc. If the baseline task doesn't load your app well you can override the default baseline to create a better baseline yourself. Below for example is how I take a baseline on a pretty simple Sinatra app.
+### 3. Configure Rack to use the Coverband middleware
+
+The middleware is what makes Coverband gather metrics while a webapp app runs.
+
+#### For Rails apps
+
+There are a number of options for starting Coverband and when to insert it into your middleware stack. At the moment this is my recommendation, to ensure you capture usage data on any files required by other plugins.
+
+Then add the middleware to your Rails rake middle ware stack:
 
 ```ruby
-namespace :coverband do
-  desc "get coverage baseline"
-  task :baseline_app do
-    Coverband::Reporter.baseline {
-      require 'sinatra'
-      require './app.rb'
-    }
-  end
-end
-```
+# config/application.rb
+[...]
 
-To verify that rake is working run `rake coverband:baseline`
-then run `rake coverband:coverage` to view what your baseline coverage looks like before any runtime traffic has been recorded.
+module MyApplication
+  class Application < Rails::Application
+    [...]
 
-### 3. Configure Rack to use the Coverband middleware
+    # Coverband needs to be setup before any of the initializers to capture usage of them
+    require 'coverband'
+    Coverband.configure
+    config.middleware.use Coverband::Middleware
 
-The middleware is what makes Coverband gather metrics when your app runs.
-I setup Coverband in my rackup `config.ru` you can also set it up in rails middleware, but it may miss recording some code coverage early in the rails process. It does improve performance to have it later in the middleware stack. So there is a tradeoff there.
+    # if one uses before_eager_load as I did previously
+    # any files that get loaded as part of railties will have no coverage
+    config.before_initialize do
+      require 'coverage'
+      Coverband::Collectors::Base.instance.start
+    end
+
+  end
+end
+```
 
 #### For Sinatra apps
 
@@ -191,51 +188,130 @@ use Coverband::Middleware
 run ActionController::Dispatcher.new
 ```
 
-#### For Rails apps
+# Verify Correct Installation
 
-Create an initializers file
+* Gather baseline metrics: run `bundle exec rake coverband:baseline` (__note: never run baseline on production__)
+* run `bundle exec rake coverband:coverage` this will show app initialization coverage
+* run app and hit a controller (hit at least +1 time over your `config.startup_delay` setting default is 0)
+* run `bundle exec rake coverband:coverage` and you should see coverage increasing for the endpoints you hit.
 
-```ruby
-# config/initializers/coverband_middleware.rb
+## Installation Script
 
-# Configure the Coverband Middleware
+These are the steps show in setting up coverband in the gif in the readme.
+
+```
+rails new coverage_example
+cd coverage_example
+atom .
+
+# open Gemfile, add lines
+gem 'redis'
+gem 'coverband', '>= 2.0.0.alpha1', require: false
+
+bundle install
+
+# create config/coverband.rb
+# copy the config from the readme
+# If you don't set REDIS_URL, remove that to use default localhose
+
+rails generate scaffold blogs
+bundle exec rake db:migrate
+
+# open Rakefile, add lines
 require 'coverband'
 Coverband.configure
-```
+require 'coverband/tasks'
 
-Then add the middleware to your Rails rake middle ware stack:
+# verify rake
+rake -T coverband
 
-```ruby
-# config/application.rb
-[...]
+# configure config/application.rb
+# copy lines from readme
 
-module MyApplication
-  class Application < Rails::Application
-    [...]
 
-    # Coverband use Middleware
-    config.middleware.use Coverband::Middleware
+rake coverband:baseline
+rake coverband:coverage
+# view baseline coverage
 
-  end
-end
+rails s
+
+open http://localhost:3000/blogs
+
+# click around some to trigger usage
+
+# view updated coverage
+rake coverband:coverage
 ```
 
-Note: To debug in development mode, I recommend turning verbose logging on `config.verbose = true` and passing in the Rails.logger `config.logger = Rails.logger` to the Coverband config. This makes it easy to follow in development mode. Be careful to not leave these on in production as they will affect performance.
+# Usage
+
+### Example apps
+
+- [Rails 5.1.x App](https://github.com/danmayer/coverage_rails_benchmark)
+- [Sinatra app](https://github.com/danmayer/churn-site)
+- [Non Rack Ruby app](https://github.com/danmayer/coverband_examples)
+
+### Coverband Baseline
 
-## Usage
+__TLDR:__ Baseline is app initialization coverage, not captured during runtime.
+
+Before starting a service verify your baseline by running `rake coverband:baseline` followed by `rake coverband:coverage` to view what your baseline coverage looks like before any runtime traffic has been recorded.
+
+The baseline seems to cause some confusion. Basically, when Coverband records code usage, it will not request initial startup code like method definition, it covers what it hit during run time. This would produce a fairly odd view of code usage. To cover things like defining routes, dynamic methods, and the like Coverband records a baseline. The baseline should capture coverage of app initialization and boot up, we don't want to do this on deploy as it can be slow. So we take a recording of boot up as a one time baseline Rake task `bundle exec rake coverband:baseline`.
 
 1. Start your server with `rails s` or `rackup config.ru`.
 2. Hit your development server exercising the endpoints you want to verify Coverband is recording (you should see debug outputs in your server console)
 3. Run `rake coverband:coverage` again, previously it should have only shown the baseline data of your app initializing. After using it in development it should show increased coverage from the actions you have exercised.
 
-Note: if you use `rails s` and data aren't recorded, make sure it is using your `config.ru`.
+Note: if you use `rails s` and data isn't recorded, make sure it is using your `config.ru`.
 
-## Example apps
+### Baseline Missing data
 
-- [Rails app](https://github.com/arnlen/rails-coverband-example-app)
-- [Rails app with Coverband 1.1](https://github.com/danmayer/covered_rails)
-- [Sinatra app](https://github.com/danmayer/churn-site)
-- [Non rack ruby app](https://github.com/danmayer/coverband_examples)
+The default Coverband baseline task will try to detect your app as either Rack or Rails environment. It will load the app to take a baseline reading. The baseline coverage is important because some code is executed during app load, but might not be invoked during any requests, think prefetching, initial cache builds, setting constants, etc. If the baseline task doesn't load your app well you can override the default baseline to create a better baseline yourself. Below for example is how I take a baseline on a pretty simple Sinatra app.
+
+```ruby
+namespace :coverband do
+  desc "get coverage baseline"
+  task :baseline_app do
+    Coverband::Reporter.baseline {
+      require 'sinatra'
+      require './app.rb'
+    }
+  end
+end
+```
+
+### View Coverage
+
+You can view the report different ways, but the easiest is the Rake task which opens the Simplecov formated HTML.
+
+`bundle exec rake coverband:coverage`
+
+This should auto-open in your browser, but if it doesn't the output file should be in `coverage/index.html`
+
+### Clear Coverage
+
+If your code has changed and your coverage line data doesn't seem to match run time. You probably need to clear your old line data... You will need to run this in the environment you wish to clear the data from.
+
+`rake coverband:clear`
+
+### Automated Clearing Line Coverage Data
+
+After a deploy where code has changed significantly.
+
+The line numbers previously recorded in Redis may no longer match the current state of the files.
+If being slightly out of sync isn't as important as gathering data over a long period,
+you can live with minor inconsistency for some files.
+
+As often as you like or as part of a deploy hook you can clear the recorded Coverband data with the following command.
+
+```ruby
+# defaults to the currently configured Coverband.configuration.redis
+Coverband::Reporter.clear_coverage
+# or pass in the current target redis
+Coverband::Reporter.clear_coverage(Redis.new(:host => 'target.com', :port => 6789))
+```
+You can also do this with the included rake tasks.
 
 ### Manual configuration (for example for background jobs)
 
@@ -284,26 +360,11 @@ coverband.sample {
 }
 ```
 
-### Clearing Line Coverage Data
+### Verbose Debug / Development Mode
 
-After a deploy where code has changed significantly.
+Note: To debug issues getting coverband working. I recommend running in development mode, by turning verbose logging on `config.verbose = true` and passing in the Rails.logger `config.logger = Rails.logger` to the Coverband config. This makes it easy to follow in development mode. Be careful to not leave these on in production as they will affect performance.
 
-The line numbers previously recorded in Redis may no longer match the current state of the files.
-If being slightly out of sync isn't as important as gathering data over a long period,
-you can live with minor inconsistency for some files.
-
-As often as you like or as part of a deploy hook you can clear the recorded Coverband data with the following command.
-
-```ruby
-# defaults to the currently configured Coverband.configuration.redis
-Coverband::Reporter.clear_coverage
-# or pass in the current target redis
-Coverband::Reporter.clear_coverage(Redis.new(:host => 'target.com', :port => 6789))
-```
-You can also do this with the included rake tasks.
-
-
-### Verbose debug mode for development
+---
 
 If you are trying to debug locally wondering what code is being run during a request. The verbose modes `config.verbose = true` and `config.verbose = 'debug'` can be useful. With true set it will output the number of lines executed per file, to the passed in log. The files are sorted from least used file to most active file. I have even run that mode in production without much of a problem. The debug verbose mode outputs both file usage and provides the number of calls per line of code. For example if you see something like below which indicates that the `application_helper` has 43150 lines executed. That might seem odd. Then looking at the breakdown of `application_helper` we can see that line `516` was executed 38,577 times. That seems bad, and is likely worth investigating perhaps memoizing or cacheing is required.
 
@@ -339,24 +400,101 @@ Coverband::Reporter.report :additional_scov_data => [data]
 
 You can also pass a `:additional_scov_data => [data]` option to `Coverband::Reporter.get_current_scov_data` to write out merged data.
 
-### Coverband development
+# Contributing To Coverband
 
 If you are working on adding features, PRs, or bugfixes to Coverband this section should help get you going.
 
+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. Make sure all tests are passing (run `bundle install`, make sure Redis is running, and then execute `bundle exec rake test`)
+6. Create new Pull Request
+
+### Tests & Benchmarks
+
+If you submit a change please make sure the tests and benchmarks are passing.
+
 * run tests: `bundle exec rake`
 * view test coverage: `open coverage/index.html`
 * run the benchmarks before and after your change to see impact
    * `bundle exec rake benchmarks` 
 
-### Known issues
+### Known Issues
 
 * __total fail__ on front end code, because of the precompiled template step basically coverage doesn't work well for `erb`, `slim`, and the like.
-* If you don't have a baseline recorded your coverage can look odd like you are missing a bunch of data. It would be good if Coverband gave a more actionable warning in this situation.
 * If you have SimpleCov filters, you need to clear them prior to generating your coverage report. As the filters will be applied to Coverband as well and can often filter out everything we are recording.
 * the line numbers reported for `ERB` files are often off and aren't considered useful. I recommend filtering out .erb using the `config.ignore` option.
 * coverage doesn't show for Rails `config/application.rb` or `config/boot.rb` as they get loaded when loading the Rake environment prior to starting to record the baseline..
 
-## TODO
+### Debugging Redis Store
+
+What files have been synced to Redis?
+
+`Coverband.configuration.store.covered_files`
+
+What is the coverage data in Redis?
+
+`Coverband.configuration.store.coverage`
+
+### Internal Formats
+
+If you are doing development having some documented examples of various internal data formats can be helpfu....
+
+The format we get from TracePoint, Coverage, Internal Representations, and Used by SimpleCov for reporting have traditionally varied a bit. We can document the differences in formats here.
+
+#### Coverage
+
+```
+>> require 'coverage'
+=> true
+>> Coverage.start
+=> nil
+>> require './test/unit/dog.rb'
+=> true
+>>  5.times { Dog.new.bark }
+=> 5
+>> Coverage.peek_result
+=> {"/Users/danmayer/projects/coverband/test/unit/dog.rb"=>[nil, nil, 1, 1, 5, nil, nil]}
+```
+
+#### SimpleCov
+
+The same format, but relative paths.
+
+```
+{"test/unit/dog.rb"=>[1, 2, nil, nil, nil, nil, nil]}
+```
+
+#### Redis Store
+
+We store relative path in Redis, the Redis hash stores line numbers -> count (as strings).
+
+```
+# Array
+["test/unit/dog.rb"]
+
+# Hash
+{"test/unit/dog.rb"=>{"1"=>"1", "2"=>"2"}}
+```
+
+#### File Store
+
+Similar format to redis store, but array with integer values
+
+```
+{"test/unit/dog.rb"=>{"1"=>1, "2"=>2}}
+```
+
+# Future Coverband
+
+### Alternative Redis formats
+
+* Look at alternative storage formats for Redis
+  * [redis bitmaps](http://blog.getspool.com/2011/11/29/fast-easy-realtime-metrics-using-redis-bitmaps/)
+  * [redis bitfield](https://stackoverflow.com/questions/47100606/optimal-way-to-store-array-of-integers-in-redis-database)
+
+### Todo
 
 * graphite adapters (it would allow passing in date ranges on usage)
 * perf test for array vs hash
@@ -371,25 +509,15 @@ If you are working on adding features, PRs, or bugfixes to Coverband this sectio
 * ability to change the Coverband config at runtime by changing the config pushed to the Redis hash. In memory cache around the changes to only make that call periodically.
 * Opposed to just showing code usage on a route allow 'tagging' events which would record line coverage for that tag (this would allow tagging all code that modified an ActiveRecord model for example
 * mountable rack app to view coverage similar to flipper-ui
+* support runner, active job, etc without needed extra config (improved railtie integration)
 
-## 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. Make sure all tests are passing (run `bundle install`, make sure Redis is running, and then execute `bundle exec rake test`)
-6. Create new Pull Request
-
-## Resources
+# Resources
 
 These notes of kind of for myself, but if anyone is seriously interested in contributing to the project, these resources might be helpful. I learned a lot looking at various existing projects and open source code.
 
 ##### Ruby Std-lib Coverage
 
-* [Fixed bug causing segfaults on 1.9.X](https://www.ruby-forum.com/topic/1811306)
-* [Current Coverage Bug causing issues on 2.1.1](https://bugs.ruby-lang.org/issues/9572)
-* [Ruby Coverage docs](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/coverage/rdoc/Coverage.html)
+* [Ruby Coverage docs](https://ruby-doc.org/stdlib-2.5.0/libdoc/coverage/rdoc/Coverage.html)
 
 ##### Other
 
@@ -404,5 +532,7 @@ These notes of kind of for myself, but if anyone is seriously interested in cont
 * [learn from stackprof](https://github.com/tmm1/stackprof#readme)
 * I believe there are possible ways to get even better data using the new [Ruby2 TracePoint API](http://www.ruby-doc.org/core/TracePoint.html)
 
-## MIT License
+# License
+
+This is a MIT License project...
 See the file license.txt for copying permission.