Method resume has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def resume
        stage = {}
        queue = []
        exist_broken_file = false

Method configure has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def configure(conf)
        super

        @variable_store = Fluent::VariableStore.fetch_or_build(:buf_file)

Method formatter has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def self.formatter(timezone = nil, format = nil)
      if timezone.nil?
        return nil
      end

Method search has 45 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def search(type)
      # search from additional plugin directories
      if @dir_search_prefix
        path = "#{@dir_search_prefix}#{type}"
        files = @paths.filter_map { |lp|

Method dump_section_markdown has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  def dump_section_markdown(base_section, level = 0)
    dumped = ""
    if base_section[:section]
      sections = []
      params = base_section

Method configure has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def configure(conf)
        bufconf = CompatOutputUtils.buffer_section(conf)
        config_style = (bufconf ? :v1 : :v0)
        if config_style == :v0
          buf_params = {

Method configure_json_parser has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def configure_json_parser(name)
        case name
        when :oj
          raise LoadError unless Fluent::OjOptions.available?
          [Oj.method(:load), Oj::ParseError]

• Read up
  Read up

Method read_ack_from_sock has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def read_ack_from_sock(sock)
        begin
          raw_data = sock.instance_of?(Fluent::PluginHelper::Socket::WrappedSocket::TLS) ? sock.readpartial(@read_length) : sock.recv(@read_length)
        rescue Errno::ECONNRESET, EOFError # ECONNRESET for #recv, #EOFError for #readpartial
          raw_data = ''

• Read up
  Read up

Method rebuild_weight_array has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def rebuild_weight_array(nodes)
        standby_nodes, regular_nodes = nodes.select { |e| e.weight > 0 }.partition {|n|
          n.standby?
        }

• Read up
  Read up

Method parse has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def parse(text)
        m = REGEXP.match(text)
        unless m
          yield nil, nil
          return

• Read up
  Read up

Method try_write has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def try_write(chunk)
      tmpfile = nil
      prog = if chunk.respond_to?(:path)
               "#{@command} #{chunk.path}"
             else

• Read up
  Read up

Method check_ping has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def check_ping(message, remote_addr, user_auth_salt, nonce)
      log.debug "checking ping"
      # ['PING', self_hostname, shared_key_salt, sha512_hex(shared_key_salt + self_hostname + nonce + shared_key), username || '', sha512_hex(auth_salt + username + password) || '']
      unless message.size == 6 && message[0] == 'PING'
        return false, 'invalid ping message'

• Read up
  Read up

Method values_map has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

        def values_map(values)
          record = Hash[keys.zip(values.map { |value| convert_value_to_nil(value) })]

          if @time_key
            value = @keep_time_key ? record[@time_key] : record.delete(@time_key)

• Read up
  Read up

Method socket_option_set has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

      def socket_option_set(sock, resolve_name: nil, nonblock: false, linger_timeout: nil, recv_timeout: nil, send_timeout: nil, receive_buffer_size: nil, send_keepalive_packet: nil)
        unless resolve_name.nil?
          sock.do_not_reverse_lookup = !resolve_name
        end
        if nonblock

• Read up
  Read up

Method find has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def find(tag)
      pipeline = nil
      @match_rules.each_with_index { |rule, i|
        if rule.match?(tag)
          if rule.collector.is_a?(Plugin::Filter)

• Read up
  Read up

Method run_configure has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def run_configure(conf, dry_run: false)
      configure(conf)
      conf.check_not_fetched do |key, e|
        parent_name, plugin_name = e.unused_in
        message = if parent_name && plugin_name

• Read up
  Read up

Method initialize has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def initialize(logger, opts={})
      # When ServerEngine changes the logger.level, the Fluentd logger level should also change.
      # So overwrites logger.level= below.
      # However, currently Fluentd doesn't use the ServerEngine's reloading feature,
      # so maybe we don't need this overwriting anymore.

Method handle_notify has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def handle_notify
          return if limit_bytes_per_second_reached?
          return if group_watcher&.limit_lines_reached?(@path)

          with_io do |io|

Method configure has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def configure(conf)
      super

      @connection_cache = Array.new(actual_flush_thread_count, ConnectionCache.new("", nil)) if @reuse_connections

Consider simplifying this complex logical expression.

Open

      if MIN_MAX_AVAILABLE
        case
        when min_version.nil? && max_version.nil?
          min_version = METHODS_MAP[version] || version
          max_version = METHODS_MAP[version] || version