fluentd 1.10.0-x64-mingw32 → 1.11.0-x64-mingw32

data/lib/fluent/plugin/out_copy.rb

@@ -61,7 +61,7 @@ module Fluent::Plugin
           output.emit_events(tag, @copy_proc ? @copy_proc.call(es) : es)
         rescue => e
           if @ignore_errors[i]
-            log.error "ignore emit error", error: e
+            log.error "ignore emit error in #{output.plugin_id}", error: e
           else
             raise e
           end

data/lib/fluent/plugin/out_file.rb

@@ -155,7 +155,7 @@ module Fluent::Plugin
         dummy_record_keys = get_placeholders_keys(@path_template) || ['message']
         dummy_record = Hash[dummy_record_keys.zip(['data'] * dummy_record_keys.size)]
 
-        test_chunk1 = chunk_for_test(dummy_tag, Fluent::Engine.now, dummy_record)
+        test_chunk1 = chunk_for_test(dummy_tag, Fluent::EventTime.now, dummy_record)
         test_path = extract_placeholders(@path_template, test_chunk1)
         unless ::Fluent::FileUtil.writable_p?(test_path)
           raise Fluent::ConfigError, "out_file: `#{test_path}` is not writable"

data/lib/fluent/plugin/out_forward.rb

@@ -324,7 +324,7 @@ module Fluent::Plugin
         end
       end
 
-      if @keepalive && @keepalive_timeout
+      if @keepalive
         timer_execute(:out_forward_keep_alived_socket_watcher, @keep_alive_watcher_interval, &method(:on_purge_obsolete_socks))
       end
     end
@@ -382,7 +382,12 @@ module Fluent::Plugin
           cert_logical_store_name: @tls_cert_logical_store_name,
           cert_use_enterprise_store: @tls_cert_use_enterprise_store,
 
-          linger_timeout: @send_timeout,
+          # Enabling SO_LINGER causes tcp port exhaustion on Windows.
+          # This is because dynamic ports are only 16384 (from 49152 to 65535) and
+          # expiring SO_LINGER enabled ports should wait 4 minutes
+          # where set by TcpTimeDelay. Its default value is 4 minutes.
+          # So, we should disable SO_LINGER on Windows to prevent flood of waiting ports.
+          linger_timeout: Fluent.windows? ? nil : @send_timeout,
           send_timeout: @send_timeout,
           recv_timeout: @ack_response_timeout,
           connect_timeout: @connect_timeout,
@@ -578,12 +583,7 @@ module Fluent::Plugin
 
       def verify_connection
         connect do |sock, ri|
-          if ri.state != :established
-            establish_connection(sock, ri)
-            if ri.state != :established
-              raise "Failed to establish connection to #{@host}:#{@port}"
-            end
-          end
+          ensure_established_connection(sock, ri)
         end
       end
 
@@ -652,14 +652,7 @@ module Fluent::Plugin
       def send_data(tag, chunk)
         ack = @ack_handler && @ack_handler.create_ack(chunk.unique_id, self)
         connect(nil, ack: ack) do |sock, ri|
-          if ri.state != :established
-            establish_connection(sock, ri)
-
-            if ri.state != :established
-              raise ConnectionClosedError, "failed to establish connection with node #{@name}"
-            end
-          end
-
+          ensure_established_connection(sock, ri)
           send_data_actual(sock, tag, chunk)
         end
 
@@ -684,7 +677,9 @@ module Fluent::Plugin
 
         case @sender.heartbeat_type
         when :transport
-          connect(dest_addr) do |_ri, _sock|
+          connect(dest_addr) do |sock, ri|
+            ensure_established_connection(sock, ri)
+
             ## don't send any data to not cause a compatibility problem
             # sock.write FORWARD_TCP_HEARTBEAT_DATA
 
@@ -714,7 +709,7 @@ module Fluent::Plugin
           @resolved_host ||= resolve_dns!
 
         else
-          now = Fluent::Engine.now
+          now = Fluent::EventTime.now
           rh = @resolved_host
           if !rh || now - @resolved_time >= @sender.expire_dns_cache
             rh = @resolved_host = resolve_dns!
@@ -776,6 +771,16 @@ module Fluent::Plugin
 
       private
 
+      def ensure_established_connection(sock, request_info)
+        if request_info.state != :established
+          establish_connection(sock, request_info)
+
+          if request_info.state != :established
+            raise ConnectionClosedError, "failed to establish connection with node #{@name}"
+          end
+        end
+      end
+
       def connect(host = nil, ack: false, &block)
         @connection_manager.connect(host: host || resolved_host, port: port, hostname: @hostname, ack: ack, &block)
       end

data/lib/fluent/plugin/out_forward/load_balancer.rb

@@ -56,7 +56,7 @@ module Fluent::Plugin
       end
 
       def rebuild_weight_array(nodes)
-        standby_nodes, regular_nodes = nodes.partition {|n|
+        standby_nodes, regular_nodes = nodes.select { |e| e.weight > 0 }.partition {|n|
           n.standby?
         }
 

data/lib/fluent/plugin/out_http.rb

@@ -37,6 +37,8 @@ module Fluent::Plugin
     config_param :proxy, :string, default: ENV['HTTP_PROXY'] || ENV['http_proxy']
     desc 'Content-Type for HTTP request'
     config_param :content_type, :string, default: nil
+    desc 'JSON array data format for HTTP request body'
+    config_param :json_array, :bool, default: false
     desc 'Additional headers for HTTP request'
     config_param :headers, :hash, default: nil
 
@@ -100,6 +102,13 @@ module Fluent::Plugin
       @proxy_uri = URI.parse(@proxy) if @proxy
       @formatter = formatter_create
       @content_type = setup_content_type unless @content_type
+
+      if @json_array
+        if @formatter_configs.first[:@type] != "json"
+          raise Fluent::ConfigError, "json_array option could be used with json formatter only"
+        end
+        define_singleton_method(:format, method(:format_json_array))
+      end
     end
 
     def multi_workers_ready?
@@ -114,6 +123,10 @@ module Fluent::Plugin
       @formatter.format(tag, time, record)
     end
 
+    def format_json_array(tag, time, record)
+      @formatter.format(tag, time, record) << ","
+    end
+
     def write(chunk)
       uri = parse_endpoint(chunk)
       req = create_request(chunk, uri)
@@ -128,7 +141,7 @@ module Fluent::Plugin
     def setup_content_type
       case @formatter_configs.first[:@type]
       when 'json'
-        'application/x-ndjson'
+        @json_array ? 'application/json' : 'application/x-ndjson'
       when 'csv'
         'text/csv'
       when 'tsv', 'ltsv'
@@ -202,7 +215,7 @@ module Fluent::Plugin
         req.basic_auth(@auth.username, @auth.password)
       end
       set_headers(req)
-      req.body = chunk.read
+      req.body = @json_array ? "[#{chunk.read.chop!}]" : chunk.read
       req
     end
 

data/lib/fluent/plugin/parser_multiline.rb

@@ -104,7 +104,7 @@ module Fluent
       end
 
       def firstline?(text)
-        @firstline_regex.match(text)
+        @firstline_regex.match?(text)
       end
 
       private

data/lib/fluent/plugin/parser_syslog.rb

@@ -63,16 +63,22 @@ module Fluent
       def initialize
         super
         @mutex = Mutex.new
-        @space_count = nil
+        @regexp = nil
+        @regexp3164 = nil
+        @regexp5424 = nil
+        @regexp_parser = nil
+        @time_parser_rfc3164 = nil
+        @time_parser_rfc5424 = nil
+        @space_count_rfc3164 = nil
         @space_count_rfc5424 = nil
+        @skip_space_count_rfc3164 = false
+        @skip_space_count_rfc5424 = false
+        @time_parser_rfc5424_without_subseconds = nil
       end
 
       def configure(conf)
         super
 
-        @time_parser_rfc3164 = @time_parser_rfc5424 = nil
-        @time_parser_rfc5424_without_subseconds = nil
-        @support_rfc5424_without_subseconds = false
         @regexp_parser = @parser_type == :regexp
         @regexp = case @message_format
                   when :rfc3164
@@ -85,27 +91,49 @@ module Fluent
                         alias_method :parse, :parse_rfc3164
                       end
                     end
+                    setup_time_parser_3164(@time_format)
                     RFC3164_WITHOUT_TIME_AND_PRI_REGEXP
                   when :rfc5424
-                    class << self
-                      alias_method :parse, :parse_rfc5424_regex
+                    if @regexp_parser
+                      class << self
+                        alias_method :parse, :parse_rfc5424_regex
+                      end
+                    else
+                      class << self
+                        alias_method :parse, :parse_rfc5424
+                      end
                     end
                     @time_format = @rfc5424_time_format unless conf.has_key?('time_format')
-                    @support_rfc5424_without_subseconds = true
+                    setup_time_parser_5424(@time_format)
                     RFC5424_WITHOUT_TIME_AND_PRI_REGEXP
                   when :auto
                     class << self
                       alias_method :parse, :parse_auto
                     end
-                    @time_parser_rfc3164 = time_parser_create(format: @time_format)
-                    @time_parser_rfc5424 = time_parser_create(format: @rfc5424_time_format)
+                    setup_time_parser_3164(@time_format)
+                    setup_time_parser_5424(@rfc5424_time_format)
                     nil
                   end
 
-        @space_count = @time_format.squeeze(' ').count(' ') + 1
-        @space_count_rfc5424 = @rfc5424_time_format.squeeze(' ').count(' ') + 1
-        @time_parser = time_parser_create
+        if @regexp_parser
+          @regexp3164 = RFC3164_WITHOUT_TIME_AND_PRI_REGEXP
+          @regexp5424 = RFC5424_WITHOUT_TIME_AND_PRI_REGEXP
+        end
+      end
+
+      def setup_time_parser_3164(time_fmt)
+        @time_parser_rfc3164 = time_parser_create(format: time_fmt)
+        if ['%b %d %H:%M:%S', '%b %d %H:%M:%S.%N'].include?(time_fmt)
+          @skip_space_count_rfc3164 = true
+        end
+        @space_count_rfc3164 = time_fmt.squeeze(' ').count(' ') + 1
+      end
+
+      def setup_time_parser_5424(time_fmt)
+        @time_parser_rfc5424 = time_parser_create(format: time_fmt)
         @time_parser_rfc5424_without_subseconds = time_parser_create(format: "%Y-%m-%dT%H:%M:%S%z")
+        @skip_space_count_rfc5424 = time_fmt.count(' ').zero?
+        @space_count_rfc5424 = time_fmt.squeeze(' ').count(' ') + 1
       end
 
       # this method is for tests
@@ -118,14 +146,13 @@ module Fluent
       end
 
       def parse_auto(text, &block)
-        if REGEXP_DETECT_RFC5424.match(text)
-          @regexp = RFC5424_WITHOUT_TIME_AND_PRI_REGEXP
-          @time_parser = @time_parser_rfc5424
-          @support_rfc5424_without_subseconds = true
-          parse_rfc5424_regex(text, &block)
+        if REGEXP_DETECT_RFC5424.match?(text)
+          if @regexp_parser
+            parse_rfc5424_regex(text, &block)
+          else
+            parse_rfc5424(text, &block)
+          end
         else
-          @regexp = RFC3164_WITHOUT_TIME_AND_PRI_REGEXP
-          @time_parser = @time_parser_rfc3164
           if @regexp_parser
             parse_rfc3164_regex(text, &block)
           else
@@ -134,6 +161,8 @@ module Fluent
         end
       end
 
+      SPLIT_CHAR = ' '.freeze
+
       def parse_rfc3164_regex(text, &block)
         idx = 0
         record = {}
@@ -151,22 +180,22 @@ module Fluent
 
         i = idx - 1
         sq = false
-        @space_count.times do
-          while text[i + 1] == ' '.freeze
+        @space_count_rfc3164.times do
+          while text[i + 1] == SPLIT_CHAR
             sq = true
             i += 1
           end
 
-          i = text.index(' '.freeze, i + 1)
+          i = text.index(SPLIT_CHAR, i + 1)
         end
 
-        time_str = sq ? text.slice(idx, i - idx).squeeze(' ') : text.slice(idx, i - idx)
-        time = @mutex.synchronize { @time_parser.parse(time_str) }
+        time_str = sq ? text.slice(idx, i - idx).squeeze(SPLIT_CHAR) : text.slice(idx, i - idx)
+        time = @mutex.synchronize { @time_parser_rfc3164.parse(time_str) }
         if @keep_time_key
           record['time'] = time_str
         end
 
-        parse_plain(time, text, i + 1, record, RFC3164_CAPTURES, &block)
+        parse_plain(@regexp3164, time, text, i + 1, record, RFC3164_CAPTURES, &block)
       end
 
       def parse_rfc5424_regex(text, &block)
@@ -175,7 +204,7 @@ module Fluent
 
         if @with_priority
           if (m = RFC5424_PRI_REGEXP.match(text))
-            record['pri'] = m['pri']
+            record['pri'] = m['pri'].to_i
             idx = m.end(0)
           else
             yield(nil, nil)
@@ -186,40 +215,36 @@ module Fluent
         i = idx - 1
         sq = false
         @space_count_rfc5424.times {
-          while text[i + 1] == ' '.freeze
+          while text[i + 1] == SPLIT_CHAR
             sq = true
             i += 1
           end
 
-          i = text.index(' '.freeze, i + 1)
+          i = text.index(SPLIT_CHAR, i + 1)
         }
 
-        time_str = sq ? text.slice(idx, i - idx).squeeze(' '.freeze) : text.slice(idx, i - idx)
+        time_str = sq ? text.slice(idx, i - idx).squeeze(SPLIT_CHAR) : text.slice(idx, i - idx)
         time = @mutex.synchronize do
           begin
-            @time_parser.parse(time_str)
+            @time_parser_rfc5424.parse(time_str)
           rescue Fluent::TimeParser::TimeParseError => e
-            if @support_rfc5424_without_subseconds
-              log.trace(e)
-              @time_parser_rfc5424_without_subseconds.parse(time_str)
-            else
-              raise
-            end
+            log.trace(e)
+            @time_parser_rfc5424_without_subseconds.parse(time_str)
           end
         end
 
         if @keep_time_key
           record['time'] = time_str
         end
-        parse_plain(time, text, i + 1, record, RFC5424_CAPTURES, &block)
+        parse_plain(@regexp5424, time, text, i + 1, record, RFC5424_CAPTURES, &block)
       end
 
       # @param time [EventTime]
       # @param idx [Integer] note: this argument is needed to avoid string creation
       # @param record [Hash]
       # @param capture_list [Array] for performance
-      def parse_plain(time, text, idx, record, capture_list, &block)
-        m = @regexp.match(text, idx)
+      def parse_plain(re, time, text, idx, record, capture_list, &block)
+        m = re.match(text, idx)
         if m.nil?
           yield nil, nil
           return
@@ -244,8 +269,6 @@ module Fluent
         yield time, record
       end
 
-      SPLIT_CHAR = ' '.freeze
-
       def parse_rfc3164(text, &block)
         pri = nil
         cursor = 0
@@ -264,20 +287,35 @@ module Fluent
           end
         end
 
-        # header part
-        time_size = 15 # skip Mmm dd hh:mm:ss
-        time_end = text[cursor + time_size]
-        if time_end == SPLIT_CHAR
-          time_str = text.slice(cursor, time_size)
-          cursor += 16 # time + ' '
-        elsif time_end == '.'.freeze
-          # support subsecond time
-          i = text.index(SPLIT_CHAR, time_size)
-          time_str = text.slice(cursor, i - cursor)
-          cursor = i + 1
+        if @skip_space_count_rfc3164
+          # header part
+          time_size = 15 # skip Mmm dd hh:mm:ss
+          time_end = text[cursor + time_size]
+          if time_end == SPLIT_CHAR
+            time_str = text.slice(cursor, time_size)
+            cursor += 16 # time + ' '
+          elsif time_end == '.'.freeze
+            # support subsecond time
+            i = text.index(SPLIT_CHAR, time_size)
+            time_str = text.slice(cursor, i - cursor)
+            cursor = i + 1
+          else
+            yield nil, nil
+            return
+          end
         else
-          yield nil, nil
-          return
+          i = cursor - 1
+          sq = false
+          @space_count_rfc3164.times do
+            while text[i + 1] == SPLIT_CHAR
+              sq = true
+              i += 1
+            end
+            i = text.index(SPLIT_CHAR, i + 1)
+          end
+
+          time_str = sq ? text.slice(idx, i - cursor).squeeze(SPLIT_CHAR) : text.slice(cursor, i - cursor)
+          cursor = i + 1
         end
 
         i = text.index(SPLIT_CHAR, cursor)
@@ -325,7 +363,130 @@ module Fluent
         msg.chomp!
         record['message'] = msg
 
-        time = @time_parser.parse(time_str)
+        time = @time_parser_rfc3164.parse(time_str)
+        record['time'] = time_str if @keep_time_key
+
+        yield time, record
+      end
+
+      NILVALUE = '-'.freeze
+
+      def parse_rfc5424(text, &block)
+        pri = nil
+        cursor = 0
+        if @with_priority
+          if text.start_with?('<'.freeze)
+            i = text.index('>'.freeze, 1)
+            if i < 2
+              yield nil, nil
+              return
+            end
+            pri = text.slice(1, i - 1).to_i
+            i = text.index(SPLIT_CHAR, i)
+            cursor = i + 1
+          else
+            yield nil, nil
+            return
+          end
+        end
+
+        # timestamp part
+        if @skip_space_count_rfc5424
+          i = text.index(SPLIT_CHAR, cursor)
+          time_str = text.slice(cursor, i - cursor)
+          cursor = i + 1
+        else
+          i = cursor - 1
+          sq = false
+          @space_count_rfc5424.times do
+            while text[i + 1] == SPLIT_CHAR
+              sq = true
+              i += 1
+            end
+            i = text.index(SPLIT_CHAR, i + 1)
+          end
+
+          time_str = sq ? text.slice(idx, i - cursor).squeeze(SPLIT_CHAR) : text.slice(cursor, i - cursor)
+          cursor = i + 1
+        end
+
+        # Repeat same code for the performance
+
+        # host part
+        i = text.index(SPLIT_CHAR, cursor)
+        unless i
+          yield nil, nil
+          return
+        end
+        slice_size = i - cursor
+        host = text.slice(cursor, slice_size)
+        cursor += slice_size + 1
+
+        # ident part
+        i = text.index(SPLIT_CHAR, cursor)
+        unless i
+          yield nil, nil
+          return
+        end
+        slice_size = i - cursor
+        ident = text.slice(cursor, slice_size)
+        cursor += slice_size + 1
+
+        # pid part
+        i = text.index(SPLIT_CHAR, cursor)
+        unless i
+          yield nil, nil
+          return
+        end
+        slice_size = i - cursor
+        pid = text.slice(cursor, slice_size)
+        cursor += slice_size + 1
+
+        # msgid part
+        i = text.index(SPLIT_CHAR, cursor)
+        unless i
+          yield nil, nil
+          return
+        end
+        slice_size = i - cursor
+        msgid = text.slice(cursor, slice_size)
+        cursor += slice_size + 1
+
+        record = {'host' => host, 'ident' => ident, 'pid' => pid, 'msgid' => msgid}
+        record['pri'] = pri if pri
+
+        # extradata part
+        ed_start = text[cursor]
+        if ed_start == NILVALUE
+          record['extradata'] = NILVALUE
+          cursor += 1
+        else
+          start = cursor
+          i = text.index('] '.freeze, cursor)
+          extradata = if i
+                        diff = i + 1 - start # calculate ']' position
+                        cursor += diff
+                        text.slice(start, diff)
+                      else  # No message part case
+                        cursor = text.bytesize
+                        text.slice(start, cursor)
+                      end
+          extradata.tr!("\\".freeze, ''.freeze)
+          record['extradata'] = extradata
+        end
+
+        # message part
+        if cursor != text.bytesize
+          msg = text.slice(cursor + 1, text.bytesize)
+          msg.chomp!
+          record['message'] = msg
+        end
+
+        time = begin
+                 @time_parser_rfc5424.parse(time_str)
+               rescue Fluent::TimeParser::TimeParseError => e
+                 @time_parser_rfc5424_without_subseconds.parse(time_str)
+               end
         record['time'] = time_str if @keep_time_key
 
         yield time, record