tlogger 0.6.0 → 0.22.0

data/lib/tlogger/logger_group.rb

@@ -0,0 +1,105 @@
+
+
+module Tlogger
+
+  # LoggerGroup is yet at wrapper around the Tlogger  
+  # This class can be used as Tlogger replacement as it is 
+  # delegated to the Tlogger upon method_missing method triggered.
+  #
+  # However this allow configuration of multiple loggers into
+  # single class.
+  #
+  # When operation such as 'debug' is called on this class
+  # all the registered logger shall be called the 'debug' method each therefore
+  # it will be logged to all registered loggers
+  class LoggerGroup
+
+    def initialize
+      @loggers = {  }
+    end
+
+    ## 
+    # Create and add the logger into the group and registerd it with the given +key+  
+    #
+    # *params shall be passed to underlying Tlogger new method
+    #
+    # Returns created Tlogger object
+    def create_logger(key, *params)
+      @loggers[key] = Tlogger.new(*params)
+      @loggers[key]
+    end # #create_logger
+
+    # Delete this logger from the group.
+    # 
+    # delete_logger different from detach_logger as delete_logger shall close and set the logger to nil. 
+    # 
+    # detach_logger however just remove the logger from the group and it is up to the applicaation to close it. 
+    def delete_logger(key)
+      logger = @loggers[key]
+      if not logger.nil?
+        logger.close
+        logger = nil
+      end
+      @loggers.delete(key)
+    end # #delete logger
+
+    ## 
+    # Detach the logger from the group, but not close the logger
+    # 
+    # Detach the logger return the object to the caller and remove it from the internal group
+    #
+    # The effect is after detach operation, any logging done to this group would not include that particular logger and 
+    # application is free to use the logger to log messages
+    #
+    def detach_logger(key)
+      @loggers.delete(key)
+    end # # detach_logger
+
+    ##
+    # Add an existing logger instance to this group
+    #
+    # Noted that this logger object not necessary to be Tlogger object. It can be any object as long as it has the method that
+    # response to the usage.
+    # 
+    # This is due to this class just a thin wrapper around the 'logger' object that any method call unknown to local shall be
+    # redirected to the 'logger' class.
+    #
+    # In another way, it is perfectly ok to call say_hello() on LoggerGroup if the 'logger' given response to method say_hello() or else
+    # NoMethodException shall be thrown. It is that simple.
+    def add_logger(key, logger)
+      @loggers[key] = logger
+    end
+
+    # Returns the logger that registered to the +key+
+    def get_log(key)
+      @loggers[key]
+    end
+
+    # Close the logger group, effectively close all registered loggers
+    def close
+      @loggers.each do |k,v|
+        v.close
+        v = nil
+      end
+      @loggers.clear
+    end # # close
+
+    # Delegate unknown method to the underlying logger
+    def method_missing(mtd,*args,&block)
+
+      #hit = false
+      @loggers.each do |k,v|
+        begin
+          v.send(mtd,*args,&block)
+          #hit = true
+        rescue Exception => ex
+          STDERR.puts ex.message
+        end
+      end
+
+      #super if not hit
+
+    end # # method_missing
+
+  end
+end

data/lib/tlogger/tlogger.rb

@@ -0,0 +1,380 @@
+
+require 'logger'
+require 'openssl'
+
+module Tlogger
+
+  ##
+  # Tlogger class is meant to be a thin wrapper around the Ruby Logger class (by default) to provide contextual logging capabilities to the logging system.
+  #
+  # Contextual logging allow developers:
+  # * Structure the log message not only by the severity (debug, info, error, warning) but also another key that is useful for the application
+  #   during troublehshooting purposes. This can provide more info to the log message being logged. For example can automatically tag the log 
+  #   message with number of 1789 loops in the program
+  # * Subsequent from this context info, developer now can selectively turn on / off certain logging message to get the clarity needed. Relying
+  #   on the above example, if we are only interested in loop 1232, we can disabled all other log message EXCEPT the tag show loop_1232. 
+  #   This will drastically reduce the effort required in reading all the 1231 lines of log. 
+  #
+  # I found it rather helpful especially in managing the print out of log AFTER it has been logging from everywhere in my programs. 
+  # I also found that just filtering by log level (debug, info, error and warn) is not sufficient sometime to lessen the effort of log reading 
+  # for a specific issue especially the only way to debug is turned on the debug level and ALL debug messages now sprang to life! 
+  # It is really not an easy task to look for specific info especially when it was an old project.
+  #
+  # Now you can just disable all and only turn on the specific tag around the issue area to investigate the issue. You will now have better focus
+  # in the issue on hand instead of hunting the line that you need from long list of debug output.
+  class Tlogger
+
+    # +tag+ is the tag that is being set for this logger session.
+    # 
+    # One session shall only have one specific tag value, which is the default tag for this logger session.
+    # 
+    # If multiple tags are required, use the method tdebug, terror, twarn, tinfo or #with_tag block to create a new tag
+    #
+    # Note that the tag can be in symbol or string, however shall convert to symbol when processing
+    attr_accessor :tag 
+    # +include_caller+ (true/false) tell the logger to print the caller together with the tag 
+    attr_accessor :include_caller
+    # +logger+ it is the actual logger instance of this Tlogger
+    attr_reader :logger
+
+    def initialize(*args , &block)
+      # default to console
+      if args.length == 0
+        args << STDOUT
+      end
+
+      @opts = {}
+      if args[-1].is_a?(Hash)
+        @opts = opts
+        @opts = { } if @opts.nil?
+        args = args[0..-2]
+      end
+
+      @logger = @opts[:logger_instance] || Logger.new(*args,&block)
+      @disabled = []
+      @dHistory = {}
+      @include_caller = false
+      @tag = nil
+
+      @genable = true
+      @exception = []
+    end # initialize
+
+    # 
+    # :method: with_tag
+    #
+    # Tag all log inside the block with the given tag value
+    #
+    # Useful to tag multiple lines of log under single tag
+    #
+    def with_tag(tag,&block)
+      if block and not tag.nil?
+        log = self.clone
+        log.tag = tag
+        block.call(log)
+      end
+    end # with_tag
+
+    # 
+    # :method: off_tag
+    #
+    # Turn off a tag. After turning off, the log message that tie to this tag shall not be printed out
+    #
+    # Do note that all tags by default are turned on.
+    #
+    def off_tag(*tags)
+      tags.each do |tag|
+        if not (tag.nil? or tag.empty? or @disabled.include?(tag))
+          @disabled << tag.to_sym
+        end
+      end
+    end # off_tag
+    alias_method :tag_off, :off_tag
+
+    #
+    # :method: on_tag
+    #
+    # Turn on a tag. 
+    #
+    # Note that by default all tags are turned on. This only affect whatever tags that has been turned off via 
+    # the method #off_tag. It doesn't work as adding a tag. Adding a tag message should use tdebug, terror, tinfo,
+    # twarn or #with_tag
+    def on_tag(*tags)
+      tags.each do |tag|
+        @disabled.delete(tag.to_sym) if not (tag.nil? or tag.empty?)
+      end
+    end # on_tag
+    alias_method :tag_on, :on_tag
+
+    # 
+    # :method: off_all_tags
+    #
+    # All log messages with tag out of your face!
+    #
+    def off_all_tags
+      @genable = false
+      clear_exceptions
+    end
+    alias_method :all_tags_off, :off_all_tags
+    alias_method :tags_all_off, :off_all_tags
+
+    #
+    # :method: on_all_tags
+    #
+    # All log messages now come down on you! RUN!
+    # 
+    # No wait, you need to read that before you run away...
+    #
+    def on_all_tags
+      @genable = true
+      clear_exceptions
+    end
+    alias_method :all_tags_on, :on_all_tags
+    alias_method :tags_all_on, :on_all_tags
+
+    # 
+    # :method: off_all_tags_except
+    # 
+    # Turn off all tags EXCEPT the tags given.
+    #
+    # Note the parameters can be a list (multiple tags with ',' separator)
+    #
+    def off_all_tags_except(*tags)
+      off_all_tags
+      clear_exceptions
+      @exception.concat tags.map(&:to_sym)  
+    end
+    alias_method :off_all_except, :off_all_tags_except
+    alias_method :all_off_except, :off_all_tags_except
+
+    # 
+    # :method: on_all_tags_except
+    #
+    # Turn on all tags EXCEPT the tags given
+    #
+    # Note the parameters can be a list (multiple tags with ',' separator)
+    #
+    def on_all_tags_except(*tags)
+      on_all_tags
+      clear_exceptions
+      @exception.concat tags.map(&:to_sym)
+    end
+    alias_method :on_all_except, :on_all_tags_except
+    alias_method :all_on_except, :on_all_tags_except
+
+    # 
+    # :method: clear_exceptions
+    #
+    # Clear the exception list. All exampted tags given either by #off_all_tags_except or #on_all_tags_except 
+    # shall be reset
+    #
+    def clear_exceptions
+      @exception.clear
+    end
+
+    # 
+    # :method: remove_from_exception
+    #
+    # Remote a set of tags from the exception list
+    #
+    def remove_from_exception(*tags)
+      @exception.delete_if { |e| tags.include?(e) }
+    end
+
+    # 
+    # :method: method_missing
+    #
+    # This is where the delegation to the Logger object happen or no_method_exception shall be thrown
+    #
+    def method_missing(mtd, *args, &block)
+      if [:debug, :error, :info, :warn].include?(mtd)
+      
+        if args.length > 0 and args[0].is_a?(Symbol)
+          tag = args[0]
+          args = args[1..-1]
+        else
+          tag = @tag
+        end 
+        
+        if is_genabled?(tag) and not tag_disabled?(tag) 
+
+          if block
+            if not (tag.nil? or tag.empty?) and args.length == 0 
+              args = [ format_message(tag) ]
+            end
+
+            out = block
+          else
+            if not (tag.nil? or tag.empty?)
+              str = args[0]
+              args = [ format_message(tag) ]
+              out = Proc.new { str }
+            else
+              out = block
+            end
+          end
+
+          @logger.send(mtd, *args, &out)
+
+        end # if not disabled
+
+
+      elsif [:tdebug, :terror, :tinfo, :twarn].include?(mtd)
+       
+        key = args[0]
+       
+        if is_genabled?(key) and not tag_disabled?(key.to_sym)
+          if block
+            out = Proc.new { block.call }
+            args = [ format_message(key) ]
+          else
+            str = args[1]
+            out = Proc.new { str }
+            args = [ format_message(key) ]
+          end
+
+          mtd = mtd.to_s[1..-1].to_sym
+          @logger.send(mtd, *args, &out)
+        end
+
+      elsif [:odebug, :oerror, :oinfo, :owarn].include?(mtd)
+
+        key = args[0]
+
+        if is_genabled?(key) and not tag_disabled?(key)
+
+          if block
+            out = Proc.new { block.call }
+            args = [ format_message(key) ]
+          else
+            str = args[1]
+            out = Proc.new { str }
+            args = [ format_message(key) ]
+          end
+
+          msg = out.call
+          if not (msg.nil? or msg.empty?) 
+            if not already_shown_or_add(key,msg)
+              mtd = mtd.to_s[1..-1].to_sym
+              @logger.send(mtd, *args, &out)
+            end
+          end
+
+        end
+
+      elsif [:ifdebug, :iferror, :ifinfo, :ifwarn].include?(mtd)  
+     
+        cond = args[0]
+        key = args[1]
+
+        if cond.is_a?(Proc)
+          cond = cond.call
+        end
+
+        if is_genabled?(key) and not tag_disabled?(key) and cond
+
+          if block
+            out = Proc.new { block.call }
+            args = [ format_message(key) ]
+          else
+            str = args[2]
+            out = Proc.new { str }
+            args = [ format_message(key) ]
+          end
+
+          msg = out.call
+          if not (msg.nil? or msg.empty?) 
+            mtd = mtd.to_s[2..-1].to_sym
+            @logger.send(mtd, *args, &out)
+          end
+
+        end
+
+      elsif @logger.respond_to?(mtd)
+        @logger.send(mtd, *args, &block)
+      else
+        super
+      end
+    end # method_missing
+
+    # 
+    # :method: tag_disabled?
+    #
+    # Check if the tag is disabled
+    #
+    def tag_disabled?(tag)
+      if tag.nil? or tag.empty?
+        false
+      else
+        @disabled.include?(tag.to_sym)
+      end
+    end
+
+    #
+    # :method: show_source
+    # Helper setting the flag include_caller
+    #
+    def show_source 
+      @include_caller = true
+    end
+
+    private
+    def format_message(key)
+      # returning args array
+      if @include_caller
+        "[#{key}] #{find_caller} "
+      else
+        "[#{key}] "
+      end 
+    end
+
+    def is_genabled?(key)
+      if key.nil?
+        true
+      else
+        (@genable and not @exception.include?(key.to_sym)) or (not @genable and @exception.include?(key.to_sym))
+      end
+    end
+
+    def already_shown_or_add(key,msg)
+      smsg = Digest::SHA256.hexdigest(msg)
+      if @dHistory[key.to_sym].nil?
+        add_to_history(key,smsg)
+        false
+      else
+        res = @dHistory[key.to_sym].include?(smsg)
+        add_to_history(key,smsg) if not res
+        res
+      end
+    end # already_shown_or_add
+
+    def add_to_history(key,dgt)
+      @dHistory[key.to_sym] = [] if @dHistory[key.to_sym].nil?
+      @dHistory[key.to_sym] << dgt if not @dHistory[key.to_sym].include?(dgt)
+    end # add_to_history
+
+    def find_caller
+      caller.each do |c|
+        next if c =~ /tlogger.rb/
+        @cal = c
+        break
+      end
+
+      if @cal.nil? or @cal.empty?
+        @cal = caller[0] 
+      end 
+     
+      # reduce it down to last two folder?
+      sp = @cal.split(File::SEPARATOR)
+      if sp.length > 1
+        msg = "/#{sp[-2]}/#{sp[-1]}" 
+      else
+        msg = sp[-1]
+      end
+      
+      msg
+      
+    end # find_caller
+
+  end
+end