semantic_logger 2.9.0 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05fe9c7ccd2177383e5f4a8cf4b5b6d0bf84df71
-  data.tar.gz: 0516f2bb270d5ea5d78b67217fd02745ebe4c3ce
+  metadata.gz: 16021fcc1001bf8f9a7805c0e041856ac2a8e7d4
+  data.tar.gz: c5cc838698726569a32679031348e8d6e970d0df
 SHA512:
-  metadata.gz: 39f2f6909cdd7e1623fd099226849a2086873b52334ddabbde84067a12b3e88d1058384b346f09c11f1c3c357b38758ae6e51dd649e3d39f2765304f40ac59d5
-  data.tar.gz: 025cca0bde8b1733a023ba9139b474d9f14e85444b518e24764b2a346aa8676be5441e4e006866caf8a103027156e4c39f8b30af3cfd144d93a2fc96f26840ed
+  metadata.gz: 55d8f67c85aa0d40e31d566b63a2baffd5aadaff647c147f9856154c64d2fb8e34f2a690de923c1238175b41ae85a8f6c366fb33c69b2dd8e4690c3909f20b0e
+  data.tar.gz: bcf75d343fec7bf5c0f13b1260ed735ef0cedbea19bf6530010c91e8ca3744dc3698d90f5214e0b7359e6a7f7248accfded5a9a3d38cfae572c504d5c4102a0e

data/lib/semantic_logger/appender/file.rb

@@ -72,10 +72,14 @@ module SemanticLogger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
+        # Ensure minimum log level is met, and check filter
+        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+
         # Since only one appender thread will be writing to the file at a time
         # it is not necessary to protect access to the file with a semaphore
         # Allow this logger to filter out log levels lower than it's own
-        @log.write(@formatter.call(log) << "\n") if level_index <= (log.level_index || 0)
+        @log.write(@formatter.call(log) << "\n")
+        true
       end
 
       # Flush all pending logs to disk.

data/lib/semantic_logger/appender/mongodb.rb

@@ -178,8 +178,12 @@ module SemanticLogger
 
       # Log the message to MongoDB
       def log(log)
+        # Ensure minimum log level is met, and check filter
+        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+
         # Insert log entry into Mongo
-        collection.insert(formatter.call(log), :w=>@write_concern) if level_index <= (log.level_index || 0)
+        collection.insert(formatter.call(log), :w=>@write_concern)
+        true
       end
 
     end

data/lib/semantic_logger/appender/new_relic.rb

@@ -92,14 +92,14 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
 
   # Send an error notification to New Relic
   def log(log)
-    # Ensure minimum log level is met.
-    return false unless level_index <= (log.level_index || 0)
+    # Ensure minimum log level is met, and check filter
+    return false if (level_index > (log.level_index || 0)) || !include_message?(log)
 
     # For more documentation on the NewRelic::Agent.notice_error method see:
     # http://rubydoc.info/github/newrelic/rpm/NewRelic/Agent#notice_error-instance_method
     # and https://docs.newrelic.com/docs/ruby/ruby-agent-api
     NewRelic::Agent.notice_error(log.exception || self.class.first_non_empty_line(log.message), formatter.call(log))
-    return true
+    true
   end
 
 end

data/lib/semantic_logger/appender/syslog.rb

@@ -48,12 +48,12 @@ module SemanticLogger
       # ::Syslog::LOG_INFO    - "Informational message"
       # ::Syslog::LOG_DEBUG   - "Debugging information"
       DEFAULT_LEVEL_MAP = {
-          :fatal   => ::Syslog::LOG_CRIT,
-          :error   => ::Syslog::LOG_ERR,
-          :warn    => ::Syslog::LOG_WARNING,
-          :info    => ::Syslog::LOG_NOTICE,
-          :debug   => ::Syslog::LOG_INFO,
-          :trace   => ::Syslog::LOG_DEBUG
+        :fatal   => ::Syslog::LOG_CRIT,
+        :error   => ::Syslog::LOG_ERR,
+        :warn    => ::Syslog::LOG_WARNING,
+        :info    => ::Syslog::LOG_NOTICE,
+        :debug   => ::Syslog::LOG_INFO,
+        :trace   => ::Syslog::LOG_DEBUG
       }
 
       # For more information on the Syslog constants used below see http://ruby-doc.org/stdlib-2.0.0/libdoc/syslog/rdoc/Syslog.html
@@ -176,24 +176,24 @@ module SemanticLogger
         end
 
         case @protocol
-          when :syslog
-            ::Syslog.open(@ident, options, @facility)
-          when :tcp
-            # The resilient_socket gem is required when logging over TCP.
-            begin
-              require 'resilient_socket'
-            rescue LoadError
-              raise 'Missing gem: resilient_socket. This gem is required when logging over TCP. To fix this error: gem install resilient_socket'
-            end
-            options = tcp_client_options || {}
-            options[:server] = "#{@host}:#{@port}"
-            @remote_syslog = ResilientSocket::TCPClient.new(options)
-            # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
-            @remote_syslog.logger = SemanticLogger::Logger.logger
-          when :udp
-            @remote_syslog = UDPSocket.new
-          else
-            raise "Unsupported protocol: #{protocol}"
+        when :syslog
+          ::Syslog.open(@ident, options, @facility)
+        when :tcp
+          # The resilient_socket gem is required when logging over TCP.
+          begin
+            require 'resilient_socket'
+          rescue LoadError
+            raise 'Missing gem: resilient_socket. This gem is required when logging over TCP. To fix this error: gem install resilient_socket'
+          end
+          options = tcp_client_options || {}
+          options[:server] = "#{@host}:#{@port}"
+          @remote_syslog = ResilientSocket::TCPClient.new(options)
+          # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
+          @remote_syslog.logger = SemanticLogger::Logger.logger
+        when :udp
+          @remote_syslog = UDPSocket.new
+        else
+          raise "Unsupported protocol: #{protocol}"
         end
 
         super(level, filter, &block)
@@ -201,18 +201,20 @@ module SemanticLogger
 
       # Write the log using the specified protocol and host.
       def log(log)
-        if level_index <= (log.level_index || 0)
-          case @protocol
-            when :syslog
-              ::Syslog.log @level_map[log.level], formatter.call(log)
-            when :tcp
-              @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{syslog_packet_formatter(log)}\r\n") }
-            when :udp
-              @remote_syslog.send syslog_packet_formatter(log), 0, @host, @port
-            else
-              raise "Unsupported protocol: #{protocol}"
-          end
+        # Ensure minimum log level is met, and check filter
+        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+
+        case @protocol
+        when :syslog
+          ::Syslog.log @level_map[log.level], formatter.call(log)
+        when :tcp
+          @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{syslog_packet_formatter(log)}\r\n") }
+        when :udp
+          @remote_syslog.send syslog_packet_formatter(log), 0, @host, @port
+        else
+          raise "Unsupported protocol: #{protocol}"
         end
+        true
       end
 
       # Flush is called by the semantic_logger during shutdown.

data/lib/semantic_logger/appender/wrapper.rb

@@ -40,7 +40,12 @@ module SemanticLogger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
+        # Check filter
+        return false unless include_message?(log)
+
+        # Underlying wrapper logger implements log level, so don't check here
         @logger.send(log.level == :trace ? :debug : log.level, @formatter.call(log))
+        true
       end
 
       # Flush all pending logs to disk.

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.9.0"
+  VERSION = "2.9.1"
 end

data/test/logger_test.rb

@@ -12,13 +12,14 @@ class LoggerTest < Test::Unit::TestCase
   context SemanticLogger::Logger do
     # Test each filter
     [ nil, /\ALogger/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
-      context "filter: #{filter.inspect}" do
+      context "filter: #{filter.class.name}" do
         setup do
           # Use a mock logger that just keeps the last logged entry in an instance
           # variable
           SemanticLogger.default_level = :trace
           @mock_logger = MockLogger.new
-          SemanticLogger.add_appender(@mock_logger)
+          appender = SemanticLogger.add_appender(@mock_logger)
+          appender.filter = filter
 
           # Add mock metric subscriber
           $last_metric = nil
@@ -27,7 +28,7 @@ class LoggerTest < Test::Unit::TestCase
           end
 
           # Use this test's class name as the application name in the log output
-          @logger   = SemanticLogger::Logger.new(self.class, :trace, filter)
+          @logger   = SemanticLogger[self.class]
           @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
           @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
           assert_equal [], @logger.tags
@@ -54,6 +55,16 @@ class LoggerTest < Test::Unit::TestCase
                 assert_nil @mock_logger.message
               end
             end
+
+            should "exclude log messages using RegExp filter" do
+              if filter.is_a?(Regexp)
+                logger = SemanticLogger::Logger.new('NotLogger', :trace, filter)
+                logger.send(level, 'Ignore all log messages from this class', @hash) { "Calculations" }
+                SemanticLogger.flush
+                assert_nil @mock_logger.message
+              end
+            end
+
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.9.1
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2014-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr