fluentd 1.12.4-x86-mingw32 → 1.13.3-x86-mingw32

data/lib/fluent/plugin/in_tail/position_file.rb

@@ -22,19 +22,18 @@ module Fluent::Plugin
       UNWATCHED_POSITION = 0xffffffffffffffff
       POSITION_FILE_ENTRY_REGEX = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.freeze
 
-      def self.load(file, follow_inodes, existing_paths, logger:)
-        pf = new(file, follow_inodes, existing_paths, logger: logger)
-        pf.load
+      def self.load(file, follow_inodes, existing_targets, logger:)
+        pf = new(file, follow_inodes, logger: logger)
+        pf.load(existing_targets)
         pf
       end
 
-      def initialize(file, follow_inodes, existing_paths, logger: nil)
+      def initialize(file, follow_inodes, logger: nil)
         @file = file
         @logger = logger
         @file_mutex = Mutex.new
         @map = {}
         @follow_inodes = follow_inodes
-        @existing_paths = existing_paths
       end
 
       def [](target_info)
@@ -60,8 +59,8 @@ module Fluent::Plugin
         end
       end
 
-      def load
-        compact
+      def load(existing_targets = nil)
+        compact(existing_targets)
 
         map = {}
         @file_mutex.synchronize do
@@ -118,9 +117,9 @@ module Fluent::Plugin
 
       private
 
-      def compact
+      def compact(existing_targets = nil)
         @file_mutex.synchronize do
-          entries = fetch_compacted_entries.values.map(&:to_entry_fmt)
+          entries = fetch_compacted_entries(existing_targets).values.map(&:to_entry_fmt)
 
           @file.pos = 0
           @file.truncate(0)
@@ -128,7 +127,7 @@ module Fluent::Plugin
         end
       end
 
-      def fetch_compacted_entries
+      def fetch_compacted_entries(existing_targets = nil)
         entries = {}
 
         @file.pos = 0
@@ -151,23 +150,26 @@ module Fluent::Plugin
             end
 
             if @follow_inodes
-              entries[ino] = Entry.new(path, pos, ino, file_pos + path.size + 1)
+              entries[ino] = Entry.new(path, pos, ino, file_pos + path.bytesize + 1)
             else
-              entries[path] = Entry.new(path, pos, ino, file_pos + path.size + 1)
+              entries[path] = Entry.new(path, pos, ino, file_pos + path.bytesize + 1)
             end
             file_pos += line.size
           end
         end
 
-        entries = remove_deleted_files_entries(entries, @existing_paths) if @follow_inodes
+        entries = remove_deleted_files_entries(entries, existing_targets) if @follow_inodes
         entries
       end
 
-      def remove_deleted_files_entries(existent_entries, existing_paths)
-        filtered_entries = existent_entries.select {|file_entry|
-          existing_paths.key?(file_entry)
-        }
-        filtered_entries
+      def remove_deleted_files_entries(existent_entries, existing_targets)
+        if existing_targets
+          existent_entries.select { |path_or_ino|
+            existing_targets.key?(path_or_ino)
+          }
+        else
+          existent_entries
+        end
       end
     end
 

data/lib/fluent/plugin/out_forward.rb

@@ -227,31 +227,14 @@ module Fluent::Plugin
         socket_cache: socket_cache,
       )
 
-      configs = []
-
-      # rewrite for using server as sd_static
-      conf.elements(name: 'server').each do |s|
-        s.name = 'service'
-      end
-
-      unless conf.elements(name: 'service').empty?
-        # To copy `services` element only
-        new_elem = Fluent::Config::Element.new('static_service_discovery', {}, {}, conf.elements(name: 'service'))
-        configs << { type: :static, conf: new_elem }
-      end
-
-      conf.elements(name: 'service_discovery').each_with_index do |c, i|
-        configs << { type: @service_discovery[i][:@type], conf: c }
-      end
-
-      service_discovery_create_manager(
+      service_discovery_configure(
         :out_forward_service_discovery_watcher,
-        configurations: configs,
+        static_default_service_directive: 'server',
         load_balancer: LoadBalancer.new(log),
         custom_build_method: method(:build_node),
       )
 
-      discovery_manager.services.each do |server|
+      service_discovery_services.each do |server|
         # it's only for test
         @nodes << server
         unless @heartbeat_type == :none
@@ -273,7 +256,7 @@ module Fluent::Plugin
         end
       end
 
-      if discovery_manager.services.empty?
+      if service_discovery_services.empty?
         raise Fluent::ConfigError, "forward output plugin requires at least one node is required. Add <server> or <service_discovery>"
       end
 
@@ -306,7 +289,7 @@ module Fluent::Plugin
 
       unless @heartbeat_type == :none
         if @heartbeat_type == :udp
-          @usock = socket_create_udp(discovery_manager.services.first.host, discovery_manager.services.first.port, nonblock: true)
+          @usock = socket_create_udp(service_discovery_services.first.host, service_discovery_services.first.port, nonblock: true)
           server_create_udp(:out_forward_heartbeat_receiver, 0, socket: @usock, max_bytes: @read_length, &method(:on_udp_heatbeat_response_recv))
         end
         timer_execute(:out_forward_heartbeat_request, @heartbeat_interval, &method(:on_heartbeat_timer))
@@ -318,7 +301,7 @@ module Fluent::Plugin
       end
 
       if @verify_connection_at_startup
-        discovery_manager.services.each do |node|
+        service_discovery_services.each do |node|
           begin
             node.verify_connection
           rescue StandardError => e
@@ -374,7 +357,7 @@ module Fluent::Plugin
       return if chunk.empty?
       tag = chunk.metadata.tag
 
-      discovery_manager.select_service { |node| node.send_data(tag, chunk) }
+      service_discovery_select_service { |node| node.send_data(tag, chunk) }
     end
 
     def try_write(chunk)
@@ -384,7 +367,7 @@ module Fluent::Plugin
         return
       end
       tag = chunk.metadata.tag
-      discovery_manager.select_service { |node| node.send_data(tag, chunk) }
+      service_discovery_select_service { |node| node.send_data(tag, chunk) }
       last_ack if @require_ack_response && @suspend_flush
     end
 
@@ -434,7 +417,7 @@ module Fluent::Plugin
 
     def statistics
       stats = super
-      services = discovery_manager.services
+      services = service_discovery_services
       healthy_nodes_count = 0
       registed_nodes_count = services.size
       services.each do |s|
@@ -471,7 +454,7 @@ module Fluent::Plugin
 
     def on_heartbeat_timer
       need_rebuild = false
-      discovery_manager.services.each do |n|
+      service_discovery_services.each do |n|
         begin
           log.trace "sending heartbeat", host: n.host, port: n.port, heartbeat_type: @heartbeat_type
           n.usock = @usock if @usock
@@ -486,16 +469,16 @@ module Fluent::Plugin
       end
 
       if need_rebuild
-        discovery_manager.rebalance
+        service_discovery_rebalance
       end
     end
 
     def on_udp_heatbeat_response_recv(data, sock)
       sockaddr = Socket.pack_sockaddr_in(sock.remote_port, sock.remote_host)
-      if node = discovery_manager.services.find { |n| n.sockaddr == sockaddr }
+      if node = service_discovery_services.find { |n| n.sockaddr == sockaddr }
         # log.trace "heartbeat arrived", name: node.name, host: node.host, port: node.port
         if node.heartbeat
-          discovery_manager.rebalance
+          service_discovery_rebalance
         end
       else
         log.warn("Unknown heartbeat response received from #{sock.remote_host}:#{sock.remote_port}. It may service out")
@@ -582,8 +565,6 @@ module Fluent::Plugin
           username: server.username || '',
         )
 
-        @unpacker = Fluent::MessagePackFactory.msgpack_unpacker
-
         @resolved_host = nil
         @resolved_time = 0
         @resolved_once = false
@@ -630,7 +611,7 @@ module Fluent::Plugin
               sleep @sender.read_interval
               next
             end
-            @unpacker.feed_each(buf) do |data|
+            Fluent::MessagePackFactory.msgpack_unpacker.feed_each(buf) do |data|
               if @handshake.invoke(sock, ri, data) == :established
                 @log.debug "connection established", host: @host, port: @port
               end

data/lib/fluent/plugin/parser_json.rb

@@ -15,8 +15,8 @@
 #
 
 require 'fluent/plugin/parser'
-require 'fluent/env'
 require 'fluent/time'
+require 'fluent/oj_options'
 
 require 'yajl'
 require 'json'
@@ -50,8 +50,7 @@ module Fluent
       def configure_json_parser(name)
         case name
         when :oj
-          require 'oj'
-          Oj.default_options = Fluent::DEFAULT_OJ_OPTIONS
+          raise LoadError unless Fluent::OjOptions.available?
           [Oj.method(:load), Oj::ParseError]
         when :json then [JSON.method(:load), JSON::ParserError]
         when :yajl then [Yajl.method(:load), Yajl::ParseError]

data/lib/fluent/plugin/service_discovery.rb

@@ -13,21 +13,6 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
-#
-# Fluentd
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
 
 require 'fluent/plugin/base'
 

data/lib/fluent/plugin_helper/http_server/router.rb

@@ -22,7 +22,7 @@ module Fluent
       class Router
         class NotFoundApp
           def self.call(req)
-            [404, { 'Content-Type' => 'text/plain' }, "404 Not Found: #{req.path}\n"]
+            [404, { 'Content-Type' => 'text/plain' }, "404 Not Found\n"]
           end
         end
 

data/lib/fluent/plugin_helper/service_discovery.rb

@@ -22,10 +22,19 @@ module Fluent
     module ServiceDiscovery
       include Fluent::PluginHelper::Timer
 
+      # For the compatibility with older versions without `param_name: :service_discovery_configs`
+      attr_reader :service_discovery
+
       def self.included(mod)
         mod.include ServiceDiscoveryParams
       end
 
+      def configure(conf)
+        super
+        # For the compatibility with older versions without `param_name: :service_discovery_configs`
+        @service_discovery = @service_discovery_configs
+      end
+
       def start
         unless @discovery_manager
           log.warn('There is no discovery_manager. skip start them')
@@ -52,6 +61,35 @@ module Fluent
 
       private
 
+      # @param title [Symbol] the thread name. this value should be unique.
+      # @param static_default_service_directive [String] the directive name of each service when "static" service discovery is enabled in default
+      # @param load_balancer [Object] object which has two methods #rebalance and #select_service
+      # @param custom_build_method [Proc]
+      def service_discovery_configure(title, static_default_service_directive: nil, load_balancer: nil, custom_build_method: nil, interval: 3)
+        configs = @service_discovery_configs.map(&:corresponding_config_element)
+        if static_default_service_directive
+          configs.prepend Fluent::Config::Element.new(
+            'service_discovery',
+            '',
+            {'@type' => 'static'},
+            @config.elements(name: static_default_service_directive.to_s).map{|e| Fluent::Config::Element.new('service', e.arg, e.dup, e.elements, e.unused) }
+          )
+        end
+        service_discovery_create_manager(title, configurations: configs, load_balancer: load_balancer, custom_build_method: custom_build_method, interval: interval)
+      end
+
+      def service_discovery_select_service(&block)
+        @discovery_manager.select_service(&block)
+      end
+
+      def service_discovery_services
+        @discovery_manager.services
+      end
+
+      def service_discovery_rebalance
+        @discovery_manager.rebalance
+      end
+
       # @param title [Symbol] the thread name. this value should be unique.
       # @param configurations [Hash] hash which must has discivery_service type and its configuration like `{ type: :static, conf: <Fluent::Config::Element> }`
       # @param load_balancer [Object] object which has two methods #rebalance and #select_service
@@ -78,7 +116,7 @@ module Fluent
       module ServiceDiscoveryParams
         include Fluent::Configurable
 
-        config_section :service_discovery do
+        config_section :service_discovery, multi: true, param_name: :service_discovery_configs do
           config_param :@type, :string
         end
       end

data/lib/fluent/plugin_helper/service_discovery/manager.rb

@@ -32,17 +32,23 @@ module Fluent
           @static_config = true
         end
 
-        def configure(opts, parent: nil)
-          opts.each do |opt|
-            sd = Fluent::Plugin.new_sd(opt[:type], parent: parent)
-            sd.configure(opt[:conf])
+        def configure(configs, parent: nil)
+          configs.each do |config|
+            type, conf = if config.has_key?(:conf) # for compatibility with initial API
+                           [config[:type], config[:conf]]
+                         else
+                           [config['@type'], config]
+                         end
+
+            sd = Fluent::Plugin.new_sd(type, parent: parent)
+            sd.configure(conf)
 
             sd.services.each do |s|
               @services[s.discovery_id] = build_service(s)
             end
             @discoveries << sd
 
-            if @static_config && opt[:type] != :static
+            if @static_config && type.to_sym != :static
               @static_config = false
             end
           end

data/lib/fluent/supervisor.rb

@@ -518,6 +518,8 @@ module Fluent
         dl_opts = {}
         # subtract 1 to match serverengine daemon logger side logging severity.
         dl_opts[:log_level] = @level - 1
+        dl_opts[:log_rotate_age] = @log_rotate_age if @log_rotate_age
+        dl_opts[:log_rotate_size] = @log_rotate_size if @log_rotate_size
         logger = ServerEngine::DaemonLogger.new(@logdev, dl_opts)
         $log = Fluent::Log.new(logger, @opts)
         $log.enable_color(false) if @path
@@ -606,6 +608,19 @@ module Fluent
 
       @cl_opt = opt
       @conf = nil
+      # parse configuration immediately to initialize logger in early stage
+      if @config_path and File.exist?(@config_path)
+        @conf = Fluent::Config.build(config_path: @config_path,
+                                     encoding: @conf_encoding ? @conf_encoding : 'utf-8',
+                                     additional_config: @inline_config ? @inline_config : nil,
+                                     use_v1_config: !!@use_v1_config)
+        @system_config = build_system_config(@conf)
+        if @system_config.log
+          @log_rotate_age ||= @system_config.log.rotate_age
+          @log_rotate_size ||= @system_config.log.rotate_size
+        end
+        @conf = nil
+      end
 
       log_opts = {suppress_repeated_stacktrace: opt[:suppress_repeated_stacktrace], ignore_repeated_log_interval: opt[:ignore_repeated_log_interval],
                   ignore_same_log_interval: opt[:ignore_same_log_interval]}

data/lib/fluent/system_config.rb

@@ -55,6 +55,20 @@ module Fluent
     config_section :log, required: false, init: true, multi: false do
       config_param :format, :enum, list: [:text, :json], default: :text
       config_param :time_format, :string, default: '%Y-%m-%d %H:%M:%S %z'
+      config_param :rotate_age, default: nil do |v|
+        if Fluent::Log::LOG_ROTATE_AGE.include?(v)
+          v.to_sym
+        else
+          begin
+            Integer(v)
+          rescue ArgumentError => e
+            raise Fluent::ConfigError, e.message
+          else
+            v.to_i
+          end
+        end
+      end
+      config_param :rotate_size, :size, default: nil
     end
 
     config_section :counter_server, multi: false do

data/lib/fluent/test/driver/storage.rb

@@ -0,0 +1,30 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/test/driver/base_owned'
+
+module Fluent
+  module Test
+    module Driver
+      class Storage < BaseOwned
+        def initialize(klass, **kwargs, &block)
+          super
+          @section_name = "storage"
+        end
+      end
+    end
+  end
+end