fluent-plugin-map 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4ad3a04fd6a20ad899c5bbcdc8677c4a168d99e
-  data.tar.gz: e71017da3b0fc6996bd61cda02a65250115e0c0d
+  metadata.gz: 4ef5c9646ede101aef6159afc29fe2c23f71ae13
+  data.tar.gz: 4b85b98b5bc707817699449ae65b7a9fef64f670
 SHA512:
-  metadata.gz: b31eac601f6eaca70e7a13248ffd0d9933577e457358a41ad52cda3652d79fa4d13e2295d126d86a8a543bd77f363e60a52042fc3af76f2e5cc2a74e9d564649
-  data.tar.gz: cae9c24f03345592f87087e3ac1ab1f5557bbc57cd3825fea2c94a94956e4201f0771f4d5dcde31e53c54e761eb8f3f239c1e4f3025c279dc1b3001a6334e7bc
+  metadata.gz: d022df78ec9b3e3b9eaf60b7c24f48f2b21e455f4e551ad147807e76bd01a78a7f7de89ea7ab1ed6e5edf5d0232789c6bdf7b9b47f0462539c4c46e910e14afa
+  data.tar.gz: 5927afac4efd90c7b3a5a85901db2e93328f4b2144ba6e87d30312f9988e4612108411cd726656c3120eaa6a9a21d489603e18ed9749cd28ceed3ae14279033c

data/README.markdown

@@ -4,27 +4,93 @@
 
 fluent-plugin-map(out\_map) is the non-buffered plugin that can convert an event log to different event log(s)
 
-## Example
+## MapFilter
+
+### Example
+
+This sample config filter code file and time file.
+
+    <source>
+      @type tail
+      format apache
+      path /var/log/httpd-access.log
+      tag tag
+      @label @raw
+    </source>
+    <label @raw>
+      <match **>
+        @type copy
+        <store>
+          @type relabel
+          @label @code
+        </store>
+        <store>
+          @type relabel
+          @label @time
+        </store>
+      </match>
+    </label>
+    <label @code>
+      <filter **>
+        @type map
+        map ([time, {"code" => record["code"].to_i}])
+      </filter>
+      <match **>
+        @type file
+        path code.log
+      </match>
+    </label>
+    <label @time>
+      <filter **>
+        @type map
+        map ([time, {"time" => record["time"].to_i}])
+      </filter>
+      <match **>
+        @type file
+        path time.log
+      </match>
+    </label>
+
+
+The parameter "map" can use 2 variables in event log; time, record. The format of time is an integer number of seconds since the Epoch. The format of record is hash.
+The config file parses # as the begin of comment. So the "map" value cannot use #{tag} operation.
+This plugin can output multi logs by seting multi to true.
+
+If you don't use multi option, you can use time, record parameter. The 2 following filter directive is same:
+
+    <filter tag>
+      @type map
+      map ([time, {"code" => record["code"].to_i}])
+    </filter>
+    <filter tag>
+      @type map
+      time time
+      record ({"code" => record["code"].to_i})
+    </filter>
+
+## MapOutput
+
+### Example
 
 This sample config output code file and time file.
 
     <source>
-      type tail
+      @type tail
       format apache
       path /var/log/httpd-access.log
       tag tag
     </source>
     <match tag>
-      type map
+      @type map
       map ([["code." + tag, time, {"code" => record["code"].to_i}], ["time." + tag, time, {"time" => record["time"].to_i}]])
       multi true
     </match>
     <match code.tag>
-      type file
+      @type file
       path code.log
     </match>
     <match time.tag>
-      type file
+      @type file
       path time.log
     </match>
 
@@ -36,17 +102,20 @@ This plugin can output multi logs by seting multi to true.
 If you don't use multi option, you can use key, time, record parameter. The 2 following match directive is same:
 
     <match tag>
-      type map
+      @type map
       map (["code." + tag, time, {"code" => record["code"].to_i}])
     </match>
     <match tag>
-      type map
+      @type map
       tag ("code." + tag)
       time time
       record ({"code" => record["code"].to_i})
     </match>
 
-Note: you have to wrap some configuration values with parenthesis like `("code." + tag)`, to avoid parsing by Fluentd itself.
+
+## Note
+
+you have to wrap some configuration values with parenthesis like `("code." + tag)`, to avoid parsing by Fluentd itself.
 See also: [Fluentd | Configuration File | Format tips](http://docs.fluentd.org/articles/config-file#format-tips)
 
 ## Copyright

data/fluent-plugin-map.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-map"
-  s.version     = "0.1.0"
+  s.version     = "0.1.1"
   s.authors     = ["Kohei Tomita", "Hiroshi Hatake", "Kenji Okomoto"]
   s.email       = ["tommy.fmale@gmail.com", "cosmo0920.oucc@gmail.com", "okkez000@gmail.com"]
   s.homepage    = "https://github.com/fluent-plugins-nursery/fluent-plugin-map"

data/lib/fluent/plugin/filter_map.rb

@@ -0,0 +1,89 @@
+#
+# fluent-plugin-map
+#
+#    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/map_support'
+require 'fluent/plugin/map_config_param'
+require 'fluent/plugin/parse_map_mixin'
+
+module Fluent
+  class MapFilter < Fluent::Filter
+    Fluent::Plugin.register_filter('map', self)
+
+    include Fluent::MapConfigParam
+    include Fluent::ParseMap::Mixin
+
+    def configure(conf)
+      super
+      @format = determine_format()
+      configure_format()
+      @map = create_map(conf)
+      @map_support = Fluent::MapSupport.new(@map, self)
+    end
+
+    def determine_format()
+      if @format
+        @format
+      elsif @map
+        "map"
+      elsif @time && @record
+        "record"
+      else
+        raise Fluent::ConfigError, "Any of map, 2 parameters(time, and record) or format is required "
+      end
+    end
+
+    def configure_format()
+      case @format
+      when "map"
+        # pass
+      when "record"
+        raise Fluent::ConfigError, "multi and 2 parameters(time, and record) are not compatible" if @multi
+      when "multimap"
+        # pass.
+      else
+        raise Fluent::ConfigError, "format #{@format} is invalid."
+      end
+    end
+
+    def create_map(conf)
+      # return string like double array.
+      case @format
+      when "map"
+        parse_map()
+      when "record"
+        "[[#{@time}, #{@record}]]"
+      when "multimap"
+        parse_multimap(conf)
+      end
+    end
+
+    def filter_stream(tag, es)
+      begin
+        new_es = Fluent::MultiEventStream.new
+        tag_output_es = @map_support.do_map(tag, es)
+        tag_output_es.each_pair do |tag, output_es|
+          output_es.each{|time, record|
+            new_es.add(time, record)
+          }
+        end
+        new_es
+      rescue SyntaxError => e
+        log.error "map command is syntax error: #{@map}"
+        e #for test
+      end
+    end
+  end
+end

data/lib/fluent/plugin/map_config_param.rb

@@ -0,0 +1,30 @@
+#
+# fluent-plugin-map
+#
+#    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
+  module MapConfigParam
+    def self.included(klass)
+      klass.instance_eval {
+        config_param :map, :string, :default => nil
+        config_param :time, :string, :default => nil
+        config_param :record, :string, :default => nil
+        config_param :multi, :bool, :default => false
+        config_param :timeout, :time, :default => 1
+        config_param :format, :string, :default => nil
+      }
+    end
+  end
+end

data/lib/fluent/plugin/map_support.rb

@@ -0,0 +1,113 @@
+#
+# fluent-plugin-map
+#
+#    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 MapSupport
+    def initialize(map, plugin)
+      @map = map
+      @plugin = plugin
+      if defined?(Fluent::Filter) and plugin.is_a?(Fluent::Filter)
+        singleton_class.module_eval(<<-CODE)
+          def map_func(time, record)
+            #{@map}
+          end
+        CODE
+        class << self
+          alias_method :generate_tuples, :generate_tuples_filter
+          alias_method :do_map, :do_map_filter
+        end
+      elsif plugin.is_a?(Fluent::Output)
+        singleton_class.module_eval(<<-CODE)
+          def map_func(tag, time, record)
+            #{@map}
+          end
+        CODE
+        class << self
+          alias_method :generate_tuples, :generate_tuples_output
+          alias_method :do_map, :do_map_output
+        end
+      end
+    end
+
+    def do_map(tag, es)
+      # This method will be overwritten in #initailize.
+    end
+
+    def do_map_filter(tag, es)
+      tuples = generate_tuples(tag, es)
+
+      tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
+      tuples.each do |time, record|
+        if time == nil || record == nil
+          raise SyntaxError.new
+        end
+        tag_output_es[tag].add(time, record)
+        @plugin.log.trace { [tag, time, record].inspect }
+      end
+      tag_output_es
+    end
+
+    def do_map_output(tag, es)
+      tuples = generate_tuples(tag, es)
+
+      tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
+      tuples.each do |tag, time, record|
+        if time == nil || record == nil
+          raise SyntaxError.new
+        end
+        tag_output_es[tag].add(time, record)
+        @plugin.log.trace { [tag, time, record].inspect }
+      end
+      tag_output_es
+    end
+
+    def generate_tuples
+      # This method will be overwritten in #initailize.
+    end
+
+    def generate_tuples_filter(tag, es)
+      tuples = []
+      es.each {|time, record|
+        timeout_block do
+          new_tuple = map_func(time, record)
+          tuples.concat new_tuple
+        end
+      }
+      tuples
+    end
+
+    def generate_tuples_output(tag, es)
+      tuples = []
+      es.each {|time, record|
+        timeout_block do
+          new_tuple = map_func(tag, time, record)
+          tuples.concat new_tuple
+        end
+      }
+      tuples
+    end
+
+    def timeout_block
+      begin
+        Timeout.timeout(@plugin.timeout){
+          yield
+        }
+      rescue Timeout::Error
+        @plugin.log.error {"Timeout: #{Time.at(time)} #{tag} #{record.inspect}"}
+      end
+    end
+  end
+end

data/lib/fluent/plugin/out_map.rb

@@ -14,10 +14,17 @@
 #    limitations under the License.
 #
 
+require 'fluent/plugin/map_support'
+require 'fluent/plugin/map_config_param'
+require 'fluent/plugin/parse_map_mixin'
+
 module Fluent
   class MapOutput < Fluent::Output
     Fluent::Plugin.register_output('map', self)
 
+    include Fluent::MapConfigParam
+    include Fluent::ParseMap::Mixin
+
     # Define `router` method of v0.12 to support v0.10 or earlier
     unless method_defined?(:router)
       define_method("router") { Fluent::Engine }
@@ -27,27 +34,15 @@ module Fluent
       define_method("log") { $log }
     end
 
-    config_param :map, :string, :default => nil
-    config_param :tag, :string, :default => nil
     config_param :key, :string, :default => nil #deprecated
-    config_param :time, :string, :default => nil
-    config_param :record, :string, :default => nil
-    config_param :multi, :bool, :default => false
-    config_param :timeout, :time, :default => 1
-    config_param :format, :string, :default => nil
-
-    MMAP_MAX_NUM = 50
+    config_param :tag, :string, :default => nil
 
     def configure(conf)
       super
       @format = determine_format()
       configure_format()
       @map = create_map(conf)
-      singleton_class.module_eval(<<-CODE)
-        def map_func(tag, time, record)
-          #{@map}
-        end
-      CODE
+      @map_support = Fluent::MapSupport.new(@map, self)
     end
 
     def determine_format()
@@ -58,7 +53,7 @@ module Fluent
       elsif (@tag || @key) && @time && @record
         "record"
       else
-        raise ConfigError, "Any of map, 3 parameters(tag, time, and record) or format is required "
+        raise Fluent::ConfigError, "Any of map, 3 parameters(tag, time, and record) or format is required "
       end
     end
 
@@ -68,11 +63,11 @@ module Fluent
         # pass
       when "record"
         @tag ||= @key
-        raise ConfigError, "multi and 3 parameters(tag, time, and record) are not compatible" if @multi
+        raise Fluent::ConfigError, "multi and 3 parameters(tag, time, and record) are not compatible" if @multi
       when "multimap"
         # pass.
       else
-        raise ConfigError, "format #{@format} is invalid."
+        raise Fluent::ConfigError, "format #{@format} is invalid."
       end
     end
 
@@ -88,45 +83,9 @@ module Fluent
       end
     end
 
-    def parse_map()
-      if @multi
-        @map
-      else
-        "[#{@map}]"
-      end
-    end
-
-    def parse_multimap(conf)
-      check_mmap_range(conf)
-
-      prev_mmap = nil
-      result_mmaps = (1..MMAP_MAX_NUM).map { |i|
-        mmap = conf["mmap#{i}"]
-        if (i > 1) && prev_mmap.nil? && !mmap.nil?
-          raise ConfigError, "Jump of mmap index found. mmap#{i - 1} is missing."
-        end
-        prev_mmap = mmap
-        next if mmap.nil?
-
-        mmap
-      }.compact.join(',')
-      "[#{result_mmaps}]"
-    end
-
-    def check_mmap_range(conf)
-      invalid_mmap = conf.keys.select { |k|
-        m = k.match(/^mmap(\d+)$/)
-        m ? !((1..MMAP_MAX_NUM).include?(m[1].to_i)) : false
-      }
-      unless invalid_mmap.empty?
-        raise ConfigError, "Invalid mmapN found. N should be 1 - #{MMAP_MAX_NUM}: " + invalid_mmap.join(",")
-      end
-    end
-
-
     def emit(tag, es, chain)
       begin
-        tag_output_es = do_map(tag, es)
+        tag_output_es = @map_support.do_map(tag, es)
         tag_output_es.each_pair do |tag, output_es|
           router.emit_stream(tag, output_es)
         end
@@ -138,38 +97,5 @@ module Fluent
         e #for test
       end
     end
-
-    def do_map(tag, es)
-      tuples = generate_tuples(tag, es)
-
-      tag_output_es = Hash.new{|h, key| h[key] = MultiEventStream::new}
-      tuples.each do |tag, time, record|
-        if time == nil || record == nil
-          raise SyntaxError.new
-        end
-        tag_output_es[tag].add(time, record)
-        log.trace { [tag, time, record].inspect }
-      end
-      tag_output_es
-    end
-
-    def generate_tuples(tag, es)
-      tuples = []
-      es.each {|time, record|
-        new_tuple = map_func(tag, time, record)
-        tuples.concat new_tuple
-      }
-      tuples
-    end
-
-    def timeout_block(tag, time, record)
-      begin
-        Timeout.timeout(@timeout){
-          yield
-        }
-      rescue Timeout::Error
-        log.error {"Timeout: #{Time.at(time)} #{tag} #{record.inspect}"}
-      end
-    end
   end
 end

data/lib/fluent/plugin/parse_map_mixin.rb

@@ -0,0 +1,59 @@
+#
+# fluent-plugin-map
+#
+#    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
+  module ParseMap
+    module Mixin
+
+      MMAP_MAX_NUM = 50
+
+      def parse_map()
+        if @multi
+          @map
+        else
+          "[#{@map}]"
+        end
+      end
+
+      def parse_multimap(conf)
+        check_mmap_range(conf)
+
+        prev_mmap = nil
+        result_mmaps = (1..MMAP_MAX_NUM).map { |i|
+          mmap = conf["mmap#{i}"]
+          if (i > 1) && prev_mmap.nil? && !mmap.nil?
+            raise Fluent::ConfigError, "Jump of mmap index found. mmap#{i - 1} is missing."
+          end
+          prev_mmap = mmap
+          next if mmap.nil?
+
+          mmap
+        }.compact.join(',')
+        "[#{result_mmaps}]"
+      end
+
+      def check_mmap_range(conf)
+        invalid_mmap = conf.keys.select { |k|
+          m = k.match(/^mmap(\d+)$/)
+          m ? !((1..MMAP_MAX_NUM).include?(m[1].to_i)) : false
+        }
+        unless invalid_mmap.empty?
+          raise Fluent::ConfigError, "Invalid mmapN found. N should be 1 - #{MMAP_MAX_NUM}: " + invalid_mmap.join(",")
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -23,3 +23,4 @@ unless ENV.has_key?('VERBOSE')
 end
 
 require "fluent/plugin/out_map"
+require "fluent/plugin/filter_map" if defined?(Fluent::Filter)

data/test/plugin/test_filter_map.rb

@@ -0,0 +1,182 @@
+require 'helper'
+
+class MapFilterTest < Test::Unit::TestCase
+  def setup
+    omit "Use Fluentd v0.12 or later" unless defined?(Fluent::Filter)
+    Fluent::Test.setup
+  end
+
+  CONFIG = %[
+    map [time, record]
+    multi false
+  ]
+
+  def create_driver(conf = CONFIG, tag='test.input')
+    Fluent::Test::FilterTestDriver.new(Fluent::MapFilter, tag).configure(conf)
+  end
+
+  def test_syntax_error
+    tag = "tag"
+    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    record = {'code' => '300'}
+
+    #map is syntax error
+    syntax_error_config = %[
+      map time.
+    ]
+    assert_raise SyntaxError do
+      create_driver(syntax_error_config, tag)
+    end
+  end
+
+  def test_syntax_error2
+    tag = "tag"
+    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    record = {'code' => '300'}
+
+    #map output lligal format
+    syntax_error_config = %[
+      map time
+    ]
+    d1 = create_driver(syntax_error_config, tag)
+    es = Fluent::OneEventStream.new(time, record)
+    e =  d1.instance.filter_stream(tag, es)
+    assert e.kind_of?(SyntaxError)
+  end
+
+  def test_tag_convert_using_time_record
+    tag = 'tag.raw'
+    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    record = {'code' => '300'}
+
+    d1 = create_driver %[
+      time time
+      record record
+    ], tag
+    d1.run do
+      d1.emit(record, time)
+    end
+    filtered = d1.filtered_as_array
+    assert_equal 1, filtered.length
+    assert_equal ["tag.raw", time, record], filtered[0]
+  end
+
+  #deprected specification test
+  def test_config_error_time
+    tag = "tag"
+    record = {'code' => '300'}
+
+    #require time
+    assert_raise(Fluent::ConfigError){
+      create_driver %[
+        record record
+      ], tag
+    }
+  end
+
+  def test_config_error_record
+    tag = "tag"
+    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+
+    #require record
+    assert_raise(Fluent::ConfigError){
+      create_driver %[
+        time time
+      ], tag
+    }
+  end
+
+  def test_config_error_multi
+    tag = "tag"
+    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    record = {'code' => '300'}
+
+    #require time
+    assert_raise(Fluent::ConfigError){
+      create_driver %[
+        time time
+        record record
+        multi true
+      ], tag
+    }
+  end
+
+  def test_config_error_sleep
+    tag = 'tag'
+    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    record = {'code' => '300'}
+
+    assert_raise(SyntaxError) {
+      create_driver %[
+        tag "newtag"
+        time sleep 10
+        record record
+        timeout 1s
+      ], tag
+    }
+  end
+
+  # Add format test
+  ## test format type (map, record, maps)
+  ## test Backward compatibility without format
+  ##
+
+  def test_convert_format_map
+    tag = 'tag.raw'
+    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    record = {'code1' => '300', 'code2' => '400'}
+
+    d1 = create_driver %[
+      format map
+      map [[time, record["code1"]], [time, record["code2"]]]
+      multi true
+    ], tag
+    d1.run do
+      d1.emit(record, time)
+    end
+    filtered = d1.filtered_as_array
+    assert_equal 2, filtered.length
+    assert_equal tag, d1.tag # tag shouldn't be changed
+    assert_equal ["tag.raw", time, record["code1"]], filtered[0]
+    assert_equal ["tag.raw", time, record["code2"]], filtered[1]
+  end
+
+  def test_tag_convert_format_record
+    tag = 'tag.raw'
+    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    record = {'code' => '300'}
+
+    d1 = create_driver %[
+      format record
+      time time
+      record record
+    ], tag
+    d1.run do
+      d1.emit(record, time)
+    end
+    filtered = d1.filtered_as_array
+    assert_equal 1, filtered.length
+    assert_equal tag, d1.tag # tag shouldn't be changed
+    assert_equal ["tag.raw", time, record], filtered[0]
+  end
+
+  def test_convert_format_multimap
+    tag = 'tag.raw'
+    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    record = {'code1' => '300', 'code2' => '400'}
+
+    d1 = create_driver %[
+      format multimap
+      mmap1 [time, record["code1"]]
+      mmap2 [time, record["code2"]]
+    ], tag
+    d1.run do
+      d1.emit(record, time)
+    end
+    filtered = d1.filtered_as_array
+    assert_equal 2, filtered.length
+    assert_equal tag, d1.tag # tag shouldn't be changed
+    assert_equal ["tag.raw", time, record["code1"]], filtered[0]
+    assert_equal ["tag.raw", time, record["code2"]], filtered[1]
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-map
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kohei Tomita
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -95,8 +95,13 @@ files:
 - gemfiles/fluentd_0_10.gemfile
 - gemfiles/fluentd_0_12.gemfile
 - gemfiles/fluentd_0_14.gemfile
+- lib/fluent/plugin/filter_map.rb
+- lib/fluent/plugin/map_config_param.rb
+- lib/fluent/plugin/map_support.rb
 - lib/fluent/plugin/out_map.rb
+- lib/fluent/plugin/parse_map_mixin.rb
 - test/helper.rb
+- test/plugin/test_filter_map.rb
 - test/plugin/test_out_map.rb
 homepage: https://github.com/fluent-plugins-nursery/fluent-plugin-map
 licenses:
@@ -125,4 +130,5 @@ summary: fluent-plugin-map is the non-buffered plugin that can convert an event
   to different event log(s).
 test_files:
 - test/helper.rb
+- test/plugin/test_filter_map.rb
 - test/plugin/test_out_map.rb