logstash-filter-units 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 693aa67dfac7153254fb62cfdb716c9d108fb92c
-  data.tar.gz: e10a3496e7c6ae1ce57972e3981be82776a20246
+  metadata.gz: 77351902d501e8d3ed2aff1d95be75078f4e6731
+  data.tar.gz: f8518e36bd0b3b9e4f70c03f18964f5debad93f7
 SHA512:
-  metadata.gz: 714eec4b166ca567bf3c5440c752e01966cc1c09eb392e337d8094200dac7c98c4d8bbd53efe78284e51ddaf500fd6fbcde3e6064187391a6d3d2d48de650656
-  data.tar.gz: d54019094055725ccb20cc9d5bc521b0c0a543e33862d38b81c48e78872e1e420efd46ddbbad6d94ce622e6b16adef49144b3452d7c45879d1530cada29912c2
+  metadata.gz: 797eec246d7f1b29e0e751a5fad410edbc1e89416233aaa926ae6ef26198977a799066190f8763bf6f6c7b45c69fc35ad9f62b1842768b345e3942484a7003a1
+  data.tar.gz: 1f36b803c1fc541cd54bd58c05ab2c7d757c6cf8972e4b1c7a277011843e5ee589df25717dd6a34670a7466b5ce781e286078dfb902a2a755646b13bf0be22c1

data/Gemfile

@@ -1,12 +1,2 @@
 source 'http://rubygems.org'
-# gem 'treetop'
-# gem 'jrjackson'
-# gem 'stud'
-# gem 'clamp'
-# gem 'i18n'
-# gem 'filesize'
-# gem 'cabin'
-# gem 'rake'
-# gem 'unitwise'
-gem "logstash", :github => "elasticsearch/logstash", :branch => "1.5"
-gemspec
+gemspec

data/lib/logstash/filters/units.rb

@@ -3,278 +3,284 @@
 require "logstash/filters/base"
 require "logstash/namespace"
 require "unitwise"
+# ------------------------------------------------------------------------------
 
 # The units filter is used for converting specified fields from one 
 # unit of measure to another (or many others).
-
 class LogStash::Filters::Units < LogStash::Filters::Base
-	config_name "units"
-	milestone 1
-	
-	config(:fields, :validate => :array, :required => true)
-	# The source fields to be converted
-	# Fields may be specified in three different ways:
-	# - Fields may be referenced specifically, by drilling
-	#   down the field hierarchy using the square bracket syntax. If
-	#   they are specified in this manner, then only the exact field
-	#   specified will be converted.
-	# - Fields may also be specifed more generally simply by proving
-	#   the field name.  If done this way, the given field will convert
-	#   any bottom level field of the same name.
-	# - If provided a string rather than an array of fields, the field
-	#   provided will be converted in place rather then prepended with
-	#   additional fields.
-	# Example:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	# 			fields => ["top_level_field",
-	#					   "bottom_level_field",
-	# 					   "[a][nested][field]"]
-	# 			output_units => ["kilobyte", "megabyte"]
-	# 		}
-	# 	}
-	# Example:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	# 			fields => "in_place_conversion"
-	# 			output_units => ["megabyte"]
-	# 		}
-	# 	}
+  config_name "units"
+  milestone 1
+  
+  # The source fields to be converted
+  # Fields may be specified in three different ways:
+  # - Fields may be referenced specifically, by drilling
+  #   down the field hierarchy using the square bracket syntax. If
+  #   they are specified in this manner, then only the exact field
+  #   specified will be converted.
+  # - Fields may also be specifed more generally simply by proving
+  #   the field name.  If done this way, the given field will convert
+  #   any bottom level field of the same name.
+  # - If provided a string rather than an array of fields, the field
+  #   provided will be converted in place rather then prepended with
+  #   additional fields.
+  # Example:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #       fields => ["top_level_field",
+  #            "bottom_level_field",
+  #              "[a][nested][field]"]
+  #       output_units => ["kilobyte", "megabyte"]
+  #     }
+  #   }
+  # Example:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #       fields => "in_place_conversion"
+  #       output_units => ["megabyte"]
+  #     }
+  #   }
+  config(:fields, :validate => :array, :required => true)
+
 
-	config(:input_unit, :validate => :string, :default => "byte")
-	# The unit of measure of the source fields to be converted.
-	# This parameter supports all units of measure specified by
-	# the unitwise gem.
-	# http://github.com/joshwlewis/unitwise
-	# Example:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	#			fields => ["length", "height"]
-	# 			input_unit => "millimeter"
-	# 			output_units => ["centimeter", "meter"]
-	# 		}
-	# 	}
+  # The unit of measure of the source fields to be converted.
+  # This parameter supports all units of measure specified by
+  # the unitwise gem.
+  # http://github.com/joshwlewis/unitwise
+  # Example:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #     fields => ["length", "height"]
+  #       input_unit => "millimeter"
+  #       output_units => ["centimeter", "meter"]
+  #     }
+  #   }
+  config(:input_unit, :validate => :string, :default => "byte")
 
-	config(:output_units, :required => true)
-	# The units of measure used for conversion.
-	# This parameter supports all units of measure specified by
-	# the unitwise gem.
-	# http://github.com/joshwlewis/unitwise
-	# By default, new fields will be named according to these units.
-	# Example:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	#			fields => ["length", "height"]
-	# 			input_unit => "millimeter"
-	# 			output_units => ["centimeter", "meter"]
-	# 		}
-	# 	} 
 
-	config(:root_field, :validate => :string)
-	# If specified, the fields generated by the filter will be
-	# placed within a hierarchy mirroring that of the fields
-	# listed within the fields parameter, which is itself nested
-	# under the given root field.
-	# For example, with this config:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	#			fields => ["c"]
-	# 			input_unit => "byte"
-	# 			output_units => ["kilobyte", "megabyte"]
-	# 			root_field => "special"
-	# 		}
-	# 	}
-	#
-	# {
-	# 	"a" => {
-	# 		"b" => {
-	# 			"c" => 1000000
-	#     	}
-	# 	}
-	# }
-	#
-	# becomes
-	#
-	# {
-	# 	"a" => {
-	# 		"b" => {
-	# 			"c" => 1000000
-	#     	}
-	# 	},
-	# 	"special" => {
-	# 		"a" => {
-	# 			"b" => {
-	# 				"c" => {
-	# 					"kilobyte" => 1000,
-	#					"megabyte" => 1
-	#				}
-	#   	  	}
-	# 		}
-	# 	}
-	# }
+  # The units of measure used for conversion.
+  # This parameter supports all units of measure specified by
+  # the unitwise gem.
+  # http://github.com/joshwlewis/unitwise
+  # By default, new fields will be named according to these units.
+  # Example:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #     fields => ["length", "height"]
+  #       input_unit => "millimeter"
+  #       output_units => ["centimeter", "meter"]
+  #     }
+  #   }
+  config(:output_units, :required => true)
 
-	config(:rename_labels, :validate => :hash, :default => {})
-	# Renames the resulting output fields according to a hash.
-	# Keys should be the output fields and values should be their
-	# desired names, respectively.  Unamed fields will persist.
-	# Example:
-	# [source,ruby]
-	# 	filter {
-	# 		units {
-	#			fields => ["file_size"]
-	# 			input_unit => "byte"
-	# 			output_units => ["kilobyte", "megabyte"]
-	# 			rename_labels => {
-	# 				"kilobyte" => "kB"
-	# 				"megabyte" => "mB"
-	# 			}
-	# 		}
-	# 	} 
+  # If specified, the fields generated by the filter will be
+  # placed within a hierarchy mirroring that of the fields
+  # listed within the fields parameter, which is itself nested
+  # under the given root field.
+  # For example, with this config:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #     fields => ["c"]
+  #       input_unit => "byte"
+  #       output_units => ["kilobyte", "megabyte"]
+  #       root_field => "special"
+  #     }
+  #   }
+  #
+  # {
+  #   "a" => {
+  #     "b" => {
+  #       "c" => 1000000
+  #       }
+  #   }
+  # }
+  #
+  # becomes
+  #
+  # {
+  #   "a" => {
+  #     "b" => {
+  #       "c" => 1000000
+  #       }
+  #   },
+  #   "special" => {
+  #     "a" => {
+  #       "b" => {
+  #         "c" => {
+  #           "kilobyte" => 1000,
+  #         "megabyte" => 1
+  #       }
+  #         }
+  #     }
+  #   }
+  # }
+  config(:root_field, :validate => :string)
 
-	def initialize(*args)
-		super(*args)
-	end
+  # Renames the resulting output fields according to a hash.
+  # Keys should be the output fields and values should be their
+  # desired names, respectively.  Unamed fields will persist.
+  # Example:
+  # [source,ruby]
+  #   filter {
+  #     units {
+  #     fields => ["file_size"]
+  #       input_unit => "byte"
+  #       output_units => ["kilobyte", "megabyte"]
+  #       rename_labels => {
+  #         "kilobyte" => "kB"
+  #         "megabyte" => "mB"
+  #       }
+  #     }
+  #   }
+  config(:rename_labels, :validate => :hash, :default => {})
+  # ----------------------------------------------------------------------------
 
-	public
-	def register()
-	end
+  def initialize(*args)
+    super(*args)
+  end
 
-	private
-	def nested_hash_to_matrix(data)
-		@sep = '.'
-		@output = []
-		def _nested_hash_to_matrix(data, name)
-			data.each do |key, val|
-				new_key = name + @sep + key.to_s
-				if val.is_a?(Hash) and val != {}
-					_nested_hash_to_matrix(val, new_key)
-				else
-					@output.push([new_key, val])
-				end
-			end
-			return @output
-		end
+  public
+  def register()
+  end
+  # ----------------------------------------------------------------------------
+  
+  private
+  def nested_hash_to_matrix(data)
+    @sep = '.'
+    @output = []
+    def _nested_hash_to_matrix(data, name)
+      data.each do |key, val|
+        new_key = name + @sep + key.to_s
+        if val.is_a?(Hash) and val != {}
+          _nested_hash_to_matrix(val, new_key)
+        else
+          @output.push([new_key, val])
+        end
+      end
+      return @output
+    end
 
-		@output = _nested_hash_to_matrix(data, @sep)
-		@output = @output.map { |key, val| [key.split('.')[2..-1], val] }
-		return @output
-	end
+    @output = _nested_hash_to_matrix(data, @sep)
+    @output = @output.map { |key, val| [key.split('.')[2..-1], val] }
+    return @output
+  end
 
-	private
-	def matrix_to_nested_hash(data)
-		output = {}
-		data.each do |keys, value|
-			cursor = output
-			for key in keys[0..-2]
-				if !cursor.include?(key)
-					cursor[key] = {}
-					cursor = cursor[key]
-				else
-					cursor = cursor[key]
-				end
-			end
-			cursor[keys[-1]] = value
-		end
-		return output
-	end
+  private
+  def matrix_to_nested_hash(data)
+    output = {}
+    data.each do |keys, value|
+      cursor = output
+      for key in keys[0..-2]
+        if !cursor.include?(key)
+          cursor[key] = {}
+          cursor = cursor[key]
+        else
+          cursor = cursor[key]
+        end
+      end
+      cursor[keys[-1]] = value
+    end
+    return output
+  end
+  # ----------------------------------------------------------------------------
 
-	private
-	def convert_to_dict(value)
-		# convert a single value to a hash of converted values
-		output = {}
-		for output_unit in @output_units do
-			output_value = convert(value, output_unit)
-			if @rename_labels.include?(output_unit)
-				output_unit = @rename_labels[output_unit]
-			end
-			output[output_unit] = output_value
-		end
-		return output
-	end
+  private
+  def convert_to_dict(value)
+    # convert a single value to a hash of converted values
+    output = {}
+    for output_unit in @output_units do
+      output_value = convert(value, output_unit)
+      if @rename_labels.include?(output_unit)
+        output_unit = @rename_labels[output_unit]
+      end
+      output[output_unit] = output_value
+    end
+    return output
+  end
 
-	private
-	def convert(value, output_unit)
-		begin
-			return output_value = Unitwise(value, @input_unit).convert_to(output_unit).value
-		rescue Exception
-			raise StandardError
-		end
-	end
+  private
+  def convert(value, output_unit)
+    begin
+      return output_value = Unitwise(value, @input_unit).convert_to(output_unit).value
+    rescue Exception
+      raise StandardError
+    end
+  end
 
-	private
-	def field_handler(fields)
-		output = {"exact" => [], "partial" => []}
-		for field in fields
-			if /\[|\]/.match(field)
-				temp = field.split(/\]\[|^\[|\]$/)[1..-1]
-				output["exact"].push(temp)
-			else
-				output["partial"].push(field)
-			end
-		end
-		return output
-	end
+  private
+  def field_handler(fields)
+    output = {"exact" => [], "partial" => []}
+    for field in fields
+      if /\[|\]/.match(field)
+        temp = field.split(/\]\[|^\[|\]$/)[1..-1]
+        output["exact"].push(temp)
+      else
+        output["partial"].push(field)
+      end
+    end
+    return output
+  end
+  # ----------------------------------------------------------------------------
 
-	public
-	def filter(event)
-		return unless filter?(event)
-		begin
-			# flag for converting a value in place or expanding it into
-			# a hash
-			inplace = @output_units.is_a?(String)
-			matrix = nested_hash_to_matrix(event.to_hash)		
+  public
+  def filter(event)
+    return unless filter?(event)
+    begin
+      # flag for converting a value in place or expanding it into
+      # a hash
+      inplace = @output_units.is_a?(String)
+      matrix = nested_hash_to_matrix(event.to_hash)   
 
-			# convert matching fields and  remove rows that
-			# do not contain leaf nodes that match @fields
-			fields = field_handler(@fields)
-			del = []
-			matrix.each do |row|
-				if fields["exact"].include?(row[0])
-					if inplace
-						row[1] = convert(row[1], @output_units)
-					else
-						row[1] = convert_to_dict(row[1])
-					end
-				elsif fields["partial"].include?(row[0][-1])
-					if inplace
-						row[1] = convert(row[1], @output_units)
-					else
-						row[1] = convert_to_dict(row[1])
-					end
-				else
-					del.push(row)
-				end
-			end
-			# delete all rows that do not have leaf nodes listed
-			# in fields
-			for row in del
-				matrix.delete(row)
-			end
-			
-			new_hash = matrix_to_nested_hash(matrix)
-			if @root_field
-				new_hash = {@root_field => new_hash}
-			end
+      # convert matching fields and  remove rows that
+      # do not contain leaf nodes that match @fields
+      fields = field_handler(@fields)
+      del = []
+      matrix.each do |row|
+        if fields["exact"].include?(row[0])
+          if inplace
+            row[1] = convert(row[1], @output_units)
+          else
+            row[1] = convert_to_dict(row[1])
+          end
+        elsif fields["partial"].include?(row[0][-1])
+          if inplace
+            row[1] = convert(row[1], @output_units)
+          else
+            row[1] = convert_to_dict(row[1])
+          end
+        else
+          del.push(row)
+        end
+      end
+      # delete all rows that do not have leaf nodes listed
+      # in fields
+      for row in del
+        matrix.delete(row)
+      end
+      
+      new_hash = matrix_to_nested_hash(matrix)
+      if @root_field
+        new_hash = {@root_field => new_hash}
+      end
 
-			# merge new hash into event's hash
-			# assignment of items from new_hash with a prior merge
-			# will destroy unmatched branches
-			data = event.to_hash().merge(new_hash)
-   			data.each do |key, value|
-				event[key] = value
-			end
-			return filter_matched(event)
-		rescue StandardError
-			event.tag("_unitsparsefailure")
-			return event
-		rescue Logstash::ShutdownSignal
-			event.cancel()
-			@logger.debug(e)
-		end
-	end
+      # merge new hash into event's hash
+      # assignment of items from new_hash with a prior merge
+      # will destroy unmatched branches
+      data = event.to_hash().merge(new_hash)
+        data.each do |key, value|
+        event[key] = value
+      end
+      return filter_matched(event)
+    rescue StandardError
+      event.tag("_unitsparsefailure")
+      return event
+    rescue Logstash::ShutdownSignal
+      event.cancel()
+      @logger.debug(e)
+    end
+  end
 end

data/logstash-filter-units.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
 	s.name            = 'logstash-filter-units'
-	s.version         = '0.1.0'
+	s.version         = '0.1.1'
 	s.licenses        = ['Apache License (2.0)']
 	s.summary         = "A filter for performing unit conversions on specified fields."
 	s.description     = "The units filter is used for converting specified fields from one unit of measure to another (or many others)."
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
 
 	# Gem dependencies
 	s.add_runtime_dependency "logstash", '>= 1.4.0', '< 2.0.0'
-	s.add_runtime_dependency "unitwise", ">= 1.0.4"
+	s.add_runtime_dependency "unitwise"
 	s.add_development_dependency "logstash-devutils"
+
 end

data/spec/filters/units_spec.rb

@@ -3,73 +3,73 @@ require "logstash/devutils/rspec/spec_helper"
 require "logstash/filters/units"
 
 describe LogStash::Filters::Units do
-	describe "special field" do
-		let(:config) do <<-CONFIG
-			filter {
-				units {
-					fields => ["[a1][a2]", "b1", "c1", "d2"]
-					input_unit => "byte"
-					output_units => ["kibibyte", "mebibyte"]
-					root_field => "special"
-					rename_labels => {
-						"kibibyte" => "kb"
-						"mebibyte" => "mb"
-					}
-				}
-			}
-		CONFIG
-		end
+  describe "special field" do
+    let(:config) do <<-CONFIG
+      filter {
+        units {
+          fields => ["[a1][a2]", "b1", "c1", "d2"]
+          input_unit => "byte"
+          output_units => ["kibibyte", "mebibyte"]
+          root_field => "special"
+          rename_labels => {
+            "kibibyte" => "kb"
+            "mebibyte" => "mb"
+          }
+        }
+      }
+    CONFIG
+    end
 
-		event = {
-				"a1" => {
-					"a2" => 1024
-					},
-				"b1" => 1024,
-				"c1" => 1024,
-				"d1" => {
-					"d2" => 1024
-					}
-				}
-		sample(event) do
-			insist { subject["special"]["a1"]["a2"]["kb"] } == 1
-			insist { subject["special"]["a1"]["a2"]["kb"] } == 1
-			insist { subject["special"]["b1"]["kb"] } == 1
-			insist { subject["special"]["c1"]["kb"] } == 1
-			insist { subject["special"]["d1"]["d2"]["kb"] } == 1
-		end
-	end
+    event = {
+        "a1" => {
+          "a2" => 1024
+          },
+        "b1" => 1024,
+        "c1" => 1024,
+        "d1" => {
+          "d2" => 1024
+          }
+        }
+    sample(event) do
+      insist { subject["special"]["a1"]["a2"]["kb"] } == 1
+      insist { subject["special"]["a1"]["a2"]["kb"] } == 1
+      insist { subject["special"]["b1"]["kb"] } == 1
+      insist { subject["special"]["c1"]["kb"] } == 1
+      insist { subject["special"]["d1"]["d2"]["kb"] } == 1
+    end
+  end
 
-	describe "in place" do
-		let(:config) do <<-CONFIG
-			filter {
-				units {
-					fields => ["[a1][a2]", "b1", "c1", "d2"]
-					input_unit => "byte"
-					output_units => ["kibibyte", "mebibyte"]
-					rename_labels => {
-						"kibibyte" => "kb"
-						"mebibyte" => "mb"
-					}
-				}
-			}
-		CONFIG
-		end
+  describe "in place" do
+    let(:config) do <<-CONFIG
+      filter {
+        units {
+          fields => ["[a1][a2]", "b1", "c1", "d2"]
+          input_unit => "byte"
+          output_units => ["kibibyte", "mebibyte"]
+          rename_labels => {
+            "kibibyte" => "kb"
+            "mebibyte" => "mb"
+          }
+        }
+      }
+    CONFIG
+    end
 
-		event = {
-				"a1" => {
-					"a2" => 1024**2
-					},
-				"b1" => 1024**2,
-				"c1" => 1024**2,
-				"d1" => {
-					"d2" => 1024**2
-					}
-				}
-		sample(event) do
-			insist { subject["a1"]["a2"]["mb"] } == 1
-			insist { subject["b1"]["mb"] } == 1
-			insist { subject["c1"]["mb"] } == 1
-			insist { subject["d1"]["d2"]["mb"] } == 1
-		end
-	end
+    event = {
+        "a1" => {
+          "a2" => 1024**2
+          },
+        "b1" => 1024**2,
+        "c1" => 1024**2,
+        "d1" => {
+          "d2" => 1024**2
+          }
+        }
+    sample(event) do
+      insist { subject["a1"]["a2"]["mb"] } == 1
+      insist { subject["b1"]["mb"] } == 1
+      insist { subject["c1"]["mb"] } == 1
+      insist { subject["d1"]["d2"]["mb"] } == 1
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-filter-units
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Alex Braun
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-16 00:00:00.000000000 Z
+date: 2015-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash
@@ -36,12 +36,12 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: '0'
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: '0'
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency