tlogger 0.8.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc3fda5c05c3948e3e08c0c184783455568b5fc3e37cf30a1d3029ac7be83d5c
-  data.tar.gz: 4eaf9af7bfea0d31fae02b83f0580ddd364369ae6e0dc6f2a5b1e691a3491c6c
+  metadata.gz: 7e5e945c26521b256ba6c54e4bfa3cdabd734872bb98d2ca5e1f5ce5e5005638
+  data.tar.gz: 80622dc6905d7f80c05bd2f2c81a987bcafa089fb21602e132e165e87f03cc2a
 SHA512:
-  metadata.gz: f1983481092884cec366883ff9e8759166f29b0c10712f09b533929fa7ebe60f839c035c47219a0d803f95052ab1f76630dab247a5efd21f8bd6456efeab0461
-  data.tar.gz: a875347a3631098a66eaff1140813d4b3b849452a1a0e9c201cba19f19e2c9c0fa7767faab22be8a246ec5fc9987f5db21f1aabcb5c27461ca0efa84b7185ff9
+  metadata.gz: a260719058fe3c4cc1ab51cc4540d52a92c56cb82a5cc1a8088fb4affbf9e662b4250e73efe6ed40a44a6ad879a4da88e971b2a4ea4be456def6ad37beeeb305
+  data.tar.gz: c72dee13fc95be607c60726749d10ea3de968e46c35c21495cdd245bbfa2fe0b93576ab3d7e96d4f365c409781f3041b37e6e78c879cf2c33271ff9f2425356a

data/.gitignore

@@ -6,3 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.log

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,10 @@
 require "bundler/gem_tasks"
-task :default => :spec
+require "rake/testtask"
+
+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/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