fluentd 0.10.53 → 0.10.54

data/test/config/test_section.rb

@@ -0,0 +1,102 @@
+require 'helper'
+require 'fluent/config/section'
+
+module Fluent::Config
+  class TestSection < ::Test::Unit::TestCase
+    sub_test_case Fluent::Config::Section do
+      sub_test_case 'class' do
+        sub_test_case '.name' do
+          test 'returns its full module name as String' do
+            assert_equal('Fluent::Config::Section', Fluent::Config::Section.name)
+          end
+        end
+      end
+
+      sub_test_case 'instance object' do
+        sub_test_case '#initialize' do
+          test 'creates blank object without argument' do
+            s = Fluent::Config::Section.new
+            assert_equal({}, s.instance_eval{ @params })
+          end
+
+          test 'creates object which contains specified hash object itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              class: 'normal',
+              keys: 5,
+            }
+            s1 = Fluent::Config::Section.new(hash)
+            assert_equal(hash, s1.instance_eval { @params })
+            assert_equal("tagomoris", s1[:name])
+            assert_equal(34, s1[:age])
+            assert_equal("email", s1[:send])
+            assert_equal("normal", s1[:class])
+            assert_equal(5, s1[:keys])
+
+            assert_equal("tagomoris", s1.name)
+            assert_equal(34, s1.age)
+            assert_equal("email", s1.send)
+            assert_equal("normal", s1.class)
+            assert_equal(5, s1.keys)
+
+            assert_raise(NoMethodError) { s1.dup }
+          end
+        end
+
+        sub_test_case '#to_h' do
+          test 'returns internal hash itself' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              class: 'normal',
+              keys: 5,
+            }
+            s = Fluent::Config::Section.new(hash)
+            assert_equal(hash, s.to_h)
+            assert_instance_of(Hash, s.to_h)
+          end
+        end
+
+        sub_test_case '#instance_of?' do
+          test 'can judge whether it is a Section object or not' do
+            s = Fluent::Config::Section.new
+            assert_true(s.instance_of?(Fluent::Config::Section))
+            assert_false(s.instance_of?(BasicObject))
+          end
+        end
+
+        sub_test_case '#is_a?' do
+          test 'can judge whether it belongs to or not' do
+            s = Fluent::Config::Section.new
+            assert_true(s.is_a?(Fluent::Config::Section))
+            assert_true(s.kind_of?(Fluent::Config::Section))
+            assert_true(s.is_a?(BasicObject))
+          end
+        end
+
+        sub_test_case '#+' do
+          test 'can merge 2 sections: argument side is primary, internal hash is newly created' do
+            h1 = {name: "s1", num: 10, class: "A"}
+            s1 = Fluent::Config::Section.new(h1)
+
+            h2 = {name: "s2", class: "A", num2: "5", num3: "8"}
+            s2 = Fluent::Config::Section.new(h2)
+            s = s1 + s2
+
+            assert_not_equal(h1.object_id, s.to_h.object_id)
+            assert_not_equal(h2.object_id, s.to_h.object_id)
+
+            assert_equal("s2", s.name)
+            assert_equal(10, s.num)
+            assert_equal("A", s.class)
+            assert_equal("5", s.num2)
+            assert_equal("8", s.num3)
+          end
+        end
+      end
+    end
+  end
+end

data/test/config/test_system_config.rb

@@ -0,0 +1,49 @@
+require 'helper'
+require 'fluent/configurable'
+require 'fluent/config/element'
+require 'fluent/config/section'
+require 'fluent/supervisor'
+
+module Fluent::Config
+  class TestSystemConfig < ::Test::Unit::TestCase
+    def parse_text(text)
+      basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
+      Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
+    end
+
+    test 'should not override default configurations when no parameters' do
+      conf = parse_text(<<EOS)
+<system>
+</system>
+EOS
+      sc = Fluent::Supervisor::SystemConfig.new(conf)
+      assert_nil(sc.log_level)
+      assert_nil(sc.suppress_repeated_stacktrace)
+      assert_nil(sc.emit_error_log_interval)
+      assert_nil(sc.suppress_config_dump)
+      assert_nil(sc.without_source)
+      assert_empty(sc.to_opt)
+    end
+
+    {'log_level' => 'error', 'suppress_repeated_stacktrace' => true, 'emit_error_log_interval' => 60, 'suppress_config_dump' => true, 'without_source' => true}.each { |k, v|
+      test "accepts #{k} parameter" do
+        conf = parse_text(<<EOS)
+<system>
+  #{k} #{v}
+</system>
+EOS
+        sc = Fluent::Supervisor::SystemConfig.new(conf)
+        assert_not_nil(sc.instance_variable_get("@#{k}"))
+        key = (k == 'emit_error_log_interval' ? :suppress_interval : k.to_sym)
+        assert_include(sc.to_opt, key)
+      end
+    }
+
+    {'foo' => 'bar', 'hoge' => 'fuga'}.each { |k, v|
+      test "should not affect settable parameters with unknown #{k} parameter" do
+        sc = Fluent::Supervisor::SystemConfig.new({k => v})
+        assert_empty(sc.to_opt)
+      end
+    }
+  end
+end

data/test/helper.rb

@@ -1,3 +1,28 @@
+# simplecov must be loaded before any of target code
+if ENV['SIMPLE_COV']
+  require 'simplecov'
+  if defined?(SimpleCov::SourceFile)
+    mod = SimpleCov::SourceFile
+    def mod.new(*args, &block)
+      m = allocate
+      m.instance_eval do
+        begin
+          initialize(*args, &block)
+        rescue Encoding::UndefinedConversionError
+          @src = "".force_encoding('UTF-8')
+        end
+      end
+      m
+    end
+  end
+  unless SimpleCov.running
+    SimpleCov.start do
+      add_filter '/test/'
+      add_filter '/gems/'
+    end
+  end
+end
+
 require 'test/unit'
 require 'fileutils'
 require 'fluent/log'

data/test/plugin/test_in_http.rb

@@ -157,7 +157,7 @@ class HttpInputTest < Test::Unit::TestCase
 
   def test_with_regexp
     d = create_driver(CONFIG + %[
-      format /^(?<field_1>\\\\d+):(?<field_2>\\\\w+)$/
+      format /^(?<field_1>\\d+):(?<field_2>\\w+)$/
       types field_1:integer
     ])
 

data/test/test_parser.rb

@@ -34,7 +34,7 @@ module ParserTest
       parser = TextParser::TimeParser.new(nil)
 
       [[], {}, nil, true, 10000].each { |v|
-        assert_raise ArgumentError do
+        assert_raise Fluent::TextParser::ParserError do
           parser.parse(v)
         end
       }
@@ -288,6 +288,12 @@ module ParserTest
         assert_nil time, "parser return nil w/o time and if specified so"
       }
     end
+
+    def test_call_with_invalid_time
+      assert_raise Fluent::TextParser::ParserError do
+        @parser.call('{"time":[],"k":"v"}') { |time, record| }
+      end
+    end
   end
 
   class NginxParserTest < ::Test::Unit::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluentd
 version: !ruby/object:Gem::Version
-  version: 0.10.53
+  version: 0.10.54
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-21 00:00:00.000000000 Z
+date: 2014-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -184,20 +184,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.15.3
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -240,6 +226,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
 description: Fluentd is an open source data collector designed to scale and simplify
   log management. It can collect, process and ship many kinds of data in near real-time.
 email:
@@ -266,6 +266,7 @@ files:
 - bin/fluent-debug
 - bin/fluent-gem
 - bin/fluentd
+- example/v1_literal_example.conf
 - fluent.conf
 - fluentd.gemspec
 - lib/fluent/buffer.rb
@@ -299,7 +300,6 @@ files:
 - lib/fluent/plugin.rb
 - lib/fluent/plugin/buf_file.rb
 - lib/fluent/plugin/buf_memory.rb
-- lib/fluent/plugin/buf_zfile.rb
 - lib/fluent/plugin/exec_util.rb
 - lib/fluent/plugin/in_debug_agent.rb
 - lib/fluent/plugin/in_exec.rb
@@ -334,15 +334,15 @@ files:
 - lib/fluent/test/input_test.rb
 - lib/fluent/test/output_test.rb
 - lib/fluent/version.rb
-- spec/config/config_parser_spec.rb
-- spec/config/configurable_spec.rb
-- spec/config/configure_proxy_spec.rb
-- spec/config/dsl_spec.rb
-- spec/config/helper.rb
-- spec/config/literal_parser_spec.rb
-- spec/config/section_spec.rb
-- spec/config/system_config_spec.rb
 - spec/spec_helper.rb
+- test/config/assertions.rb
+- test/config/test_config_parser.rb
+- test/config/test_configurable.rb
+- test/config/test_configure_proxy.rb
+- test/config/test_dsl.rb
+- test/config/test_literal_parser.rb
+- test/config/test_section.rb
+- test/config/test_system_config.rb
 - test/helper.rb
 - test/plugin/data/2010/01/20100102-030405.log
 - test/plugin/data/2010/01/20100102-030406.log
@@ -403,15 +403,15 @@ signing_key:
 specification_version: 4
 summary: Fluentd event collector
 test_files:
-- spec/config/config_parser_spec.rb
-- spec/config/configurable_spec.rb
-- spec/config/configure_proxy_spec.rb
-- spec/config/dsl_spec.rb
-- spec/config/helper.rb
-- spec/config/literal_parser_spec.rb
-- spec/config/section_spec.rb
-- spec/config/system_config_spec.rb
 - spec/spec_helper.rb
+- test/config/assertions.rb
+- test/config/test_config_parser.rb
+- test/config/test_configurable.rb
+- test/config/test_configure_proxy.rb
+- test/config/test_dsl.rb
+- test/config/test_literal_parser.rb
+- test/config/test_section.rb
+- test/config/test_system_config.rb
 - test/helper.rb
 - test/plugin/data/2010/01/20100102-030405.log
 - test/plugin/data/2010/01/20100102-030406.log

data/lib/fluent/plugin/buf_zfile.rb

@@ -1,84 +0,0 @@
-#
-# Fluent
-#
-# Copyright (C) 2011 FURUHASHI Sadayuki
-#
-#    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.
-#
-module Fluent
-
-
-class ZFileBufferChunk < FileBufferChunk
-  def initialize(path)
-    super(path)
-    @z = Zlib::Deflate.new
-  end
-
-  def <<(data)
-    zdata = @z.deflate(data, Z_NO_FLUSH)
-    unless zdata.empty?
-      super(zdata)
-    end
-  end
-
-  def close_write
-    zdata = @z.flush
-    unless zdata.empty?
-      @file.write(zdata)
-      @size += zdata.bytesize
-    end
-    super
-  end
-
-  def close
-    @z.close
-    super
-  end
-
-  def purge
-    @z.close
-    super
-  end
-
-  # TODO
-  #def open(&block)
-  #end
-end
-
-
-class ZFileBuffer < FileBuffer
-  # TODO
-  #Plugin.register_buffer('zfile', self)
-
-  def initialize
-    require 'zlib'
-    super
-  end
-
-  def resume_queue
-    queue = resume_queue_paths.map {|path|
-      ZFileBufferChunk.new(path)
-    }
-    top = new_chunk
-    return queue, top
-  end
-
-  def new_chunk
-    path = new_chunk_path
-    ZFileBufferChunk.new(path)
-  end
-end
-
-
-end
-

data/spec/config/config_parser_spec.rb

@@ -1,314 +0,0 @@
-require "json"
-require "config/helper"
-require "fluent/config/error"
-require "fluent/config/basic_parser"
-require "fluent/config/literal_parser"
-require "fluent/config/v1_parser"
-
-describe Fluent::Config::V1Parser do
-  include_context 'config_helper'
-
-  def read_config(path)
-    path = File.expand_path(path)
-    data = File.read(path)
-    Fluent::Config::V1Parser.parse(data, File.basename(path), File.dirname(path))
-  end
-
-  def parse_text(text)
-    basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
-    Fluent::Config::V1Parser.parse(text, '(test)', basepath, nil)
-  end
-
-  def root(*elements)
-    if elements.first.is_a?(Fluent::Config::Element)
-      attrs = {}
-    else
-      attrs = elements.shift || {}
-    end
-    Fluent::Config::Element.new('ROOT', '', attrs, elements)
-  end
-
-  def e(name, arg='', attrs={}, elements=[])
-    Fluent::Config::Element.new(name, arg, attrs, elements)
-  end
-
-  describe 'attribute parsing' do
-    it "parses attributes" do
-      expect(%[
-        k1 v1
-        k2 v2
-      ]).to be_parsed_as(e('ROOT', '', {"k1"=>"v1", "k2"=>"v2"}))
-    end
-
-    it "allows attribute without value" do
-      expect(%[
-        k1
-        k2 v2
-      ]).to be_parsed_as(e('ROOT', '', {"k1"=>"", "k2"=>"v2"}))
-    end
-
-    it "parses attribute key always string" do
-      expect("1 1").to be_parsed_as(e('ROOT', '', {"1" => "1"}))
-    end
-
-    [
-      "_.%$!,",
-      "/=~-~@\`:?",
-      "()*{}.[]",
-    ].each do |v|
-      it "parses a value with symbol #{v.inspect}" do
-        expect("k #{v}").to be_parsed_as(e('ROOT', '', {"k" => v}))
-      end
-    end
-
-    it "ignores spacing around value" do
-      expect("  k1     a    ").to be_parsed_as(e('ROOT', '', {"k1" => "a"}))
-    end
-
-    it "allows spaces in value" do
-      expect("k1 a  b  c").to be_parsed_as(e('ROOT', '', {"k1" => "a  b  c"}))
-    end
-
-    it "ignores comments after value" do
-      expect("  k1 a#comment").to be_parsed_as(e('ROOT', '', {"k1" => "a"}))
-    end
-
-    it "allows # in value if quoted" do
-      expect('  k1 "a#comment"').to be_parsed_as(e('ROOT', '', {"k1" => "a#comment"}))
-    end
-
-    it "rejects characters after quoted string" do
-      expect('  k1 "a" 1').to be_parse_error
-    end
-
-    it "rejects @ prefix in parameter name" do
-      expect('  @k v').to be_parse_error
-    end
-  end
-
-  describe 'element parsing' do
-    it do
-      expect("").to be_parsed_as(root)
-    end
-
-    it "accepts empty element" do
-      expect(%[
-        <test>
-        </test>
-      ]).to be_parsed_as(
-        root(
-          e("test")
-        )
-      )
-    end
-
-    it "accepts argument and attributes" do
-      expect(%[
-        <test var>
-          key val
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>"val"})
-        ))
-    end
-
-    it "accepts nested elements" do
-      expect(%[
-        <test var>
-          key 1
-          <nested1>
-          </nested1>
-          <nested2>
-          </nested2>
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>'1'}, [
-            e('nested1'),
-            e('nested2')
-          ])
-        ))
-    end
-
-    it "accepts multiline json values" do
-      expect(%[
-        <test var>
-          key ["a",
-"b", "c",
-"d"]
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>"[\"a\",\"b\",\"c\",\"d\"]"})
-      ))
-    end
-
-    [
-      "**",
-      "*.*",
-      "1",
-      "_.%$!",
-      "/",
-      "()*{}.[]",
-    ].each do |arg|
-      it "parses element argument #{arg.inspect}" do
-        expect(%[
-          <test #{arg}>
-          </test>
-        ]).to be_parsed_as(root(
-            e("test", arg)
-          ))
-      end
-    end
-
-    it "parses empty element argument to nil" do
-      expect(%[
-        <test >
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", '')
-        ))
-    end
-
-    it "ignores spacing around element argument" do
-      expect(%[
-        <test    a    >
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", "a")
-        ))
-    end
-
-    it "considers comments in element argument" do
-      expect(%[
-        <test #a>
-        </test>
-      ]).to be_parse_error
-    end
-
-    it "requires line_end after begin tag" do
-      expect(%[
-        <test></test>
-      ]).to be_parse_error
-    end
-
-    it "requires line_end after end tag" do
-      expect(%[
-        <test>
-        </test><test>
-        </test>
-      ]).to be_parse_error
-    end
-  end
-
-  # port from test_config.rb
-  describe '@include parsing' do
-    TMP_DIR = File.dirname(__FILE__) + "/tmp/v1_config#{ENV['TEST_ENV_NUMBER']}"
-
-    def write_config(path, data)
-      FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, "w") { |f| f.write data }
-    end
-
-    def prepare_config
-      write_config "#{TMP_DIR}/config_test_1.conf", %[
-        k1 root_config
-        include dir/config_test_2.conf  #
-        @include #{TMP_DIR}/config_test_4.conf
-        include file://#{TMP_DIR}/config_test_5.conf
-        @include config.d/*.conf
-      ]
-      write_config "#{TMP_DIR}/dir/config_test_2.conf", %[
-        k2 relative_path_include
-        @include ../config_test_3.conf
-      ]
-      write_config "#{TMP_DIR}/config_test_3.conf", %[
-        k3 relative_include_in_included_file
-      ]
-      write_config "#{TMP_DIR}/config_test_4.conf", %[
-        k4 absolute_path_include
-      ]
-      write_config "#{TMP_DIR}/config_test_5.conf", %[
-        k5 uri_include
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_6.conf", %[
-        k6 wildcard_include_1
-        <elem1 name>
-          include normal_parameter
-        </elem1>
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_7.conf", %[
-        k7 wildcard_include_2
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_8.conf", %[
-        <elem2 name>
-          @include ../dir/config_test_9.conf
-        </elem2>
-      ]
-      write_config "#{TMP_DIR}/dir/config_test_9.conf", %[
-        k9 embeded
-        <elem3 name>
-          nested nested_value
-          include hoge
-        </elem3>
-      ]
-      write_config "#{TMP_DIR}/config.d/00_config_test_8.conf", %[
-        k8 wildcard_include_3
-        <elem4 name>
-          include normal_parameter
-        </elem4>
-      ]
-    end
-
-    it 'parses @include / include correctly' do
-      prepare_config
-      c = read_config("#{TMP_DIR}/config_test_1.conf")
-      expect(c['k1']).to eq('root_config')
-      expect(c['k2']).to eq('relative_path_include')
-      expect(c['k3']).to eq('relative_include_in_included_file')
-      expect(c['k4']).to eq('absolute_path_include')
-      expect(c['k5']).to eq('uri_include')
-      expect(c['k6']).to eq('wildcard_include_1')
-      expect(c['k7']).to eq('wildcard_include_2')
-      expect(c['k8']).to eq('wildcard_include_3')
-      expect(c.keys).to eq([
-        'k1',
-        'k2',
-        'k3',
-        'k4',
-        'k5',
-        'k8', # Because of the file name this comes first.
-        'k6',
-        'k7',
-      ])
-
-      elem1 = c.elements.find { |e| e.name == 'elem1' }
-      expect(elem1).to be
-      expect(elem1.arg).to eq('name')
-      expect(elem1['include']).to eq('normal_parameter')
-
-      elem2 = c.elements.find { |e| e.name == 'elem2' }
-      expect(elem2).to be
-      expect(elem2.arg).to eq('name')
-      expect(elem2['k9']).to eq('embeded')
-      expect(elem2.has_key?('include')).to be(false)
-
-      elem3 = elem2.elements.find { |e| e.name == 'elem3' }
-      expect(elem3).to be
-      expect(elem3['nested']).to eq('nested_value')
-      expect(elem3['include']).to eq('hoge')
-    end
-
-    # TODO: Add uri based include spec
-  end
-
-  describe 'unescape parameter' do
-    it 'parses dumpped configuration' do
-      original = %q!a\\\\\n\r\f\b\\'\\"z!
-      expected = %!a\\\n\r\f\b'"z!
-
-      conf = parse_text(%[k1 #{original}])
-      expect(conf['k1']).to eq(expected) # escape check
-      conf2 = parse_text(conf.to_s) # use dumpped configuration to check unescape
-      expect(conf2.elements.first['k1']).to eq(expected)
-    end
-  end
-end