tagged_logger 0.2.5 → 0.3.0

data/CHANGES.markdown

@@ -2,12 +2,48 @@
 
 ## Version 0.2.5
 
-* If somebody is not ready to define any logging rules, but still want to use #logger everywhere, use new _init()_ method:
+* If somebody is not ready to define any logging rules, but still want to use *#logger()* everywhere:
 
-    _TaggedLogger.init_
+        TaggedLogger.init
 
-* Runs about 3 times faster by executing code responsible for rule matching to the first _#logger()_ call and "precompiling" it.
-So rather than iterating over **all** rules on every _#logger_ call only subset of rules specific to _#logger()_ callee are executed.
+* Runs about 3 times faster by executing code responsible for rule matching on the first *#logger()* call and "precompiling" it.
+So rather than iterating over **all** rules on every _#logger_ call only subset of rules specific to *#logger()* callee get executed.
 
 * Code simplified
    
+## Version 0.3.0
+
+* The DSL for defining rules is changed - instead of
+
+        output /A/ => ...
+
+    use one of:
+  
+        debug /A/, :to => ...
+        info  /A/, :to => ...
+        warn  /A/, :to => ...
+        error /A/, :to => ...
+        fatal /A/, :to => ...
+
+    and instead of 
+
+        output /A/ do
+          #...
+        end
+    
+    use 
+
+        debug /A/ do #or #info, #warn, #error, #fatal
+          #...
+        end  
+
+
+    These rules are more specific since they name logging level explictly which makes DSL shorter, 
+    also such form has allowed to make some optimization.
+
+* The *#format()* could be used inside *rules* block:
+
+        TaggedLogger.rules do
+          format { |level, tag, msg| "#{level}-#{tag}: #{msg}\n"}
+          info /.*/, :to => Logger.new(STDOUT)
+        end

data/README.html

@@ -11,11 +11,11 @@
 
 <h2 id='what_is_it_for'>What is it for?</h2>
 
-<p>Everytime you want to log something, simply write:</p>
+<p>Every time you want to log something, simply write:</p>
 
-<pre><code>logger.debug(&quot;verbose debug information&quot;) #warn, #info, #error, #fatal also work</code></pre>
+<pre><code>logger.debug(&quot;verbose debug information&quot;) #warn, #info, #error, #fatal also works</code></pre>
 
-<p>and do not worry about what kind of logger you use and how your code accesses it. You may confugure these things later, one day writing to STDOUT works for you, another day you&#8217;ll need something more sofisticated - like several log files each serving different components, and for different audience.</p>
+<p>and do not worry about what kind of logger you use and how your code accesses it. You may configure these things later, one day writing to STDOUT works for you, another day you&#8217;ll need something more sophisticated, like several log files each serving different components and for different audience.</p>
 
 <h2 id='installation'>Installation</h2>
 
@@ -23,69 +23,108 @@
 
 <h2 id='usage'>Usage</h2>
 
-<p>The simplest way to turn logging on for every class whose methods calls <em>#logger</em></p>
+<p>After specifying some logging rules:</p>
 
 <pre><code>TaggedLogger.rules do
-  out_everything_to Logger.new(STDOUT)
+  info A, :to =&gt; Logger.new(&quot;log_for_A_class.log&quot;) #1 rule
+  error /.*/, :to =&gt; Logger.new(ERROR)             #2 rule
+  info /.*/, :to =&gt; Logger.new(STDOUT)             #3 rule
 end</code></pre>
 
-<p>From now on you may call <em>#logger</em> from anywhere, for example:</p>
+<p>the following will happen:</p>
 
-<pre><code>class IWantToLogThis
-  def foo
-    logger.warn &quot;foo&quot;
-  end
-end</code></pre>
+<ol>
+<li>
+<p>The <em>#logger()</em> method becomes available <strong>everywhere</strong>, so it is completely safe to have a code like:</p>
+
+<pre><code> class A
+   def foo
+      logger.info(&quot;Something interesting happened in A#foo&quot;) #goes to STDOUT and to &#39;log_for_A_class.log&#39; file
+      logger.debug(&quot;I want to see some details.&quot;) #goes nowhere
+   end
+ end
+ logger.error(&quot;#logger is available everywhere&quot;) #goes to STDERR
+ class B
+    logger.warn(&quot;#logger is available everywhere&quot;) #goes to STDOUT
+ end     </code></pre>
+</li>
+
+<li>
+<p>The A&#8217;s <em>logger.info()</em> output will show up in two destinations:</p>
+
+<ul>
+<li>
+<p>in STDOUT, as defined by rule #3</p>
+</li>
+
+<li>
+<p>in &#8216;log_for_A_class.log&#8217; file, as defined by rule #1</p>
+</li>
+</ul>
+</li>
 
-<p>and after execution of:</p>
+<li>
+<p>From <strong>wherever</strong> it gets called from:</p>
 
-<pre><code>IWantToLogThis.new.foo</code></pre>
+<pre><code> logger.error(&quot;ERROR&quot;) #will print &#39;ERROR&#39; in standard error
+ logger.info(&quot;INFO&quot;)  #will print &#39;INFO&#39; in standard output
+ logger.debug(&quot;DEBUG&quot;) #will not print anything, since there is no &#39;debug&#39; rule</code></pre>
+</li>
+</ol>
 
-<p>you will see somewhat like:</p>
+<p>The <em>#logger()</em> returns some object having methods: <em>#debug(), #info(), #warn(), #error() and #fatal()</em>. These method have generated on first <em>#logger()</em> call and contain only necessary code to meet rules. It means, for example, that if no rules defined all these methods do nothing. It is done for performance reasons, I like to log a lot and I do not want calls like <em>#logger.debug()</em> slowing down production code.</p>
 
-<pre><code>W, [2009-12-20T21:45:02.443524 #37166]  WARN -- : IWantToLogThis: foo</code></pre>
+<p>The simplest way to have a <em>#logger()</em> available everywhere without specifying any rules is:</p>
+
+<pre><code>TaggedLogger.init</code></pre>
+
+<p>No rules specified, therefore whenever you call <em>logger.debug()</em> (or alike) you actually paying for just an empty method execution. You may specify rules later, now you may stay focused on code you are writing.</p>
 
 <p>You may define your own formatting:</p>
 
 <pre><code>TaggedLogger.rules do
-  out /.*/ do |level, tag, msg|
-    puts &quot;#{level}-#{tag}: #{msg}&quot;
-  end
+  format {|level, tag, message| &quot;#{level}-#{tag}: #{msg}&quot;}
 end</code></pre>
 
-<p>The &#8216;/.*/&#8217; says that rule is applied for every class (i.e. class name matches /.*/). The <em>level</em> and <em>msg</em> semantics should be obvious, they are severity threshold and being logged message, but <em>tag</em> is something not so obvious - it is class name whose method calls <em>#logger</em>. In example above tag is &#8220;IWantToLogThis&#8221; since <em>IWantToLogThis#foo</em> calls <em>#logger</em>. Note the <em>#logger</em> does not have <em>tag</em> parameter - tags defined automatically and they are always class names.</p>
+<p>Each <em>#format()</em> call overrides previous format. If you are wondering what the heck the &#8216;tag&#8217; is - the answer is simple. The tag is a class name whose method calls <em>#logger()</em>. This is what allows to specify rules for classes or namespaces and this is what the <em>tagged_logger</em> plugin is named after.</p>
 
-<p>If you decided to have separate log files for classes <em>Network</em> and <em>Database</em>:</p>
+<p>Lets see how you may use it. For example you want to have separate log files for classes <em>Network</em> and <em>Database</em>:</p>
 
 <pre><code>TaggedLogger.rules do
-  out Network =&gt; Logger.new(&quot;network.log&quot;)
-  out Database =&gt; Logger.new(&quot;database.log&quot;)
+  debug Network, :to =&gt; Logger.new(&quot;network.log&quot;)
+  debug Database, :to =&gt; Logger.new(&quot;database.log&quot;)
 end</code></pre>
 
 <p>In case you want to define common log for several classes:</p>
 
 <pre><code>TaggedLogger.rules do
-  out [Ftp, Http, Sockets] =&gt; Logger.new(&quot;network.log&quot;)
+  debug [Ftp, Http, Sockets], :to =&gt; Logger.new(&quot;network.log&quot;)
 end </code></pre>
 
 <p>Or if you want to have all these classes showing up under common tag <em>Network</em> in standard output:</p>
 
 <pre><code>TaggedLogger.rules do
-  out_everything_to Logger.new(STDOUT)
+  info /.*/, :to =&gt; Logger.new(STDOUT)
   rename [Ftp, Http, Sockets] =&gt; :Network
 end</code></pre>
 
 <p>You may also use regular expressions in your rules:</p>
 
 <pre><code>TaggedLogger.rules do
-  out /Active::/ =&gt; Logger.new(&quot;active.log&quot;)
+  info /Active::/, :to =&gt; Logger.new(&quot;active.log&quot;)
 end</code></pre>
 
 <h2 id='license'>License</h2>
 
-<p>TaggedLogger is released under the MIT license.</p>
+<p><em>TaggedLogger</em> is released under the MIT license.</p>
+
+<h2 id='shortcomings'>Shortcomings</h2>
 
-<h2 id='shortcumings'>Shortcumings</h2>
+<p>The <em>#info(), #debug(), #warn(), #error(), #fatal()</em> rules when have form like <em>:to =&gt; logger</em>, the <em>logger</em> <strong>has</strong> to be an object of standard library <em>Logger</em> class. If you need to use different sort of logger the more general rules form could is:</p>
 
-<p>Was not tested with <em>log4r</em></p>
+<pre><code>TaggedLogger.rules do
+  info /Whatever/ do |level, tag, message|
+    #do your special logging here
+  end      
+end</code></pre>
 </body></html>

data/README.markdown

@@ -4,7 +4,7 @@ Detaches **what** is logged from **how** it is logged.
 ## What is it for?
 Every time you want to log something, simply write:
 
-    logger.debug("verbose debug information") #warn, #info, #error, #fatal also work
+    logger.debug("verbose debug information") #warn, #info, #error, #fatal also works
 
 and do not worry about what kind of logger you use and how your code accesses it.
 You may configure these things later, one day writing to STDOUT works for you, another
@@ -16,75 +16,106 @@ different components and for different audience.
 
 ## Usage
 
-The simplest way to turn logging on for every class whose methods calls *#logger*
-
+After specifying some logging rules:
+    
     TaggedLogger.rules do
-      output_everything_to Logger.new(STDOUT)
+      info A, :to => Logger.new("log_for_A_class.log") #1 rule
+      error /.*/, :to => Logger.new(ERROR)             #2 rule
+      info /.*/, :to => Logger.new(STDOUT)             #3 rule
     end
 
-From now on you may call *#logger* from anywhere, for example:
-    
-    class IWantToLogThis
-      def foo
-        logger.warn "foo"
-      end
-    end
+the following will happen:
+
+1. The *#logger()* method becomes available **everywhere**, so it is completely safe to have a code like:
+
+        class A
+          def foo
+             logger.info("Something interesting happened in A#foo") #goes to STDOUT and to 'log_for_A_class.log' file
+             logger.debug("I want to see some details.") #goes nowhere
+          end
+        end
+        logger.error("#logger is available everywhere") #goes to STDERR
+        class B
+           logger.warn("#logger is available everywhere") #goes to STDOUT
+        end     
+
+2. The A's *logger.info()* output will show up in two destinations:
+ 
+    - in STDOUT, as defined by rule #3
+
+    - in 'log_for_A_class.log' file, as defined by rule #1
 
-and after execution of:
+3. From **wherever** it gets called from:
 
-    IWantToLogThis.new.foo
+        logger.error("ERROR") #will print 'ERROR' in standard error
+        logger.info("INFO")  #will print 'INFO' in standard output
+        logger.debug("DEBUG") #will not print anything, since there is no 'debug' rule
 
-you will see somewhat like:
 
-    W, [2009-12-20T21:45:02.443524 #37166]  WARN -- : IWantToLogThis: foo
+The *#logger()* returns some object having methods: *#debug(), #info(), #warn(), #error() and #fatal()*. 
+These methods have generated on first *#logger()* call and contain only necessary code to meet rules.
+It means, for example, that if no rules defined all these methods do nothing. It is done for performance
+reasons, I like to log a lot and I do not want calls like *#logger.debug()* slowing down production code.
+ 
+
+The simplest way to have a *#logger()* available everywhere without specifying any rules is:
+
+    TaggedLogger.init
+
+No rules specified, therefore whenever you call *logger.debug()* (or alike) you actually paying for just an empty method
+execution. You may specify rules later, now you may stay focused on code you are writing.
 
 
 You may define your own formatting:
 
     TaggedLogger.rules do
-      output /.*/ do |level, tag, msg|
-        puts "#{level}-#{tag}: #{msg}"
-      end
+      format {|level, tag, message| "#{level}-#{tag}: #{msg}"}
     end
 
-The '/.\*/' says that rule is applied for every class (i.e. class name matches /.\*/). 
-The *level* and *msg* semantics should be obvious, they are severity threshold 
-and being logged message, but *tag* is something not so obvious - it is class name whose
-method calls *#logger*. In example above tag is "IWantToLogThis" since *IWantToLogThis#foo* 
-calls *#logger*. Note the *#logger* does not have *tag* parameter - tags defined automatically
-and they are always class names.
-
+Each *#format()* call overrides previous format.
+If you are wondering what the heck the 'tag' is - the answer is simple. The tag is a class name
+whose method calls *#logger()*. This is what allows to specify rules for classes or namespaces and this 
+is what the *tagged_logger* plugin is named after.
 
-  If you decided to have separate log files for classes *Network* and *Database*:
+Lets see how you may use it. For example you want to have separate log files 
+for classes *Network* and *Database*:
 
     TaggedLogger.rules do
-      output Network => Logger.new("network.log")
-      output Database => Logger.new("database.log")
+      debug Network, :to => Logger.new("network.log")
+      debug Database, :to => Logger.new("database.log")
     end
    
 In case you want to define common log for several classes:
 
     TaggedLogger.rules do
-      output [Ftp, Http, Sockets] => Logger.new("network.log")
+      debug [Ftp, Http, Sockets], :to => 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
-      output_everything_to Logger.new(STDOUT)
+      info /.*/, :to => Logger.new(STDOUT)
       rename [Ftp, Http, Sockets] => :Network
     end
    
 You may also use regular expressions in your rules:
 
     TaggedLogger.rules do
-      output /Active::/ => Logger.new("active.log")
+      info /Active::/, :to => Logger.new("active.log")
     end
 
 
 ## License
-TaggedLogger is released under the MIT license.
+*TaggedLogger* is released under the MIT license.
 
 ## Shortcomings
-Was not tested with *log4r*
+The *#info(), #debug(), #warn(), #error(), #fatal()* rules when having form like *:to => logger*, the 
+*logger* **has** to be an object of standard library *Logger* class. If you need to use different sort of logger
+the more general rules form is:
+
+    TaggedLogger.rules do
+      info /Whatever/ do |level, tag, message|
+        #do your special logging here
+      end      
+    end

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/rdoctask'
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/test.rb']
+  t.test_files = FileList['test/test.rb', 'test/test_examples.rb']
   t.verbose = true
 end
 
@@ -16,7 +16,7 @@ begin
     s.email = "fkocherga@gmail.com"
     s.homepage = "http://github.com/fkocherga/tagged_logger"
     s.authors = ["Fedor Kocherga"]
-    s.test_files = ['test/test.rb']
+    s.test_files = ['test/test.rb', 'test/test_examples.rb']
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.3.0

data/examples/changing_format.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'tagged_logger'
+require 'logger'
+
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
+TaggedLogger.rules do
+  format { |level, tag, msg| "#{level}-#{tag}: #{msg}\n"}
+  info /.*/, :to => Logger.new(STDOUT)
+end
+
+logger.info("message")

data/examples/one_log_per_classes.rb

@@ -2,18 +2,36 @@ require 'rubygems'
 require 'tagged_logger'
 require 'logger'
 
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
 class LogFoo
   def foo
-    logger.info("foo")
+    logger.info("#{self.class}#foo")
   end
 end
 
-Ftp = Class.new LogFoo
-Http = Class.new LogFoo
-Sockets = Class.new LogFoo
+module Network
+  Ftp = Class.new LogFoo
+  Http = Class.new LogFoo
+  Sockets = Class.new LogFoo
+end
+include Network
+
+def run
+  [Network::Ftp, Network::Http, Network::Sockets, LogFoo].each { |c| c.new.foo }
+end
 
 TaggedLogger.rules do
-  output [Ftp, Http, Sockets] => Logger.new(open("network.log", "w"))
+  stdout = Logger.new(STDOUT)
+  puts "- Only logging from within classes Ftp, Http and Sockets will be shown in output (no LogFoo):"
+  info [Ftp, Http, Sockets], :to => stdout
+  run
+  puts "\n- Same result, but regex syntax:"
+  info /(Ftp|Http|Sockets)/, :to => stdout
+  run
+  puts "\n- Or even shorter:"
+  info /Network::/, :to => stdout
+  run
 end 
 
-[Ftp, Http, Sockets].each { |c| c.new.foo }
+

data/examples/one_tag_per_classes.rb

@@ -2,20 +2,25 @@ require 'rubygems'
 require 'tagged_logger'
 require 'logger'
 
-module LogFoo
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
+class 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 }
+Ftp = Class.new LogFoo
+Http = Class.new LogFoo
+Sockets = Class.new LogFoo
 
 TaggedLogger.rules do
+  format { |level, tag, message| "#{tag}: #{message}\n"}
+  puts "- Only logging from within classes Ftp, Http and Sockets will be shown in output (no LogFoo)"
+  puts "  tag is also printed and it is 'Network' after renaming took place:"
   rename [Ftp, Http, Sockets] => :Network
-  output :Network => Logger.new(STDOUT)
+  info :Network, :to => Logger.new(STDOUT)
 end
 
-[Ftp, Http, Sockets].each { |c| c.new.foo }
+[Ftp, Http, Sockets, LogFoo].each { |c| c.new.foo }
 

data/examples/per_class_customization.rb

@@ -2,19 +2,22 @@ require 'rubygems'
 require 'tagged_logger'
 require 'logger'
 
-class LogFoo
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
+class Some
   def foo
-    logger.info("foo")
+    logger.info("Some information")
   end
 end
 
-Database = Class.new LogFoo
-Network = Class.new LogFoo
 
 TaggedLogger.rules do
-  output Network => Logger.new(open("network.log", "w"))
-  output Database => Logger.new(open("database.log", "w"))
+  format { |level, tag, message| "#{tag}: #{message}\n"}
+  puts "- Only logging for Some class is shown in STDOUT"
+  puts "- Run this script again by adding '2>/dev/null' and see the difference:"
+  info /.*/, :to => Logger.new(STDERR)
+  info Some, :to => Logger.new(STDOUT)
 end
 
-Database.new.foo
-Network.new.foo
+Some.new.foo
+logger.info "INFO"

data/examples/rule_with_regex.rb

@@ -2,6 +2,8 @@ require 'rubygems'
 require 'tagged_logger'
 require 'logger'
 
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
 module Active
   class Base
     def foo
@@ -11,7 +13,8 @@ module Active
 end
 
 TaggedLogger.rules do
-  output /Active::/ => Logger.new(open("active.log", "w"))
+  puts "- The recommended way to specify logging for all classes within same namespace:"
+  info /Active::/, :to => Logger.new(STDOUT)
 end
 
 Active::Base.new.foo

data/examples/simplest_usage.rb

@@ -2,17 +2,18 @@ require 'rubygems'
 require 'tagged_logger'
 require 'logger'
 
+puts "\n<<<#{File.basename(__FILE__, ".rb")}>>> \n".upcase
+
 TaggedLogger.rules do
-  output_everything_to Logger.new(STDOUT)
+  info /.*/, :to => Logger.new(STDOUT)
 end
 
 class A
   def foo
-    logger.warn "foo"
+    logger.warn "WARNING message" #will be printed since treshold is set to 'info'
   end
-  logger.debug "A parsed"
+  logger.debug "DEBUG message" #will not be printed since we have only 'info' rule
 end
 
-
-logger.info("Hello word!")
+logger.info("INFO message") #will be printed
 A.new.foo

data/lib/tagged_logger.rb

@@ -10,16 +10,18 @@ class TaggedLogger
       @rename_rules = Dictionary.new
       @tag_blocks = Dictionary.new
       ObjectSpace.each_object(ClassSpecificLogger) { |obj| obj.detach }
+      init
     end
     
     def rules(&block)
+      add_logger_generator_in_Kernel
       instance_eval(&block)
     end
     
-    def blocks_for(tag)
+    def blocks_for(level, tag)
       blocks = []
       tag_aliases(tag) do |tag_alias|
-        tag_blocks(tag_alias) do |tag_block|
+        tag_blocks(level, tag_alias) do |tag_block|
           blocks << [tag_alias, tag_block]
         end
       end
@@ -27,46 +29,63 @@ class TaggedLogger
     end
     
     def init
-      add_logger_generator_in_Kernel
+      rules {}
     end
     
-    def output_everything_to(logger = nil, &block)
-      if logger && block
-        raise ArgumentError, "Either block or logger has to be specified, but not both."
-      end
-      output /.*/ => logger if logger
-      output &block if block
-    end
+    def debug(what, where = {}, &block) output(:debug, what, where, &block) end
+    def info(what, where = {}, &block) output(:info, what, where, &block) end
+    def warn(what, where = {}, &block) output(:wanr, what, where, &block) end
+    def error(what, where = {}, &block) output(:error, what, where, &block) end
+    def fatal(what, where = {}, &block) output(:fatal, what, where, &block) end
     
-    def output(spec, &block)
-      add_logger_generator_in_Kernel
-      if spec.is_a? Hash
-        spec.each do |what, where|
-          @tag_blocks[tag_matcher(what)] = lambda { |level, tag, msg | where.send(level, "#{tag}: #{msg}\n") }
-        end
-        raise ArgumentError "No block should be specified in this 'output' rule" if block
-      else
-        raise ArgumentError "Block has to be specified in this 'output' rule" unless block
-        @tag_blocks[tag_matcher(spec)] = block
-      end
+    def format(&block)
+      @formatter = block
     end
-    
+
+    def formatter
+      @formatter = lambda { |level, tag, message| "#{message}\n"} unless @formatter
+      @formatter
+    end
+
     def rename(renames)
       renames.each { |from, to| @rename_rules[tag_matcher(from)] = to }
     end
     
     private
+    def output(level, what, where, &block)
+      logger = where[:to]
+      code = nil
+      if logger
+        #todo: hack - what about other logger classes?
+        logger.formatter = lambda {|severity, datetime, progname, msg| "#{msg}"} if logger.is_a? Logger
+        write = lambda { |level, tag, msg | logger.send(level, formatter.call(level, tag, msg)) }
+        code = block ? lambda { |l,t,m| write.call(l,t,m); block.call(l,t,m) } : write
+      elsif block
+        code = block
+      else
+        raise ArgumentError "Should be called with block or :to => <logger>"
+      end
+      @tag_blocks[tag_matcher(what, level)] = code
+    end
+    
     class TagMatcher
       attr_reader :match_spec
+      LEVELS = { :debug => 1, :info => 2, :warn => 3, :error => 4, :fatal => 5}
       
-      def initialize(match_spec)
+      def initialize(match_spec, level = nil)
+        @level = level || :debug
         @match_spec = match_spec
       end
       
-      def match?(tag)
+      def match?(tag, level = nil)
+        return false if level && !above_treshold(level)
         self.class.match?(@match_spec, tag)
       end
       
+      def above_treshold(level)
+        LEVELS[@level] <= LEVELS[level]
+      end
+      
       def self.match?(spec, tag)
         t = tag.to_s
         case spec
@@ -82,8 +101,8 @@ class TaggedLogger
       end
     end #TagMatcher
     
-    def tag_matcher(tag)
-      TagMatcher.new(tag)
+    def tag_matcher(tag, level = nil)
+      TagMatcher.new(tag, level)
     end
     
     def tag_aliases(tag, &block)
@@ -92,9 +111,9 @@ class TaggedLogger
       block.call(current_name)
     end
     
-    def tag_blocks(tag, &block)
+    def tag_blocks(level, tag, &block)
       @tag_blocks.each do |matcher, block|
-        yield block if matcher.match? tag
+        yield block if matcher.match?(tag, level)
       end
     end
     
@@ -122,10 +141,10 @@ class TaggedLogger
 
     def initialize(klass)
       @klass = klass
-      blocks = TaggedLogger.blocks_for(klass.to_s)
-      [:debug, :warn, :info, :error, :fatal].each do |method|
-        eigenclass.send(:define_method, method) do |msg|
-          blocks.each { |(tag_alias, block)| block.call(method, tag_alias, msg) }
+      [:debug, :warn, :info, :error, :fatal].each do |level|
+        blocks = TaggedLogger.blocks_for(level, klass.to_s)
+        eigenclass.send(:define_method, level) do |msg|
+          blocks.each { |(tag_alias, block)| block.call(level, tag_alias, msg) }
         end
       end    
     end

data/tagged_logger.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tagged_logger}
-  s.version = "0.2.5"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Fedor Kocherga"]
-  s.date = %q{2010-01-13}
+  s.date = %q{2010-01-16}
   s.email = %q{fkocherga@gmail.com}
   s.extra_rdoc_files = [
     "README.html",
@@ -22,16 +22,18 @@ Gem::Specification.new do |s|
      "README.markdown",
      "Rakefile",
      "VERSION",
+     "examples/changing_format.rb",
      "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",
      "tagged_logger.gemspec",
      "tagged_logger.rb",
+     "test/expected_examples_output.txt",
      "test/test.rb",
+     "test/test_examples.rb",
      "todo.txt"
   ]
   s.homepage = %q{http://github.com/fkocherga/tagged_logger}
@@ -40,7 +42,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{Detaches _what_ is logged from _how_ it is logged.}
   s.test_files = [
-    "test/test.rb"
+    "test/test.rb",
+     "test/test_examples.rb"
   ]
 
   if s.respond_to? :specification_version then

data/test/expected_examples_output.txt

@@ -0,0 +1,39 @@
+
+<<<CHANGING_FORMAT>>> 
+info-Object: message
+
+<<<ONE_LOG_PER_CLASSES>>> 
+- Only logging from within classes Ftp, Http and Sockets will be shown in output (no LogFoo):
+Network::Ftp#foo
+Network::Http#foo
+Network::Sockets#foo
+
+- Same result, but regex syntax:
+Network::Ftp#foo
+Network::Http#foo
+Network::Sockets#foo
+
+- Or even shorter:
+Network::Ftp#foo
+Network::Http#foo
+Network::Sockets#foo
+
+<<<ONE_TAG_PER_CLASSES>>> 
+- Only logging from within classes Ftp, Http and Sockets will be shown in output (no LogFoo)
+  tag is also printed and it is 'Network' after renaming took place:
+Network: Ftp#foo
+Network: Http#foo
+Network: Sockets#foo
+
+<<<PER_CLASS_CUSTOMIZATION>>> 
+- Only logging for Some class is shown in STDOUT
+- Run this script again by adding '2>/dev/null' and see the difference:
+Some: Some information
+
+<<<RULE_WITH_REGEX>>> 
+- The recommended way to specify logging for all classes within same namespace:
+foo
+
+<<<SIMPLEST_USAGE>>> 
+INFO message
+WARNING message

data/test/test.rb

@@ -18,134 +18,140 @@ end
 class TaggedLoggerTest < Test::Unit::TestCase
   include RR::Adapters::TestUnit
 
-  
-  context "@standard_logger with stub output @out1;" do
+  context "stub output device @@stub_out;" do
     setup do
-      @out1 = TestLogDevice.new
-      @standard_logger = Logger.new(@out1)
-      @formatter = lambda {|severity, datetime, progname, msg| "#{msg}"}
-      @standard_logger.formatter = @formatter
+      @@stub_out = TestLogDevice.new
     end
     
     teardown do
-      Kernel.class_eval do
-        remove_method :logger
-      end
+      Kernel.class_eval { remove_method :logger }
     end
     
-    should "be able to intialize with minimal effort" do
+    should "be able to intialize with minimal effort, without defining any rules" do
       TaggedLogger.init
-      dont_allow(@out1).write
+      dont_allow(@@stub_out).write
       assert Class.new.methods.include? "logger"
       assert_nothing_raised { Class.new.logger }
     end
     
-    context "everything gets logged to @out1;" do
+    context "everything gets logged to @@stub_out;" do
       setup do 
-        logger = @standard_logger
         TaggedLogger.rules do
           reset
-          output_everything_to logger
+          format {|level, tag, msg| "#{tag}: #{msg}"}
+          debug /.*/, :to => Logger.new(@@stub_out)
         end
       end
       
-      should " be possible to log by .logger.debug/info/warn/error/fatal()" do
+      should "write output for every of #debug, #info, #warn, #error, #fatal call" 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}\n", @out1.to_s
-        end
+        TaggedLogger.rules { format { |level, tag, msg| "#{msg}" } }
+        
+        mock(@@stub_out).write("debug")
+        obj.logger.debug("debug")
+        mock(@@stub_out).write("info")
+        obj.logger.info("info")
+        mock(@@stub_out).write("warn")
+        obj.logger.warn("warn")
+        mock(@@stub_out).write("error")
+        obj.logger.error("error")
+        mock(@@stub_out).write("fatal")
+        obj.logger.fatal("fatal")
       end
 
-      context "class A and class B with logging;" do
+      context "class A and class B with logger.info() in their method #foo;" do
         setup do
-          module Foo
-            def foo
-              logger.info("foo")
-            end
-          end
+          module Foo; def foo; logger.info("foo"); end; end
           class A;include Foo; end
           class B;include Foo; end
           @a = A.new
           @b = B.new
         end
-        
+       
         should "be possible to replace tags for A, B classes with single tag TEST making rules for A and B obsolete" do
           TaggedLogger.rules do
             rename [A,B] => :TEST
           end
-          
+          mock(@@stub_out).write("TEST: foo")
           @a.foo
-          assert_equal "TEST: foo\n", @out1.to_s
-          @out1.clear
-          
+          mock(@@stub_out).write("TEST: foo")
           @b.foo
-          assert_equal "TEST: foo\n", @out1.to_s
         end
 
-        context "@logger2 with stub output @out2;" do
-          setup do 
-            @out2 = TestLogDevice.new
-            @logger2 = Logger.new(@out2)
-            @logger2.formatter = @formatter
+       context "@logger2 with stub output @@stub_out_aux;" do
+          setup { @@stub_out_aux = TestLogDevice.new }
+          
+          should "be possible to add logging to @@stub_out_aux for A" do
+            TaggedLogger.rules { debug A, :to => Logger.new(@@stub_out_aux) }
+            mock(@@stub_out).write("#{self.class}::A: foo")
+            mock(@@stub_out_aux).write("#{self.class}::A: foo")
+            @a.foo
+            mock(@@stub_out).write("#{self.class}::B: foo")
+            dont_allow(@@stub_out_aux).write
+            @b.foo
           end
           
-          should "be possible to speialize logging for tag A by specifying another @logger2" do
-            logger2 = @logger2
+          should "be possible to speialize logging for tag A by providing block" do
             TaggedLogger.rules do
-              output A => logger2
+              debug A do |level, tag, msg| 
+                @@stub_out_aux.write("#{level} #{tag} #{msg}")
+              end
             end
+            mock(@@stub_out_aux).write("info #{self.class}::A foo")
+            mock(@@stub_out).write("#{self.class}::A: foo")
             @a.foo
-            assert_equal "#{self.class}::A: foo\n", @out1.to_s
-            assert_equal "#{self.class}::A: foo\n", @out2.to_s
-            @out2.clear
-            @b.foo
-            assert_equal "#{self.class}::B: foo\n", @out1.to_s
-            assert_equal "", @out2.to_s
           end
-
-          should "be possible to speialize logging for tag A by providing block" do
-            logger2 = @logger2
+          
+          should "be possible to provide block and logger together, and do actual writing by yielding" do
             TaggedLogger.rules do
-              output A do |level, tag, msg| 
-                logger2.send(level, msg)
+              debug A, :to => Logger.new(@@stub_out_aux) do |level, tag, message|
+                @@stub_out_aux.write "post write callback"
               end
             end
+            mock(@@stub_out_aux).write("#{self.class}::A: foo")
+            mock(@@stub_out_aux).write("post write callback")
+            mock(@@stub_out).write("#{self.class}::A: foo")
             @a.foo
-            assert_equal "#{self.class}::A: foo\n", @out1.to_s
-            assert_equal "foo", @out2.to_s
-            @out2.clear
-            @b.foo
-            assert_equal "#{self.class}::B: foo\n", @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
-            logger2 = @logger2
             TaggedLogger.rules do
               rename [A, B] => :TEST
-              output :TEST => logger2 
+              debug :TEST, :to => Logger.new(@@stub_out_aux)
             end
+            mock(@@stub_out).write("TEST: foo")
+            mock(@@stub_out_aux).write("TEST: foo")
             @a.foo
-            assert_equal "TEST: foo\n", @out1.to_s
-            assert_equal "TEST: foo\n", @out2.to_s
-            @out1.clear
-            @out2.clear
+            mock(@@stub_out).write("TEST: foo")
+            mock(@@stub_out_aux).write("TEST: foo")
             @b.foo
-            assert_equal "TEST: foo\n", @out1.to_s
-            assert_equal "TEST: foo\n", @out2.to_s
           end
           
           should "use default tag equal to class name for class methods" do
             def A.bar
               logger.info "bar"
             end
+            mock(@@stub_out).write("#{self.class}::A: bar")
             A.bar
-            assert_equal "#{self.class}::A: bar\n", @out1.to_s
           end
-        end
+          
+          context "class A and class B with logger.debug() in their method #bar;" do
+            setup do
+              module Bar; def bar; logger.debug("bar");  end; end
+              class A;include Bar; end
+              class B;include Bar; end
+            end
+            
+            should "not print debug messages if info level specified" do
+              TaggedLogger.rules do
+                info /A/, :to => Logger.new(@@stub_out_aux)
+              end
+              dont_allow(@@stub_out_aux).write
+              @a.bar
+            end
+          end
+          end
         
       end
     end

data/test/test_examples.rb

@@ -0,0 +1,8 @@
+root_dir = File.dirname(File.expand_path(__FILE__)) + '/../'
+examples_output = `find -s #{root_dir}examples -iname '*.rb' -exec ruby {} \\;`
+expected_output = File.read("#{root_dir}test/expected_examples_output.txt")
+if expected_output != examples_output
+  puts "FAILED: Examples do not produce same output as expected.\n"
+  raise StandardError, "FAILED"
+end
+puts "SUCCEEDED.\n"

data/todo.txt

@@ -1,21 +1,7 @@
-- It is slow: logger on first call has to select only applicable rules and 
-  run only them afterwards rather than going via all rules each time. It will
-  gain almost 300% in parsing speed on my app.
-
-- Replace output ... => ... with
-  format ...
-  output ... => do
-     format ....
-  end
-
-- output ... => ... - may be:
-     debug ... => ...
-     info ... => ...
-
-- Simplest configuration with warning
-
-- Switch tests on rr expectations
-
+- logger.debug method (and alike) should accept block for performance reason
 - logger called within Base does not log when Derived is instantiated
-
 - writing messages in any encoding
+- test against 'logging' framework
+- test agains 1.8.6 and 1.9.1
+- test with Rails
+- when logger specified in :to => ... then lib must complain unless formatting and logging code to that specific logger class was not defined

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tagged_logger
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors: 
 - Fedor Kocherga
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-13 00:00:00 -06:00
+date: 2010-01-16 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -29,16 +29,18 @@ files:
 - README.markdown
 - Rakefile
 - VERSION
+- examples/changing_format.rb
 - 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
 - tagged_logger.gemspec
 - tagged_logger.rb
+- test/expected_examples_output.txt
 - test/test.rb
+- test/test_examples.rb
 - todo.txt
 - README.html
 has_rdoc: true
@@ -71,3 +73,4 @@ specification_version: 3
 summary: Detaches _what_ is logged from _how_ it is logged.
 test_files: 
 - test/test.rb
+- test/test_examples.rb

data/examples/simplest_customization.rb

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