tagged_logger 0.1.2 → 0.2.0

data/Rakefile

@@ -12,16 +12,72 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |s|
     s.name = "tagged_logger"
-    s.summary = "Split your logging by using tags-based rules (tags are generated automatically)"
+    s.summary = "Detaches _what_ is logged from _how_ it is logged."
     s.email = "fkocherga@gmail.com"
     s.homepage = "http://github.com/fkocherga/tagged_logger"
-    s.description = <<END
-When you need to use logging for different code in different ways, 
-here is help for you: create tags-based rules for logging. Tags are 
-class names by default, so you do not have to specify them in 
-logger's #info, #warn and similar calls. Rules are just code blocks, 
-so any logging facility could be used underneath:  standard library 
-Logger, log4r, writing to STDOUT or something else.
+    s.description = <<'END'
+This gem supposed to help you to forget about how to expose logging 
+facitilities to the code you write. Any time you want to log something, 
+simply do one of: 
+   logger.debug("verbose debug information") #or
+   logger.warn("warning")  #or 
+   logger.info("information you frequently want to see") #or
+   logger.error("errors") #or
+   logger.fatal("fatal errors") 
+
+and do not worry about where the '#logger' is and what it does at the moment,
+you will have a chance to configure it in place where you confugure other things.
+So you may focus on _what_ to put in the logging rather on how to set it up. 
+Later you may turn logging on for specific class or bunch of classes or in case
+you have special logging demands for specific classes you also may specify it 
+in very simple way.
+
+The simplest way to turn logging on for every class whose methods calls '#logger':
+
+    TaggedLogger.rules do
+      out_everything_to Logger.new(STDOUT)
+    end
+
+or you may cook it in your special way:
+
+    TaggedLogger.rules do
+      out /.*/ do |level, tag, msg|
+        puts "#{level}-#{tag}: #{msg}"
+      end
+    end
+
+Where 'tag' is the simple class name whose method calls '#logger'. Note, 
+you do not have to implement '#logger' method anywhere. It gets 
+automatically generated by specifying any of 'out' rules.
+  You may be even more picky about what and where to log. Imagine 
+you have 'Network' and 'Database' classes and you want to have 
+separate log files for them, it is easy:
+
+    TaggedLogger.rules do
+      out Network => Logger.new("network.log")
+      out Database => Logger.new("database.log")
+    end
+   
+In case you want to define common log for several classes:
+
+  TaggedLogger.rules do
+    out [Ftp, Http, Sockets] => Logger.new("network.log")
+  end 
+
+Or if you want to have all these classes showing up under common 
+tag 'Network' in standard output:
+
+    TaggedLogger.rules do
+      out_everything_to Logger.new(STDOUT)
+      rename [Ftp, Http, Sockets] => :Network
+    end
+   
+You may also use regular expressions in your rules:
+
+  TaggedLogger.rules do
+    out /Active::/ => Logger.new("active.log")
+  end
+
 END
     s.authors = ["Fedor Kocherga"]
     s.test_files = ['test/test.rb']

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/active.log

@@ -0,0 +1,2 @@
+# Logfile created on Sun Dec 20 19:27:33 -0600 2009 by /
+I, [2009-12-20T19:27:33.951440 #36852]  INFO -- : Active::Base: foo

data/database.log

@@ -0,0 +1,2 @@
+# Logfile created on Sun Dec 20 19:27:20 -0600 2009 by /
+I, [2009-12-20T19:27:20.352239 #36844]  INFO -- : Database: foo

data/examples/one_log_per_classes.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+class LogFoo
+  def foo
+    logger.info("foo")
+  end
+end
+
+Ftp = Class.new LogFoo
+Http = Class.new LogFoo
+Sockets = Class.new LogFoo
+
+`rm -f network.log`
+TaggedLogger.rules do
+  out [Ftp, Http, Sockets] => Logger.new("network.log")
+end 
+
+[Ftp, Http, Sockets].each { |c| c.new.foo }
+IO.foreach('network.log') { |line| puts line }

data/examples/one_tag_per_classes.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+module LogFoo
+  def foo
+    logger.info("#{self.class}#foo")
+  end
+end
+
+Ftp = Class.new { include LogFoo }
+Http = Class.new { include LogFoo }
+Sockets = Class.new { include LogFoo }
+
+TaggedLogger.rules do
+  out_everything_to Logger.new(STDOUT)
+  rename [Ftp, Http, Sockets] => :Network
+end
+
+[Ftp, Http, Sockets].each { |c| c.new.foo }
+

data/examples/per_class_customization.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+class LogFoo
+  def foo
+    logger.info("foo")
+  end
+end
+
+Database = Class.new LogFoo
+Network = Class.new LogFoo
+
+`rm -f network.log`
+`rm -f database.log`
+
+TaggedLogger.rules do
+  out Network => Logger.new("network.log")
+  out Database => Logger.new("database.log")
+end
+
+Database.new.foo
+Network.new.foo

data/examples/rule_with_regex.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+module Active
+  class Base
+    def foo
+      logger.info("foo")
+    end
+  end
+end
+
+`rm -f active.log`
+
+TaggedLogger.rules do
+  out /Active::/ => Logger.new("active.log")
+end
+
+Active::Base.new.foo

data/examples/simplest_customization.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'tagged_logger'
+
+TaggedLogger.rules do
+  out /.*/ do |level, tag, msg|
+    puts "#{level}-#{tag}: #{msg}"
+  end
+end
+
+logger.info("message")

data/examples/simplest_usage.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+TaggedLogger.rules do
+  out_everything_to Logger.new(STDOUT)
+end
+
+class A
+  def foo
+    logger.warn "foo"
+  end
+  logger.debug "A parsed"
+end
+
+
+logger.info("Hello word!")
+A.new.foo

data/lib/tagged_logger.rb

@@ -1,60 +1,107 @@
 require 'delegate'
+require 'facets/dictionary'
 
 class TaggedLogger
-
-  attr_reader :tags_map
-  def initialize()
-    @tags_map = {}
-  end
-
-  @@tagged_logger = self.new
-  
-  def log(level, tag, msg)
-    remapped_tag = remap(tag)
-    find_blocks(remapped_tag).each { |b| b.call(level, remapped_tag, msg) }
-  end
+  @logger_generator_exists = false
+  @rename_rules = Dictionary.new
+  @tag_blocks = Dictionary.new
   
-  def for_tag(*args, &block)
-    tags = args
-    tags.each do |tag|
-      case tag
-      when Regexp then rules[args.first] = block
-      when Class then rules[Regexp.new("^#{tag.to_s}$")] = block
-      when Array then args.first.each {|e| for_tag(tag, block)}
-      when Symbol then rules[Regexp.new("^#{tag.to_s}$")] = block
+  class << self
+    def reset
+      @rename_rules = Dictionary.new
+      @tag_blocks = Dictionary.new
+    end
+    
+    def rules(&block)
+      instance_eval(&block)
+    end
+    
+    def log(level, tag, msg)
+      tag_aliases(tag) do |tag_alias|
+        tag_blocks(tag_alias) do |tag_block|
+          tag_block.call(level, tag_alias, msg)
+        end
       end
     end
-  end
-  
-  
-  class << self
     
-    def replace_tags(tags, with)
-      with_tag = with[:with] 
-      raise ArgumentError.new(":with => <tag> has to be specified") unless with_tag
-      @@tagged_logger.instance_eval do
-        tags.each {|t| @tags_map[t.to_s] = with_tag}
+    def out_everything_to(logger = nil, &block)
+      if logger && block
+        raise ArgumentError, "Either block or logger has to be specified, but not both."
       end
+      out /.*/ => logger if logger
+      oout &block if block
     end
     
-    def reset
-      @@tagged_logger.instance_eval do
-        @rules = {}
-        @tags_map = {}
+    def out(spec, &block)
+      add_logger_generator_in_Object
+      if spec.is_a? Hash
+        spec.each do |what, where|
+          @tag_blocks[tag_matcher(what)] = lambda { |level, tag, msg | where.send(level, "#{tag}: #{msg}") }
+        end
+        raise ArgumentError "No block should be specified in this 'out' rule" if block
+      else
+        raise ArgumentError "Block has to be specified in this 'out' rule" unless block
+        @tag_blocks[tag_matcher(spec)] = block
       end
     end
-  
-    def use_in_every_class
-      #Object#logger when called generates <self.class>#logger (only once)
-      #returning logger knowing what tags to use for self.class and passing them to delegator which is
-      #instance (singleton) of TaggedLogger
+    
+    def rename(renames)
+      renames.each { |from, to| @rename_rules[tag_matcher(from)] = to }
+    end
+    
+    private
+    class TagMatcher
+      attr_reader :match_spec
+      
+      def initialize(match_spec)
+        @match_spec = match_spec
+      end
+      
+      def match?(tag)
+        self.class.match?(@match_spec, tag)
+      end
+      
+      def self.match?(spec, tag)
+        t = tag.to_s
+        case spec
+        when Regexp 
+          t =~ spec
+        when Class 
+          t == spec.name
+        when Array 
+          spec.any? {|s| match?(s, tag)}
+        else
+          spec.to_s == t
+        end
+      end
+    end #TagMatcher
+    
+    def tag_matcher(tag)
+      TagMatcher.new(tag)
+    end
+    
+    def tag_aliases(tag, &block)
+      current_name = tag
+      @rename_rules.each { |from, to| current_name = to if from.match?(tag) }
+      block.call(current_name)
+    end
+    
+    def tag_blocks(tag, &block)
+      @tag_blocks.each do |matcher, block|
+        yield block if matcher.match? tag
+      end
+    end
+    
+    def add_logger_generator_in_Object
+      return if @logger_generator_exists
+      @logger_generator_exists = true
       Object.send(:define_method, "logger") do
         self.class.class_eval do
           attr_reader :class_logger
           @class_logger = nil
           def logger
             return class_logger if class_logger
-            @class_logger = SimpleDelegator.new(@@tagged_logger)
+            @class_logger = SimpleDelegator.new(TaggedLogger)
             class_logging_tag = self.class == Class ?  self.to_s : self.class.to_s 
             [:debug, :warn, :info, :error, :fatal].each do |method|
               (class << @class_logger;self;end).instance_eval do
@@ -68,34 +115,7 @@ class TaggedLogger
         end
         logger
       end
-      if block_given?
-        @@tagged_logger.for_tag /.*/ do |level, tag, what|
-          yield(level, tag, what)
-        end
-      end
     end
     
-    def for_tag(*args, &block)
-      @@tagged_logger.for_tag(*args, &block)
-    end
   end # class methods
-
-  private
-  def rules
-    @rules ||= {}
-  end
-  
-  def find_blocks(tag)
-    compare_with = tag.to_s
-    result = []
-    rules.each do |rule, block|
-      result << block if compare_with =~ rule
-    end
-    result
-  end
-  
-  def remap(tag)
-    return tag unless @tags_map.key? tag
-    @tags_map[tag]
-  end
 end

data/network.log

@@ -0,0 +1,2 @@
+# Logfile created on Sun Dec 20 19:27:20 -0600 2009 by /
+I, [2009-12-20T19:27:20.356509 #36844]  INFO -- : Network: foo

data/tagged_logger.gemspec

@@ -1,21 +1,77 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{tagged_logger}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fedor Kocherga"]
-  s.date = %q{2009-10-13}
-  s.description = %q{When you need to use logging for different code in different ways, 
-here is help for you: create tags-based rules for logging. Tags are 
-class names by default, so you do not have to specify them in 
-logger's #info, #warn and similar calls. Rules are just code blocks, 
-so any logging facility could be used underneath:  standard library 
-Logger, log4r, writing to STDOUT or something else.
+  s.date = %q{2009-12-20}
+  s.description = %q{This gem supposed to help you to forget about how to expose logging 
+facitilities to the code you write. Any time you want to log something, 
+simply do one of: 
+   logger.debug("verbose debug information") #or
+   logger.warn("warning")  #or 
+   logger.info("information you frequently want to see") #or
+   logger.error("errors") #or
+   logger.fatal("fatal errors") 
+
+and do not worry about where the '#logger' is and what it does at the moment,
+you will have a chance to configure it in place where you confugure other things.
+So you may focus on _what_ to put in the logging rather on how to set it up. 
+Later you may turn logging on for specific class or bunch of classes or in case
+you have special logging demands for specific classes you also may specify it 
+in very simple way.
+
+The simplest way to turn logging on for every class whose methods calls '#logger':
+
+    TaggedLogger.rules do
+      out_everything_to Logger.new(STDOUT)
+    end
+
+or you may cook it in your special way:
+
+    TaggedLogger.rules do
+      out /.*/ do |level, tag, msg|
+        puts "#{level}-#{tag}: #{msg}"
+      end
+    end
+
+Where 'tag' is the simple class name whose method calls '#logger'. Note, 
+you do not have to implement '#logger' method anywhere. It gets 
+automatically generated by specifying any of 'out' rules.
+  You may be even more picky about what and where to log. Imagine 
+you have 'Network' and 'Database' classes and you want to have 
+separate log files for them, it is easy:
+
+    TaggedLogger.rules do
+      out Network => Logger.new("network.log")
+      out Database => Logger.new("database.log")
+    end
+   
+In case you want to define common log for several classes:
+
+  TaggedLogger.rules do
+    out [Ftp, Http, Sockets] => Logger.new("network.log")
+  end 
+
+Or if you want to have all these classes showing up under common 
+tag 'Network' in standard output:
+
+    TaggedLogger.rules do
+      out_everything_to Logger.new(STDOUT)
+      rename [Ftp, Http, Sockets] => :Network
+    end
+   
+You may also use regular expressions in your rules:
+
+  TaggedLogger.rules do
+    out /Active::/ => Logger.new("active.log")
+  end
+
 }
   s.email = %q{fkocherga@gmail.com}
   s.extra_rdoc_files = [
@@ -27,7 +83,16 @@ Logger, log4r, writing to STDOUT or something else.
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "active.log",
+     "database.log",
+     "examples/one_log_per_classes.rb",
+     "examples/one_tag_per_classes.rb",
+     "examples/per_class_customization.rb",
+     "examples/rule_with_regex.rb",
+     "examples/simplest_customization.rb",
+     "examples/simplest_usage.rb",
      "lib/tagged_logger.rb",
+     "network.log",
      "tagged_logger.gemspec",
      "tagged_logger.rb",
      "test/test.rb"
@@ -36,7 +101,7 @@ Logger, log4r, writing to STDOUT or something else.
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Split your logging by using tags-based rules (tags are generated automatically)}
+  s.summary = %q{Detaches _what_ is logged from _how_ it is logged.}
   s.test_files = [
     "test/test.rb"
   ]
@@ -51,3 +116,4 @@ Logger, log4r, writing to STDOUT or something else.
   else
   end
 end
+

data/test/test.rb

@@ -16,29 +16,29 @@ end
 
 class TaggedLoggerTest < Test::Unit::TestCase
   
-  context "#logger() generated for every class, logging goes to String @out;" do
+  context "#logger() generated for every class, logging goes to String @out1;" do
     setup do 
-      @out = TestLogDevice.new
-      @standard_logger = Logger.new(@out)
+      @out1 = TestLogDevice.new
+      standard_logger = Logger.new(@out1)
       @formatter = lambda {|severity, datetime, progname, msg| "#{msg}"}
-      @standard_logger.formatter = @formatter
-      TaggedLogger.reset
-      TaggedLogger.use_in_every_class do |level, tag, what|
-        @standard_logger.send(level, "#{tag}: #{what}")
+      standard_logger.formatter = @formatter
+      TaggedLogger.rules do
+        reset
+        out_everything_to standard_logger
       end
     end
     
     should "include #logger in every class" do
       assert Class.new.methods.include? "logger"
     end
-
+    
     should "do logging with different levels" do
       NewClass = Class.new
       obj = NewClass.new
       %w[debug info warn error fatal].each do |method|
         assert obj.logger.methods.include? method
         obj.logger.send(method.intern, method)
-        assert_equal "#{obj.class}: #{method}", @out.to_s
+        assert_equal "#{obj.class}: #{method}", @out1.to_s
       end
     end
 
@@ -56,11 +56,16 @@ class TaggedLoggerTest < Test::Unit::TestCase
       end
       
       should "be possible to replace tags for A, B classes with single tag TEST making rules for A and B obsolete" do
-        TaggedLogger.replace_tags [A, B], :with => :TEST
+        TaggedLogger.rules do
+          rename [A,B] => :TEST
+        end
+        
         @a.foo
-        assert_equal "TEST: foo", @out.to_s
+        assert_equal "TEST: foo", @out1.to_s
+        @out1.clear
+        
         @b.foo
-        assert_equal "TEST: foo", @out.to_s
+        assert_equal "TEST: foo", @out1.to_s
       end
 
       context "specialized logging" do
@@ -70,32 +75,50 @@ class TaggedLoggerTest < Test::Unit::TestCase
           @logger2.formatter = @formatter
         end
         
-        should "be possible to speialize logging for tag A" do
-          TaggedLogger.for_tag A do |level, tag, what|
-            @logger2.send(level, "#{level}---#{tag}---#{what}")
+        should "be possible to speialize logging for tag A by specifying different logger" do
+          logger2 = @logger2
+          TaggedLogger.rules do
+            out A => logger2
+          end
+          @a.foo
+          assert_equal "#{self.class}::A: foo", @out1.to_s
+          assert_equal "#{self.class}::A: foo", @out2.to_s
+          @out2.clear
+          @b.foo
+          assert_equal "#{self.class}::B: foo", @out1.to_s
+          assert_equal "", @out2.to_s
+        end
+
+        should "be possible to speialize logging for tag A by providing block" do
+          logger2 = @logger2
+          TaggedLogger.rules do
+            out A do |level, tag, msg| 
+              logger2.send(level, msg)
+            end
           end
           @a.foo
-          assert_equal "#{self.class}::A: foo", @out.to_s
-          assert_equal "info---#{self.class}::A---foo", @out2.to_s
+          assert_equal "#{self.class}::A: foo", @out1.to_s
+          assert_equal "foo", @out2.to_s
           @out2.clear
           @b.foo
-          assert_equal "#{self.class}::B: foo", @out.to_s
+          assert_equal "#{self.class}::B: foo", @out1.to_s
           assert_equal "", @out2.to_s
         end
         
         should "be possible to replace tags for A, B classes with single tag TEST and specialize logging for it" do
-          TaggedLogger.replace_tags [A, B], :with => :TEST 
-          TaggedLogger.for_tag :TEST do |level, tag, what|
-            @logger2.send(level, "#{level}---#{tag}---#{what}")
+          logger2 = @logger2
+          TaggedLogger.rules do
+            rename [A, B] => :TEST
+            out :TEST => logger2 
           end
           @a.foo
-          assert_equal "TEST: foo", @out.to_s
-          assert_equal "info---TEST---foo", @out2.to_s
-          @out.clear
+          assert_equal "TEST: foo", @out1.to_s
+          assert_equal "TEST: foo", @out2.to_s
+          @out1.clear
           @out2.clear
           @b.foo
-          assert_equal "TEST: foo", @out.to_s
-          assert_equal "info---TEST---foo", @out2.to_s
+          assert_equal "TEST: foo", @out1.to_s
+          assert_equal "TEST: foo", @out2.to_s
         end
         
         should "use default tag equal to class name for class methods" do
@@ -103,7 +126,7 @@ class TaggedLoggerTest < Test::Unit::TestCase
             logger.info "bar"
           end
           A.bar
-          assert_equal "#{self.class}::A: bar", @out.to_s
+          assert_equal "#{self.class}::A: bar", @out1.to_s
         end
       end
       

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tagged_logger
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Fedor Kocherga
@@ -9,18 +9,73 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-13 00:00:00 +04:00
+date: 2009-12-20 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
-description: |
-  When you need to use logging for different code in different ways, 
-  here is help for you: create tags-based rules for logging. Tags are 
-  class names by default, so you do not have to specify them in 
-  logger's #info, #warn and similar calls. Rules are just code blocks, 
-  so any logging facility could be used underneath:  standard library 
-  Logger, log4r, writing to STDOUT or something else.
-
+description: |+
+  This gem supposed to help you to forget about how to expose logging 
+  facitilities to the code you write. Any time you want to log something, 
+  simply do one of: 
+     logger.debug("verbose debug information") #or
+     logger.warn("warning")  #or 
+     logger.info("information you frequently want to see") #or
+     logger.error("errors") #or
+     logger.fatal("fatal errors") 
+  
+  and do not worry about where the '#logger' is and what it does at the moment,
+  you will have a chance to configure it in place where you confugure other things.
+  So you may focus on _what_ to put in the logging rather on how to set it up. 
+  Later you may turn logging on for specific class or bunch of classes or in case
+  you have special logging demands for specific classes you also may specify it 
+  in very simple way.
+  
+  The simplest way to turn logging on for every class whose methods calls '#logger':
+  
+      TaggedLogger.rules do
+        out_everything_to Logger.new(STDOUT)
+      end
+  
+  or you may cook it in your special way:
+  
+      TaggedLogger.rules do
+        out /.*/ do |level, tag, msg|
+          puts "#{level}-#{tag}: #{msg}"
+        end
+      end
+  
+  Where 'tag' is the simple class name whose method calls '#logger'. Note, 
+  you do not have to implement '#logger' method anywhere. It gets 
+  automatically generated by specifying any of 'out' rules.
+    You may be even more picky about what and where to log. Imagine 
+  you have 'Network' and 'Database' classes and you want to have 
+  separate log files for them, it is easy:
+  
+      TaggedLogger.rules do
+        out Network => Logger.new("network.log")
+        out Database => Logger.new("database.log")
+      end
+     
+  In case you want to define common log for several classes:
+  
+    TaggedLogger.rules do
+      out [Ftp, Http, Sockets] => Logger.new("network.log")
+    end 
+  
+  Or if you want to have all these classes showing up under common 
+  tag 'Network' in standard output:
+  
+      TaggedLogger.rules do
+        out_everything_to Logger.new(STDOUT)
+        rename [Ftp, Http, Sockets] => :Network
+      end
+     
+  You may also use regular expressions in your rules:
+  
+    TaggedLogger.rules do
+      out /Active::/ => Logger.new("active.log")
+    end
+  
 email: fkocherga@gmail.com
 executables: []
 
@@ -34,7 +89,16 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- active.log
+- database.log
+- examples/one_log_per_classes.rb
+- examples/one_tag_per_classes.rb
+- examples/per_class_customization.rb
+- examples/rule_with_regex.rb
+- examples/simplest_customization.rb
+- examples/simplest_usage.rb
 - lib/tagged_logger.rb
+- network.log
 - tagged_logger.gemspec
 - tagged_logger.rb
 - test/test.rb
@@ -65,6 +129,6 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Split your logging by using tags-based rules (tags are generated automatically)
+summary: Detaches _what_ is logged from _how_ it is logged.
 test_files: 
 - test/test.rb