yeti_logger 3.0.0

data/lib/yeti_logger/configuration.rb

@@ -0,0 +1,14 @@
+module YetiLogger
+
+  module Configuration
+    attr_accessor :logger
+
+    def configure(&block)
+      instance_eval &block
+    end
+
+  end
+
+  extend Configuration
+
+end

data/lib/yeti_logger/constants.rb

@@ -0,0 +1,5 @@
+module YetiLogger
+  DEFAULT_OBJ_ARG = Object.new
+  LEVELS = [ :fatal, :error, :warn, :info, :debug ]
+  NUM_LINES_OF_EXCEPTIONS = 50
+end

data/lib/yeti_logger/message_formatters.rb

@@ -0,0 +1,93 @@
+# require 'logger'
+# require 'yeti_logger/version'
+# require 'yeti_logger/configuration'
+# require 'active_support/core_ext/benchmark'
+# require 'active_support/concern'
+# require 'active_support/core_ext/object/blank'
+# require 'active_support/core_ext/object/try'
+
+
+# Helper class used to format messages for logging. These can be used
+# directly, but are more convenient when used via YetiLogger
+module YetiLogger::MessageFormatters
+  NUM_LINES_OF_EXCEPTIONS = 50
+
+  # Helper method used to build up a single log message string you can pass to
+  # the underlying logger implementation.
+  # @param klass [String] Name of the class you are logging on behalf
+  # @param obj [Object] Object to log, may be nil
+  # @param exception [Exception] Optional exception to include in the log message
+  # @return [String] to log
+  def self.build_log_message(klass, obj, exception = nil, backtrace_lines = NUM_LINES_OF_EXCEPTIONS)
+    msg = if obj.is_a?(Hash)
+            if exception
+              format_hash(obj.merge(exception_hash(exception, backtrace_lines)))
+            else
+              format_hash(obj)
+            end
+          elsif exception
+            "#{obj} Exception: #{exception.message} "\
+            "Error Class: #{exception.class.name} "\
+            "#{format_backtrace(exception, backtrace_lines)}"
+          else
+            obj
+          end
+    "#{klass}: #{msg}"
+  end
+
+  # Format a Hash into key=value pairs, separated by whitespace.
+  # TODO: support nested hashes by serializing to JSON?
+  #
+  # @param hash [Hash] Hash to serialize into a key=value string
+  # @return [String] string representation of hash
+  def self.format_hash(hash)
+    hash.map do |k, v|
+      "#{k}=#{quote_unquoted(v.to_s)}"
+    end.join(' ')
+  end
+
+  # Helper method to quote strings that need quoting (spaces in them, or
+  # embedded quotes) that have not already been quoted.
+  # @param str [String] string to quote if it has spaces within it
+  # @return [String] original string, or quoted version if necessary
+  def self.quote_unquoted(str)
+    if str && (!needs_quoting?(str) || quoted?(str))
+      str
+    else
+      str.inspect
+    end
+  end
+
+  def self.needs_quoting?(str)
+    str.index(' ') || str.index('"')
+  end
+  private_class_method :needs_quoting?
+
+  def self.quoted?(str)
+    str[0] == ?" && str[-1] == ?"
+  end
+  private_class_method :quoted?
+
+  # Create a hash with the exception message and backtrace. You can merge this
+  # into an existing hash if you're logging key=value pairs.
+  # @param exception [Exception] The Exception you want to create a hash for.
+  # @param lines [Integer] How many lines of the backtrace to keep.
+  # @return [Hash] Hash with exception details in it.
+  def self.exception_hash(exception, lines = 20)
+    {
+      :error => exception.message,
+      :error_class => exception.class.name,
+      :backtrace => format_backtrace(exception, lines)
+    }
+  end
+
+  # Format a backtrace by joining all lines into a single line and quoting the
+  # results. You can optionally specify how many lines to include.
+  # @param exception [Exception] The Exception you want to convert to a string
+  # @param lines [Integer] How many lines of the backtrace to keep.
+  # @return [String] String of the backtrace.
+  def self.format_backtrace(exception, lines = 20)
+    exception.try(:backtrace).try(:take, lines).try(:join, ', ').inspect
+  end
+
+end

data/lib/yeti_logger/test_helper.rb

@@ -0,0 +1,65 @@
+# Helper methods for tests that interact with the Logging system
+#
+module YetiLogger::TestHelper
+
+  # Execute a block within the context of a changed log level. This will ensure
+  # the level is returned to is original state upon exit.
+  def with_log_level(level = Logger::DEBUG)
+    orig_level = YetiLogger.logger.level
+    begin
+      YetiLogger.logger.level = level
+      yield
+    ensure
+      YetiLogger.logger.level = orig_level
+    end
+  end
+
+  # Execute a block and ensure that among all the log messages received, message
+  # is among them. Not as elegant as a should_log type of method, but I can't
+  # figure out how to inject that into the rspec framework so it's evaluated
+  # after the method is done being called like should_receive's are.
+  def expect_to_see_log_message(message, level = :debug, &block)
+    expect_to_see_log_messages([message], level, &block)
+  end
+
+  # Plural version of above
+  def expect_to_see_log_messages(messages, level = :debug, &block)
+    log_messages = []
+
+    allow(YetiLogger.logger).to receive(level) do |log_line|
+      log_messages << log_line
+    end
+
+    block.call
+
+    # There is no unstub in rspec 3, but the closest to that would be to
+    # continue to stub it, but defer to the original implementation.
+    allow(YetiLogger.logger).to receive(level).and_call_original
+
+    # Find each message, removing the first occurrence.
+    messages.each do |message|
+      if message.is_a?(Regexp)
+        found = log_messages.find do |log_message|
+          log_message =~ message
+        end
+        if found
+          log_messages.delete_at(log_messages.find_index(found))
+        else
+          fail "Should have found #{message.inspect} amongst #{log_messages.inspect}"
+        end
+      else
+        expect(log_messages).to include(message)
+        log_messages.delete_at(log_messages.find_index(message))
+      end
+    end
+  end
+
+  def should_log(level = :info)
+    expect(YetiLogger.logger).to(receive(level))
+  end
+
+  def should_not_log(level = :info)
+    expect(YetiLogger.logger).to_not(receive(level))
+  end
+
+end

data/lib/yeti_logger/version.rb

@@ -0,0 +1,3 @@
+module YetiLogger
+  VERSION = "3.0.0"
+end

data/lib/yeti_logger/wrapped_logger.rb

@@ -0,0 +1,24 @@
+module YetiLogger
+
+  # This class provides a wrapper around an instance of a class that includes
+  # YetiLogger.
+  #
+  # The wrapper responds to the standard Logger methods :info, :warn, :error,
+  # and :debug, and forwards to the YetiLogger methods.
+  class WrappedLogger
+
+    # @param obj [Object] An instance of a class that includes YetiLogger.
+    def initialize(obj)
+      @obj = obj
+    end
+
+    # Use metaprogramming to define methods on the instance for each
+    # log level that YetiLogger supports.
+    YetiLogger::LEVELS.each do |level|
+      define_method(level) do |*args, &block|
+        instance_variable_get(:@obj).send("log_#{level}", *args, &block)
+      end
+    end
+
+  end
+end

data/spec/lib/yeti_logger/message_formatters_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper.rb'
+
+# Class used for class and instance level testing
+module Yucatan
+  class YellinYeti
+    include YetiLogger
+  end
+end
+
+describe YetiLogger::MessageFormatters do
+  let(:exception) do
+    begin
+      raise StandardError.new('fail!')
+    rescue => ex
+      ex
+    end
+  end
+  let(:exception_without_backtrace) do
+    StandardError.new('no-backtrace fail!')
+  end
+  let(:klass) do
+    Yucatan::YellinYeti.name
+  end
+
+  describe '.build_log_message' do
+    let(:klassname) { klass }
+    let(:obj) { 'foo bar' }
+    let(:hash) do
+      {
+        :k1 => 'value',
+        :k2 => 37
+      }
+    end
+
+    it 'dumps plain ole objects' do
+      expect(described_class.build_log_message(klass, obj)).
+          to eq("#{klassname}: foo bar")
+    end
+
+    it 'formats hashes' do
+      expect(described_class.build_log_message(klass, hash)).
+          to eq("#{klassname}: k1=value k2=37")
+    end
+
+    it 'appends on exceptions if they there' do
+      expect(described_class.build_log_message(klass, 'message', exception)).
+          to eq("#{klassname}: message Exception: fail! "\
+                "Error Class: StandardError "\
+                "#{exception.backtrace.take(50).join(', ').inspect}")
+    end
+
+    it 'appends an exception onto the hash' do
+      expect(described_class.build_log_message(klass, hash, exception)).
+          to eq("#{klassname}: k1=value k2=37 "\
+                "error=fail! "\
+                "error_class=StandardError "\
+                "backtrace=#{exception.backtrace.take(50).join(', ').inspect}")
+    end
+
+    it 'quotes values that need them.' do
+      hash[:quoted] = 'some value that is very long'
+      expect(described_class.build_log_message(klass, hash)).
+          to eq("#{klassname}: k1=value k2=37 "\
+                "quoted=\"some value that is very long\"")
+    end
+
+  end
+
+  describe '.exception_hash' do
+    it 'formats a hash with the exception details' do
+      expect(described_class.exception_hash(exception)).
+          to eq({
+                  :error => 'fail!',
+                  :error_class => 'StandardError',
+                  :backtrace => exception.backtrace.take(20).join(', ').inspect
+                })
+    end
+
+    it 'can deal with an exception without a backtrace' do
+      expect(described_class.exception_hash(exception_without_backtrace)).
+          to eq({
+                  :error => 'no-backtrace fail!',
+                  :error_class => 'StandardError',
+                  :backtrace => 'nil'
+                })
+    end
+
+    it 'can be told to produce shorter backtraces' do
+      expect(described_class.exception_hash(exception, 1)).
+          to eq({
+                  :error => 'fail!',
+                  :error_class => 'StandardError',
+                  :backtrace => exception.backtrace.take(1).join(', ').inspect
+                })
+    end
+  end
+
+  describe '.format_backtrace' do
+
+    it 'formats backtraces on one line' do
+      expect(described_class.format_backtrace(exception)).
+          to eq(exception.backtrace.take(20).join(', ').inspect)
+    end
+
+    it 'deals with exceptions without backtraces' do
+      expect(described_class.format_backtrace(exception_without_backtrace)).
+          to eq('nil')
+    end
+
+    it 'can be told to produce shorter backtraces' do
+      expect(described_class.format_backtrace(exception, 1)).
+          to eq(exception.backtrace.take(1).join(', ').inspect)
+    end
+
+  end
+
+  describe '.quote_unquoted' do
+
+    it 'does not quote nil values' do
+      expect(described_class.quote_unquoted(nil)).to eq("nil")
+    end
+
+    it 'does not quote simple values' do
+      expect(described_class.quote_unquoted("hello")).to eq("hello")
+    end
+
+    it 'does quote values with spaces in them' do
+      expect(described_class.quote_unquoted("hello world")).
+          to eq("\"hello world\"")
+    end
+
+    it 'does quote values with quotes in them' do
+      expect(described_class.quote_unquoted("hello\"world")).
+          to eq("\"hello\\\"world\"")
+    end
+
+    it 'does not re-quote quoted values' do
+      expect(described_class.quote_unquoted("\"hello world\"")).
+          to eq("\"hello world\"")
+    end
+
+  end
+end

data/spec/lib/yeti_logger/test_helper_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+class YetiLogger::TestLogger
+  include YetiLogger
+end
+
+
+describe YetiLogger::TestHelper do
+  include described_class
+
+  let(:instance) { YetiLogger::TestLogger.new }
+
+  before(:each) do
+    YetiLogger.logger.level = Logger::INFO
+    expect(YetiLogger.logger.level).to be > Logger::DEBUG
+  end
+
+  # NOTE: I'm using the block form here since YetiLogger does the level checking
+  # for blocks, rather than relying on the logger implementation.
+  describe '.with_log_level' do
+
+    context 'when not using with_log_level' do
+
+      it 'respects the log level' do
+        expect(YetiLogger.logger).to_not receive(:debug)
+        expect(YetiLogger.logger).to receive(:info).with('YetiLogger::TestLogger: info')
+
+        instance.log_debug { 'debug' }
+        instance.log_info { 'info' }
+      end
+
+      it 'can adjust the log level to log more' do
+        expect(YetiLogger.logger).to receive(:debug).with('YetiLogger::TestLogger: say')
+        with_log_level(Logger::DEBUG) do
+          instance.log_debug { 'say' }
+        end
+      end
+
+      it 'can adjust the log level to log less' do
+        expect(YetiLogger.logger).to_not receive(:warn)
+        with_log_level(Logger::ERROR) do
+          instance.log_warn { 'warn!' }
+        end
+      end
+
+    end
+
+  end
+
+  describe '.expect_to_see_log_messages' do
+    it 'has a singular form' do
+      expect_to_see_log_message('YetiLogger::TestLogger: foo', :warn) do
+        instance.log_warn('foo')
+      end
+    end
+
+    it 'checks for multiple messages' do
+      messages = [
+                  'YetiLogger::TestLogger: one',
+                  'YetiLogger::TestLogger: two'
+                 ]
+      expect_to_see_log_messages(messages, :info) do
+        instance.log_info('one')
+        instance.log_info('two')
+      end
+    end
+
+    it 'only stubs the log level you request' do
+      expect(YetiLogger.logger).to receive(:info).with('YetiLogger::TestLogger: info')
+
+      expect_to_see_log_message('YetiLogger::TestLogger: warn', :warn) do
+        instance.log_info { 'info' }
+        instance.log_warn { 'warn' }
+      end
+    end
+
+    it 'supports regexes' do
+      messages = [
+                  'YetiLogger::TestLogger: one',
+                  /two-\d/,
+                  'YetiLogger::TestLogger: three'
+                 ]
+      expect_to_see_log_messages(messages, :info) do
+        instance.log_info('one')
+        instance.log_info('two-7')
+        instance.log_info('three')
+      end
+    end
+
+    it 'fails when it cannot find the string message' do
+      expect do
+        expect_to_see_log_message('not there', :info) do
+          instance.log_info('one')
+        end
+      end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    it 'fails when it cannot find the regexp message' do
+      expect do
+        expect_to_see_log_message(/bazinga/, :info) do
+          instance.log_info('one')
+        end
+      end.to raise_exception(RuntimeError)
+    end
+
+    it 'fails when it runs out of messages to search through' do
+      expect do
+        messages = [
+                    'YetiLogger::TestLogger: one',
+                    /two-\d/,
+                    'YetiLogger::TestLogger: three',
+                    'YetiLogger::TestLogger: four'
+                   ]
+        expect_to_see_log_messages(messages, :info) do
+          instance.log_info('one')
+          instance.log_info('two-7')
+          instance.log_info('three')
+        end
+      end.to raise_exception(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+  end
+
+  describe '.should_log' do
+    it 'verifies a log message came through' do
+      should_log(:info).with("YetiLogger::TestLogger: hello!")
+      instance.log_info("hello!")
+    end
+  end
+
+  describe '.should_not_log' do
+    it 'verifies a log message does not happen' do
+      should_not_log(:info)
+      if false
+        instance.log_info("hello!")
+      end
+    end
+  end
+
+end