ruby_smart-simple_logger 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9d250fc038e12f5d76ede43d6714efb039be7b6093bd4ea8abca6dfc937d8cc
-  data.tar.gz: 52d4bc7495fea29db91b336161b7af454d55b9f22e76f1e83291264844686df7
+  metadata.gz: a47086748b62315efd5a4497e118bbb8a537cb153099cefa99e9432a8ed14ecb
+  data.tar.gz: 9f74e2177dfd4fb008fb8b203d282217a37846c724b4e2b0bfa55ae982ea83ef
 SHA512:
-  metadata.gz: cf60c99604f5da1abd4bc4ffa5c536c233728c242c7c198849fd1838cacf856a0abaaef39f6cb1aa46fc9adbd85be329637f01e0844c39e43bdac660db311a20
-  data.tar.gz: 7c618af918fd6a19228f152fd456a8a4f2d99bbeceae1aec4d2aa6706f11f2138ba575390d68076f2d07e29fe09fbcdce75c64baed06a887becb752662f391bd
+  metadata.gz: 50d2cb4beda62d0c4189c22eb201ae8cc95e1cf6d9e0f037522f58c27ce3ddf34a000fba9156a71b662b223313fe2cdd4d5589916094cbe19b71393220e62464
+  data.tar.gz: 723da7c50cc2d87ea2c8de011c0f54d743c32c5abf99da5441a5cf6a6cec7657ec4dd35de3d67ab6d3cc9ed8b95db01c0ef702a20a6d33b8a25d1f1ba7ab34dc

data/README.md

@@ -112,6 +112,8 @@ logger = ::SimpleLogger.new
 logger.debug "some debug"
 logger.error "that failed ..."
 
+# ----------------------------------------------------------------------------------------------------------------------
+
 alternative_logger = ::SimpleLogger.new :memory
 alternative_logger.debug "some debug, just in memory logs"
 alternative_logger.error "that failed, also in memory logs..."
@@ -123,6 +125,16 @@ alternative_logger.logs
 # access the logs as grouped hash
 alternative_logger.logs_to_h
 #=> {:debug=>["some debug, just in memory logs"], :error=>["that failed, also in memory logs..."]}
+
+# ----------------------------------------------------------------------------------------------------------------------
+
+multi_logger = ::SimpleLogger.new :memory, :stdout, clr: true, format: :default
+multi_logger.debug "some debug, sent to stdout & memory"
+# > D, [2023-02-15T10:22:45.030758 #13397]   DEBUG -- : some debug, sent to stdout & memory
+
+# access the logs as array
+multi_logger.logs
+# => [[:debug, 2023-02-15T10:22:45 +0200, "some debug, sent to stdout & memory"]]
 ```
 _You can also create a new instance from every klass_logger Object (see below)._
 
@@ -142,7 +154,6 @@ MyCustomLogger.theme "My Theme"
 
 # log directly to a customized logfile - created through the builtin module name
 MyCustomLogger.klass_logger_opts = {builtin: MyApp::Tasks::SpecialTask}
-MyCustomLogger.clear!
 MyCustomLogger.info "Very nice here"
 # => creates a logfile @ log/my_app/tasks/special_task.log
 ```
@@ -156,7 +167,6 @@ SimpleLogger.error "that failed ..."
 
 # resetting options
 SimpleLogger.klass_logger_opts = {builtin: :memory, stdout: false}
-SimpleLogger.clear!
 
 SimpleLogger.debug "some other debug in memory only ..."
 SimpleLogger.logs
@@ -167,13 +177,14 @@ other_logger = SimpleLogger.new
 other_logger.debug "some other debug in memory only ..."
 
 # create new logger, but don't use 'klass_logger_opts' - instead pipe to the rails logger
-other_logger2 = SimpleLogger.new :rails
+other_logger2 = SimpleLogger.new :rails, :stdout
 other_logger2.info "directly logs to the rails logger"
+other_logger2.info "and also to STDOUT"
 ```
 
-Alternatives with 'Debugger':
+Alternatives with already build 'Debugger':
 ```ruby
-require 'debugger'
+require 'ruby_smart-debugger'
 
 Debugger.debug "some debug"
 Debugger.error "that failed ..."
@@ -530,7 +541,7 @@ logger.debug({ a: 1, b: 2 })
 
 ## _defaults_
 
-Logger default options are still available: ```shift_age, shift_size, progname, datetime_format, shift_period_suffix```
+Device default options are still available: ```shift_age, shift_size, progname, datetime_format, shift_period_suffix, binmode```
 
 -----
 
@@ -737,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 [SUCCESS] (duration: 0.000267545)
+# ║ ┌ START :: transforming ...
 # ║ ├ bad memory
 # ║ ├ rolling back
-# ║ └ END   - FAILED
-# ╚ END   - Process Alpha (duration: 0.001040807)
+# ║ └ END [FAILED]
+# ╚ END [Process Alpha] (duration: 0.001040807)
 ```
 
 ### _other useful methods_

data/docs/CHANGELOG.md

@@ -1,5 +1,17 @@
 # RubySmart::SimpleLogger - CHANGELOG
 
+## [1.2.0] - 2023-02-16
+* **[add]** multi-'builtins' support
+* **[ref]** `Logger` initialization - now supports to provide multiple builtins 
+* **[ref]** `Debugger` requirement to 'ruby_smart-debugger' instead of 'debugger'
+* **[ref]** 'processed' scene to be moved to 'debug'-severity
+* **[fix]** some contradictions within the builtins
+* **[fix]** nested 'logdev' relation with `::RubySmart::SimpleLogger::Devices::MultiDevice` devices
+* **[fix]** `::RubySmart::SimpleLogger::KlassLogger` not forwarding optional block to scenes
+* **[fix]** overcomplicated initialization with ruby's logger - now creates it own logdev
+* **[fix]** `Debugger` conflict with `ruby-debug-ide`-gem
+* **[fix]** 'date_helper' initialisation
+
 ## [1.1.1] - 2023-02-07
 * **[fix]** 'ruby 2.6.x' kwargs for `::Logger::LogDevice` messed up with 'binmode'
 

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

@@ -11,104 +11,178 @@ module RubySmart
 
         private
 
-        # prepare builtin defaults
+        # set / overwrite default opts
         # @param [Hash] opts
-        # @param [Object] builtin
-        def _opts_builtin(opts, builtin = nil)
-          builtin ||= opts.delete(:builtin)
+        def _opts_init!(opts)
+          ##################################################################################
+          # level
+
+          # initialize a default rails-dependent output
+          if ::ThreadInfo.rails?
+            opts[:level] ||= (::Rails.env.production? ? :info : :debug)
+          end
+
+          # clean & rewrite level (possible symbols) to real level
+          opts[:level] = _level(opts[:level] || :debug)
+
+          ##################################################################################
+          # mask
+
+          # set mask from options
+          self.mask(opts[:mask]) if opts[:mask]
+
+          # disable mask color if explicit disabled
+          self.mask(clr: false) if opts[:clr] == false
+
+          # reduce mask-size to window size
+          if ::ThreadInfo.windowed? && ::ThreadInfo.winsize[1] < self.mask[:length]
+            self.mask(length: ::ThreadInfo.winsize[1])
+          end
+
+          ##################################################################################
+          # instance related
+
+          # ignore payload and send data directly to the logdev
+          @ignore_payload = true if @ignore_payload.nil? && opts[:payload] == false
+
+          # set the inspector to be used for data inspection.
+          # 'disable' inspector, if false was provided - which simply results in +#to_s+
+          @inspector = (opts[:inspect] == false) ? :to_s : opts[:inspector]
+
+          # prevent to return any data
+          nil
+        end
+
+        # enhance provided opts with +:device+.
+        # opts may be manipulated by resolved device
+        # does not return any data.
+        # @param [Hash] opts
+        def _opts_device!(opts)
+          # check for already existing +device+
+          return if opts[:device]
+
+          # remove builtin key from opts
+          builtin = opts.delete(:builtin)
+
+          # retransform array into single value
+          builtin = builtin[0] if builtin.is_a?(Array) && builtin.length < 2
+
+          # expand current builtin with optional provided keywords
+          if opts.delete(:stdout)
+            builtin = [builtin] unless builtin.is_a?(Array)
+            builtin << :stdout
+          end
+
+          if opts.delete(:memory)
+            builtin = [builtin] unless builtin.is_a?(Array)
+            builtin << :memory
+          end
+
+          # determinate builtin - first check to create +MultiDevice+.
+          if builtin.is_a?(Array)
+            opts[:device] = ::RubySmart::SimpleLogger::Devices::MultiDevice.new
+            builtin.uniq.each do |key|
+              # 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))
+            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
+          nil
+        end
+
+        # enhance provided opts with +:formatter+.
+        # opts may be manipulated by resolved formatter
+        # does not return any data.
+        # @param [Hash] opts
+        def _opts_formatter!(opts)
+          # check for already existing +formatter+
+          return if opts[:formatter]
+
+          opts[:formatter] = _resolve_formatter(opts)
+
+          # prevent to return any data
+          nil
+        end
+
+        # resolves & returns formatter from provided opts
+        # @param [Hash] opts
+        # @return [RubySmart::SimpleLogger::Formatter]
+        def _resolve_formatter(opts)
+          # set default format
+          opts[:format] ||= :plain
 
+          # fix nl - which depends on other opts
+          opts[:nl] = _nl(opts)
+
+          # fix clr
+          opts[:clr] = true if opts[:clr].nil?
+
+          ::RubySmart::SimpleLogger::Formatter.new(opts)
+        end
+
+        # resolves & returns device from builtin & provided opts
+        # @param [Object] builtin
+        # @param [Hash] opts
+        def _resolve_device(builtin, opts)
           case builtin
-          when nil
-            # device is nil - resolve optimal device
+          when nil # builtin is nil - resolve optimal device for current environment
             if ::ThreadInfo.stdout?
-              _opts_builtin(opts, :stdout)
+              _resolve_device(:stdout, opts)
             elsif ::ThreadInfo.rails? && ::Rails.logger
-              _opts_builtin(opts, :rails)
+              _resolve_device(:stdout, opts)
             else
-              _opts_builtin(opts, :memory)
+              _resolve_device(:memory, opts)
             end
           when :stdout
-            # set device ONLY if unset in opts
-            opts[:device] ||= STDOUT
-            # colorize output
-            opts[:clr]    = true if opts[:clr].nil?
+            STDOUT
           when :stderr
-            opts[:device] ||= STDERR
-            # colorize output
-            opts[:clr]    = true if opts[:clr].nil?
+            STDERR
           when :rails
-            # set device ONLY if unset in opts
-            opts[:device] ||= ::RubySmart::SimpleLogger::Devices::MultiDevice.register(::Rails.logger.instance_variable_get(:@logdev).dev)
+            ::Rails.logger.instance_variable_get(:@logdev).dev
           when :proc
-            # auto sets related opts for proc device
-            opts[:payload] = false
+            # force overwrite opts
+            @ignore_payload = true
             opts[:nl]      = false
-            opts[:format]  ||= :passthrough
+            opts[:format]  = :passthrough
 
-            # set device ONLY if unset in opts
-            opts[:device] ||= ::RubySmart::SimpleLogger::Devices::ProcDevice.new(opts[:proc])
+            ::RubySmart::SimpleLogger::Devices::ProcDevice.new(opts.delete(:proc))
           when :memory
-            # auto sets related opts for memory device
-            opts[:payload] = false
-
-            # set device ONLY if unset in opts
-            opts[:device] ||= if opts[:stdout]
-                                # store original format
-                                stdout_format = opts[:format] || :plain
-
-                                # force 'passthrough', as format, since this is required for multi-devices
-                                opts[:format] = :passthrough
-
-                                # special case handling to additionally stdout logs
-                                ::RubySmart::SimpleLogger::Devices::MultiDevice.new
-                                                                               .register(::RubySmart::SimpleLogger::Devices::MemoryDevice.new, ::RubySmart::SimpleLogger::Formatter.new(format: :memory))
-                                                                               .register(STDOUT, ::RubySmart::SimpleLogger::Formatter.new(format: stdout_format, nl: _nl(opts), clr: opts[:clr]))
-                              else
-                                opts[:format] ||= :memory
-                                ::RubySmart::SimpleLogger::Devices::MemoryDevice.new
-                              end
-          when Module
-            # set device ONLY if unset in opts
-            opts[:device] ||= if opts[:stdout]
-                                # store original format
-                                device_format = opts[:format] || :plain
-
-                                # force 'passthrough', as format, since this is required for multi-devices
-                                opts[:format] = :passthrough
-
-                                # colorize output
-                                opts[:clr]    = true if opts[:clr].nil?
-
-                                # special case handling to additionally stdout logs
-                                ::RubySmart::SimpleLogger::Devices::MultiDevice.register(
-                                  if GemInfo.match?(RUBY_VERSION, '< 2.7')
-                                    ::Logger::LogDevice.new(_logdev(builtin),
-                                                            shift_age:           opts[:shift_age] || 0,
-                                                            shift_size:          opts[:shift_size] || 1048576,
-                                                            shift_period_suffix: opts[:shift_period_suffix])
-                                  else
-                                    ::Logger::LogDevice.new(_logdev(builtin),
-                                                            shift_age:           opts[:shift_age] || 0,
-                                                            shift_size:          opts[:shift_size] || 1048576,
-                                                            shift_period_suffix: opts[:shift_period_suffix],
-                                                            binmode:             opts[:binmode])
-                                  end,
-                                  ::RubySmart::SimpleLogger::Formatter.new(format: device_format, nl: _nl(opts), clr: false))
-                                                                               .register(STDOUT, ::RubySmart::SimpleLogger::Formatter.new(format: device_format, nl: _nl(opts), clr: opts[:clr]))
-                              else
-                                builtin
-                              end
+            # force overwrite opts
+            @ignore_payload = true
+            opts[:format]  = :memory
+
+            ::RubySmart::SimpleLogger::Devices::MemoryDevice.new
+          when Module, String
+            # force overwrite opts
+            opts[:clr] = false
+            _logdev(opts, builtin)
           else
-            # forward provided device ONLY if unset in opts
-            opts[:device] ||= builtin
+            _logdev(opts, builtin)
           end
         end
 
         # resolve the final log-device from provided param
+        # @param [Hash] opts
         # @param [Object] device
-        # @return [Object]
-        def _logdev(device)
-          if device.is_a?(Module)
+        # @return [:Logger::LogDevice]
+        def _logdev(opts, device = nil)
+          device ||= opts.delete(:device)
+
+          # if existing device is already writeable, simply return it
+          return device if device.respond_to?(:write)
+
+          file_location = nil
+
+          # resolve the file_location from provided device
+          case device
+          when Module
             devstring = device.to_s
             logfile   = (devstring.respond_to?(:underscore) ? devstring.underscore : _underscore(device.to_s)) + '.log'
             # check for rails
@@ -122,23 +196,36 @@ module RubySmart
             file_path = File.dirname(file_location)
             FileUtils.mkdir_p(file_path) unless File.directory?(file_path)
 
+            # the logdev
             file_location
-          elsif device.is_a?(String)
-            device = "log/#{device}" unless device[0] == '/'
+          when String
+            file_location = (device[0] == '/' ? device : "log/#{device}")
 
             # resolve path to create a folder
-            file_path = File.dirname(device)
+            file_path = File.dirname(file_location)
             FileUtils.mkdir_p(file_path) unless File.directory?(file_path)
 
-            device
-          elsif device.respond_to?(:write)
-            device
+            file_location
           else
-            raise "SimpleLogger :: device '#{device}' must respond to 'write'!"
+            raise "Unable to build SimpleLogger! The provided device '#{device}' must respond to 'write'!"
+          end
+
+          if GemInfo.match?(RUBY_VERSION, '< 2.7')
+            ::Logger::LogDevice.new(file_location,
+                                    shift_age:           opts[:shift_age] || 0,
+                                    shift_size:          opts[:shift_size] || 1048576,
+                                    shift_period_suffix: opts[:shift_period_suffix])
+          else
+            ::Logger::LogDevice.new(file_location,
+                                    shift_age:           opts[:shift_age] || 0,
+                                    shift_size:          opts[:shift_size] || 1048576,
+                                    shift_period_suffix: opts[:shift_period_suffix],
+                                    binmode:             opts[:binmode])
           end
         end
 
         # this is a 1:1 copy of +String#underscore+ @ activesupport gem
+        # and only used if activesupport is not available ...
         def _underscore(camel_cased_word)
           return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
           word = camel_cased_word.to_s.gsub("::", "/")
@@ -150,52 +237,6 @@ module RubySmart
           word
         end
 
-        # build log-device & options on initialize
-        # @param [Hash] opts
-        # @return [Array<logdev,opts>] logdev, opts
-        def _init_opts(opts)
-          # clean & rewrite opts (especially device) to a real logdev
-          _opts_builtin(opts)
-
-          # set mask from options
-          self.mask(opts[:mask]) if opts[:mask]
-
-          # disable mask color if explicit disabled
-          self.mask(clr: false) if opts[:clr] == false
-
-          # reduce mask-size to window size
-          if ::ThreadInfo.windowed? && ::ThreadInfo.winsize[1] < self.mask[:length]
-            self.mask(length: ::ThreadInfo.winsize[1])
-          end
-
-          # initialize a default rails-dependent output
-          if ::ThreadInfo.rails?
-            opts[:level] ||= (::Rails.env.production? ? :info : :debug)
-          end
-
-          # clean & rewrite level (possible symbols) to real level
-          opts[:level] = _level(opts[:level] || :debug)
-
-          # clean & rewrite nl
-          opts[:nl] = _nl(opts)
-
-          # rewrite format
-          opts[:format] ||= :plain
-
-          # provide custom formatter and forward special opts (format, nl, clr)
-          opts[:formatter] ||= ::RubySmart::SimpleLogger::Formatter.new(opts)
-
-          # ignore payload and send data directly to the logdev
-          @ignore_payload  = true if opts[:payload].is_a?(FalseClass)
-
-          # set the inspector to be used for data inspection.
-          # 'disable' inspector, if false was provided - which simply results in +#to_s+
-          @inspector = (opts[:inspect] === false) ? :to_s : opts[:inspector]
-
-          # simple return opts
-          opts
-        end
-
         # returns the +nl+ (new line) flag, depending on the provided options.
         # recognizes +:nl+ and +:payload+ options.
         # @param [Hash] opts
@@ -247,8 +288,8 @@ module RubySmart
         # @param [String] str
         # @param [String, Symbol, nil] color
         # @return [String] colored string
-        def _clr(str, color)
-          return str unless color && str.respond_to?(color)
+        def _clr(str, color = nil)
+          return str unless color
           str.send(color) rescue str
         end
 

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

@@ -7,8 +7,8 @@ module RubySmart
         # returns the logdev logs
         # @return [Array]
         def logs
-          return [] unless logdev.dev.respond_to?(:logs)
-          logdev.dev.logs
+          return [] unless logdev.respond_to?(:logs)
+          logdev.logs
         end
 
         # transforms the logs-array into a hash of logs, grouped by level (:error, :success, ...)

data/lib/ruby_smart/simple_logger/gem_version.rb

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

data/lib/ruby_smart/simple_logger/klass_logger.rb

@@ -19,14 +19,13 @@ module RubySmart
         class_variable_set('@@klass_logger_opts', opts)
       end
 
-      # delegate new method to logger
+      # delegate new method to Logger
       def new(*args)
-        args = [nil, self.klass_logger_opts.dup] if args.length == 0
         RubySmart::SimpleLogger::Logger.new(*args)
       end
 
       def klass_logger
-        @klass_logger ||= self.new
+        @klass_logger ||= self.new(self.klass_logger_opts.dup)
       end
 
       def clear!
@@ -34,7 +33,7 @@ module RubySmart
       end
 
       def method_missing(name, *args, &block)
-        return self.klass_logger.send(name, *args) if self.klass_logger.respond_to? name
+        return self.klass_logger.send(name, *args, &block) if self.klass_logger.respond_to? name
         super
       end
 

data/lib/ruby_smart/simple_logger/logger.rb

@@ -40,30 +40,30 @@ module RubySmart
       # defines a uniq key to parse the data
       PAYLOAD_DATA_KEY = :__data__
 
-      # initialize new Logger
-      # @param [Object, Symbol, nil] builtin
-      # @param [Hash] opts
-      # @option opts [Symbol] :format - defines a custom format
-      def initialize(builtin = nil, opts = nil)
-        # check if only a hash was provided
-        if opts.nil? && builtin.is_a?(Hash)
-          opts = builtin
-        else
-          opts ||= {}
+      # initializes a new Logger
+      #
+      # @param [Array] args (<builtin>,<opts>) OR (<builtin>) OR (<opts>)
+      # @option args[Symbol,Array] <builtin> - provide a builtin, either a single symbol or array of symbols
+      # @option args[Hash] <options> - provide custom options
+      def initialize(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts[:builtin] = args if args.length > 0
 
-          # extend builtin option if not set
-          opts[:builtin] = builtin unless opts[:builtin]
-        end
+        # enhance options with device & formatter
+        _opts_device!(opts)
+        _opts_formatter!(opts)
 
-        # initialize provided opts
-        o = _init_opts(opts)
+        # initialize & set defaults by provided opts
+        _opts_init!(opts)
 
-        super(
-          _logdev(o[:device]),
-          o[:shift_age] || 0,
-          o[:shift_size] || 1048576,
-          **o.slice(:level, :progname, :formatter, :datetime_format, :binmode, :shift_period_suffix)
-        )
+        # initialize with a nil +logdev+ to prevent any nested +LogDevice+ creation.
+        # we already arranged device & formatter to be able to respond to ther required methods
+        super(nil)
+
+        # set explicit after called super
+        self.level = opts[:level]
+        self.formatter = opts[:formatter]
+        @logdev = _logdev(opts)
       end
 
       # overwrite level setter, to accept every available (also newly defined) Severity

data/lib/ruby_smart/simple_logger/scenes.rb

@@ -284,14 +284,14 @@ module RubySmart
         end
 
         # processed method
-        # log level @ info
+        # 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)
-        base.scene :processed, { level: :info } do |name, opts = {}, &block|
+        # ╚ END [job] (duration: 4.34223)
+        base.scene :processed, { level: :debug } do |name, opts = {}, &block|
           # resolve the current process-level
           lvl = processed_lvl(:up)
 
@@ -300,18 +300,18 @@ module RubySmart
             self.timer(:start, timer_key) if timer_key
           end
 
-          self.log("START - #{name}", _scene_opt(:processed, { pcd: :start }))
+          self.log("START :: #{name}", _scene_opt(:processed, opts, { pcd: :start }))
 
           end_str = case block.call
                     when true
-                      "END   - SUCCESS"
+                      'SUCCESS'
                     when false
-                      "END   - FAILED"
+                      'FAILED'
                     else
-                      "END   - #{name}"
+                      name
                     end
 
-          self.log("#{end_str} #{(timer_key ? "(duration: #{self.timer(:clear, timer_key, :humanized => true)})" : '')}", _scene_opt(:processed, { pcd: :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)
 

data/lib/ruby_smart/simple_logger.rb

@@ -18,7 +18,7 @@ end
 
 # load date extensions for logger
 if GemInfo.loaded?('activesupport') && GemInfo.installed?('actionview')
-  ActiveSupport.on_load(:action_view) do
+  ActiveSupport.on_load(:active_record) do
     require('action_view/helpers/date_helper')
     RubySmart::SimpleLogger::Logger.include(ActionView::Helpers::DateHelper)
   end

data/lib/{debugger.rb → ruby_smart-debugger.rb}

@@ -9,7 +9,7 @@ GemInfo.safe_require 'ruby-debug-ide'
 # try to load 'awesome_print', if available
 GemInfo.safe_require 'awesome_print'
 
-class Debugger
+module Debugger
   extend ::RubySmart::SimpleLogger::KlassLogger
 
   # force debugger to 'DEBUG' severity

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_smart-simple_logger
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Tobias Gonsior
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-07 00:00:00.000000000 Z
+date: 2023-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_smart-support
@@ -114,7 +114,7 @@ files:
 - docs/CHANGELOG.md
 - docs/CODE_OF_CONDUCT.md
 - docs/LICENSE.txt
-- lib/debugger.rb
+- 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