fluent/fluentd

Method write has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def write(chunk)
      path = extract_placeholders(@path_template, chunk)
      FileUtils.mkdir_p File.dirname(path), mode: @dir_perm

      writer = case

Method check_ping has 29 lines of code (exceeds 25 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'

Method gen_copy_proc has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def gen_copy_proc
      @copy_mode = :shallow if @deep_copy

      case @copy_mode
      when :no_copy

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

Open

    def configure(conf)
      super

      map = {}
      # <record></record> directive

Method install_main_process_command_handlers has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def install_main_process_command_handlers
      command_pipe = $stdin.dup
      $stdin.reopen(File::NULL, "rb")
      command_pipe.binmode
      command_pipe.sync = true

Method eval_include has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def eval_include(attrs, elems, uri)
        # replace space(s)(' ') with '+' to prevent invalid uri due to space(s).
        # See: https://github.com/fluent/fluentd/pull/2780#issuecomment-576081212
        u = URI.parse(uri.tr(' ', '+'))
        if u.scheme == 'file' || (!u.scheme.nil? && u.scheme.length == 1) || u.path == uri.tr(' ', '+') # file path

Method parse_dot_array_op has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        def self.parse_dot_array_op(key, param)
          start = key.index('[')
          result = if start.zero?
                     []
                   else

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      case
      when @parser.implement?(:parse_io)
        @parser.parse_io(io, &method(:on_record))
      when @parser.implement?(:parse_partial_data)
        until io.eof?

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

      case
      when @parser.implement?(:parse_io)
        @parser.parse_io(io, &method(:on_record))
      when @parser.implement?(:parse_partial_data)
        until io.eof?

• Read up
  Read up

Method initialize has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def initialize(target_info, pe, log, read_from_head, follow_inodes, update_watcher, line_buffer_timer_flusher, io_handler_build, metrics)

Method initialize has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

        def initialize(title, wait, timeout, forever, max_steps, randomize, randomize_width, secondary, secondary_threshold)

Method initialize has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

        def initialize(title, wait, timeout, forever, max_steps, randomize, randomize_width, secondary, secondary_threshold)

Method update_watcher has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def update_watcher(tail_watcher, pe, new_inode)
      # TODO we should use another callback for this.
      # To supress impact to existing logics, limit the case to `@follow_inodes`.
      # We may not need `@follow_inodes` condition.
      if @follow_inodes && new_inode.nil?

Method refresh_watchers has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def refresh_watchers
      target_paths_hash = expand_paths
      existence_paths_hash = existence_path

      log.debug {

Method read_messages has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def read_messages(conn, &block)
      feeder = nil
      serializer = nil
      bytes = 0
      conn.data do |data|

Method supervise has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def supervise
      Process.setproctitle("supervisor:#{@system_config.process_name}") if @system_config.process_name
      $log.info "starting fluentd-#{Fluent::VERSION}", pid: Process.pid, ruby: RUBY_VERSION

      fluentd_spawn_cmd = build_spawn_command

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

Open

        def initialize(title, wait, timeout, forever, max_steps, randomize, randomize_width, secondary, secondary_threshold)
          @title = title

          @start = current_time
          @steps = 0

Method default_options has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def self.default_options
      {
        config_path: Fluent::DEFAULT_CONFIG_PATH,
        plugin_dirs: [Fluent::DEFAULT_PLUGIN_DIR],
        log_level: Fluent::Log::LEVEL_INFO,

Method mount_proc has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def mount_proc(path, &block)
        @server.mount_proc(path) { |req, res|
          begin
            code, header, response = block.call(req, res)
          rescue => e

Method configure has 28 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 = {