tlogger 0.7.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f9b1b28c4dfcbe2b0fd0de47df01d8f14e83ae00efa3b3abbd6db9bd8330d1f
-  data.tar.gz: a59d64d311798dd9a523b2e13223e580db07e3a1b67825b7e680192f69414051
+  metadata.gz: 7cf3256d26a571615fe3121d443904dcbeb8cf54ea1761a1d52704d36f5a9418
+  data.tar.gz: e0c620dca8f28c1f2177bd4e460c68b43bd4a31be6906cf304423240481a59b9
 SHA512:
-  metadata.gz: 2c238b0a66dd21096b9e0d0d9a36557bfb19f2fda136fd0bc38afd1d9caeafa218c865a20e8c30a4d7bcab5414aafda160d4ade4d81da1e723b92590e6453cc1
-  data.tar.gz: 638660c6d8e855986608c112d1b2a1e5792f862538983229cbbcae4f867b40f891c0abb3ada22daa8f6555d38e3352c9e66ea2eff91d787a121e6631cd51e726
+  metadata.gz: 26a1ecb562014272126bcbe5669ca7e6cee341d93f1c0bca7f52a85f099f60d7e8f5557001ad032ce00379f295ec14a749242020f7b5e9797c4bc25ee28b7f28
+  data.tar.gz: b22ed97e724d855d993533cd5062920c85934358e2e1e62fb691d81e4045c28e2335a93f3b8c7c83dd3646dffb985b3e9bc89abd897ef5f6ee5966565c86c4e8

data/.gitignore

@@ -6,3 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.log
+*.gem
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.1.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at chrisliaw@antrapol.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -2,3 +2,6 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in tlogger.gemspec
 gemspec
+
+gem "rake", ">= 12.3.3"
+gem "minitest", "~> 5.0"

data/README.md

@@ -1,5 +1,28 @@
 # Tlogger
 
+Tlogger is the attempt to have some control in logging by the developer.
+
+I found that usually debug message is turned off in production environment but when issue happened and investigation undergoing, there is little help to the developer when ALL debug messages now falls on the developer. Developer now has to go line by line or by searching certain keyword from a big big log file just to see what's happening inside the program. What if you can just disable all other log messages and only focus on the log messages around the suspected issue? That is the reason of this library.
+
+Tlogger wrap around the default Ruby Logger class to provide the actual logging facilities, however allow developer to add some context with the log messages. 
+The context is a string that is printed along with the log messages
+
+For example:
+
+```console
+D, [2020-04-23T16:19:15.537926 #23173] DEBUG -- [global] : Testing 123
+I, [2020-04-23T16:19:15.537964 #23173]  INFO -- [global] : Testing 123
+W, [2020-04-23T16:19:15.537980 #23173]  WARN -- [global] : Testing 123
+E, [2020-04-23T16:19:15.537993 #23173] ERROR -- [global] : Testing 123
+```
+Note the '[global]' in the print out is the context.
+
+The Ruby Logger actually already supported this feature therefore Tlogger just use the feature, with some additional utilities around the context.
+
+The utilities include:
+* Selectively turn on and off certain log messages based on tag
+* Turn off/on all log messages with tagging
+* Provide group logging engine whereby single log message can be written to multiple log engines (e.g. STDOUT and log file)
 
 
 ## Installation
@@ -12,7 +35,7 @@ gem 'tlogger'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -20,18 +43,77 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Basic - Adding Context
+
+Since Tlogger is just wrapped around Ruby Logger, it is initiated like Logger:
 
-## Development
+```ruby
+require 'tlogger'
+
+# Initiate without parameters shall print out the log to STDOUT
+log = Tlogger::Tlogger.new
+
+# Alternatively, this initiate logging with log file
+# The parameter is directly pass to Ruby Logger.new method
+log = Tlogger::Tlogger.new('app.log',10,1024000)
+
+# default tag for this logger instance / session
+log.tag = "init"
+
+# now logging can be done as usual...
+log.debug "Step 1 rolling"
+D, [2020-04-23T16:19:15.537926 #23173] DEBUG -- [init] : Step 1 rolling  # sample output
+....
+...
+...
+log.debug "Step 1.1 rolling"
+D, [2020-04-23T16:19:15.537940 #23173] DEBUG -- [init] : Step 1.1 rolling  # sample output
+...
+...
+log.debug "Step 1.1.1 rolling"
+D, [2020-04-23T16:19:15.537963 #23173] DEBUG -- [init] : Step 1.1.1 rolling  # sample output
+...
+...
+
+# context switch
+log.tdebug :phase1, "Step 2 starting..."
+D, [2020-04-23T16:19:18.537881 #23173] DEBUG -- [phase1] : Step 2 starting...  # sample output
+...
+log.tdebug :phase1, "Step 2 setup completed..."
+D, [2020-04-23T16:19:18.537881 #23173] DEBUG -- [phase1] : Step 2 setup completed...  # sample output
+...
+...
+# or tag a group of log files
+log.with_tag(:phase2) do
+  log.debug "Step 3 starting..."
+D, [2020-04-23T16:19:18.548893 #23173] DEBUG -- [phase2] : Step 3 starting...  # sample output
+  log.error "Step 3 parameter X is wrong"
+E, [2020-04-23T16:19:18.548893 #23173] ERROR -- [phase2] : Step 3 parameter X is wrong  # sample output
+end
+
+# after the block, the default tagging shall be restored
+log.error "Stepping stopped in the middle"
+E, [2020-04-23T16:19:18.548893 #23173] ERROR -- [init] : Stepping stopped in the middle  # sample output
+```
+
+### Filter Log Messages
+
+After the log messages are tagged, let say two years down the road the program is reported having error. You suspected should be around phase 1 or phase 2 operation, you can now load back the program, configure the log
+
+```ruby
+# turned off all tags except the one given
+log.off_all_tags_except(:phase1, :phase2)
+
+# OR turned off selected tags only
+log.tag_off(:init)
+```
+By configuring the log above, only log messages tagged with :phase1 and :phase2 shall be logged inside the log file. This drastically reduce the log entries that developer needs to find from one giant log file.
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Possible Concern
 
-## Contributing
+By limiting the log messages, it may be more difficult some times to spot the issue since the log messages that point out the error has already been filtered from the log file. It is definitely possible that this is happening since not all log messages shall be available if it is filtered. Therefore it is up to the developer if that is a disadvantages or advantages under their specific use case. Also it is up to developer to tag the log messages which can be anything under the sun. It may be only two tags, one for internal usage one for external. Hence it is really up to the use case that makes the scenario possible or otherwise.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tlogger.
+To me I can now even in production system, hide some log messages under info log level and reveal it if necessary. Since it is part of the code, the tag to hide or show can be configured via a configuration files. No changing of code needed and the debug messages can be as extensive as possible since you know that there is a way to filter after that.  
 
-## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,2 +1,12 @@
 require "bundler/gem_tasks"
-task :default => :spec
+require "rake/testtask"
+
+require 'devops_helper'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -7,8 +7,8 @@ require "tlogger"
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-require "pry"
-Pry.start
+# require "pry"
+# Pry.start
 
-#require "irb"
-#IRB.start(__FILE__)
+require "irb"
+IRB.start(__FILE__)

data/lib/tlogger.rb

@@ -1,327 +1,54 @@
-
-
-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
-  #
+  # shorten the initializer to Tlogger.new instead of the longer Tlogger::Tlogger.new
   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
+    def new(*args,&block)
+      ::Tlogger::Tlogger.new(*args,&block) 
     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)
+    # detect if the prompt should be to env or file
+    def init
+      if is_dev?
+        new(STDOUT) 
+      else
+        c = output_channel
+        new(*c[:path])
       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)
-            
+    private
+    def is_dev?
+      ENV.keys.include?("TLOGGER_MODE") and ENV["TLOGGER_MODE"].downcase == "dev"
+    end
+
+    def output_channel
+      out = ENV["TLOGGER_OUT"]
+      if not out.nil?
+        case out
+        when "file"
+          path = ENV["TLOGGER_OUTPATH"]
+          if path =~ /,/
+            { mode: :file, path: path.split(",") }
           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_auto_tag_on?
-              intDebug("auto_tag is on...")
-              args = tag_class(*args)
-              @tlogger.send(mtd,*args,&block)
-            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)
-            end
-            
+            { mode: :file, path: [path] }
           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)
+          { mode: :file, path: [nil] }
         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
+        { mode: :stdio, path: [nil] }
       end
     end
-    # end method_missing
-    # 
+  end # class self
 
-    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
+