0_logging_unnecesary_synchronize.rb

require 'logging'

module Logging
#  require 'logging/repository'
#  class Repository
#    # include Singleton
#
#    def initialize; require 'thread_safe'
#      # @h = {:root => ::Logging::RootLogger.new}
#      @h = ThreadSafe::Cache.new
#      @h[:root] = ::Logging::RootLogger.new
#
#      # configures the internal logger which is disabled by default
#      logger = ::Logging::Logger.allocate
#      logger._setup(
#          to_key(::Logging),
#          :parent   => @h[:root],
#          :additive => false,
#          :level    => ::Logging::LEVELS.length # turns this logger off
#      )
#      @h[logger.name] = logger
#    end
#
#  end
  require 'logging/logger'
  class Logger

    # @mutex = Mutex.new

    REPOSITORY = Repository.instance

    class << self

      def root; REPOSITORY[:root] end

      remove_method :new rescue nil

      alias instantiate new # the "real" new

      def new( *args )
        args.empty? ? super : self[ args.shift ]
      end
      # alias :[] :new

      # used heavily - make it fast (no garbage/unnecessary code)
      def [](name)
        repo = REPOSITORY # repo = ::Logging::Repository.instance
        logger = repo[ name = repo.to_key(name) ]
        return logger unless logger.nil?

        @mutex.synchronize do
          logger = repo[ name ]
          return logger unless logger.nil? # double checking

          logger = instantiate(name)
          repo[ name ] = logger
          repo.children(name).each { |c| c.__send__(:parent=, logger) }
          logger
        end
      end

      # @note added API that did no exist before __FILE__
      # @see ::Logging::Logger#dispose! (bellow)
      def dispose!(logger)
        # TODO: as this might CME ... until plain Hash is used
        @mutex.synchronize do
          REPOSITORY.delete(logger.is_a?(Logger) ? logger.name : logger)
        end
      end

      # NOTE: delete is a patch from Adhearsion::Logging :
      #class ::Logging::Repository
      #  def delete( key ) @h.delete(to_key(key)) end
      #end

    end

  end
end

1_ahn_logging_improvements.rb

require 'adhearsion/logging'

module Adhearsion
  module Logging
    class << self

      def start(appenders = nil, level = :info, formatter = nil)
        ::Logging.logger.root.appenders = appenders.nil? ? default_appenders : appenders
        ::Logging.logger.root.level = level

        if formatter
          self.formatter = formatter
        else
          tuned_layout = {
            # (#%t %T) to include thread's object_id and Thread.current[:name]
            :pattern => '[%d] %-5l (#%t %T) %c: %m\n',
            :date_pattern => '%Y-%m-%d %H:%M:%S.%L', # added .millis
          }
          ::Logging.logger.root.appenders.each do |appender|
            if appender.is_a?(::Logging::Appenders::Stdout)
              appender.layout = ::Logging.layouts.pattern tuned_layout.merge(:color_scheme => 'bright')
            else
              appender.layout = ::Logging.layouts.pattern tuned_layout
            end
          end
        end
      end

    end
  end
end

# added (#%t %T) to include thread's object_id and Thread.current[:name] :
# Adhearsion::Logging.layout.pattern = '[%d] %-5l (#%t %T) %c: %m\n'
# Adhearsion::Logging.layout.date_pattern = '%Y-%m-%d %H:%M:%S.%L' # added .millis

require 'logging/layouts'

module Logging::Layouts
   class Pattern < ::Logging::Layout
#     DIRECTIVE_TABLE = {
#      'c' => 'event.logger'.freeze,
#      'd' => 'format_date(event.time)'.freeze,
#      'F' => 'event.file'.freeze,
#      'l' => '::Logging::LNAMES[event.level]'.freeze,
#      'L' => 'event.line'.freeze,
#      'm' => 'format_obj(event.data)'.freeze,
#      'M' => 'event.method'.freeze,
#      'p' => 'Process.pid'.freeze,
#      'r' => 'Integer((event.time-@created_at)*1000).to_s'.freeze,
#      't' => 'Thread.current.object_id.to_s'.freeze,
#      'T' => 'Thread.current[:name]'.freeze,
#      'X' => :placeholder,
#      'x' => :placeholder,
#      '%' => :placeholder
#     }.freeze
     DIRECTIVE_TABLE = DIRECTIVE_TABLE.dup # it's frozen
     DIRECTIVE_TABLE['T'] = '(Thread.current[:name] || Thread.current.to_java.native_thread.name)'.freeze
   end
end

2_ahn_logging_speedy_quirks.rb

# NOTE: Adhearsion::Logging is "poluted" every-where :

=begin
module Adhearsion::Logging::HasLogger
  def logger
    ::Logging.logger[logger_id]
  end

  def logger_id
    self
  end
end

class Object
  include Adhearsion::Logging::HasLogger
end
=end


require 'adhearsion/call'

module Adhearsion
  class Call

#    def initialize(offer = nil)
#      register_initial_handlers
#
#      @offer        = nil
#      @tags         = []
#      @commands     = CommandRegistry.new
#      @variables    = HashWithIndifferentAccess.new
#      @controllers  = []
#      @end_reason   = nil
#      @end_code     = nil
#      @end_blocker  = Celluloid::Condition.new
#      @peers        = {}
#      @duration     = nil
#      @auto_hangup  = true
#
#      self << offer if offer
#    end

    def logger
      if id
        @logger ||= ::Logging.logger[ logger_id ]
      else
        ::Logging.logger[ self.class.name ]
      end
    end

    def finalize; ::Logging::Logger.dispose!(logger_id) end

    # NOTE: memoize once used so it's correctly disposed (won't leak)
    def logger_id; @logger_id ||= "#{self.class}: #{id}@#{domain}" end

  end
end

require 'punchblock/translator/asterisk'
require 'punchblock/translator/asterisk/call'

module Punchblock
  module Translator
    class Asterisk
      class Call

        def logger
          @logger ||= ::Logging.logger[ logger_id ]
        end
        alias pb_logger logger

        #def logger_id
        #  "#{self.class}: #{id}"
        #end

      end
    end
  end
end


require 'adhearsion/foundation/object'

module Celluloid
  class ActorProxy
    def logger
      if current_actor = Thread.current[:celluloid_actor]
        current_actor.bare_object.send :logger
      else
        Actor.call @mailbox, :logger
      end
    end
    alias pb_logger logger
  end
end

# TEMP to resolve loggers created :
#require 'logging/repository'
#class Logging::Repository
#  def each_pair
#    @h.each_pair { |key, logger| yield(key, logger) }
#  end
#end
#print_loggers = Proc.new do
#  Logging::Repository.instance.each_pair do |key, logger|
#    puts " #{key.inspect} #{logger.inspect}"
#  end
#end
#print_loggers.call; at_exit { print_loggers.call }

# pre-initialize loggers that only get created only **after** calls come in :
%w{ Adhearsion::Call Adhearsion::Router Adhearsion::Calls }.each { |name| ::Logging.logger[name] }
%w{ Adhearsion::Process Adhearsion::Events }.each { |name| ::Logging.logger[name] }
%w{ ActiveRecord::Relation }.each { |name| ::Logging.logger[name] }