logstash-filter-mutate 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2373e3dacb12fba8e76b73ad1a25ae4936fa4ca
-  data.tar.gz: 61b0f5308de9d387655f822ce13cd15536fa9b1f
+  metadata.gz: fd1c151098361f3b30635ab7d3091585514f2f6a
+  data.tar.gz: bc60754791477e9e23211cc2a2da52e5f26e95de
 SHA512:
-  metadata.gz: 6590939b5d4885d99efa079852caca9c99571b4296c9f0eec30a0cf54e52f56031231897818ce7fd67e10a15b8643b71ad53ea6b5717160fe9a27750cb7ac672
-  data.tar.gz: c629d3ee574f556fce2b33dfff71f77864811d77761401bb117aebdfc965aacc1366046a948b97f44121032d2af327c7013ddb3ebf67d10244ed28aa22e4dcf5
+  metadata.gz: 59c5e5b86234a514c5cf5ce735c05f788117fdbd7aff5476a0b2fb034022c7a7e35f68c76132f381d42a63fa8f5ccfd654899afcbb2b9b16af3569dd5a9ecdc5
+  data.tar.gz: 49b29f761184665f0f4da21a2bb3a692732d5c801f93cd67d63b72cdb91613194f77cf031102f33c99a748eb683c0b11a6e1bffad3ed2c3c579b6c3f81d1125f

data/CHANGELOG.md

@@ -1,5 +1,8 @@
+## 2.0.3
+ - Code cleanups and fix field assignments
+
 ## 2.0.0
- - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully, 
+ - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully,
    instead of using Thread.raise on the plugins' threads. Ref: https://github.com/elastic/logstash/pull/3895
  - Dependency on logstash-core update to 2.0
 

data/README.md

@@ -1,5 +1,8 @@
 # Logstash Plugin
 
+[![Build
+Status](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Filters/job/logstash-plugin-filter-mutate-unit/badge/icon)](http://build-eu-00.elastic.co/view/LS%20Plugins/view/LS%20Filters/job/logstash-plugin-filter-mutate-unit/)
+
 This is a plugin for [Logstash](https://github.com/elastic/logstash).
 
 It is fully free and fully open source. The license is Apache 2.0, meaning you are pretty much free to use it however you want in whatever way.

data/lib/logstash/filters/mutate.rb

@@ -33,7 +33,7 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
   # filters.
   config :remove, :validate => :array, :deprecated => true
 
-  # Replace a field with a new value. The new value can include %{foo} strings
+  # Replace a field with a new value. The new value can include `%{foo}` strings
   # to help you build a new value from other parts of the event.
   #
   # Example:
@@ -176,24 +176,33 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
   #     }
   config :merge, :validate => :hash
 
-  public
+  TRUE_REGEX = (/^(true|t|yes|y|1)$/i).freeze
+  FALSE_REGEX = (/^(false|f|no|n|0)$/i).freeze
+  CONVERT_PREFIX = "convert_".freeze
+
   def register
     valid_conversions = %w(string integer float boolean)
     # TODO(sissel): Validate conversion requests if provided.
     @convert.nil? or @convert.each do |field, type|
       if !valid_conversions.include?(type)
-        raise LogStash::ConfigurationError, I18n.t("logstash.agent.configuration.invalid_plugin_register",
-          :plugin => "filter", :type => "mutate",
-          :error => "Invalid conversion type '#{type}', expected one of '#{valid_conversions.join(',')}'")
+        raise LogStash::ConfigurationError, I18n.t(
+          "logstash.agent.configuration.invalid_plugin_register",
+          :plugin => "filter",
+          :type => "mutate",
+          :error => "Invalid conversion type '#{type}', expected one of '#{valid_conversions.join(',')}'"
+        )
       end
-    end # @convert.each
+    end
 
     @gsub_parsed = []
     @gsub.nil? or @gsub.each_slice(3) do |field, needle, replacement|
       if [field, needle, replacement].any? {|n| n.nil?}
-        raise LogStash::ConfigurationError, I18n.t("logstash.agent.configuration.invalid_plugin_register",
-          :plugin => "filter", :type => "mutate",
-          :error => "Invalid gsub configuration #{[field, needle, replacement]}. gsub requires 3 non-nil elements per config entry")
+        raise LogStash::ConfigurationError, I18n.t(
+          "logstash.agent.configuration.invalid_plugin_register",
+          :plugin => "filter",
+          :type => "mutate",
+          :error => "Invalid gsub configuration #{[field, needle, replacement]}. gsub requires 3 non-nil elements per config entry"
+        )
       end
 
       @gsub_parsed << {
@@ -202,12 +211,9 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
         :replacement  => replacement
       }
     end
-  end # def register
+  end
 
-  public
   def filter(event)
-    
-
     rename(event) if @rename
     update(event) if @update
     replace(event) if @replace
@@ -222,17 +228,17 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
     merge(event) if @merge
 
     filter_matched(event)
-  end # def filter
+  end
 
   private
+
   def remove(event)
     @remove.each do |field|
       field = event.sprintf(field)
       event.remove(field)
     end
-  end # def remove
+  end
 
-  private
   def rename(event)
     @rename.each do |old, new|
       old = event.sprintf(old)
@@ -240,98 +246,94 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
       next unless event.include?(old)
       event[new] = event.remove(old)
     end
-  end # def rename
+  end
 
-  private
   def update(event)
     @update.each do |field, newvalue|
       next unless event.include?(field)
       event[field] = event.sprintf(newvalue)
     end
-  end # def update
+  end
 
-  private
   def replace(event)
     @replace.each do |field, newvalue|
       event[field] = event.sprintf(newvalue)
     end
-  end # def replace
+  end
 
   def convert(event)
     @convert.each do |field, type|
       next unless event.include?(field)
       original = event[field]
       # calls convert_{string,integer,float,boolean} depending on type requested.
-      converter = method("convert_" + type)
-      if original.nil?
-        next
-      elsif original.is_a?(Hash)
-        @logger.debug("I don't know how to type convert a hash, skipping",
-                      :field => field, :value => original)
-        next
-      elsif original.is_a?(Array)
-        value = original.map { |v| converter.call(v) }
+      converter = method(CONVERT_PREFIX + type)
+
+      case original
+      when Hash
+        @logger.debug? && @logger.debug("I don't know how to type convert a hash, skipping", :field => field, :value => original)
+      when Array
+        event[field] = original.map { |v| converter.call(v) }
+      when NilClass
+        # ignore
       else
-        value = converter.call(original)
+        event[field] = converter.call(original)
       end
-      event[field] = value
     end
-  end # def convert
+  end
 
   def convert_string(value)
     # since this is a filter and all inputs should be already UTF-8
     # we wont check valid_encoding? but just force UTF-8 for
     # the Fixnum#to_s case which always result in US-ASCII
+    # also not that force_encoding checks current encoding against the
+    # target encoding and only change if necessary, so calling
+    # valid_encoding? is redundant
     # see https://twitter.com/jordansissel/status/444613207143903232
-    return value.to_s.force_encoding(Encoding::UTF_8)
-  end # def convert_string
+    value.to_s.force_encoding(Encoding::UTF_8)
+  end
 
   def convert_integer(value)
-    return value.to_i
-  end # def convert_integer
+    value.to_i
+  end
 
   def convert_float(value)
-    return value.to_f
-  end # def convert_float
+    value.to_f
+  end
 
   def convert_boolean(value)
-    return true if value =~ (/^(true|t|yes|y|1)$/i)
-    return false if value.empty? || value =~ (/^(false|f|no|n|0)$/i)
+    return true if value =~ TRUE_REGEX
+    return false if value.empty? || value =~ FALSE_REGEX
     @logger.warn("Failed to convert #{value} into boolean.")
-    return value
-  end # def convert_boolean
+    value
+  end
 
-  private
   def gsub(event)
     @gsub_parsed.each do |config|
       field = config[:field]
       needle = config[:needle]
       replacement = config[:replacement]
 
-      if event[field].is_a?(Array)
-        event[field] = event[field].map do |v|
-          if not v.is_a?(String)
-            @logger.warn("gsub mutation is only applicable for Strings, " +
-                          "skipping", :field => field, :value => v)
-            v
-          else
+      value = event[field]
+      case value
+      when Array
+        event[field] = value.map do |v|
+          if v.is_a?(String)
             gsub_dynamic_fields(event, v, needle, replacement)
+          else
+            @logger.warn("gsub mutation is only applicable for Strings, skipping", :field => field, :value => v)
+            v
           end
         end
+      when String
+        event[field] = gsub_dynamic_fields(event, value, needle, replacement)
       else
-        if not event[field].is_a?(String)
-          @logger.debug("gsub mutation is only applicable for Strings, " +
-                        "skipping", :field => field, :value => event[field])
-          next
-        end
-        event[field] = gsub_dynamic_fields(event, event[field], needle, replacement)
+        @logger.debug? && @logger.debug("gsub mutation is only applicable for Strings, skipping", :field => field, :value => event[field])
       end
-    end # @gsub_parsed.each
-  end # def gsub
+    end
+  end
 
-  private
   def gsub_dynamic_fields(event, original, needle, replacement)
-    if needle.is_a? Regexp
+    if needle.is_a?(Regexp)
       original.gsub(needle, event.sprintf(replacement))
     else
       # we need to replace any dynamic fields
@@ -339,7 +341,6 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
     end
   end
 
-  private
   def uppercase(event)
     @uppercase.each do |field|
       original = event[field]
@@ -347,95 +348,100 @@ class LogStash::Filters::Mutate < LogStash::Filters::Base
       # therefore we can't assume that we are modifying the actual value behind
       # the key so read, modify and overwrite
       event[field] = case original
-        when Array
-          # can't map upcase! as it replaces an already upcase value with nil
-          # ["ABCDEF"].map(&:upcase!) => [nil]
-          original.map do |elem|
-           (elem.is_a?(String) ? elem.upcase : elem)
-          end
-        when String
-          # nil means no change was made to the String
-          original.upcase! || original
-        else
-          @logger.debug("Can't uppercase something that isn't a string",
-                        :field => field, :value => original)
-          original
+      when Array
+        # can't map upcase! as it replaces an already upcase value with nil
+        # ["ABCDEF"].map(&:upcase!) => [nil]
+        original.map do |elem|
+          (elem.is_a?(String) ? elem.upcase : elem)
         end
+      when String
+        # nil means no change was made to the String
+        original.upcase! || original
+      else
+        @logger.debug? && @logger.debug("Can't uppercase something that isn't a string", :field => field, :value => original)
+        original
+      end
     end
-  end # def uppercase
+  end
 
-  private
   def lowercase(event)
     #see comments for #uppercase
     @lowercase.each do |field|
       original = event[field]
       event[field] = case original
-        when Array
-          original.map! do |elem|
-            (elem.is_a?(String) ? elem.downcase : elem)
-          end
-        when String
-          original.downcase! || original
-        else
-          @logger.debug("Can't lowercase something that isn't a string",
-                        :field => field, :value => original)
-          original
+      when Array
+        original.map! do |elem|
+          (elem.is_a?(String) ? elem.downcase : elem)
         end
+      when String
+        original.downcase! || original
+      else
+        @logger.debug? && @logger.debug("Can't lowercase something that isn't a string", :field => field, :value => original)
+        original
+      end
     end
-  end # def lowercase
-
+  end
 
-  private
   def split(event)
     @split.each do |field, separator|
-      if event[field].is_a?(String)
-        event[field] = event[field].split(separator)
+      value = event[field]
+      if value.is_a?(String)
+        event[field] = value.split(separator)
       else
-        @logger.debug("Can't split something that isn't a string",
-                      :field => field, :value => event[field])
+        @logger.debug? && @logger.debug("Can't split something that isn't a string", :field => field, :value => event[field])
       end
     end
   end
 
-  private
   def join(event)
     @join.each do |field, separator|
-      if event[field].is_a?(Array)
-        event[field] = event[field].join(separator)
+      value = event[field]
+      if value.is_a?(Array)
+        event[field] = value.join(separator)
       end
     end
   end
 
-  private
   def strip(event)
     @strip.each do |field|
-      if event[field].is_a?(Array)
-        event[field] = event[field].map{|s| s.strip }
-      elsif event[field].is_a?(String)
-        event[field] = event[field].strip
+      value = event[field]
+      case value
+      when Array
+        event[field] = value.map{|s| s.strip }
+      when String
+        event[field] = value.strip
       end
     end
   end
 
-  private
   def merge(event)
     @merge.each do |dest_field, added_fields|
       # When multiple calls, added_field is an array
+
+      dest_field_value = event[dest_field]
+
       Array(added_fields).each do |added_field|
-        if event[dest_field].is_a?(Hash) ^ event[added_field].is_a?(Hash)
+        added_field_value = event[added_field]
+
+        if dest_field_value.is_a?(Hash) ^ added_field_value.is_a?(Hash)
           @logger.error("Not possible to merge an array and a hash: ", :dest_field => dest_field, :added_field => added_field )
           next
         end
 
-        if event[dest_field].is_a?(Hash)
-          # No need to test the other
-          event[dest_field].update(event[added_field])
+        # No need to test the other
+        if dest_field_value.is_a?(Hash)
+          # do not use event[dest_field].update because the returned object from event[dest_field]
+          # can/will be a copy of the actual event data and directly updating it will not update
+          # the Event internal data. The updated value must be reassigned in the Event.
+          event[dest_field] = dest_field_value.update(added_field_value)
         else
-          event[dest_field] = Array(event[dest_field])
-          event[dest_field].concat(Array(event[added_field]))
+          # do not use event[dest_field].concat because the returned object from event[dest_field]
+          # can/will be a copy of the actual event data and directly updating it will not update
+          # the Event internal data. The updated value must be reassigned in the Event.
+          event[dest_field] = Array(dest_field_value).concat(Array(added_field_value))
         end
       end
     end
   end
 
-end # class LogStash::Filters::Mutate
+end

data/logstash-filter-mutate.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-filter-mutate'
-  s.version         = '2.0.2'
+  s.version         = '2.0.3'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "The mutate filter allows you to perform general mutations on fields. You can rename, remove, replace, and modify fields in your events."
   s.description     = "This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program"

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: logstash-filter-mutate
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-10-14 00:00:00.000000000 Z
+date: 2015-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: logstash-core
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -19,10 +20,7 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: 3.0.0
-  name: logstash-core
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -30,48 +28,50 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: 3.0.0
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
+  name: logstash-patterns-core
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-patterns-core
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-filter-grok
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-filter-grok
   prerelease: false
   type: :runtime
+- !ruby/object:Gem::Dependency
+  name: logstash-devutils
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: logstash-devutils
   prerelease: false
   type: :development
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: This gem is a logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/plugin install gemname. This gem is not a stand-alone program
 email: info@elastic.co
 executables: []