semantic_logger 4.2.0 → 4.2.1

data/lib/semantic_logger/semantic_logger.rb

@@ -3,7 +3,7 @@ require 'socket'
 
 module SemanticLogger
   # Logging levels in order of most detailed to most severe
-  LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
+  LEVELS = %i[trace debug info warn error fatal].freeze
 
   # Return a logger for the supplied class or class_name
   def self.[](klass)
@@ -35,7 +35,7 @@ module SemanticLogger
   def self.backtrace_level=(level)
     @backtrace_level = level
     # For performance reasons pre-calculate the level index
-    @backtrace_level_index = level.nil? ? 65535 : level_to_index(level)
+    @backtrace_level_index = level.nil? ? 65_535 : level_to_index(level)
   end
 
   # Returns the current backtrace level
@@ -45,14 +45,14 @@ module SemanticLogger
 
   # Returns the current backtrace level index
   # For internal use only
-  def self.backtrace_level_index #:nodoc
+  def self.backtrace_level_index
     @backtrace_level_index
   end
 
   # Returns [String] name of this host for logging purposes
   # Note: Not all appenders use `host`
   def self.host
-    @host ||= Socket.gethostname.force_encoding("UTF-8")
+    @host ||= Socket.gethostname.force_encoding('UTF-8')
   end
 
   # Override the default host name
@@ -223,7 +223,7 @@ module SemanticLogger
   # * This callback is called within the thread of the application making the logging call.
   # * If these callbacks are slow they will slow down the application.
   def self.on_log(object = nil, &block)
-    Processor.instance.on_log(object, &block)
+    Processor.instance.appender.on_log(object, &block)
   end
 
   # Add signal handlers for Semantic Logger
@@ -261,22 +261,26 @@ module SemanticLogger
   # Note:
   #   To only register one of the signal handlers, set the other to nil
   #   Set gc_log_microseconds to nil to not enable JRuby Garbage collections
-  def self.add_signal_handler(log_level_signal='USR2', thread_dump_signal='TTIN', gc_log_microseconds=100000)
-    Signal.trap(log_level_signal) do
-      index     = (default_level == :trace) ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
-      new_level = LEVELS[index-1]
-      self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
-      self.default_level = new_level
-    end if log_level_signal
-
-    Signal.trap(thread_dump_signal) do
-      logger = SemanticLogger['Thread Dump']
-      Thread.list.each do |thread|
-        # MRI re-uses the main thread for signals, JRuby uses `SIGTTIN handler` thread.
-        next if defined?(JRuby) && (thread == Thread.current)
-        logger.backtrace(thread: thread)
+  def self.add_signal_handler(log_level_signal = 'USR2', thread_dump_signal = 'TTIN', gc_log_microseconds = 100_000)
+    if log_level_signal
+      Signal.trap(log_level_signal) do
+        index     = default_level == :trace ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
+        new_level = LEVELS[index - 1]
+        self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
+        self.default_level = new_level
       end
-    end if thread_dump_signal
+    end
+
+    if thread_dump_signal
+      Signal.trap(thread_dump_signal) do
+        logger = SemanticLogger['Thread Dump']
+        Thread.list.each do |thread|
+          # MRI re-uses the main thread for signals, JRuby uses `SIGTTIN handler` thread.
+          next if defined?(JRuby) && (thread == Thread.current)
+          logger.backtrace(thread: thread)
+        end
+      end
+    end
 
     if gc_log_microseconds && defined?(JRuby)
       listener = SemanticLogger::JRuby::GarbageCollectionLogger.new(gc_log_microseconds)
@@ -360,9 +364,9 @@ module SemanticLogger
   end
 
   # Remove specified number of tags from the current tag list
-  def self.pop_tags(quantity=1)
+  def self.pop_tags(quantity = 1)
     t = Thread.current[:semantic_logger_tags]
-    t.pop(quantity) unless t.nil?
+    t&.pop(quantity)
   end
 
   # :nodoc
@@ -370,12 +374,11 @@ module SemanticLogger
     return yield if hash.nil? || hash.empty?
     raise(ArgumentError, '#named_tagged only accepts named parameters (Hash)') unless hash.is_a?(Hash)
 
-    t = Thread.current[:semantic_logger_named_tags] ||= []
     begin
-      t << hash
+      push_named_tags(hash)
       yield
     ensure
-      t.pop
+      pop_named_tags
     end
   end
 
@@ -392,6 +395,16 @@ module SemanticLogger
     end
   end
 
+  def self.push_named_tags(hash)
+    (Thread.current[:semantic_logger_named_tags] ||= []) << hash
+    hash
+  end
+
+  def self.pop_named_tags(quantity = 1)
+    t = Thread.current[:semantic_logger_named_tags]
+    t&.pop(quantity)
+  end
+
   # Silence noisy log levels by changing the default_level within the block
   #
   # This setting is thread-safe and only applies to the current thread
@@ -436,19 +449,19 @@ module SemanticLogger
     Thread.current[:semantic_logger_silence] = current_index
   end
 
-  private
-
-  @appenders = Concurrent::Array.new
-
   def self.default_level_index
     Thread.current[:semantic_logger_silence] || @default_level_index
   end
 
+  # private_class_method :default_level_index
+
   # Returns the symbolic level for the supplied level index
   def self.index_to_level(level_index)
     LEVELS[level_index]
   end
 
+  # private_class_method :index_to_level
+
   # Internal method to return the log level as an internal index
   # Also supports mapping the ::Logger levels to SemanticLogger levels
   def self.level_to_index(level)
@@ -465,7 +478,8 @@ module SemanticLogger
         @map_levels ||= begin
           levels = []
           ::Logger::Severity.constants.each do |constant|
-            levels[::Logger::Severity.const_get(constant)] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
+            levels[::Logger::Severity.const_get(constant)] =
+              LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
           end
           levels
         end
@@ -475,6 +489,8 @@ module SemanticLogger
     index
   end
 
+  # private_class_method :level_to_index
+
   # Backward compatibility
   def self.convert_old_appender_args(appender, level)
     options         = {}
@@ -493,6 +509,10 @@ module SemanticLogger
     options
   end
 
+  private_class_method :convert_old_appender_args
+
+  @appenders = Concurrent::Array.new
+
   # Initial default Level for all new instances of SemanticLogger::Logger
   @default_level         = :info
   @default_level_index   = level_to_index(@default_level)

data/lib/semantic_logger/subscriber.rb

@@ -104,6 +104,5 @@ module SemanticLogger
     def level_index
       @level_index || 0
     end
-
   end
 end

data/lib/semantic_logger/utils.rb

@@ -1,47 +1,47 @@
-module SemanticLogger::Utils
-
-  def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
-    klass = "#{namespace}::#{camelize(symbol.to_s)}"
-    begin
-      if RUBY_VERSION.to_i >= 2
-        Object.const_get(klass)
-      else
-        klass.split('::').inject(Object) { |o, name| o.const_get(name) }
+module SemanticLogger
+  module Utils
+    def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
+      klass = "#{namespace}::#{camelize(symbol.to_s)}"
+      begin
+        if RUBY_VERSION.to_i >= 2
+          Object.const_get(klass)
+        else
+          klass.split('::').inject(Object) { |o, name| o.const_get(name) }
+        end
+      rescue NameError
+        raise(ArgumentError, "Could not convert symbol: #{symbol.inspect} to a class in: #{namespace}. Looking for: #{klass}")
       end
-    rescue NameError
-      raise(ArgumentError, "Could not convert symbol: #{symbol.inspect} to a class in: #{namespace}. Looking for: #{klass}")
     end
-  end
 
-  # Borrow from Rails, when not running Rails
-  def self.camelize(term)
-    string = term.to_s
-    string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
-    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
-    string.gsub!('/'.freeze, '::'.freeze)
-    string
-  end
+    # Borrow from Rails, when not running Rails
+    def self.camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/, &:capitalize)
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+      string.gsub!('/'.freeze, '::'.freeze)
+      string
+    end
 
-  # Returns the visibility for an instance method
-  def self.method_visibility(mod, method_name)
-    method_name = method_name.to_sym
-    if mod.instance_methods.include?(method_name)
-      :public
-    elsif mod.private_instance_methods.include?(method_name)
-      :private
-    elsif mod.protected_instance_methods.include?(method_name)
-      :protected
+    # Returns the visibility for an instance method
+    def self.method_visibility(mod, method_name)
+      method_name = method_name.to_sym
+      if mod.instance_methods.include?(method_name)
+        :public
+      elsif mod.private_instance_methods.include?(method_name)
+        :private
+      elsif mod.protected_instance_methods.include?(method_name)
+        :protected
+      end
     end
-  end
 
-  SELF_PATTERN = File.join('lib', 'semantic_logger')
+    SELF_PATTERN = File.join('lib', 'semantic_logger')
 
-  # Extract the backtrace leaving out the last few Semantic Logger lines.
-  def self.cleanse_backtrace(stack = caller)
-    while (first = stack.first) && first.include?(SELF_PATTERN)
-      stack.shift
+    # Extract the backtrace leaving out the last few Semantic Logger lines.
+    def self.cleanse_backtrace(stack = caller)
+      while (first = stack.first) && first.include?(SELF_PATTERN)
+        stack.shift
+      end
+      stack
     end
-    stack
   end
-
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
-module SemanticLogger #:nodoc
-  VERSION = '4.2.0'
+module SemanticLogger
+  VERSION = '4.2.1'.freeze
 end

data/test/appender/async_batch_test.rb

@@ -55,7 +55,6 @@ module Appender
           assert_equal 'hello world', logs.first.message
         end
       end
-
     end
   end
 end

data/test/appender/async_test.rb

@@ -39,7 +39,6 @@ module Appender
           assert_instance_of Queue, added_appender.queue
         end
       end
-
     end
   end
 end

data/test/appender/bugsnag_test.rb

@@ -21,10 +21,10 @@ module Appender
               level.to_s
             end
           exception     = hash = nil
-          Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
+          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
             @appender.send(level, @message)
           end
-          if [:trace, :debug].include?(level)
+          if %i[trace debug].include?(level)
             assert_nil exception
             assert_nil hash
           else
@@ -36,10 +36,10 @@ module Appender
 
         it "sends #{level} custom attributes" do
           exception = hash = nil
-          Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-            @appender.send(level, @message, {key1: 1, key2: 'a'})
+          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
+            @appender.send(level, @message, key1: 1, key2: 'a')
           end
-          if [:trace, :debug].include?(level)
+          if %i[trace debug].include?(level)
             assert_nil exception
             assert_nil hash
           else
@@ -54,10 +54,10 @@ module Appender
         it "sends #{level} exceptions" do
           error     = RuntimeError.new('Hello World')
           exception = hash = nil
-          Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
+          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
             @appender.send(level, @message, error)
           end
-          if [:trace, :debug].include?(level)
+          if %i[trace debug].include?(level)
             assert_nil exception
             assert_nil hash
           else
@@ -67,7 +67,6 @@ module Appender
           end
         end
       end
-
     end
   end
 end

data/test/appender/elasticsearch_http_test.rb

@@ -17,7 +17,7 @@ module Appender
 
       it 'logs to daily indexes' do
         index = nil
-        @appender.stub(:post, -> json, ind { index = ind }) do
+        @appender.stub(:post, ->(_json, ind) { index = ind }) do
           @appender.info @message
         end
         assert_equal "/semantic_logger-#{Time.now.utc.strftime('%Y.%m.%d')}/log", index
@@ -26,7 +26,7 @@ module Appender
       SemanticLogger::LEVELS.each do |level|
         it "send #{level}" do
           request = nil
-          @appender.http.stub(:request, -> r { request = r; response_mock.new('200', 'ok') }) do
+          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
             @appender.send(level, @message)
           end
           message = JSON.parse(request.body)
@@ -43,7 +43,7 @@ module Appender
             exc = e
           end
           request = nil
-          @appender.http.stub(:request, -> r { request = r; response_mock.new('200', 'ok') }) do
+          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
             @appender.send(level, 'Reading File', exc)
           end
           hash = JSON.parse(request.body)
@@ -57,8 +57,8 @@ module Appender
 
         it "sends #{level} custom attributes" do
           request = nil
-          @appender.http.stub(:request, -> r { request = r; response_mock.new('200', 'ok') }) do
-            @appender.send(level, @message, {key1: 1, key2: 'a'})
+          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
+            @appender.send(level, @message, key1: 1, key2: 'a')
           end
           message = JSON.parse(request.body)
           assert_equal @message, message['message']
@@ -69,7 +69,6 @@ module Appender
           assert_equal 'a', payload['key2'], message
         end
       end
-
     end
   end
 end

data/test/appender/elasticsearch_test.rb

@@ -106,13 +106,15 @@ module Appender
             request = stub_client { appender.batch(logs) }
 
             assert body = request[:body]
-            assert_equal 4, body.size, body
-            index = body[0]['index']['_index']
-            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+            assert_equal 6, body.size, body
 
+            index = "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}"
+            assert_equal index, body[0]['index']['_index']
             assert_equal 'hello world1', body[1][:message]
-            assert_equal 'hello world2', body[2][:message]
-            assert_equal 'hello world3', body[3][:message]
+            assert_equal index, body[2]['index']['_index']
+            assert_equal 'hello world2', body[3][:message]
+            assert_equal index, body[4]['index']['_index']
+            assert_equal 'hello world3', body[5][:message]
           end
         end
 
@@ -223,13 +225,15 @@ module Appender
             request = stub_client { appender.batch(logs) }
 
             assert body = request[:body]
-            assert_equal 4, body.size, body
-            index = body[0]['index']['_index']
-            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+            assert_equal 6, body.size, body
 
+            index = "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}"
+            assert_equal index, body[0]['index']['_index']
             assert_equal 'hello world1', body[1][:message]
-            assert_equal 'hello world2', body[2][:message]
-            assert_equal 'hello world3', body[3][:message]
+            assert_equal index, body[2]['index']['_index']
+            assert_equal 'hello world2', body[3][:message]
+            assert_equal index, body[4]['index']['_index']
+            assert_equal 'hello world3', body[5][:message]
           end
         end
 

data/test/appender/file_test.rb

@@ -12,8 +12,8 @@ module Appender
         @time                          = Time.new
         @io                            = StringIO.new
         @appender                      = SemanticLogger::Appender::File.new(io: @io)
-        @hash                          = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-        @hash_str                      = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+        @hash                          = {session_id: 'HSSKLEU@JDK767', tracking_number: 12_345}
+        @hash_str                      = @hash.inspect.sub('{', '\\{').sub('}', '\\}')
         @thread_name                   = Thread.current.name
         @file_name_reg_exp             = RUBY_VERSION.to_f <= 2.0 ? ' (mock|file_test).rb:\d+' : ' file_test.rb:\d+'
       end
@@ -88,15 +88,15 @@ module Appender
       describe 'custom formatter' do
         before do
           @appender = SemanticLogger::Appender::File.new(io: @io) do |log|
-            tags = log.tags.collect { |tag| "[#{tag}]" }.join(' ') + ' ' if log.tags && (log.tags.size > 0)
+            tags = log.tags.collect { |tag| "[#{tag}]" }.join(' ') + ' ' if log.tags&.size&.positive?
 
             message = log.message.to_s
             message << ' -- ' << log.payload.inspect if log.payload
             message << ' -- ' << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
 
-            duration_str = log.duration ? " (#{'%.1f' % log.duration}ms)" : ''
+            duration_str = log.duration ? " (#{format('%.1f', log.duration)}ms)" : ''
 
-            "#{log.formatted_time} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
+            "#{log.formatted_time} #{log.level.to_s.upcase} [#{$PROCESS_ID}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
           end
         end
 
@@ -105,7 +105,6 @@ module Appender
           assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ DEBUG \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string)
         end
       end
-
     end
   end
 end