gem_logger 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTIzNzQ0NzlhNDdlMjkzMDk5NDM1ZTBjZWU3NmYxN2ZmMzhmNWQ1OQ==
-  data.tar.gz: !binary |-
-    MmFkOTczODI3NGFjZTczNWEzOTk2OTU4N2Q4MWY2ZDdmYTgyYTBkMQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    YmU1OWJkMTFmMTg5MWExNDYwMzJjOWQ2OWM4N2ViZTI1ZDU3ZDQyM2MzOTc4
-    ZDBlZGVjODBhMGIwNTk3MmM0NzFkNGNjMTZlNTcxMGJmMTBkZWU4MTI0ZjYy
-    OTE1NDBlYzRiNjZhYmJiZWU2MDA0MmYxY2U2OGVjZjgwZjU1MzA=
-  data.tar.gz: !binary |-
-    MzYzZmMxYzAzYTZjOTRmNjUyOWI4YWY5NGRjYjZiNDhiNzM2OTdhMDAwNzdk
-    NzI4ZDhkZGY5OTBhZWY2MDI4ZjdlY2E2MzNiNzNlYzFhYzc0ZjljM2YxZGIx
-    NWEzODBlZDcxY2FkMTQ5MzQxNTlhNjdlYjc4Njc1NTI1ODMwMGY=
+SHA1:
+  metadata.gz: cac9834fee2a3e0b443c0385601b22831093517f
+  data.tar.gz: 312e92da1a677e310c80b02b42ccb94cce8cfa52
+SHA512:
+  metadata.gz: 31460132ab3adec8fa05f3457cdf1b39629b7870aa86a5f3a619e43661afeb66f11b0f94cb55e7a13a50089e8e0c51637c3112456b64201ea6ef4f652eb5db53
+  data.tar.gz: 09e7ed4a79a2ee5ab9e5cb45e8781b021cfd249148a21f6d99883a1dd98fe453b41f83275058de4f6092596850b5107613070b28e805cfdd352c890a250c85bb

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+/.idea

data/.travis.yml

@@ -2,7 +2,12 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.1
   - jruby-19mode
-  - rbx-19mode
+  - rbx
   
 script: bundle exec rake
+
+matrix:
+  allow_failures:
+    - rvm: rbx

data/Gemfile

@@ -2,9 +2,10 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in gem_logger.gemspec
 gemspec
-
 # so we can test GemLogger.logger_concern
 gem "lumber", :require => false
 
 # for code coverage during travis-ci test runs
 gem 'coveralls', :require => false
+
+gem "mocha", :require => false

data/README.md

@@ -21,3 +21,29 @@ Include the GemLogger::Logger concern into the classes that need to be able to l
     
     end
 
+## Context
+
+It is also possible to add context to your log messages through the context call:
+
+    MyClass.logger.context(:key => 'value').debug("I want context here")
+    
+as well as include backtraces and context to exceptions by calling the log_exception method with the error and a custom message:
+
+    MyClass.logger.log_exception(StandardError.new('uh oh'), 'This is bad')
+    
+By default, log_exception uses the ERROR level, but also accepts a level as an option:
+
+    MyClass.logger.log_exception(StandardError.new('uh oh'), 'This is bad', {:level => :debug})
+    
+Unless otherwise specified, the context is added to the beginning of the log message in a basic key = value format. You can, however, define your own context handler, and pass it in on initialization:
+
+    GemLogger.configure do |config| do
+      config.context_handler = MyHandler
+    end
+
+The class should implement:
+  get_context - initialize and return the context
+  add_to_context(key, val) - add a given value to the context at key
+  remove_from_context(key) - remove the key from the context
+  format_msg_with_context(msg) - takes the base log message and adds the context to it, returning the final message.
+

data/gem_logger.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest", "~> 4.0"
   spec.add_development_dependency "minitest_should"
   spec.add_development_dependency "minitest-reporters"
   spec.add_development_dependency "factory_girl"

data/lib/gem_logger.rb

@@ -2,51 +2,10 @@ require "gem_logger/version"
 
 require 'logger'
 require 'active_support/concern'
+require 'active_support/core_ext/object'
 require 'active_support/core_ext/module/delegation'
 
 require "gem_logger/basic_logger"
+require "gem_logger/context_handler"
+require "gem_logger/gem_logger"
 require "gem_logger/logger_support"
-
-# To configure gem_logger, add something like the
-# following to an initializer (defaults shown):
-#
-#    GemLogger.configure do |config|
-#
-#      # The default logger instance to use
-#      # (optional, defaults to Logger.new) 
-#      config.default_logger = CustomLogger.new
-#
-#      # module to include when GemLogger::LoggerSupport is included
-#      # (optional, defaults to GemLogger::BasicLogger) 
-#      config.logger_concern = SomeModule
-#
-#    end
-#
-module GemLogger
-  
-  # Allows configuring via class accessors
-  class << self
-    # The logger concern (ActiveSupport::Concern) to include when clients include GemLogger::Logger
-    # The module needs to cause a class level "logger" method (returning the logger instance) to be deSupportfined on the client
-    attr_accessor :logger_concern
-  end
-  
-  # default values
-  self.logger_concern = GemLogger::BasicLogger
-
-  # The default_logger to use with GemLogger::BasicLogger
-  def self.default_logger
-    @default_logger ||= ::Logger.new(STDOUT)
-  end
-
-  # Set the default_logger to use with GemLogger::BasicLogger
-  def self.default_logger=(default_logger)
-    @default_logger = default_logger
-  end
-  
-  # Allows configuring via class accessors
-  def self.configure
-    yield self
-  end
-  
-end

data/lib/gem_logger/basic_logger.rb

@@ -10,7 +10,7 @@ module GemLogger
         GemLogger::default_logger
       end
     end
-    
+
   end
-  
+
 end

data/lib/gem_logger/context_handler.rb

@@ -0,0 +1,31 @@
+module GemLogger
+  module ContextHandler
+    extend ActiveSupport::Concern
+
+    # Initializes and returns context hash.
+    def get_context
+      @context_hash ||= {}
+    end
+
+    def add_to_context(key, value)
+      @context_hash[key.to_s] = value.to_s
+    end
+
+    def remove_from_context(key)
+      @context_hash.delete(key.to_s)
+    end
+
+    # Adds the keys/values to the message to be logged in a basic [key=val] format.
+    def format_msg_with_context(msg)
+      if @context_hash.keys.length > 0
+        msg_context = '['
+        @context_hash.each do |k, v|
+          msg_context += "#{k}=#{v} "
+        end
+        msg_context += '] '
+        msg = msg.prepend(msg_context)
+      end
+      msg
+    end
+  end
+end

data/lib/gem_logger/gem_logger.rb

@@ -0,0 +1,45 @@
+# To configure gem_logger, add something like the
+# following to an initializer (defaults shown):
+#
+#    GemLogger.configure do |config|
+#
+#      # The default logger instance to use
+#      # (optional, defaults to Logger.new)
+#      config.default_logger = CustomLogger.new
+#
+#      # module to include when GemLogger::LoggerSupport is included
+#      # (optional, defaults to GemLogger::BasicLogger)
+#      config.logger_concern = SomeModule
+#
+#    end
+#
+module GemLogger
+
+  # Allows configuring via class accessors
+  class << self
+    # The logger concern (ActiveSupport::Concern) to include when clients include GemLogger::Logger
+    # The module needs to cause a class level "logger" method (returning the logger instance) to be defined on the client
+    attr_accessor :logger_concern
+    attr_accessor :context_handler
+  end
+
+  # default values
+  self.logger_concern = GemLogger::BasicLogger
+  self.context_handler = GemLogger::ContextHandler
+
+  # The default_logger to use with GemLogger::BasicLogger
+  def self.default_logger
+    @default_logger ||= ::Logger.new(STDOUT).extend(LoggerSupport::LogContext)
+  end
+
+  # Set the default_logger to use with GemLogger::BasicLogger
+  def self.default_logger=(default_logger)
+    @default_logger = default_logger
+  end
+
+  # Allows configuring via class accessors
+  def self.configure
+    yield self
+  end
+
+end

data/lib/gem_logger/logger_support.rb

@@ -1,21 +1,21 @@
 module GemLogger
   module LoggerSupport
-    
+
     extend ActiveSupport::Concern
-  
+
     included do
       # A guard to prevent misuse, may just want a log message instead of a hard fail
       if self.class == Module && ! self.singleton_class.included_modules.include?(ActiveSupport::Concern)
         raise ArgumentError, "module that includes #{self.name} must be an ActiveSupport::Concern"
       end
-      
+
       include GemLogger.logger_concern
-      
-      delegate :logger, :log_exception, :log_warning, :log_message, :to => "self.class"      
+
+      delegate :logger, :log_exception, :log_warning, :log_message, :to => "self.class"
     end
-        
-    module ClassMethods
 
+    module ClassMethods
+      # @deprecated Consider using {#logger.context(:exception => exception.class).error("Exception: ...")} instead
       def log_exception(exception, opts={})
         logger.error("Exception #{generate_message(exception, opts)}")
       end
@@ -44,7 +44,71 @@ module GemLogger
 
         "#{log_encode(message_prefix)}#{log_encode(exception.inspect)}, #{log_encode(opts.inspect)}:\n#{exception.backtrace.collect {|x| log_encode(x)}.join("\n") rescue 'no backtrace'}"
       end
-      
+
+    end
+
+
+    module ContextLoggerCommon
+      # @param [Hash] added_context - A hash containing context that will be added to the log messages produced by the
+      # returned logger
+      # @returns [LogContextLogger] - logger with the added context
+      def context(added_context)
+        LogContextLogger.new(self.logger, self.log_context.merge(added_context))
+      end
+
+      # Adds an event_type to the context
+      # @param [Symbol] event_type - The event type, which will be added to the context of this log statement
+      def event_context(event_type)
+        context(:event_type => event_type)
+      end
+
+      # Adds an exception class to the context
+      # @param [Exception] exception
+      def exception_context(exception)
+        context(:exception => exception.class.to_s)
+      end
+
+      # Logs an exception, including the backtrace.
+      # @param [Exception] exception
+      # @param [String] message
+      # @option [Symbol] :level - The log level to log the message at (default :error)
+      def log_exception(e, message, options = {})
+        level = options.delete(:level) || :error
+        backtrace = e.backtrace.try{ |b| b.join("\n") } || '(no backtrace)'
+        exception_context(e).send(level, "#{message}: #{e} #{backtrace}")
+      end
+    end
+
+    # The base context logger.
+    module LogContext
+      include ContextLoggerCommon
+
+      def log_context
+        {}
+      end
+
+      def logger
+        self
+      end
+    end
+
+    LogContextLogger = Struct.new(:logger, :log_context) do
+      include ContextLoggerCommon
+      include GemLogger.context_handler
+
+      [:debug, :info, :warn, :error, :fatal].each do |method|
+        define_method(method) { |msg| self.log(method, msg) }
+      end
+
+      def log(level, msg)
+        existing_context = get_context
+        self.log_context.each { |k,v| add_to_context(k, v) }
+        msg = format_msg_with_context(msg)
+        self.logger.send(level, msg)
+      ensure
+        self.log_context.each { |k,v| remove_from_context(k) }
+        existing_context.each { |k,v| add_to_context(k, v) }
+      end
     end
 
   end

data/lib/gem_logger/version.rb

@@ -1,3 +1,3 @@
 module GemLogger
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/test_helper.rb

@@ -17,14 +17,15 @@ end
 require 'minitest/autorun'
 require 'minitest/should'
 require "minitest/reporters"
+require "mocha/setup"
 
 reporter = ENV['REPORTER']
 reporter = case reporter
-  when 'none' then nil
-  when 'spec' then MiniTest::Reporters::SpecReporter.new
-  when 'progress' then MiniTest::Reporters::ProgressReporter.new
-  else MiniTest::Reporters::DefaultReporter.new
-end
+             when 'none' then nil
+             when 'spec' then MiniTest::Reporters::SpecReporter.new
+             when 'progress' then MiniTest::Reporters::ProgressReporter.new
+             else MiniTest::Reporters::DefaultReporter.new
+           end
 MiniTest::Reporters.use!(reporter) if reporter
 
 require 'gem_logger'
@@ -36,7 +37,7 @@ class << MiniTest::Unit.runner
   # Minitest runs each context as a suite
   # Minitest filters methods by matching against: <suite>#test_0001_<should>
   # Nested contexts are separted by spaces in rubymine, but ::s in minitest
-  
+
   def _run_suites(suites, type)
     if options[:filter]
       if options[:filter] =~ /\/\\Atest\\: (.*) should (.*)\\\.\//
@@ -49,21 +50,21 @@ class << MiniTest::Unit.runner
         options[:filter] = "/\\A#{context_filter}(Test)?#test(_\\d+)?_should_#{should_filter}\\Z/"
       end
     end
-    
+
     super
   end
-  
+
   # Prevent "Empty test suite" verbosity when running in rubymine
   def _run_suite(suite, type)
-    
+
     filter = options[:filter] || '/./'
-    filter = Regexp.new $1 if filter =~ /\/(.*)\//    
+    filter = Regexp.new $1 if filter =~ /\/(.*)\//
     all_test_methods = suite.send "#{type}_methods"
     filtered_test_methods = all_test_methods.find_all { |m|
       filter === m || filter === "#{suite}##{m}"
     }
-    
-    if filtered_test_methods.size > 0    
+
+    if filtered_test_methods.size > 0
       super
     else
       [0, 0]

data/test/unit/gem_logger/context_handler_test.rb

@@ -0,0 +1,45 @@
+require_relative '../../test_helper'
+
+module GemLogger
+  class ContextHandlerTest < Minitest::Should::TestCase
+
+    setup do
+      class MyClass
+        include GemLogger::ContextHandler
+      end
+    end
+
+    should "return empty hash on get_context" do
+      assert_equal Hash.new, MyClass.new.get_context
+    end
+
+    should 'add given arguments to context on add_context' do
+      klass = MyClass.new
+      klass.get_context
+      klass.add_to_context('foo', 'bar')
+      assert_equal Hash['foo', 'bar'], klass.get_context
+    end
+
+    should "convert add_to_context args to strings" do
+      klass = MyClass.new
+      klass.get_context
+      klass.add_to_context(:foo, :bar)
+      assert_equal Hash['foo', 'bar'], klass.get_context
+    end
+
+    should "pass remove_from_context to Log4r remove" do
+      klass = MyClass.new
+      klass.get_context
+      klass.remove_from_context('foo')
+      assert_equal Hash.new, klass.get_context
+    end
+
+    should "convert remove_from_context args to strings" do
+      klass = MyClass.new
+      klass.get_context
+      klass.add_to_context('foo', 'bar')
+      klass.remove_from_context(:foo)
+      assert_equal Hash.new, klass.get_context
+    end
+  end
+end

data/test/unit/gem_logger/logger_support_test.rb

@@ -2,42 +2,42 @@ require_relative '../../test_helper'
 
 module GemLogger
   class LoggerSupportTest < Minitest::Should::TestCase
-    
+
     setup do
       @uniq = SecureRandom.uuid.gsub("-", "")
     end
-    
+
     teardown do
       LoggerSupportTest.constants.grep(/^Foo/).each do |c|
         LoggerSupportTest.send(:remove_const, c)
       end
     end
-    
+
     def new_module(module_name, &block)
       mod = self.class.const_set module_name, Module.new
       mod.class_eval(&block)
       mod
     end
-    
+
     # can't do this dynamically as the class name needs to be set at inheritance time for lumber to work
     def new_class(class_name, super_class=nil, &block)
       s = "class #{class_name}"
       s << " < #{super_class}" if super_class
       s << "; end"
-    
+
       eval(s)
       clazz = self.class.const_get(class_name)
       clazz.class_eval(&block)
       clazz
     end
-    
+
     context "BasicLogger" do
-      
+
       setup do
         @old_default_logger = GemLogger.default_logger
         GemLogger.default_logger = Minitest::Mock.new
       end
-    
+
       teardown do
         GemLogger.default_logger.verify
         GemLogger.default_logger = @old_default_logger
@@ -49,14 +49,14 @@ module GemLogger
         foo.logger.expect(:debug, nil, ['hi'])
         foo.new.member_method
       end
-    
+
       should "have a logger instance accessible from a class method " do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; logger.debug('hi'); end; }
         assert foo.respond_to?(:logger)
         foo.logger.expect(:debug, nil, ['hi'])
         foo.class_method
       end
-    
+
       should "have a logger instance when in a nested module" do
         foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
         foo = new_class("Foo#{@uniq}") { include foomod; def member_method; logger.debug('hi'); end; }
@@ -64,50 +64,50 @@ module GemLogger
         foo.logger.expect(:debug, nil, ['hi'])
         foo.new.member_method
       end
-    
+
       should "fail when included in a module that is not a Concern" do
         assert_raises(ArgumentError) do
           new_module("FooMod#{@uniq}") { include GemLogger::LoggerSupport; }
         end
       end
-      
+
       should "have a log_exception method accessible from an instance method" do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def member_method; log_exception(RuntimeError.new("hell")); end; }
         assert foo.new.respond_to?(:log_exception)
         foo.logger.expect(:error, nil, [/.*/])
         foo.new.member_method
       end
-    
+
       should "have a log_exception method accessible from a class method " do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("hell")); end; }
         assert foo.respond_to?(:log_exception)
         foo.logger.expect(:error, nil, [/.*/])
         foo.class_method
       end
-    
+
       should "log_exception should populate class name as controller and method name as action" do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("hell")); end; }
         foo.logger.expect(:error, nil, [/.*/])
         foo.class_method
       end
-    
+
       should "not raise exception on bad encoding" do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; def self.class_method; log_exception(RuntimeError.new("\xE2".force_encoding('ASCII-8BIT'))); end; }
         foo.logger.expect(:error, nil, [/.*/])
         foo.class_method
       end
-    
+
       context 'Generate Message' do
         should 'properly generate messages with a message prefix' do
           foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
           assert_match /^prefix /, foo.generate_message(StandardError.new('Hello'), {:message_prefix => 'prefix'})
         end
-    
+
         should 'properly generate messages with a blank message prefix' do
           foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
           assert_match /^#<StandardError: Hello>/, foo.generate_message(StandardError.new('Hello'), {:message_prefix => ''})
         end
-    
+
         should 'properly generate messages with no message prefix' do
           foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
           assert_match /^#<StandardError: Hello>/, foo.generate_message(StandardError.new('Hello'), {})
@@ -115,75 +115,193 @@ module GemLogger
       end
 
     end
-    
+
+    context "logger with added context" do
+
+      setup do
+        class Foo; include GemLogger::LoggerSupport; end
+      end
+
+      should "add the context to generated messages" do
+
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with("ctx", "1")
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with('ctx')
+        Foo.logger.expects(:info).with("msg")
+
+        Foo.logger.context("ctx" => "1").info("msg")
+      end
+
+      should "allow symbols as contexts" do
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:ctx, "1")
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:ctx)
+
+        Foo.logger.context(:ctx => "1").info("msg")
+      end
+
+      should "implement debug" do
+        Foo.logger.expects(:debug).with("[ctx=1 ] msg")
+        Foo.logger.context(:ctx => "1").debug("msg")
+      end
+
+      should "implement info" do
+        Foo.logger.expects(:info).with("[ctx=1 ] msg")
+        Foo.logger.context(:ctx => "1").info("msg")
+      end
+
+      should "implement warn" do
+        Foo.logger.expects(:warn).with("[ctx=1 ] msg")
+        Foo.logger.context(:ctx => "1").warn("msg")
+      end
+
+      should "implement error" do
+        Foo.logger.expects(:error).with("[ctx=1 ] msg")
+        Foo.logger.context(:ctx => "1").error("msg")
+      end
+
+      should "implement fatal" do
+        Foo.logger.expects(:fatal).with("[ctx=1 ] msg")
+        Foo.logger.context(:ctx => "1").fatal("msg")
+      end
+
+      should 'allow context to be chained' do
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with('ctx', '1')
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with('ctx')
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with('ctx2', '2')
+        GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with('ctx2')
+        Foo.logger.expects(:info).with("msg")
+
+        Foo.logger.context("ctx" => "1").context("ctx2" => "2").info("msg")
+      end
+
+      context "event_context" do
+        should "add the event_type as context" do
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:event_type, :test_event)
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:event_type)
+
+          Foo.logger.expects(:info).with("msg")
+          Foo.logger.event_context(:test_event).info("msg")
+        end
+
+        should "include the context of the logger used" do
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:event_type, :test_event)
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:event_type)
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:ctx, '1')
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:ctx)
+
+          Foo.logger.expects(:error).with("msg")
+          Foo.logger.context(:ctx => "1").event_context(:test_event).error("msg")
+        end
+
+        should 'restore previous log context after logging' do
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.stubs(:get_context).returns({'foo' => 'bar'})
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:event_type, {'foo' => 'baz'})
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:event_type)
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:format_msg_with_context).with('msg')
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with('foo', 'bar')
+
+          Foo.logger.event_context('foo' => 'baz').info("msg")
+        end
+      end
+
+      context "exception_context" do
+        should "add the exception class as context" do
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:exception, 'StandardError')
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:exception)
+
+          Foo.logger.expects(:info).with("msg")
+          Foo.logger.exception_context(StandardError.new).info("msg")
+        end
+      end
+
+      context "log_exception" do
+        should "add the exception class as context" do
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:add_to_context).with(:exception, 'StandardError')
+          GemLogger::LoggerSupport::LogContextLogger.any_instance.expects(:remove_from_context).with(:exception)
+
+          Foo.logger.expects(:error)
+          Foo.logger.log_exception(StandardError.new, "msg")
+        end
+
+        should "log the backtrace" do
+          Foo.logger.expects(:error).with("[exception=StandardError ] msg: err (no backtrace)")
+          Foo.logger.log_exception(StandardError.new("err"), "msg")
+        end
+
+        should 'allow the level to be changed as an option' do
+          Foo.logger.expects(:warn).with("[exception=StandardError ] msg: err (no backtrace)")
+          Foo.logger.log_exception(StandardError.new("err"), "msg", :level => :warn)
+        end
+      end
+    end
+
     context "lumber integration" do
-      
+
       setup do
         require 'lumber'
-        
+
         yml = <<-EOF
-          log4r_config:
-            pre_config:
-              root:
-                level: 'DEBUG'
-            loggers:
-              - name: "rails"
-                level: DEBUG
-            outputters: []
+log4r_config:
+  pre_config:
+    root:
+      level: 'DEBUG'
+  loggers:
+    - name: "rails"
+      level: DEBUG
+  outputters: []
         EOF
-        
+
         cfg = Log4r::YamlConfigurator
         cfg.load_yaml_string(yml)
         logger = Log4r::Logger['rails']
-        sio = StringIO.new 
+        sio = StringIO.new
         logger.outputters = [Log4r::IOOutputter.new("sbout", sio)]
-        
+
         Log4r::YamlConfigurator.stub(:load_yaml_file, nil) do
           root = File.expand_path("../../..", __FILE__)
           Lumber.init(:root => root, :env => 'test', :config_file => __FILE__)
         end
-        
+
         @old_logger_concern = GemLogger.logger_concern
         GemLogger.logger_concern = Lumber::LoggerSupport
       end
-      
+
       teardown do
         GemLogger.logger_concern = @old_logger_concern
       end
-    
+
       should "have a logger instance accessible from an instance method" do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
         assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.new.logger.fullname
       end
-    
+
       should "have a logger instance accessible from a class method " do
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; }
         assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
       end
-    
+
       should "have a logger instance when in a nested module" do
         foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
         foo = new_class("Foo#{@uniq}") { include foomod; }
         assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
       end
-    
+
       should "have correct logger instance with multiple includes" do
         foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
         foo = new_class("Foo#{@uniq}") { include GemLogger::LoggerSupport; include foomod; }
         assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
       end
-    
+
       should "have correct logger instance with includes and inheritance" do
         foosuper = new_class("FooSuper#{@uniq}") { include GemLogger::LoggerSupport; }
         foo = new_class("Foo#{@uniq}", foosuper) { }
-        assert_equal "rails::GemLogger::LoggerSupportTest::#{foosuper.name.split('::').last}::#{foo.name.split('::').last}", foo.logger.fullname
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
       end
-    
+
       should "have correct logger instance with multiple includes and inheritance" do
         foomod = new_module("FooMod#{@uniq}") { extend ActiveSupport::Concern; include GemLogger::LoggerSupport; }
         foosuper = new_class("FooSuper#{@uniq}") { include foomod; }
         foo = new_class("Foo#{@uniq}", foosuper) { include GemLogger::LoggerSupport; include foomod; }
-        assert_equal "rails::GemLogger::LoggerSupportTest::#{foosuper.name.split('::').last}::#{foo.name.split('::').last}", foo.logger.fullname
+        assert_equal "rails::GemLogger::LoggerSupportTest::#{foo.name.split('::').last}", foo.logger.fullname
       end
 
     end

metadata

@@ -1,141 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: gem_logger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Matt Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-23 00:00:00.000000000 Z
+date: 2014-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-  type: :development
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '4.0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '4.0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: minitest_should
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: factory_girl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :development
+        version: '0'
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
+        version: '0'
+  type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  type: :runtime
+        version: '0'
 description: Allows classes/modules in gems to have logger class/instance methods
   with a pluggable Logger implementation
 email:
@@ -144,9 +130,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .coveralls.yml
-- .gitignore
-- .travis.yml
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -154,10 +140,13 @@ files:
 - gem_logger.gemspec
 - lib/gem_logger.rb
 - lib/gem_logger/basic_logger.rb
+- lib/gem_logger/context_handler.rb
+- lib/gem_logger/gem_logger.rb
 - lib/gem_logger/logger_support.rb
 - lib/gem_logger/version.rb
 - test/test_helper.rb
 - test/unit/gem_logger/basic_logger_test.rb
+- test/unit/gem_logger/context_handler_test.rb
 - test/unit/gem_logger/logger_support_test.rb
 - test/unit/gem_logger_test.rb
 homepage: ''
@@ -170,19 +159,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Allows classes/modules in gems to have logger class/instance methods with
@@ -190,5 +177,7 @@ summary: Allows classes/modules in gems to have logger class/instance methods wi
 test_files:
 - test/test_helper.rb
 - test/unit/gem_logger/basic_logger_test.rb
+- test/unit/gem_logger/context_handler_test.rb
 - test/unit/gem_logger/logger_support_test.rb
 - test/unit/gem_logger_test.rb
+has_rdoc: