semantic_logger 2.15.0 → 2.16.0

data/lib/semantic_logger/appender/wrapper.rb

@@ -15,7 +15,7 @@ module SemanticLogger
       #    ruby_logger = Logger.new(STDOUT)
       #    SemanticLogger.add_appender(ruby_logger)
       #    logger =  SemanticLogger['test']
-      #    logger.info('Hello World', :some => :payload)
+      #    logger.info('Hello World', some: :payload)
       #
       # Enhance the Rails Logger
       #    # Add the Rails logger to the list of appenders
@@ -28,8 +28,8 @@ module SemanticLogger
       # Note: Since the log level is controlled by setting the Ruby or Rails logger directly
       #   the level is ignored for this appender
       def initialize(logger, filter=nil, &block)
-        raise "logger cannot be null when initiailizing the SemanticLogging::Appender::Wrapper" unless logger
-        @logger = logger
+        raise 'logger cannot be null when initiailizing the SemanticLogging::Appender::Wrapper' unless logger
+        @logger    = logger
 
         # Set the formatter to the supplied block
         @formatter = block || self.default_formatter

data/lib/semantic_logger/base.rb

@@ -21,7 +21,7 @@ module SemanticLogger
     # nil if this logger instance should use the global default level
     def level=(level)
       @level_index = SemanticLogger.level_to_index(level)
-      @level = level
+      @level       = level
     end
 
     # Returns the current log level if set, otherwise it returns the global
@@ -68,7 +68,7 @@ module SemanticLogger
     #    logger.debug("Only display this if log level is set to Debug or lower")
     #
     #    # Log semantic information along with a text message
-    #    logger.info("Request received", :user => "joe", :duration => 100)
+    #    logger.info("Request received", user: "joe", duration: 100)
     #
     #    # Log an exception in a semantic way
     #    logger.info("Parsing received XML", exc)
@@ -134,8 +134,8 @@ module SemanticLogger
     # Returns the list of tags pushed after flattening them out and removing blanks
     def push_tags *tags
       # Need to flatten and reject empties to support calls from Rails 4
-      new_tags = tags.flatten.collect(&:to_s).reject(&:empty?)
-      t = Thread.current[:semantic_logger_tags]
+      new_tags                              = tags.flatten.collect(&:to_s).reject(&:empty?)
+      t                                     = Thread.current[:semantic_logger_tags]
       Thread.current[:semantic_logger_tags] = t.nil? ? new_tags : t.concat(new_tags)
       new_tags
     end
@@ -150,18 +150,18 @@ module SemanticLogger
     #
     # Add a payload to all log calls on This Thread within the supplied block
     #
-    #   logger.with_payload(:tracking_number=>12345) do
+    #   logger.with_payload(tracking_number: 12345) do
     #     logger.debug('Hello World')
     #   end
     #
     # If a log call already includes a pyload, this payload will be merged with
     # the supplied payload, with the supplied payload taking precedence
     #
-    #   logger.with_payload(:tracking_number=>12345) do
-    #     logger.debug('Hello World', :result => 'blah')
+    #   logger.with_payload(tracking_number: 12345) do
+    #     logger.debug('Hello World', result: 'blah')
     #   end
     def with_payload(payload)
-      current_payload = self.payload
+      current_payload                          = self.payload
       Thread.current[:semantic_logger_payload] = current_payload ? current_payload.merge(payload) : payload
       yield
     ensure
@@ -218,7 +218,7 @@ module SemanticLogger
     #   #silence does not affect any loggers which have had their log level set
     #   explicitly. I.e. That do not rely on the global default level
     def silence(new_level = :error)
-      current_index = Thread.current[:semantic_logger_silence]
+      current_index                            = Thread.current[:semantic_logger_silence]
       Thread.current[:semantic_logger_silence] = SemanticLogger.level_to_index(new_level)
       yield
     ensure
@@ -227,13 +227,13 @@ module SemanticLogger
 
     # DEPRECATED See SemanticLogger.default_level=
     def self.default_level=(level)
-      warn "[DEPRECATION] `SemanticLogger::Logger.default_level=` is deprecated.  Please use `SemanticLogger.default_level=` instead."
+      warn '[DEPRECATION] SemanticLogger::Logger.default_level= is deprecated.  Please use SemanticLogger.default_level= instead.'
       SemanticLogger.default_level = level
     end
 
     # DEPRECATED See SemanticLogger.default_level
     def self.default_level
-      warn "[DEPRECATION] `SemanticLogger::Logger.default_level` is deprecated.  Please use `SemanticLogger.default_level` instead."
+      warn '[DEPRECATION] SemanticLogger::Logger.default_level is deprecated.  Please use SemanticLogger.default_level instead.'
       SemanticLogger.default_level
     end
 
@@ -260,7 +260,7 @@ module SemanticLogger
     def initialize(klass, level=nil, filter=nil)
       # Support filtering all messages to this logger using a Regular Expression
       # or Proc
-      raise ":filter must be a Regexp or Proc" unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
+      raise ':filter must be a Regexp or Proc' unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
 
       @filter    = filter.is_a?(Regexp) ? filter.freeze : filter
       @name      = klass.is_a?(String) ? klass : klass.name
@@ -269,7 +269,7 @@ module SemanticLogger
 
     # Write log data to underlying data storage
     def log(log_)
-      raise NotImplementedError.new("Logging Appender must implement #log(log)")
+      raise NotImplementedError.new('Logging Appender must implement #log(log)')
     end
 
     # Return the level index for fast comparisons
@@ -334,7 +334,7 @@ module SemanticLogger
         message   = exception.inspect
       elsif exception.nil? && payload && payload.is_a?(Exception)
         exception = payload
-        payload = nil
+        payload   = nil
       end
 
       if block && (result = block.call)
@@ -357,34 +357,36 @@ module SemanticLogger
 
     # Measure the supplied block and log the message
     def benchmark_internal(level, index, message, params, &block)
-      start     = Time.now
+      start = Time.now
       begin
         if block
-          result = if silence_level = params[:silence]
-            # In case someone accidentally sets `silence: true` instead of `silence: :error`
-            silence_level = :error if silence_level == true
-            silence(silence_level) { block.call(params) }
-          else
-            block.call(params)
-          end
+          result    =
+            if silence_level = params[:silence]
+              # In case someone accidentally sets `silence: true` instead of `silence: :error`
+              silence_level = :error if silence_level == true
+              silence(silence_level) { block.call(params) }
+            else
+              block.call(params)
+            end
           exception = params[:exception]
           result
         end
       rescue Exception => exc
         exception = exc
       ensure
-        end_time = Time.now
+        end_time           = Time.now
         # Extract options after block completes so that block can modify any of the options
         log_exception      = params[:log_exception] || :partial
         on_exception_level = params[:on_exception_level]
         min_duration       = params[:min_duration] || 0.0
         payload            = params[:payload]
         metric             = params[:metric]
-        duration           = if block_given?
-          1000.0 * (end_time - start)
-        else
-          params[:duration] || raise("Mandatory block missing when :duration option is not supplied")
-        end
+        duration           =
+          if block_given?
+            1000.0 * (end_time - start)
+          else
+            params[:duration] || raise('Mandatory block missing when :duration option is not supplied')
+          end
 
         # Add scoped payload
         if self.payload
@@ -405,7 +407,7 @@ module SemanticLogger
               level = on_exception_level
               index = SemanticLogger.level_to_index(level)
             end
-            message = "#{message} -- Exception: #{exception.class}: #{exception.message}"
+            message          = "#{message} -- Exception: #{exception.class}: #{exception.message}"
             logged_exception = nil
           else
             # Log the message with its duration but leave out the exception that was raised

data/lib/semantic_logger/jruby/garbage_collection_logger.rb

@@ -14,8 +14,8 @@ module SemanticLogger
         # Only care about GARBAGE_COLLECTION_NOTIFICATION notifications
         return unless notification.get_type == Java::ComSunManagement::GarbageCollectionNotificationInfo::GARBAGE_COLLECTION_NOTIFICATION
 
-        info = Java::ComSunManagement::GarbageCollectionNotificationInfo.from(notification.user_data)
-        gc_info = info.gc_info
+        info     = Java::ComSunManagement::GarbageCollectionNotificationInfo.from(notification.user_data)
+        gc_info  = info.gc_info
         duration = gc_info.duration
         if duration >= @min_microseconds
           SemanticLogger['GarbageCollector'].benchmark_warn "Garbage Collection completed: #{info.gc_name} ##{gc_info.id}", duration: duration.to_f / 1000

data/lib/semantic_logger/loggable.rb

@@ -18,7 +18,7 @@ require 'sync_attr'
 #    include SemanticLogger::Loggable
 #
 #    def call_supplier(amount, name)
-#      logger.debug "Calculating with amount", { :amount => amount, :name => name }
+#      logger.debug "Calculating with amount", { amount: amount, name: name }
 #
 #      # Measure and log on completion how long the call took to the external supplier
 #      logger.benchmark_info "Calling external interface" do
@@ -94,4 +94,4 @@ module SemanticLogger
     end
 
   end
-end
+end

data/lib/semantic_logger/logger.rb

@@ -60,12 +60,12 @@ module SemanticLogger
 
       logger.debug "Flushing appenders with #{queue_size} log messages on the queue"
       reply_queue = Queue.new
-      queue << { :command => :flush, :reply_queue => reply_queue }
+      queue << {command: :flush, reply_queue: reply_queue}
       reply_queue.pop
     end
 
     @@lag_check_interval = 5000
-    @@lag_threshold_s = 30
+    @@lag_threshold_s    = 30
 
     # Returns the check_interval which is the number of messages between checks
     # to determine if the appender thread is falling behind
@@ -99,13 +99,13 @@ module SemanticLogger
 
     # DEPRECATED See SemanticLogger.add_appender
     def self.appenders
-      warn "[DEPRECATION] `SemanticLogger::Logger.appenders` is deprecated.  Please use `SemanticLogger.add_appender` instead."
+      warn '[DEPRECATION] SemanticLogger::Logger.appenders is deprecated.  Please use SemanticLogger.add_appender instead.'
       SemanticLogger.appenders
     end
 
     # DEPRECATED: Please use queue_size instead.
     def self.cache_count
-      warn "[DEPRECATION] 'SemanticLogger::Logger.cache_count' is deprecated.  Please use 'SemanticLogger::Logger.queue_size' instead."
+      warn '[DEPRECATION] SemanticLogger::Logger.cache_count is deprecated.  Please use SemanticLogger::Logger.queue_size instead.'
       queue_size
     end
 
@@ -120,7 +120,7 @@ module SemanticLogger
     #     puts "#{log_struct.metric} was received. Log Struct: #{log_struct.inspect}"
     #   end
     def self.on_metric(&block)
-      (@@metric_subscribers  ||= ThreadSafe::Array.new) << block
+      (@@metric_subscribers ||= ThreadSafe::Array.new) << block
     end
 
     ############################################################################
@@ -146,7 +146,7 @@ module SemanticLogger
     #   By default logs to STDERR
     def self.logger
       @@logger ||= begin
-        l = SemanticLogger::Appender::File.new(STDERR, :warn)
+        l      = SemanticLogger::Appender::File.new(STDERR, :warn)
         l.name = name
         l
       end
@@ -156,7 +156,7 @@ module SemanticLogger
     def self.start_appender_thread
       return false if appender_thread_active?
       @@appender_thread = Thread.new { appender_thread }
-      raise "Failed to start Appender Thread" unless @@appender_thread
+      raise 'Failed to start Appender Thread' unless @@appender_thread
       true
     end
 
@@ -173,7 +173,7 @@ module SemanticLogger
       #
       # Should any appender fail to log or flush, the exception is logged and
       # other appenders will still be called
-      Thread.current.name = "SemanticLogger::AppenderThread"
+      Thread.current.name = 'SemanticLogger::AppenderThread'
       logger.debug "V#{VERSION} Appender thread active"
       begin
         count = 0
@@ -208,7 +208,7 @@ module SemanticLogger
               end
 
               message[:reply_queue] << true if message[:reply_queue]
-              logger.debug "Appender thread: All appenders flushed"
+              logger.debug 'Appender thread: All appenders flushed'
             else
               logger.warn "Appender thread: Ignoring unknown command: #{message[:command]}"
             end
@@ -217,7 +217,7 @@ module SemanticLogger
       rescue Exception => exception
         # This block may be called after the file handles have been released by Ruby
         begin
-          logger.error "Appender thread restarting due to exception", exception
+          logger.error 'Appender thread restarting due to exception', exception
         rescue Exception
           nil
         end
@@ -226,7 +226,7 @@ module SemanticLogger
         @@appender_thread = nil
         # This block may be called after the file handles have been released by Ruby
         begin
-          logger.debug "Appender thread has stopped"
+          logger.debug 'Appender thread has stopped'
         rescue Exception
           nil
         end
@@ -242,7 +242,7 @@ module SemanticLogger
         begin
           subscriber.call(log_struct)
         rescue Exception => exc
-          logger.error "Exception calling subscriber", exc
+          logger.error 'Exception calling subscriber', exc
         end
       end
     end

data/lib/semantic_logger/semantic_logger.rb

@@ -8,16 +8,14 @@ module SemanticLogger
     SemanticLogger::Logger.new(klass)
   end
 
-  # Allow for setting the global default log level
-  # This change only applies to _new_ loggers, existing logger levels
-  # will not be changed in any way
+  # Sets the global default log level
   def self.default_level=(level)
-    @@default_level = level
+    @@default_level       = level
     # For performance reasons pre-calculate the level index
     @@default_level_index = level_to_index(level)
   end
 
-  # Returns the global default log level for new Logger instances
+  # Returns the global default log level
   def self.default_level
     @@default_level
   end
@@ -80,26 +78,27 @@ module SemanticLogger
   #
   #   logger = SemanticLogger['Example']
   #   logger.info "Hello World"
-  #   logger.debug("Login time", :user => 'Joe', :duration => 100, :ip_address=>'127.0.0.1')
+  #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
   #
   def self.add_appender(appender, level=nil, &block)
-    appender_instance = if appender.is_a?(String) || appender.is_a?(IO)
-      # $stderr, STDOUT, other IO, or a filename
-      SemanticLogger::Appender::File.new(appender, level, &block)
-    elsif appender.is_a? Appender::Base
-      # Already an instance of an appender
-      appender.level = level if level
-      appender.formatter = block if block
-      appender
-    else
-      # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
-      if does_not_implement = LEVELS[1..-1].find{|i| !appender.respond_to?(i)}
-        raise "Supplied appender does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}"
-      end
+    appender_instance =
+      if appender.is_a?(String) || appender.is_a?(IO)
+        # $stderr, STDOUT, other IO, or a filename
+        SemanticLogger::Appender::File.new(appender, level, &block)
+      elsif appender.is_a? Appender::Base
+        # Already an instance of an appender
+        appender.level     = level if level
+        appender.formatter = block if block
+        appender
+      else
+        # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
+        if does_not_implement = LEVELS[1..-1].find { |i| !appender.respond_to?(i) }
+          raise "Supplied appender does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}"
+        end
 
-      raise "Change the log level to #{level}, update the log level directly against the supplied appender" if level
-      SemanticLogger::Appender::Wrapper.new(appender, &block)
-    end
+        raise "Change the log level to #{level}, update the log level directly against the supplied appender" if level
+        SemanticLogger::Appender::Wrapper.new(appender, &block)
+      end
     @@appenders << appender_instance
 
     # Start appender thread if it is not already running
@@ -133,7 +132,7 @@ module SemanticLogger
   #
   # Note: Only appenders that implement the reopen method will be called
   def self.reopen
-    @@appenders.each {|appender| appender.reopen if appender.respond_to?(:reopen)}
+    @@appenders.each { |appender| appender.reopen if appender.respond_to?(:reopen) }
     # After a fork the appender thread is not running, start it if it is not running
     SemanticLogger::Logger.start_appender_thread
   end
@@ -189,7 +188,7 @@ module SemanticLogger
   #   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)
+      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
@@ -242,27 +241,28 @@ module SemanticLogger
   def self.level_to_index(level)
     return if level.nil?
 
-    index = if level.is_a?(Symbol)
-      LEVELS.index(level)
-    elsif level.is_a?(String)
-      level = level.downcase.to_sym
-      LEVELS.index(level)
-    elsif level.is_a?(Integer) && defined?(::Logger::Severity)
-      # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
-      @@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)
+    index =
+      if level.is_a?(Symbol)
+        LEVELS.index(level)
+      elsif level.is_a?(String)
+        level = level.downcase.to_sym
+        LEVELS.index(level)
+      elsif level.is_a?(Integer) && defined?(::Logger::Severity)
+        # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
+        @@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)
+          end
+          levels
         end
-        levels
+        @@map_levels[level]
       end
-      @@map_levels[level]
-    end
     raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
     index
   end
 
   # Initial default Level for all new instances of SemanticLogger::Logger
-  @@default_level = :info
+  @@default_level       = :info
   @@default_level_index = level_to_index(@@default_level)
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.15.0"
+  VERSION = '2.16.0'
 end

data/test/appender_bugsnag_test.rb

@@ -3,14 +3,14 @@ require_relative 'test_helper'
 # Unit Test for SemanticLogger::Appender::Bugsnag
 #
 class AppenderBugsnagTest < Minitest::Test
-  context SemanticLogger::Appender::Bugsnag do
-    setup do
+  describe SemanticLogger::Appender::Bugsnag do
+    before do
       @appender = SemanticLogger::Appender::Bugsnag.new(:warn)
       @message  = 'AppenderBugsnagTest log message'
     end
 
     (SemanticLogger::LEVELS - [:warn, :error]).each do |level|
-      should "not send :#{level} notifications to Bugsnag" do
+      it "not send :#{level} notifications to Bugsnag" do
         message = hash = nil
         Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
           @appender.send(level, "AppenderBugsnagTest #{level.to_s} message")
@@ -20,7 +20,7 @@ class AppenderBugsnagTest < Minitest::Test
       end
     end
 
-    should "send error notifications to Bugsnag with severity" do
+    it "send error notifications to Bugsnag with severity" do
       message = hash = nil
       Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
         @appender.error @message
@@ -29,7 +29,7 @@ class AppenderBugsnagTest < Minitest::Test
       assert_equal 'error', hash[:severity]
     end
 
-    should 'send warn notifications to Bugsnag replace warn severity with warning' do
+    it 'send warn notifications to Bugsnag replace warn severity with warning' do
       message = hash = nil
       Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
         @appender.warn @message
@@ -38,19 +38,19 @@ class AppenderBugsnagTest < Minitest::Test
       assert_equal 'warning', hash[:severity]
     end
 
-    should 'send notification to Bugsnag with custom attributes' do
+    it 'send notification to Bugsnag with custom attributes' do
       message = hash = nil
       Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-        @appender.error @message, {:key1 => 1, :key2 => 'a'}
+        @appender.error @message, {key1: 1, key2: 'a'}
       end
       assert_equal RuntimeError.new(@message), message
       assert_equal(1, hash[:key1], hash)
       assert_equal('a', hash[:key2], hash)
     end
 
-    should 'send notification to Bugsnag with exception' do
+    it 'send notification to Bugsnag with exception' do
       message = hash = nil
-      error = RuntimeError.new('Hello World')
+      error   = RuntimeError.new('Hello World')
       Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
         @appender.error error
       end