tagged_logger 0.5.0 → 0.5.1

data/README.markdown

@@ -54,14 +54,14 @@ the following will happen:
 
 
 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.
+These methods have generated on first *#logger()* call and contain only necessary code to satisfy rules conditions.
+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()* to slow down production code. 
  
 
 The simplest way to have a *#logger()* available everywhere without specifying any rules is:
 
-    TaggedLogger.init
+    TaggedLogger.rules
 
 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.
@@ -78,7 +78,7 @@ If you are wondering what the heck the 'tag' is - the answer is simple. The tag
 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.
 
-Lets see how you may use it. For example you want to have separate log files 
+Lets see how you may use it. For example, you want to have separate log files 
 for classes *Network* and *Database*:
 
     TaggedLogger.rules do
@@ -92,7 +92,7 @@ In case you want to define common log for several classes:
       debug [Ftp, Http, Sockets], :to => Logger.new("network.log")
     end 
 
-Or if you want to have all these classes showing up under common 
+Or if you want to have all these classes to show up under common 
 tag *Network* in standard output:
 
     TaggedLogger.rules do
@@ -107,7 +107,7 @@ You may also use regular expressions in your rules:
     end
 
 
-There is more general form for rules, it accepts block with three params:
+There is more general form for rules, it accepts block with three parameters:
 
     TaggedLogger.rules do
       info /Whatever/ do |level, tag, message|
@@ -117,14 +117,23 @@ There is more general form for rules, it accepts block with three params:
 
 As previously explained the *tag* is a class name the *#logger* is being called from (except when you override Rails instrumentation, see below)
 
-## Integration with Rails (only Rails 3.0 supported at the moment, not completely tested):
+## Integration with Rails (only Rails 3.0 supported at the moment, not completely tested)
 
-Installation:
+### Installation
 
     $ gem install tagged_logger
 
-Rails has two facility for logging - *#logger* method injected in base classes such in ActiveRecord::Base and instrumentation. Instrumentation is somewhat which allows to issue an event upon execution of 
-block, for example:
+In Rails.root/config/application.rb:
+
+       TaggedLogger.config(:replace_existing_logger => true)
+
+Without that original methods *ActionController::Base#logger*, *ActiveRecord::Base#logger* and alike will remain untouched, and they have to be patched if we want
+redefine their behavior. 
+
+### Logging in Rails
+
+Rails has two facility for logging - *#logger* method injected in base classes (*ActiveRecord::Base*, *ActionController::Base*, etc.) and *instrumentation*. 
+Instrumentation in Rails allows to subscribe on event signaled upon block execution, for example:
 
     def sendfile(path, options={})
       ActiveSupport::Notifications.instrument("sendfile.action_controller") do
@@ -132,36 +141,35 @@ block, for example:
       end
     end
 
-The event *"sendfile.action_controller"* will be issued and one could subscribe to that event:
+The event *"sendfile.action_controller"* will be signaled after actual work on sending file is done. One could subscribe to that event:
 
-    ActiveSupport::Notifications.subscribe("sendfile.action_controller") do
-      #do something, for example log an event
+    ActiveSupport::Notifications.subscribe("sendfile.action_controller") do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      #do something, for example, log an event
     end
 
+### Overriding Rails logging
+Logging inside Rails is done by log subscribers - their task to subscribe to instrumentation events, receive and log them.
+*TaggedLogger* allows you to override how these subscribers work, for example, 
+you could redirect what is being logged in *ActionController* to some external logging service, like [Logworm](http://www.logworm.com/):
 
-Actually Rails subscribers - they are responsible for majority of logging in Rails.
-*TaggedLogger* allows you to override how those subscribers do actual logging, for example if you want to override it for *ActionController*:
-
-    # "#{Rails.root}/config/initializers/tagged_logger.rb"
-    TaggedLogger.rules(:override=>true) do
-      debug "action_controller.instrumentation" do |level, tag, msg|
-        puts "#{tag} {msg}" #msg formed by ActionController::LogSubscriber goes here, tag is 'action_controller.instrumentation'
+    # In Rails.root/config/initializers/tagged_logger.rb:
+    TaggedLogger.rules do
+      debug "action_controller.logsubscriber" do |level, tag, msg|
+        Logworm::Logger.log(:controllers, :level => level.to_s, :tag => tag.to_s, :message => msg.to_s )
       end
     end
 
-If you like to have a special logging not only for *ActionController*, but rather for everything logged by Rails via instrumentation mechanism, you could use a 
+You may also use *active_record.logsubscriber*, *action_mailer.logsubscriber*, *action_view.logsubscriber* and *rack.logsubscriber* tags.
+If you'd like to have a special logging not only for *ActionController*, but rather for entire logging done in Rails (via instrumentation), you could use a 
 rule with regular expression:
    
-    debug /.*\.instrumentation$/ do |level, tag, msg|
-      #you special logging
+    debug /\.logsubscriber$/ do |level, tag, msg|
+      #your special logging
     end
 
 
-Since *#logger* is defined by Rails for classes you inherits from (*ActionController::Base*, *ActiveRecord::Base*), you have to initialize *TaggedLogger* with
-
-    :override => true 
-
- option since by default *TaggedLogger* is trying to be safe and does not override existing *#logger* method:
+You also could use *#logger* in your classes inherited from Rails bases and define your own logging rules, for example:
 
     class ApplicationController < ActionController::Base
       def welcome
@@ -169,15 +177,14 @@ Since *#logger* is defined by Rails for classes you inherits from (*ActionContro
       end
     end
   
-    # "#{Rails.root}/config/initializers/tagged_logger.rb"
-    TaggedLogger.rules(:override=>true) do
+    # Rails.root/config/initializers/tagged_logger.rb
+    TaggedLogger.rules do
       debug /.*Controller$/ do |level, tag, msg|
         puts "Here I dump whatever happens in controllers, including ApplicationController"
       end
     end
 
 
-
 ## License
 *TaggedLogger* is released under the MIT license.
 

data/lib/tagged_logger/railtie.rb

@@ -2,24 +2,29 @@ if defined?(Rails::Railtie)
   module TaggedLogger
     class Railtie < Rails::Railtie
       ActiveSupport.on_load(:action_controller) do
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionController::Base)
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionController::LogSubscriber)
-        TaggedLogger.rename [ActionController::LogSubscriber] => "action_controller.instrumentation"
+        TaggedLogger.patch_logger(ActionController::Base, TaggedLogger.options[:replace_existing_logger]).
+          patch_logger(ActionController::LogSubscriber, TaggedLogger.options[:replace_existing_logger]).
+          rename [ActionController::LogSubscriber] => "action_controller.logsubscriber"
       end
       ActiveSupport.on_load(:active_record) do
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActiveRecord::Base)
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActiveRecord::LogSubscriber)
-        TaggedLogger.rename [ActiveRecord::LogSubscriber] => "active_record.instrumentation"
+        TaggedLogger.patch_logger(ActiveRecord::Base, TaggedLogger.options[:replace_existing_logger]).
+          patch_logger(ActiveRecord::LogSubscriber, TaggedLogger.options[:replace_existing_logger]).
+          rename [ActiveRecord::LogSubscriber] => "active_record.logsubscriber"
       end
       ActiveSupport.on_load(:action_mailer) do
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionMailer::Base)
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionMailer::LogSubscriber)
-        TaggedLogger.rename [ActionMailer::LogSubscriber] => "action_mailer.instrumentation"
+        TaggedLogger.patch_logger(ActionMailer::Base, TaggedLogger.options[:replace_existing_logger]).
+          patch_logger(ActionMailer::LogSubscriber, TaggedLogger.options[:replace_existing_logger]).
+          rename [ActionMailer::LogSubscriber] => "action_mailer.logsubscriber"
       end
       ActiveSupport.on_load(:action_view) do
-        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionView::LogSubscriber)
-        TaggedLogger.rename [ActionView::LogSubscriber] => "action_view.instrumentation"
+        TaggedLogger.patch_logger(ActionView::LogSubscriber, TaggedLogger.options[:replace_existing_logger]).
+          rename [ActionView::LogSubscriber] => "action_view.logsubscriber"
       end
+      ActiveSupport.on_load(:after_initialize) do
+        TaggedLogger.patch_logger(Rails::Rack::Logger, TaggedLogger.options[:replace_existing_logger]).
+          rename [Rails::Rack::Logger] => "rack.logsubscriber"
+      end
+      
     end
   end
 end

data/lib/tagged_logger/tagged_logger.rb

@@ -2,42 +2,59 @@ require 'delegate'
 require 'hashery/dictionary'
 
 module TaggedLogger
+  
   @rename_rules = Dictionary.new
   @tag_blocks = Dictionary.new
-  @overridees = []
-
+  @patched = []
+  @formatter = nil
+  @config = {}
+  
   class << self
+    
+    #Supported options: :replace_existing_logger => true/false
+    def config(options)
+      @config = options
+      self
+    end
+    
+    def options
+      @config
+    end
+    
+    def rules(&block)
+      patch_logger(Object, options[:replace_existing_logger]) unless @patched.include?(Object)
+      instance_eval(&block) if block
+      self
+    end
+
     def reset
+      unpatch_all
       @rename_rules = Dictionary.new
       @tag_blocks = Dictionary.new
-      ObjectSpace.each_object(ClassSpecificLogger) { |obj| obj.detach }
-      init
-    end
-    
-    def rules(options = {}, &block)
-      @options = options
-      @old_methods_restored = false
-      inject_logger_method_in_call_chain(Object)
-      instance_eval(&block)
+      @formatter = nil
+      @config = {}
+      self
     end
 
+    def init
+      puts "TaggedLogger#init() is deprecated. Use TaggedLogger.rules with no block."
+    end
+    
     def klass_has_method?(klass, method)
       klass.instance_methods(false).include?(RUBY_VERSION >= '1.9' ? method.to_sym : method.to_s)
     end
     
-    def restore_old_logger_methods
-      return if @old_methods_restored
-      @old_methods_restored = true
-      @overridees.each do |klass|
-        if klass_has_method?(klass, :tagged_logger_original_logger)
-          klass.class_eval {alias_method :logger, :tagged_logger_original_logger}
-        elsif klass_has_method?(klass, :logger)
-          klass.class_eval {remove_method :logger}
-        end
-      end
-      @overridees = []
+    def format(&block)
+      @formatter = block
+      self
+    end
+    
+    def rename(renames)
+      renames.each { |from, to| @rename_rules[tag_matcher(from)] = to }
+      self
     end
     
+    # should private, but used by ClassSpecificLogger
     def blocks_for(level, tag)
       blocks = []
       tag_aliases(tag) do |tag_alias|
@@ -48,8 +65,42 @@ module TaggedLogger
       blocks
     end
     
-    def init
-      rules {}
+    def patch_logger(patchee, replace_existing_logger)
+      return self if @patched.include?(patchee)
+      
+      if klass_has_method?(patchee, :logger)
+        return self if !replace_existing_logger
+        #so we could resurrect old :logger method if we need
+        patchee.class_eval { alias_method :tagged_logger_original_logger, :logger }
+      end
+      
+      @patched << patchee
+      
+      patchee.class_eval do
+        def logger
+          klass = self.class == Class ? self : self.class
+          result = klass.class_eval do
+            return @class_logger if @class_logger
+            @class_logger = ClassSpecificLogger.new(klass)
+            @class_logger
+          end
+          result
+        end
+      end
+      self
+    end
+    
+    private
+    def unpatch_all
+      @patched.each do |klass|
+        if klass_has_method?(klass, :tagged_logger_original_logger)
+          klass.class_eval {alias_method :logger, :tagged_logger_original_logger}
+        elsif klass_has_method?(klass, :logger)
+          klass.class_eval {remove_method :logger}
+        end
+      end
+      @patched = []
+      ObjectSpace.each_object(ClassSpecificLogger) { |obj| obj.detach }
     end
     
     def debug(what, where = {}, &block) output(:debug, what, where, &block) end
@@ -62,21 +113,12 @@ module TaggedLogger
         output(level, what, where, &block)
         end
     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
@@ -144,31 +186,6 @@ module TaggedLogger
       end
     end
     
-    def inject_logger_method_in_call_chain(definee_klass)
-      return if @overridees.include?(definee_klass)
-      
-      if klass_has_method?(definee_klass, :logger)
-        return if !@options[:override]
-        #so we could resurrect old :logger method if we need
-        definee_klass.class_eval { alias_method :tagged_logger_original_logger, :logger }
-      end
-      
-      @overridees << definee_klass
-      
-      definee_klass.class_eval do
-        def logger
-          klass = self.class == Class ? self : self.class
-          result = klass.class_eval do
-            return @class_logger if @class_logger
-            @class_logger = ClassSpecificLogger.new(klass)
-            @class_logger
-          end
-          result
-        end
-      end
-      
-    end
-    
   end # class methods
   
   class ClassSpecificLogger

data/test/test.rb

@@ -9,11 +9,11 @@ class TaggedLoggerTest < Test::Unit::TestCase
     end
     
     teardown do
-      TaggedLogger.restore_old_logger_methods
+      TaggedLogger.reset
     end
     
     should "be able to intialize with minimal effort, without defining any rules" do
-      TaggedLogger.init
+      TaggedLogger.rules
       dont_allow(@@stub_out).write
       logger_method = RUBY_VERSION >= '1.9' ? :logger : "logger"
       assert Class.new.methods.include? logger_method
@@ -27,7 +27,6 @@ class TaggedLoggerTest < Test::Unit::TestCase
         def foo; logger.write("debug"); end
       end
       TaggedLogger.rules do
-        reset
         debug(/.*/) { |level, tag, msg| @@stub_out.write("hmmm, something new") }
       end
       mock(@@stub_out).write("debug")
@@ -40,8 +39,8 @@ class TaggedLoggerTest < Test::Unit::TestCase
         def logger; @logger ||= Logger.new('/dev/null');  end
         def foo; logger.debug("debug"); end
       end
-      TaggedLogger.rules(:override => true) do
-        reset
+      TaggedLogger.config(:replace_existing_logger => true)
+      TaggedLogger.rules do
         debug(/.*/) { |level, tag, msg| @@stub_out.write(msg) }
       end
       mock(@@stub_out).write("debug")
@@ -51,7 +50,6 @@ class TaggedLoggerTest < Test::Unit::TestCase
     context "everything gets logged to @@stub_out;" do
       setup do 
         TaggedLogger.rules do
-          reset
           format {|level, tag, msg| "#{tag}: #{msg}"}
           debug /.*/, :to => Logger.new(@@stub_out)
         end

data/test/test_rails.rb

@@ -28,12 +28,13 @@ class TaggedLoggerRailsTest < Test::Unit::TestCase
     end
     
     teardown do
-      TaggedLogger.restore_old_logger_methods
+      TaggedLogger.reset
     end
 
     should "be able possible to initialize in the way to override Rails existing logger" do
       assert TestController.new.respond_to? :logger
-      TaggedLogger.rules(:override=>true) do 
+      TaggedLogger.config(:replace_existing_logger => true)
+      TaggedLogger.rules do 
         info /.*/ do |level, tag, message|
           @@stub_out.write(tag.to_s)
         end
@@ -43,10 +44,11 @@ class TaggedLoggerRailsTest < Test::Unit::TestCase
     end
     
     should "be possible to restore old logger methods" do
-      TaggedLogger.rules(:override=>true) do 
+      TaggedLogger.config(:replace_existing_logger => true)
+      TaggedLogger.rules do 
         info(/.*/) {|level, tag, message|}
       end
-      TaggedLogger.restore_old_logger_methods
+      TaggedLogger.reset
       mock(Test.rails_log_device).write("hi\n")
       TestController.new.hi
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tagged_logger
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Aleksandr Furmanov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-29 00:00:00 -05:00
+date: 2010-10-30 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency