tlogger 0.8.0 → 0.21.0

data/lib/tlogger/tlogger.rb

@@ -0,0 +1,352 @@
+
+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(args[0]) ]
+          else
+            str = args[1]
+            out = Proc.new { str }
+            args = [ format_message(args[0]) ]
+          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(args[0]) ]
+          else
+            str = args[1]
+            out = Proc.new { str }
+            args = [ format_message(args[0]) ]
+          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 @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

data/lib/tlogger/version.rb

@@ -1,3 +1,3 @@
 module Tlogger
-  VERSION = "0.8.0"
+  VERSION = "0.21.0"
 end

data/lib/tlogger.rb

@@ -1,330 +1,11 @@
-
-
-require 'logger'
-require 'singleton'
-
 require "tlogger/version"
 
+require_relative "tlogger/tlogger"
+require_relative "tlogger/logger_group"
+
+# 
+# :nodoc:
+#
 module Tlogger
   class Error < StandardError; end
-  # Your code goes here...
-
-  # 
-  # Singleton object to facilitate tag management
-  #
-  class TloggerConf
-    include Singleton
-    attr_reader :active_tags, :scoped_tag, :blacklisted_tags, :show_source
-    #GLOBAL_TAG = :global
-    GLOBAL_TAG = ""
-    INT_TAG = :tlogger
-    
-    def initialize
-      @active_tags = []
-      # tag added to black listed will not be printed out even the tag is added later in the code path
-      @blacklisted_tags = []
-      @disable_all_tags = false
-      @auto_tag = false
-      # todo
-      # allow to redirect certain tag to specific output. tag: [<config>]
-      @output_map = {}
-      # if output_map is there, then there should be pre created log file with specific output defined in the map. [<config>] => log_instance
-      @output_log = {}
-      # show where is the log being printed out. Like auto_tag output
-      @show_source = false
-      # end todo
-    end
-
-    def show_source
-      @show_source = true
-    end
-    alias_method :auto_tag_on, :show_source
-
-    def hide_source
-      @show_source = false
-    end
-    alias_method :auto_tag_off, :hide_source
-
-    def is_show_source?
-      @show_source
-    end
-    alias_method :is_auto_tag_on?, :is_show_source?
-
-    #def auto_tag_on
-    #  @auto_tag = true
-    #end
-
-    #def auto_tag_off
-    #  @auto_tag = false
-    #end
-
-    #def is_auto_tag_on?
-    #  @auto_tag
-    #end
-
-    def activate_tag(tag)
-      @active_tags << tag
-    end
-
-    def deactivate_tag(tag)
-      @active_tags.delete(tag)
-    end
-
-    def blacklist_tag(tag)
-      if tag.is_a?(Array)
-        @blacklisted_tags += tag
-      else
-        @blacklisted_tags << tag
-      end
-    end
-
-    def all_tags_off
-      @disable_all_tags = true
-    end
-
-    def all_tags_on
-      @disable_all_tags = false
-    end
-
-    def whitelist_tag(tag)
-      if tag.is_a?(Array)
-        tag.each do |t|
-          @blacklisted_tags.delete(t)
-        end
-      else
-        @blacklisted_tags.delete(tag)
-      end
-    end
-
-    def whitelist_all_tags
-      @disabled_tags.clear
-    end
-   
-    def is_tag_active?(tag)
-      if @disable_all_tags
-        false
-      else
-        @active_tags.include?(tag) #and not @disabled_tags.include?(tag)
-      end
-    end
-
-    def remove_all_active_tags
-      @active_tags.clear
-    end
-
-    def set_scoped_tag(tag)
-      @scoped_tag = tag
-    end
-
-    def clear_scoped_tag
-      @scoped_tag = nil
-    end
-
-    def has_scoped_tag?
-      if @disable_all_tags
-        false
-      else
-        not @scoped_tag.nil? and not @scoped_tag.empty?
-      end
-    end
-
-    def is_scoped_tag_active?
-      #@active_tags.include?(@scoped_tag)
-      not @blacklisted_tags.include?(@scoped_tag)
-    end
-
-    def self.method_missing(mtd,*args,&block)
-      if TloggerConf.instance.respond_to?(mtd)
-        TloggerConf.instance.send(mtd,*args,&block)
-      else
-        super
-      end
-    end
-  end
-  # 
-  # end TloggerConf singleton
-  #
-
-  # 
-  # add object like methods to make module a class
-  #
-  class << self
-    attr_accessor :tag
-    include Tlogger
-    
-    PROXY_MTD = [:debug, :info, :error, :warn]
-    def new(*args)
-      if args.length == 0
-        args << STDOUT
-      end
-      @tlogger = Logger.new(*args)
-      @tag = TloggerConf::GLOBAL_TAG
-      # disable by default
-      # If there is issue then enable it back in application level
-      self
-    end
-
-    def tag=(val)
-      @tag = val
-      TloggerConf.activate_tag(@tag)
-      self
-    end
-
-    def tdebug(tag,*args)
-      with_tag(tag) do
-        self.debug(*args)
-      end
-      self
-    end
-
-    def terror(tag, *args)
-      with_tag(tag) do
-        self.error(*args)
-      end
-      self
-    end
-
-    def tinfo(tag, *args)
-      with_tag(tag) do
-        self.info(*args)
-      end
-      self
-    end
-
-    def twarn(tag, *args)
-      with_tag(tag) do
-        self.warn(*args)
-      end
-      self
-    end
-
-    def intDebug(msg)
-      #puts TloggerConf.active_tags
-      if TloggerConf.instance.is_tag_active?(TloggerConf::INT_TAG)
-        msg2 = "[#{TloggerConf::INT_TAG}] #{msg}"
-        #puts "intDebug"
-        @tlogger.debug(msg2)
-      end
-    end
-
-    def method_missing(mtd,*args,&block)
-      #@tlogger.debug "[tlogger] method_missing: Method #{mtd}"
-      intDebug("method_missing: #{mtd}")
-      if @tlogger.respond_to?(mtd)
-
-        if PROXY_MTD.include?(mtd)
-          
-          if @tag.nil? or @tag.empty?
-            # no tag. Output like normal log
-            @tlogger.send(mtd, *args, &block)
-            
-          else
-
-            if TloggerConf.has_scoped_tag?
-              if TloggerConf.is_scoped_tag_active?
-                intDebug("Scoped tag detected")
-                tag = []
-                tag << TloggerConf.scoped_tag
-                if TloggerConf.instance.is_show_source?
-                  tag << " - "
-                  tag << find_caller
-                end
-                args[0] = "[#{tag.join}] #{args[0]}"
-                @tlogger.send(mtd,*args,&block)
-              end
-            elsif TloggerConf.is_tag_active?(@tag)
-              intDebug("Tagged output...")
-              tag = []
-              tag << @tag
-              if TloggerConf.instance.is_show_source?
-                tag << " - "
-                tag << find_caller
-              end
-              args[0] = "[#{tag.join}] #{args[0]}"
-              @tlogger.send(mtd,*args,&block)
-              
-            elsif TloggerConf.is_auto_tag_on?
-              intDebug("auto_tag is on...")
-              args = tag_class(*args)
-              @tlogger.send(mtd,*args,&block)
-
-            end
-            
-          end
-
-        else
-          intDebug("Not proxy method for logger. Pass to logger to handle. (#{mtd})")
-          ## not the debug, info, warn and error method, no need change message
-          @tlogger.send(mtd, *args, &block)
-        end
-
-
-      elsif TloggerConf.instance.respond_to?(mtd)
-        # redirect the config method to make it consistent API
-        intDebug("Redirect to TloggerConf for consistancy (#{mtd})")
-        TloggerConf.send(mtd, *args, &block)
-      else
-        intDebug("Call method_missing parent to handle method '#{mtd}'")
-        super
-      end
-    end
-    # end method_missing
-    # 
-
-    private
-    def tag_class(*args)
-      args[0] = "[#{find_caller}] #{args[0]}"
-      args
-    end
-    # end tag_class()
-    #
-  
-    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
-      
-      #wd = Dir.getwd
-      #indx = @cal =~ /#{wd}/
-      #if indx != nil
-      #  @scal = []
-      #  @scal << @cal[0..indx]
-      #  @scal << @cal[indx+wd.length..-1]
-      #  @scal.join
-      #else
-      #  @cal
-      #end
-    end
-    # end find_caller
-    #
-  end
-  # 
-  # end class definition
-  #
-
-
-  def with_tag(tag,&block)
-    if block
-      TloggerConf.instance.set_scoped_tag(tag) #if not TloggerConf.instance.disabled_tags.include?(tag)
-      block.call
-      TloggerConf.instance.clear_scoped_tag
-    end
-  end
-  
 end