Merge pull request #33 from smallcreep/Replace

Implement replace

Author: repeatedly

README.md

@@ -148,6 +148,48 @@ then you got new record like below:
 {"key1":"hoge", "key2":"foo"}
 ```
 
+### replace_keys_value
+
+If you want to replace specific value for keys you can use `replace` section.
+
+```conf
+<filter pattern>
+  @type record_modifier
+
+  # replace key key1
+  <replace>
+    # your key name
+    key key1
+    # your regexp
+    expression /^(?<start>.+).{2}(?<end>.+)$/
+    # replace string
+    replace \\k<start>ors\\k<end>
+  </replace>
+  # replace key key2
+  <replace>
+    # your key name
+    key key2
+    # your regexp
+    expression /^(.{1}).{2}(.{1})$/
+    # replace string
+    replace \\1ors\\2
+  </replace>
+</filter>
+```
+
+If following record is passed:
+
+```js
+{"key1":"hoge", "key2":"hoge", "key3":"bar"}
+```
+
+then you got new record like below:
+
+```js
+{"key1":"horse", "key2":"horse", "key3":"bar"}
+```
+
+
 ### Ruby code trick for complex logic
 
 If you need own complex logic in filter, writing filter plugin is better. But if you don't want to write new plugin, you can use temporal key trick like below:
@@ -174,12 +216,6 @@ In v0.10, you can use `record_modifier` output to emulate filter. `record_modifi
       foo bar
     </match>
 
-## TODO
-
-* Adding following features if needed
-
-    * Replace record value
-
 ## Copyright
 
 <table>

lib/fluent/plugin/filter_record_modifier.rb

@@ -31,6 +31,22 @@ class Plugin::RecordModifierFilter < Plugin::Filter
 This option is exclusive with `remove_keys`.
 DESC
 
+    config_section :replace, param_name: :replaces, multi: true do
+                 desc"The field name to which the regular expression is applied"
+                 config_param :key, :string
+                 desc "The regular expression"
+                 config_param :expression do |value|
+                   if value.start_with?("/") && value.end_with?("/")
+                     Regexp.compile(value[1..-2])
+                   else
+                     $log.warn("You should use \"pattern /#{value}/\" instead of \"pattern #{value}\"")
+                     Regexp.compile(value)
+                   end
+                 end
+                 desc "The replacement string"
+                 config_param :replace, :string
+    end
+
     def configure(conf)
       super
 
@@ -97,6 +113,12 @@ def filter(tag, time, record)
         record = modified
       end
 
+      if @replaces.any?
+        @replaces.each {|replace|
+          record[replace.key] = record[replace.key].gsub(replace.expression, replace.replace) if record.include?(replace.key) && replace.expression.match(record[replace.key])
+        }
+      end
+
       record = change_encoding(record) if @char_encoding
       record
     end

test/test_filter_record_modifier.rb

@@ -141,6 +141,43 @@ def test_prepare_values
     assert_equal [{"k1" => 'v', "test_key" => 'foo'}], d.filtered.map(&:last)
   end
 
+  def test_replace_values
+    d = create_driver %[
+        <replace>
+          key k1
+          expression /^(?<start>.+).{2}(?<end>.+)$/
+          replace \\k<start>ors\\k<end>
+        </replace>
+        <replace>
+          key k2
+          expression /^(.{1}).{2}(.{1})$/
+          replace \\1ors\\2
+        </replace>
+    ]
+
+    d.run(default_tag: @tag) do
+      d.feed("k1" => 'hoge', "k2" => 'hoge', "k3" => 'bar')
+    end
+
+    assert_equal [{"k1" => 'horse', "k2" => 'horse', "k3" => 'bar'}], d.filtered.map(&:last)
+  end
+
+  def test_does_not_replace
+    d = create_driver %[
+        <replace>
+          key k1
+          expression /^(?<start>.+).{2}(?<end>.+)$/
+          replace \\k<start>ors\\k<end>
+        </replace>
+    ]
+
+    d.run(default_tag: @tag) do
+      d.feed("k1" => 'hog')
+    end
+
+    assert_equal [{"k1" => 'hog'}], d.filtered.map(&:last)
+  end
+
   sub_test_case 'frozen check' do
     def test_set_char_encoding
       d = create_driver %[