Method dump_section_markdown has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

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

• Read up
  Read up

Method refresh_watchers has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def refresh_watchers
      target_paths_hash = expand_paths
      existence_paths_hash = existence_path

      log.debug {

• Read up
  Read up

Method <=> has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

        def <=>(o)
          timekey2 = o.timekey
          tag2 = o.tag
          variables2 = o.variables
          if (!!timekey ^ !!timekey2) || (!!tag ^ !!tag2) || (!!variables ^ !!variables2)

• Read up
  Read up

Method handle_connection has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_connection(conn)
      send_data = ->(serializer, data){ conn.write serializer.call(data) }

      log.trace "connected fluent socket", addr: conn.remote_addr, port: conn.remote_port
      state = :established

• Read up
  Read up

Method start has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

      def start
        super

        if @buffering.nil?
          @buffering = prefer_buffered_processing

• Read up
  Read up

Method initialize has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def initialize(format = nil, localtime = true, timezone = nil)
      if format.nil? && (timezone || !localtime)
        raise Fluent::ConfigError, "specifying timezone requires time format"
      end

• Read up
  Read up

Method run_supervisor has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def run_supervisor(dry_run: false)
      if dry_run
        $log.info "starting fluentd-#{Fluent::VERSION} as dry run mode", ruby: RUBY_VERSION
      end

• Read up
  Read up

Method hash_value has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def self.hash_value(val, opts = {}, name = nil)
      return nil if val.nil?

      param = if val.is_a?(String)
                val.start_with?('{') ? JSON.parse(val) : Hash[val.strip.split(/\s*,\s*/).map{|v| v.split(':', 2)}]

• Read up
  Read up

Method check_unused_section has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

      def self.check_unused_section(proxy, conf, plugin_class)
        elems = conf.respond_to?(:elements) ? conf.elements : []
        elems.each { |e|
          next if plugin_class.nil? && Fluent::Config::V1Parser::ELEM_SYMBOLS.include?(e.name) # skip pre-defined non-plugin elements because it doesn't have proxy section
          next if e.unused_in && e.unused_in.empty? # the section is used at least once

• Read up
  Read up

Method close has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

      def close
        while true
          pids = @_child_process_mutex.synchronize{ @_child_process_processes.keys }
          break if pids.size < 1

• Read up
  Read up

Method shutdown has 56 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def shutdown # Fluentd's shutdown sequence is stop, before_shutdown, shutdown, after_shutdown, close, terminate for plugins
      # These method callers does `rescue Exception` to call methods of shutdown sequence as far as possible
      # if plugin methods does something like infinite recursive call, `exit`, unregistering signal handlers or others.
      # Plugins should be separated and be in sandbox to protect data in each plugins/buffers.

File out_exec_filter.rb has 259 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'fluent/plugin/output'
require 'fluent/env'
require 'fluent/config/error'

require 'yajl'

Method server_create has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def server_create(title, port, proto: nil, bind: '0.0.0.0', shared: true, socket: nil, backlog: nil, tls_options: nil, max_bytes: nil, flags: 0, **socket_options, &callback)
        proto ||= (@transport_config && @transport_config.protocol == :tls) ? :tls : :tcp

        raise ArgumentError, "BUG: title must be a symbol" unless title && title.is_a?(Symbol)
        raise ArgumentError, "BUG: port must be an integer" unless port && port.is_a?(Integer)

Class EventTime has 21 methods (exceeds 20 allowed). Consider refactoring.

Open

  class EventTime
    TYPE = 0
    FORMATTER = Strftime.new('%Y-%m-%d %H:%M:%S.%N %z')

    def initialize(sec, nsec = 0)

Method enqueue_thread_run has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def enqueue_thread_run
        value_for_interval = nil
        if @flush_mode == :interval
          value_for_interval = @buffer_config.flush_interval
        end

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

Open

      def configure(conf)
        super

        @on_memory = false
        if @path

File filter_record_transformer.rb has 255 lines of code (exceeds 250 allowed). Consider refactoring.

Open

require 'socket'
require 'json'
require 'ostruct'

require 'fluent/plugin/filter'

Method preprocess_map has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

      def preprocess_map(value, force_stringify = false)
        new_value = nil
        if value.is_a?(String)
          if @auto_typecast && !force_stringify
            num_placeholders = value.scan('${').size

• Read up
  Read up

Method start has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def start
      super

      log.info "listening udp socket", bind: @bind, port: @port
      server_create(:in_udp_server, @port, proto: :udp, bind: @bind, resolve_name: !!@source_hostname_key, max_bytes: @message_length_limit, receive_buffer_size: @receive_buffer_size) do |data, sock|

• Read up
  Read up

Method process has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def process(tag, es)
      unless es.repeatable?
        m = Fluent::MultiEventStream.new
        es.each {|time,record|
          m.add(time, record)

• Read up
  Read up