silencer 1.0.0.rc3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c3957c09e55e6fcaa4028e2cfadbe5f356c9948
-  data.tar.gz: 42c65e23eb1d156e0566b3a19251fd88f4cec662
+  metadata.gz: d2f6e12917e629307fa4e989b58e40e582239b48
+  data.tar.gz: 00d6fdf3db1107a3eeab0774d6d19e229d0365df
 SHA512:
-  metadata.gz: 007f356080f9a3a0fa4698a968fd21434db70dfc809c4643ba64e78bf43eb45cec69684579efb15ed6da875690683d8069b0a66799e397ea4c9d513317d0b6c9
-  data.tar.gz: 496d3ee52a8d11aa9d2ce9d3eff1805716327b474025f23302aa3a92f9f692c59b5dae76e967c120b06e4c5154496e61c2bd903d2f2984e18ce7829aea4d8e2d
+  metadata.gz: 50c6487b88a6fa6fff7a5c621a5207d75a7bbb32b891cabdfbd08cb343f57eb9a2df1dd3a2ed9794e4c1f1368e1a6aeddff1d953b8efee944cfbdb3b60dfd096
+  data.tar.gz: 1025cf5f7748607427929508c1f1f615231f1847e55ae0209213b389cd574a88d4cd27e3b97794337d6f86afc379da563df4b621a6b81c4f8afadb025899529c

data/README.md

@@ -1,11 +1,17 @@
-# Silencer [![Build Status](https://secure.travis-ci.org/spagalloco/silencer.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/spagalloco/silencer.png?travis)][gemnasium]
+# Silencer
 
-[travis]: http://travis-ci.org/spagalloco/silencer
-[gemnasium]: https://gemnasium.com/spagalloco/silencer
+
+[![Gem Version](http://img.shields.io/gem/v/silencer.svg)][gem]
+[![Build Status](http://img.shields.io/travis/stve/silencer.svg)][travis]
+[![Dependency Status](http://img.shields.io/gemnasium/stve/silencer.svg)][gemnasium]
+
+[gem]: https://rubygems.org/gems/silencer
+[travis]: https://travis-ci.org/stve/silencer
+[gemnasium]: https://gemnasium.com/stve/silencer
 
 Silencer is a simple rack-middleware for Rails that can selectively disable logging on per-action basis.  It's based on a [blog post](http://dennisreimann.de/blog/silencing-the-rails-log-on-a-per-action-basis/) by Dennis Reimann.
 
-__Note__: Silencer is not thread safe.
+__Note__: Silencer is only threadsafe in Rails version 4.2.6 and later.
 
 ## Installation
 
@@ -15,22 +21,39 @@ Just add silencer to your Gemfile:
 
 ## Usage
 
-In your production environment (presumably):
+### Rails
 
+Create an initializer (like `config/initializers/silencer.rb`) with the contents:
 
-    require 'silencer/logger'
+```ruby
+require 'silencer/logger'
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => ["/noisy/action.json"]
+Rails.application.configure do
+  config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => ["/noisy/action.json"]
+end
+```
 
-Or if you'd prefer, you can pass it regular expressions:
+### Rack
 
+```ruby
+require 'silencer/logger'
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => [%r{^/assets/}]
+use Silencer::Logger, :silence => ["/noisy/action.json"]
+```
 
-Or you can silence specific request methods only:
+## Configuration
 
+Or if you'd prefer, you can pass it regular expressions:
+
+```ruby
+config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => [%r{^/assets/}]
+```
+
+Or you can silence specific request methods only:
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :get => [%r{^/assets/}], :post => [%r{^/some_path}]
+```ruby
+config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :get => [%r{^/assets/}], :post => [%r{^/some_path}]
+```
 
 Silencer's logger will serve as a drop-in replacement for Rails' default logger.  It will not suppress any logging by default, simply pass it an array of urls via the options hash.  You can also send it a 'X-SILENCE-LOGGER' header (with any value) with your request and that will also produce the same behavior.
 
@@ -53,7 +76,9 @@ Silencer supports the following configuration options.
 
 Rails 2.3.x introduced a tagged logging feature.  If you are using tagged logging with Rails 2.3 you can also pass taggers via the middleware:
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, config.log_tags, :silence => [%r{^/assets/}]
+```ruby
+config.middleware.swap Rails::Rack::Logger, Silencer::Logger, config.log_tags, :silence => [%r{^/assets/}]
+```
 
 ## Note on Patches/Pull Requests
 

data/Rakefile

@@ -1,21 +1,16 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
-task :test => :spec
+task test: :spec
 
-namespace :doc do
-  require 'yard'
-  YARD::Rake::YardocTask.new do |task|
-    task.files   = ['lib/**/*.rb']
-    task.options = [
-      '--protected',
-      '--output-dir', 'doc/yard',
-      '--markup', 'markdown',
-      '--readme', 'README.md'
-    ]
-  end
-end
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+task default: [:spec, :rubocop]

data/lib/silencer/environment.rb

@@ -1,9 +1,8 @@
 module Silencer
   module Environment
-
-    RAILS_2_3 = %r{^2.3}
-    RAILS_3_2 = %r{^3.2}
-    RAILS_4 = %r{^4}
+    RAILS_2_3 = /^2.3/
+    RAILS_3_2 = /^3.2/
+    RAILS_4 = /^4/
 
     def rails?
       defined?(::Rails)
@@ -32,6 +31,5 @@ module Silencer
 
     module_function :rails?, :rails2?, :rails_version, :rails3_2?
     module_function :rails4?, :tagged_logger?
-
   end
 end

data/lib/silencer/hush.rb

@@ -1,6 +1,5 @@
 module Silencer
   module Hush
-
     private
 
     def silence_request?(env)
@@ -12,8 +11,16 @@ module Silencer
     end
 
     def silent_path?(env)
-      (@routes[env['REQUEST_METHOD']] || @silence).any? { |s| s === env['PATH_INFO'] }
+      (@routes[env['REQUEST_METHOD']] || @silence).any? do |rule|
+        case rule
+        when String, Integer
+          rule.to_s == env['PATH_INFO']
+        when Regexp
+          rule =~ env['PATH_INFO']
+        else
+          false
+        end
+      end
     end
-
   end
 end

data/lib/silencer/logger.rb

@@ -1,11 +1,14 @@
-require 'silencer/environment'
 require 'silencer/rack/logger'
-require 'silencer/rails/logger' if Silencer::Environment.rails?
+require 'silencer/environment'
 
 module Silencer
-  Logger = if Silencer::Environment.rails?
-    Silencer::Rails::Logger
-  else
-    Silencer::Rack::Logger
+  # rubocop:disable Style/ConstantName
+  Logger = begin
+    if Silencer::Environment.rails?
+      require 'silencer/rails/logger'
+      Silencer::Rails::Logger
+    else
+      Silencer::Rack::Logger
+    end
   end
 end

data/lib/silencer/methods.rb

@@ -0,0 +1,12 @@
+module Silencer
+  module Methods
+    METHODS = [:options, :get, :head, :post, :put, :delete, :trace, :connect, :patch]
+
+    def define_routes(silence_paths, opts)
+      METHODS.each_with_object({}) do |method, routes|
+        routes[method.to_s.upcase] = wrap(opts.delete(method)) + silence_paths
+        routes
+      end
+    end
+  end
+end

data/lib/silencer/rack/logger.rb

@@ -1,29 +1,21 @@
 require 'rack/logger'
-require 'silencer/util'
 require 'silencer/hush'
+require 'silencer/methods'
+require 'silencer/util'
 
 module Silencer
   module Rack
     class Logger < ::Rack::Logger
-      include Silencer::Util
       include Silencer::Hush
+      include Silencer::Methods
+      include Silencer::Util
 
       def initialize(app, *args)
         opts     = extract_options!(args)
         @silence = wrap(opts.delete(:silence))
-        @routes  = {
-          'OPTIONS' => wrap(opts.delete(:options)) + @silence,
-          'GET'     => wrap(opts.delete(:get)) + @silence,
-          'HEAD'    => wrap(opts.delete(:head)) + @silence,
-          'POST'    => wrap(opts.delete(:post)) + @silence,
-          'PUT'     => wrap(opts.delete(:put)) + @silence,
-          'DELETE'  => wrap(opts.delete(:delete)) + @silence,
-          'TRACE'   => wrap(opts.delete(:trace)) + @silence,
-          'CONNECT' => wrap(opts.delete(:connect)) + @silence,
-          'PATCH'   => wrap(opts.delete(:patch)) + @silence,
-        }
+        @routes  = define_routes(@silence, opts)
 
-        super app, *args
+        super(app, *args)
       end
 
       def call(env)

data/lib/silencer/rails/logger.rb

@@ -1,33 +1,31 @@
+require 'silencer/hush'
+require 'silencer/methods'
+require 'silencer/util'
+
 module Silencer
-  RailsLogger = if Silencer::Environment.rails2?
-    require 'rails/rack/log_tailer'
-    ::Rails::Rack::LogTailer
-  else
-    require 'rails/rack/logger'
-    ::Rails::Rack::Logger
+  # rubocop:disable Style/ConstantName
+  RailsLogger = begin
+    if Silencer::Environment.rails2?
+      require 'rails/rack/log_tailer'
+      ::Rails::Rack::LogTailer
+    else
+      require 'rails/rack/logger'
+      ::Rails::Rack::Logger
+    end
   end
 
   module Rails
     class Logger < RailsLogger
-      include Silencer::Util
       include Silencer::Hush
+      include Silencer::Methods
+      include Silencer::Util
 
       def initialize(app, *args)
         opts     = extract_options!(args)
         @silence = wrap(opts.delete(:silence))
-        @routes  = {
-          'OPTIONS' => wrap(opts.delete(:options)) + @silence,
-          'GET'     => wrap(opts.delete(:get)) + @silence,
-          'HEAD'    => wrap(opts.delete(:head)) + @silence,
-          'POST'    => wrap(opts.delete(:post)) + @silence,
-          'PUT'     => wrap(opts.delete(:put)) + @silence,
-          'DELETE'  => wrap(opts.delete(:delete)) + @silence,
-          'TRACE'   => wrap(opts.delete(:trace)) + @silence,
-          'CONNECT' => wrap(opts.delete(:connect)) + @silence,
-          'PATCH'   => wrap(opts.delete(:patch)) + @silence,
-        }
-
-        if normalized_args = normalize(args)
+        @routes  = define_routes(@silence, opts)
+
+        if normalized_args = normalize(args) # rubocop:disable Lint/AssignmentInCondition
           super(app, normalized_args)
         else
           super(app)
@@ -35,19 +33,45 @@ module Silencer
       end
 
       def call(env)
+        if silence_request?(env)
+          quiet do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      def quiet(&block)
+        if ::Rails.logger.respond_to?(:silence)
+          quiet_with_silence(&block)
+        else
+          quiet_with_log_level(&block)
+        end
+      end
+
+      # This is threadsafe in Rails 4.2.6+
+      def quiet_with_silence
+        ::Rails.logger.silence do
+          yield
+        end
+      end
+
+      # This is not threadsafe
+      def quiet_with_log_level
         old_logger_level     = ::Rails.logger.level
-        ::Rails.logger.level = ::Logger::ERROR if silence_request?(env)
+        ::Rails.logger.level = ::Logger::ERROR
 
-        super
+        yield
       ensure
         # Return back to previous logging level
         ::Rails.logger.level = old_logger_level
       end
 
-      private
-
       def normalize(args)
-        args = case args.size
+        case args.size
         when 0 then nil
         when 1 then args.shift
         else args

data/lib/silencer/util.rb

@@ -1,6 +1,5 @@
 module Silencer
   module Util
-
     def wrap(object)
       if object.nil?
         []
@@ -20,6 +19,5 @@ module Silencer
     end
 
     module_function :wrap, :extract_options!
-
   end
 end

data/lib/silencer/version.rb

@@ -1,3 +1,3 @@
 module Silencer
-  VERSION = "1.0.0.rc3"
+  VERSION = '1.0.0'
 end

data/silencer.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
 
   gem.files = %w(.yardopts LICENSE.md README.md Rakefile silencer.gemspec)
   gem.files += Dir.glob("lib/**/*.rb")
-  gem.files += Dir.glob("spec/**/*")
+
   gem.test_files = Dir.glob("spec/**/*")
 
   gem.require_paths = ["lib"]

data/spec/silencer/rack/logger_spec.rb

@@ -1,62 +1,62 @@
 require 'spec_helper'
 
 describe Silencer::Rack::Logger do
-  let(:app) { lambda { |env| [200, {}, ''] } }
+  let(:app) { ->(_env) { [200, {}, ''] } }
 
   it 'quiets the log when configured with a silenced path' do
     expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-    Silencer::Rack::Logger.new(app, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
+    Silencer::Rack::Logger.new(app, silence: ['/'])
+                          .call(Rack::MockRequest.env_for('/'))
   end
 
   it 'quiets the log when configured with a regex' do
     expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-    Silencer::Rack::Logger.new(app, :silence => [/assets/]).
-      call(Rack::MockRequest.env_for("/assets/application.css"))
+    Silencer::Rack::Logger.new(app, silence: [/assets/])
+                          .call(Rack::MockRequest.env_for('/assets/application.css'))
   end
 
   %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT PATCH).each do |method|
     it "quiets the log when configured with a silenced path for #{method} requests" do
       expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-      Silencer::Rack::Logger.new(app, method.downcase.to_sym => ['/']).
-        call(Rack::MockRequest.env_for("/", :method => method))
+      Silencer::Rack::Logger.new(app, method.downcase.to_sym => ['/'])
+                            .call(Rack::MockRequest.env_for('/', method: method))
     end
 
     it "quiets the log when configured with a regex for #{method} requests" do
       expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-      Silencer::Rack::Logger.new(app, method.downcase.to_sym => [/assets/]).
-        call(Rack::MockRequest.env_for("/assets/application.css", :method => method))
+      Silencer::Rack::Logger.new(app, method.downcase.to_sym => [/assets/])
+                            .call(Rack::MockRequest.env_for('/assets/application.css', method: method))
     end
   end
 
   it 'quiets the log when configured with a silenced path for non-standard requests' do
     expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-    Silencer::Rack::Logger.new(app, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/", :method => 'UPDATE'))
+    Silencer::Rack::Logger.new(app, silence: ['/'])
+                          .call(Rack::MockRequest.env_for('/', method: 'UPDATE'))
   end
 
   it 'quiets the log when configured with a regex for non-standard requests' do
     expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-    Silencer::Rack::Logger.new(app, :silence => [/assets/]).
-      call(Rack::MockRequest.env_for("/assets/application.css", :method => 'UPDATE'))
+    Silencer::Rack::Logger.new(app, silence: [/assets/])
+                          .call(Rack::MockRequest.env_for('/assets/application.css', method: 'UPDATE'))
   end
 
   it 'quiets the log when passed a custom header "X-SILENCE-LOGGER"' do
     expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
 
-    Silencer::Rack::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    Silencer::Rack::Logger.new(app)
+                          .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
   end
 
   it 'does not tamper with the response' do
-    response = Silencer::Rack::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    response = Silencer::Rack::Logger.new(app)
+                                     .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
 
     expect(response[0]).to eq(200)
   end

data/spec/silencer/rails/logger_spec.rb

@@ -1,88 +1,81 @@
 require 'spec_helper'
 
 describe Silencer::Rails::Logger do
-  let(:app)       { lambda { |env| [200, {}, ''] } }
+  let(:app)       { ->(_env) { [200, {}, ''] } }
   let(:log_tags)  { [:uuid, :queue] }
 
-  it 'quiets the log when configured with a silenced path' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+  context 'quieted' do
+    before do
+      expect_any_instance_of(Silencer::Rails::Logger).to receive(:quiet).at_least(:once).and_call_original
+    end
 
-    Silencer::Rails::Logger.new(app, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
-  end
+    it 'quiets the log when configured with a silenced path' do
+      Silencer::Rails::Logger.new(app, silence: ['/'])
+                             .call(Rack::MockRequest.env_for('/'))
+    end
 
-  it 'quiets the log when configured with a regex' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+    it 'quiets the log when configured with a regex' do
+      Silencer::Rails::Logger.new(app, silence: [/assets/])
+                             .call(Rack::MockRequest.env_for('/assets/application.css'))
+    end
 
-    Silencer::Rails::Logger.new(app, :silence => [/assets/]).
-      call(Rack::MockRequest.env_for("/assets/application.css"))
-  end
+    %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT PATCH).each do |method|
+      it "quiets the log when configured with a silenced path for #{method} requests" do
+        Silencer::Rails::Logger.new(app, method.downcase.to_sym => ['/'])
+                               .call(Rack::MockRequest.env_for('/', method: method))
+      end
 
-  %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT PATCH).each do |method|
-    it "quiets the log when configured with a silenced path for #{method} requests" do
-      expect(::Rails.logger).to receive(:level=).
-        with(::Logger::ERROR).at_least(:once)
+      it "quiets the log when configured with a regex for #{method} requests" do
+        Silencer::Rails::Logger.new(app, method.downcase.to_sym => [/assets/])
+                               .call(Rack::MockRequest.env_for('/assets/application.css', method: method))
+      end
+    end
 
-      Silencer::Rails::Logger.new(app, method.downcase.to_sym => ['/']).
-        call(Rack::MockRequest.env_for("/", :method => method))
+    it 'quiets the log when configured with a silenced path for non-standard requests' do
+      Silencer::Rails::Logger.new(app, silence: ['/'])
+                             .call(Rack::MockRequest.env_for('/', method: 'UPDATE'))
     end
 
-    it "quiets the log when configured with a regex for #{method} requests" do
-      expect(::Rails.logger).to receive(:level=).
-        with(::Logger::ERROR).at_least(:once)
+    it 'quiets the log when configured with a regex for non-standard requests' do
+      Silencer::Rails::Logger.new(app, silence: [/assets/])
+                             .call(Rack::MockRequest.env_for('/assets/application.css', method: 'UPDATE'))
+    end
 
-      Silencer::Rails::Logger.new(app, method.downcase.to_sym => [/assets/]).
-        call(Rack::MockRequest.env_for("/assets/application.css", :method => method))
+    it 'quiets the log when passed a custom header "X-SILENCE-LOGGER"' do
+      Silencer::Rails::Logger.new(app)
+                             .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
     end
-  end
 
-  it 'quiets the log when configured with a silenced path for non-standard requests' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+    it 'does not tamper with the response' do
+      response = Silencer::Rails::Logger.new(app)
+                                        .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
 
-    Silencer::Rails::Logger.new(app, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/", :method => 'UPDATE'))
-  end
+      expect(response[0]).to eq(200)
+    end
 
-  it 'quiets the log when configured with a regex for non-standard requests' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+    if Silencer::Environment.tagged_logger?
+      it 'instantiates with an optional taggers array' do
+        Silencer::Rails::Logger.new(app, log_tags, silence: ['/'])
+                               .call(Rack::MockRequest.env_for('/'))
+      end
 
-    Silencer::Rails::Logger.new(app, :silence => [/assets/]).
-      call(Rack::MockRequest.env_for("/assets/application.css", :method => 'UPDATE'))
+      it 'instantiates with an optional taggers array passed as args' do
+        Silencer::Rails::Logger.new(app, :uuid, :queue, silence: ['/'])
+                               .call(Rack::MockRequest.env_for('/'))
+      end
+    end
   end
 
-  it 'quiets the log when passed a custom header "X-SILENCE-LOGGER"' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
-
-    Silencer::Rails::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
-  end
+  it 'silences' do
+    logger = Silencer::Rails::Logger.new(app, silence: ['/'])
 
-  it 'does not tamper with the response' do
-    response = Silencer::Rails::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    if ::Rails.logger.respond_to?(:silence)
+      expect(::Rails.logger).to receive(:silence).at_least(:once)
+    else
+      expect(::Rails.logger).to receive(:level=)
+        .with(::Logger::ERROR).at_least(:once)
+    end
 
-    expect(response[0]).to eq(200)
+    logger.call(Rack::MockRequest.env_for('/'))
   end
-
-  it 'instantiates with an optional taggers array' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
-
-    Silencer::Rails::Logger.new(app, log_tags, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
-  end if Silencer::Environment.tagged_logger?
-
-  it 'instantiates with an optional taggers array passed as args' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
-
-    Silencer::Rails::Logger.new(app, :uuid, :queue, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
-  end if Silencer::Environment.tagged_logger?
-
 end

data/spec/spec_helper.rb

@@ -1,7 +1,6 @@
 unless ENV['CI']
   require 'simplecov'
   SimpleCov.start do
-    add_filter '.bundle'
     add_group 'Silencer', 'lib/silencer'
     add_group 'Specs', 'spec'
   end
@@ -17,7 +16,11 @@ io = StringIO.new
 
 begin
   require 'rails'
-  ::Rails.logger = ::Logger.new(io)
+  ::Rails.logger = if Rails::VERSION::MAJOR >= 4
+                     ::ActiveSupport::Logger.new(io)
+                   else
+                     ::Logger.new(io)
+                   end
 rescue LoadError
   require 'activesupport'
   RAILS_ENV            = 'test'
@@ -36,5 +39,4 @@ RSpec.configure do |config|
   config.before(:each) do
     allow(::Rails.logger).to receive(:level=).with(anything)
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: silencer
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc3
+  version: 1.0.0
 platform: ruby
 authors:
 - Steve Agalloco
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-10 00:00:00.000000000 Z
+date: 2017-02-15 00:00:00.000000000 Z
 dependencies: []
 description: Selectively quiet your Rails/Rack logger on a per-route basis
 email:
@@ -25,6 +25,7 @@ files:
 - lib/silencer/environment.rb
 - lib/silencer/hush.rb
 - lib/silencer/logger.rb
+- lib/silencer/methods.rb
 - lib/silencer/rack/logger.rb
 - lib/silencer/rails/logger.rb
 - lib/silencer/util.rb
@@ -48,12 +49,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Selectively quiet your Rails/Rack logger on a per-route basis
@@ -62,4 +63,3 @@ test_files:
 - spec/silencer/rack/logger_spec.rb
 - spec/silencer/rails/logger_spec.rb
 - spec/spec_helper.rb
-has_rdoc: