smart_logger_wrapper 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f193215b0f2007b0861602a5169acd5b6f4fe8a2
-  data.tar.gz: c6a426240e52e5f6d24fbfbe9151288f19115b57
+  metadata.gz: 558223eabf09d913bbcb7ff302e8324a898df644
+  data.tar.gz: 23d518a2d535c9fbd9a71ba4eb734d8402cff775
 SHA512:
-  metadata.gz: 4545b47f0bc02df95cbc5699ae8243990851b894fd17569705b31d2a0369d95f0a6c02603f9e61c7ba3a5eb5dc3d85ace00b700e23aab555ac87a5352a623e86
-  data.tar.gz: 45f5c6e4014e62913bba562bc61ed4b6da304ca091c53f0d08dbd274bf8f780a782c03917868a405849e4f4ec02b539dd0dcd8fa5ad0b8445a51dbc105426dff
+  metadata.gz: 8a5035037cd1fcde6dcd95fb7c8802c479ef11ade20dc8ebd9f11eb8c4e9f3f278e107f25b0bf8638fe3864708dd47a6114e193eeb1221a07b50d4e09a2ea8b5
+  data.tar.gz: e3c2fa794d687d95428e0c3a90a91a7d33a49a8dde282f42b1fd9a1448e40dc55aa09009e62cfce30be6ce15e591b67228ee30e15821f6344bfd991fc5ee26fc

data/README.md

@@ -1,6 +1,6 @@
 # SmartLoggerWrapper
 
-SmartLoggerWrapper adds some useful features to the Ruby Logger or the compatibles. See Usage below to find out how it benefits your development.
+SmartLoggerWrapper adds some useful features to the Ruby Logger or its subclasses. See Usage below to find out how it benefits your development.
 
 [![Build Status](https://travis-ci.org/akeyhero/smart_logger_wrapper.svg?branch=master)](https://travis-ci.org/akeyhero/smart_logger_wrapper)
 
@@ -29,7 +29,7 @@ Wrap your logger with `SmartLoggerWrapper`, for example, in `config/environments
 +  config.logger = SmartLoggerWrapper(Logger.new('log/production.log', 'daily')).with_position
 ```
 
-Note that it is strongly recommended to use the wrapper for all environments so that you can avoid exceptions such as `NoMethodError` due to the unique features of this library.
+Note that it is strongly recommended to use the wrapper for all kind of environments so that you can avoid exceptions such as `NoMethodError` due to the unique features of this library.
 
 You may want to put log messages to `STDOUT` in your development environment. Then:
 
@@ -44,7 +44,9 @@ You may want to put log messages to `STDOUT` in your development environment. Th
 
 ### Basic
 
-Initialize with a Ruby `Logger` or an instance of the compatibles (e.g. `ActiveSupport::TaggedLogging`):
+This wrapper mainly modifies the behaviors of the following methods: `debug`, `info`, `warn`, `error`, `fatal`, and `unknown`.
+
+To use this wrapper, initialize with a Ruby `Logger` or an instance of its subclass:
 
 ```ruby
 require 'logger'
@@ -58,8 +60,6 @@ logger.info 'Call logging methods as usual.'
 logger2 = SmartLoggerWrapper.new(Logger.new('log/development.log'), Logger.new(STDOUT))
 ```
 
-The compatibles must respond to `#add` with the same arguments as `Logger#add`.
-
 ### Feature 1: Integrate multiple logger calls
 
 `SmartLoggerWrapper` accepts multiple arguments like `puts` method does. Then the wrapped logger will be called for each of the arguments.

data/lib/smart_logger_wrapper/options/append_backtrace.rb

@@ -1,22 +1,21 @@
+require 'logger'
 require 'smart_logger_wrapper/options/base'
 require 'smart_logger_wrapper/utils/backtrace'
 
-class SmartLoggerWrapper
+class SmartLoggerWrapper < Logger
   module Options
     class AppendBacktrace < Base
       include ::SmartLoggerWrapper::Utils::Backtrace
 
-      def initialize(start)
-        super()
-        @start = start
-      end
-
-      def apply!(messages, value = nil)
+      def apply!(messages, value, logger)
         length = value.is_a?(Numeric) ? value : nil
-        messages << "BACKTRACE:\n" + get_backtrace(@start + 1, length).join("\n")
+        messages << [
+          'BACKTRACE:',
+          *get_backtrace(logger.offset + APPLY_CALLER_STACK_DEPTH + 1, length)
+        ].join("\n")
       end
     end
 
-    define_appender :append_backtrace, AppendBacktrace.new(APPLY_CALLER_STACK_DEPTH + 1)
+    define_appender :append_backtrace, AppendBacktrace.new
   end
 end

data/lib/smart_logger_wrapper/options/base.rb

@@ -1,7 +1,9 @@
-class SmartLoggerWrapper
+require 'logger'
+
+class SmartLoggerWrapper < Logger
   module Options
     class Base
-      def apply!(messages, value)
+      def apply!(messages, value, logger)
         raise NotImplementedError, __callee__
       end
     end

data/lib/smart_logger_wrapper/options/to.rb

@@ -1,9 +1,10 @@
+require 'logger'
 require 'smart_logger_wrapper/options/base'
 
-class SmartLoggerWrapper
+class SmartLoggerWrapper < Logger
   module Options
     class To < Base
-      def apply!(messages, value)
+      def apply!(messages, value, logger)
         raise ApplicationError, 'No handler given' if value == nil
         value.puts messages.join("\n")
       rescue NoMethodError => e

data/lib/smart_logger_wrapper/options/with_position.rb

@@ -1,20 +1,16 @@
+require 'logger'
 require 'smart_logger_wrapper/options/base'
 require 'smart_logger_wrapper/utils/path'
 
-class SmartLoggerWrapper
+class SmartLoggerWrapper < Logger
   module Options
     class WithPosition < Base
       include ::SmartLoggerWrapper::Utils::Path
 
-      def initialize(start)
-        super()
-        @start = start
-      end
-
-      def apply!(messages, value = nil)
+      def apply!(messages, value, logger)
         return if value == false
         # add 1 to `start` because this method dug the backtrace by 1
-        location = caller_locations(@start + 1, 1)
+        location = caller_locations(logger.offset + APPLY_CALLER_STACK_DEPTH + 1, 1)
         prefix =
           if location && location.length > 0
             method_name = location[0].label
@@ -28,6 +24,6 @@ class SmartLoggerWrapper
       end
     end
 
-    define_tagger :with_position, WithPosition.new(APPLY_CALLER_STACK_DEPTH + 1)
+    define_tagger :with_position, WithPosition.new
   end
 end

data/lib/smart_logger_wrapper/options.rb

@@ -1,15 +1,19 @@
-class SmartLoggerWrapper
+require 'logger'
+
+class SmartLoggerWrapper < Logger
   module Options
     class ApplicationError < StandardError; end
 
-    # XXX: Be careful! This relies strongly on the implementation of this and the callers
-    APPLY_CALLER_STACK_DEPTH = 4
+    # XXX: Be careful! This relies strongly on the implementation of this class
+    APPLY_CALLER_STACK_DEPTH = 2
 
     module_function
 
-    def apply_all!(messages, options)
+    def apply_all!(messages, logger)
       [defined_appenders, defined_taggers, defined_redirectors].flatten.each do |option_key|
-        defined_options[option_key].apply!(messages, options[option_key]) if options.include?(option_key)
+        if logger.options.include?(option_key)
+          defined_options[option_key].apply!(messages, logger.options[option_key], logger)
+        end
       end
     end
 

data/lib/smart_logger_wrapper/utils/backtrace.rb

@@ -1,6 +1,7 @@
+require 'logger'
 require 'smart_logger_wrapper/utils/path'
 
-class SmartLoggerWrapper
+class SmartLoggerWrapper < Logger
   module Utils
     module Backtrace
       module_function

data/lib/smart_logger_wrapper/utils/path.rb

@@ -1,4 +1,6 @@
-class SmartLoggerWrapper
+require 'logger'
+
+class SmartLoggerWrapper < Logger
   module Utils
     module Path
       DIR_TRIMMER_PATTERN = /^#{Dir.pwd}\/?/

data/lib/smart_logger_wrapper/version.rb

@@ -1,3 +1,5 @@
-class SmartLoggerWrapper
-  VERSION = "0.2.1"
+require 'logger'
+
+class SmartLoggerWrapper < Logger
+  VERSION = "0.3.0"
 end

data/lib/smart_logger_wrapper.rb

@@ -2,9 +2,11 @@ require 'logger'
 require 'smart_logger_wrapper/version'
 require 'smart_logger_wrapper/options'
 
-class SmartLoggerWrapper
+class SmartLoggerWrapper < Logger
   include Logger::Severity
 
+  LOGGER_SHORTCUT_OFFSET = 3
+
   SEVERITY_MAPPING = {
     debug:   DEBUG,
     info:    INFO,
@@ -14,33 +16,53 @@ class SmartLoggerWrapper
     unknown: UNKNOWN
   }.freeze
 
-  attr_reader :loggers, :options
+  attr_reader :loggers, :options, :offset
 
   def initialize(logger = Logger.new(STDOUT), *loggers, **options)
-    @loggers = [logger, *loggers]
-    @options = options
-  end
-
-  def add(severity, *args, &block)
-    _add(severity, *args, &block)
+    @loggers = [logger, *loggers].freeze
+    @options = options.freeze
+    @offset = LOGGER_SHORTCUT_OFFSET
+    @_loggers_cache = {}
+    @_loggers_with_offset_cache = {}
   end
-  alias log add
 
+  # For all methods with severity label, logger accepts multiple messages.
+  # The return value is the first logger's.
   SEVERITY_MAPPING.each do |severity_name, severity|
     define_method(severity_name) do |*args, &block|
-      _add(severity, *args, &block)
+      format_messages(*args, &block).map do |message|
+        add(severity, nil, message)
+      end.first
+    end
+  end
+
+  # Aside from #debug, #info, etc., all Logger instance methods are called for all the wrapped loggers.
+  # The return value is the first logger's.
+  (Logger.instance_methods(false) - SEVERITY_MAPPING.keys).each do |method_name|
+    define_method(method_name) do |*args, &block|
+      loggers.map do |logger|
+        logger.public_send(method_name, *args, &block)
+      end.first
     end
   end
 
+  def with_offset(_offset)
+    @_loggers_with_offset_cache[_offset] ||= clone.tap do |logger_with_offset|
+      logger_with_offset.instance_variable_set(:@offset, _offset)
+    end
+  end
+
+  def overwrite_options(_options)
+    @options = options.merge(_options).freeze
+  end
+
   private
 
-  # All methods calling this must have the synchronized call stack depth so that this can show neat positions and backtraces
-  def _add(severity, *args, &block)
+  def format_messages(*args, &block)
     messages = args.map { |arg| to_message(arg) }
     messages << to_message(block.call) if block_given?
     begin
-      Options.apply_all!(messages, options)
-      true
+      Options.apply_all!(messages, self)
     rescue Options::ApplicationError => e
       loggers.each do |logger|
         logger.error(<<~EOM)
@@ -48,14 +70,8 @@ class SmartLoggerWrapper
           #{e.backtrace.join("\n")}
         EOM
       end
-      false
-    end.tap do |succeeded|
-      messages.each do |message|
-        loggers.each do |logger|
-          logger.add(severity, nil, message)
-        end
-      end
     end
+    messages
   end
 
   def to_message(object)
@@ -74,15 +90,15 @@ class SmartLoggerWrapper
   def method_missing(method_name, *args, &block)
     if Options.defined_option?(method_name)
       # If there is an defined option with the same name as the method name, return a new logger with the option.
-      new_logger = self.class.new(*loggers, **options.merge(method_name => args.first))
+      arg = args.first
+      @_loggers_cache[method_name] = {} unless @_loggers_cache.include?(method_name)
+      new_logger = @_loggers_cache[method_name][arg] ||= clone.tap do |cloned|
+        cloned.overwrite_options(method_name => arg)
+      end
       return block.(new_logger) if block_given?
       new_logger
     else
-      # Otherwise, call the method of the warpped logger.
-      # The reutrn value is that of the first one.
-      loggers.map do |logger|
-        logger.public_send(method_name, *args, &block)
-      end.first
+      super
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_logger_wrapper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Akihiro Katsura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler