teLogger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7919230720df3483a2140226524bde04ad0da1981a6dc612ddf0c1b9c8adfe95
+  data.tar.gz: db1fa0e3029d48c66bfc56c41cd93a56b8d3c20ab69c2dac09fb870e1114b031
+SHA512:
+  metadata.gz: 6bccfe28dd331dc3a5e594c7d36c8ddf2ba3449b9702dab305cf6694fa0be159208e73950f0d963728fb5fd1de847d528e96964ba88ce286c7c64f487608820d
+  data.tar.gz: bac3ec9366528a8a6d1dc12056bb6c0ffc0e6432cc4b9d1b2e800c1671062a9a6293e07b52e7728a6fc280801b7a0d688638e5108b0e964eaf522c5f694c5884

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in teLogger.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,71 @@
+PATH
+  remote: .
+  specs:
+    teLogger (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base58 (0.2.3)
+    devops_assist (0.1.4)
+      git_cli
+      git_cli_prompt
+      gvcs
+      tlogger
+      toolrack
+      tty-prompt
+    diff-lcs (1.5.0)
+    git_cli (0.9.0)
+      gvcs
+      ptools (~> 1.4.0)
+      tlogger
+      toolrack
+    git_cli_prompt (0.2.2)
+      tlogger
+      toolrack
+      tty-prompt
+    gvcs (0.1.0)
+    pastel (0.8.0)
+      tty-color (~> 0.5)
+    ptools (1.4.2)
+    rake (13.0.6)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    tlogger (0.26.3)
+    toolrack (0.18.5)
+      base58
+      tlogger
+    tty-color (0.6.0)
+    tty-cursor (0.7.1)
+    tty-prompt (0.23.1)
+      pastel (~> 0.8)
+      tty-reader (~> 0.8)
+    tty-reader (0.9.0)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      wisper (~> 2.0)
+    tty-screen (0.8.1)
+    wisper (2.0.1)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  devops_assist
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  teLogger!
+
+BUNDLED WITH
+   2.2.28

data/README.md

@@ -0,0 +1,122 @@
+# TeLogger
+
+TeLogger is the attempt to have some control in logging by the developer.
+
+We 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 developer can just disable all other log messages and only focus on the log messages around the suspected issue? That is the motivation of this library.
+
+TeLogger 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 TeLogger 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. write to STDOUT and log file at the same time)
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'teLogger'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install teLogger
+
+## Usage
+
+### Basic - Adding Context
+
+Since TeLogger is just wrapped around Ruby Logger, it is initiated like Logger:
+
+```ruby
+require 'teLogger'
+
+# Initiate without parameters shall print out the log to STDOUT
+log = TeLogger::Tlogger.new
+
+# Alternatively, this initiate logging with log file
+# The parameter is directly pass to Ruby Logger.new method
+log = TeLogger::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
+```
+
+Refers to spec/tLogger\_spec.rb for details usage
+
+
+### 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.
+
+
+### Possible Concern
+
+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.
+
+For current use cases 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.  
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+require 'devops_assist'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "teLogger"
+
+# 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/teLogger/logger_group.rb

@@ -0,0 +1,110 @@
+
+
+module TeLogger
+
+  # 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 attach_logger(key, logger)
+      @loggers[key] = logger
+    end
+
+    # Returns the logger that registered to the +key+
+    def get_log(key)
+      @loggers[key]
+    end
+
+    # Returns the registered logger
+    def registered_logger
+      @loggers.keys.freeze
+    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/teLogger/tlogger.rb

@@ -0,0 +1,411 @@
+
+require 'logger'
+require 'digest'
+
+module TeLogger
+  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
+
+      # allow caller application to create the logger instance instead of internal created
+      @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)
+        
+        # proxy the standard API call for logger
+        # Shall print out if the tag is active and vice versa
+        
+        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)
+        
+        # new API that allow caller to include the tag as first parameter and 
+        # all subsequent parameters will pass to underlying Logger object
+        
+        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)
+        
+        # new API that allow caller to include the tag as first parameter and 
+        # all subsequent parameters will pass to underlying Logger object
+        # however only print the message once for each instance
+        
+        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)  
+     
+        # new API that allow caller to include 
+        # the condition as first parameter
+        # tag as second parameter
+        # Rest of the parameters will be passed to underlying Logger object
+        
+        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)
+        
+        # rest of the method which not recognized, just passed to underlying Logger object
+       
+        @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
+
+    ## detect if the prompt should be to env or file
+    #def self.init(out = STDOUT)
+    #  if is_dev?
+    #    Tlogger.new(out) 
+    #  else
+    #    path = ENV["TLOGGER_FILE_PATH"]
+    #    if path.nil? or path.empty?
+    #      Tlogger.new(nil)
+    #    else
+    #      path = [path] if not path.is_a?(Array)
+    #      Tlogger.new(*path)
+    #    end
+    #  end
+    #end
+
+    #def self.set_dev_mode
+    #  ENV["TLOGGER_MODE"] = "dev"
+    #end
+
+    #def self.set_production_mode
+    #  ENV.delete("TLOGGER_MODE")
+    #end
+
+    #def self.is_dev?
+    #  ENV.keys.include?("TLOGGER_MODE") and ENV["TLOGGER_MODE"].downcase == "dev"
+    #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/teLogger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TeLogger
+  VERSION = "0.1.0"
+end

data/lib/teLogger.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "teLogger/version"
+require_relative 'teLogger/tlogger'
+require_relative 'teLogger/logger_group'
+
+module TeLogger
+  class Error < StandardError; end
+  # Your code goes here...
+
+
+  # for classes including the TeLogger
+  module TeLogHelper
+
+    module ClassMethods
+      # methods called at class level by included class
+      def teLogger_tag(val)
+        @telTag = val 
+      end
+
+      def teLogger_output(*val)
+        @telOutput = val
+      end
+
+      def logTag
+        @telTag
+      end
+
+      def logOutput
+        if @telOutput.nil?
+          []
+        elsif not @telOutput.is_a?(Array)
+          [@telOutput]
+        else
+          @telOutput
+        end
+      end
+
+    end # ClassMethods
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.class_eval <<-END
+        extend TeLogger::TeLogHelper
+      END
+    end
+
+    private
+    def teLogger
+      if @teLogger.nil?
+        if self.class.respond_to?(:logOutput)
+          @teLogger = Tlogger.new(*self.class.logOutput)
+        else
+          @teLogger = Tlogger.new(*logOutput)
+        end
+
+        if self.respond_to?(:logTag)
+          @teLogger.tag = logTag
+        elsif self.class.respond_to?(:logTag)
+          @teLogger.tag = self.class.logTag
+        end
+      end
+
+      @teLogger
+    end
+
+  end
+
+
+end

data/teLogger.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "lib/teLogger/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "teLogger"
+  spec.version       = TeLogger::VERSION
+  spec.authors       = ["Ian"]
+  spec.email         = ["cameronian0@protonmail.com"]
+
+  spec.summary       = "Restructuring of Tlogger gem"
+  spec.description   = "Restructuring of Tlogger library to ensure interfacing layer covers all expected use cases. "
+  spec.homepage      = ""
+  spec.required_ruby_version = ">= 2.4.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.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."
+
+  # 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(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'devops_assist'
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: teLogger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: devops_assist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Restructuring of Tlogger library to ensure interfacing layer covers
+  all expected use cases. '
+email:
+- cameronian0@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/teLogger.rb
+- lib/teLogger/logger_group.rb
+- lib/teLogger/tlogger.rb
+- lib/teLogger/version.rb
+- teLogger.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key: 
+specification_version: 4
+summary: Restructuring of Tlogger gem
+test_files: []