ruby_smart-simple_logger 1.2.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f93f509aad065f314393b0b7f630694091fb06c967bc20ad1fe4e0b7683f843b
-  data.tar.gz: 9d5a325fac9bc01ad330cec1c1c31a9bc3f5602e1934893b04ab5f3baed22ac0
+  metadata.gz: 499ca8f400db9b2df6a9e3017fece6c7e2b94c32c72feb2d04c3a7013a946c4e
+  data.tar.gz: f684b602ec79afe45e2cebf5b158eacfab127cd1af7e9aee994a7ec824b0f802
 SHA512:
-  metadata.gz: 5b4b91d4c70cd0e373af89191b9147739a55443e851ffdc8751e3853d833e04f59cd9aa6d125a60c752e924686a190d8bd492560860e91d18749af48adc210d4
-  data.tar.gz: 5cb89dd0a2cf9b77f3ce2cbc4bcf7c9f8ee218fb9030a16c9bba0259ac5ca16bf82fcdffef2602533b567b2591d94f672662a46e3562b8a1fdee398980137718
+  metadata.gz: aa7911b6005d56ffc56585674bd90ff47f07bb0e632b08447c52e4f4222996ca52d783ab44fcae057b034b2920f0b7e0e5cb044be66a7c79be4dcb1ff18abcc6
+  data.tar.gz: 9f1ae4aed0ca7965cbe57d24223a7283915cf7ab876a467945da7269ea6bb66f292704f7e48400a260542eb5b35dc0898b277c5ad338443e459a529e9f5bebf5

data/.github/workflows/ruby.yml

@@ -18,21 +18,17 @@ permissions:
 
 jobs:
   test:
-
-    runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
-        ruby-version: ['3.1', '3.0', '2.7', '2.6']
-
+        os: [ubuntu-latest]
+        # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
+        ruby: ['3.2', '3.1', '3.0', '2.7', '2.6']
+    runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@0a29871fe2b0200a17a4497bae54fe5df0d973aa # v1.115.3
-      with:
-        ruby-version: ${{ matrix.ruby-version }}
-        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - name: Run tests
-      run: bundle exec rake
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - run: bundle exec rake

data/README.md

@@ -9,7 +9,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/ruby-smart/simple_logger/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/ruby-smart/simple_logger?branch=main)
 [![Tests](https://github.com/ruby-smart/simple_logger/actions/workflows/ruby.yml/badge.svg)](https://github.com/ruby-smart/simple_logger/actions/workflows/ruby.yml)
 
-A simple, multifunctional logging library for Ruby.
+A simple, multifunctional logging library for Ruby (and Rails).
 It features a fast, customizable logging with multi-device support (e.g. log to STDOUT AND file).
 Special (PRE-defined) scenes can be used for interactive CLI and better logging visibility.
 
@@ -36,7 +36,7 @@ Or install it yourself as:
 ## Enhancements
 * PRE-defined scenes to fastly create a simple, structured CLI output. _(see [Scenes](#scenes))_
 * Better log-visibility with masked output through scenes
-* ```awesome_print``` gem compatibility for a prettified object debug
+* `awesome_print` gem compatibility for a prettified object debug
 * Multi-device support (write to logfile & to STDOUT & to ... & to ...)
 * 'klass_logger' instances for easier access _(see [klass_logger](#klass_logger_Usage))_
 
@@ -198,10 +198,11 @@ While you can just build a new logger _(or use the klass_logger)_ without any ar
 
 ### nil Builtin
 
-A ```nil``` builtin will auto-detect the best logging solution for you.
-For CLI or windowed programs it'll just send the logs to ```STDOUT```.
-For rails-applications it'll send to the current ```Rails.logger``` instance.
-Otherwise it'll store logs temporary in memory _(accessible through the #logs method)_
+A `nil` builtin will auto-detect the best logging solution for you:
+* For CLI or windowed programs it'll just send the logs to `STDOUT`.
+* For Debugging _(e.g. IDE-related debugging gems)_ it'll send the logs to the `Debugger`.
+* For rails-applications it'll send to the current `Rails.logger` instance.
+* Otherwise it'll store logs temporary in memory _(accessible through the #logs method)_
 
 **Example:**
 ```ruby
@@ -211,7 +212,7 @@ logger.debug "some debug"
 
 ### stdout / stderr Builtin
 
-A ```:stdout / :stderr``` builtin will send to ```STDOUT / STDERR``` and uses a colored output by default.
+A `:stdout / :stderr` builtin will send to `STDOUT / STDERR` and uses a colored output by default.
 
 **Example:**
 ```ruby
@@ -224,9 +225,34 @@ logger = ::SimpleLogger.new(:stdout)
 logger.debug "some debug"
 ```
 
+### debugger Builtin
+
+A `:debugger` builtin will send to the `Debugger` (e.g. your IDE's debugging gem)
+
+**Example:**
+```ruby
+logger = ::SimpleLogger.new(:debugger)
+
+# > will be shown within your debugging gem
+logger.debug "some debug"
+```
+
+
+### null Builtin
+
+A `:null` builtin will silently swallow all logging data (so it will not be send).
+
+**Example:**
+```ruby
+logger = ::SimpleLogger.new(:null)
+
+# >
+logger.debug "some debug"
+```
+
 ### rails Builtin
 
-A ```:rails``` builtin will always send to the ```Rails.logger``` instance.
+A `:rails` builtin will always send to the `Rails.logger` instance.
 
 **Example:**
 ```ruby
@@ -238,9 +264,9 @@ logger.debug "some debug"
 
 ### proc Builtin
 
-A ```:proc``` builtin will call the provided proc _(through ```options[:proc]```)_ everytime a log will be written.
+A `:proc` builtin will call the provided proc _(through `options[:proc]```)_ everytime a log will be written.
 
-The data will be provided as array _( ```[severity, time, progname, data]``` )_.
+The data will be provided as array _( `[severity, time, progname, data]` )_.
 
 **Example:**
 ```ruby
@@ -255,7 +281,7 @@ logger.debug "some debug"
 
 ### memory Builtin
 
-A ```:memory``` builtin will always store the logged data within an _instance variable_ and can be accessed through the ```#logs``` or ```#logs_to_h``` methods.
+A `:memory` builtin will always store the logged data within an _instance variable_ and can be accessed through the `#logs` or `#logs_to_h` methods.
 
 **Example:**
 ```ruby
@@ -276,7 +302,7 @@ logger.logs
 
 ### String Builtin
 
-Providing a ```String``` will always create and write to a new logfile.
+Providing a `String` will always create and write to a new logfile.
 
 **Example:**
 ```ruby
@@ -313,7 +339,7 @@ noformat_logger.debug "some debug without color and mask - uses the default form
 
 ### Module Builtin
 
-Providing a ```module``` will also create and write to a new logfile.
+Providing a `module` will also create and write to a new logfile.
 The path depends on the provided module name.
 
 **Example:**
@@ -331,13 +357,13 @@ logger.debug "some debug"
 
 ### other Builtin
 
-Providing any other Object must respond to ```#write```.
+Providing any other Object must respond to `#write```.
 
 -----
 
 ## Formats
 
-The default formatter _(if no other was provided through ```opts[:formatter```)_ will provide the following PRE-defined formats:
+The default formatter _(if no other was provided through `opts[:formatter```)_ will provide the following PRE-defined formats:
 _Also prints a colored output by default._
 
 ### default Format
@@ -447,7 +473,7 @@ logger = ::SimpleLogger.new(:stdout, payload: false)
 ### format
 
 Provide a other format.
-Possible values: ```:default, :passthrough, :plain, :memory, :datalog```
+Possible values: `:default, :passthrough, :plain, :memory, :datalog```
 ```ruby
 logger = ::SimpleLogger.new(format: :default)
 logger = ::SimpleLogger.new(:memory, format: :passthrough)
@@ -465,7 +491,7 @@ logger.debug "debug 2"
 
 ### proc _(:proc-builtin ONLY)_
 
-Provide a callback for the ```:proc``` builtin.
+Provide a callback for the `:proc` builtin.
 ```ruby
 logger = ::SimpleLogger.new(:proc, proc: lambda{|data| ... })
 ```
@@ -528,7 +554,7 @@ logger.debug({a: {custom: 'object'}})
 
 ### inspector
 
-Provide a other ```inspector``` method for the data-debug.
+Provide a other `inspector` method for the data-debug.
 
 ```ruby
 logger = ::SimpleLogger.new(inspector: :to_s)
@@ -541,13 +567,13 @@ logger.debug({ a: 1, b: 2 })
 
 ## _defaults_
 
-Device default options are still available: ```shift_age, shift_size, progname, datetime_format, shift_period_suffix, binmode```
+Device default options are still available: `shift_age, shift_size, progname, datetime_format, shift_period_suffix, binmode```
 
 -----
 
 ## Scenes
 
-The following PRE-defined scenes are available. _(You can define your own scenes by using the class method ```.scene```)_
+The following PRE-defined scenes are available. _(You can define your own scenes by using the class method `.scene```)_
 
 ### debug(data, subject = 'Debug')
 ```ruby
@@ -560,7 +586,7 @@ The following PRE-defined scenes are available. _(You can define your own scenes
 # > ==========================================================================================================
 ```
 
-### info, warn, error, fatal, success (data, subject = 'name')
+### info, warn, error, fatal, unknown, success (data, subject = 'name')
 ```ruby
 # info method (BASE)
 # severity: methods name
@@ -748,19 +774,19 @@ l.processed("Process Alpha", timer: true) do
 end
 
 
-# ╔ START :: Process Alpha
+# ╔ START ❯ Process Alpha
 # ╟ find files
 # ╟ found 34 files
-# ║ ┌ START :: extracting ...
+# ║ ┌ START ❯ extracting ...
 # ║ ├ 10% done
 # ║ ├ 20% done
 # ║ ├ 100% done
-# ║ └ END [SUCCESS] (duration: 0.000267545)
-# ║ ┌ START :: transforming ...
+# ║ └   END ❯ extracting ... [SUCCESS] (0.000244804)
+# ║ ┌ START ❯ transforming ...
 # ║ ├ bad memory
 # ║ ├ rolling back
-# ║ └ END [FAILED]
-# ╚ END [Process Alpha] (duration: 0.001040807)
+# ║ └   END ❯ transforming ... [FAIL]
+# ╚   END ❯ Process Alpha (0.001036969)
 ```
 
 ### _other useful methods_
@@ -768,6 +794,7 @@ end
 - line
 - print
 - nl
+- model _(rails only)_
 
 -----
 
@@ -784,7 +811,7 @@ This project is intended to be a safe, welcoming space for collaboration, and co
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-A copy of the [LICENSE](docs/LICENSE.txt) can be found @ the docs.
+A copy of the [LICENSE](LICENSE.txt) can be found @ the docs.
 
 ## Code of Conduct
 

data/docs/CHANGELOG.md

@@ -1,5 +1,29 @@
 # RubySmart::SimpleLogger - CHANGELOG
 
+## [1.4.0] - 2024-07-31
+* **[add]** 'null'-device / builtin
+* **[add]** 'debugger'-builtin to send logs to the debugging gem
+* **[add]** new logging method `model` _(for rails applications only)_
+* **[ref]** `nil`-builtin to detect `Debugger` after checking for stdout
+* **[ref]** `mask`-length to 120 _(was 100 by default)_
+* **[ref]** `ruby_smart-support`-gem dependency to 1.5
+* **[fix]** exception _(to build a new device)_ if a Logger was provided
+* **[fix]** mask-reference manipulation on inherited classes
+
+## [1.3.0] - 2023-08-15
+* **[add]** exception message within `processed`-scene
+* **[add]** new logging option `tag`, to prefix a log-string with a [TAG]
+* **[add]** logger options `processed: false` & `tagged: false` to prevent processing or tagging
+* **[add]** `_tagged`-helper method
+* **[add]** `__scene_subject_with_opts`-helper method to grep subject&opts from args (used for default severities)
+* **[add]** additional box_chars for 'tagged' & 'feed' extensions - used @ `processed`-scene
+* **[add]** `unknown`-scene
+* **[ref]** `processed`-scene with better logging chars & homogenous syntax for humanized reading
+* **[fix]** missing '_declr' for memory formatting (only on Strings)
+* **[fix]** missing 'clr:false' option for memory devices
+* **[fix]** exception while in `processed`-scene not logging the END-line
+* **[fix]** re-using timer-methods with the same key, did not restart the 'total' measurement
+
 ## [1.2.2] - 2023-03-15
 * **[ref]** simplify device-generation for builtins 
 * **[fix]** `ActionView::Helpers::DateHelper` require, which breaks rails loading process in some cases

data/lib/ruby_smart/simple_logger/devices/memory_device.rb

@@ -4,7 +4,6 @@ module RubySmart
   module SimpleLogger
     module Devices
       class MemoryDevice
-
         attr_reader :logs
         attr_reader :status
 

data/lib/ruby_smart/simple_logger/devices/null_device.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubySmart
+  module SimpleLogger
+    module Devices
+      class NullDevice
+        attr_reader :status
+
+        def initialize
+          @status = true
+        end
+
+        def write(*)
+          nil
+        end
+
+        alias_method :<<, :write
+
+        # disables writing
+        def close
+          @status = false
+        end
+
+        # enables writing
+        def reopen
+          @status = true
+        end
+
+        # clears all logs
+        def clear!
+          nil
+        end
+
+        # returns logs
+        # @return [Array] logs
+        def logs
+          []
+        end
+      end
+    end
+  end
+end

data/lib/ruby_smart/simple_logger/extensions/helper.rb

@@ -14,8 +14,7 @@ module RubySmart
         # set / overwrite default opts
         # @param [Hash] opts
         def _opts_init!(opts)
-          ##################################################################################
-          # level
+          # -- level ---------------------------------------------------------------------------------------------------
 
           # initialize a default rails-dependent output
           if ::ThreadInfo.rails?
@@ -25,8 +24,7 @@ module RubySmart
           # clean & rewrite level (possible symbols) to real level
           opts[:level] = _level(opts[:level] || :debug)
 
-          ##################################################################################
-          # mask
+          # -- mask ----------------------------------------------------------------------------------------------------
 
           # set mask from options
           self.mask(opts[:mask]) if opts[:mask]
@@ -39,13 +37,18 @@ module RubySmart
             self.mask(length: ::ThreadInfo.winsize[1])
           end
 
-          ##################################################################################
-          # instance related
+          # -- instance related ----------------------------------------------------------------------------------------
 
           # ignore payload and send data directly to the logdev
-          @ignore_payload = true if @ignore_payload.nil? && opts[:payload] == false
+          @ignore_payload   = true if @ignore_payload.nil? && opts[:payload] == false
 
-          # set the inspector to be used for data inspection.
+          # ignore processed logging and send data without 'leveling' & PCD-char to the logdev
+          @ignore_processed = true if @ignore_processed.nil? && opts[:processed] == false
+
+          # ignore tagged logging and send data without 'tags' to the logdev
+          @ignore_tagged    = true if @ignore_tagged.nil? && opts[:tagged] == false
+
+          # set custom inspector (used for data inspection)
           # 'disable' inspector, if false was provided - which simply results in +#to_s+
           @inspector = (opts[:inspect] == false) ? :to_s : opts[:inspector]
 
@@ -113,7 +116,7 @@ module RubySmart
           opts[:format] ||= :plain
 
           # fix nl - which depends on other opts
-          opts[:nl] = _nl(opts)
+          opts[:nl]  = _nl(opts)
 
           # fix clr
           opts[:clr] = true if opts[:clr].nil?
@@ -129,11 +132,19 @@ module RubySmart
           when nil # builtin is nil - resolve optimal device for current environment
             if ::ThreadInfo.stdout?
               _resolve_device(:stdout, opts)
+            elsif ::ThreadInfo.debugger?
+              _resolve_device(:debugger, opts)
             elsif ::ThreadInfo.rails? && ::Rails.logger
               _resolve_device(:rails, opts)
             else
               _resolve_device(:memory, opts)
             end
+          when :null
+            ::RubySmart::SimpleLogger::Devices::NullDevice.new
+          when :debugger
+            raise "Unable to build SimpleLogger with 'debugger' builtin for not initialized Debugger!" unless ThreadInfo.debugger?
+
+            _resolve_device(::Debugger.logger, opts)
           when :stdout
             STDOUT
           when :stderr
@@ -145,27 +156,31 @@ module RubySmart
             if ThreadInfo.console? && ::Rails.logger.instance_variable_get(:@logdev).dev != STDOUT
               ::RubySmart::SimpleLogger::Devices::MultiDevice
                 .register(_resolve_device(:stdout, opts))
-                .register(::Rails.logger.instance_variable_get(:@logdev).dev)
+                .register(_resolve_device(::Rails.logger, opts))
             else
-              ::Rails.logger.instance_variable_get(:@logdev).dev
+              _resolve_device(::Rails.logger, opts)
             end
           when :proc
             # force overwrite opts
             @ignore_payload = true
-            opts[:nl]      = false
-            opts[:format]  = :passthrough
+            opts[:nl]       = false
+            opts[:format]   = :passthrough
 
             ::RubySmart::SimpleLogger::Devices::ProcDevice.new(opts.delete(:proc))
           when :memory
             # force overwrite opts
             @ignore_payload = true
-            opts[:format]  = :memory
+            opts[:format]   = :memory
+            # no color logging for memory devices
+            opts[:clr] = false
 
             ::RubySmart::SimpleLogger::Devices::MemoryDevice.new
           when Module, String
             # force overwrite opts
             opts[:clr] = false
             _logdev(opts, builtin)
+          when ::Logger
+            builtin.instance_variable_get(:@logdev).dev
           else
             _logdev(opts, builtin)
           end
@@ -275,6 +290,18 @@ module RubySmart
           end
         end
 
+        # 'tags' a provided string
+        # returns the string if no tag was provided or general tags are disabled
+        # @param [String] str
+        # @param [nil|Symbol|String] tag
+        # @return [String]
+        def _tagged(str, tag = nil)
+          # check for active tag
+          return str if tag.nil? || ignore_tagged?
+
+          "#{"[#{tag.to_s.upcase.bg_cyan}]"} #{str}"
+        end
+
         # colorizes a provided string
         # returns the string if no color was provided or invalid
         #
@@ -343,6 +370,19 @@ module RubySmart
             res_or_clr.to_sym
           end
         end
+
+        # resolves subject & opts from provided args.
+        # returns provided default subject, if not in args.
+        # @param [Object] args
+        # @param [String] subject
+        # @return [Array]
+        def _scene_subject_with_opts(args, subject = '')
+          if args[0].is_a?(Hash)
+            [subject, args[0]]
+          else
+            [args[0] || subject, args[1] || {}]
+          end
+        end
       end
     end
   end

data/lib/ruby_smart/simple_logger/extensions/mask.rb

@@ -13,17 +13,25 @@ module RubySmart
             # @option [String] :char - the character to be used as mask
             # @option [Integer] :length - the mask length (amount of mask chars be line)
             # @option [Symbol] :clr - the color to be used by printing the mask
-            self.mask = { char: '=', length: 100, clr: :blue }
+            self.mask = { char: '=', length: 120, clr: :blue }
           end
         end
 
         module ClassMethods
           def mask
-            class_variable_get('@@mask')
+            @mask
           end
 
           def mask=(mask)
-            class_variable_set('@@mask', mask)
+            @mask = mask
+          end
+
+          # prevents to overwrite parent class through inheriting subclasses
+          def inherited(subclass)
+            super
+
+            # dup existing values
+            subclass.mask = self.mask.dup
           end
         end
 

data/lib/ruby_smart/simple_logger/extensions/processed.rb

@@ -12,10 +12,15 @@ module RubySmart
           base.class_eval do
             # set default box chars
             self.box_chars = {
-              __default__:   %w(╟ ├),
-              __processed__: %w(║ │),
+              # control characters by provided +:pcd+
+              default:       %w(╟ ├),
               start:         %w(╔ ┌),
-              end:           %w(╚ └)
+              end:           %w(╚ └),
+
+              # additional characters, added ad specific position
+              __processed__: %w(║ │),
+              __feed__:      %w(═ ─),
+              __tagged__:    %w(┄ ┄),
             }.freeze
           end
         end
@@ -33,18 +38,20 @@ module RubySmart
         module InstanceMethods
           # returns the current processed level.
           # by providing a handle it will either increase or decrease the current level.
-          # @param [nil, Symbol] handle - optional handle to increase or decrease the current lvl (+:up+ / +:down+)
+          # @param [Symbol|Integer] handle - optional handle to increase or decrease the current lvl (+:up+ / +:down+)
           # @return [Integer]
           def processed_lvl(handle = nil)
             @processed_lvl ||= -1
 
             case handle
+            when :reset
+              @processed_lvl = -1
             when :up
               @processed_lvl += 1
             when :down
               @processed_lvl -= 1 if @processed_lvl >= 0
             else
-              # nothing here ...
+              @processed_lvl = handle if handle.is_a?(Integer)
             end
 
             @processed_lvl
@@ -53,25 +60,54 @@ module RubySmart
           # returns true if the processed state is active.
           # @return [Boolean]
           def processed?
-            processed_lvl >= 0
+            processed_lvl >= 0 && !@ignore_processed
           end
 
           private
 
           # transforms the provided data into a 'processed' string and forces the data to be transformed to string.
           # simple returns the provided data, if currently not processed.
-          # @param [Object] data
+          # @param [String] data
           # @param [Hash] opts
-          # @return [Object,String]
+          # @return [String]
           def _pcd(data, opts)
             # check for active pcd (processed)
             return data if opts[:pcd] == false || !processed?
 
-            # resolve lvl, once
+            # resolve the current level - either directly through the options or the +processed_lvl+.
             lvl = opts[:lvl] || processed_lvl
 
-            # create final string
-            lvl.times.map { |i| "#{_pcd_box_char(:__processed__, i)} " }.join + _pcd_box_char(opts[:pcd], lvl) + " #{data}"
+            # prepares the out-string array
+            strs = []
+
+            # add level-charters with indent
+            lvl.times.each { |i|
+              # ║ │
+              strs << _pcd_box_char(:__processed__, i) + ' '
+            }
+
+            # add pcd-related control character
+            strs << _pcd_box_char(opts[:pcd], lvl)
+
+            # add pcd-operation string
+            if opts[:pcd].is_a?(Symbol)
+              # ╔ START ❯
+              # └   END ❯
+              strs << " #{opts[:pcd].to_s.upcase.rjust(5)} \u276F"
+            end
+
+            # check for tagged
+            # ┄
+            if opts[:tag]
+              strs << _pcd_box_char(:__tagged__, lvl)
+            else
+              strs << ' '
+            end
+
+            # add data
+            strs << data.to_s
+
+            strs.join
           end
 
           # returns the processed box character for provided key and position.
@@ -81,7 +117,7 @@ module RubySmart
           # @param [Integer] pos
           # @return [String]
           def _pcd_box_char(key, pos = 0)
-            chars = self.class.box_chars[key] || self.class.box_chars[:__default__]
+            chars = self.class.box_chars[key] || self.class.box_chars[:default]
             chars[pos] || chars[-1]
           end
         end

data/lib/ruby_smart/simple_logger/extensions/simple_log.rb

@@ -53,7 +53,7 @@ module RubySmart
               # prevent logging nil data
               return false if data.nil?
 
-              add level, _pcd(data, opts)
+              add level, _parse_data(data, opts)
               return true
             end
 
@@ -82,6 +82,14 @@ module RubySmart
             !!@ignore_payload
           end
 
+          # returns true if no tags should be created - instead the data will be send directly to the logdev
+          # forces the *simple_log* method to prevent building tags from opts
+          #
+          # @return [Boolean]
+          def ignore_tagged?
+            !!@ignore_tagged
+          end
+
           # resolve an inspector method for data inspection
           # @return [Symbol, nil]
           def inspector
@@ -107,7 +115,7 @@ module RubySmart
               str = ''
               if payload == self.class::PAYLOAD_DATA_KEY
                 # checks, if we should inspect the data
-                str << _parse_data(data, (opts[:inspect] ? (opts[:inspector] || self.inspector) : nil))
+                str << _parse_inspect_data(data, opts)
               else
                 str << _parse_payload(payload, opts)
               end
@@ -121,13 +129,33 @@ module RubySmart
             true
           end
 
-          # just parses the data and calls an inspection method, if provided
+          # parses the provided data to string.
+          # - calls an inspection method, if provided
+          # - tags the string, if provided
+          # - adds processed prefix-chars, if provided
           #
           # @param [Object] data
-          # @param [Symbol, nil] inspector - the inspection method to be called (e.g. :ai, :inspect, :to_s) - if not provided it tries to auto-resolve
+          # @param [Hash] opts
+          # @return [String] stringified data
+          def _parse_data(data, opts)
+            _pcd(
+              _tagged(
+                data.to_s,
+                opts[:tag]
+              ),
+              opts
+            )
+          end
+
+          # parses the provided data to string, but calls a possible inspect method.
+          # @param [Object] data
+          # @param [Hash] opts
           # @return [String] stringified data
-          def _parse_data(data, inspector = nil)
-            (inspector ? data.send(inspector) : data).to_s
+          def _parse_inspect_data(data, opts)
+            _parse_data(
+              data.send(opts[:inspect] ? (opts[:inspector] || self.inspector) : :to_s),
+              opts
+            )
           end
 
           # parses a single payload with provided options

data/lib/ruby_smart/simple_logger/extensions/timer.rb

@@ -5,21 +5,23 @@ module RubySmart
     module Extensions
       module Timer
         def timer(action, key = :default, opts = {})
+          return if key.nil?
+
           @timers      ||= {}
           @timers[key] ||= {
             start:   nil,
             stop:    nil,
-            measure: 0
+            total: 0
           }
 
           case action
-          when :restart
+          when :start, :restart
             @timers[key][:start]   = Time.now
             @timers[key][:stop]    = nil
-            @timers[key][:measure] = 0
+            @timers[key][:total] = 0
 
             true
-          when :start, :continue
+          when :continue
             @timers[key][:start] = Time.now
             @timers[key][:stop]  = nil
 
@@ -27,13 +29,13 @@ module RubySmart
           when :stop
             return false if !@timers[key][:start] || @timers[key][:stop]
             @timers[key][:stop]    = Time.now
-            @timers[key][:measure] += @timers[key][:stop] - @timers[key][:start]
+            @timers[key][:total] += @timers[key][:stop] - @timers[key][:start]
 
             true
           when :pause
             return false if !@timers[key][:start] || @timers[key][:stop]
 
-            @timers[key][:measure] += Time.now - @timers[key][:start]
+            @timers[key][:total] += Time.now - @timers[key][:start]
             @timers[key][:start]   = nil
             @timers[key][:stop]    = nil
 
@@ -50,7 +52,7 @@ module RubySmart
               current
             end
           when :current
-            current = @timers[key][:measure]
+            current = @timers[key][:total]
             current += Time.now - @timers[key][:start] if @timers[key][:start] && @timers[key][:stop].nil?
             current
           else

data/lib/ruby_smart/simple_logger/formatter.rb

@@ -33,7 +33,7 @@ module RubySmart
         plain: -> (_severity, _time, _progname, data) { _nl _declr(data.to_s) },
 
         # specialized array for memory-logging
-        memory: -> (severity, time, _progname, data) { [severity.downcase.to_sym, time, data] },
+        memory: -> (severity, time, _progname, data) { [severity.downcase.to_sym, time, _declr(data)] },
 
         # specialized string as datalog with every provided data in additional brackets -> [data] [data] [data]
         datalog: -> (severity, time, _progname, data) {
@@ -202,7 +202,7 @@ module RubySmart
       # @param [String] str
       # @return [String]
       def _declr(str)
-        if opts[:clr]
+        if opts[:clr] || !str.is_a?(String)
           str
         else
           str.gsub(/\e\[[\d;]+m/, '')

data/lib/ruby_smart/simple_logger/gem_version.rb

@@ -9,8 +9,8 @@ module RubySmart
 
     module VERSION
       MAJOR = 1
-      MINOR = 2
-      TINY  = 2
+      MINOR = 4
+      TINY  = 0
       PRE   = nil
 
       STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/ruby_smart/simple_logger/logger.rb

@@ -11,6 +11,7 @@ require_relative 'extensions/timer'
 
 require_relative 'devices/memory_device'
 require_relative 'devices/multi_device'
+require_relative 'devices/null_device'
 require_relative 'devices/proc_device'
 
 require_relative 'formatter'

data/lib/ruby_smart/simple_logger/scenes.rb

@@ -11,7 +11,8 @@ module RubySmart
         # > ================================================= [Debug] ================================================
         # > "DEBUGGED DATA" <- analyzed by awesome_print#ai method
         # > ==========================================================================================================
-        base.scene :debug, { level: :debug, inspect: true, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Debug', opts = {}|
+        base.scene :debug, { level: :debug, inspect: true, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Debug')
           self.log data, _scene_opt(:debug, { subject: subject }, opts)
         end
 
@@ -22,7 +23,8 @@ module RubySmart
         # > ================================================= [Info] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :info, { level: :info, mask: { clr: :cyan }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Info', opts = {}|
+        base.scene :info, { level: :info, mask: { clr: :cyan }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Info')
           self.log data, _scene_opt(:info, { subject: subject }, opts)
         end
 
@@ -33,7 +35,8 @@ module RubySmart
         # > ================================================= [Warn] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :warn, { level: :warn, mask: { clr: :yellow }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Warn', opts = {}|
+        base.scene :warn, { level: :warn, mask: { clr: :yellow }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Warn')
           self.log data, _scene_opt(:warn, { subject: subject }, opts)
         end
 
@@ -44,7 +47,8 @@ module RubySmart
         # > ================================================ [Error] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :error, { level: :error, mask: { clr: :red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Error', opts = {}|
+        base.scene :error, { level: :error, mask: { clr: :red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Error')
           self.log data, _scene_opt(:error, { subject: subject }, opts)
         end
 
@@ -55,10 +59,23 @@ module RubySmart
         # > ================================================ [Fatal] =================================================
         # > DATA
         # > ==========================================================================================================
-        base.scene :fatal, { level: :fatal, mask: { clr: :bg_red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Fatal', opts = {}|
+        base.scene :fatal, { level: :fatal, mask: { clr: :bg_red }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Fatal')
           self.log data, _scene_opt(:fatal, { subject: subject }, opts)
         end
 
+        # unknown method (BASE)
+        # log level @ unknown
+        # prints: enclosed data
+        #
+        # > =============================================== [Unknown] ================================================
+        # > DATA
+        # > ==========================================================================================================
+        base.scene :unknown, { level: :unknown, mask: { clr: :gray }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Unknown')
+          self.log data, _scene_opt(:unknown, { subject: subject }, opts)
+        end
+
         # success method
         # log level @ success (sub-level of info)
         # prints: enclosed data
@@ -66,7 +83,8 @@ module RubySmart
         # > ================================================ [Success] ================================================
         # > DATA
         # > ===========================================================================================================
-        base.scene :success, { level: :success, mask: { clr: :green }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, subject = 'Success', opts = {}|
+        base.scene :success, { level: :success, mask: { clr: :green }, payload: [[:mask, ' [%{subject}] '], :__data__, :mask] } do |data, *args|
+          subject, opts = _scene_subject_with_opts(args, 'Success')
           self.log data, _scene_opt(:success, { subject: subject }, opts)
         end
 
@@ -287,36 +305,80 @@ module RubySmart
         # log level @ debug
         # prints: a processed output with unicode box-chars (e.g. ║ )
         #
-        # ╔ START :: job
+        # ╔ START ❯ job
         # ╟ doing some cool log
         # ╟ doing some extra log
-        # ╚ END [job] (duration: 4.34223)
+        # ╚ END   ❯ job [SUCCESS] (duration: 4.34223)
         base.scene :processed, { level: :debug } do |name, opts = {}, &block|
-          # resolve the current process-level
+          # increase level
           lvl = processed_lvl(:up)
 
-          # start the timer, if it should - directly sets a timer key to be reused in the +:clear+ method
-          if (timer_key = (opts[:timer] ? "processed_#{lvl}" : nil))
-            self.timer(:start, timer_key) if timer_key
+          # resolve a new time-key.
+          # The key depends on the current level - this should be possible, since processes on the same level should not be possible
+          timer_key = if opts[:timer]
+                        "processed_#{lvl}"
+                      else
+                        nil
+                      end
+
+          begin
+            # starts new time (if key was created)
+            self.timer(:start, timer_key)
+
+            # send START name as +data+ - the full log line is created through the +_pcd+ method.
+            self.log(name, _scene_opt(:processed, opts, { pcd: :start }))
+
+            # run the provided block and resolve result
+            result_str = case block.call
+                         when true
+                           '[SUCCESS]'.bg_green + ' '
+                         when false
+                           '[FAIL]'.bg_red + ' '
+                         else
+                           ''
+                         end
+          rescue => e
+            self.fatal("#{e.message} @ #{e.backtrace_locations&.first}") unless opts[:silent]
+            # reraise exception
+            raise
+          ensure
+            result_str ||= ''
+
+            # send END name with result & possible time as +data+ - the full log line is created through the +_pcd+ method.
+            self.log("#{name} #{result_str}#{(timer_key ? "(#{self.timer(:clear, timer_key, humanized: true)})" : '')}", _scene_opt(:processed, opts, { pcd: :end }))
+
+            # reduce level
+            processed_lvl(:down)
           end
 
-          self.log("START :: #{name}", _scene_opt(:processed, opts, { pcd: :start }))
-
-          end_str = case block.call
-                    when true
-                      'SUCCESS'
-                    when false
-                      'FAILED'
-                    else
-                      name
-                    end
-
-          self.log("END [#{end_str}] #{(timer_key ? "(duration: #{self.timer(:clear, timer_key, humanized: true)})" : '')}", _scene_opt(:processed, opts, { pcd: :end }))
-
-          processed_lvl(:down)
-
           true
         end
+
+        # model method
+        # log level @ error/success/info
+        # prints: ActiveRecord::Base related data, depending on the models "save" state (also shows possible errors)
+        base.scene :model do |model, opts = {}|
+          # build model-logging string
+          mdl_string = "#{model.id.present? ? "##{model.id} - " : ''}#{model.to_s[0..49]}"
+
+          # resolve model's status
+          status = ((model.persisted? && model.errors.empty?) ? (model.previous_changes.blank? ? :skipped : :success) : :error)
+
+          # switch between status
+          case status
+          when :success
+            # show verbose logging for updated records
+            if opts[:verbose] != false && !model.previously_new_record?
+              log(:success, "#{mdl_string} (#{model.previous_changes.inspect})", tag: "#{model.class.name.upcase}|UPDATED")
+            else
+              log(:success, mdl_string, tag: "#{model.class.name.upcase}|#{(model.previously_new_record? ? 'CREATED' : 'UPDATED')}")
+            end
+          when :error
+            log(:error, "#{mdl_string} (#{model.errors.full_messages.join(', ').presence || '-'})", tag: "#{model.class.name.upcase}|ERROR")
+          else
+            log(:info, mdl_string, tag: "#{model.class.name.upcase}|#{status}")
+          end
+        end
       end
     end
   end

data/ruby_smart-simple_logger.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors     = ['Tobias Gonsior']
   spec.email       = ['info@ruby-smart.org']
 
-  spec.summary               = "A simple, multifunctional logging library for Ruby."
+  spec.summary               = "A simple, multifunctional logging library for Ruby (and Rails)."
   spec.description = <<~DESC
     RubySmart::SimpleLogger is a fast, customizable logging library with multi-device support, 
     special (PRE-defined) scenes for better logging visibility.
@@ -33,11 +33,13 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'ruby_smart-support', '~> 1.2'
+  spec.add_dependency 'ruby_smart-support', '~> 1.5'
 
   spec.add_development_dependency 'awesome_print', '~> 1.9'
   spec.add_development_dependency 'coveralls_reborn', '~> 0.25'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'yard-activesupport-concern', '~> 0.0.1'
+  spec.add_development_dependency 'yard-relative_markdown_links', '>= 0.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_smart-simple_logger
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Tobias Gonsior
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-15 00:00:00.000000000 Z
+date: 2024-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_smart-support
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: yard-activesupport-concern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: yard-relative_markdown_links
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: "RubySmart::SimpleLogger is a fast, customizable logging library with
   multi-device support, \nspecial (PRE-defined) scenes for better logging visibility.\n"
 email:
@@ -107,19 +135,20 @@ files:
 - ".rspec"
 - ".yardopts"
 - Gemfile
+- LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - docs/CHANGELOG.md
 - docs/CODE_OF_CONDUCT.md
-- docs/LICENSE.txt
 - lib/ruby_smart-debugger.rb
 - lib/ruby_smart-simple_logger.rb
 - lib/ruby_smart/simple_logger.rb
 - lib/ruby_smart/simple_logger/core_ext/ruby/string.rb
 - lib/ruby_smart/simple_logger/devices/memory_device.rb
 - lib/ruby_smart/simple_logger/devices/multi_device.rb
+- lib/ruby_smart/simple_logger/devices/null_device.rb
 - lib/ruby_smart/simple_logger/devices/proc_device.rb
 - lib/ruby_smart/simple_logger/extensions/helper.rb
 - lib/ruby_smart/simple_logger/extensions/logs.rb
@@ -146,7 +175,7 @@ metadata:
   documentation_uri: https://rubydoc.info/gems/ruby_smart-simple_logger
   changelog_uri: https://github.com/ruby-smart/simple_logger/blob/main/docs/CHANGELOG.md
   allowed_push_host: https://rubygems.org
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -161,8 +190,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.5.14
+signing_key: 
 specification_version: 4
-summary: A simple, multifunctional logging library for Ruby.
+summary: A simple, multifunctional logging library for Ruby (and Rails).
 test_files: []