Moved global logger out of Configuration object.

Author: jdantonio

lib/concurrent/configuration.rb

@@ -8,14 +8,20 @@
 module Concurrent
   extend Logging
 
+  # Suppresses all output when used for logging.
+  NULL_LOGGER = lambda { |level, progname, message = nil, &block| }
+
   # initialize the global executors
   class << self
 
     # @!visibility private
-    @@auto_terminate_global_executors = Concurrent::AtomicBoolean.new(true)
+    @@global_logger = Atomic.new(NULL_LOGGER)
+
+    # @!visibility private
+    @@auto_terminate_global_executors = AtomicBoolean.new(true)
 
     # @!visibility private
-    @@auto_terminate_all_executors = Concurrent::AtomicBoolean.new(true)
+    @@auto_terminate_all_executors = AtomicBoolean.new(true)
 
     # @!visibility private
     @@global_fast_executor = LazyReference.new do
@@ -31,11 +37,18 @@ class << self
 
     # @!visibility private
     @@global_timer_set = LazyReference.new do
-      Concurrent::TimerSet.new(
-        stop_on_exit: @@auto_terminate_global_executors.value)
+      TimerSet.new(stop_on_exit: @@auto_terminate_global_executors.value)
     end
   end
 
+  def self.global_logger
+    @@global_logger.value
+  end
+
+  def self.global_logger=(value)
+    @@global_logger.value = value
+  end
+
   # Defines if global executors should be auto-terminated with an
   # `at_exit` callback. When set to `false` it will be the application
   # programmer's responsibility to ensure that the global thread pools
@@ -155,15 +168,15 @@ def self.kill_global_executors
   end
 
   def self.wait_for_global_executors_termination(timeout = nil)
-    latch = Concurrent::CountDownLatch.new(3)
+    latch = CountDownLatch.new(3)
     [ global_fast_executor, global_io_executor, global_timer_set ].each do |executor|
       Thread.new{ executor.wait_for_termination(timeout); latch.count_down }
     end
     latch.wait(timeout)
   end
 
   def self.new_fast_executor(opts = {})
-    Concurrent::FixedThreadPool.new(
+    FixedThreadPool.new(
       [2, Concurrent.processor_count].max,
       stop_on_exit:    opts.fetch(:stop_on_exit, true),
       idletime:        60,          # 1 minute
@@ -173,7 +186,7 @@ def self.new_fast_executor(opts = {})
   end
 
   def self.new_io_executor(opts = {})
-    Concurrent::ThreadPoolExecutor.new(
+    ThreadPoolExecutor.new(
       min_threads: [2, Concurrent.processor_count].max,
       max_threads: Concurrent.processor_count * 100,
       stop_on_exit:    opts.fetch(:stop_on_exit, true),
@@ -186,18 +199,33 @@ def self.new_io_executor(opts = {})
   # A gem-level configuration object.
   class Configuration
 
-    # a proc defining how to log messages, its interface has to be:
-    #   lambda { |level, progname, message = nil, &block| _ }
-    attr_accessor :logger
-
     # Create a new configuration object.
     def initialize
-      @logger                = no_logger
     end
 
     # if assigned to {#logger}, it will log nothing.
+    # @deprecated Use Concurrent::NULL_LOGGER instead
     def no_logger
-      lambda { |level, progname, message = nil, &block| }
+      warn '[DEPRECATED] Use Concurrent::NULL_LOGGER instead'
+      NULL_LOGGER
+    end
+
+    # a proc defining how to log messages, its interface has to be:
+    #   lambda { |level, progname, message = nil, &block| _ }
+    #
+    # @deprecated Use Concurrent.global_logger instead
+    def logger
+      warn '[DEPRECATED] Use Concurrent.global_logger instead'
+      Concurrent.global_logger.value
+    end
+
+    # a proc defining how to log messages, its interface has to be:
+    #   lambda { |level, progname, message = nil, &block| _ }
+    #
+    # @deprecated Use Concurrent.global_logger instead
+    def logger=(value)
+      warn '[DEPRECATED] Use Concurrent.global_logger instead'
+      Concurrent.global_logger = value
     end
 
     # @deprecated Use Concurrent.global_io_executor instead

lib/concurrent/logging.rb

@@ -11,7 +11,7 @@ module Logging
     # @param [String, nil] message when nil block is used to generate the message
     # @yieldreturn [String] a message
     def log(level, progname, message = nil, &block)
-      (@logger || Concurrent.configuration.logger).call level, progname, message, &block
+      (@logger || Concurrent.global_logger).call level, progname, message, &block
     rescue => error
       $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"

spec/spec_helper.rb

@@ -24,7 +24,7 @@
 
 logger                          = Logger.new($stderr)
 logger.level                    = Logger::WARN
-Concurrent.configuration.logger = lambda do |level, progname, message = nil, &block|
+Concurrent.global_logger = lambda do |level, progname, message = nil, &block|
   logger.add level, message, progname, &block
 end