contrast-agent 3.9.1 → 6.15.3

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

@@ -0,0 +1,109 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/agent/telemetry/base'
+require 'contrast/agent/telemetry/identifier'
+require 'contrast/config/env_variables'
+
+module Contrast
+  module Agent
+    # Tools for supporting the Telemetry feature
+    module Telemetry
+      DIR = '/etc/contrast/ruby-agent/'.cs__freeze
+      FILE = '.telemetry'.cs__freeze
+      CURRENT_DIR = Dir.pwd.cs__freeze
+      CONFIG_DIR = CURRENT_DIR + '/config/contrast/'.cs__freeze
+      MESSAGE = {
+          disclaimer:
+            "\n===================================================================================================" \
+            "\n\nThe [Contrast Security] [Ruby Agent] " \
+            "collects usage data in order to help us improve compatibility\n" \
+            "and security coverage. The data is anonymous and does not contain application data. It is collected\n" \
+            "by Contrast and is never shared. You can opt-out of telemetry by setting the\n" \
+            "'CONTRAST_AGENT_TELEMETRY_OPTOUT' environment variable to '1' or 'true'.\n" \
+            'Read more about [Contrast Security] [Ruby Agent] telemetry: ' \
+            "https://docs.contrastsecurity.com/en/ruby-telemetry.html \n\n" \
+            "===================================================================================================\n\n"
+      }.cs__freeze
+
+      # Here we create the .telemetry file. If the file exist we do nothing.
+      #
+      # @return[Boolean, nil] true if file is created, false if file already exist
+      # and nil if Telemetry is disabled or on unsupported OS.
+      def self.create_telemetry_file
+        write_mark_file(DIR, FILE, CONFIG_DIR)
+      end
+
+      # The telemetry disclaimer message, set if needed.
+      #
+      # @return [String]
+      def self.disclaimer
+        @_disclaimer = MESSAGE[:disclaimer]
+      end
+
+      # Determine if telemetry has been explicitly disabled by opt out or has been left running.
+      #
+      # @return [Boolean]
+      def self.exceptions_enabled?
+        @_exceptions_enabled = telemetry_exceptions_enabled? if @_exceptions_enabled.nil?
+        @_exceptions_enabled
+      end
+
+      class << self
+        include Contrast::Config::EnvVariables
+
+        private
+
+        # Create the mark file
+        #
+        # @param dir [String] Directory in which the file is to be created
+        # @param file [String] filename of the mark file
+        # @param config_dir [String] path for the config folder in working directory
+        # @return[Boolean, nil] true if file is created, false if file already exist
+        # and nil if Telemetry is disabled or on unsupported OS.
+        def write_mark_file dir, file, config_dir
+          return unless Contrast::Agent::Telemetry::Base.enabled?
+          return if Contrast::Utils::OS.windows?
+
+          @dir = dir
+          # After macOS Catalina, you can no longer store files or data in the read-only system volume,
+          # nor can we write to the "root" directory ( / ). This results in Errno::EROFS exception.
+          # So for the MacOS we would use the config directory of the instrumented application.
+          @dir = config_dir if Contrast::Utils::OS.mac?
+          return false if File.file?(@dir + file)
+          return true if touch_marker(@dir, file)
+
+          # If we don't have permission to write to root directory use config instead
+          touch_marker(config_dir, file)
+        end
+
+        # Touches .telemetry file
+        #
+        # @return[Boolean] true if success, false if fails
+        def touch_marker dir, file
+          FileUtils.mkdir_p(dir)
+          FileUtils.touch(dir + file)
+          File.file?(dir + file)
+        rescue StandardError => _e
+          false
+        end
+
+        # Determine if telemetry has been explicitly disabled by opt out or has been left running.
+        #
+        # @return [Boolean]
+        def telemetry_exceptions_enabled?
+          opts_out_telemetry = return_value(:telemetry_opt_outs).to_s
+          return false if opts_out_telemetry.casecmp?('true') || opts_out_telemetry == '1'
+          # Double check if telemetry is enabled, this includes a check for Agent enable setting in the
+          # config. In case of disabled Agent the queue won't be created and the Telemetry would not
+          # be enabled. This check is here to prevent a loop of error creations that could no be added
+          # to a queue ( because the client cannot be initialized if the Agent is disabled or settings are
+          # missing).
+          return false unless Contrast::Agent::Telemetry::Base.enabled?
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/contrast/agent/{thread.rb → thread/thread.rb}

@@ -1,15 +1,13 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-cs__scoped_require 'contrast/components/interface'
+require 'contrast/components/scope'
 
 module Contrast
   module Agent
-    # Threads used by Contrast.
+    # Threads used by Contrast. Any long running thread should be created and managed by our ThreadWatcher class.
     class Thread < ::Thread
-      include Contrast::Components::Interface
-
-      access_component :logging, :scope
+      include Contrast::Components::Scope::InstanceMethods
 
       # Make our internal code run in Contrast scope.
       def initialize *args

data/lib/contrast/agent/thread/thread_watcher.rb

@@ -0,0 +1,126 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/logger'
+require 'contrast/agent/reporting/report'
+require 'contrast/agent/reporting/reporting_workers/reporting_workers'
+require 'contrast/agent/telemetry/base'
+require 'contrast/agent/protect/input_analyzer/worth_watching_analyzer'
+require 'contrast/config/diagnostics'
+require 'contrast/utils/job_servers_running'
+
+module Contrast
+  module Agent
+    # This class used to ensure that our worker threads are running in multi-process environments
+    class ThreadWatcher
+      include Contrast::Components::Logger::InstanceMethods
+
+      # @return [Contrast::Utils::HeapDumpUtil]
+      attr_reader :heapdump_util
+      # @return [Contrast::Agent::Reporter]
+      attr_reader :reporter
+      # @return [Contrast::Agent::ReportingWorkers::ReporterHeartbeat]
+      attr_reader :reporter_heartbeat
+      # @return [Contrast::Agent::Protect::WorthWatchingInputAnalyzer]
+      attr_reader :worth_watching_analyzer
+      # @return [Contrast::Agent::ReportingWorkers::ServerSettingsWorker]
+      attr_reader :reporter_settings_worker
+      # @return [Contrast::Agent::ReportingWorkers::ApplicationServerWorker]
+      attr_reader :reporter_app_settings_worker
+
+      def initialize
+        if Contrast::AGENT.disabled? || Contrast::Utils::JobServersRunning.job_servers_running?
+          logger.info('Agent Disabled, shutting down all threads...')
+          return
+        end
+
+        @heapdump_util = Contrast::Utils::HeapDumpUtil.new
+        @reporter = Contrast::Agent::Reporter.new
+        @reporter_heartbeat = Contrast::Agent::ReportingWorkers::ReporterHeartbeat.new
+        @reporter_settings_worker = Contrast::Agent::ReportingWorkers::ServerSettingsWorker.new
+        @reporter_app_settings_worker = Contrast::Agent::ReportingWorkers::ApplicationServerWorker.new
+        @telemetry = Contrast::Agent::Telemetry::Base.new if Contrast::Agent::Telemetry::Base.enabled?
+        @worth_watching_analyzer = Contrast::Agent::Protect::WorthWatchingInputAnalyzer.new unless protect_disabled?
+      end
+
+      # @return [Array<Contrast::Agent::WorkerThread>] map of process to thread startup status
+      def startup!
+        check_before_start
+
+        return unless ::Contrast::AGENT.enabled?
+
+        logger.debug('ThreadWatcher started threads')
+
+        desired_threads.each do |thread|
+          init_thread(thread)
+        end
+      end
+
+      def ensure_running?
+        return if desired_threads.all?(&:running?)
+
+        logger.debug('ThreadWatcher - threads not running')
+        startup!
+      end
+
+      def shutdown!
+        heapdump_util&.stop!
+        telemetry_queue&.stop!
+        reporter&.stop!
+        reporter_heartbeat&.stop!
+        worth_watching_analyzer&.stop!
+        reporter_settings_worker&.stop!
+        reporter_app_settings_worker&.stop!
+      end
+
+      # @return [Contrast::Agent::Telemetry::Base]
+      def telemetry_queue
+        @telemetry
+      end
+
+      private
+
+      # Retrieve a list of the desired threads.
+      #
+      # @return [Array<Contrast::Agent::WorkerThread>]
+      def desired_threads
+        [reporter, reporter_heartbeat, reporter_settings_worker, reporter_app_settings_worker].tap do |entries|
+          entries.push(telemetry_queue) if Contrast::Agent::Telemetry::Base.enabled?
+          entries.push(worth_watching_analyzer) unless protect_disabled?
+        end
+      end
+
+      # Start the thread governed by the given watcher
+      #
+      # @param watcher [Contrast::Agent::ThreadWatcher]
+      # @return [Boolean] if the watched thread started successfully
+      def init_thread watcher
+        return unless watcher&.attempt_to_start?
+
+        unless watcher.running?
+          logger.debug('Attempting to start thread', type: watcher.to_s)
+          watcher.start_thread!
+        end
+        result = watcher.running?
+        logger.debug('Thread status', type: watcher.to_s, alive: result)
+        result
+      end
+
+      def protect_disabled?
+        ::Contrast::PROTECT.forcibly_disabled?
+      end
+
+      # This method will check the config and if the config is invalid - it will kill the agent
+      def check_before_start
+        return if Contrast::CONFIG.send(:validate)
+
+        @_diagnostics = Contrast::Agent::DiagnosticsConfig::Diagnostics.new(Contrast::AGENT.logger.path ||
+                                                                            Contrast::Components::Config::CONTRAST_LOG)
+        @_diagnostics.config.populate_fail_connection
+        @_diagnostics.write_to_file_logic(false, reset: false)
+        # kill agent
+        Contrast::AGENT.disable_agent!
+      end
+    end
+  end
+end

data/lib/contrast/agent/thread/worker_thread.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: true
+
+require 'contrast/components/logger'
+
+module Contrast
+  module Agent
+    # Base class for threads that do async processing
+    class WorkerThread
+      include Contrast::Components::Logger::InstanceMethods
+
+      def initialize
+        @_thread = nil
+      end
+
+      def running?
+        !!@_thread&.alive?
+      end
+
+      def stop!
+        return unless running?
+        return unless @_thread
+
+        Thread.kill(@_thread)
+        @_thread = nil
+      end
+
+      # Most threads, we always want to start. Some may be controlled by feature guards though, so we need to check.
+      #
+      # @return [Boolean]
+      def attempt_to_start?
+        Contrast::AGENT.enabled?
+      end
+
+      def clean_properties
+        logger.debug("Cleaning PROPERTIES_HASH size: #{ Contrast::Agent::Assess::Tracker::PROPERTIES_HASH.size }")
+        Contrast::Agent::Assess::Tracker.cleanup!
+        logger.debug("Cleaned PROPERTIES_HASH size: #{ Contrast::Agent::Assess::Tracker::PROPERTIES_HASH.size }")
+      end
+    end
+  end
+end

data/lib/contrast/agent/version.rb

@@ -1,8 +1,8 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
 module Contrast
   module Agent
-    VERSION = '3.9.1'
+    VERSION = '6.15.3'
   end
 end

data/lib/contrast/agent.rb

@@ -1,41 +1,49 @@
-# Copyright (c) 2020 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
 # frozen_string_literal: true
 
-cs__scoped_require 'English'
+require 'English'
 
 # This must precede other Contrast C extensions
-cs__scoped_require 'cs__common/cs__common'
-
-cs__scoped_require 'contrast/extensions/ruby_core/delegator'
-cs__scoped_require 'contrast/extensions/ruby_core/module'
-
-cs__scoped_require 'contrast/utils/object_share'
-cs__scoped_require 'contrast/utils/boolean_util'
-cs__scoped_require 'contrast/utils/string_utils'
-cs__scoped_require 'contrast/utils/io_util'
-cs__scoped_require 'contrast/utils/os'
-
-cs__scoped_require 'contrast/common_agent_configuration'
-
-cs__scoped_require 'contrast/utils/hash_digest'
-cs__scoped_require 'contrast/utils/invalid_configuration_util'
-
-cs__scoped_require 'contrast/utils/cache'
-
+require 'cs__common/cs__common'
+# This must precede any patching we do as we log patches and we shouldn't cause
+# requires to happen during that process.
+require 'contrast/components/logger'
+
+# defining instrumentation, this must precede core extensions
+# because they need to register their patches
+require 'contrast/agent/patching/policy/patcher'
+require 'contrast/agent/patching/policy/patch'
+
+# core extensions
+require 'contrast/extension/assess'
+require 'contrast/extension/delegator'
+require 'contrast/extension/inventory'
+require 'contrast/extension/module'
+require 'contrast/extension/protect'
+
+require 'contrast/utils/object_share'
+require 'contrast/utils/string_utils'
+require 'contrast/utils/io_util'
+require 'contrast/utils/os'
+
+require 'contrast/utils/hash_digest'
+require 'contrast/utils/invalid_configuration_util'
+
+# Collect findings
+require 'contrast/utils/findings'
+
+# Collect Exploites and Attacks
+require 'contrast/agent/protect/exploitable_collection'
 # scoping
-cs__scoped_require 'contrast/agent/scope'
+require 'contrast/agent/scope/scope'
 
-cs__scoped_require 'contrast/utils/thread_tracker'
-
-cs__scoped_require 'contrast/api'
-
-cs__scoped_require 'contrast/utils/resource_loader'
-cs__scoped_require 'contrast/utils/duck_utils'
-cs__scoped_require 'contrast/agent/tracepoint_hook'
-cs__scoped_require 'contrast/agent/at_exit_hook'
+require 'contrast/utils/thread_tracker'
 
 # Framework support
-cs__scoped_require 'contrast/framework/manager'
+require 'contrast/framework/manager'
+
+require 'contrast/agent/thread/thread_watcher'
+require 'contrast/utils/silence_maker'
 
 module Contrast
   # Top namespace of the Agent section. Holds tracking contexts that will be
@@ -43,48 +51,79 @@ module Contrast
   module Agent
     # build a map for tracking the context of the current request
     REQUEST_TRACKER = Contrast::Utils::ThreadTracker.new
+    FINDINGS = Contrast::Utils::Findings.new
+    EXPLOITS = Contrast::Agent::Protect::ExploitableCollection.new
 
+    # @return [Contrast::Framework::Manager]
     def self.framework_manager
+      reinitialize_with_log
       @_framework_manager ||= Contrast::Framework::Manager.new
     end
+
+    # @return [nil, Contrast::Utils::HeapDumpUtil]
+    def self.heapdump_util
+      thread_watcher.heapdump_util
+    end
+
+    # @return [nil, Contrast::Agent::Telemetry::Base]
+    def self.telemetry_queue
+      thread_watcher.telemetry_queue
+    end
+
+    # @return [Contrast::Agent::Reporter]
+    def self.reporter
+      thread_watcher.reporter
+    end
+
+    # @return [Contrast::Agent::Protect::WorthWatchingAnalyzer]
+    def self.worth_watching_analyzer
+      thread_watcher.worth_watching_analyzer
+    end
+
+    # @return [Contrast::Agent::ThreadWatcher]
+    def self.thread_watcher
+      @_thread_watcher ||= Contrast::Agent::ThreadWatcher.new
+    end
+
+    # Apparently by some unknown reason - if we have already some instance for the AgentLib - we can set the
+    # logger with options. That's why in rspec it started passing - because when we set the const in
+    # protect_spec_helper in the with AgentLib context - we've already set the AGENT_LIB constant.
+    #
+    # So that leads to this methods logic here, which somehow works
+    def self.reinitialize_with_log
+      return if Contrast::AGENT_LIB.enable_log
+
+      # Silence warning about reinit AgentLib
+      Contrast::Utils::SilenceMaker.hush do
+        Contrast.cs__const_set(:AGENT_LIB, Contrast::AgentLib::Interface.new(true, 2, nil))
+      end
+    end
   end
 end
 
-# keep tracker of logger updates
-cs__scoped_require 'contrast/agent/logger_manager'
+require 'contrast/utils/resource_loader'
+require 'contrast/utils/duck_utils'
+require 'contrast/agent/hooks/tracepoint_hook'
+require 'contrast/agent/hooks/at_exit_hook'
 
-# communication with contrast service
-cs__scoped_require 'contrast/agent/exclusion_matcher'
-cs__scoped_require 'contrast/agent/socket_client'
+require 'contrast/agent/excluder/exclusion_matcher'
 
-# config interface
-cs__scoped_require 'contrast/agent/feature_state'
-
-# threads that handle contrast scope
-cs__scoped_require 'contrast/agent/thread'
+# threads that handle contrast scoper
+require 'contrast/agent/thread/thread'
 
 # keep track of attacks
-cs__scoped_require 'contrast/agent/request_context'
-
-cs__scoped_require 'contrast/agent/assess'
+require 'contrast/agent/request/request_context'
 
-# Unconditional early-framework patches.
-# These happen regardless of analysis mode, & should be lightweight.
-cs__scoped_require 'contrast/utils/rack_assess_session_cookie'
-cs__scoped_require 'contrast/utils/rails_assess_configuration'
-# Also: should document the necessity of patching this ASAP.
-# In Rails, session configuration occurs extremely early & only once.
-# If we defer our patching of the rails session configuration too long
-# (i.e., where we normally patch) we will miss the configuration
-# and will never be able to report session misconfiguration rules.
-cs__scoped_require 'contrast/extensions/framework/rails/configuration' if defined?(Rails)
+require 'contrast/agent/assess/assess'
 
 # protect rules
-cs__scoped_require 'contrast/agent/protect/rule'
+require 'contrast/agent/protect/rule'
 
 # application libraries and technologies
-cs__scoped_require 'contrast/utils/gemfile_reader'
+require 'contrast/agent/inventory/inventory'
 
 # rack event monitoring
-cs__scoped_require 'contrast/agent/middleware'
-cs__scoped_require 'contrast/agent/railtie' if defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3
+require 'contrast/agent/middleware/middleware'
+
+# Install the patches we need before the application has a chance to initialize
+Contrast::Agent.framework_manager.before_load_patches!

data/lib/contrast/agent_lib/api/command_injection.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: false
+
+require 'ffi'
+# require the gem
+require 'contrast-agent-lib'
+
+module Contrast
+  module AgentLib
+    # This module is defined in Rust as external, we used it here.
+    # Initializes the AgentLib. Here will be all methods from
+    # the C bindings  contrast_c::cmdi_semantic_chained_command module.
+    module CommandInjection
+      extend FFI::Library
+      ffi_lib ContrastAgentLib::CONTRAST_C
+
+      attach_function :get_index_of_chained_command, [:string], :long_long
+      attach_function :does_command_contain_dangerous_path, [:string], :int
+
+      private
+
+      # Checks that a given shell command contained a chained command.
+      # This is used for the cmd-injection-semantic-chained-commands rule.
+      #
+      # @param cmd [String] command to check.
+      # @return index[Integer] Returns the index of the command chaining if found.
+      # If the chaining index is >= 0, an injection is detected. Returns -1 when
+      # no command chaining is found.
+      def dl__index_of_chained_command cmd
+        get_index_of_chained_command(cmd)
+      end
+
+      # Checks if a given shell command is trying to access a dangerous path.
+      # This is used for the cmd-injection-semantic-dangerous-paths rule.
+      #
+      # @param path [String] path to check.
+      # @return index[Boolean] Returns 1 if a dangerous path is found.
+      # Returns 0 if no dangerous paths are found.
+      def dl__dangerous_path? path
+        return false if does_command_contain_dangerous_path(path).zero?
+
+        true
+      end
+    end
+  end
+end

data/lib/contrast/agent_lib/api/init.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2023 Contrast Security, Inc. See https://www.contrastsecurity.com/enduser-terms-0317a for more details.
+# frozen_string_literal: false
+
+require 'ffi'
+# require the gem
+require 'contrast-agent-lib'
+
+module Contrast
+  module AgentLib
+    # This module is defined in Rust as external, we used it here.
+    # Initializes the AgentLib. Here will be all methods from
+    # the C bindings agent_init mod.
+    module Init
+      extend FFI::Library
+      ffi_lib ContrastAgentLib::CONTRAST_C
+
+      # Init
+      #
+      # 0 => OK, -1 => Err
+      # The attach function could be called also like this:
+      # attach_function :ruby_name, :c_name, [ :params ], :returns, { :options => values }
+      # an that way we define a ruby_name for the C method, but we alias to make a documentation
+      # for the method.
+      #
+      # Also we extend the FFI::Library inside this module so we could also redefine the
+      # attach_function to our taste, not worry about it leaking outside of this module.
+      #
+      # @param [Symbol] Name of required function.
+      # @param [Array] An array of argument types.
+      # @return [Integer] Return type of the function.
+      attach_function :init, [], :int
+
+      #  Initialize agent lib without any optional settings. To set optional settings consider using
+      # `init_with_options` instead If you want to enable logging, it must be set using environment variables
+      # `CONTRAST_AGENTLIB_LOG_LEVEL` - set to log level.  Must of one of ERROR, WARN, INFO, DEBUG or TRACE
+      # `CONTRAST_AGENTLIB_LOG_DIR` - must point to an accessible directory where logs will be written.
+      #  The name of the log file
+      # is auto-generated and cannot be set. The format is 'libcontrast_<date>_<process_id>.log'
+      #
+      # If these environment variables are not present during `init`, agent-lib will be initialized with
+      # logging disabled and you will not be able to re-enable it using `change_log_settings`
+      # @param [Symbol] Name of required function.
+      # @param [Array] An array of argument types.
+      # @return [Integer] Return type of the function.
+      attach_function :init_with_options, %i[bool string string], :int
+
+      # Change log settings for agent lib after it's been initialized.  This api must be used after init
+      #
+      # Safety
+      # The `log_level` parameter must point to must point to an UTF-8 encoded string C-string
+      # @param enable_logging [Boolean] flag to enable or disable logging.
+      # @param log_level [String] UTF-8 encoded string indicating the maximum log level
+      # if logging is enabled
+      attach_function :change_log_settings, %i[bool string], :int
+
+      # Initialize AgentLib with options.
+      # If init returns 0 = successful setup with options
+      # if init returns 1 = unsuccessful setup with options
+      #
+      # @param enable_logging [Boolean] flag to enable or disable logging.
+      # @param log_dir [String] path to existing log directory.
+      # @param log_level [String] OFF, ERROR, WARN, INFO, DEBUG or TRACE.
+      # @return [Boolean] true if initialized false if not.
+      def dl__init_with_options enable_logging, log_dir, log_level
+        # This is useful for scope sensitive string pointers, if function ends and
+        # you need them to be picked up after the C function.
+        init_with_options(enable_logging, log_dir, log_level).zero?
+      end
+
+      private
+
+      # Initialize AgentLib without options. Log level could not be set after.
+      # If you want to set the log levels you can do it be ENV variables:
+      # EVN [CONTRAST_AGENTLIB_LOG_LEVEL] - set to log level.  Must of one of ERROR, WARN, INFO, DEBUG or TRACE
+      # ENV['CONTRAST_AGENTLIB_LOG_DIR'] - must point to an accessible directory where logs will be written.
+      # The name of the log file.
+      #
+      # @return [Boolean] true if initialized, false if not.
+      def dl__init
+        init.zero?
+      end
+
+      # Change the log settings. This api must be called after the dl__init_with_options.
+      #
+      # @param enable_log [Boolean] flag to enable or disable logging this sets the inner flag.
+      # @param log_level [String] OFF, ERROR, WARN, INFO, DEBUG or TRACE.
+      # @return [Boolean] true if initialized false if not.
+      def dl__change_log_settings enable_log, log_level
+        return true if change_log_settings(enable_log, log_level).zero?
+
+        false
+      end
+    end
+  end
+end