logging 1.8.0 → 1.8.1

data/History.txt

@@ -1,3 +1,9 @@
+== 1.8.1 / 2013-01-02
+
+Bug Fixes
+- Diagnostic context thread inheritance [issue #56]
+- Fixing trace reporting in JRuby 1.7
+
 == 1.8.0 / 2012-09-13
 
 Enhancements

data/README.rdoc

@@ -79,10 +79,12 @@ There are many more examples in the "examples" folder of the logging
 package. The recommended reading order is the following:
 
 * {simple.rb}[https://github.com/TwP/logging/blob/master/examples/simple.rb]
+* {rspec_integration.rb}[https://github.com/TwP/logging/blob/master/examples/rspec_integration.rb]
 * {loggers.rb}[https://github.com/TwP/logging/blob/master/examples/loggers.rb]
 * {classes.rb}[https://github.com/TwP/logging/blob/master/examples/classes.rb]
 * {hierarchies.rb}[https://github.com/TwP/logging/blob/master/examples/hierarchies.rb]
 * {names.rb}[https://github.com/TwP/logging/blob/master/examples/names.rb]
+* {lazy.rb}[https://github.com/TwP/logging/blob/master/examples/lazy.rb]
 * {appenders.rb}[https://github.com/TwP/logging/blob/master/examples/appenders.rb]
 * {layouts.rb}[https://github.com/TwP/logging/blob/master/examples/layouts.rb]
 * {formatting.rb}[https://github.com/TwP/logging/blob/master/examples/formatting.rb]

data/examples/custom_log_levels.rb

@@ -0,0 +1,53 @@
+# :stopdoc:
+#
+# It's useful to define custom log levels that denote success, or otherwise
+# meaningful events that happen to not be negative (more than 50% of the
+# levels are given to warn, error, fail - quite a pessimistic view of one's
+# application's chances of success, no?  ;-) )
+#
+# Here, we define two new levels, 'happy' and 'success' and make them soothing
+# colours.
+#
+
+  require 'logging'
+
+  # https://github.com/TwP/logging/blob/master/lib/logging.rb#L250-285
+  # The levels run from lowest level to highest level.
+
+  Logging.init :debug, :info, :happy, :warn, :success, :error, :fatal
+
+  Logging.color_scheme( 'soothing_ish',
+    :levels => {
+      :info  => :cyan,
+      :happy => :green,
+      :warn  => :yellow,
+      :success => [:blue],
+      :error => :red,
+      :fatal => [:white, :on_red]
+    },
+    :date => :cyan,
+    :logger => :cyan,
+    :message => :orange
+  )
+
+  Logging.appenders.stdout(
+    'stdout',
+    :layout => Logging.layouts.pattern(
+      :pattern => '[%d] %-7l %c: %m\n',
+      :color_scheme => 'soothing_ish'
+    )
+  )
+
+  log = Logging.logger['Soothing::Colors']
+  log.add_appenders 'stdout'
+  log.level = :debug
+
+  log.debug   'a very nice little debug message'
+  log.info    'things are operating nominally'
+  log.happy   'What a beautiful day'
+  log.warn    'this is your last warning'
+  log.success 'I am INWEENCIBLE!!'
+  log.error   StandardError.new('something went horribly wrong')
+  log.fatal   'I Die!'
+
+# :startdoc:

data/examples/lazy.rb

@@ -0,0 +1,45 @@
+# :stopdoc:
+#
+# It happens sometimes that it is very expensive to construct a logging
+# message; for example, if a large object structure has to be traversed
+# during executing of an `object.to_s` method. It would be convenient to
+# delay creation of the message until the log event actually takes place.
+#
+# For example, with a logger configured only to show WARN messages and higher,
+# creating the log message for an INFO message would be wasteful. The INFO log
+# event would never be generated in this case.
+#
+# Log message creation can be performed lazily by wrapping the expensive
+# message generation code in a block and passing that to the logging method.
+
+  require 'logging'
+
+  Logging.logger.root.appenders = Logging.appenders.stdout
+  Logging.logger.root.level = :info
+
+  # We use this dummy method in order to see if the method gets called, but in practice,
+  # this method might do complicated string operations to construct a log message.
+  def expensive_method
+    puts "Called!"
+    "Expensive message"
+  end
+
+  log = Logging.logger['Lazy']
+
+  # If you log this message the usual way, expensive_method gets called before
+  # debug, hence the Logging framework has no chance to stop it from being executed
+  # immediately.
+  log.info("Normal")
+  log.debug(expensive_method)
+
+  # If we put the message into a block, then the block is not executed, if
+  # the message is not needed with the current log level.
+  log.info("Block unused")
+  log.debug { expensive_method }
+
+  # If the log message is needed with the current log level, then the block is of
+  # course executed and the log message appears as expected.
+  log.info("Block used")
+  log.warn { expensive_method }
+
+# :startdoc:

data/examples/rspec_integration.rb

@@ -0,0 +1,38 @@
+# :stopdoc:
+#
+# One useful feature of log messages in your code is that they provide a
+# convenient instrumentation point for testing. Through log messages you can
+# confirm that internal methods were called or that certain code paths were
+# executed. This example demonstrates how to capture log output during testing
+# for later analysis.
+#
+# The Logging framework provides an RSpec helper that will direct log output
+# to a StringIO appender. Log lines can be read from this IO destination
+# during tests.
+#
+
+  require 'rspec'
+  require 'logging'
+  require 'rspec/logging_helper'
+
+  # Configure RSpec to capture log messages for each test. The output from the
+  # logs will be stored in the @log_output variable. It is a StringIO instance.
+  RSpec.configure do |config|
+    include RSpec::LoggingHelper
+    config.capture_log_messages
+  end
+
+  # Now within your specs you can check that various log events were generated.
+  describe 'SuperLogger' do
+    it 'should be able to read a log message' do
+      logger = Logging.logger['SuperLogger']
+
+      logger.debug 'foo bar'
+      logger.warn  'just a little warning'
+
+      @log_output.readline.should be == 'DEBUG SuperLogger: foo bar'
+      @log_output.readline.should be == 'WARN  SuperLogger: just a little warning'
+    end
+  end
+
+# :startdoc:

data/lib/logging/diagnostic_context.rb

@@ -307,17 +307,17 @@ class Thread
     # then they cannot be garbage collected until the child thread exits.
     #
     def create_with_logging_context( m, *a, &b )
-      p_mdc, p_ndc = nil
+      mdc, ndc = nil
 
       if Thread.current[Logging::MappedDiagnosticContext::NAME]
-        p_mdc = Thread.current[Logging::MappedDiagnosticContext::NAME].dup
+        mdc = Thread.current[Logging::MappedDiagnosticContext::NAME].dup
       end
 
       if Thread.current[Logging::NestedDiagnosticContext::NAME]
-        p_ndc = Thread.current[Logging::NestedDiagnosticContext::NAME].dup
+        ndc = Thread.current[Logging::NestedDiagnosticContext::NAME].dup
       end
 
-      self.send(m, p_mdc, p_ndc, *a) { |mdc, ndc, *args|
+      self.send(m, *a) { |*args|
         Logging::MappedDiagnosticContext.inherit(mdc)
         Logging::NestedDiagnosticContext.inherit(ndc)
         b.call(*args)

data/lib/logging/log_event.rb

@@ -13,7 +13,7 @@ module Logging
     # * $3 == method name (might be nil)
     CALLER_RGXP = %r/([-\.\/\(\)\w]+):(\d+)(?::in `(\w+)')?/o
     #CALLER_INDEX = 2
-    CALLER_INDEX = ((defined? JRUBY_VERSION and JRUBY_VERSION[%r/^1.6/]) or (defined? RUBY_ENGINE and RUBY_ENGINE[%r/^rbx/i])) ? 1 : 2
+    CALLER_INDEX = ((defined? JRUBY_VERSION and JRUBY_VERSION > '1.6') or (defined? RUBY_ENGINE and RUBY_ENGINE[%r/^rbx/i])) ? 1 : 2
     # :startdoc:
 
     # call-seq:

data/test/layouts/test_yaml.rb

@@ -98,7 +98,7 @@ module TestLayouts
       assert_match %r/\A--- ?\nthread_id: -?\d+\n\z/, @layout.format(event)
 
       @layout.items = %w[thread]
-      assert_match %r/\A--- ?\nthread: \n/, @layout.format(event)
+      assert_match %r/\A--- ?\nthread: ?\n/, @layout.format(event)
       Thread.current[:name] = "Main"
       assert_match %r/\A--- ?\nthread: Main\n/, @layout.format(event)
 

data/version.txt

@@ -1 +1 @@
-1.8.0
+1.8.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logging
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
+date: 2013-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: little-plugger
@@ -120,13 +120,16 @@ files:
 - examples/classes.rb
 - examples/colorization.rb
 - examples/consolidation.rb
+- examples/custom_log_levels.rb
 - examples/fork.rb
 - examples/formatting.rb
 - examples/hierarchies.rb
 - examples/layouts.rb
+- examples/lazy.rb
 - examples/loggers.rb
 - examples/mdc.rb
 - examples/names.rb
+- examples/rspec_integration.rb
 - examples/simple.rb
 - lib/logging.rb
 - lib/logging/appender.rb