ruby_smart-simple_logger 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4f5d3ae3592f31b6c012044205c37d859c9e809d58f8cce63c7b6b2ed634829
-  data.tar.gz: d50becd65a8386e2466ddebcbbbd6bf2ec92aad95f4c5ae76288974429d607bc
+  metadata.gz: 101c7a9ab2862c9ff3e7ace74f812a20a522dfa7fa8c6fcdf9f9accc53fd29e2
+  data.tar.gz: 1e1f7d6e1c9cbfe48a21cc8cceaa7cd37de7712363ae78e80bcff87aa6c5ca5a
 SHA512:
-  metadata.gz: dbe6aab96f5a2f67f85fd5147462d65e0f8496a1271406710f4d9e8b5df3a245c8f7e1292a9ac3f548973a204442332abafe21a8a97b6724f25a513b3eef7148
-  data.tar.gz: 5165beba92525197a3d9359bc7513c15e4aa6057a3bea5902870541141fe9ca4fdb3b4f6270eefcbbbf7ca75aff209e03cf39d4d8eb00d34e3292a45e71960ad
+  metadata.gz: 875fc9ea64929088e6a445f43b1e3a0c7b1c92de106a53c8112c68a3eb28ab5ea081c2a1e21d7d672d7e3109c68e68a83283be41364d65b2c450b6932408e15a
+  data.tar.gz: 9be8b0019a5afb3b3a9050dcb6139d9cf2ffe9fbd89549ebb717e8e4a2b59ee981dad95948400836a78e8b8205a324dbd2a35dea6638567143e37cbc93425e32

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

@@ -560,7 +560,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 +748,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_

data/docs/CHANGELOG.md

@@ -1,5 +1,23 @@
 # RubySmart::SimpleLogger - CHANGELOG
 
+## [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
+
 ## [1.2.1] - 2023-02-17
 * **[fix]** 'rails'-related builtins
 * **[fix]** `::RubySmart::SimpleLogger::Devices::MultiDevice` register `MultiDevice` instead of nested devices

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]
 
@@ -61,36 +64,30 @@ module RubySmart
           # check for already existing +device+
           return if opts[:device]
 
-          # remove builtin key from opts
-          builtin = opts.delete(:builtin)
+          # remove builtin key from opts and force an array
+          builtins = Array(opts.delete(:builtin))
 
-          # retransform array into single value
-          builtin = builtin[0] if builtin.is_a?(Array) && builtin.length < 2
+          # expand builtins with stdout
+          builtins << :stdout if opts.delete(:stdout)
 
-          # expand current builtin with optional provided keywords
-          if opts.delete(:stdout)
-            builtin = [builtin] unless builtin.is_a?(Array)
-            builtin << :stdout
-          end
+          # expand builtins with memory
+          builtins << :memory if opts.delete(:memory)
 
-          if opts.delete(:memory)
-            builtin = [builtin] unless builtin.is_a?(Array)
-            builtin << :memory
-          end
+          builtins.uniq!
 
-          # determinate builtin - first check to create +MultiDevice+.
-          if builtin.is_a?(Array)
+          # don't create multi-device for a single (or +nil+) builtin
+          if builtins.length < 2
+            opts[:device] = _resolve_device(builtins[0], opts)
+          else
             opts[:device] = ::RubySmart::SimpleLogger::Devices::MultiDevice.new
-            builtin.uniq.each do |key|
+            builtins.each do |builtin|
               # IMPORTANT: dup, original hash to prevent reference manipulation (on the TOP-level, only)
               builtin_opts = opts.dup
-              opts[:device].register(_resolve_device(key, builtin_opts), _resolve_formatter(builtin_opts))
+              opts[:device].register(_resolve_device(builtin, builtin_opts), _resolve_formatter(builtin_opts))
             end
 
             # force 'passthrough', as format, since this is required for multi-devices
             opts[:format] = :passthrough
-          else
-            opts[:device] = _resolve_device(builtin, opts)
           end
 
           # prevent to return any data
@@ -119,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?
@@ -158,14 +155,16 @@ module RubySmart
           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
@@ -281,6 +280,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
         #
@@ -349,6 +360,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/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  = 1
+      MINOR = 3
+      TINY  = 0
       PRE   = nil
 
       STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

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,34 +305,52 @@ 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
       end

data/lib/ruby_smart/simple_logger.rb

@@ -17,9 +17,8 @@ module RubySmart
 end
 
 # load date extensions for logger
-if GemInfo.loaded?('activesupport') && GemInfo.installed?('actionview')
-  ActiveSupport.on_load(:active_record) do
-    require('action_view/helpers/date_helper')
-    RubySmart::SimpleLogger::Logger.include(ActionView::Helpers::DateHelper)
-  end
+# since 'actionview' is loaded in different ways, we only can check for +installed?+ here...
+if GemInfo.installed?('actionview')
+  # IMPORTANT: any require will break the loading process
+  RubySmart::SimpleLogger::Logger.include(ActionView::Helpers::DateHelper) unless RubySmart::SimpleLogger::Logger.included_modules.include?(ActionView::Helpers::DateHelper)
 end

data/ruby_smart-simple_logger.gemspec

@@ -40,4 +40,6 @@ Gem::Specification.new do |spec|
   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.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Tobias Gonsior
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-17 00:00:00.000000000 Z
+date: 2023-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_smart-support
@@ -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:
@@ -146,7 +174,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 +189,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.4.10
+signing_key: 
 specification_version: 4
 summary: A simple, multifunctional logging library for Ruby.
 test_files: []