tagged_logger 0.4.6 → 0.5.0

data/README.markdown

@@ -107,16 +107,80 @@ You may also use regular expressions in your rules:
     end
 
 
-## License
-*TaggedLogger* is released under the MIT license.
-
-## Shortcomings
-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:
+There is more general form for rules, it accepts block with three params:
 
     TaggedLogger.rules do
       info /Whatever/ do |level, tag, message|
         #do your special logging here
       end      
     end
+
+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):
+
+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:
+
+    def sendfile(path, options={})
+      ActiveSupport::Notifications.instrument("sendfile.action_controller") do
+        #do actual file send
+      end
+    end
+
+The event *"sendfile.action_controller"* will be issued and one could subscribe to that event:
+
+    ActiveSupport::Notifications.subscribe("sendfile.action_controller") do
+      #do something, for example log an event
+    end
+
+
+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'
+      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 
+rule with regular expression:
+   
+    debug /.*\.instrumentation$/ do |level, tag, msg|
+      #you 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:
+
+    class ApplicationController < ActionController::Base
+      def welcome
+        logger.info "welcome..."
+      end
+    end
+  
+    # "#{Rails.root}/config/initializers/tagged_logger.rb"
+    TaggedLogger.rules(:override=>true) 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.
+
+## Shortcomings
+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. 

data/TODO.markdown

@@ -1,26 +1,6 @@
-### The *level* param in rule below appears to be obsolete:
-
-    debug /something/ do |level, tag, msg| 
-    end
-
-We specify *debug* rule, so what the need to pass it as a param? May be:
-
-    any_level /something/ do |level, tag, msg| 
-    end
-
-and
-  
-    debug /something/ do |tag, msg|
-    end
-
-
-
-### Integration with Rails instrumenation, may be somewhat like:
-
-    debug 'sql.active_record' do |msg| do
-      # custom handling for Rails 'sql.active_record' instrumentation
-    end
-
+### ActiveResource::LogSubscriber instrumentation
+### Tests for Rails instrumentation
+### Refactor TagMatcher#match? with ===
 ### Documentation
 
 ### Ability to accept blocks as arguments for #debug, #info, and alike, i.e.:

data/lib/tagged_logger/railtie.rb

@@ -1,9 +1,25 @@
 if defined?(Rails::Railtie)
   module TaggedLogger
     class Railtie < Rails::Railtie
-      ActiveSupport.on_load(:action_controller) { TaggedLogger.send(:inject_logger_method_in_call_chain, ActionController::Base)}
-      ActiveSupport.on_load(:active_record)     { TaggedLogger.send(:inject_logger_method_in_call_chain, ActiveRecord::Base)}
-      ActiveSupport.on_load(:action_mailer)     { TaggedLogger.send(:inject_logger_method_in_call_chain, ActionMailer::Base)}
+      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"
+      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"
+      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"
+      end
+      ActiveSupport.on_load(:action_view) do
+        TaggedLogger.send(:inject_logger_method_in_call_chain, ActionView::LogSubscriber)
+        TaggedLogger.rename [ActionView::LogSubscriber] => "action_view.instrumentation"
+      end
     end
   end
 end

data/lib/tagged_logger/tagged_logger.rb

@@ -132,10 +132,10 @@ module TaggedLogger
       TagMatcher.new(tag, level)
     end
     
-    def tag_aliases(tag, &block)
+    def tag_aliases(tag)
       current_name = tag
       @rename_rules.each { |from, to| current_name = to if from.match?(tag) }
-      block.call(current_name)
+      yield current_name
     end
     
     def tag_blocks(level, tag, &block)

metadata

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