You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: config.rb
    path of file: ./repos/racecar/lib/racecar
    
    the code of the file until where you have to start completion: # frozen_string_literal: true

require "tmpdir"

require "king_konf"

require "racecar/liveness_probe"
require "racecar/instrumenter"
require "racecar/rebalance_listener"

module Racecar
  class Config < KingKonf::Config
    env_prefix :racecar

    STATISTICS_DISABLED_VALUE = 0

    desc "A list of Kafka brokers in the cluster that you're consuming from"
    list :brokers, default: ["localhost:9092"]

    desc "A string used to identify the client in logs and metrics"
    string :client_id, default: "racecar"

    desc "How frequently to commit offset positions"
    float :offset_commit_interval, default: 10

    desc "How often to send a heartbeat message to Kafka"
    float :heartbeat_interval, default: 10

    desc "The minimum number of messages in the local consumer queue"
    integer :min_message_queue_size, default: 2000

    desc "Which partition assignment strategy to use, range, roundrobin or cooperative-sticky. -- https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md"
    string :partition_assignment_strategy, default: "range,roundrobin"

    desc "Kafka consumer configuration options, separated with '=' -- https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md"
    list :consumer, default: []

    desc "Kafka producer configuration options, separated with '=' -- https://github.com/
    
    def rdkafka_consumer
      consumer_config = consumer.map do |param|
        param.split("=", 2).map(&:strip)
      end.to_h
      consumer_config.merge!(rdkafka_security_config)
      consumer_config
    end

    def rdkafka_producer
      producer_config = producer.map do |param|
        param.split("=", 2).map(&:strip)
      end.to_h
      producer_config.merge!(rdkafka_security_config)
      producer_config
    end

    def instrumenter
      @instrumenter ||= begin
        default_payload = { client_id: client_id, group_id: group_id }

        if defined?(ActiveSupport::Notifications)
          # ActiveSupport needs `concurrent-ruby` but doesn't `require` it.
          require 'concurrent/utility/monotonic_time'
          Instrumenter.new(backend: ActiveSupport::Notifications, default_payload: default_payload)
        else
          logger.warn "ActiveSupport::Notifications not available, instrumentation is disabled"
          NullInstrumenter
        end
      end
    end
    attr_writer :instrumenter

    def install_liveness_probe
      liveness_probe.tap(&:install)
    end

    def liveness_probe
      require "active_support/notifications"
      @liveness_probe ||= LivenessProbe.new(
        ActiveSupport::Notifications,
        liveness_probe_file_path,
        liveness_probe_max_interval
      )
    end

    private

    def rdkafka_security_config
      {
        "security.protocol" => security_protocol,
        "enable.ssl.certificate.verification" => ssl_verify_hostname,
        "ssl.ca.location" => ssl_ca_location,
        "ssl.crl.location" => ssl_crl_location,
        "ssl.keystore.location" => ssl_keystore_location,
        "ssl.keystore.password" => ssl_keystore_password,
        "ssl.certificate.location" => ssl_certificate_location,
        "ssl.key.location" => ssl_key_location,
        "ssl.key.password" => ssl_key_password,
        "sasl.mechanism" => sasl_mechanism,
        "sasl.kerberos.service.name" => sasl_kerberos_service_name,
        "sasl.kerberos.principal" => sasl_kerberos_principal,
        "sasl.kerberos.kinit.cmd" => sasl_kerberos_kinit_cmd,
        "sasl.kerberos.keytab" => sasl_kerberos_keytab,
        "sasl.kerberos.min.time.before.relogin" => sasl_kerberos_min_time_before_relogin,
        "sasl.username" => sasl_username,
        "sasl.password" => sasl_password,
      }.compact
    end
  end