fluent-plugin-grok-parser 2.1.6 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bc85cddf3ae82876f8fa683d15d4554a2c83a1f077a8fc46ece9e6d14f3ec3d
-  data.tar.gz: 4b4321c7a01f13be984bcb853a8048dbe6e590b73980984e122be0407b0a37aa
+  metadata.gz: b7652c7a0665b1f6d46aa18bd2e1b373d45facfebe5d0343ab83e34fda23b74f
+  data.tar.gz: 9a124bd9fedd164691d1eedc434d3f29dbfcddc8fe0dba94cdc5babe05185194
 SHA512:
-  metadata.gz: 1fe9e8af7dcfec87f6fbdb1d0e7f70aaeed3a1ae930810e58f0eeb19d39dbb21bceb8dbf8260ee58793711abd2dda9a7ac1247f7db300e0f69865fc60cbbb345
-  data.tar.gz: d1cfba449d9fe5747b2746dd0d3a9e3ad8aff05560c85f6f5630238f46f63493dc3645f24d7d2d484dff468723b7c79ba407e92d74fe8e00b867639003645f32
+  metadata.gz: 60b36ca6f266b804b95f2e325c16a3e2ff003d75f5b49826b5bb12fc4160b32dccf7b540b9741b5a9a58a8996afbb7dcdad3d66679369ba254a27a8e4e73a6bc
+  data.tar.gz: c45fa99fcb9cd319b6d9d7956d7db94a0c2f40ed8e0919d7807cec51139c7fe845fdbf0c852778735ff45ed2f74bc5b78c2d59c81eef6951f4718fa38c6afc38

data/.travis.yml

@@ -2,8 +2,8 @@ sudo: false
 language: ruby
 
 rvm:
-  - 2.1
-  - 2.2
-  - 2.3.3
-  - 2.4.0
+  - 2.2.10
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
 

data/README.md

@@ -6,8 +6,8 @@ This is a Fluentd plugin to enable Logstash's Grok-like parsing logic.
 
 | fluent-plugin-grok-parser | fluentd    | ruby   |
 |---------------------------|------------|--------|
-| >= 1.0.0                  | >= v0.14.0 | >= 2.1 |
-| < 1.0.0                   | >= v0.12.0 | >= 1.9 |
+| >= 2.0.0                  | >= v0.14.0 | >= 2.1 |
+| < 2.0.0                   | >= v0.12.0 | >= 1.9 |
 
 
 ## What's Grok?
@@ -33,18 +33,6 @@ extracts the first IP address that matches in the log.
 </source>
 ```
 
-For Fluentd v0.12, use following style:
-
-```aconf
-<source>
-  @type tail
-  path /path/to/log
-  tag grokked_log
-  format grok
-  grok_pattern %{IP:ip_address}
-</source>
-```
-
 **If you want to try multiple grok patterns and use the first matched one**, you can use the following syntax:
 
 ```aconf
@@ -68,27 +56,6 @@ For Fluentd v0.12, use following style:
 </source>
 ```
 
-For Fluentd v0.12, use following style:
-
-```aconf
-<source>
-  @type tail
-  path /path/to/log
-  tag grokked_log
-  format grok
-  <grok>
-    pattern %{COMBINEDAPACHELOG}
-    time_format "%d/%b/%Y:%H:%M:%S %z"
-  </grok>
-  <grok>
-    pattern %{IP:ip_address}
-  </grok>
-  <grok>
-    pattern %{GREEDYDATA:message}
-  </grok>
-</source>
-```
-
 ### Multiline support
 
 You can parse multiple line text.
@@ -106,19 +73,6 @@ You can parse multiple line text.
 </source>
 ```
 
-For Fluentd v0.12, use following style:
-
-```aconf
-<source>
-  @type tail
-  path /path/to/log
-  format multiline_grok
-  grok_pattern %{IP:ip_address}%{GREEDYDATA:message}
-  multiline_start_regexp /^[^\s]/
-  tag grokked_log
-</source>
-```
-
 You can use multiple grok patterns to parse your data.
 
 ```aconf
@@ -135,41 +89,25 @@ You can use multiple grok patterns to parse your data.
 </source>
 ```
 
-For Fluentd v0.12, use following style:
-
-```aconf
-<source>
-  @type tail
-  path /path/to/log
-  format multiline_grok
-  <grok>
-    pattern Started %{WORD:verb} "%{URIPATH:pathinfo}" for %{IP:ip} at %{TIMESTAMP_ISO8601:timestamp}\nProcessing by %{WORD:controller}#%{WORD:action} as %{WORD:format}%{DATA:message}Completed %{NUMBER:response} %{WORD} in %{NUMBER:elapsed} (%{DATA:elapsed_details})
-  </grok>
-  tag grokked_log
-</source>
-```
-
 Fluentd accumulates data in the buffer forever to parse complete data when no pattern matches.
 
 You can use this parser without `multiline_start_regexp` when you know your data structure perfectly.
 
 ## Configurations
 
-**time_format**
-
-The format of the time field.
-
-**grok_pattern**
+* See also: [TimeParameters Plugin Overview](https://docs.fluentd.org/v1.0/articles/timeparameters-plugin-overview)
+* See also: [Parser Plugin Overview](https://docs.fluentd.org/v1.0/articles/parser-plugin-overview)
 
-The pattern of grok. You cannot specify multiple grok pattern with this.
+* **time_format** (string) (optional): The format of the time field.
+* **grok_pattern** (string) (optional): The pattern of grok. You cannot specify multiple grok pattern with this.
+* **custom_pattern_path** (string) (optional): Path to the file that includes custom grok patterns
+* **grok_failure_key** (string) (optional): The key has grok failure reason.
+* **grok_name_key** (string) (optional): The key name to store grok section's name
+* **multi_line_start_regexp** (string) (optional): The regexp to match beginning of multiline. This is only for "multiline_grok".
 
-**custom_pattern_path**
+## Examples
 
-Path to the file that includes custom grok patterns
-
-**grok_failure_key**
-
-The key has grok failure reason. Default is `nil`.
+### Using grok\_failure\_key
 
 ```aconf
 <source>
@@ -209,21 +147,42 @@ This generates following events:
 2016-11-28 13:07:09.010400923 +0900 dummy.log: {"message1":"/","prog":"bar","path":"/"}
 ```
 
-
-**grok/pattern**
-
-Section for grok patterns. You can use multiple grok patterns with
-multiple `<grok>` sections.
+### Using grok\_name\_key
 
 ```aconf
-<grok>
-  pattern %{IP:ipaddress}
-</grok>
+<source>
+  @type tail
+  path /path/to/log
+  tag grokked_log
+  grok_name_key grok_name
+  grok_failure_key grokfailure
+  <parse>
+    @type grok
+    <grok>
+      name apache_log
+      pattern %{COMBINEDAPACHELOG}
+      time_format "%d/%b/%Y:%H:%M:%S %z"
+    </grok>
+    <grok>
+      name ip_address
+      pattern %{IP:ip_address}
+    </grok>
+    <grok>
+      name rest_message
+      pattern %{GREEDYDATA:message}
+    </grok>
+  </parse>
+</source>
 ```
 
-**multiline_start_regexp**
+This will add keys like following:
+
+* Add `grok_name: "apache_log"` if the record matches `COMBINEDAPACHELOG`
+* Add `grok_name: "ip_address"` if the record matches `IP`
+* Add `grok_name: "rest_message"` if the record matches `GREEDYDATA`
 
-The regexp to match beginning of multiline. This is only for "multiline_grok".
+Add `grokfailure` key to the record if the record does not match any grok pattern.
+See also test code for more details.
 
 ## How to write Grok patterns
 
@@ -310,7 +269,7 @@ Here is a sample config using the Grok parser with `in_tail` and the `types` par
 
 ## Notice
 
-If you want to use this plugin with Fluentd v0.12.x or earlier, you can use this plugin version v1.0.0.
+If you want to use this plugin with Fluentd v0.12.x or earlier, you can use this plugin version v1.x.
 
 See also: [Plugin Management | Fluentd](http://docs.fluentd.org/articles/plugin-management#plugin-version-management)
 

data/fluent-plugin-grok-parser.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "fluent-plugin-grok-parser"
-  spec.version       = "2.1.6"
+  spec.version       = "2.2.0"
   spec.authors       = ["kiyoto", "Kenji Okimoto"]
   spec.email         = ["kiyoto@treasure-data.com", "okimoto@clear-code.com"]
   spec.summary       = %q{Fluentd plugin to support Logstash-inspired Grok format for parsing logs}

data/lib/fluent/plugin/grok.rb

@@ -23,14 +23,15 @@ module Fluent
 
     def initialize(plugin, conf)
       @pattern_map = {}
-      @parsers = []
+      @parsers = {}
       @multiline_mode = false
       @conf = conf
-      if plugin.respond_to?(:firstline?)
+      @plugin = plugin
+      if @plugin.respond_to?(:firstline?)
         @multiline_mode = true
       end
-      if @conf["multiline_start_regexp"]
-        @multiline_start_regexp = Regexp.compile(@conf["multiline_start_regexp"][1..-2])
+      if @plugin.respond_to?(:multiline_start_regexp) && @plugin.multiline_start_regexp
+        @multiline_start_regexp = Regexp.compile(@plugin.multiline_start_regexp[1..-2])
       end
     end
 
@@ -43,15 +44,16 @@ module Fluent
     end
 
     def setup
-      if @conf["grok_pattern"]
-        @parsers << expand_pattern_expression(@conf["grok_pattern"], @conf)
+      if @plugin.grok_pattern
+        @parsers[:grok_pattern] = expand_pattern_expression(@plugin.grok_pattern, @conf)
       else
-        grok_confs = @conf.elements.select {|e| e.name == "grok"}
-        grok_confs.each do |grok_conf|
-          @parsers << expand_pattern_expression(grok_conf["pattern"], grok_conf)
+        @plugin.grok_confs.each.with_index do |grok_conf, index|
+          @parsers[grok_conf.name || index] = expand_pattern_expression(grok_conf.pattern, grok_conf)
         end
       end
-      @parsers.compact!
+      @parsers.reject! do |key, parser|
+        parser.nil?
+      end
       if @parsers.empty?
         raise Fluent::ConfigError, 'no grok patterns. Check configuration, e.g. typo, configuration syntax, etc'
       end
@@ -61,11 +63,12 @@ module Fluent
 
     def expand_pattern_expression(grok_pattern, conf)
       regexp, types = expand_pattern(grok_pattern)
-      $log.info "Expanded the pattern #{conf['grok_pattern']} into #{regexp}"
+      $log.info "Expanded the pattern #{grok_pattern} into #{regexp}"
+      _conf = conf.to_h
       unless types.empty?
-        conf["types"] = types.map{|subname,type| "#{subname}:#{type}" }.join(",")
+        _conf["types"] = types.map{|subname,type| "#{subname}:#{type}" }.join(",")
       end
-      _conf = conf.merge("expression" => regexp, "multiline" => @multiline_mode)
+      _conf = _conf.merge("expression" => regexp, "multiline" => @multiline_mode)
       config = Fluent::Config::Element.new("parse", nil, _conf, [])
       parser = Fluent::Plugin::RegexpParser.new
       parser.configure(config)

data/lib/fluent/plugin/parser_grok.rb

@@ -14,6 +14,15 @@ module Fluent
       config_param :custom_pattern_path, :string, default: nil
       desc "The key has grok failure reason"
       config_param :grok_failure_key, :string, default: nil
+      desc "The key name to store grok section's name"
+      config_param :grok_name_key, :string, default: nil
+
+      config_section :grok, param_name: "grok_confs", multi: true do
+        desc "The name of this grok section"
+        config_param :name, :string, default: nil
+        desc "The pattern of grok"
+        config_param :pattern, :string
+      end
 
       def initialize
         super
@@ -44,9 +53,10 @@ module Fluent
       end
 
       def parse(text)
-        @grok.parsers.each do |parser|
+        @grok.parsers.each do |name_or_index, parser|
           parser.parse(text) do |time, record|
             if time and record
+              record[@grok_name_key] = name_or_index if @grok_name_key
               yield time, record
               return
             end

data/lib/fluent/plugin/parser_multiline_grok.rb

@@ -17,9 +17,10 @@ module Fluent
       end
 
       def parse(text)
-        @grok.parsers.each do |parser|
+        @grok.parsers.each do |name_or_index, parser|
           parser.parse(text) do |time, record|
             if time and record
+              record[@grok_name_key] = name_or_index if @grok_name_key
               yield time, record
               return
             end

data/test/test_grok_parser.rb

@@ -11,49 +11,49 @@ def str2time(str_time, format = nil)
 end
 
 class GrokParserTest < ::Test::Unit::TestCase
-  def setup
+  setup do
     Fluent::Test.setup
   end
 
-  class Timestamp < self
-    def test_timestamp_iso8601
+  sub_test_case "timestamp" do
+    test "timestamp iso8601" do
       internal_test_grok_pattern("%{TIMESTAMP_ISO8601:time}", "Some stuff at 2014-01-01T00:00:00+0900",
                                  event_time("2014-01-01T00:00:00+0900"), {})
     end
 
-    def test_datestamp_rfc822_with_zone
+    test "datestamp rfc822 with zone" do
       internal_test_grok_pattern("%{DATESTAMP_RFC822:time}", "Some stuff at Mon Aug 15 2005 15:52:01 UTC",
                                  event_time("Mon Aug 15 2005 15:52:01 UTC"), {})
     end
 
-    def test_datestamp_rfc822_with_numeric_zone
+    test "datestamp rfc822 with numeric zone" do
       internal_test_grok_pattern("%{DATESTAMP_RFC2822:time}", "Some stuff at Mon, 15 Aug 2005 15:52:01 +0000",
                                  event_time("Mon, 15 Aug 2005 15:52:01 +0000"), {})
     end
 
-    def test_syslogtimestamp
+    test "syslogtimestamp" do
       internal_test_grok_pattern("%{SYSLOGTIMESTAMP:time}", "Some stuff at Aug 01 00:00:00",
                                  event_time("Aug 01 00:00:00"), {})
     end
   end
 
-  def test_date
+  test "date" do
     internal_test_grok_pattern("\\[(?<date>%{DATE} %{TIME} (?:AM|PM))\\]", "[2/16/2018 10:19:34 AM]",
                                nil, { "date" => "2/16/2018 10:19:34 AM" })
   end
 
-  def test_call_for_grok_pattern_not_found
+  test "grok pattern not found" do
     assert_raise Fluent::Grok::GrokPatternNotFoundError do
       internal_test_grok_pattern("%{THIS_PATTERN_DOESNT_EXIST}", "Some stuff at somewhere", nil, {})
     end
   end
 
-  def test_call_for_multiple_fields
+  test "multiple fields" do
     internal_test_grok_pattern("%{MAC:mac_address} %{IP:ip_address}", "this.wont.match DEAD.BEEF.1234 127.0.0.1", nil,
                                {"mac_address" => "DEAD.BEEF.1234", "ip_address" => "127.0.0.1"})
   end
 
-  def test_call_for_complex_pattern
+  test "complex pattern" do
     internal_test_grok_pattern("%{COMBINEDAPACHELOG}", '127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"',
                                 str2time("28/Feb/2013:12:00:00 +0900", "%d/%b/%Y:%H:%M:%S %z"),
                                 {
@@ -73,59 +73,59 @@ class GrokParserTest < ::Test::Unit::TestCase
                               )
   end
 
-  def test_call_for_custom_pattern
+  test "custom pattern" do
     internal_test_grok_pattern("%{MY_AWESOME_PATTERN:message}", "this is awesome",
                                nil, {"message" => "this is awesome"},
                                "custom_pattern_path" => fixtures("my_pattern").to_s)
   end
 
-  class OptionalType < self
-    def test_simple
+  sub_test_case "OptionalType" do
+    test "simple" do
       internal_test_grok_pattern("%{INT:user_id:integer} paid %{NUMBER:paid_amount:float}",
                                  "12345 paid 6789.10", nil,
                                  {"user_id" => 12345, "paid_amount" => 6789.1 })
     end
 
-    def test_array
+    test "array" do
       internal_test_grok_pattern("%{GREEDYDATA:message:array}",
                                  "a,b,c,d", nil,
                                  {"message" => %w(a b c d)})
     end
 
-    def test_array_with_delimiter
+    test "array with delimiter" do
       internal_test_grok_pattern("%{GREEDYDATA:message:array:|}",
                                  "a|b|c|d", nil,
                                  {"message" => %w(a b c d)})
     end
 
-    def test_timestamp_iso8601
+    test "timestamp iso8601" do
       internal_test_grok_pattern("%{TIMESTAMP_ISO8601:stamp:time}", "Some stuff at 2014-01-01T00:00:00+0900",
                                  nil, {"stamp" => event_time("2014-01-01T00:00:00+0900")})
     end
 
-    def test_datestamp_rfc822_with_zone
+    test "datestamp rfc822 with zone" do
       internal_test_grok_pattern("%{DATESTAMP_RFC822:stamp:time}", "Some stuff at Mon Aug 15 2005 15:52:01 UTC",
                                  nil, {"stamp" => event_time("Mon Aug 15 2005 15:52:01 UTC")})
     end
 
-    def test_datestamp_rfc822_with_numeric_zone
+    test "datestamp rfc822 with numeric zone" do
       internal_test_grok_pattern("%{DATESTAMP_RFC2822:stamp:time}", "Some stuff at Mon, 15 Aug 2005 15:52:01 +0000",
                                  nil, {"stamp" => event_time("Mon, 15 Aug 2005 15:52:01 +0000")})
     end
 
-    def test_syslogtimestamp
+    test "syslogtimestamp" do
       internal_test_grok_pattern("%{SYSLOGTIMESTAMP:stamp:time}", "Some stuff at Aug 01 00:00:00",
                                  nil, {"stamp" => event_time("Aug 01 00:00:00")})
     end
 
-    def test_timestamp_with_format
+    test "timestamp with format" do
       internal_test_grok_pattern("%{TIMESTAMP_ISO8601:stamp:time:%Y-%m-%d %H%M}", "Some stuff at 2014-01-01 1000",
                                  nil, {"stamp" => event_time("2014-01-01 10:00")})
     end
   end
 
-  class NoGrokPatternMatched < self
-    def test_with_grok_failure_key
+  sub_test_case "NoGrokPatternMatched" do
+    test "with grok_failure_key" do
       config = %[
         grok_failure_key grok_failure
         <grok>
@@ -142,7 +142,7 @@ class GrokParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_without_grok_failure_key
+    test "without grok_failure_key" do
       config = %[
         <grok>
           pattern %{PATH:path}
@@ -158,13 +158,13 @@ class GrokParserTest < ::Test::Unit::TestCase
     end
   end
 
-  def test_no_grok_patterns
+  test "no grok patterns" do
     assert_raise Fluent::ConfigError do
       create_driver('')
     end
   end
 
-  def test_invalid_config_value_type
+  test "invalid config value type" do
     assert_raise Fluent::ConfigError do
       create_driver(%[
         <grok>
@@ -174,7 +174,7 @@ class GrokParserTest < ::Test::Unit::TestCase
     end
   end
 
-  def test_invalid_config_value_type_and_normal_grok_pattern
+  test "invalid config value type and normal grok pattern" do
     d = create_driver(%[
       <grok>
         pattern %{PATH:path:foo}
@@ -191,6 +191,116 @@ class GrokParserTest < ::Test::Unit::TestCase
     assert_equal("unknown value conversion for key:'path', type:'foo'", error_message)
   end
 
+  sub_test_case "grok_name_key" do
+    test "one grok section with name" do
+      d = create_driver(%[
+        grok_name_key grok_name
+        <grok>
+          name path
+          pattern %{PATH:path}
+        </grok>
+      ])
+      expected = {
+        "path" => "/",
+        "grok_name" => "path"
+      }
+      d.instance.parse("/") do |time, record|
+        assert_equal(expected, record)
+      end
+    end
+
+    test "one grok section without name" do
+      d = create_driver(%[
+        grok_name_key grok_name
+        <grok>
+          pattern %{PATH:path}
+        </grok>
+      ])
+      expected = {
+        "path" => "/",
+        "grok_name" => 0
+      }
+      d.instance.parse("/") do |time, record|
+        assert_equal(expected, record)
+      end
+    end
+
+    test "multiple grok sections with name" do
+      d = create_driver(%[
+        grok_name_key grok_name
+        <grok>
+          name path
+          pattern %{PATH:path}
+        </grok>
+        <grok>
+          name ip
+          pattern %{IP:ip_address}
+        </grok>
+      ])
+      expected = [
+        { "path" => "/", "grok_name" => "path" },
+        { "ip_address" => "127.0.0.1", "grok_name" => "ip" },
+      ]
+      records = []
+      d.instance.parse("/") do |time, record|
+        records << record
+      end
+      d.instance.parse("127.0.0.1") do |time, record|
+        records << record
+      end
+      assert_equal(expected, records)
+    end
+
+    test "multiple grok sections without name" do
+      d = create_driver(%[
+        grok_name_key grok_name
+        <grok>
+          pattern %{PATH:path}
+        </grok>
+        <grok>
+          pattern %{IP:ip_address}
+        </grok>
+      ])
+      expected = [
+        { "path" => "/", "grok_name" => 0 },
+        { "ip_address" => "127.0.0.1", "grok_name" => 1 },
+      ]
+      records = []
+      d.instance.parse("/") do |time, record|
+        records << record
+      end
+      d.instance.parse("127.0.0.1") do |time, record|
+        records << record
+      end
+      assert_equal(expected, records)
+    end
+
+    test "multiple grok sections with both name and index" do
+      d = create_driver(%[
+        grok_name_key grok_name
+        <grok>
+          name path
+          pattern %{PATH:path}
+        </grok>
+        <grok>
+          pattern %{IP:ip_address}
+        </grok>
+      ])
+      expected = [
+        { "path" => "/", "grok_name" => "path" },
+        { "ip_address" => "127.0.0.1", "grok_name" => 1 },
+      ]
+      records = []
+      d.instance.parse("/") do |time, record|
+        records << record
+      end
+      d.instance.parse("127.0.0.1") do |time, record|
+        records << record
+      end
+      assert_equal(expected, records)
+    end
+  end
+
   private
 
   def create_driver(conf)

data/test/test_grok_parser_in_tcp.rb

@@ -16,7 +16,7 @@ class TcpInputWithGrokTest < Test::Unit::TestCase
     end
   end
 
-  def setup
+  setup do
     Fluent::Test.setup
   end
 
@@ -54,15 +54,14 @@ class TcpInputWithGrokTest < Test::Unit::TestCase
     configs[:ipv6] = ["::1", IPv6_CONFIG] if ipv6_enabled?
     configs
   end
-  def test_configure(data)
-    k, config = data
+  test "configure" do |(ip, config)|
     d = create_driver(config)
     assert_equal PORT, d.instance.port
-    assert_equal k, d.instance.bind
+    assert_equal ip, d.instance.bind
     assert_equal "\n", d.instance.delimiter
   end
 
-  def test_grok_pattern
+  test "grok_pattern" do
     tests = [
       {"msg" => "tcptest1\n", "expected" => "tcptest1"},
       {"msg" => "tcptest2\n", "expected" => "tcptest2"},
@@ -77,7 +76,7 @@ class TcpInputWithGrokTest < Test::Unit::TestCase
     internal_test_grok(config, tests)
   end
 
-  def test_grok_pattern_block_config
+  test "grok_pattern_block_config" do
     tests = [
       {"msg" => "tcptest1\n", "expected" => "tcptest1"},
       {"msg" => "tcptest2\n", "expected" => "tcptest2"},
@@ -94,7 +93,7 @@ class TcpInputWithGrokTest < Test::Unit::TestCase
     internal_test_grok(block_config, tests)
   end
 
-  def test_grok_multi_patterns
+  test "grok_multi_patterns" do
     tests = [
       {"msg" => "Current time is 2014-01-01T00:00:00+0900\n", "expected" => "2014-01-01T00:00:00+0900"},
       {"msg" => "The first word matches\n", "expected" => "The"}

data/test/test_multiline_grok_parser.rb

@@ -50,7 +50,7 @@ TEXT
     end
   end
 
-  def test_empty_range_text_in_text
+  test "empty_range_text_in_text" do
     text = " [b-a]"
     conf = %[
       grok_pattern %{HOSTNAME:hostname} %{GREEDYDATA:message}
@@ -61,8 +61,8 @@ TEXT
     assert(d.instance.firstline?(text))
   end
 
-  class NoGrokPatternMatched < self
-    def test_with_grok_failure_key
+  sub_test_case "NoGrokPatternMatched" do
+    test "with grok_failure_key" do
       config = %[
         grok_failure_key grok_failure
         <grok>
@@ -79,7 +79,7 @@ TEXT
       end
     end
 
-    def test_without_grok_failure_key
+    test "without grok_failure" do
       config = %[
         <grok>
           pattern %{PATH:path}
@@ -95,7 +95,7 @@ TEXT
     end
   end
 
-  def test_no_grok_patterns
+  test "no_grok_patterns" do
     assert_raise Fluent::ConfigError do
       create_driver('')
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-grok-parser
 version: !ruby/object:Gem::Version
-  version: 2.1.6
+  version: 2.2.0
 platform: ruby
 authors:
 - kiyoto
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-20 00:00:00.000000000 Z
+date: 2018-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Fluentd plugin to support Logstash-inspired Grok format for parsing logs