fluent-plugin-rename-key 0.2.0 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe8b87f5ca1a68033f2d8d22ad283c097f63bca8
-  data.tar.gz: f7fd6a36cf2f4b85b02a3b626b28d2c986b40eb1
+  metadata.gz: 3594c5318a78874b31f44ee67dc0df53c93c3ded
+  data.tar.gz: 08e8678877a28546a04066094bf3c9c25dd131da
 SHA512:
-  metadata.gz: fd388ad6dd9c73618ee654dce8786dad13714f32cbf8f76706838050a4c28009c271faa90c73b82d57f5da52d4b1a27f16fd47fd8aba266f8ae07ddf7ca5abbc
-  data.tar.gz: c6eeab30ca1317114b157f9ddd6baf4041e330ed30ae289aeb44fad45ba72d8689af5041e0f6f79617d4def623d011a13c629d09201bcebbc8a6befc9f4208b1
+  metadata.gz: d716e34b91a1386e0ef9507444b1f867c02f92f8d593dda28b3c0ab32deb9193bd87bb23fa8afc7f860aa6c96fa57b5b70aeebbe4fc49528d0d937ce5e98cba4
+  data.tar.gz: 1e23080c26b312eb4dd00d73ee88afeb4761d2090650a9c96f7baa7cf920b08606891885e18f48e41ac0367fc83338759b641f4e13e3474e69e8762fdac91145

data/.travis.yml

@@ -3,7 +3,6 @@ language: ruby
 rvm:
   - 2.3.0
   - 2.2
-  - 1.9.3
 
 # to avoid travis-ci issue since 2015-12-25
 before_install:

data/README.md

@@ -28,6 +28,11 @@ $ sudo /usr/lib64/fluent/ruby/bin/fluent-gem install fluent-plugin-rename-key
 
 ## Configuration
 
+### Notice
+
+v0.12's filter plugin does not have a functionality to modify tag and time. If you want to modify time in filter plugin, we recommends to migrate to depends on v0.14 Filter Plugin API.
+v0.14's filter API has `#filter_with_time` method.
+
 ### Syntax
 
 ```

data/fluent-plugin-rename-key.gemspec

@@ -3,22 +3,21 @@ $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = 'fluent-plugin-rename-key'
-  s.version     = '0.2.0'
-  s.date        = '2016-04-05'
+  s.version     = '0.3.3'
+  s.date        = '2016-11-29'
   s.license     = 'Apache-2.0'
-  s.authors     = ['Shunwen Hsiao', 'Julian Grinblat']
+  s.authors     = ['Shunwen Hsiao', 'Julian Grinblat', 'Hiroshi Hatake']
   s.email       = ['hsiaoshunwen@gmail.com']
   s.homepage    = 'https://github.com/shunwen/fluent-plugin-rename-key'
   s.summary     = %q[Fluentd output plugin. Rename keys which match given regular expressions, assign new tags and re-emit the records.]
 
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 2.2'
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- {test}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
-
-  s.add_runtime_dependency 'fluentd'
-  s.add_development_dependency 'test-unit', '>= 3.1.0'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'coveralls'
+  s.add_runtime_dependency 'fluentd', ">= 0.12.0", "< 2"
+  s.add_development_dependency 'test-unit', '~> 3.2'
+  s.add_development_dependency 'rake', '~> 11.3'
+  s.add_development_dependency 'coveralls', '~> 0.8'
 end

data/lib/fluent/plugin/filter_rename_key.rb

@@ -0,0 +1,25 @@
+require 'fluent/plugin/rename_key_util'
+
+class Fluent::RenameKeyFilter < Fluent::Filter
+  Fluent::Plugin.register_filter 'rename_key', self
+
+  include Fluent::RenameKeyUtil
+
+  desc 'Deep rename/replace operation.'
+  config_param :deep_rename, :bool, default: true
+
+  def configure conf
+    super
+
+    create_rename_rules(conf)
+    create_replace_rules(conf)
+
+    raise Fluent::ConfigError, "No rename or replace rules are given" if @rename_rules.empty? && @replace_rules.empty?
+  end
+
+  def filter tag, time, record
+    new_record = rename_key record
+    new_record = replace_key new_record
+    new_record
+  end
+end if defined?(Fluent::Filter)

data/lib/fluent/plugin/out_rename_key.rb

@@ -1,6 +1,10 @@
+require 'fluent/plugin/rename_key_util'
+
 class Fluent::RenameKeyOutput < Fluent::Output
   Fluent::Plugin.register_output 'rename_key', self
 
+  include Fluent::RenameKeyUtil
+
   # To support Fluentd v0.10.57 or earlier
   unless method_defined?(:router)
     define_method("router") { Fluent::Engine }
@@ -31,43 +35,8 @@ class Fluent::RenameKeyOutput < Fluent::Output
   def configure conf
     super
 
-    @rename_rules = []
-    conf_rename_rules = conf.keys.select { |k| k =~ /^rename_rule(\d+)$/ }
-    conf_rename_rules.sort_by { |r| r.sub('rename_rule', '').to_i }.each do |r|
-      key_regexp, new_key = parse_rename_rule conf[r]
-
-      if key_regexp.nil? || new_key.nil?
-        raise Fluent::ConfigError, "Failed to parse: #{r} #{conf[r]}"
-      end
-
-      if @rename_rules.map { |r| r[:key_regexp] }.include? /#{key_regexp}/
-        raise Fluent::ConfigError, "Duplicated rules for key #{key_regexp}: #{@rename_rules}"
-      end
-
-      @rename_rules << { key_regexp: /#{key_regexp}/, new_key: new_key }
-      log.info "Added rename key rule: #{r} #{@rename_rules.last}"
-    end
-
-    @replace_rules = []
-    conf_replace_rules = conf.keys.select { |k| k =~ /^replace_rule(\d+)$/ }
-    conf_replace_rules.sort_by { |r| r.sub('replace_rule', '').to_i }.each do |r|
-      key_regexp, replacement = parse_replace_rule conf[r]
-
-      if key_regexp.nil?
-        raise Fluent::ConfigError, "Failed to parse: #{r} #{conf[r]}"
-      end
-
-      if replacement.nil?
-          replacement = ""
-      end
-
-      if @replace_rules.map { |r| r[:key_regexp] }.include? /#{key_regexp}/
-        raise Fluent::ConfigError, "Duplicated rules for key #{key_regexp}: #{@replace_rules}"
-      end
-
-      @replace_rules << { key_regexp: /#{key_regexp}/, replacement: replacement }
-      log.info "Added replace key rule: #{r} #{@replace_rules.last}"
-    end
+    create_rename_rules(conf)
+    create_replace_rules(conf)
 
     raise Fluent::ConfigError, "No rename or replace rules are given" if @rename_rules.empty? && @replace_rules.empty?
 
@@ -85,81 +54,4 @@ class Fluent::RenameKeyOutput < Fluent::Output
 
     chain.next
   end
-
-  # private
-
-  def parse_rename_rule rule
-    $~.captures if rule.match /^([^\s]+)\s+(.+)$/
-  end
-
-  def parse_replace_rule rule
-    $~.captures if rule.match /^([^\s]+)(?:\s+(.+))?$/
-  end
-
-  def rename_key record
-    new_record = {}
-
-    record.each do |key, value|
-
-      @rename_rules.each do |rule|
-        match_data = key.match rule[:key_regexp]
-        next unless match_data # next rule
-
-        placeholder = get_placeholder match_data
-        key = rule[:new_key].gsub /\${md\[\d+\]}/, placeholder
-        break
-      end
-
-      if @deep_rename
-        if value.is_a? Hash
-          value = rename_key value
-        elsif value.is_a? Array
-          value = value.map { |v| v.is_a?(Hash) ? rename_key(v) : v }
-        end
-      end
-
-      new_record[key] = value
-    end
-
-    new_record
-  end
-
-  def replace_key record
-    new_record = {}
-
-    record.each do |key, value|
-
-      @replace_rules.each do |rule|
-        match_data = key.match rule[:key_regexp]
-        next unless match_data # next rule
-
-        placeholder = get_placeholder match_data
-        key = key.gsub rule[:key_regexp], rule[:replacement].gsub(/\${md\[\d+\]}/, placeholder)
-        break
-      end
-
-      if @deep_rename
-        if value.is_a? Hash
-          value = replace_key value
-        elsif value.is_a? Array
-          value = value.map { |v| v.is_a?(Hash) ? replace_key(v) : v }
-        end
-      end
-
-      new_record[key] = value
-    end
-
-    new_record
-  end
-
-  def get_placeholder match_data
-    placeholder = {}
-
-    match_data.to_a.each_with_index do |e, idx|
-      placeholder["${md[#{idx}]}"] = e
-    end
-
-    placeholder
-  end
-
 end

data/lib/fluent/plugin/rename_key_util.rb

@@ -0,0 +1,119 @@
+module Fluent
+  module RenameKeyUtil
+    def create_rename_rules(conf)
+      @rename_rules = []
+      conf_rename_rules = conf.keys.select { |k| k =~ /^rename_rule(\d+)$/ }
+      conf_rename_rules.sort_by { |r| r.sub('rename_rule', '').to_i }.each do |r|
+        key_regexp, new_key = parse_rename_rule conf[r]
+
+        if key_regexp.nil? || new_key.nil?
+          raise Fluent::ConfigError, "Failed to parse: #{r} #{conf[r]}"
+        end
+
+        if @rename_rules.map { |r| r[:key_regexp] }.include? /#{key_regexp}/
+          raise Fluent::ConfigError, "Duplicated rules for key #{key_regexp}: #{@rename_rules}"
+        end
+
+        @rename_rules << { key_regexp: /#{key_regexp}/, new_key: new_key }
+        log.info "Added rename key rule: #{r} #{@rename_rules.last}"
+      end
+    end
+
+    def create_replace_rules(conf)
+      @replace_rules = []
+      conf_replace_rules = conf.keys.select { |k| k =~ /^replace_rule(\d+)$/ }
+      conf_replace_rules.sort_by { |r| r.sub('replace_rule', '').to_i }.each do |r|
+        key_regexp, replacement = parse_replace_rule conf[r]
+
+        if key_regexp.nil?
+          raise Fluent::ConfigError, "Failed to parse: #{r} #{conf[r]}"
+        end
+
+        if replacement.nil?
+          replacement = ""
+        end
+
+        if @replace_rules.map { |r| r[:key_regexp] }.include? /#{key_regexp}/
+          raise Fluent::ConfigError, "Duplicated rules for key #{key_regexp}: #{@replace_rules}"
+        end
+
+        @replace_rules << { key_regexp: /#{key_regexp}/, replacement: replacement }
+        log.info "Added replace key rule: #{r} #{@replace_rules.last}"
+      end
+    end
+
+    def parse_rename_rule rule
+      $~.captures if rule.match /^([^\s]+)\s+(.+)$/
+    end
+
+    def parse_replace_rule rule
+      $~.captures if rule.match /^([^\s]+)(?:\s+(.+))?$/
+    end
+
+    def rename_key record
+      new_record = {}
+
+      record.each do |key, value|
+
+        @rename_rules.each do |rule|
+          match_data = key.match rule[:key_regexp]
+          next unless match_data # next rule
+
+          placeholder = get_placeholder match_data
+          key = rule[:new_key].gsub /\${md\[\d+\]}/, placeholder
+          break
+        end
+
+        if @deep_rename
+          if value.is_a? Hash
+            value = rename_key value
+          elsif value.is_a? Array
+            value = value.map { |v| v.is_a?(Hash) ? rename_key(v) : v }
+          end
+        end
+
+        new_record[key] = value
+      end
+
+      new_record
+    end
+
+    def replace_key record
+      new_record = {}
+
+      record.each do |key, value|
+
+        @replace_rules.each do |rule|
+          match_data = key.match rule[:key_regexp]
+          next unless match_data # next rule
+
+          placeholder = get_placeholder match_data
+          key = key.gsub rule[:key_regexp], rule[:replacement].gsub(/\${md\[\d+\]}/, placeholder)
+          break
+        end
+
+        if @deep_rename
+          if value.is_a? Hash
+            value = replace_key value
+          elsif value.is_a? Array
+            value = value.map { |v| v.is_a?(Hash) ? replace_key(v) : v }
+          end
+        end
+
+        new_record[key] = value
+      end
+
+      new_record
+    end
+
+    def get_placeholder match_data
+      placeholder = {}
+
+      match_data.to_a.each_with_index do |e, idx|
+        placeholder["${md[#{idx}]}"] = e
+      end
+
+      placeholder
+    end
+  end
+end

data/test/helper.rb

@@ -23,6 +23,9 @@ unless ENV.has_key?('VERBOSE')
 end
 
 require 'fluent/plugin/out_rename_key'
+if defined?(Fluent::Filter)
+  require 'fluent/plugin/filter_rename_key'
+end
 
 class Test::Unit::TestCase
 end

data/test/plugin/test_filter_rename_key.rb

@@ -0,0 +1,215 @@
+require 'helper'
+
+class RenameKeyFilterTest < Test::Unit::TestCase
+  MATCH_TAG = 'incoming_tag'
+  RENAME_RULE_CONFIG = 'rename_rule1 ^\$(.+) x$${md[1]}'
+  REPLACE_RULE_CONFIG = 'replace_rule1 ^\$ x'
+
+  def setup
+    omit("Fluentd v0.12 or later is required.") unless defined?(Fluent::Filter)
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf, tag = MATCH_TAG)
+    Fluent::Test::FilterTestDriver.new(Fluent::RenameKeyFilter, tag).configure(conf)
+  end
+
+  def test_config_error
+    assert_raise(Fluent::ConfigError) { create_driver('') }
+
+    assert_raise(Fluent::ConfigError) { create_driver('rename_rule1 ^$(.+?) ') }
+
+    assert_raise(Fluent::ConfigError) {
+      config_dup_rules_for_a_key = %q[
+        rename_rule1 ^\$(.+) ${md[1]}
+        rename_rule2 ^\$(.+) ${md[1]} something
+      ]
+      create_driver(config_dup_rules_for_a_key)
+    }
+  end
+
+  def test_config_success
+    config_multiple_rules = %q[
+      rename_rule1 ^\$(.+)1 x$${md[1]}
+      rename_rule2 ^\$(.+)2(\d+) ${md[1]}_${md[2]}
+    ]
+
+    d = create_driver config_multiple_rules
+    assert_equal '^\$(.+)1 x$${md[1]}', d.instance.config['rename_rule1']
+    assert_equal '^\$(.+)2(\d+) ${md[1]}_${md[2]}', d.instance.config['rename_rule2']
+  end
+
+  def test_parse_rename_rule
+    parsed = Fluent::RenameKeyOutput.new.parse_rename_rule '(reg)(exp) ${md[1]} ${md[2]}'
+    assert_equal 2, parsed.length
+    assert_equal '(reg)(exp)', parsed[0]
+    assert_equal '${md[1]} ${md[2]}', parsed[1]
+  end
+
+  def test_parse_replace_rule_with_replacement
+    # Replace hyphens with underscores
+    parsed = Fluent::RenameKeyOutput.new.parse_replace_rule '- _'
+    assert_equal 2, parsed.length
+    assert_equal '-', parsed[0]
+    assert_equal '_', parsed[1]
+  end
+
+  def test_parse_replace_rule_without_replacement
+    # Remove all parenthesis hyphens and spaces
+    parsed = Fluent::RenameKeyOutput.new.parse_replace_rule '[()-\s]'
+    assert_equal 2, parsed.length
+    assert_equal '[()-\s]', parsed[0]
+    assert parsed[1].nil?
+  end
+
+  def test_rename_rule_emit_deep_rename_hash
+    d = create_driver RENAME_RULE_CONFIG
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => {'$key3' => 'value3', '$key4'=> {'$key5' => 'value5'} }
+    end
+
+    emits = d.emits
+    assert_equal %w[x$key1 key2], emits[0][2].keys
+    assert_equal %w[x$key3 x$key4], emits[0][2]['key2'].keys
+    assert_equal ['x$key5'], emits[0][2]['key2']['x$key4'].keys
+  end
+
+  def test_rename_rule_emit_deep_rename_array
+    d = create_driver RENAME_RULE_CONFIG
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => [{'$key3' => 'value3'}, {'$key4'=> {'$key5' => 'value5'}}]
+    end
+
+    emits = d.emits
+    assert_equal %w[x$key3 x$key4], emits[0][2]['key2'].flat_map(&:keys)
+    assert_equal ['x$key5'], emits[0][2]['key2'][1]['x$key4'].keys
+  end
+
+  def test_rename_rule_emit_deep_rename_off
+    config = %Q[
+      #{RENAME_RULE_CONFIG}
+      deep_rename false
+    ]
+
+    d = create_driver config
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => {'$key3'=>'value3', '$key4'=> 'value4'}
+    end
+
+    emits = d.emits
+    assert_equal %w[$key3 $key4], emits[0][2]['key2'].keys
+  end
+
+  def test_rename_rule_emit_with_match_data
+    d = create_driver 'rename_rule1 (\w+)\s(\w+)\s(\w+) ${md[3]} ${md[2]} ${md[1]}'
+    d.run do
+      d.emit 'key1 key2 key3' => 'value'
+    end
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ['key3 key2 key1'], emits[0][2].keys
+  end
+
+  def test_multiple_rename_rules_emit
+    config_multiple_rules = %q[
+      rename_rule1 ^(\w+)\s1 ${md[1]}_1
+      rename_rule2 ^(\w+)\s2 ${md[1]}_2
+    ]
+
+    d = create_driver config_multiple_rules
+    d.run do
+      d.emit 'key 1' => 'value1', 'key 2' => 'value2'
+    end
+
+    emits = d.emits
+    assert_equal %w[key_1 key_2], emits[0][2].keys
+  end
+
+  def test_replace_rule_emit_deep_rename_hash
+    d = create_driver 'replace_rule1 ^(\$) x'
+
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => { 'key3' => 'value3', '$key4' => 'value4' }
+    end
+    emits = d.emits
+    assert_equal %w[xkey1 key2], emits[0][2].keys
+    assert_equal %w[key3 xkey4], emits[0][2]['key2'].keys
+  end
+
+  def test_replace_rule_emit_with_match_data
+    d = create_driver 'rename_rule1 (\w+)\s(\w+)\s(\w+) ${md[3]} ${md[2]} ${md[1]}'
+    d.run do
+      d.emit 'key1 key2 key3' => 'value'
+    end
+    emits = d.emits
+    assert_equal 1, emits.length
+    assert_equal ['key3 key2 key1'], emits[0][2].keys
+  end
+
+  def test_replace_rule_emit_deep_rename_array
+    d = create_driver 'replace_rule1 ^(\$) x${md[1]}'
+
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => [{'$key3' => 'value3'}, {'$key4' => {'$key5' => 'value5'}}]
+    end
+
+    emits = d.emits
+    assert_equal %w[x$key3 x$key4], emits[0][2]['key2'].flat_map(&:keys)
+    assert_equal %w[x$key5], emits[0][2]['key2'][1]['x$key4'].keys
+  end
+
+  def test_replace_rule_emit_deep_rename_off
+    config = %Q[
+      #{REPLACE_RULE_CONFIG}
+      deep_rename false
+    ]
+
+    d = create_driver config
+    d.run do
+      d.emit '$key1' => 'value1', 'key2' => {'$key3'=>'value3', '$key4'=> 'value4'}
+    end
+
+    emits = d.emits
+    assert_equal %w[$key3 $key4], emits[0][2]['key2'].keys
+  end
+
+  def test_replace_rule_emit_remove_matched_when_no_replacement
+    d = create_driver 'replace_rule1 [\s/()]'
+    d.run do
+      d.emit 'key (/1 )' => 'value1'
+    end
+
+    emits = d.emits
+    assert_equal %w[key1], emits[0][2].keys
+  end
+
+  def test_multiple_replace_rules_emit
+    config_multiple_rules = %q[
+      replace_rule1 ^(\w+)\s(\d) ${md[1]}${md[2]}
+      replace_rule2 [\s()]
+    ]
+
+    d = create_driver config_multiple_rules
+    d.run do
+      d.emit 'key 1' => 'value1', 'key (2)' => 'value2'
+    end
+
+    emits = d.emits
+    assert_equal %w[key1 key2], emits[0][2].keys
+  end
+
+  def test_combined_rename_rule_and_replace_rule
+    config_combined_rules = %q[
+      rename_rule1 ^(.+)\s(one) ${md[1]}1
+      replace_rule2 [\s()]
+    ]
+
+    d = create_driver config_combined_rules
+    d.run do
+      d.emit '(key) one (x)' => 'value1', 'key (2)' => 'value2'
+    end
+
+    emits = d.emits
+    assert_equal %w[key1 key2], emits[0][2].keys
+  end
+end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-rename-key
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Shunwen Hsiao
 - Julian Grinblat
+- Hiroshi Hatake
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
+date: 2016-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -17,56 +18,62 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.0
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '11.3'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.8'
 description: 
 email:
 - hsiaoshunwen@gmail.com
@@ -81,8 +88,11 @@ files:
 - README.md
 - Rakefile
 - fluent-plugin-rename-key.gemspec
+- lib/fluent/plugin/filter_rename_key.rb
 - lib/fluent/plugin/out_rename_key.rb
+- lib/fluent/plugin/rename_key_util.rb
 - test/helper.rb
+- test/plugin/test_filter_rename_key.rb
 - test/plugin/test_out_rename_key.rb
 homepage: https://github.com/shunwen/fluent-plugin-rename-key
 licenses:
@@ -96,7 +106,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -104,9 +114,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.2
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Fluentd output plugin. Rename keys which match given regular expressions,
   assign new tags and re-emit the records.
 test_files: []
+has_rdoc: