chalk-log 0.1.2

data/lib/chalk-log/logger.rb

@@ -0,0 +1,63 @@
+# Thin wrapper over Logging::Logger. This is the per-class object
+# instantiated by the `log` method.
+class Chalk::Log::Logger
+  attr_reader :backend
+
+  # Initialization of the logger backend. It does the actual creation
+  # of the various logger methods. Will be called automatically upon
+  # your first `log` method call.
+  def self.init
+    Chalk::Log::LEVELS.each do |level|
+      define_method(level) do |*data, &blk|
+        return if logging_disabled?
+        @backend.send(level, data, &blk)
+      end
+    end
+  end
+
+  # The level this logger is set to.
+  def level
+    @backend.level
+  end
+
+  # Set the maximum log level.
+  #
+  # @param level [Fixnum|String|Symbol] A valid Logging::Logger level, e.g. :debug, 0, 'DEBUG', etc.
+  def level=(level)
+    @backend.level = level
+  end
+
+  # Create a new logger, and auto-initialize everything.
+  def initialize(name)
+    # It's generally a bad pattern to auto-init, but we want
+    # Chalk::Log to be usable anytime during the boot process, which
+    # requires being a little bit less explicit than we usually like.
+    Chalk::Log.init
+    @backend = ::Logging::Logger.new(name)
+    if level = configatron.chalk.log.default_level
+      @backend.level = level
+    end
+  end
+
+  # Check whether logging has been globally turned off, either through
+  # configatron or LSpace.
+  def logging_disabled?
+    configatron.chalk.log.disabled || LSpace[:'chalk.log.disabled']
+  end
+
+  def with_contextual_info(contextual_info={}, &blk)
+    unless blk
+      raise ArgumentError.new("Must pass a block to #{__method__}")
+    end
+    unless contextual_info.is_a?(Hash)
+      raise TypeError.new(
+        "contextual_info must be a Hash, but got #{contextual_info.class}"
+      )
+    end
+    existing_context = LSpace[:'chalk.log.contextual_info'] || {}
+    LSpace.with(
+      :'chalk.log.contextual_info' => contextual_info.merge(existing_context),
+      &blk
+    )
+  end
+end

data/lib/chalk-log/utils.rb

@@ -0,0 +1,84 @@
+module Chalk::Log::Utils
+  # Nicely formats a backtrace:
+  #
+  # ```ruby
+  # format_backtrace(['line1', 'line2'])
+  # #=>   line1
+  #   line2
+  # ```
+  #
+  # (Used internally when `Chalk::Log` is formatting exceptions.)
+  #
+  # TODO: add autotruncating of backtraces.
+  def self.format_backtrace(backtrace)
+    if configatron.chalk.log.compress_backtraces
+      backtrace = compress_backtrace(backtrace)
+      backtrace << '(Disable backtrace compression by setting configatron.chalk.log.compress_backtraces = false.)'
+    end
+
+    "  " + backtrace.join("\n  ")
+  end
+
+  # Explodes a nested hash to just have top-level keys. This is
+  # generally useful if you have something that knows how to parse
+  # kv-pairs.
+  #
+  # ```ruby
+  # explode_nested_hash(foo: {bar: 'baz', bat: 'zom'})
+  # #=> {'foo_bar' => 'baz', 'foo_bat' => 'zom'}
+  # ```
+  def self.explode_nested_hash(hash, prefix=nil)
+    exploded = {}
+
+    hash.each do |key, value|
+      new_prefix = prefix ? "#{prefix}_#{key}" : key.to_s
+
+      if value.is_a?(Hash)
+        exploded.merge!(self.explode_nested_hash(value, new_prefix))
+      else
+        exploded[new_prefix] = value
+      end
+    end
+
+    exploded
+  end
+
+  # Compresses a backtrace, omitting gem lines (unless they appear
+  # before any application lines).
+  def self.compress_backtrace(backtrace)
+    compressed = []
+    gemdir = Gem.dir
+
+    hit_application = false
+    # This isn't currently read by anything, but we could easily use
+    # it to limit the number of leading gem lines.
+    leading_lines = 0
+    gemlines = 0
+    backtrace.each do |line|
+      if line.start_with?(gemdir)
+        # If we're in a gem, always increment the counter. Record the
+        # first three lines if we haven't seen any application lines
+        # yet.
+        if !hit_application
+          compressed << line
+          leading_lines += 1
+        else
+          gemlines += 1
+        end
+      elsif gemlines > 0
+        # If we were in a gem and now are not, record the number of
+        # lines skipped.
+        compressed << "<#{gemlines} #{gemlines == 1 ? 'line' : 'lines'} omitted>"
+        compressed << line
+        hit_application = true
+        gemlines = 0
+      else
+        # If we're in the application, always record the line.
+        compressed << line
+        hit_application = true
+      end
+    end
+
+    compressed
+  end
+end

data/lib/chalk-log/version.rb

@@ -0,0 +1,5 @@
+module Chalk
+  module Log
+    VERSION = '0.1.2'
+  end
+end

data/tddium.yml

@@ -0,0 +1,8 @@
+:tddium:
+  :ruby_version: ruby-1.9.3-p194
+  :bundler_version: 1.3.5
+  :test_pattern:
+    - "test/wholesome/[^_]*.rb"
+    - "test/unit/[^_]*.rb"
+    - "test/integration/[^_]*.rb"
+    - "test/functional/[^_]*.rb"

data/test/_lib.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'mocha/setup'
+
+module Critic
+  require_relative '_lib/fake'
+
+  class Test < ::MiniTest::Spec
+    def setup
+      # Put any stubs here that you want to apply globally
+    end
+  end
+end

data/test/_lib/fake.rb

@@ -0,0 +1,5 @@
+module Critic::Fake
+  Dir[File.expand_path('../fake/*.rb', __FILE__)].each do |file|
+    require_relative(file)
+  end
+end

data/test/_lib/fake/event.rb

@@ -0,0 +1,9 @@
+class Critic::Fake::Event
+  attr_reader :data, :time, :level
+
+  def initialize(opts)
+    @data = opts.fetch(:data)
+    @time = opts.fetch(:time, Time.new(1979,4,9))
+    @level = opts.fetch(:level, 1)
+  end
+end

data/test/functional/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Functional
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/functional/formatting.rb

@@ -0,0 +1,188 @@
+require File.expand_path('../_lib', __FILE__)
+
+require 'chalk-log'
+
+module Critic::Functional
+  class LogTest < Test
+    def enable_timestamp
+      configatron.chalk.log.stubs(:timestamp).returns(true)
+    end
+
+    def disable_timestamp
+      configatron.chalk.log.stubs(:timestamp).returns(false)
+    end
+
+    def disable_pid
+      configatron.chalk.log.stubs(:pid).returns(false)
+    end
+
+    def disable_tagging
+      configatron.chalk.log.stubs(:tagging).returns(false)
+    end
+
+    before do
+      Chalk::Log.init
+      Process.stubs(:pid).returns(9973)
+      disable_timestamp
+    end
+
+    class MyClass
+      include Chalk::Log
+    end
+
+    describe 'when called without arguments' do
+      it 'does not loop infinitely' do
+        MyClass.log.info
+      end
+    end
+
+    describe 'when called with a message' do
+      it 'does not mutate the input' do
+        canary = "'hello, world!'"
+        baseline = canary.dup
+        MyClass.log.info(canary)
+        assert_equal(baseline, canary)
+      end
+    end
+
+    describe 'layout' do
+      before do
+        @layout = MyClass::Layout.new
+      end
+
+      def layout(opts)
+        event = Critic::Fake::Event.new(opts)
+        formatted = @layout.format(event)
+
+        # Everything should end with a newline, but they're annoying
+        # to have to test elsewhere, so strip it away.
+        assert_equal("\n", formatted[-1], "Layout did not end with a newline: #{formatted.inspect}")
+        formatted.chomp
+      end
+
+      it 'log entry from info' do
+        rendered = layout(data: ["A Message", {:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+        assert_equal('[9973] A Message: key1=ValueOne key2=["An","Array"]', rendered)
+      end
+
+      it 'logs the action_id correctly' do
+        LSpace.with(action_id: 'action') do
+          rendered = layout(data: ["A Message", {:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+          assert_equal('[9973|action] A Message: key1=ValueOne key2=["An","Array"]', rendered)
+        end
+      end
+
+      it 'logs timestamp correctly' do
+        enable_timestamp
+        LSpace.with(action_id: 'action') do
+          rendered = layout(data: ["A Message", {:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+          assert_equal('[1979-04-09 00:00:00.000000] [9973|action] A Message: key1=ValueOne key2=["An","Array"]', rendered)
+        end
+      end
+
+      it 'logs without pid correctly' do
+        disable_pid
+        LSpace.with(action_id: 'action') do
+          rendered = layout(data: ["A Message", {:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+          assert_equal('[action] A Message: key1=ValueOne key2=["An","Array"]', rendered)
+        end
+      end
+
+      it 'log from info hash without a message' do
+        rendered = layout(data: [{:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+        assert_equal('[9973] key1=ValueOne key2=["An","Array"]', rendered)
+      end
+
+      it 'renders [no backtrace] as appropriate' do
+        rendered = layout(data: ["Another Message", StandardError.new('msg')])
+        assert_equal("[9973] Another Message: error_class=StandardError error=msg\n[9973]   [no backtrace]", rendered)
+      end
+
+      it 'renders when given error and info hash' do
+        rendered = layout(data: ["Another Message", StandardError.new('msg'), {:key1 => "ValueOne", :key2 => ["An", "Array"]}])
+        assert_equal(%Q{[9973] Another Message: key1=ValueOne key2=["An","Array"] error_class=StandardError error=msg\n[9973]   [no backtrace]}, rendered)
+      end
+
+      it 'renders an error with a backtrace' do
+        error = StandardError.new('msg')
+        backtrace = ["a fake", "backtrace"]
+        error.set_backtrace(backtrace)
+
+        rendered = layout(data: ["Yet Another Message", error])
+        assert_equal("[9973] Yet Another Message: error_class=StandardError error=msg\n[9973]   a fake\n[9973]   backtrace", rendered)
+      end
+
+      it 'renders an error passed alone' do
+        error = StandardError.new('msg')
+        backtrace = ["a fake", "backtrace"]
+        error.set_backtrace(backtrace)
+
+        rendered = layout(data: [error])
+        assert_equal("[9973] error_class=StandardError error=msg\n[9973]   a fake\n[9973]   backtrace", rendered)
+      end
+
+      it 'handles bad unicode' do
+        rendered = layout(data: [{:key1 => "ValueOne", :key2 => "\xC3"}])
+        assert_equal("[9973] key1=ValueOne key2=\"\\xC3\" [JSON-FAILED]", rendered)
+      end
+
+      it 'allows disabling tagging' do
+        enable_timestamp
+        disable_tagging
+
+        LSpace.with(action_id: 'action') do
+          rendered = layout(data: [{:key1 => "ValueOne", :key2 => "Value Two"}])
+          assert_equal(%Q{key1=ValueOne key2="Value Two"}, rendered)
+        end
+      end
+
+      describe 'faults' do
+        it 'shows an appropriate error if the invalid arguments are provided' do
+          rendered = layout(data: ['foo', nil])
+
+          lines = rendered.split("\n")
+          assert_equal('[Chalk::Log fault: Could not format message] error_class="Chalk::Log::InvalidArguments" error="Invalid leftover arguments: [\"foo\", nil]"', lines[0])
+          assert(lines.length > 1)
+        end
+
+        it 'handles single faults' do
+          e = StandardError.new('msg')
+          @layout.expects(:do_format).raises(e)
+          rendered = layout(data: ['hi'])
+
+          lines = rendered.split("\n")
+          assert_equal('[Chalk::Log fault: Could not format message] error_class=StandardError error=msg', lines[0])
+          assert(lines.length > 1)
+        end
+
+        it 'handles double-faults' do
+          e = StandardError.new('msg')
+          def e.to_s; raise 'Time to double-fault'; end
+
+          @layout.expects(:do_format).raises(e)
+          rendered = layout(data: ['hi'])
+
+          lines = rendered.split("\n")
+          assert_match(/Chalk::Log fault: Double fault while formatting message/, lines[0])
+          assert_equal(1, lines.length, "Lines: #{lines.inspect}")
+        end
+
+        it 'handles triple-faults' do
+          e = StandardError.new('msg')
+          def e.to_s
+            f = StandardError.new('double')
+            def f.to_s; raise 'Time to triple fault'; end
+            raise f
+          end
+
+          @layout.expects(:do_format).raises(e)
+          rendered = layout(data: ['hi'])
+
+          lines = rendered.split("\n")
+          assert_match(/Chalk::Log fault: Triple fault while formatting message/, lines[0])
+          assert_equal(1, lines.length, "Lines: #{lines.inspect}")
+        end
+      end
+    end
+  end
+end

data/test/functional/log.rb

@@ -0,0 +1,296 @@
+require File.expand_path('../_lib', __FILE__)
+
+require 'chalk-log'
+
+module Critic::Functional
+  class LogTest < Test
+    def self.add_appender
+      unless @appender
+        @appender = ::Logging.appenders.string_io(
+          'test-stringio',
+          layout: Chalk::Log.layout
+        )
+        ::Logging.logger.root.add_appenders(@appender)
+      end
+      @appender
+    end
+
+    before do
+      Chalk::Log.init
+    end
+
+    describe 'when a class has included Log' do
+      it 'instances are loggable' do
+        class MyClass
+          include Chalk::Log
+        end
+
+        MyClass.new.log.info("Hi!")
+      end
+
+      it 'the class is loggable' do
+        class YourClass
+          include Chalk::Log
+        end
+
+        YourClass.log.info("Hi!")
+      end
+    end
+
+    describe 'including a loggable module into another' do
+      describe 'the inclusions are straightline' do
+        it 'make the includee loggable' do
+          module LogTestA
+            include Chalk::Log
+          end
+
+          module LogTestB
+            include LogTestA
+          end
+
+          assert(LogTestB < Chalk::Log)
+          assert(LogTestB.respond_to?(:log))
+        end
+
+        it 'preserves any custom include logic prior to Log inclusion' do
+          module CustomLogTestA
+            def self.dict=(dict)
+              @dict = dict
+            end
+
+            def self.dict
+              @dict
+            end
+
+            def self.included(other)
+              dict['included'] = true
+            end
+
+            include Chalk::Log
+          end
+
+          dict = {}
+          CustomLogTestA.dict = dict
+
+          module CustomLogTestB
+            include CustomLogTestA
+          end
+
+          assert(CustomLogTestB < Chalk::Log)
+          assert(CustomLogTestB.respond_to?(:log))
+          assert_equal(true, dict['included'])
+        end
+
+        # TODO: it'd be nice if this weren't true, but I'm not sure
+        # how to get a hook when a method is overriden.
+        it 'custom include logic after Log inclusion clobbers the default include logic' do
+          module CustomLogTestC
+            def self.dict=(dict)
+              @dict = dict
+            end
+
+            def self.dict
+              @dict
+            end
+
+            include Chalk::Log
+
+            def self.included(other)
+              dict['included'] = true
+            end
+          end
+
+          dict = {}
+          CustomLogTestC.dict = dict
+
+          module CustomLogTestD
+            include CustomLogTestC
+          end
+
+          assert(CustomLogTestD < Chalk::Log)
+          assert(!CustomLogTestD.respond_to?(:log))
+          assert_equal(true, dict['included'])
+        end
+      end
+    end
+
+    describe 'extending a Log module into another' do
+      describe 'the inclusions are straightline' do
+        it 'make the extendee loggable' do
+          module ExtendLogTestA
+            include Chalk::Log
+          end
+
+          module ExtendLogTestB
+            extend ExtendLogTestA
+          end
+
+          assert(ExtendLogTestB < Chalk::Log)
+          assert(ExtendLogTestB.respond_to?(:log))
+        end
+      end
+    end
+
+    describe 'when a class is loggable' do
+      class MyLog
+        include Chalk::Log
+      end
+
+      it 'log.warn works' do
+        msg = 'msg'
+        # For some reason this isn't working:
+        MyLog.log.backend.expects(:warn).once
+        MyLog.log.warn(msg)
+      end
+
+      it 'log.info works' do
+        msg = 'msg'
+        MyLog.log.backend.expects(:info).once
+        MyLog.log.info(msg)
+      end
+
+      it 'accepts blocks' do
+        class LogTestE
+          include Chalk::Log
+        end
+        LogTestE.log.level = "INFO"
+
+        LogTestE.log.debug { assert(false, "DEBUG block called when at INFO level") }
+        called = false
+        LogTestE.log.info { called = true; "" }
+        assert(called, "INFO block not called at INFO level")
+      end
+    end
+
+    class TestLogInstanceMethods < Test
+      include Chalk::Log
+
+      before do
+        TestLogInstanceMethods.log.level = 'INFO'
+        Chalk::Log.init
+        @appender = LogTest.add_appender
+      end
+
+      def assert_logged(expected_string, *args)
+        assert_includes(@appender.sio.string, expected_string, *args)
+      end
+
+      it 'accepts blocks on instance methods' do
+        called = false
+        log.debug { assert(false, "DEBUG block called at INFO") }
+        log.info { called = true; "" }
+        assert(called, "INFO block not called at INFO level")
+      end
+
+      describe 'when contextual info is set' do
+
+        it 'adds contextual information to `.info` log lines' do
+          log.with_contextual_info(key: 'value') {log.info("message")}
+          assert_logged("key=value")
+        end
+
+        it 'nests contexts' do
+          log.with_contextual_info(top_key: "top_value") do
+            log.info("top message")
+            log.with_contextual_info(inner_key: "inner_value") do
+              log.info("inner message")
+            end
+          end
+          %w{top_key=top_value inner_key=inner_value}.each do |pair|
+            assert_logged(pair)
+          end
+        end
+
+        it 'requires a block' do
+          exn = assert_raises(ArgumentError) do
+            log.with_contextual_info(i_am_not: "passing a block")
+          end
+          assert_includes(exn.message, "Must pass a block")
+        end
+
+        it 'requires its argument must be a hash' do
+          exn = assert_raises(TypeError) do
+            log.with_contextual_info('not a hash') {}
+          end
+          assert_includes(exn.message, 'must be a Hash')
+        end
+      end
+    end
+
+    describe 'when chaining includes and extends' do
+      it 'correctly make the end class loggable' do
+        module Base1
+          include Chalk::Log
+        end
+
+        class Child1
+          extend Base1
+        end
+
+        Child1.log.info("Hello!")
+        assert(true)
+      end
+
+      it 'correctly make the end class loggable when chaining an include and extend' do
+        module Base2
+          include Chalk::Log
+        end
+
+        module Middle2
+          extend Base2
+        end
+
+        class Child2
+          include Middle2
+        end
+
+        Child2.log.info("Hello!")
+        assert(true)
+      end
+
+      it 'correctly make the end class loggable when chaining an extend and an extend' do
+        module Base3
+          include Chalk::Log
+        end
+
+        module Middle3
+          extend Base3
+        end
+
+        class Child3
+          extend Middle3
+        end
+
+        Child3.log.info("Hello!")
+        assert(true)
+      end
+
+      it 'correctly make the end class loggable when it has already included loggable' do
+        module Base4
+          include Chalk::Log
+        end
+
+        module Middle4
+          extend Base4
+        end
+
+        class Child4
+          include Chalk::Log
+          extend Middle4
+        end
+
+        Child4.log.info("Hello!")
+        assert(true)
+      end
+    end
+
+    it 'correctly makes a module loggable' do
+      module Base5
+        include Chalk::Log
+      end
+
+      Base5.log.info("Hello!")
+      assert(true)
+    end
+  end
+end