semantic_logger 2.12.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a76d0de5e08c9768042187ab19b2546d5c91b3a
-  data.tar.gz: b04d51de5d531ec57ce382e77ddfd21bd69a420a
+  metadata.gz: 0e66e26770a5132bf299fe3b539af221ca75b0ae
+  data.tar.gz: 3f116e726cb8a76dda143f0b960cc9cc879be953
 SHA512:
-  metadata.gz: 7fc60fcfef8e8c255720de4a4972ae2f0b919dd022eccc68afef004ad1f3fd0870f6c4adc54d190d0ff109a6671be910dbfafdf63f9ade57e9c8caedc66bead1
-  data.tar.gz: 2c73e2cf3ac75e19097a3acb6b0437df745c4d60e7c8c3a5a02ef846a9b1ba1b16e37b49e07bbde4851c4ba77e63c1d22e027bf65ea3882150c1608f98db0f93
+  metadata.gz: 04f53db9e8ed15857bc9d0c2ce127ff1b0cc343fff8c5f43ca7bf0b7759e0ca69dd3415c3688fd807922f85e4d838bad3ecf1de499ee8dcd44c656bd9015c494
+  data.tar.gz: 9654f21ce94245806887850ec16ce506698262c6e70c31fc237ec090f054a76c23db743caca0927161e03ea528b5448a070d2fabe257e956ad45d164d6181cc6

data/lib/LogGC.java

@@ -0,0 +1,26 @@
+            //get all the info and pretty print it
+            duration =
+            //System.out.println("GcInfo CompositeType: " + info.getGcInfo().getCompositeType());
+            //System.out.println("GcInfo MemoryUsageAfterGc: " + info.getGcInfo().getMemoryUsageAfterGc());
+            //System.out.println("GcInfo MemoryUsageBeforeGc: " + info.getGcInfo().getMemoryUsageBeforeGc());
+
+            //Get the information about each memory space, and pretty print it
+            Map<String, MemoryUsage> membefore = info.getGcInfo().getMemoryUsageBeforeGc();
+            Map<String, MemoryUsage> mem = info.getGcInfo().getMemoryUsageAfterGc();
+            for (Entry<String, MemoryUsage> entry : mem.entrySet()) {
+              String name = entry.getKey();
+              MemoryUsage memdetail = entry.getValue();
+              long memInit = memdetail.getInit();
+              long memCommitted = memdetail.getCommitted();
+              long memMax = memdetail.getMax();
+              long memUsed = memdetail.getUsed();
+              MemoryUsage before = membefore.get(name);
+              long beforepercent = ((before.getUsed() * 1000L) / before.getCommitted());
+              long percent = ((memUsed * 1000L) / before.getCommitted()); //>100% when it gets expanded
+
+              System.out.print(name + (memCommitted == memMax ? "(fully expanded)" : "(still expandable)") + "used: " + (beforepercent / 10) + "." + (beforepercent % 10) + "%->" + (percent / 10) + "." + (percent % 10) + "%(" + ((memUsed / 1048576) + 1) + "MB) / ");
+            }
+            System.out.println();
+            totalGcDuration += info.getGcInfo().getDuration();
+            long percent = totalGcDuration * 1000L / info.getGcInfo().getEndTime();
+            System.out.println("GC cumulated overhead " + (percent / 10) + "." + (percent % 10) + "%");

data/lib/LogGC_1.java

@@ -0,0 +1,68 @@
+//
+// http://docs.oracle.com/javase/7/docs/jre/api/management/extension/com/sun/management/GarbageCollectionNotificationInfo.html
+public class LogGC {
+
+  public static void installGCMonitoring() {
+    //get all the GarbageCollectorMXBeans - there's one for each heap generation
+    //so probably two - the old generation and young generation
+    List<GarbageCollectorMXBean> gcbeans = java.lang.management.ManagementFactory.getGarbageCollectorMXBeans();
+    //Install a notifcation handler for each bean
+    for (GarbageCollectorMXBean gcbean : gcbeans) {
+      System.out.println(gcbean);
+      NotificationEmitter emitter = (NotificationEmitter) gcbean;
+      //use an anonymously generated listener for this example
+      // - proper code should really use a named class
+      NotificationListener listener = new NotificationListener() {
+        //keep a count of the total time spent in GCs
+        long totalGcDuration = 0;
+
+        //implement the notifier callback handler
+        @Override
+        public void handleNotification(Notification notification, Object handback) {
+          //we only handle GARBAGE_COLLECTION_NOTIFICATION notifications here
+          if (notification.getType().equals(GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION)) {
+            //get the information associated with this notification
+            GarbageCollectionNotificationInfo info = GarbageCollectionNotificationInfo.from((CompositeData) notification.getUserData());
+            //get all the info and pretty print it
+            long duration = info.getGcInfo().getDuration();
+            String gctype = info.getGcAction();
+            if ("end of minor GC".equals(gctype)) {
+              gctype = "Young Gen GC";
+            } else if ("end of major GC".equals(gctype)) {
+              gctype = "Old Gen GC";
+            }
+            System.out.println();
+            System.out.println(gctype + ": - " + info.getGcInfo().getId() + " " + info.getGcName() + " (from " + info.getGcCause() + ") " + duration + " microseconds; start-end times " + info.getGcInfo().getStartTime() + "-" + info.getGcInfo().getEndTime());
+            //System.out.println("GcInfo CompositeType: " + info.getGcInfo().getCompositeType());
+            //System.out.println("GcInfo MemoryUsageAfterGc: " + info.getGcInfo().getMemoryUsageAfterGc());
+            //System.out.println("GcInfo MemoryUsageBeforeGc: " + info.getGcInfo().getMemoryUsageBeforeGc());
+
+            //Get the information about each memory space, and pretty print it
+            Map<String, MemoryUsage> membefore = info.getGcInfo().getMemoryUsageBeforeGc();
+            Map<String, MemoryUsage> mem = info.getGcInfo().getMemoryUsageAfterGc();
+            for (Entry<String, MemoryUsage> entry : mem.entrySet()) {
+              String name = entry.getKey();
+              MemoryUsage memdetail = entry.getValue();
+              long memInit = memdetail.getInit();
+              long memCommitted = memdetail.getCommitted();
+              long memMax = memdetail.getMax();
+              long memUsed = memdetail.getUsed();
+              MemoryUsage before = membefore.get(name);
+              long beforepercent = ((before.getUsed() * 1000L) / before.getCommitted());
+              long percent = ((memUsed * 1000L) / before.getCommitted()); //>100% when it gets expanded
+
+              System.out.print(name + (memCommitted == memMax ? "(fully expanded)" : "(still expandable)") + "used: " + (beforepercent / 10) + "." + (beforepercent % 10) + "%->" + (percent / 10) + "." + (percent % 10) + "%(" + ((memUsed / 1048576) + 1) + "MB) / ");
+            }
+            System.out.println();
+            totalGcDuration += info.getGcInfo().getDuration();
+            long percent = totalGcDuration * 1000L / info.getGcInfo().getEndTime();
+            System.out.println("GC cumulated overhead " + (percent / 10) + "." + (percent % 10) + "%");
+          }
+        }
+      };
+
+      //Add the listener
+      emitter.addNotificationListener(listener, null, null);
+    }
+  }
+}

data/lib/semantic_logger.rb

@@ -17,6 +17,12 @@ module SemanticLogger
     autoload :NewRelic, 'semantic_logger/appender/new_relic'
     autoload :Splunk,   'semantic_logger/appender/splunk'
   end
+
+  if defined?(JRuby)
+    module JRuby
+      autoload :GarbageCollectionLogger, 'semantic_logger/jruby/garbage_collection_logger'
+    end
+  end
 end
 
 # Flush all appenders at exit, waiting for outstanding messages on the queue

data/lib/semantic_logger/base.rb

@@ -181,6 +181,50 @@ module SemanticLogger
     alias :unknown :error
     alias :unknown? :error?
 
+    # Silence noisy log levels by changing the default_level within the block
+    #
+    # This setting is thread-safe and only applies to the current thread
+    #
+    # Any threads spawned within the block will not be affected by this setting
+    #
+    # #silence can be used to both raise and lower the log level within
+    # the supplied block.
+    #
+    # Example:
+    #
+    #   # Perform trace level logging within the block when the default is higher
+    #   SemanticLogger.default_level = :info
+    #
+    #   logger.debug 'this will _not_ be logged'
+    #
+    #   logger.silence(:trace) do
+    #     logger.debug "this will be logged"
+    #   end
+    #
+    # Parameters
+    #   new_level
+    #     The new log level to apply within the block
+    #     Default: :error
+    #
+    # Example:
+    #   # Silence all logging below :error level
+    #   logger.silence do
+    #     logger.info "this will _not_ be logged"
+    #     logger.warn "this neither"
+    #     logger.error "but errors will be logged"
+    #   end
+    #
+    # Note:
+    #   #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]
+      Thread.current[:semantic_logger_silence] = SemanticLogger.level_to_index(new_level)
+      yield
+    ensure
+      Thread.current[:semantic_logger_silence] = current_index
+    end
+
     # DEPRECATED See SemanticLogger.default_level=
     def self.default_level=(level)
       warn "[DEPRECATION] `SemanticLogger::Logger.default_level=` is deprecated.  Please use `SemanticLogger.default_level=` instead."
@@ -312,9 +356,17 @@ module SemanticLogger
     def benchmark_internal(level, index, message, params, &block)
       start     = Time.now
       begin
-        rc = block.call(params) if block
-        exception = params[:exception]
-        rc
+        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
+          exception = params[:exception]
+          result
+        end
       rescue Exception => exc
         exception = exc
       ensure

data/lib/semantic_logger/jruby/garbage_collection_logger.rb

@@ -0,0 +1,27 @@
+module SemanticLogger
+  module JRuby
+    class GarbageCollectionLogger
+      include Java::JavaxManagement::NotificationListener
+
+      # Only log the garbage collection if the number of microseconds exceeds
+      # this value
+      def initialize(min_microseconds = 10000)
+        @min_microseconds = min_microseconds
+      end
+
+      # Must leave the method name as-is so that it can be found by Java
+      def handleNotification(notification, _)
+        # 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
+        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
+        end
+      end
+    end
+
+  end
+end

data/lib/semantic_logger/semantic_logger.rb

@@ -152,23 +152,65 @@ module SemanticLogger
     SemanticLogger::Logger.on_metric(&block)
   end
 
-  # Add a signal handler so that the log level can be changed externally
-  # without restarting the process
+  # Add signal handlers for Semantic Logger
   #
-  # When the signal is raised on this process, the global default log level
-  # rotates through the following log levels in the following order, starting
-  # from the current global default level:
-  #   :warn, :info, :debug, :trace
+  # Two signal handlers will be registered by default:
   #
-  # If the current level is :trace it wraps around back to :warn
-  def self.add_signal_handler(signal='USR2')
-    Signal.trap(signal) do
+  # 1. Changing the log_level:
+  #
+  #   The log level can be changed without restarting the process by sending the
+  #   log_level_signal, which by default is 'USR2'
+  #
+  #   When the log_level_signal is raised on this process, the global default log level
+  #   rotates through the following log levels in the following order, starting
+  #   from the current global default level:
+  #     :warn, :info, :debug, :trace
+  #
+  #   If the current level is :trace it wraps around back to :warn
+  #
+  # 2. Logging a Ruby thread dump
+  #
+  #   When the signal is raised on this process, Semantic Logger will write the list
+  #   of threads to the log file, along with their back-traces when available
+  #
+  #   For JRuby users this thread dump differs form the standard QUIT triggered
+  #   Java thread dump which includes system threads and Java stack traces.
+  #
+  #   It is recommended to name any threads you create in the application, by
+  #   calling the following from within the thread itself:
+  #      Thread.current.name = 'My Worker'
+  #
+  # Also adds JRuby Garbage collection logging so that any garbage collections
+  # that exceed the time threshold will be logged. Default: 10 ms
+  # Currently only supported when running JRuby
+  #
+  # 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=10000)
+    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['Ruby Thread Dump']
+      Thread.list.each do |thread|
+        backtrace = thread.backtrace ? thread.backtrace.join("\n") : ''
+        logger.warn "#{thread.name}\n#{backtrace}"
+      end
+    end if thread_dump_signal
+
+    if gc_log_microseconds && defined?(JRuby)
+      listener = SemanticLogger::JRuby::GarbageCollectionLogger.new(gc_log_microseconds)
+      Java::JavaLangManagement::ManagementFactory.getGarbageCollectorMXBeans.each do |gcbean|
+        gcbean.add_notification_listener(listener, nil, nil)
+      end
     end
-    signal
+
+    true
   end
 
   ############################################################################
@@ -180,7 +222,7 @@ module SemanticLogger
   private
 
   def self.default_level_index
-    @@default_level_index
+    Thread.current[:semantic_logger_silence] || @@default_level_index
   end
 
   # Returns the symbolic level for the supplied level index

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.12.0"
+  VERSION = "2.13.0"
 end

data/test/logger_test.rb

@@ -216,6 +216,29 @@ class LoggerTest < Minitest::Test
             SemanticLogger.flush
             assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
           end
+
+          should 'not log at a level below the silence level' do
+            SemanticLogger.default_level = :info
+            @logger.benchmark_info('hello world', silence: :error) do
+              @logger.warn "don't log me"
+            end
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+          end
+
+          should 'log at a silence level below the default level' do
+            SemanticLogger.default_level = :info
+            first_message = nil
+            @logger.benchmark_info('hello world', silence: :trace) do
+              @logger.debug('hello world', @hash) { "Calculations" }
+              SemanticLogger.flush
+              first_message = @mock_logger.message
+            end
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, first_message
+            SemanticLogger.flush
+            # Only the last log message is kept in mock logger
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+          end
         end
 
         context '.default_level' do
@@ -224,6 +247,7 @@ class LoggerTest < Minitest::Test
           end
 
           should 'not log at a level below the global default' do
+            assert_equal :debug, SemanticLogger.default_level
             assert_equal :debug, @logger.level
             @logger.trace('hello world', @hash) { "Calculations" }
             SemanticLogger.flush
@@ -231,6 +255,7 @@ class LoggerTest < Minitest::Test
           end
 
           should 'log at the instance level' do
+            assert_equal :debug, SemanticLogger.default_level
             @logger.level = :trace
             assert_equal :trace, @logger.level
             @logger.trace('hello world', @hash) { "Calculations" }
@@ -239,6 +264,7 @@ class LoggerTest < Minitest::Test
           end
 
           should 'not log at a level below the instance level' do
+            assert_equal :debug, SemanticLogger.default_level
             @logger.level = :warn
             assert_equal :warn, @logger.level
             @logger.debug('hello world', @hash) { "Calculations" }
@@ -247,6 +273,45 @@ class LoggerTest < Minitest::Test
           end
         end
 
+        context '.silence' do
+          setup do
+            SemanticLogger.default_level = :info
+          end
+
+          should 'not log at a level below the silence level' do
+            assert_equal :info, SemanticLogger.default_level
+            assert_equal :info, @logger.level
+            @logger.silence do
+              @logger.warn('hello world', @hash) { "Calculations" }
+              @logger.info('hello world', @hash) { "Calculations" }
+              @logger.debug('hello world', @hash) { "Calculations" }
+              @logger.trace('hello world', @hash) { "Calculations" }
+            end
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+
+          should 'log at the instance level even with the silencer at a higher level' do
+            @logger.level = :trace
+            assert_equal :trace, @logger.level
+            @logger.silence do
+              @logger.trace('hello world', @hash) { "Calculations" }
+            end
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+          end
+
+          should 'log at a silence level below the default level' do
+            assert_equal :info, SemanticLogger.default_level
+            assert_equal :info, @logger.level
+            @logger.silence(:debug) do
+              @logger.debug('hello world', @hash) { "Calculations" }
+            end
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+          end
+        end
+
         context '.level?' do
           should 'return true for debug? with :trace level' do
             SemanticLogger.default_level = :trace

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -49,6 +49,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/LogGC.java
+- lib/LogGC_1.java
 - lib/semantic_logger.rb
 - lib/semantic_logger/appender/base.rb
 - lib/semantic_logger/appender/file.rb
@@ -60,6 +62,7 @@ files:
 - lib/semantic_logger/base.rb
 - lib/semantic_logger/core_ext/thread.rb
 - lib/semantic_logger/debug_as_trace_logger.rb
+- lib/semantic_logger/jruby/garbage_collection_logger.rb
 - lib/semantic_logger/loggable.rb
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/semantic_logger.rb