[feat] make logger in Rails include AS::LoggerSilence

src/main/ruby/jruby/rack/rails/railtie.rb

@@ -37,7 +37,11 @@ class Railtie < ::Rails::Railtie
         log_formatter = config.log_formatter if config.respond_to?(:log_formatter)
         logger.formatter = log_formatter if log_formatter && logger.respond_to?(:formatter=)
         require 'active_support/tagged_logging' unless defined?(ActiveSupport::TaggedLogging)
-        ActiveSupport::TaggedLogging.new(logger) # returns a logger.clone
+        logger = ActiveSupport::TaggedLogging.new(logger) # returns a logger.clone
+        logger.singleton_class.instance_eval do
+          include ActiveSupport::LoggerSilence if defined?(ActiveSupport::LoggerSilence)
+        end
+        logger
       end
     end
 

src/spec/ruby/jruby/rack/rails_booter_spec.rb

@@ -168,16 +168,17 @@
 
       before(:all) do
         @active_support = defined? ::ActiveSupport
-        @tagged_logging = active_support && ActiveSupport::TaggedLogging rescue false
+        @active_support = ::ActiveSupport.constants if @active_support
+        require 'active_support/logger'
       end
 
       after(:all) do
-        if @tagged_logging == false
-          if @active_support
-            ActiveSupport.send :remove_const, :TaggedLogging
-          else
-            Object.send :remove_const, :ActiveSupport rescue nil
+        if @active_support
+          [:Logger, :TaggedLogging, :LoggerSilence, :LoggerThreadSafeLevel].each do |name| # stubbed bits we might end up loading
+            ActiveSupport.send :remove_const, name unless @active_support.include?(name)
           end
+        else
+          Object.send :remove_const, :ActiveSupport rescue nil
         end
       end
 
@@ -195,7 +196,7 @@ def logger=(logger); @logger = logger; end
         log_initializer[1].should == [{:before => :initialize_logger}]
       end
 
-      it "gets set as config.logger (wrapped with tagged logging)" do
+      it "gets set as config.logger (wrapped with tagged logging and logger_silence)" do
         logger = JRuby::Rack::Logger.new STDERR
         @config.stub(:log_level).and_return(:info)
         @config.stub(:log_formatter).and_return(nil)
@@ -206,6 +207,13 @@ def logger=(logger); @logger = logger; end
         rails_logger = @app.config.logger
         # ActiveSupport::TaggedLogging.new clones the original logger instance
         expect(rails_logger).to be_a(JRuby::Rack::Logger)
+        expect(rails_logger).to be_a(ActiveSupport::TaggedLogging)
+        if defined? ActiveSupport::LoggerSilence
+          expect(rails_logger).to be_a(ActiveSupport::LoggerSilence)
+          # sanity check silence works:
+          value_returned = rails_logger.silence(Logger::WARN) { |logger| logger.class.name }
+          expect(value_returned).to eql('JRuby::Rack::Logger')
+        end
       end
 
       it "has a configurable log level" do

src/spec/ruby/rails/stub/active_support/logger.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-# require "active_support/logger_silence"
-# require "active_support/logger_thread_safe_level"
+require "active_support/logger_silence"
+require "active_support/logger_thread_safe_level"
 require "logger"
 
 module ActiveSupport
   class Logger < ::Logger
-    # include LoggerSilence
+    include LoggerSilence
 
     # Returns true if the logger destination matches one of the sources
     #

src/spec/ruby/rails/stub/active_support/logger_silence.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# require "active_support/concern"
+# require "active_support/core_ext/module/attribute_accessors"
+require "active_support/logger_thread_safe_level"
+
+module ActiveSupport
+  module LoggerSilence
+    # extend ActiveSupport::Concern
+
+    def self.included(base)
+      base.class_eval do
+        # cattr_accessor :silencer, default: true
+        @@silencer = true
+        def self.silencer; @@silencer end
+        def silencer; self.class.silencer end
+
+        include ActiveSupport::LoggerThreadSafeLevel
+      end
+    end
+
+    # Silences the logger for the duration of the block.
+    def silence(severity = Logger::ERROR)
+      silencer ? log_at(severity) { yield self } : yield(self)
+    end
+  end
+end

src/spec/ruby/rails/stub/active_support/logger_thread_safe_level.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# require "active_support/concern"
+require "logger"
+
+module ActiveSupport
+  module LoggerThreadSafeLevel # :nodoc:
+    # extend ActiveSupport::Concern
+
+    def local_level
+      # IsolatedExecutionState[local_level_key]
+    end
+
+    def local_level=(level)
+      case level
+      when Integer
+      when Symbol
+        level = Logger::Severity.const_get(level.to_s.upcase)
+      when nil
+      else
+        raise ArgumentError, "Invalid log level: #{level.inspect}"
+      end
+      # if level.nil?
+      #   IsolatedExecutionState.delete(local_level_key)
+      # else
+      #   IsolatedExecutionState[local_level_key] = level
+      # end
+      level
+    end
+
+    def level
+      local_level || super
+    end
+
+    # Change the thread-local level for the duration of the given block.
+    def log_at(level)
+      old_local_level, self.local_level = local_level, level
+      yield
+    ensure
+      self.local_level = old_local_level
+    end
+
+    private
+    def local_level_key
+      @local_level_key ||= :"logger_thread_safe_level_#{object_id}"
+    end
+  end
+end