semantic_logger 2.11.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8ef6f216370a6763f9cd28aa1c5a098c1cc584e
-  data.tar.gz: c02264af59deef219f5970e8ec51b4af852ed48e
+  metadata.gz: 1a76d0de5e08c9768042187ab19b2546d5c91b3a
+  data.tar.gz: b04d51de5d531ec57ce382e77ddfd21bd69a420a
 SHA512:
-  metadata.gz: e5bf5e189ddccbcf52c57be758a53d8224777ec4a35c2beea4502a3c271cb15e82078ca67ab1aec4da5f5d80a1cf01ef4e8ccea20d9623c442eba0bc272a39b0
-  data.tar.gz: 4299412a428431a41126a3e6ba47ea6a3c19867c2393162dd61e02d8c6cda8ca5b084405cb1203bb7fc25044d5a47b6cf9e790ddf34fdccbd7b538d57903c1d0
+  metadata.gz: 7fc60fcfef8e8c255720de4a4972ae2f0b919dd022eccc68afef004ad1f3fd0870f6c4adc54d190d0ff109a6671be910dbfafdf63f9ade57e9c8caedc66bead1
+  data.tar.gz: 2c73e2cf3ac75e19097a3acb6b0437df745c4d60e7c8c3a5a02ef846a9b1ba1b16e37b49e07bbde4851c4ba77e63c1d22e027bf65ea3882150c1608f98db0f93

data/lib/semantic_logger/appender/base.rb

@@ -81,6 +81,12 @@ module SemanticLogger
         # An appender can implement a flush method if it supports it.
       end
 
+      # Returns the current log level if set, otherwise it returns the global
+      # default log level
+      def level
+        @level || :trace
+      end
+
       ############################################################################
       protected
 
@@ -105,6 +111,13 @@ module SemanticLogger
         super(self.class, level, filter)
       end
 
+      # Return the level index for fast comparisons
+      # Returns the lowest level index if the level has not been explicitly
+      # set for this instance
+      def level_index
+        @level_index || 0
+      end
+
       # For JRuby include the Thread name rather than its id
       if defined? Java
         # Return the Time as a formatted string

data/lib/semantic_logger/debug_as_trace_logger.rb

@@ -0,0 +1,18 @@
+module SemanticLogger
+  # Custom logger that maps all calls to debug to trace calls
+  # This is useful for existing gems / libraries that log too much to debug
+  # when most of the debug logging should be at the trace level
+  class DebugAsTraceLogger < Logger
+    def debug(*args, &block)
+      trace(*args, &block)
+    end
+
+    def debug?
+      trace?
+    end
+
+    def benchmark_debug(*args, &block)
+      benchmark_trace(*args, &block)
+    end
+  end
+end

data/lib/semantic_logger/version.rb

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

data/lib/semantic_logger.rb

@@ -3,9 +3,10 @@ require 'semantic_logger/version'
 require 'semantic_logger/semantic_logger'
 
 module SemanticLogger
-  autoload :Base,       'semantic_logger/base'
-  autoload :Logger,     'semantic_logger/logger'
-  autoload :Loggable,   'semantic_logger/loggable'
+  autoload :Base,               'semantic_logger/base'
+  autoload :Logger,             'semantic_logger/logger'
+  autoload :Loggable,           'semantic_logger/loggable'
+  autoload :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'
 
   module Appender
     autoload :Base,     'semantic_logger/appender/base'

data/test/debug_as_trace_logger_test.rb

@@ -0,0 +1,98 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
+
+# Unit Test for SemanticLogger::Logger
+class DebugAsTraceLoggerTest < Minitest::Test
+  context SemanticLogger::Logger do
+    # Test each filter
+    [ nil, /\ADebugAsTraceLoggerTest/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
+      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
+          appender = SemanticLogger.add_appender(@mock_logger)
+          appender.filter = filter
+
+          # Use this test's class name as the application name in the log output
+          @logger   = SemanticLogger::DebugAsTraceLogger.new(self.class)
+          @hash     = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+          @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+          assert_equal [], @logger.tags
+        end
+
+        teardown do
+          # Remove all appenders
+          SemanticLogger.appenders.each{|appender| SemanticLogger.remove_appender(appender)}
+        end
+
+        context '.level?' do
+          should 'return true for debug? with :trace level' do
+            SemanticLogger.default_level = :trace
+            assert_equal :trace, @logger.level
+            assert_equal true,   @logger.debug?
+            assert_equal true,   @logger.trace?
+          end
+
+          should 'return false for debug? with global :debug level' do
+            SemanticLogger.default_level = :debug
+            assert_equal :debug, @logger.level,  @logger.inspect
+            assert_equal false,  @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return true for debug? with global :info level' do
+            SemanticLogger.default_level = :info
+            assert_equal :info, @logger.level,  @logger.inspect
+            assert_equal false,  @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return false for debug? with instance :debug level' do
+            @logger.level = :debug
+            assert_equal :debug, @logger.level,  @logger.inspect
+            assert_equal false,   @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return true for debug? with instance :info level' do
+            @logger.level = :info
+            assert_equal :info, @logger.level,  @logger.inspect
+            assert_equal false,  @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+        end
+
+        should 'not log trace when level is debug' do
+          @logger.level = :debug
+          @logger.trace('hello world', @hash) { "Calculations" }
+          SemanticLogger.flush
+          assert_nil @mock_logger.message
+        end
+
+        should 'not log debug when level is debug' do
+          @logger.level = :debug
+          @logger.debug('hello world', @hash) { "Calculations" }
+          SemanticLogger.flush
+          assert_nil @mock_logger.message
+        end
+
+        should 'map trace to debug' do
+          @logger.level = :trace
+          @logger.debug('hello world', @hash) { "Calculations" }
+          SemanticLogger.flush
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+        end
+
+        should 'log trace as trace' do
+          @logger.level = :trace
+          @logger.trace('hello world', @hash) { "Calculations" }
+          SemanticLogger.flush
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+        end
+      end
+    end
+
+  end
+end

data/test/logger_test.rb

@@ -97,128 +97,196 @@ class LoggerTest < Minitest::Test
               end
             end
           end
+        end
 
-          context "Ruby Logger" do
-            # Ensure that any log level can be logged
-            Logger::Severity.constants.each do |level|
-              should "log Ruby logger #{level} info" do
-                @logger.level = Logger::Severity.const_get(level)
-                if level.to_s == 'UNKNOWN'
-                  assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
-                else
-                  assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
-                end
+        context "Ruby Logger" do
+          # Ensure that any log level can be logged
+          Logger::Severity.constants.each do |level|
+            should "log Ruby logger #{level} info" do
+              @logger.level = Logger::Severity.const_get(level)
+              if level.to_s == 'UNKNOWN'
+                assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
+              else
+                assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
               end
             end
           end
+        end
 
-          context "benchmark" do
-            # Ensure that any log level can be benchmarked and logged
-            SemanticLogger::LEVELS.each do |level|
-              level_char = level.to_s.upcase[0]
+        context "benchmark" do
+          # Ensure that any log level can be benchmarked and logged
+          SemanticLogger::LEVELS.each do |level|
+            level_char = level.to_s.upcase[0]
 
-              context 'direct method' do
-                should "log #{level} info" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-                end
+            context 'direct method' do
+              should "log #{level} info" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+              end
 
-                should "log #{level} info with payload" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-                end
+              should "log #{level} info with payload" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "not log #{level} info when block is faster than :min_duration" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_nil @mock_logger.message
-                end
+              should "not log #{level} info when block is faster than :min_duration" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_nil @mock_logger.message
+              end
 
-                should "log #{level} info when block duration exceeds :min_duration" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-                end
+              should "log #{level} info when block duration exceeds :min_duration" do
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "log #{level} info with an exception" do
-                  assert_raises RuntimeError do
-                    @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
-                  end
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              should "log #{level} info with an exception" do
+                assert_raises RuntimeError do
+                  @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "change log #{level} info with an exception" do
-                  assert_raises RuntimeError do
-                    @logger.send("benchmark_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
-                  end
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              should "change log #{level} info with an exception" do
+                assert_raises RuntimeError do
+                  @logger.send("benchmark_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "log #{level} info with metric" do
-                  metric_name = '/my/custom/metric'
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-                  assert metric_name, $last_metric.metric
-                end
+              should "log #{level} info with metric" do
+                metric_name = '/my/custom/metric'
+                assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert metric_name, $last_metric.metric
               end
+            end
 
-              context 'generic method' do
-                should "log #{level} info" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world') { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-                end
+            context 'generic method' do
+              should "log #{level} info" do
+                assert_equal "result", @logger.benchmark(level, 'hello world') { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+              end
 
-                should "log #{level} info with payload" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-                end
+              should "log #{level} info with payload" do
+                assert_equal "result", @logger.benchmark(level, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "not log #{level} info when block is faster than :min_duration" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_nil @mock_logger.message
-                end
+              should "not log #{level} info when block is faster than :min_duration" do
+                assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 500) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_nil @mock_logger.message
+              end
 
-                should "log #{level} info when block duration exceeds :min_duration" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-                end
+              should "log #{level} info when block duration exceeds :min_duration" do
+                assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "log #{level} info with an exception" do
-                  assert_raises RuntimeError do
-                    @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
-                  end
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              should "log #{level} info with an exception" do
+                assert_raises RuntimeError do
+                  @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                 end
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+              end
 
-                should "log #{level} info with metric" do
-                  metric_name = '/my/custom/metric'
-                  assert_equal "result", @logger.benchmark(level, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
-                  SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-                  assert metric_name, $last_metric.metric
-                end
+              should "log #{level} info with metric" do
+                metric_name = '/my/custom/metric'
+                assert_equal "result", @logger.benchmark(level, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                assert metric_name, $last_metric.metric
               end
             end
+          end
 
-            should "log when the block performs a return" do
-              assert_equal "Good", function_with_return(@logger)
-              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 "log when the block performs a return" do
+            assert_equal "Good", function_with_return(@logger)
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+          end
+        end
+
+        context '.default_level' do
+          setup do
+            SemanticLogger.default_level = :debug
+          end
+
+          should 'not log at a level below the global default' do
+            assert_equal :debug, @logger.level
+            @logger.trace('hello world', @hash) { "Calculations" }
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+
+          should 'log at the instance level' do
+            @logger.level = :trace
+            assert_equal :trace, @logger.level
+            @logger.trace('hello world', @hash) { "Calculations" }
+            SemanticLogger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+          end
+
+          should 'not log at a level below the instance level' do
+            @logger.level = :warn
+            assert_equal :warn, @logger.level
+            @logger.debug('hello world', @hash) { "Calculations" }
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+        end
+
+        context '.level?' do
+          should 'return true for debug? with :trace level' do
+            SemanticLogger.default_level = :trace
+            assert_equal :trace, @logger.level
+            assert_equal true,   @logger.debug?
+            assert_equal true,   @logger.trace?
+          end
+
+          should 'return false for debug? with global :debug level' do
+            SemanticLogger.default_level = :debug
+            assert_equal :debug, @logger.level,  @logger.inspect
+            assert_equal true,   @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return true for debug? with global :info level' do
+            SemanticLogger.default_level = :info
+            assert_equal :info, @logger.level,  @logger.inspect
+            assert_equal false,  @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return false for debug? with instance :debug level' do
+            @logger.level = :debug
+            assert_equal :debug, @logger.level,  @logger.inspect
+            assert_equal true,   @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
+          end
+
+          should 'return true for debug? with instance :info level' do
+            @logger.level = :info
+            assert_equal :info, @logger.level,  @logger.inspect
+            assert_equal false,  @logger.debug?, @logger.inspect
+            assert_equal false,  @logger.trace?, @logger.inspect
           end
         end
+
       end
     end
+
   end
 
   # Make sure that benchmark still logs when a block uses return to return from

data/test/test_helper.rb

@@ -1,7 +1,9 @@
 # Allow test to be run in-place without requiring a gem install
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 
-#require 'rubygems'
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
 require 'minitest/autorun'
 require 'minitest/reporters'
 require 'minitest/stub_any_instance'
@@ -10,4 +12,4 @@ require 'semantic_logger'
 require 'logger'
 require 'mock_logger'
 
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.11.0
+  version: 2.12.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-02 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -59,6 +59,7 @@ files:
 - lib/semantic_logger/appender/wrapper.rb
 - lib/semantic_logger/base.rb
 - lib/semantic_logger/core_ext/thread.rb
+- lib/semantic_logger/debug_as_trace_logger.rb
 - lib/semantic_logger/loggable.rb
 - lib/semantic_logger/logger.rb
 - lib/semantic_logger/semantic_logger.rb
@@ -69,6 +70,7 @@ files:
 - test/appender_splunk_test.rb
 - test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
+- test/debug_as_trace_logger_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/mock_logger.rb
@@ -105,6 +107,7 @@ test_files:
 - test/appender_splunk_test.rb
 - test/appender_syslog_test.rb
 - test/appender_wrapper_test.rb
+- test/debug_as_trace_logger_test.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/mock_logger.rb