alog 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c99568a04040e5467af6aa0230606d1b3e7e6d12a19da083ce27574a12a67a1
+  data.tar.gz: a0f6cfa695a5b1b1874eb2a55cfa88804f1ceccbe34b6e2c07254a01309508ad
+SHA512:
+  metadata.gz: c08f58b90258819bc35b63a40da82aa126645d976edb5b2a625c532dcaf9e44bfecc14b8e4d33915f53c7c6ed25ea8ca842e3f77112589d0987f76238a761cbb
+  data.tar.gz: 921a75bed5bfb7b861e3bc27fa2bfeb87394055f44c18c8133da03c34b7c0da9d9158cfe8d1bead17f55dc2d1cbe05f86b427ce37dc79b5753c158edbed636c9

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in alog.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    alog (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  alog!
+  bundler (~> 2.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Chris Liaw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,141 @@
+# Alog
+
+Alog (Advanced/Antrapol Logging) is an attempt to tackle the logging issue that is too verbose. 
+
+Logging is better to be verbose but when working on large project, the development is evolution type of progress instead of revolution. Hence the logging output tends to be increasing over the time of development. Those logging generated during the early stage of the development may not be siginificant in later development work. 
+
+In other framework there is conditional logging like #IFDEF in C to ignore logging if a key is not defined. 
+
+This conditional logging however is not related to the log level (DEBUG, ERROR etc) as defined by the log engine.
+
+Alog is meant to be allow developer to group the logging under a meaningful tag and if the tag is not defined, the log is skipped therefore removing the log entirely out from the view of the developer and left only the current focusing development work's log.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'alog'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install alog
+
+## Usage
+
+First is to include the alog library
+```ruby
+require 'alog'
+```
+
+Include the namespace into your class and configure the tag that you want the library to show/display. 
+Any tag that is not configured will be skipped
+
+```ruby
+class MyApp
+  include Alog
+  
+  # STEP 1: Configuration
+  #
+  # Configure logger and bind the logger to a key
+  # Whatever on the right side shall be passed to the standard library Logger object
+  # The array construct is necesary because *args is used in 
+  # passing the parameters to actual standard library Logger object via new()
+  LogFacts[:stdout] = [STDOUT]  
+  # Also multiple loggers can be configured by creating multiple keys
+  LogFacts[:app_file] = ['app.log',10, 1024000]
+  ...
+  
+  # STEP 2: Define which keys to activate
+  # Any block/log output tagged by the key included in this array shall be printed
+  LogTag << :feature_1
+  LogTag << :feature_2
+  ...
+  # Any tag that is not configured inside the LogTag will not be printed out
+  # If the list is empty, no log under the library shall be printed.
+  # Or there is more then dozens tags and want to show all, use this method
+  show_all_tags
+
+  
+  # STEP 3: Create the logging
+  def my_method(p1, p2)
+    # Method 1: block logging
+    l(:feature_1, type: :debug, logEng: [:stdout]) do
+      # All clog() call inside this block will be tagged with key :feature_1
+      # enabling the key :feature_1 shall show all log messages inside this block or disabling otherwise
+      ...
+      ...
+      # If only message is given, the following is the default:
+      # 1. The system shall use the first logger, in this case it will be using logger with key :stdout
+      # 2. The logger will use debug level to log the message 
+      #    (System will use log level debug if the log level is not given in the l() above via key 'type'.
+      clog "This is logging message"
+      ...
+      ...
+      # If the message and tag is given
+      # 1. The tag shall override the global configuration of logging level debug (to whatever level given by developer)
+      # Note that 'error' logging level will ignore the tag-skipping feature since error conditions (and its messages) will likely 
+      # affect the subsequent code/logic of a system. Therefore 'error' will always be printed.
+      clog "Error in defining X", :error
+      clog "Reach here means ok", :info
+      
+      # Asking the Alogger to write to other logger at the same time, 
+      # overriding the parameter given in the l().
+      clog "This will written to both :stdout and :app_file", logEng: [:stdout,:app_file]
+      ...
+      ...
+    end
+    
+    (business logic continues...)
+    ...
+    ...
+    # Method 2: Call clog() directly
+    # Param 1 : Log messages
+    # Param 2 : Log level [:debug|:info|:error] (empty = :debug)
+    # Param 3 : Tag of the log message (empty = :global)
+    # Param 4 : Log engine to be used (refers to LogFacts hash entries above) (empty = first LogFacts key)
+    clog("Business continue up to level 2", :debug, :feature_2, [:stdout])
+    ...
+    
+  end
+
+  def my_method2(p2)
+    # Method 3 : Create the AOlogger object
+    # AOlogger is meant to be proxy for standard Logger, with the tagging and multiple log engines included
+    # The initialize parameter is an array containing key to the LogFacts above...
+    # In the following case, the AOlogger shall only configured to :stdout configuration (refers above)
+    @log = AOlogger.new([:stdout])
+    ...
+    ...
+    # This behave like standard logging engine
+    @log.debug "Code reached here..."
+    ...
+    @log.error "Oppss... We did it again!"
+    ...
+    ...
+    # This allow application to participate in the conditional logging
+    # If the tag :feature_x is not activated, the message will not be printed.
+    @log.log("this only shown if tag :feature_x is activated", :debug, :feature_x, [:app_file])
+    
+  end
+
+end
+```
+
+
+## TODO
+
+Library not yet tested extensively under multi-threaded applications. Some variables may not be thread safe.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/chrisliaw/alog.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/alog.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "alog/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "alog"
+  spec.version       = Alog::VERSION
+  spec.authors       = ["Chris Liaw"]
+  spec.email         = ["chrisliaw@antrapol.com"]
+
+  spec.summary       = %q{Conditional logging to provide contextual logging and ability to reconfigure log message visibility during runtime}
+  spec.description   = %q{Allow contextual log output to ease developer in log management}
+  spec.homepage      = "https://github.com/chrisliaw/alog"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #  spec.metadata["homepage_uri"] = spec.homepage
+  #  spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  #end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "alog"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# 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 "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/alog/version.rb

@@ -0,0 +1,3 @@
+module Alog
+  VERSION = "0.1.0"
+end

data/lib/alog.rb

@@ -0,0 +1,166 @@
+require "alog/version"
+
+require 'logger'
+
+module Alog
+  class AlogException < StandardError; end
+
+  # allow application to provide which tag should print out
+  LogTag = [:global]
+  
+  # allow application to configure multiple logging
+  # log factories configurations
+  LogFacts = {}
+  
+  # multi logger created from
+  # LogFacts entry given by application
+  GLog = {}
+
+  # 
+  # class Alogger
+  # Inherited from standard library Logger
+  # 
+  class Alogger < Logger
+    def initialize(args)
+      @log = Logger.new(*args)
+    end
+
+    def log(msg, type = :debug, &block)
+      @log.send(type, msg)
+    end
+  end
+  # end class Alogger
+  # 
+
+  # 
+  # class AloggerObject
+  # Mimiking the original Logger object
+  # to be used by application but with
+  # the conditioning logging logic available
+  # to the application instead
+  #
+  class AOlogger
+    attr_reader :logEng
+    def initialize(logEng = [])
+      @myMethods = [:debug, :error, :warn, :warning]
+      @logEng = logEng || []
+    end
+
+    def log(msg, ltype = :debug, key = :global, logEng = [])
+      CondLog.call(msg, { key: key, type: ltype, logEng: logEng || @logEng })
+    end
+
+    def method_missing(mtd, *args, &block)
+      if @myMethods.include?(mtd)
+        params = {}
+        pa = args[1]
+        params[:key] = :global
+        params[:logEng] = @logEng
+        # TODO cases here may not be extensive to 
+        # the original Logger supported.
+        case mtd
+        when :debug
+          params[:type] = :debug
+          CondLog.call(args[0], params, &block)
+        when :error
+          params[:type] = :error
+          CondLog.call(args[0], params, &block)
+        when :warn, :warning
+          params[:type] = :warn
+          CondLog.call(args[0], params, &block)
+        end
+        
+      else
+        super
+      end
+    end
+  end
+  # 
+  # end class AloggerObject
+  # 
+
+  def show_all_tags
+    LogTag << :all
+  end
+
+  def selected_tags_only
+    LogTag.delete(:all)
+  end
+
+  # 
+  # Provide a block construct that can set values consistantly for multiple clog() call
+  # TODO How to make this thread safe?
+  # 
+  def l(key = :global, params = { type: :debug, logEng: [] } ,&block)
+    # this construct try to make the variable private to the block
+    # Still not sure will error condition exist for multi threaded application
+    b = Proc.new do |key, params, &block|
+      @lKey = key 
+      @lType = params[:type]
+      @llEng = params[:logEng]
+      if block
+        block.call
+      end
+    end
+    b.call(key, params, &block)
+  end
+
+  #
+  # Module level clog() method
+  # Meant to be called by application INSIDE the l()'s block
+  # 
+  def clog(msg, ltype = :debug, key = :global, logEng = [])
+    log(msg, { type: @lType != ltype ? ltype : @lType, 
+               key: (key == @lKey ? key : @lKey),
+               logEng: @llEng  })
+  end
+  #
+  # end of module level clob()
+  # 
+
+  # 
+  # Actual logic of detecting a tag should be activated and on which logger should it written to
+  # 
+  CondLog = Proc.new do |msg, params = {}, &block|
+    key = params[:key] || :global
+    type = params[:type] || :debug
+    if defined?(:LogTag) and LogTag.is_a?(Array) and (LogTag.include?(key) or LogTag.include?(:all)) or type == :error
+      logEng = params[:logEng]
+      if logEng == nil or (logEng != nil and logEng.empty?)
+        logEng = (LogFacts.length > 0 ? [LogFacts.keys[0]] : [:default])
+      end
+      
+      logEng = [logEng] if not logEng.is_a?(Array)
+
+      # allow written to multiple logger
+      logEng.each do |e|
+        
+        if GLog[e] == nil
+
+          lp = LogFacts[e]
+          if lp == nil
+            # default if empty
+            lp = [STDOUT]
+          end
+
+          # ensure the same configuration only created a logger object once
+          GLog[e] = Alogger.new(lp)
+
+        end
+        
+        GLog[e].log("#{caller.length > 3 ? "[#{File.basename(caller[4])}]" : ""} [#{key}] #{msg}", type, &block)
+      end
+      
+    end
+    
+  end
+  # end CondLog() proc
+  # 
+
+  # provide module level method to write to the logger object
+  def log(msg, params = { }, &block)
+    CondLog.call(msg, params, &block)
+  end
+  # end module level log()
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: alog
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Liaw
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Allow contextual log output to ease developer in log management
+email:
+- chrisliaw@antrapol.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- alog.gemspec
+- bin/console
+- bin/setup
+- lib/alog.rb
+- lib/alog/version.rb
+homepage: https://github.com/chrisliaw/alog
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Conditional logging to provide contextual logging and ability to reconfigure
+  log message visibility during runtime
+test_files: []