eco-helpers 2.6.4 → 2.7.0

data/lib/eco/api/common/people/person_parser.rb

@@ -2,21 +2,35 @@ module Eco
   module API
     module Common
       module People
-
         # Class to define/group a set of parsers/serializers.
         #
-        # @attr_reader schema [Ecoportal::API::V1::PersonSchema, nil] schema of person details that this parser will be based upon.
-        # @attr_reader details_attrs [Array<String>] internal names of schema details attributes.
-        # @attr_reader all_model_attrs [Array<String>] all the internal name attributes, including _core_, _account_ and _details_.
+        # @attr_reader schema [Ecoportal::API::V1::PersonSchema, nil] schema of
+        #   person details that this parser will be based upon.
+        # @attr_reader details_attrs [Array<String>] internal names of
+        #   chema details attributes.
+        # @attr_reader all_model_attrs [Array<String>] all the internal
+        #   name attributes, including _core_, _account_ and _details_.
         class PersonParser
-          extend  Eco::API::Common::ClassAutoLoader
+          extend Eco::API::Common::ClassAutoLoader
           autoloads_children_of     "Eco::API::Common::Loaders::Parser"
           autoload_namespace_ignore "Eco::API"
 
-          CORE_ATTRS    = ["id", "external_id", "email", "name", "supervisor_id", "filter_tags", "contractor_organization_id", "freemium"]
-          ACCOUNT_ATTRS = ["policy_group_ids", "default_tag", "send_invites", "landing_page_id", "login_provider_ids"]
-          TYPE          = [:select, :text, :date, :number, :phone_number, :boolean, :multiple]
-          FORMAT        = [:csv, :xml, :json, :xls]
+          CORE_ATTRS = %w[
+            id external_id email name
+            supervisor_id filter_tags
+            contractor_organization_id freemium
+          ].freeze
+          ACCOUNT_ATTRS = %w[
+            policy_group_ids default_tag
+            send_invites landing_page_id
+            login_provider_ids
+          ].freeze
+          TYPE = %i[
+            select text date
+            number phone_number
+            boolean multiple
+          ].freeze
+          FORMAT = %i[csv xml json xls].freeze
 
           attr_reader :schema
           attr_reader :details_attrs, :all_model_attrs
@@ -33,16 +47,18 @@ module Eco
           #      value.to_s
           #    end
           #  end
-          # @param schema [Ecoportal::API::V1::PersonSchema, nil] schema of person details that this parser will be based upon.
+          # @param schema [Ecoportal::API::V1::PersonSchema, nil] schema of
+          #   person details that this parser will be based upon.
           def initialize(schema: nil)
-            raise "Constructor needs a PersonSchema. Given: #{schema}" if schema && !schema.is_a?(Ecoportal::API::V1::PersonSchema)
+            msg = "Constructor needs a PersonSchema. Given: #{schema.class}"
+            raise msg if schema && !schema.is_a?(Ecoportal::API::V1::PersonSchema)
             @details_attrs = []
             @parsers       = {}
             @patch_version = 0
 
             if schema
               @schema = Ecoportal::API::Internal::PersonSchema.new(JSON.parse(schema.doc.to_json))
-              @details_attrs  = @schema&.fields.map { |fld| fld.alt_id }
+              @details_attrs = @schema&.fields&.map(&:alt_id)
             end
 
             @all_model_attrs = CORE_ATTRS + ACCOUNT_ATTRS + @details_attrs
@@ -57,6 +73,25 @@ module Eco
             self.class.new(schema: schema || self.schema).merge(self)
           end
 
+          # @!group selection options of all select attributes
+
+          # Select Options
+          def select_tables
+            return nil unless @schema
+
+            @select_tables ||= @schema.fields.select do |fld|
+              fld.type == "select"
+            end.to_h do |fld|
+              msg = "The schema selection field '#{fld.name}' is missing selection options."
+              raise msg unless fld.options&.any?
+
+              options_hash = fld.options.to_h { |v| [v.downcase.strip, v] }
+              [fld.alt_id, options_hash]
+            end
+          end
+
+          # @!endgroup
+
           # @!group Scopping attributes (identifying, presence & active)
 
           # @return [Array<Eco::API::Common::Loaders::Parser::RequiredAttrs>]
@@ -71,29 +106,35 @@ module Eco
           end
 
           # Scopes `source_attrs` using the _**core** attributes_.
-          # @note use this helper to know which among your attributes are **core** ones.
+          # @note use this helper to know which among your attributes are
+          #   **core** ones.
           # @param source_attrs [Array<String>]
-          # @return [Array<String>] the scoped **core** attributes, if `source_attrs` is not `nil`. All the _core attributes_, otherwise.
+          # @return [Array<String>] the scoped **core** attributes,
+          #   if `source_attrs` is not `nil`. All the _core attributes_, otherwise.
           def target_attrs_core(source_attrs = nil)
-            return CORE_ATTRS if !source_attrs
+            return CORE_ATTRS unless source_attrs
             scoped_attrs(source_attrs, CORE_ATTRS)
           end
 
           # Scopes `source_attrs` using the schema _**details** attributes_.
-          # @note use this helper to know which among your attributes are schema **details** ones.
+          # @note use this helper to know which among your attributes
+          #   are schema **details** ones.
           # @param source_attrs [Array<String>]
-          # @return [Array<String>] the scoped **details** attributes, if `source_attrs` is not `nil`. All the _details attributes_, otherwise.
+          # @return [Array<String>] the scoped **details** attributes,
+          #   if `source_attrs` is not `nil`. All the _details attributes_, otherwise.
           def target_attrs_details(source_attrs = nil)
-            return @details_attrs if !source_attrs
+            return @details_attrs unless source_attrs
             scoped_attrs(source_attrs, @details_attrs)
           end
 
           # Scopes `source_attrs` using the schema _**account** attributes_.
           # @note use this helper to know which among your attributes are **account** ones.
           # @param source_attrs [Array<String>]
-          # @return [Array<String>] the scoped **account** attributes, if `source_attrs` is not `nil`. All the _account attributes_, otherwise.
+          # @return [Array<String>] the scoped **account** attributes,
+          #   if `source_attrs` is not `nil`.
+          #   All the _account attributes_, otherwise.
           def target_attrs_account(source_attrs = nil)
-            return ACCOUNT_ATTRS if !source_attrs
+            return ACCOUNT_ATTRS unless source_attrs
             scoped_attrs(source_attrs, ACCOUNT_ATTRS)
           end
 
@@ -128,12 +169,17 @@ module Eco
             @parsers.keys.select {|k| k.is_a?(Symbol)}
           end
 
-          # Returns a list of all the internal attributes of the model that have a parser defined & that should be active.
-          # @param source_data [Hash, Array<String>] the data that we scope for parsing
-          # @param phase [Symbol] the phase when the attr parser is expected to be called.
+          # Returns a list of all the internal attributes of the model that have
+          # a parser defined & that should be active.
+          # @param source_data [Hash, Array<String>] the data that we scope for
+          #   parsing
+          # @param phase [Symbol] the phase when the attr parser is expected
+          #   to be called.
           # Can be [:internal, :final, :person]
-          # @param process [Symbol] either `:parse` or `:serialize`, depending if we want to parse or serialize the `attr`.
-          # @return [Array<String>] list of all attribute defined parsers that should be active for the given `source_data`.
+          # @param process [Symbol] either `:parse` or `:serialize`, depending
+          #   if we want to parse or serialize the `attr`.
+          # @return [Array<String>] list of all attribute defined parsers that
+          #   should be active for the given `source_data`.
           def active_attrs(source_data, phase = :any, process: :parse)
             defined_model_attrs.select do |attr|
               if process == :serialize
@@ -165,8 +211,10 @@ module Eco
           # @param parser [Eco::API::Common::People::PersonParser] a `PersonParser` containing defined parsers.
           # @return [Eco::API::Common::People::PersonParser] the current object (to ease chainig).
           def merge(parser)
-            return self if !parser
-            raise "Expected a PersonParser object. Given #{parser}" if !parser.is_a?(PersonParser)
+            return self unless parser
+            msg = "Expected a PersonParser object. Given #{parser.class}"
+            raise msg unless parser.is_a?(PersonParser)
+
             to_h.merge!(parser.to_h)
             patched!
             self
@@ -183,7 +231,9 @@ module Eco
           # @return [Eco::API::Common::People::PersonParser] the current object (to ease chainig).
           def define_attribute(attr, dependencies: {}, &definition)
             unless valid?(attr)
-              msg = "The attribute '#{attr_to_str(attr)}' is not part of core, account or target schema, or does not match any type: #{@details_attrs}"
+              msg =  "The attribute '#{attr_to_str(attr)}' is not part of "
+              msg << "core, account or target schema, or does "
+              msg << "not match any type: #{@details_attrs}"
               raise msg
             end
             Eco::API::Common::People::PersonAttributeParser.new(attr, dependencies: dependencies).tap do |parser|
@@ -197,19 +247,27 @@ module Eco
 
           # @!group Launching parser/serializer
 
-          # Call to parser `source` value of attribute or type `attr` into an internal valid value.
-          # @note dependencies introduced on `parse` call will be merged with those defined during the
-          #  initialization of the parser `attr`.
-          # @raise [Exception] if there is **no** parser for attribute or type `attr`.
+          # Call to parser `source` value of attribute or type `attr` into
+          #   an internal valid value.
+          # @note dependencies introduced on `parse` call will be merged with
+          #   those defined during the initialization of the parser `attr`.
+          # @raise [Exception] if there is **no** parser for attribute or
+          #   type `attr`.
           # @param attr [String] target attribute or type to **parse**.
           # @param source [Any] source value to be parsed.
-          # @param phase [Symbol] the phase when the attr parser is expected to be called.
+          # @param phase [Symbol] the phase when the attr parser is expected
+          #   to be called.
           #   Must be [:internal, :final]
           # @param deps [Hash] key-value pairs of call dependencies.
           # @return [Any] a valid internal value.
           def parse(attr, source, phase = :internal, deps: {})
-            raise "There is no parser for attribute '#{attr}'" if !self.defined?(attr)
-            @parsers[attr].parse(source, phase, dependencies: deps)
+            msg = "There is no parser for attribute '#{attr}'"
+            raise msg unless self.defined?(attr)
+
+            @parsers[attr].parse(source, phase, dependencies: deps) do |_dkey, dval|
+              next dval unless dval.is_a?(Proc)
+              dval.call(self)
+            end
           end
 
           # Call to serialise `object` value of attribute or type `attr` into an external valid value.
@@ -223,8 +281,13 @@ module Eco
           # @param deps [Hash] key-value pairs of call dependencies.
           # @return a valid external value.
           def serialize(attr, object, phase = :person, deps: {})
-            raise "There is no parser for attribute '#{attr}'" if !self.defined?(attr)
-            @parsers[attr].serialize(object, phase, dependencies: deps)
+            msg = "There is no parser for attribute '#{attr}'"
+            raise msg unless self.defined?(attr)
+
+            @parsers[attr].serialize(object, phase, dependencies: deps) do |_dkey, dval|
+              next dval unless dval.is_a?(Proc)
+              dval.call(self)
+            end
           end
           # @!endgroup
 
@@ -247,7 +310,7 @@ module Eco
           end
 
           def attr_to_str(attr)
-            attr.is_a?(Symbol)? ":#{attr.to_s}" : "#{attr.to_s}"
+            attr.is_a?(Symbol)? ":#{attr}" : attr.to_s
           end
 
           def valid?(attr)
@@ -265,7 +328,6 @@ module Eco
           def valid_format?(attr)
             attr.is_a?(Symbol) && FORMAT.include?(attr)
           end
-
         end
       end
     end

data/lib/eco/api/common/people/supervisor_helpers.rb

@@ -18,12 +18,13 @@ module Eco
             # @return [Array<PersonEntry>] `values` sorted by supervisors/subordinates
             def sort_by_supervisors(values, supervisors_first: true)
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return [] unless values && values.is_a?(Enumerable)
-              roam = Proc.new do |tree|
+              return [] unless values.is_a?(Enumerable)
+              roam = proc do |tree|
                 [].tap do |out|
                   sub_outs = tree.empty?? [] : tree.map {|sup, subtree| roam.call(subtree)}
+
                   tree.each do |sup, subtree|
-                    sout = subtree.empty?? [] :roam.call(subtree)
+                    sout = subtree.empty?? [] : roam.call(subtree)
                     supervisors_first ? sout.unshift(sup) : sout.push(sup)
                     out.concat(sout)
                   end
@@ -34,13 +35,14 @@ module Eco
             end
 
             # Identifies all the cyclic supervisor chains
-            # @note as `supervisors_tree` will have any entry involved in a cycle at the top, it just checks all the top entries against their offspring
+            # @note as `supervisors_tree` will have any entry involved in a cycle at the top,
+            #   it just checks all the top entries against their offspring
             # @return [Array<Array>] the sets of entries that are cyclic
             def identify_cyclic_chains(values)
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return [] unless values && values.is_a?(Enumerable)
+              return [] unless values.is_a?(Enumerable)
 
-              identify  = Proc.new do |top_sup, offspring, chain = [top_sup]|
+              identify  = proc do |top_sup, offspring, chain = [top_sup]|
                 next [] if offspring.empty?
                 offspring.each_with_object([]) do |(sup, subordinates), set|
                   break set unless set.empty?
@@ -80,15 +82,15 @@ module Eco
             # @param values [Enumerable<Object>] of objects with methods:
             #  `id`, `external_id` and `supervisor_id`
             # @return [Hash] the tree structure
-            def supervisors_tree(values)
+            def supervisors_tree(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return {} unless values && values.is_a?(Enumerable)
+              return {} unless values.is_a?(Enumerable)
               idx = get_super_indexes(values)
 
               processed = []
-              subtree = Proc.new do |entry, level, toptree|
+              subtree = proc do |entry, level, toptree|
                 if processed.include?(entry)
-                  next {} unless toptree.key?(entry) && level > 0
+                  next {} unless toptree.key?(entry) && level.positive?
                   # needs to be moved as a child
                   subnodes = toptree.delete(entry)
                   processed.delete(entry)
@@ -109,7 +111,7 @@ module Eco
 
               {}.tap do |tree|
                 idx[:by_sup].keys.each do |sup_id|
-                  if sup = idx[:supers][sup_id]
+                  if (sup = idx[:supers][sup_id])
                     tree.merge!(subtree.call(sup, 0, tree))
                   else
                     idx[:by_sup][sup_id].each do |sub|
@@ -122,7 +124,7 @@ module Eco
 
             private
 
-            def get_super_indexes(values)
+            def get_super_indexes(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
               {}.tap do |indexes|
                 indexes[:by_id]  = values.map do |e|
@@ -133,45 +135,42 @@ module Eco
                 end.compact.to_h
 
                 indexes[:by_sup] = {}.tap do |by_s|
-                  values.group_by do |e|
-                    e.supervisor_id
-                  end.tap do |by_sup|
+                  values.group_by(&:supervisor_id).tap do |by_sup|
                     by_s[nil] = by_sup.delete(nil) if by_sup.key?(nil)
                     by_s.merge!(by_sup)
                   end
                 end
 
                 indexes[:supers] = {}.tap do |sups|
-                  indexes[:by_ext].select do |ext, e|
+                  indexes[:by_ext].select do |ext, _e|
                     ext && indexes[:by_sup].key?(ext)
                   end.tap {|found| sups.merge!(found)}
-                  indexes[:by_id].select do |id, e|
+                  indexes[:by_id].select do |id, _e|
                     id && indexes[:by_sup].key?(id)
                   end.tap {|found| sups.merge!(found)}
                 end
 
-                indexes[:is_super]     = Proc.new do |entry|
-                  !!(indexes[:supers][entry.id] || indexes[:supers][entry.external_id])
+                indexes[:is_super] = proc do |entry|
+                  is = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
+                  !is.nil?
                 end
 
-                indexes[:subordinates] = Proc.new do |entry|
+                indexes[:subordinates] = proc do |entry|
                   subs = nil
-                  if sup = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
-                    subs ||= indexes[:by_sup][sup.id]          unless !sup.id
-                    subs ||= indexes[:by_sup][sup.external_id] unless !sup.external_id
+                  sup  = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
+                  if sup
+                    subs ||= indexes[:by_sup][sup.id]          if sup.id
+                    subs ||= indexes[:by_sup][sup.external_id] if sup.external_id
                   end
                   subs
                 end
               end
-
             end
-
           end
 
           class << self
             include SupervisorHelpers::ClassMethods
           end
-
         end
       end
     end

data/lib/eco/api/common/session/base_session.rb

@@ -3,19 +3,17 @@ module Eco
     module Common
       module Session
         class BaseSession
-          attr_accessor :session
-          attr_accessor :environment, :config
+          attr_writer :session, :config
+          attr_reader :environment
           alias_method :enviro, :environment
-          alias_method :enviro=, :environment=
-
-          attr_reader  :api, :file_manager, :logger
-          alias_method :fm, :file_manager
 
           include Session::Helpers
 
-          def initialize(e)
-            raise "Expected object Eco::API::Common::Session::Environment. Given: #{e.class}" unless e.is_a?(Environment)
-            self.environment = e
+          def initialize(env)
+            msg = "Expected object Eco::API::Common::Session::Environment. Given: #{env.class}"
+            raise msg unless env.is_a?(Environment)
+
+            self.environment = env
           end
 
           def session
@@ -26,6 +24,7 @@ module Eco
             @environment = nil
             @environment = value if value.is_a?(Environment)
           end
+          alias_method :enviro=, :environment=
 
           def config
             enviro.config
@@ -42,6 +41,7 @@ module Eco
           def file_manager
             enviro.file_manager
           end
+          alias_method :fm, :file_manager
 
           def mailer
             enviro.mailer

data/lib/eco/api/common/session/environment.rb

@@ -5,7 +5,6 @@ module Eco
         class Environment
           attr_reader :config, :session
           attr_reader :file_manager, :logger
-          attr_reader :mailer, :sftp, :s3uploader
 
           alias_method :fm, :file_manager
 
@@ -13,12 +12,15 @@ module Eco
           #@param session [Eco::API::Session, nil] the current session
           def initialize(init = {}, session:)
             init = init.conf if init.is_a?(Environment)
+
             msg = "Expected object Eco::API::Session::Config or Environment. Given: #{init}"
             raise msg unless init.is_a?(Eco::API::Session::Config)
-            raise "Expected an Eco::API::Session object. Given: #{session}" if session  && !session.is_a?(Eco::API::Session)
 
-            @config  = init
-            @session = session
+            invalid_session = session && !session.is_a?(Eco::API::Session)
+            raise "Expected an Eco::API::Session object. Given: #{session}" if invalid_session
+
+            @config       = init
+            @session      = session
             @file_manager = Eco::API::Common::Session::FileManager.new(enviro: self)
             @logger       = Eco::API::Common::Session::Logger.new(enviro: self)
           end
@@ -43,7 +45,7 @@ module Eco
 
           def s3uploader
             return nil unless s3uploader?
-            @s3uploader  ||= Eco::API::Common::Session::S3Uploader.new(enviro: self)
+            @s3uploader ||= Eco::API::Common::Session::S3Uploader.new(enviro: self)
           end
 
           def s3uploader?

data/lib/eco/api/common/session/sftp.rb

@@ -3,8 +3,11 @@ module Eco
     module Common
       module Session
         class SFTP
-          def initialize (enviro:)
-            raise "Required Environment object (enviro:). Given: #{enviro}" if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+          include Eco::Language::AuxiliarLogger
+
+          def initialize(enviro:)
+            invalid_env = enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+            raise "Required Environment object (enviro:). Given: #{enviro}" if invalid_env
             @enviro = enviro
           end
 
@@ -15,23 +18,22 @@ module Eco
           # @see Net::SFTP::Session
           def sftp_session
             require "net/sftp"
-            begin
-              @sftp_session ||= Net::SFTP.start(
-                host,
-                fetch_user,
-                **session_options
-              )
-            rescue Exception => e
-              msg = "Could not open SFTP session. Possible misconfiguration: #{e}"
-              logger.error(msg)
-              raise
-            end
-            @sftp_session
+
+            @sftp_session ||= Net::SFTP.start(
+              host,
+              fetch_user,
+              **session_options
+            )
+          rescue StandardError => err
+            log(:error) {
+              "Could not open SFTP session. Possible misconfiguration: #{err}"
+            }
+            raise
           end
 
           # @see Net::SFTP::Operations::Dir#entries
           def entries(path)
-            sftp_session.dir.entries(path).sort_by {|rf| rf.name}
+            sftp_session.dir.entries(path).sort_by(&:name)
           end
 
           # **Files** of the remote directory.
@@ -40,8 +42,9 @@ module Eco
           # @param pattern [Regexp] if given, filters by using this pattern
           # @return [Array<Net::SFTP::Protocol::V01::Name>]
           def files(path, pattern: nil)
-            entries = entries(path).select {|remote_file| remote_file.file?}
+            entries = entries(path).select(&:file?)
             return entries unless pattern
+
             entries.select {|remote_file| remote_file.name =~ pattern}
           end
 
@@ -51,20 +54,20 @@ module Eco
           # @param pattern [Regexp] if given, filters by using this pattern
           # @return [Array<Net::SFTP::Protocol::V01::Name>]
           def folders(path, pattern: nil)
-            entries = entries(path).select {|remote_file| remote_file.directory?}
+            entries = entries(path).select(&:directory?)
             return entries unless pattern
+
             entries.select {|remote_file| remote_file.name =~ pattern}
           end
 
           # @see Net::SFTP::Session#rename
-          def move(fullname_source, fullname_dest, flags=0x0001, override: true, &callback)
-            begin
-              sftp_session.rename!(fullname_source, fullname_dest, flags, &callback)
-            rescue Net::SFTP::StatusException => e
-              raise unless override
-              sftp_session.remove(fullname_dest)
-              sftp_session.rename!(fullname_source, fullname_dest, flags, &callback)
-            end
+          def move(fullname_source, fullname_dest, flags = 0x0001, override: true, &callback)
+            sftp_session.rename!(fullname_source, fullname_dest, flags, &callback)
+          rescue Net::SFTP::StatusException => _err
+            raise unless override
+
+            sftp_session.remove(fullname_dest)
+            sftp_session.rename!(fullname_source, fullname_dest, flags, &callback)
           end
 
           # Downloads the files specified to a local folder
@@ -78,10 +81,29 @@ module Eco
               dest_fullname = File.join(local_folder || ".", basename)
               puts " • #{dest_fullname}"
               sftp_session.download(fullname, dest_fullname)
-            end.each do |dw|
-              # run SSH event loop while dw.active?
-              dw.wait
+            end.each(&:wait)
+            # run SSH event loop while dw.active?
+          end
+
+          # Upload a file to the specific `remote_folder`
+          def upload(local_file, remote_folder:, gid: nil)
+            return false unless local_file && File.exist?(local_file)
+
+            dest_file = "#{remote_folder}/#{File.basename(local_file)}"
+            res       = sftp_session.upload!(local_file, dest_file)
+
+            unless gid.nil?
+              attrs = sftp_session.stat!(dest_file)
+              unless gid == attrs.gid
+                flags     = {permissions: 0o660, uid: attrs.uid, gid: gid}
+                _stat_res = sftp_session.setstat!(dest_file, flags)
+              end
             end
+
+            log(:info) {
+              "Uploaded '#{local_file}' (#{res})"
+            }
+            true
           end
 
           private
@@ -94,21 +116,26 @@ module Eco
                 opts.merge!({password: fetch_password})
               else
                 opts.merge!({
-                  keys:            fetch_key_files,
-                  keys_only:       true
+                  keys:      fetch_key_files,
+                  keys_only: true
                 })
               end
             end
           end
 
           def windows_basename(remote_fullname)
-            parts = remote_fullname.split(/[\\\/]/).map {|node| node.gsub(/[<>:\\\/\|?*]/, '_')}
+            dir_sep = /[\\\/]/
+            patr_re = /[<>:\\\/|?*]/
+            parts   = remote_fullname.split(dir_sep).map do |node|
+              node.gsub(patr_re, '_')
+            end
             local_fullname = File.join(*parts)
             File.basename(local_fullname)
           end
 
           def logger
-            @enviro&.logger || ::Logger.new(IO::NULL)
+            @enviro&.logger ||
+              (defined?(super)? super : ::Logger.new(IO::NULL))
           end
 
           def config

data/lib/eco/api/common/version_patches/exception.rb

@@ -1,16 +1,14 @@
 class ::Exception
   def patch_full_message(trace_count: -1)
-    begin
-      msg = []
-      tracing   = backtrace ? backtrace : []
-      tracing   = (self.class == SystemStackError) ? tracing[1..30] : tracing[1..trace_count]
-      tracing ||= []
-      msg << "\n#{tracing.first} \n#{message} (#{self.class.to_s})"
-      tracing.each_with_index {|bt, i| msg << "#{" "*8}#{i+1}: from #{bt}"}
-      msg.join("\n")
-    rescue Exception => e
-      puts "Something is wrong with 'patch_full_message': #{e}"
-    end
+    msg = []
+    tracing   = backtrace || []
+    tracing   = instance_of?(SystemStackError) ? tracing[1..30] : tracing[1..trace_count]
+    tracing ||= []
+    msg << "\n#{tracing.first} \n#{message} (#{self.class})"
+    tracing.each_with_index {|bt, i| msg << "#{" "*8}#{i+1}: from #{bt}"}
+    msg.join("\n")
+  rescue StandardError => e
+    puts "Something is wrong with 'patch_full_message': #{e}"
   end
 end
 
@@ -23,7 +21,7 @@ Exception.class_eval do
         String(message) + super()
       end
     end
-    self.extend mod
+    extend mod
   end
 
   def append_message(message)
@@ -32,6 +30,6 @@ Exception.class_eval do
         super() + String(message)
       end
     end
-    self.extend mod
+    extend mod
   end
 end