contrast-agent 6.8.0 → 6.9.0

data/lib/contrast/components/settings.rb

@@ -4,6 +4,7 @@
 require 'contrast/agent/excluder'
 require 'contrast/agent/reporting/settings/sensitive_data_masking'
 require 'contrast/components/config'
+require 'contrast/components/logger'
 
 module Contrast
   module Components
@@ -24,7 +25,8 @@ module Contrast
       SENSITIVE_DATA_MASKING_BASE = Contrast::Agent::Reporting::Settings::SensitiveDataMasking.new
 
       # This is a class.
-      class Interface
+      class Interface # rubocop:disable Metrics/ClassLength
+        include Contrast::Components::Logger::InstanceMethods
         extend Contrast::Components::Config
 
         # tainted_columns are database columns that receive unsanitized input.
@@ -68,6 +70,11 @@ module Contrast
         attr_reader :last_server_update_ms
         # @return [Contrast::Agent::Excluder] a wrapper around the exclusion rules for the application
         attr_reader :excluder
+        # @return [String] The last update but in string format used to build request header.
+        # This value should be sent be TS in the Last-Modified header to sync and save resources if the
+        # two dates are the same.
+        # format: <day-name>, <day> <month> <year> <hour>:<minute>:<second> GMT
+        attr_reader :server_settings_last_httpdate
 
         def initialize
           reset_state
@@ -83,11 +90,43 @@ module Contrast
 
           log_file = server_features.log_file
           log_level = server_features.log_level
+          # Update logger:
           Contrast::Logger::Log.instance.update(log_file, log_level) if log_file || log_level
-          @protect_state.enabled = server_features.protect.enabled?
-          @assess_state.enabled = server_features.assess.enabled?
-          @assess_state.sampling_settings = server_features.assess.sampling
+          # Update CEFlogger:
+          unless server_features.security_logger.settings_blank?
+            cef_logger.build_logger(server_features.security_logger.log_level, server_features.security_logger.log_file)
+          end
+          # TODO: RUBY-99999 Update Bot-Blocker from server settings - check enable value.
+          # For now all protection rules are rebuild on Application update. Bot blocker uses the default
+          # enable from the base rule, and update it's mode on app settings update.
+          # Here we receive also bots for that rule.
+          unless settings_empty?(server_features.protect.enabled?)
+            @protect_state.enabled = server_features.protect.enabled?
+            store_in_config(%i[protect enable], server_features.protect.enabled?)
+          end
+          update_assess_server_features(server_features.assess)
           @last_server_update_ms = Contrast::Utils::Timer.now_ms
+          # update via response header. We receive header from TS with last update info, setting the
+          # next request's header with the same time will save needless update of settings if there
+          # are no new server features updates after the said time.
+          @server_settings_last_httpdate = header_last_update
+        end
+
+        # Update Assess server features
+        #
+        # @param assess [Contrast::Agent::Reporting::Settings::AssessServerFeature]
+        def update_assess_server_features assess
+          return if settings_empty?(assess.enabled?)
+
+          @assess_state.enabled = assess.enabled?
+          store_in_config(%i[assess enable], assess.enabled?)
+          @assess_state.sampling_settings = assess.sampling
+
+          Contrast::Components::Sampling::Interface::CONFIG_VALUES.each do |field|
+            lookup_field = field == 'enable' ? :enabled : field.to_sym
+            store_in_config(Contrast::Components::Sampling::Interface::CANON_NAME.split('.') + [field.to_sym],
+                            assess.sampling.send(lookup_field))
+          end
         end
 
         # @param settings_response [Contrast::Agent::Reporting::Response]
@@ -118,12 +157,15 @@ module Contrast
 
           # Rules. They add themselves on initialize.
           Contrast::Agent::Protect::Rule::BotBlocker.new
-          Contrast::Agent::Protect::Rule::CmdInjection.new
+          cmdi = Contrast::Agent::Protect::Rule::CmdInjection.new
+          cmdi.sub_rules
           Contrast::Agent::Protect::Rule::Deserialization.new
           Contrast::Agent::Protect::Rule::HttpMethodTampering.new
           Contrast::Agent::Protect::Rule::NoSqli.new
-          Contrast::Agent::Protect::Rule::PathTraversal.new
-          Contrast::Agent::Protect::Rule::Sqli.new
+          path = Contrast::Agent::Protect::Rule::PathTraversal.new
+          path.sub_rules
+          sqli = Contrast::Agent::Protect::Rule::Sqli.new
+          sqli.sub_rules
           Contrast::Agent::Protect::Rule::UnsafeFileUpload.new
           Contrast::Agent::Protect::Rule::Xss.new
           Contrast::Agent::Protect::Rule::Xxe.new
@@ -174,6 +216,31 @@ module Contrast
 
           false
         end
+
+        # update via response header.
+        # Used to build the next request header.
+        #
+        # @return [String]
+        def header_last_update
+          Contrast::Agent.reporter.client.response_handler.last_server_modified
+        end
+
+        # Update the stored config values to ensure that we know about the correct values,
+        # and that the sources are correct for entries updated from the UI.
+        #
+        # @param parts [Array] the path to the setting in config
+        # @param value [String, Integer, Array, nil] the value for the configuration setting
+        def store_in_config parts, value
+          level = Contrast::CONFIG.config.loaded_config
+          parts[0...-1].each do |segment|
+            level[segment] ||= {}
+            level = level[segment]
+          end
+          return unless level.cs__is_a?(Hash)
+
+          level[parts[-1]] = value
+          Contrast::CONFIG.sources.set(parts.join('.'), Contrast::Components::Config::Sources::CONTRASTUI)
+        end
       end
     end
   end

data/lib/contrast/config/certification_configuration.rb

@@ -1,11 +1,17 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # Certificate Configuration
     class CertificationConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'api.certification'
+      CONFIG_VALUES = %w[ca_file cert_file key_file enable].cs__freeze
 
       # @return [String] path to CA Cert file
       attr_accessor :ca_file
@@ -28,6 +34,14 @@ module Contrast
       def enable
         @enable.nil? ? false : @enable
       end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        add_effective_config_values(effective_config, CONFIG_VALUES, CANON_NAME, CONTRAST)
+      end
     end
   end
 end

data/lib/contrast/config/config.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/config/effective_config'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # This class is responsible for logging to file the effective Agent configurations after startup.
+      class Config
+        attr_reader :effective_config
+
+        MESSAGE_FAIL = 'Unable to connect to Contrast, configuration details from the Contrast UI will not be included.'
+        MESSAGE_SUCCESSFUL = 'Connected to Contrast.'
+        CONN_STATUS_MSG_FAILURE = 'Unable to connect to Contrast, insufficient connection properties provided.'
+
+        def initialize
+          @effective_config = Contrast::Agent::DiagnosticsConfig::EffectiveConfig.new
+          @config_status = Contrast::Utils::ObjectShare::EMPTY_STRING
+        end
+
+        # This method will set the status from the request/response cycles
+        #
+        # @param response [Contrast::Agent::Reporting::Response]
+        def determine_config_status response
+          return unless response
+          # If we encounter for some of the startup events failure - always return failure
+          return if @config_status == MESSAGE_FAIL || CONN_STATUS_MSG_FAILURE
+
+          response_code = response.code.to_s
+          @config_status = response_code.starts_with?('2') ? MESSAGE_SUCCESSFUL : MESSAGE_FAIL
+          nil
+        end
+
+        # This method will set the status message from the config validation
+        def populate_fail_connection
+          @config_status = CONN_STATUS_MSG_FAILURE
+        end
+
+        def to_controlled_hash
+          @effective_config.to_controlled_hash.merge({ Status: @config_status })
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/diagnostics.rb

@@ -0,0 +1,114 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'contrast/utils/timer'
+require 'contrast/utils/log_utils'
+require 'contrast/components/logger'
+require 'contrast/utils/object_share'
+require 'contrast/config/config'
+require 'contrast/config/effective_config'
+require 'contrast/config/effective_config_value'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # This class is responsible for logging to file the effective Agent configurations after startup.
+      class Diagnostics
+        include Contrast::Components::Logger::InstanceMethods
+        include Contrast::Utils::LogUtils
+
+        # @return [String] path to write the file.
+        attr_reader :path
+
+        DEFAULT_PATH = File.join(Dir.pwd).cs__freeze
+        ERROR_MESSAGE = '[Configuration Diagnostics] Could not write effective Agent configuration to file'
+        FILE_NAME = 'contrast_connection.json'
+        WRITE = 'w+'
+
+        # @param path [String] path to write to file.
+        def initialize path
+          @path = path if path && !path.empty?
+        end
+
+        # Write current settings to file.
+        #
+        # @param reset [Boolean] should we reset the config we have
+        # @return [Boolean]
+        def write_to_file reset: true
+          logger&.info('[Configuration Diagnostics] Writing Effective Configurations to file', path: dir_name)
+          status = false
+          write_to_file_logic(status, reset: reset)
+        rescue IOError => e
+          logger&.warn(ERROR_MESSAGE, e)
+          false
+        end
+
+        def extract_settings
+          Contrast::AGENT.to_effective_config(config.effective_config)
+          Contrast::API.to_effective_config(config.effective_config)
+          Contrast::APP_CONTEXT.to_effective_config(config.effective_config)
+          Contrast::ASSESS.to_effective_config(config.effective_config)
+          Contrast::INVENTORY.to_effective_config(config.effective_config)
+          Contrast::PROTECT.to_effective_config(config.effective_config)
+        end
+
+        # Determine the path of the current logger and permissions required for
+        # writing to path.
+        #
+        # @return [String] Path
+        def dir_name
+          @_dir_name ||= if write_permission?(@path)
+                           File.dirname(File.absolute_path(@path))
+                         else
+                           DEFAULT_PATH
+                         end
+        rescue Errno::EROFS => e
+          logger.warn(ERROR_MESSAGE, e)
+        end
+
+        # Returns effective configurations of the agent.
+        #
+        # @return [Contrast::Agent::DiagnosticsConfig::Config]
+        def config
+          @_config ||= Contrast::Agent::DiagnosticsConfig::Config.new
+        end
+
+        # Reset the state of the current effective config.
+        def reset_config
+          @_config = Contrast::Agent::DiagnosticsConfig::Config.new
+        end
+
+        def to_controlled_hash
+          {
+              ReportCreate: report_create_time,
+              Config: config.to_controlled_hash
+          }
+        end
+
+        def write_to_file_logic status, reset: true
+          # We need to reset the config before updating it's values
+          reset_config if reset
+          extract_settings
+          File.open(File.join(dir_name, FILE_NAME), WRITE) do |file|
+            file.truncate(0)
+            file.write(JSON.pretty_generate(to_controlled_hash, { space: Contrast::Utils::ObjectShare::EMPTY_STRING }))
+            status = true if file
+            file.close
+          end
+          status
+        end
+
+        private
+
+        # Return current time in iso8601 format.
+        #
+        # @return [String] Time of creation
+        def report_create_time
+          Contrast::Utils::Timer.time_now
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/diagnostics_tools.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/utils/object_share'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # Diagnostics tools to be included in config components.
+      module DiagnosticsTools
+        CHECK = 'd'
+
+        # Converts current configuration for array of values to effective config values class and appends them to
+        # EffectiveConfig class. Must be used inside Config Components only.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        # @param config_values [Array<String>] array of the names of values.
+        # @param canonical_prefix [String] starting of the path to config => api.proxy...
+        # @param name_prefix [String] the name of the config prefix => contrast.api_key, contrast.url
+        def add_effective_config_values effective_config, config_values, canonical_prefix, name_prefix
+          return if config_values.to_s.empty?
+
+          config_values.each do |config|
+            Contrast::Agent::DiagnosticsConfig::EffectiveConfigValue.new.tap do |value|
+              next if (config_val = send(config.to_sym)).to_s.empty?
+
+              config_name = assign_name(config)
+              value.canonical_name = "#{ canonical_prefix }.#{ config_name }"
+              value.name = "#{ name_prefix }.#{ config_name }"
+              value.value = config_val
+              value.source = Contrast::CONFIG.sources.get(value.canonical_name)
+              if value.source == Contrast::Components::Config::Sources::YAML
+                value.filename = Contrast::CONFIG.config_file_path
+              end
+              effective_config.values << value
+            rescue StandardError => e
+              log_error(e)
+              next
+            end
+          end
+        end
+
+        # Converts current configuration for single value to effective config values class and appends them to
+        # EffectiveConfig class. Must be used inside Config Components only.
+        #
+        # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+        # @param config_name [String] name of the config.
+        # @param config_value [String, Boolean] value of the config.
+        # @param canonical_prefix [String] starting of the path to config => api.proxy...
+        # @param name_prefix [String] the name of the config prefix => contrast.api_key, contrast.url
+        def add_single_effective_value effective_config, config_name, config_value, canonical_prefix, name_prefix
+          Contrast::Agent::DiagnosticsConfig::EffectiveConfigValue.new.tap do |value|
+            break if config_value.to_s.empty?
+
+            value.value = config_value
+            value.canonical_name = "#{ canonical_prefix }.#{ config_name }"
+            value.name = "#{ name_prefix }.#{ config_name }"
+            value.source = Contrast::CONFIG.sources.get(value.canonical_name)
+            if value.source == Contrast::Components::Config::Sources::YAML
+              value.filename = Contrast::CONFIG.config_file_path
+            end
+            effective_config.values << value
+          rescue StandardError => e
+            log_error(e)
+            next
+          end
+        end
+
+        private
+
+        # Assigns a proper name for the config removing '?' out of method names.
+        #
+        # @param config [String] name of the configuration
+        # @return [String]
+        def assign_name config
+          return Contrast::Utils::ObjectShare::EMPTY_STRING unless config
+
+          name = config.dup
+          if name.end_with?(Contrast::Utils::ObjectShare::QUESTION_MARK)
+            # check and remove '?' : start_bundled_service? => start_bundled_service
+            name.delete!(Contrast::Utils::ObjectShare::QUESTION_MARK)
+            name.chop! if name.end_with?(CHECK)
+            name
+          end
+          name
+        end
+
+        # Logs any caught error.
+        #
+        # @param error [StandardError]
+        def log_error error
+          Contrast::CONFIG.proto_logger.warn('Could not write effective config to file: ',
+                                             error: error, backtrace: error.backtrace)
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/effective_config.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/config/effective_config_value'
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # The current effective config received from all authorized configuration channels.
+      class EffectiveConfig
+        # Value of effective agent configurations
+        #
+        # @return [Array]
+        attr_reader :values
+
+        def initialize
+          @values = []
+        end
+
+        def to_controlled_hash
+          {
+              EffectiveConfig: { values: @values&.map(&:to_controlled_hash) },
+              File: yaml_config_settings,
+              Environment: environment_settings,
+              CommandLine: command_line_settings,
+              ContrastUI: contrast_ui_settings
+          }
+        end
+
+        private
+
+        def yaml_config_settings
+          {
+              Path: Contrast::CONFIG.config_file_path,
+              Values: Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::YAML)
+          }
+        end
+
+        def command_line_settings
+          flatten_settings(Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::CLI))
+        end
+
+        def contrast_ui_settings
+          flatten_settings(Contrast::CONFIG.sources.for(Contrast::Components::Config::Sources::CONTRASTUI))
+        end
+
+        def flatten_settings data, path = []
+          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 }" => Contrast::CONFIG.config.loaded_config.dig(*path, k) }
+            end
+          end.flatten # rubocop:disable Style/MethodCalledOnDoEndBlock
+        end
+
+        def environment_settings
+          ENV.select { |e| e.to_s.start_with?(Contrast::Components::Config::CONTRAST_ENV_MARKER) }.
+              to_a.
+              map { |e| Hash[*e] }
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/effective_config_value.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+module Contrast
+  module Agent
+    module DiagnosticsConfig
+      # All In effect config values stored in a easy to write representation.
+      class EffectiveConfigValue
+        # @return [String] Name of the config starting form root of yaml config.
+        attr_accessor :canonical_name
+        # @return [String] Name of the config.
+        attr_accessor :name
+        # @return [String] Value set for the config.
+        attr_accessor :value
+        # @return [String] The source for the entry in the config.
+        attr_accessor :source
+        # @return [String,nil] The filename for the source of the config, if the source was "yaml".
+        attr_accessor :filename
+
+        def to_controlled_hash
+          {
+              canonical_name: canonical_name,
+              name: name, # rubocop:disable Security/Module/Name
+              value: value,
+              Source: source,
+              Filename: filename
+          }.compact
+        end
+      end
+    end
+  end
+end

data/lib/contrast/config/exception_configuration.rb

@@ -1,20 +1,32 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # Common Configuration settings. Those in this section pertain to the exception handling in Ruby, allowing for the
     # override of Response Code and Message when Security Exceptions are raised.
     class ExceptionConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
+
+      CANON_NAME = 'agent.ruby.exception'
+      CONFIG_VALUES = %w[capture override_status override_message].cs__freeze
 
       # @return [Integer] the HTTP status code override
       attr_accessor :override_status
       # @return [String] the message text override
       attr_accessor :override_message
       attr_writer :capture
+      # @return [String]
+      attr_reader :canon_name
+      # @return [Array]
+      attr_reader :config_values
 
       def initialize hsh = {}
+        @config_values = CONFIG_VALUES
+        @canon_name = CANON_NAME
         return unless hsh
 
         @capture = hsh[:capture]

data/lib/contrast/config/protect_rule_configuration.rb

@@ -40,7 +40,7 @@ module Contrast
       def applicable_mode
         return unless mode
 
-        case mode
+        case mode.downcase
         when 'permit'
           :PERMIT
         when 'block_at_perimeter'

data/lib/contrast/config/protect_rules_configuration.rb

@@ -11,13 +11,13 @@ module Contrast
 
       attr_accessor :disabled_rules
       attr_reader :bot_blocker,
-                  :cmd_injection, :cmdi_command_backdoors,
+                  :cmd_injection, :cmd_injection_command_backdoors,
                   :cmd_injection_semantic_chained_commands, :cmd_injection_semantic_dangerous_paths,
                   :method_tampering,
                   :nosql_injection,
                   :path_traversal, :path_traversal_semantic_file_security_bypass,
                   :reflected_xss,
-                  :sql_injection, :sqli_dangerous_function,
+                  :sql_injection, :sql_injection_semantic_dangerous_functions,
                   :unsafe_file_upload,
                   :untrusted_deserialization,
                   :xxe,
@@ -28,15 +28,16 @@ module Contrast
       def initialize hsh = {} # rubocop:disable Metrics/AbcSize
         return unless hsh
 
+        # IVs must be with the same name as rule_id
         @disabled_rules = hsh[:disabled_rules]
         @rule_base = Contrast::Config::ProtectRuleConfiguration.new(hsh[BASE_RULE.to_sym])
         @bot_blocker = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'bot-blocker'])
         @cmd_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection'])
-        @cmdi_command_backdoors =
+        @cmd_injection_command_backdoors =
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-command-backdoors'])
-        @cmdi_chained_command =
+        @cmd_injection_semantic_chained_commands =
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-semantic-chained-commands'])
-        @cmdi_dangerous_path =
+        @cmd_injection_semantic_dangerous_paths =
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'cmd-injection-semantic-dangerous-paths'])
         @method_tampering = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'method-tampering'])
         @nosql_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'nosql-injection'])
@@ -45,11 +46,11 @@ module Contrast
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'path-traversal-semantic-file-security-bypass'])
         @reflected_xss = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'reflected-xss'])
         @sql_injection = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'sql-injection'])
-        @sqli_dangerous_function =
+        @sql_injection_semantic_dangerous_functions =
           Contrast::Config::ProtectRuleConfiguration.new(hsh[:'sql-injection-semantic-dangerous-functions'])
         @unsafe_file_upload = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'unsafe-file-upload'])
         @untrusted_deserialization = Contrast::Config::ProtectRuleConfiguration.new(hsh[:'untrusted-deserialization'])
-        @xxe = Contrast::Config::ProtectRuleConfiguration.new(hsh[:xxe])
+        @xxe = Contrast::Config::ProtectRuleConfiguration.new(hsh['xxe'])
       end
 
       def []= key, value

data/lib/contrast/config/request_audit_configuration.rb

@@ -1,13 +1,18 @@
 # Copyright (c) 2022 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
+require 'contrast/components/base'
+
 module Contrast
   module Config
     # This class holds the Common Settings for the hidden functionality of the TS
     class RequestAuditConfiguration
       include Contrast::Config::BaseConfiguration
+      include Contrast::Components::ComponentBase
 
       DEFAULT_PATH = './messages'
+      CANON_NAME = 'api.request_audit'
+      CONFIG_VALUES = %w[enable requests responses path].cs__freeze
 
       attr_writer :enable, :requests, :responses, :path
 
@@ -39,6 +44,14 @@ module Contrast
       def path
         @path.nil? ? DEFAULT_PATH : @path
       end
+
+      # Converts current configuration to effective config values class and appends them to
+      # EffectiveConfig class.
+      #
+      # @param effective_config [Contrast::Agent::DiagnosticsConfig::EffectiveConfig]
+      def to_effective_config effective_config
+        add_effective_config_values(effective_config, CONFIG_VALUES, CANON_NAME, "#{ CONTRAST }.#{ CANON_NAME }")
+      end
     end
   end
 end