fluent-plugin-record-modifier 0.6.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d387097d02bdd7a23188147b637a43f66fe55698
-  data.tar.gz: 8e77cfa13ed400aba3ea7b6a974a71443a599742
+  metadata.gz: bd31ea6b4191c161f1518dbdfb7cbc57b9840902
+  data.tar.gz: ce1368e0f6b21845deafeb6c72ec60b06d9a2146
 SHA512:
-  metadata.gz: 2b52745de9ae3a6a22d8cee708a2def04b70a96d61cc2221a99156031b9f6d849d2b49a561bdecc30807a3f027f77c6818bc3a784c9bd6836b8a31e8cfcaf944
-  data.tar.gz: '08a27b0a0475c8af1f6804318a22ec816a3084a30ac5047afed1dbf97c30c297f4d2f5d648cc112dc9f8d2eb06e9019bc8a9db75c79d0db912d67692ac85a2c7'
+  metadata.gz: 00b348bb146840c6e754d974e4400e5dee8444289f3f6bdee1e19b0932f76ece490639e1d0bf2ff0f90e4491b1fc127792b5fadf1130cf08c13e5627b4c30bf6
+  data.tar.gz: 4fcc2ab8f86c7e7e40df240fdbdde4e88c80fb4f2e1dd06ae45b766faac620c381e762946b0cbdb6c3795ead3e3e62b43219325a2f635d4b0bf6510fff3a586f

data/.travis.yml

@@ -1,25 +1,25 @@
 language: ruby
 
 rvm:
+  - 2.0.0
   - 2.1
   - 2.2.5
   - 2.3.1
-  - 2.4.2
   - ruby-head
+  - rbx
 
 branches:
   only:
     - master
-    - v0.12
 
 gemfile:
   - Gemfile
 
-sudo: false
-
 matrix:
   allow_failures:
     - rvm: ruby-head
+    - rvm: rbx
+    - rvm: 2.0.0
 
 before_install: gem update bundler
 script: bundle exec rake test

data/ChangeLog

@@ -1,17 +1,7 @@
-Release 0.6.2 - 2017/12/27
+Release 1.0.0.rc1 - 2016/08/23
 
-  * Add prepare_value parameter
-  * Fix non-string object handling
-
-Release 0.6.1 - 2017/12/12
-
-  * Drop fluentd v0.10 support
-  * Add frozen object support
-    https://github.com/repeatedly/fluent-plugin-record-modifier/pull/26
-
-Release 0.6.0 - 2017/06/06
-
-  * Drop fluentd v0.10 support
+  * Use v0.14 API
+    https://github.com/repeatedly/fluent-plugin-record-modifier/pull/14
 
 Release 0.5.0 - 2016/08/23
 

data/Gemfile

@@ -1,5 +1,3 @@
 source "http://rubygems.org"
 
-gem 'fluentd', '~> 0.12.0'
-
 gemspec

data/README.md

@@ -5,6 +5,15 @@ Adding arbitary field to event record without customizing existence plugin.
 For example, generated event from *in_tail* doesn't contain "hostname" of running machine.
 In this case, you can use *record_modifier* to add "hostname" field to event record.
 
+## Requirements
+
+| fluent-plugin-record-modifier  | fluentd | ruby |
+|--------------------------------|---------|------|
+| >= 1.0.0 | >= v0.14.0 | >= 2.1 |
+|  < 1.0.0 | >= v0.12.0 | >= 1.9 |
+
+NOTE: fluent-plugin-record-modifier v1.0.0 is now RC. We will release stable v1.0.0 soon.
+
 ## Installation
 
 Use RubyGems:
@@ -43,7 +52,7 @@ You can also use `record_transformer` like `${xxx}` placeholders and access `tag
 
       <record>
         tag ${tag}
-        tag_extract ${tag_parts[0]}-${tag_pars[1]}-foo
+        tag_extract ${tag_parts[0]}-${tag_parts[1]}-foo
         formatted_time ${Time.at(time).to_s}
         new_field foo:${record['key1'] + record['dict']['key']} 
       </record>
@@ -55,20 +64,6 @@ But unlike `record_transformer`, `record_modifier` doesn't support following fea
 - tag_suffix and tag_prefix
 - dynamic key placeholder
 
-### prepare_value
-
-Prepare values for filtering. This ruby code is evaluated in `configure` phase and prepared values can be used in `<record>`. Here is an example:
-
-    <filter pattern>
-      @type record_modifier
-      prepare_value require 'foo'; @foo = Foo.new
-      <record>
-        key ${@foo.method1}
-      </record>
-    </filter>
-
-This feature is useful for using external library.
-
 ### char_encoding
 
 Fluentd including some plugins treats logs as a BINARY by default to forward.

data/VERSION

@@ -1 +1 @@
-0.6.2
+1.0.0.rc1

data/fluent-plugin-record-modifier.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.require_paths = ['lib']
 
-  gem.add_dependency "fluentd", [">= 0.12", "< 2"]
+  gem.add_dependency "fluentd", [">= 0.10.58", "< 2"]
   gem.add_development_dependency "rake", ">= 0.9.2"
   gem.add_development_dependency("test-unit", ["~> 3.1.4"])
 end

data/lib/fluent/plugin/filter_record_modifier.rb

@@ -1,14 +1,9 @@
-require 'fluent/filter'
+require 'fluent/plugin/filter'
 
 module Fluent
-  class RecordModifierFilter < Filter
+  class Plugin::RecordModifierFilter < Plugin::Filter
     Fluent::Plugin.register_filter('record_modifier', self)
 
-    config_param :prepare_value, :string, default: nil,
-                 desc: <<-DESC
-Prepare values for filtering in configure phase. Prepared values can be used in <record>.
-You can write any ruby code.
-DESC
     config_param :char_encoding, :string, default: nil,
                  desc: <<-DESC
 Fluentd including some plugins treats the logs as a BINARY by default to forward.
@@ -31,7 +26,7 @@ Modified events will have only specified keys (if exist in original events).
 This option is exclusive with `remove_keys`.
 DESC
 
-    BUILTIN_CONFIGURATIONS = %W(type @type log_level @log_level id @id char_encoding remove_keys whitelist_keys prepare_value)
+    BUILTIN_CONFIGURATIONS = %W(type @type log_level @log_level id @id char_encoding remove_keys whitelist_keys)
 
     def configure(conf)
       super
@@ -50,6 +45,7 @@ DESC
         end
       }
 
+      @to_enc = nil
       if @char_encoding
         from, to = @char_encoding.split(':', 2)
         @from_enc = Encoding.find(from)
@@ -72,7 +68,7 @@ DESC
           check_config_placeholders(k, v)
           element.has_key?(k) # to suppress unread configuration warning
           @has_tag_parts = true if v.include?('tag_parts')
-          @map[k] = DynamicExpander.new(k, v, @prepare_value)
+          @map[k] = DynamicExpander.new(k, v)
         end
       end
 
@@ -88,31 +84,27 @@ DESC
       GC.start
     end
 
-    def filter_stream(tag, es)
-      new_es = MultiEventStream.new
+    def filter(tag, time, record)
       tag_parts = @has_tag_parts ? tag.split('.') : nil
 
-      es.each { |time, record|
-        @map.each_pair { |k, v|
-          record[k] = v.expand(tag, time, record, tag_parts)
-        }
+      @map.each_pair { |k, v|
+        record[k] = v.expand(tag, time, record, tag_parts)
+      }
 
-        if @remove_keys
-          @remove_keys.each { |v|
-            record.delete(v)
-          }
-        elsif @whitelist_keys
-          modified = {}
-          record.each do |k, v|
-            modified[k] = v if @whitelist_keys.include?(k)
-          end
-          record = modified
+      if @remove_keys
+        @remove_keys.each { |v|
+          record.delete(v)
+        }
+      elsif @whitelist_keys
+        modified = {}
+        record.each do |k, v|
+          modified[k] = v if @whitelist_keys.include?(k)
         end
+        record = modified
+      end
 
-        record = change_encoding(record) if @char_encoding
-        new_es.add(time, record)
-      }
-      new_es
+      record = change_encoding(record) if @char_encoding
+      record
     end
 
     private
@@ -121,17 +113,9 @@ DESC
       if value.is_a?(String)
         value.force_encoding(@from_enc)
       elsif value.is_a?(Hash)
-        value.each_pair { |k, v|
-          if v.frozen? && v.is_a?(String)
-            value[k] = set_encoding(v.dup)
-          else
-            set_encoding(v)
-          end
-        }
+        value.each_pair { |k, v| set_encoding(v) }
       elsif value.is_a?(Array)
         value.each { |v| set_encoding(v) }
-      else
-        value
       end
     end
 
@@ -140,17 +124,9 @@ DESC
         value.force_encoding(@from_enc) if value.encoding == Encoding::BINARY
         value.encode!(@to_enc, @from_enc, :invalid => :replace, :undef => :replace)
       elsif value.is_a?(Hash)
-        value.each_pair { |k, v|
-          if v.frozen? && v.is_a?(String)
-            value[k] = convert_encoding(v.dup)
-          else
-            convert_encoding(v)
-          end
-        }
+        value.each_pair { |k, v| convert_encoding(v) }
       elsif value.is_a?(Array)
         value.each { |v| convert_encoding(v) }
-      else
-        value
       end
     end
 
@@ -165,7 +141,7 @@ DESC
     end
 
     class DynamicExpander
-      def initialize(param_key, param_value, prepare_value)
+      def initialize(param_key, param_value)
         if param_value.include?('${')
           __str_eval_code__ = parse_parameter(param_value)
 
@@ -181,12 +157,6 @@ DESC
           @param_value = param_value
         end
 
-        begin
-          eval prepare_value if prepare_value
-        rescue SyntaxError
-          raise ConfigError, "Pass invalid syntax parameter : key = prepare_value, value = #{prepare_value}"
-        end
-
         begin
           # check eval genarates wrong code or not
           expand(nil, nil, nil, nil)
@@ -217,5 +187,5 @@ DESC
         end
       end
     end
-  end if defined?(Filter)
+  end
 end

data/lib/fluent/plugin/out_record_modifier.rb

@@ -1,9 +1,11 @@
-require 'fluent/output'
+require 'fluent/plugin/output'
 
 module Fluent
-  class RecordModifierOutput < Output
+  class Plugin::RecordModifierOutput < Plugin::Output
     Fluent::Plugin.register_output('record_modifier', self)
 
+    helpers :event_emitter, :compat_parameters, :inject
+
     config_param :tag, :string,
                  desc: "The output record tag name."
     config_param :char_encoding, :string, default: nil,
@@ -29,11 +31,10 @@ Modified events will have only specified keys (if exist in original events).
 This option is exclusive with `remove_keys`.
 DESC
 
-    include SetTagKeyMixin
-
-    BUILTIN_CONFIGURATIONS = %W(type @type @id id @log_level log_level tag include_tag_key tag_key char_encoding remove_keys whitelist_keys)
+    BUILTIN_CONFIGURATIONS = %W(type @type log_level @log_level id @id tag include_tag_key tag_key char_encoding remove_keys whitelist_keys)
 
     def configure(conf)
+      compat_parameters_convert(conf, :buffer, :inject)
       super
 
       @map = {}
@@ -45,6 +46,7 @@ DESC
         end
       }
 
+      @to_enc = nil
       if @char_encoding
         from, to = @char_encoding.split(':', 2)
         @from_enc = Encoding.find(from)
@@ -70,15 +72,13 @@ DESC
       end
     end
 
-    def emit(tag, es, chain)
+    def process(tag, es)
       stream = MultiEventStream.new
       es.each { |time, record|
-        filter_record(tag, time, record)
+        record = inject_values_to_record(tag, time, record)
         stream.add(time, modify_record(record))
       }
       router.emit_stream(@tag, stream)
-
-      chain.next
     end
 
     private

data/test/test_filter_record_modifier.rb

@@ -1,9 +1,9 @@
+# coding: utf-8
 require 'fluent/test'
+require 'fluent/test/driver/filter'
 require 'fluent/plugin/filter_record_modifier'
 require 'test/unit'
 
-exit unless defined?(Fluent::Filter)
-
 class RecordModifierFilterTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
@@ -11,6 +11,7 @@ class RecordModifierFilterTest < Test::Unit::TestCase
   end
 
   CONFIG = %q!
+    type record_modifier
     remove_keys hoge
 
     <record>
@@ -22,7 +23,7 @@ class RecordModifierFilterTest < Test::Unit::TestCase
   !
 
   def create_driver(conf = CONFIG)
-    Fluent::Test::FilterTestDriver.new(Fluent::RecordModifierFilter, @tag).configure(conf, true)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::RecordModifierFilter).configure(conf)
   end
 
   def get_hostname
@@ -35,143 +36,104 @@ class RecordModifierFilterTest < Test::Unit::TestCase
     map = d.instance.instance_variable_get(:@map)
 
     map.each_pair { |k, v|
-      assert v.is_a?(Fluent::RecordModifierFilter::DynamicExpander)
+      assert v.is_a?(Fluent::Plugin::RecordModifierFilter::DynamicExpander)
     }
   end
 
   def test_format
     d = create_driver
 
-    d.run do
-      d.emit("a" => 1)
-      d.emit("a" => 2)
+    d.run(default_tag: @tag) do
+      d.feed("a" => 1)
+      d.feed("a" => 2)
     end
 
     mapped = {'gen_host' => get_hostname, 'foo' => 'bar', 'included_tag' => @tag, 'tag_wrap' => "-#{@tag.split('.')[0]}-#{@tag.split('.')[1]}-"}
     assert_equal [
       {"a" => 1}.merge(mapped),
       {"a" => 2}.merge(mapped),
-    ], d.filtered_as_array.map { |e| e.last }
+    ], d.filtered.map { |e| e.last }
   end
 
   def test_set_char_encoding
     d = create_driver %[
+      type record_modifier
+
       char_encoding utf-8
     ]
 
-    d.run do
-      d.emit("k" => 'v'.force_encoding('BINARY'))
-      d.emit("k" => %w(v ビ).map{|v| v.force_encoding('BINARY')})
-      d.emit("k" => {"l" => 'ビ'.force_encoding('BINARY')})
+    d.run(default_tag: @tag) do
+      d.feed("k" => 'v'.force_encoding('BINARY'))
+      d.feed("k" => %w(v ビ).map{|v| v.force_encoding('BINARY')})
+      d.feed("k" => {"l" => 'ビ'.force_encoding('BINARY')})
     end
 
     assert_equal [
       {"k" => 'v'.force_encoding('UTF-8')},
       {"k" => %w(v ビ).map{|v| v.force_encoding('UTF-8')}},
       {"k" => {"l" => 'ビ'.force_encoding('UTF-8')}},
-    ], d.filtered_as_array.map { |e| e.last }
+    ], d.filtered.map { |e| e.last }
   end
 
   def test_convert_char_encoding
     d = create_driver %[
+      type record_modifier
+
       char_encoding utf-8:cp932
     ]
 
-    d.run do
-      d.emit("k" => 'v'.force_encoding('utf-8'))
-      d.emit("k" => %w(v ビ).map{|v| v.force_encoding('utf-8')})
-      d.emit("k" => {"l" => 'ビ'.force_encoding('utf-8')})
+    d.run(default_tag: @tag) do
+      d.feed("k" => 'v'.force_encoding('utf-8'))
+      d.feed("k" => %w(v ビ).map{|v| v.force_encoding('utf-8')})
+      d.feed("k" => {"l" => 'ビ'.force_encoding('utf-8')})
     end
 
     assert_equal [
       {"k" => 'v'.force_encoding('cp932')},
       {"k" => %w(v ビ).map{|v| v.encode!('cp932')}},
       {"k" => {"l" => 'ビ'.encode!('cp932')}},
-    ], d.filtered_as_array.map { |e| e.last }
+    ], d.filtered.map { |e| e.last }
   end
 
   def test_remove_one_key
     d = create_driver %[
+      type record_modifier
+
       remove_keys k1
     ]
 
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v')
+    d.run(default_tag: @tag) do
+      d.feed("k1" => 'v', "k2" => 'v')
     end
 
-    assert_equal [{"k2" => 'v'}], d.filtered_as_array.map { |e| e.last }
+    assert_equal [{"k2" => 'v'}], d.filtered.map { |e| e.last }
   end
 
   def test_remove_multiple_keys
     d = create_driver %[
+      type record_modifier
+
       remove_keys k1, k2, k3
     ]
 
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v', "k4" => 'v')
+    d.run(default_tag: @tag) do
+      d.feed({"k1" => 'v', "k2" => 'v', "k4" => 'v'})
     end
 
-    assert_equal [{"k4" => 'v'}], d.filtered_as_array.map { |e| e.last }
+    assert_equal [{"k4" => 'v'}], d.filtered.map { |e| e.last }
   end
 
   def test_remove_non_whitelist_keys
     d = create_driver %[
-      whitelist_keys k1, k2, k3
-    ]
-
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v', "k4" => 'v', "k5" => 'v')
-    end
-
-    assert_equal [{"k1" => 'v', "k2" => 'v'}], d.filtered_as_array.map(&:last)
-  end
+      type record_modifier
 
-  def test_prepare_values
-    d = create_driver %[
-      prepare_value @foo = 'foo'
-      <record>
-        test_key ${@foo}
-      </record>
+      whitelist_keys k1, k2, k3
     ]
 
-    d.run do
-      d.emit("k1" => 'v')
-    end
-
-    assert_equal [{"k1" => 'v', "test_key" => 'foo'}], d.filtered_as_array.map(&:last)
-  end
-
-  sub_test_case 'frozen check' do
-    def test_set_char_encoding
-      d = create_driver %[
-        char_encoding utf-8
-      ]
-
-      d.run do
-        d.emit("k" => 'v'.force_encoding('BINARY').freeze, 'n' => 1)
-        d.emit("k" => {"l" => 'v'.force_encoding('BINARY').freeze, 'n' => 1})
-      end
-
-      assert_equal [
-        {"k" => 'v'.force_encoding('UTF-8'), 'n' => 1},
-        {"k" => {"l" => 'v'.force_encoding('UTF-8'), 'n' => 1}},
-      ], d.filtered_as_array.map { |e| e.last }
+    d.run(default_tag: @tag) do
+      d.feed("k1" => 'v', "k2" => 'v', "k4" => 'v', "k5" => 'v')
     end
 
-    def test_convert_char_encoding
-      d = create_driver %[
-        char_encoding utf-8:cp932
-      ]
-
-      d.run do
-        d.emit("k" => 'v'.force_encoding('utf-8').freeze, 'n' => 1)
-        d.emit("k" => {"l" => 'v'.force_encoding('utf-8').freeze, 'n' => 1})
-      end
-
-      assert_equal [
-        {"k" => 'v'.force_encoding('cp932'), 'n' => 1},
-        {"k" => {"l" => 'v'.force_encoding('cp932'), 'n' => 1}},
-      ], d.filtered_as_array.map { |e| e.last }
-    end
+    assert_equal [{"k1" => 'v', "k2" => 'v'}], d.filtered.map(&:last)
   end
 end

data/test/test_out_record_modifier.rb

@@ -1,4 +1,4 @@
-require 'fluent/test'
+require 'fluent/test/driver/output'
 require 'fluent/plugin/out_record_modifier'
 
 
@@ -19,7 +19,7 @@ class RecordModifierOutputTest < Test::Unit::TestCase
   !
 
   def create_driver(conf = CONFIG)
-    Fluent::Test::OutputTestDriver.new(Fluent::RecordModifierOutput, tag='test_tag').configure(conf, true)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::RecordModifierOutput).configure(conf)
   end
 
   def get_hostname
@@ -38,16 +38,16 @@ class RecordModifierOutputTest < Test::Unit::TestCase
   def test_format
     d = create_driver
 
-    d.run do
-      d.emit("a" => 1)
-      d.emit("a" => 2)
+    d.run(default_tag: 'test_tag') do
+      d.feed({"a" => 1})
+      d.feed({"a" => 2})
     end
 
     mapped = {'gen_host' => get_hostname, 'foo' => 'bar', 'included_tag' => 'test_tag'}
     assert_equal [
       {"a" => 1}.merge(mapped),
       {"a" => 2}.merge(mapped),
-    ], d.records
+    ], d.events.map { |e| e.last }
   end
 
   def test_set_char_encoding
@@ -58,12 +58,11 @@ class RecordModifierOutputTest < Test::Unit::TestCase
       char_encoding utf-8
     ]
 
-
-    d.run do
-      d.emit("k" => 'v'.force_encoding('BINARY'))
+    d.run(default_tag: 'test_tag') do
+      d.feed({"k" => 'v'.force_encoding('BINARY')})
     end
 
-    assert_equal [{"k" => 'v'.force_encoding('UTF-8')}], d.records
+    assert_equal [{"k" => 'v'.force_encoding('UTF-8')}], d.events.map { |e| e.last }
   end
 
   def test_convert_char_encoding
@@ -74,11 +73,11 @@ class RecordModifierOutputTest < Test::Unit::TestCase
       char_encoding utf-8:cp932
     ]
 
-    d.run do
-      d.emit("k" => 'v'.force_encoding('utf-8'))
+    d.run(default_tag: 'test_tag') do
+      d.feed("k" => 'v'.force_encoding('utf-8'))
     end
 
-    assert_equal [{"k" => 'v'.force_encoding('cp932')}], d.records
+    assert_equal [{"k" => 'v'.force_encoding('cp932')}], d.events.map { |e| e.last }
   end
 
   def test_remove_one_key
@@ -89,11 +88,11 @@ class RecordModifierOutputTest < Test::Unit::TestCase
       remove_keys k1
     ]
 
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v')
+    d.run(default_tag: 'test_tag') do
+      d.feed({"k1" => 'v', "k2" => 'v'})
     end
 
-    assert_equal [{"k2" => 'v'}], d.records
+    assert_equal [{"k2" => 'v'}], d.events.map { |e| e.last }
   end
 
   def test_remove_multiple_keys
@@ -104,11 +103,11 @@ class RecordModifierOutputTest < Test::Unit::TestCase
       remove_keys k1, k2, k3
     ]
 
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v', "k4" => 'v')
+    d.run(default_tag: 'test_tag') do
+      d.feed({"k1" => 'v', "k2" => 'v', "k4" => 'v'})
     end
 
-    assert_equal [{"k4" => 'v'}], d.records
+    assert_equal [{"k4" => 'v'}], d.events.map { |e| e.last }
   end
 
   def test_remove_non_whitelist_keys
@@ -119,10 +118,10 @@ class RecordModifierOutputTest < Test::Unit::TestCase
       whitelist_keys k1, k2, k3
     ]
 
-    d.run do
-      d.emit("k1" => 'v', "k2" => 'v', "k4" => 'v', "k5" => 'v')
+    d.run(default_tag: 'test_tag') do
+      d.feed({"k1" => 'v', "k2" => 'v', "k4" => 'v', "k5" => 'v'})
     end
 
-    assert_equal [{"k1" => 'v', "k2" => 'v'}], d.records
+    assert_equal [{"k1" => 'v', "k2" => 'v'}], d.events.map { |e| e.last }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-record-modifier
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Masahiro Nakagawa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-28 00:00:00.000000000 Z
+date: 2017-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: 0.10.58
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: 0.10.58
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -90,12 +90,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Filter plugin for modifying event record