silencer 1.0.0.rc3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6c3957c09e55e6fcaa4028e2cfadbe5f356c9948
-  data.tar.gz: 42c65e23eb1d156e0566b3a19251fd88f4cec662
+SHA256:
+  metadata.gz: 63363db7eb9e93e891e6910a11e53919acfaab80e63a280544e9b7c1b3eed686
+  data.tar.gz: 347c68c4cf21b860ab12497a684b5b037f980ef1649ae9bdc03fda713870703e
 SHA512:
-  metadata.gz: 007f356080f9a3a0fa4698a968fd21434db70dfc809c4643ba64e78bf43eb45cec69684579efb15ed6da875690683d8069b0a66799e397ea4c9d513317d0b6c9
-  data.tar.gz: 496d3ee52a8d11aa9d2ce9d3eff1805716327b474025f23302aa3a92f9f692c59b5dae76e967c120b06e4c5154496e61c2bd903d2f2984e18ce7829aea4d8e2d
+  metadata.gz: b631a27a0bb92c343ff55f5976416b44d23cbe9f520d412890c98ba1c7d2489a283404d8b0d70a2ac2ee0278d5578f52affcc37d7b891809e8907aaac96a85de
+  data.tar.gz: 4435eb5f9254a7fd2266947dcef3b4776b41e8e1579edab6adb2a550d6bd2c6f5b5903e596dfa741a9bbdda21b76c68dbe30ec40bf8e13c7bae557b8ab90d731

data/README.md

@@ -1,64 +1,104 @@
-# 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]
+![Tests](https://github.com/stve/silencer/actions/workflows/ci.yml/badge.svg)
+
+[gem]: https://rubygems.org/gems/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
 
 Just add silencer to your Gemfile:
 
-    gem 'silencer'
+```ruby
+gem 'silencer', require: false
+```
 
-## Usage
+### Upgrading to version 2.0
 
-In your production environment (presumably):
+__Note:__ 1.x versions of silencer detected the presence of Rails when it was required. This made it easy to use silencer for most applications, but made assumptions on usage.
 
+In version 2.0, you'll need to require the correct logger within your application. See the Usage documentation for more details.
 
-    require 'silencer/logger'
+## Usage
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => ["/noisy/action.json"]
+### Rails
 
-Or if you'd prefer, you can pass it regular expressions:
+Create an initializer (like `config/initializers/silencer.rb`) with the contents:
 
+```ruby
+require 'silencer/rails/logger'
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :silence => [%r{^/assets/}]
+Rails.application.configure do
+  config.middleware.swap(
+    Rails::Rack::Logger, 
+    Silencer::Logger, 
+    config.log_tags,
+    silence: ["/noisy/action.json"]
+  )
+end
+```
 
-Or you can silence specific request methods only:
+### Rack
 
+```ruby
+require 'silencer/rack/logger'
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, :get => [%r{^/assets/}], :post => [%r{^/some_path}]
+use Silencer::Logger, silence: ["/noisy/action.json"]
+```
 
-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.
+## Configuration
 
-### All options
+Or if you'd prefer, you can pass it regular expressions:
 
-Silencer supports the following configuration options.
+```ruby
+config.middleware.swap(
+  Rails::Rack::Logger, 
+  Silencer::Logger, 
+  config.log_tags, 
+  silence: [%r{^/assets/}]
+)
+```
+
+Or you can silence specific request methods only:
 
-    :silence - Silences matching requests regardless of request method
-    :get     - Silences matching GET requests
-    :head    - Silences matching HEAD requests
-    :post    - Silences matching POST requests
-    :put     - Silences matching PUT requests
-    :delete  - Silences matching DELETE requests
-    :patch   - Silences matching PATCH requests
-    :trace   - Silences matching TRACE requests
-    :connect - Silences matching CONNECT requests
-    :options - Silences matching OPTIONS requests
+```ruby
+config.middleware.swap(
+  Rails::Rack::Logger, 
+  Silencer::Logger, 
+  config.log_tags, 
+  get: [%r{^/assets/}], 
+  post: [%r{^/some_path}]
+)
+```
 
-### Rails 2.3
+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 an `X-SILENCE-LOGGER` header (with any value) with your request and that will also produce the same behavior.
 
-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:
+### All options
+
+Silencer supports the following configuration options.
 
-    config.middleware.swap Rails::Rack::Logger, Silencer::Logger, config.log_tags, :silence => [%r{^/assets/}]
+| Configuration | Description | Default |
+|---------------|-------------|---------|
+| `silence` | Silences matching requests regardless of request method | None |
+| `get` | Silences matching GET requests | None |
+| `head` | Silences matching HEAD requests | None |
+| `post` | Silences matching POST requests | None |
+| `put` | Silences matching PUT requests | None |
+| `delete` | Silences matching DELETE requests | None |
+| `patch` | Silences matching PATCH requests | None |
+| `trace` | Silences matching TRACE requests | None |
+| `connect` | Silences matching CONNECT requests | None |
+| `options` | Silences matching OPTIONS requests | None |
+| `enable_header` | Enable/disable X-SILENCE-LOGGER header support | `true` |
 
 ## Note on Patches/Pull Requests
 
 * Fork the project.
-* Make your feature addition or bug fix.
+* Make your feature addition or bugfix.
 * Add tests for it. This is important so I don't break it in a
   future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
@@ -67,4 +107,4 @@ Rails 2.3.x introduced a tagged logging feature.  If you are using tagged loggin
 
 ## Copyright
 
-Copyright (c) 2012 Steve Agalloco. See [LICENSE](https://github.com/spagalloco/silencer/blob/master/LICENSE.md) for details.
+Copyright (c) 2012 Steve Agalloco. See [LICENSE](https://github.com/spagalloco/silencer/blob/main/LICENSE.md) for details.

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/hush.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Silencer
   module Hush
-
     private
 
-    def silence_request?(env)
-      (silent_header?(env) || silent_path?(env))
+    def silence_request?(env, enable_header: true)
+      ((enable_header && silent_header?(env)) || silent_path?(env))
     end
 
     def silent_header?(env)
@@ -12,8 +13,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/methods.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Silencer
+  module Methods
+    METHODS = %i[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,38 +1,51 @@
+# frozen_string_literal: true
+
 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,
-        }
-
-        super app, *args
+        @routes  = define_routes(@silence, opts)
+
+        @enable_header = opts.delete(:enable_header) { true }
+
+        super(app, *args)
       end
 
       def call(env)
-        logger       = ::Logger.new(env['rack.errors'])
-        logger.level = (silence_request?(env) ? ::Logger::ERROR : @level)
+        if silence_request?(env, enable_header: @enable_header)
+          quiet(env) do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      def quiet(env)
+        old_logger = env['rack.logger']
+        logger = ::Logger.new(env['rack.errors'])
+        logger.level = ::Logger::ERROR
 
         env['rack.logger'] = logger
-        @app.call(env)
+        yield
+      ensure
+        env['rack.logger'] = old_logger
       end
     end
   end
+
+  Logger = Silencer::Rack::Logger
 end

data/lib/silencer/rails/environment.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Silencer
+  module Environment
+    RAILS_4 = /^4/
+    RAILS_5 = /^5/
+
+    module_function
+
+    def rails?
+      defined?(::Rails)
+    end
+
+    def rails_version
+      return unless rails?
+
+      ::Rails::VERSION::STRING
+    end
+
+    def rails4?
+      rails_version =~ RAILS_4
+    end
+
+    def rails5?
+      rails_version =~ RAILS_5
+    end
+
+    def tagged_logger?
+      rails4? || rails5?
+    end
+  end
+end

data/lib/silencer/rails/logger.rb

@@ -1,33 +1,27 @@
-module Silencer
-  RailsLogger = if Silencer::Environment.rails2?
-    require 'rails/rack/log_tailer'
-    ::Rails::Rack::LogTailer
-  else
-    require 'rails/rack/logger'
-    ::Rails::Rack::Logger
-  end
+# frozen_string_literal: true
+
+require 'rails/rack/logger'
+require 'silencer/hush'
+require 'silencer/methods'
+require 'silencer/util'
+require 'silencer/rails/environment'
 
+module Silencer
   module Rails
-    class Logger < RailsLogger
-      include Silencer::Util
+    class Logger < ::Rails::Rack::Logger
       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)
+
+        @enable_header = opts.delete(:enable_header) { true }
+
+        normalized_args = normalize(args)
+        if normalized_args
           super(app, normalized_args)
         else
           super(app)
@@ -35,19 +29,43 @@ module Silencer
       end
 
       def call(env)
+        if silence_request?(env, enable_header: @enable_header)
+          quiet do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      def quiet(&block)
+        if ::Rails.logger.respond_to?(:silence) && ::Rails.logger.method(:silence).owner != ::Kernel
+          quiet_with_silence(&block)
+        else
+          quiet_with_log_level(&block)
+        end
+      end
+
+      # This is threadsafe in Rails 4.2.6+
+      def quiet_with_silence(&block)
+        ::Rails.logger.silence(&block)
+      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
@@ -55,4 +73,6 @@ module Silencer
       end
     end
   end
+
+  Logger = Silencer::Rails::Logger
 end

data/lib/silencer/util.rb

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

data/lib/silencer/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Silencer
-  VERSION = "1.0.0.rc3"
+  VERSION = '2.0.0'
 end

data/lib/silencer.rb

@@ -1 +1 @@
-require 'silencer/logger'
+# frozen_string_literal: true

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,63 +1,63 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
+require 'silencer/rack/logger'
 
 describe Silencer::Rack::Logger do
-  let(:app) { lambda { |env| [200, {}, ''] } }
+  let(:app) do
+    lambda { |env|
+      log = env['rack.logger']
+      log.info('ohai')
 
-  it 'quiets the log when configured with a silenced path' do
-    expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
+      [200, {'Content-Type' => 'text/plain'}, ['Hello, World!']]
+    }
+  end
 
-    Silencer::Rack::Logger.new(app, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
+  let(:errors) do
+    StringIO.new
   end
 
-  it 'quiets the log when configured with a regex' do
-    expect_any_instance_of(::Logger).to receive(:level=).with(::Logger::ERROR)
+  it 'quiets the log when configured with a silenced path' do
+    a = Rack::Lint.new(Silencer::Rack::Logger.new(app, silence: ['/']))
+    Rack::MockRequest.new(a).get('/', 'rack.errors' => errors)
+    expect(errors).not_to match('ohai')
+  end
 
-    Silencer::Rack::Logger.new(app, :silence => [/assets/]).
-      call(Rack::MockRequest.env_for("/assets/application.css"))
+  it 'quiets the log when configured with a regex' do
+    a = Rack::Lint.new(Silencer::Rack::Logger.new(app, silence: [/assets/]))
+    Rack::MockRequest.new(a).get('/assets/application.css', 'rack.errors' => errors)
+    expect(errors).not_to match('ohai')
   end
 
-  %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT PATCH).each do |method|
+  %w[OPTIONS GET POST PUT DELETE 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))
+      a = Rack::Lint.new(Silencer::Rack::Logger.new(app, method.downcase.to_sym => ['/']))
+      Rack::MockRequest.new(a).send(method.downcase.to_sym, '/', 'rack.errors' => errors)
+      expect(errors).not_to match('ohai')
     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))
+      a = Rack::Lint.new(Silencer::Rack::Logger.new(app, method.downcase.to_sym => [/assets/]))
+      Rack::MockRequest.new(a).send(method.downcase.to_sym, '/assets/application.css', 'rack.errors' => errors)
+      expect(errors).not_to match('ohai')
     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'))
-  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'))
+    a = Rack::Lint.new(Silencer::Rack::Logger.new(app, silence: [/assets/]))
+    Rack::MockRequest.new(a).get('/', 'rack.errors' => errors)
+    expect(errors).not_to match('ohai')
   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'))
+    a = Rack::Lint.new(Silencer::Rack::Logger.new(app))
+    Rack::MockRequest.new(a).get('/', 'rack.errors' => errors, 'HTTP_X_SILENCE_LOGGER' => 'true')
+    expect(errors).not_to match('ohai')
   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'))
-
-    expect(response[0]).to eq(200)
+    a = Rack::Lint.new(Silencer::Rack::Logger.new(app))
+    response = Rack::MockRequest.new(a).get('/', 'rack.errors' => errors, 'HTTP_X_SILENCE_LOGGER' => 'true')
+    expect(response.status).to eq(200)
   end
 end

data/spec/silencer/rails/logger_spec.rb

@@ -1,88 +1,111 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
+require 'syslogger'
+require 'silencer/rails/logger'
 
 describe Silencer::Rails::Logger do
-  let(:app)       { lambda { |env| [200, {}, ''] } }
-  let(:log_tags)  { [:uuid, :queue] }
+  let(:app)       { ->(_env) { [200, {}, ''] } }
+  let(:log_tags)  { %i[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)
+  describe 'enable_header option' do
+    it 'does not quiet the log when passed a custom header "X-SILENCE-LOGGER" when enable_header option is false' do
+      expect_any_instance_of(Silencer::Rails::Logger).to_not receive(:quiet)
 
-    Silencer::Rails::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
-  end
+      Silencer::Rails::Logger.new(app, enable_header: false)
+                             .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    end
 
-  it 'does not tamper with the response' do
-    response = Silencer::Rails::Logger.new(app).
-      call(Rack::MockRequest.env_for("/", 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    it 'quiets the log when passed a custom header "X-SILENCE-LOGGER" when enable_header option is true' do
+      expect_any_instance_of(Silencer::Rails::Logger).to receive(:quiet).once.and_call_original
 
-    expect(response[0]).to eq(200)
+      Silencer::Rails::Logger.new(app, enable_header: true)
+                             .call(Rack::MockRequest.env_for('/', 'HTTP_X_SILENCE_LOGGER' => 'true'))
+    end
   end
 
-  it 'instantiates with an optional taggers array' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+  it 'silences' do
+    logger = Silencer::Rails::Logger.new(app, silence: ['/'])
 
-    Silencer::Rails::Logger.new(app, log_tags, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
-  end if Silencer::Environment.tagged_logger?
+    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
 
-  it 'instantiates with an optional taggers array passed as args' do
-    expect(::Rails.logger).to receive(:level=).
-      with(::Logger::ERROR).at_least(:once)
+    logger.call(Rack::MockRequest.env_for('/'))
+  end
 
-    Silencer::Rails::Logger.new(app, :uuid, :queue, :silence => ['/']).
-      call(Rack::MockRequest.env_for("/"))
-  end if Silencer::Environment.tagged_logger?
+  context 'when logger is Syslogger' do
+    it 'does not throw error' do
+      mock_rails_logger = Syslogger.new
+      allow(::Rails).to receive(:logger) { mock_rails_logger }
 
+      logger = Silencer::Rails::Logger.new(app, silence: ['/'])
+      expect { logger.call(Rack::MockRequest.env_for('/')) }.not_to raise_error
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 unless ENV['CI']
   require 'simplecov'
   SimpleCov.start do
-    add_filter '.bundle'
     add_group 'Silencer', 'lib/silencer'
     add_group 'Specs', 'spec'
   end
 end
 
 require 'rack'
+require 'rack/lint'
 require 'rspec'
 
 require 'logger'
@@ -17,7 +19,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 +42,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: 2.0.0
 platform: ruby
 authors:
 - Steve Agalloco
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-06-10 00:00:00.000000000 Z
+date: 2022-04-24 00:00:00.000000000 Z
 dependencies: []
 description: Selectively quiet your Rails/Rack logger on a per-route basis
 email:
@@ -22,10 +22,10 @@ files:
 - README.md
 - Rakefile
 - lib/silencer.rb
-- lib/silencer/environment.rb
 - lib/silencer/hush.rb
-- lib/silencer/logger.rb
+- lib/silencer/methods.rb
 - lib/silencer/rack/logger.rb
+- lib/silencer/rails/environment.rb
 - lib/silencer/rails/logger.rb
 - lib/silencer/util.rb
 - lib/silencer/version.rb
@@ -37,7 +37,7 @@ files:
 homepage: http://github.com/spagalloco/silencer
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -48,13 +48,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
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Selectively quiet your Rails/Rack logger on a per-route basis
 test_files:
@@ -62,4 +61,3 @@ test_files:
 - spec/silencer/rack/logger_spec.rb
 - spec/silencer/rails/logger_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/lib/silencer/environment.rb

@@ -1,37 +0,0 @@
-module Silencer
-  module Environment
-
-    RAILS_2_3 = %r{^2.3}
-    RAILS_3_2 = %r{^3.2}
-    RAILS_4 = %r{^4}
-
-    def rails?
-      defined?(::Rails)
-    end
-
-    def rails_version
-      return unless rails?
-      ::Rails::VERSION::STRING
-    end
-
-    def rails2?
-      rails_version =~ RAILS_2_3
-    end
-
-    def rails3_2?
-      rails_version =~ RAILS_3_2
-    end
-
-    def rails4?
-      rails_version =~ RAILS_4
-    end
-
-    def tagged_logger?
-      rails3_2? || rails4?
-    end
-
-    module_function :rails?, :rails2?, :rails_version, :rails3_2?
-    module_function :rails4?, :tagged_logger?
-
-  end
-end

data/lib/silencer/logger.rb

@@ -1,11 +0,0 @@
-require 'silencer/environment'
-require 'silencer/rack/logger'
-require 'silencer/rails/logger' if Silencer::Environment.rails?
-
-module Silencer
-  Logger = if Silencer::Environment.rails?
-    Silencer::Rails::Logger
-  else
-    Silencer::Rack::Logger
-  end
-end