contrast-agent 7.2.0 → 7.3.1

data/lib/contrast/agent/telemetry/metric_event.rb

@@ -3,6 +3,8 @@
 
 require 'contrast/utils/metrics_hash'
 require 'contrast/agent/telemetry/event'
+require 'contrast/utils/duck_utils'
+require 'contrast/utils/os'
 
 module Contrast
   module Agent
@@ -10,6 +12,7 @@ module Contrast
       # This class will hold the basic information for a Telemetry Event
       class MetricEvent < Contrast::Agent::Telemetry::Event
         include Contrast::Utils
+        include Contrast::Utils::OS
 
         attr_reader :fields
 
@@ -19,6 +22,15 @@ module Contrast
           @fields['_filler'] = 0
         end
 
+        def sys_info
+          @sys_info ||= get_system_information if @sys_info.nil?
+          @sys_info
+        end
+
+        def empty?
+          Contrast::Utils::DuckUtils.empty_duck?(@fields)
+        end
+
         def to_controlled_hash **_args
           super.merge!({ fields: @fields })
         end

data/lib/contrast/agent/telemetry/startup_metrics_event.rb

@@ -4,7 +4,6 @@
 require 'contrast/utils/metrics_hash'
 require 'contrast/agent/telemetry/metric_event'
 require 'contrast/agent/version'
-require 'contrast/utils/os'
 
 module Contrast
   module Agent
@@ -15,8 +14,6 @@ module Contrast
       # application framework and version and server framework
       # It will be initialized and send in Middleware#agent_startup_routine
       class StartupMetricsEvent < Contrast::Agent::Telemetry::MetricEvent
-        include Contrast::Utils::OS
-
         APP_AND_SERVER_DATA = ::Contrast::APP_CONTEXT.app_and_server_information.cs__freeze
         # Multi-tenant Production Environments
         SAAS_DEFAULT = { addr: 'app.contrastsecurity.com', type: 'SAAS_DEFAULT' }.cs__freeze
@@ -82,11 +79,6 @@ module Contrast
           end
         end
 
-        def sys_info
-          @sys_info ||= get_system_information if @sys_info.nil?
-          @sys_info
-        end
-
         private
 
         # Here we extract the TeamServer url type

data/lib/contrast/agent/version.rb

@@ -3,6 +3,6 @@
 
 module Contrast
   module Agent
-    VERSION = '7.2.0'
+    VERSION = '7.3.1'
   end
 end

data/lib/contrast/components/assess.rb

@@ -17,14 +17,26 @@ module Contrast
 
         # @return [Boolean, nil]
         attr_accessor :enable
-        # @return [Array, nil]
-        attr_writer :enable_scan_response, :enable_dynamic_sources, :sampling, :rules, :stacktraces, :tags
+        # @return [Boolean, nil]
+        attr_writer :enable_scan_response
+        # @return [Boolean, nil]
+        attr_writer :enable_dynamic_sources
+        # @return [Contrast::Components::Sampling::Interface]
+        attr_writer :sampling
+        # @return [Contrast::Components::AssessRules::Interface]
+        attr_writer :rules
+        # @return [String, nil]
+        attr_writer :stacktraces
+        # @return [Array<String>, nil]
+        attr_writer :tags
         # @return [String]
         attr_reader :canon_name
-        # @return [Array]
+        # @return [Array<String>]
         attr_reader :config_values
         # @return [Boolean]
         attr_writer :enable_original_object
+        # @return [Boolean]
+        attr_writer :enable_response_as_source
         # @return [Integer]
         attr_writer :max_context_source_events
         # @return [Integer]
@@ -46,6 +58,7 @@ module Contrast
           enable_scan_response
           enable_original_object
           enable_dynamic_sources
+          enable_response_as_source
           stacktraces
           max_context_source_events
           max_propagation_events
@@ -63,27 +76,33 @@ module Contrast
           @enable_scan_response = hsh[:enable_scan_response]
           @enable_dynamic_sources = hsh[:enable_dynamic_sources]
           @enable_original_object = hsh[:enable_original_object]
+          @enable_response_as_source = hsh[:enable_response_as_source]
           @sampling = Contrast::Components::Sampling::Interface.new(hsh[:sampling])
           @rules = Contrast::Components::AssessRules::Interface.new(hsh[:rules])
           @stacktraces = hsh[:stacktraces]
           assign_limits(hsh)
         end
 
-        # @return [Boolean, true]
+        # @return [Boolean]
         def enable_scan_response
           @enable_scan_response.nil? ? true : @enable_scan_response
         end
 
-        # @return [Boolean, true]
+        # @return [Boolean]
         def enable_dynamic_sources
           @enable_dynamic_sources.nil? ? true : @enable_dynamic_sources
         end
 
-        # @return [Boolean, true]
+        # @return [Boolean]
         def enable_original_object
           @enable_original_object.nil? ? true : @enable_original_object
         end
 
+        # @return [Boolean]
+        def enable_response_as_source
+          @enable_response_as_source.nil? ? false : @enable_response_as_source
+        end
+
         # @return [Contrast::Components::Sampling::Interface]
         def sampling
           @sampling ||= Contrast::Components::Sampling::Interface.new
@@ -209,6 +228,13 @@ module Contrast
           @_track_original_object
         end
 
+        def track_response_as_source?
+          @track_response_as_source = !false?(enable_response_as_source) if
+            @track_response_as_source.nil?
+
+          @track_response_as_source
+        end
+
         # The id for this process, based on the session metadata or id provided by the user, as indicated in
         # application startup.
         def session_id
@@ -234,6 +260,7 @@ module Contrast
         end
 
         # Sets Event limits from configuration and converts string numbers to integers.
+        # @param hsh [Hash] the configuration hash
         def assign_limits hsh
           return unless hsh
 

data/lib/contrast/components/base.rb

@@ -3,6 +3,7 @@
 
 require 'contrast/config/diagnostics/tools'
 require 'contrast/utils/object_share'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Components
@@ -89,12 +90,13 @@ module Contrast
         add_effective_config_values(effective_config, config_values, canon_name, "#{ CONTRAST }.#{ canon_name }")
       end
 
-      # attempts to stringifys the config value if it is an array with the join char
+      # attempts to stringify the config value if it is an array with the join char
+      #
       # @param val[Object] val to stringify
       # @param join_char[String, ','] join character defaults to ','
       # @return [String, Object] the stringified val or the object as is
       def stringify_array val, join_char = ','
-        return val.join(join_char) if val.cs__is_a?(Array)
+        return val.join(join_char) if val.cs__is_a?(Array) && val.any?
 
         val
       end

data/lib/contrast/components/config.rb

@@ -24,8 +24,7 @@ module Contrast
     # it should break LOUDLY.  Better to waste half an hour of the sysadmin's
     # time than to silently fail to deliver functionality.
     module Config
-      CONTRAST_ENV_MARKER = 'CONTRAST__'
-      CONTRAST_LOG = 'contrast_agent.log'
+      CONTRAST_LOG = 'contrast.log'
       CONTRAST_NAME = 'Contrast Agent'
       DATE_TIME = '%Y-%m-%dT%H:%M:%S.%L%z'
 
@@ -63,7 +62,7 @@ module Contrast
           env_overrides
           validate
         rescue ArgumentError => e
-          proto_logger.error('Configuration failed with error: ', e)
+          proto_logger.error('[PROTO_LOGGER] Configuration failed with error: ', e)
         end
         alias_method :rebuild, :build
 
@@ -157,7 +156,7 @@ module Contrast
         # @return [boolean]
         def valid_session_metadata?
           if !session_id&.empty? && !session_metadata&.empty?
-            proto_logger.error(SESSION_VARIABLES)
+            proto_logger.error("[PROTO_LOGGER] #{ SESSION_VARIABLES }")
             return false
           end
           true
@@ -172,7 +171,7 @@ module Contrast
           msg << API_KEY unless api_key
           msg << API_SERVICE_KEY unless api_service_key
           msg << API_USERNAME unless api_username
-          msg.any? { |m| proto_logger.error(m) }
+          msg.any? { |m| proto_logger.error("[PROTO_LOGGER] #{ m }") }
           msg.empty?
         end
 
@@ -180,7 +179,8 @@ module Contrast
           # For env variables resembling CONTRAST__WHATEVER__NESTED_VALUE
           # override raw.whatever.nested_value
           ENV.each do |env_key, env_value|
-            next unless env_key.to_s.start_with?(CONTRAST_ENV_MARKER)
+            next unless env_key.to_s.start_with?(Contrast::Configuration::CONTRAST_ENV_MARKER)
+            next if Contrast::Configuration::DEPRECATED_PROPERTIES.include?(env_key.to_s)
 
             config_item = Contrast::Utils::EnvConfigurationItem.new(env_key, env_value)
             assign_value_to_path_array(self, config_item.dot_path_array, config_item.value)

data/lib/contrast/components/protect.rb

@@ -15,12 +15,14 @@ module Contrast
         include Contrast::Config::BaseConfiguration
 
         CANON_NAME = 'protect'
-        CONFIG_VALUES = %w[enabled?].cs__freeze
+        CONFIG_VALUES = %w[enabled? normalize_base64?].cs__freeze
         RULES = 'rules'
         MODE = 'mode'
 
         # @return [Boolean, nil]
         attr_accessor :enable
+        # @return [Boolean, nil]
+        attr_accessor :normalize_base64
         # @return [String]
         attr_reader :canon_name
         # @return [Array]
@@ -36,6 +38,7 @@ module Contrast
           @_exceptions = Contrast::Config::ExceptionConfiguration.new(hsh[:exceptions])
           @_rules = Contrast::Config::ProtectRulesConfiguration.new(hsh[:rules])
           @enable = hsh[:enable]
+          @normalize_base64 = hsh[:normalize_base64]
           @agent_lib = hsh[:agent_lib]
         end
 
@@ -68,6 +71,13 @@ module Contrast
           ::Contrast::SETTINGS.protect_state.enabled == true
         end
 
+        # Check to determine if the base64 decoding is required for user inputs.
+        def normalize_base64?
+          @normalize_base64 = Contrast::CONFIG.protect.normalize_base64 if @normalize_base64.nil?
+
+          true?(@normalize_base64)
+        end
+
         # Current Configuration for the protect rules
         #
         # @return [Contrast::Config::ProtectRulesConfiguration]

data/lib/contrast/components/sampling.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'contrast/components/base'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Components
@@ -27,7 +28,7 @@ module Contrast
             config_settings = ::Contrast::CONFIG.assess&.sampling
             settings = ::Contrast::SETTINGS&.assess_state&.sampling_settings
             {
-                enabled: enabled?(config_settings, settings),
+                enabled: enabled?(config_settings&.enable, settings&.enabled),
                 baseline: check_baseline(config_settings, settings),
                 request_frequency: check_request_frequency(config_settings, settings),
                 response_frequency: check_response_frequency(config_settings, settings),
@@ -43,13 +44,20 @@ module Contrast
 
         private
 
-        # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
+        # @param config_value [Boolean, nil] the Sampling configuration as provided by
         #   local user input
-        # @param settings [Contrast::Agent::Reporting::Settings::Sampling, nil] the Sampling settings as provided by
+        # @param settings_value [Boolean, nil] the Sampling settings as provided by
         # TeamServer
         # @return [Boolean] the resolution of the config_settings, settings, and default value
-        def enabled? config_settings, settings
-          true?([config_settings&.enable, settings&.enabled, DEFAULT_SAMPLING_ENABLED].compact[0])
+        def enabled? config_value, settings_value
+          # Check the Assess State received from TS:
+          sampling_enable = settings_value unless Contrast::Utils::DuckUtils.empty_duck?(settings_value)
+          # Check for local settings, YAML, ENV, CLI (it's with higher priority than Web Interface)
+          # see: https://docs.contrastsecurity.com/en/order-of-precedence.html
+          sampling_enable = config_value unless Contrast::Utils::DuckUtils.empty_duck?(config_value)
+          # Use default value, unless a false or true is set from local or TS settings.
+          sampling_enable = DEFAULT_SAMPLING_ENABLED if Contrast::Utils::DuckUtils.empty_duck?(sampling_enable)
+          true?(sampling_enable)
         end
 
         # @param config_settings [Contrast::Config::SamplingConfiguration] the Sampling configuration as provided by
@@ -106,6 +114,8 @@ module Contrast
         NAME_PREFIX = "#{ CONTRAST }.#{ CANON_NAME }".cs__freeze
         CONFIG_VALUES = %w[enable baseline request_frequency response_frequency window_ms].cs__freeze
 
+        # @return [Boolean, nil]
+        attr_accessor :enable
         # @return [Integer, nil]
         attr_accessor :baseline
         # @return [Integer, nil]
@@ -128,11 +138,6 @@ module Contrast
           @window_ms = hsh[:window_ms]
         end
 
-        # @return [Boolean, false]
-        def enable
-          !!@enable
-        end
-
         # Converts current configuration to effective config values class and appends them to
         # EffectiveConfig class.
         #

data/lib/contrast/config/diagnostics/command_line.rb

@@ -13,9 +13,9 @@ module Contrast
         class << self
           def command_line_settings
             cli = Contrast::Config::Diagnostics::Tools.flatten_settings(Contrast::CONFIG.sources.
-              for(Contrast::Components::Config::Sources::COMMAND_LINE))
+              for(Contrast::Components::Config::Sources::COMMAND_LINE), cli: true)
 
-            Contrast::Config::Diagnostics::Tools.to_config_values(cli, source: true)
+            Contrast::Config::Diagnostics::Tools.to_config_values(cli, source: true, cli: true)
           end
         end
       end

data/lib/contrast/config/diagnostics/environment_variables.rb

@@ -11,7 +11,9 @@ module Contrast
       # Reads All ENV variables.
       module EnvironmentVariables
         class << self
-          NON_COMMON_ENV = %w[CONTRAST_CONFIG_PATH CONTRAST_AGENT_TELEMETRY_OPTOUT].cs__freeze
+          NON_COMMON_ENV = %w[
+            CONTRAST_CONFIG_PATH CONTRAST_AGENT_TELEMETRY_OPTOUT CONTRAST_AGENT_TELEMETRY_TEST
+          ].cs__freeze
 
           # This method will fill the canonical name for each env var and will check for any uncommon ones.
           #
@@ -19,7 +21,7 @@ module Contrast
           # @return [Array] array of all the values needed to be written.
           def environment_settings env
             env_hash = env.select do |e|
-              e.to_s.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER) || NON_COMMON_ENV.include?(e.to_s)
+              e.to_s.start_with?(Contrast::Configuration::CONTRAST_ENV_MARKER) || NON_COMMON_ENV.include?(e.to_s)
             end
             environment_settings = []
             env_hash.each do |key, value|
@@ -39,6 +41,7 @@ module Contrast
                                                         Contrast::Utils::ObjectShare::EMPTY_STRING)
                 end
                 effective_value.value = Contrast::Config::Diagnostics::Tools.value_to_s(value)
+                effective_value.key = key
               end
               environment_settings << efc_value if efc_value
             end

data/lib/contrast/config/diagnostics/tools.rb

@@ -11,13 +11,15 @@ module Contrast
       # Diagnostics tools to be included in config components.
       module Tools
         CHECK = 'd'
+        CONTRAST_MARK = 'CONTRAST_'
         class << self
           # Creates new config instances for each read config entry from the flat generated configs.
           #
           # @param flats [Array] of flatten configs produced by #flatten_settings
           # @param source [Boolean] flag to set the desired value class, it may be a effective or source value.
+          # @param cli [Boolean] flag to check if the value comes from cli.
           # @return [Array<Contrast::Config::Diagnostics::SourceConfigValue>]
-          def to_config_values flats, source: false
+          def to_config_values flats, source: false, cli: false
             config_value_klass = if source
                                    Contrast::Config::Diagnostics::SourceConfigValue
                                  else
@@ -27,7 +29,11 @@ module Contrast
             flats.each do |entry|
               entry.each do |key, value|
                 efc_value = config_value_klass.new.tap do |config_value|
-                  config_value.canonical_name = Contrast::Utils::ObjectShare::CONTRAST_DOT + key
+                  config_value.canonical_name = Contrast::Utils::ObjectShare::CONTRAST_DOT + key unless cli
+                  if cli && key.to_s.include?(CONTRAST_MARK)
+                    config_value.canonical_name = key.gsub(Contrast::Utils::ObjectShare::DOUBLE_UNDERSCORE,
+                                                           Contrast::Utils::ObjectShare::PERIOD).downcase
+                  end
                   config_value.key = key
                   config_value.value = value_to_s(value)
                 end
@@ -40,17 +46,21 @@ module Contrast
           # Flattens out the read settings from file, env or contrast ui.
           # example: {"agent.polling.server_settings_ms"=>"50000"}
           #
+          # If cli is set we avoid adding the path and additional '.' to the key.
+          #
           #  @param data [Hash, nil]
           #  @param path  [String] where to look for settings.
           #  @param config [Hash] symbolized config to fetch keys from.
-          def flatten_settings data, path = [], config: Contrast::CONFIG.config.loaded_config
+          #  @param cli [Boolean] does the config come from cli.
+          def flatten_settings data, path = [], config: Contrast::CONFIG.config.loaded_config, cli: false
             return [] unless data
 
             data.each_with_object([]) do |(k, v), entries|
               if v.cs__is_a?(Hash)
                 entries.concat(flatten_settings(v, path.dup.append(k.to_sym)))
               else
-                entries << { "#{ path.join('.') }.#{ k }" => config.dig(*path, k).to_s }
+                entries << { k.to_s => config.dig(*path, k).to_s } if cli
+                entries << { "#{ path.join('.') }.#{ k }" => config.dig(*path, k).to_s } unless cli
               end
             end.flatten # rubocop:disable Style/MethodCalledOnDoEndBlock
           end
@@ -62,7 +72,7 @@ module Contrast
             return if value.nil?
             return value if value.cs__is_a?(String)
 
-            value.each_with_object({}) do |(k, v), m| # rubocop:disable Style/HashTransformValues
+            value&.each_with_object({}) do |(k, v), m| # rubocop:disable Style/HashTransformValues
               m[k] = if v.cs__is_a?(Hash)
                        value_to_s(v)
                      elsif v.cs__is_a?(Array)

data/lib/contrast/config/yaml_file.rb

@@ -11,6 +11,8 @@ module Contrast
     # instrumentation.
     module YamlFile
       CONFIG_FILE_NAME = 'contrast_security'
+      CONTRAST_ENV_MARKER = 'CONTRAST__'
+
       EXT = { yml: 'yml', yaml: 'yaml' }.freeze # rubocop:disable Security/Object/Freeze
 
       POSSIBLE_TARGET_PATHS = %w[
@@ -89,6 +91,8 @@ module Contrast
         #
         def create
           # rubocop:disable Rails/Output
+          return puts("\u{02C3}  Contrast configuration set by ENV variables.") if env_config_set?
+
           puts("\u{1F48E} Generating: Contrast Configuration file.")
           if Contrast::Config::YamlFile.created?
             puts("\u{2705}  Configuration file already exists: #{ Contrast::Config::YamlFile.find! }")
@@ -123,6 +127,10 @@ module Contrast
         def file_name
           ENV['CONTRAST_YAML_FILE_TEST_CREATE_CONFIG_FILE_NAME_VALUE'] || CONFIG_FILE_NAME
         end
+
+        def env_config_set?
+          ENV.keys&.select { |config| config.include?(CONTRAST_ENV_MARKER) }&.any?
+        end
       end
     end
   end

data/lib/contrast/configuration.rb

@@ -64,44 +64,29 @@ module Contrast
     KEYS_TO_REDACT = %i[api_key url service_key user_name].cs__freeze
     REDACTED = '**REDACTED**'
 
-    def initialize cli_options = nil, default_name = DEFAULT_YAML_PATH # rubocop:disable Metrics/AbcSize
+    DEPRECATED_PROPERTIES = %w[
+      CONTRAST__AGENT__SERVICE__ENABLE CONTRAST__AGENT__SERVICE__LOGGER__LEVEL
+      CONTRAST__AGENT__SERVICE__LOGGER__PATH CONTRAST__AGENT__SERVICE__LOGGER__STDOUT
+    ].cs__freeze
+
+    def initialize cli_options = nil, default_name = DEFAULT_YAML_PATH
       @default_name = default_name
 
       # Load config_kv from file
       config_kv = Contrast::Utils::HashUtils.deep_symbolize_all_keys(load_config)
-      unless cli_options
-        cli_options = {}
-        ENV.each do |key, value|
-          next unless key.to_s.start_with?(CONTRAST_ENV_MARKER)
 
-          cli_options[key] = value
-        end
-      end
-
-      # Overlay CLI options - they take precedence over config file
-      cli_options = Contrast::Utils::HashUtils.deep_symbolize_all_keys(cli_options)
-      if cli_options
-        config_kv = Contrast::Utils::HashUtils.precedence_merge(cli_options, config_kv)
-        @_source_file_extensions = Contrast::Utils::HashUtils.
-            precedence_merge(assign_source_to(cli_options,
-                                              Contrast::Components::Config::Sources::COMMAND_LINE),
-                             @_source_file_extensions)
-      end
+      # Load cli options from env
+      cli_options ||= cli_to_hash
+      config_kv = Contrast::Utils::HashUtils.precedence_merge(config_kv, cli_options)
+      update_sources_from_cli(cli_options)
 
       # Some in-flight rewrites to maintain backwards compatibility
       config_kv = update_prop_keys(config_kv)
+      @sources = Contrast::Components::Config::Sources.new(source_file_extensions)
       @loaded_config = config_kv
 
-      @sources = Contrast::Components::Config::Sources.new(@_source_file_extensions)
-
-      @api = Contrast::Components::Api::Interface.new(config_kv[:api])
-      @enable = config_kv[:enable]
-      @agent = Contrast::Components::Agent::Interface.new(config_kv[:agent])
-      @application = Contrast::Components::AppContext::Interface.new(config_kv[:application])
-      @server = Contrast::Config::ServerConfiguration.new(config_kv[:server])
-      @assess = Contrast::Components::Assess::Interface.new(config_kv[:assess])
-      @inventory = Contrast::Components::Inventory::Interface.new(config_kv[:inventory])
-      @protect = Contrast::Components::Protect::Interface.new(config_kv[:protect])
+      # requires loaded_config:
+      create_config_components
     end
 
     # Get a loggable YAML format of this configuration
@@ -155,7 +140,7 @@ module Contrast
     # reverse order of precedence (first is most important).
     def configuration_paths
       @_configuration_paths ||= begin
-        basename = default_name.split('.').first
+        basename = default_name.split('.')[0]
         # Order of extensions comes from here:
         extensions = Contrast::Components::Config::Sources::APP_CONFIGURATION_EXTENSIONS
 
@@ -263,6 +248,18 @@ module Contrast
 
     private
 
+    # Creates and updates the config components with the loaded config values.
+    def create_config_components
+      @api = Contrast::Components::Api::Interface.new(loaded_config[:api])
+      @enable = loaded_config[:enable]
+      @agent = Contrast::Components::Agent::Interface.new(loaded_config[:agent])
+      @application = Contrast::Components::AppContext::Interface.new(loaded_config[:application])
+      @server = Contrast::Config::ServerConfiguration.new(loaded_config[:server])
+      @assess = Contrast::Components::Assess::Interface.new(loaded_config[:assess])
+      @inventory = Contrast::Components::Inventory::Interface.new(loaded_config[:inventory])
+      @protect = Contrast::Components::Protect::Interface.new(loaded_config[:protect])
+    end
+
     # We cannot use all access components at this point, unfortunately, as they
     # may not have been initialized. Instead, we need to access the logger
     # directly.
@@ -367,5 +364,40 @@ module Contrast
         end
       end
     end
+
+    # Update the source mapping to reflect the cli values passed. Using raw string rather than path values.
+    #
+    # @param cli_options[Hash<Symbol, String>]
+    def update_sources_from_cli cli_options
+      @_source_file_extensions = Contrast::Utils::HashUtils.
+          precedence_merge(assign_source_to(cli_options,
+                                            Contrast::Components::Config::Sources::COMMAND_LINE),
+                           @_source_file_extensions)
+    end
+
+    # Find all the set Contrast environment variables and cast them to their hash form. Keys will be split on __ and
+    # converted to symbols to match parsing of the YAML file
+    #
+    # @return [Hash<Symbol, (Hash, String)>]
+    def cli_to_hash
+      cli_options ||= ENV.select do |name, _value|
+        name.to_s.start_with?(CONTRAST_ENV_MARKER) && !DEPRECATED_PROPERTIES.include?(name.to_s)
+      end
+
+      converted = {}
+      cli_options&.each do |key, value|
+        # Split the env key into path components
+        path = key.to_s.split(Contrast::Utils::ObjectShare::DOUBLE_UNDERSCORE)
+        # Remove the `CONTRAST` start
+        path&.shift
+        # Convert it to hash form, with lowercase symbol keys
+        as_hash = path&.reverse&.reduce(value) do |assigned_value, path_segment|
+          { path_segment.downcase.to_sym => assigned_value }
+        end
+        # And join it w/ the parsed keys
+        Contrast::Utils::HashUtils.precedence_merge!(converted, as_hash)
+      end
+      converted
+    end
   end
 end

data/lib/contrast/framework/rails/support.rb

@@ -4,6 +4,7 @@
 require 'contrast/framework/base_support'
 require 'contrast/framework/rails/patch/support'
 require 'contrast/utils/string_utils'
+require 'contrast/utils/duck_utils'
 
 module Contrast
   module Framework
@@ -129,6 +130,8 @@ module Contrast
             if engine_route?(route)
               new_req = retrieve_request(request.env)
               new_req.path_info = new_req.path_info.gsub(match.to_s, '')
+              # solves the issue when requiring base path '/' without the slash
+              new_req.path_info = '/' if Contrast::Utils::DuckUtils.empty_duck?(new_req.path_info)
               get_full_route(new_req, route.app.app.routes.router, path << match.to_s)
             else
               [match, params, route, path]

data/lib/contrast/logger/application.rb

@@ -17,8 +17,8 @@ module Contrast
         ENV.each do |env_key, env_value|
           env_key = env_key.to_s
           next unless ENV_KEYS.include?(env_key) ||
-              (env_key.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER) &&
-                  !env_key.start_with?("#{ Contrast::Components::Config::CONTRAST_ENV_MARKER }API"))
+              (env_key.start_with?(Contrast::Configuration::CONTRAST_ENV_MARKER) &&
+                  !env_key.start_with?("#{ Contrast::Configuration::CONTRAST_ENV_MARKER }API"))
 
           info('Environment settings', key: env_key, value: env_value)
         end
@@ -30,7 +30,7 @@ module Contrast
         loggable = ::Contrast::CONFIG.loggable
         info('Current configuration', configuration: loggable)
         env_keys = ENV.keys.select do |env_key|
-          env_key&.to_s&.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER)
+          env_key&.to_s&.start_with?(Contrast::Configuration::CONTRAST_ENV_MARKER)
         end
         env_items = env_keys.map { |env_key| Contrast::Utils::EnvConfigurationItem.new(env_key, nil) }
         env_translations = env_items.each_with_object({}) do |conversion, hash|