semantic_logger 2.18.0 → 2.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60df9242109f0c836e1375c4c21d5b0a85165e34
-  data.tar.gz: 47e1799788d85898b1ff7501ba99e460c78a815f
+  metadata.gz: 8edd7638dee098976eeee0f818ea64c213da2a1f
+  data.tar.gz: a03fac478e80e0784e765a7c2f28c8c6b929b94b
 SHA512:
-  metadata.gz: 304af80d0e158f72a2dd5a90f8ac1e56dd8955bcfd26b4cec84862c0347ba5fb5b93ae4d6e76cdf6f48f3f84bb6310c9dfa703f36534bc253c64020d91576cd2
-  data.tar.gz: 0b1064e891a59877f1e991a19e73e2a1f10aac25e4621df25c311bd7d903df68144df37a88d5bc13b6e456a86446d14e43ad5834fa5009e2eb651745de5d0e6c
+  metadata.gz: 9f85f11748ef85c23dbd912fa5a690d57cd50af051edaeb37014ba30ef987e9f22866b0632f457327c78f6243e88b242c2fe3cc4c46135b8b2f64c298de9961e
+  data.tar.gz: 1b5ac351139f57b94743022465f86030a8959df41e696fdcb048b4f3f07adfa1736bc21d9f4de74c6b8e0434a5d32ee44c79b7c26df4272a0201a78da8bb017a

data/README.md

@@ -11,7 +11,7 @@ Low latency, high throughput, enterprise-scale logging system for Ruby
 
 [Reference Documentation](http://www.rubydoc.info/gems/semantic_logger/)
 
-## Supports
+## Logging Destinations
 
 Logging to the following destinations are all supported "out-of-the-box":
 

data/lib/semantic_logger/appender/base.rb

@@ -59,8 +59,8 @@ module SemanticLogger
           entry << " -- #{log.message}" if log.message
 
           # Payload
-          unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
-            entry << ' -- ' << log.payload.inspect
+          if payload = log.payload_to_s(false)
+            entry << ' -- ' << payload
           end
 
           # Exceptions
@@ -83,7 +83,7 @@ module SemanticLogger
           level_color = colors::LEVEL_MAP[log.level]
 
           # Header with date, time, log level and process info
-          entry = "#{log.formatted_time} #{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
+          entry       = "#{log.formatted_time} #{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
 
           # Tags
           entry << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)
@@ -98,9 +98,7 @@ module SemanticLogger
           entry << " -- #{log.message}" if log.message
 
           # Payload
-          unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
-            payload = log.payload
-            payload = (defined?(AwesomePrint) && payload.respond_to?(:ai)) ? payload.ai(multiline: false) : payload.inspect
+          if payload = log.payload_to_s(true)
             entry << ' -- ' << payload
           end
 
@@ -123,8 +121,7 @@ module SemanticLogger
         @level || :trace
       end
 
-      ############################################################################
-      protected
+      private
 
       # Initializer for Abstract Class SemanticLogger::Appender
       #

data/lib/semantic_logger/base.rb

@@ -237,8 +237,7 @@ module SemanticLogger
       SemanticLogger.default_level
     end
 
-    ############################################################################
-    protected
+    private
 
     # Initializer for Abstract Class SemanticLogger::Base
     #

data/lib/semantic_logger/log.rb

@@ -124,6 +124,16 @@ module SemanticLogger
       message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip
     end
 
+    # Return the payload in text form
+    # Returns nil if payload is missing or empty
+    def payload_to_s(colorized = false)
+      return if payload.nil? || (payload.respond_to?(:empty?) && payload.empty?)
+      return payload.inspect if !colorized || !defined?(AwesomePrint) || !payload.respond_to?(:ai)
+
+      # Colorize the payload if the AwesomePrint gem is loaded
+      payload.ai(multiline: false) rescue payload.inspect
+    end
+
     if defined? JRuby
       # Return the Time as a formatted string
       # JRuby only supports time in ms

data/lib/semantic_logger/loggable.rb

@@ -1,5 +1,3 @@
-require 'sync_attr'
-
 # Logger class variable mix-in
 #
 #   Lazy initialize a logger class variable with instance accessor
@@ -31,9 +29,8 @@ module SemanticLogger
 
     def self.included(base)
       base.class_eval do
-        # Thread safe logger class variable initializer
-        sync_cattr_reader :logger do
-          SemanticLogger[self]
+        def self.logger
+          @semantic_logger ||= SemanticLogger[self]
         end
       end
     end

data/lib/semantic_logger/logger.rb

@@ -1,22 +1,8 @@
-require 'thread_safe'
-
-# Logger stores the class name to be used for all log messages so that every
-# log message written by this instance will include the class name
+require 'concurrent'
 module SemanticLogger
+  # Logger stores the class name to be used for all log messages so that every
+  # log message written by this instance will include the class name
   class Logger < Base
-
-    # DO NOT USE. Adding unused formatter to support Rails 4 logging
-    # Formatters must be set at the appender level, not at the logger level
-    #
-    # Due to the following code in Rails::Server#start that cannot be changed
-    # without patching the entire method
-    #    console = ActiveSupport::Logger.new($stdout)
-    #    console.formatter = Rails.logger.formatter
-    #    console.level = Rails.logger.level
-    #
-    #    Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
-    attr_accessor :formatter
-
     # Returns a Logger instance
     #
     # Return the logger for a specific class, supports class specific log levels
@@ -120,11 +106,10 @@ 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 ||= Concurrent::Array.new) << block
     end
 
-    ############################################################################
-    protected
+    private
 
     @@appender_thread    = nil
     @@queue              = Queue.new

data/lib/semantic_logger/semantic_logger.rb

@@ -1,4 +1,4 @@
-require 'thread_safe'
+require 'concurrent'
 module SemanticLogger
   # Logging levels in order of most detailed to most severe
   LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
@@ -246,14 +246,10 @@ module SemanticLogger
     true
   end
 
-  ############################################################################
-  protected
-
-  @@appenders = ThreadSafe::Array.new
-
-  ############################################################################
   private
 
+  @@appenders = Concurrent::Array.new
+
   def self.default_level_index
     Thread.current[:semantic_logger_silence] || @@default_level_index
   end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '2.18.0'
+  VERSION = '2.19.0'
 end

data/test/loggable_test.rb

@@ -8,42 +8,73 @@ end
 # Unit Test for SemanticLogger::Appender::File
 #
 class AppenderFileTest < Minitest::Test
+  class Base
+    include SemanticLogger::Loggable
+  end
+
+  class Subclass < Base
+  end
+
   describe SemanticLogger::Loggable do
-    before do
-      @time                        = Time.new
-      @io                          = StringIO.new
-      @appender                    = SemanticLogger::Appender::File.new(@io)
-      SemanticLogger.default_level = :trace
-      @mock_logger                 = MockLogger.new
-      @appender                    = SemanticLogger.add_appender(@mock_logger)
-      @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-      @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      @thread_name                 = Thread.current.name
-    end
+    describe 'inheritance' do
+      it 'should give child classes their own logger' do
+        assert_equal Subclass.name, Subclass.logger.name
+        assert_equal Base.name, Base.logger.name
+        assert_equal Subclass.name, Subclass.logger.name
+        child_logger = Subclass.logger
+        refute_equal child_logger, Base.logger
+        assert_equal child_logger.object_id, Subclass.logger.object_id
+      end
 
-    after do
-      SemanticLogger.remove_appender(@appender)
+      it 'should give child objects their own logger' do
+        subclass = Subclass.new
+        base = Base.new
+        assert_equal subclass.class.name, subclass.logger.name
+        assert_equal base.class.name, base.logger.name
+        assert_equal subclass.class.name, subclass.logger.name
+        child_logger = subclass.logger
+        refute_equal child_logger, base.logger
+        assert_equal child_logger.object_id, subclass.logger.object_id
+      end
     end
 
-    describe 'for each log level' do
-      # Ensure that any log level can be logged
-      SemanticLogger::LEVELS.each do |level|
-        it "log #{level} information with class attribute" do
-          SemanticLogger.stub(:backtrace_level_index, 0) do
-            SemanticLogger.stub(:appenders, [@appender]) do
-              TestAttribute.logger.send(level, "hello #{level}", @hash)
-              SemanticLogger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message
+    describe 'logger' do
+      before do
+        @time                        = Time.new
+        @io                          = StringIO.new
+        @appender                    = SemanticLogger::Appender::File.new(@io)
+        SemanticLogger.default_level = :trace
+        @mock_logger                 = MockLogger.new
+        @appender                    = SemanticLogger.add_appender(@mock_logger)
+        @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+        @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+        @thread_name                 = Thread.current.name
+      end
+
+      after do
+        SemanticLogger.remove_appender(@appender)
+      end
+
+      describe 'for each log level' do
+        # Ensure that any log level can be logged
+        SemanticLogger::LEVELS.each do |level|
+          it "log #{level} information with class attribute" do
+            SemanticLogger.stub(:backtrace_level_index, 0) do
+              SemanticLogger.stub(:appenders, [@appender]) do
+                TestAttribute.logger.send(level, "hello #{level}", @hash)
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message
+              end
             end
           end
-        end
 
-        it "log #{level} information with instance attribute" do
-          SemanticLogger.stub(:backtrace_level_index, 0) do
-            SemanticLogger.stub(:appenders, [@appender]) do
-              TestAttribute.new.logger.send(level, "hello #{level}", @hash)
-              SemanticLogger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message
+          it "log #{level} information with instance attribute" do
+            SemanticLogger.stub(:backtrace_level_index, 0) do
+              SemanticLogger.stub(:appenders, [@appender]) do
+                TestAttribute.new.logger.send(level, "hello #{level}", @hash)
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message
+              end
             end
           end
         end

data/test/logger_test.rb

@@ -97,7 +97,7 @@ class LoggerTest < Minitest::Test
             end
           end
 
-          it 'add payload to log entries' do
+          it 'logs tagged payload' do
             hash     = {tracking_number: "123456", even: 2, more: "data"}
             hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
             @logger.with_payload(tracking_number: '123456') do
@@ -108,6 +108,21 @@ class LoggerTest < Minitest::Test
               end
             end
           end
+
+          it 'logs payload' do
+            hash     = {tracking_number: "123456", even: 2, more: "data"}
+            hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
+            @logger.info('Hello world', hash)
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+          end
+
+          it 'does not log an empty payload' do
+            hash     = {}
+            @logger.info('Hello world', hash)
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] LoggerTest -- Hello world/, @mock_logger.message
+          end
         end
 
         describe 'Ruby Logger' do

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.18.0
+  version: 2.19.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-11 00:00:00.000000000 Z
+date: 2015-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sync_attr
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: thread_safe
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
 description: Next generation logging system for Ruby to support highly concurrent,
   high throughput, low latency enterprise systems
 email: