logstash-codec-protobuf 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92231ace59a2a8218764c99dab51abb5636db440
-  data.tar.gz: d8129bf3a5bf757f42bb3c2e95ae8d74455531b2
+  metadata.gz: 32ac341961786a035ed34e5e221de5e6944c2226
+  data.tar.gz: 8bb727065267603b4d0d771e2ab1937e7eb83660
 SHA512:
-  metadata.gz: 6a7379eeb8a33c4dd722a01e55bd67f5daeb37ba7ad323ebd41707b359f27a585ca5dcaaf720ecb74d6746c50230fda17249ef849ff3f01489714dbd9c286769
-  data.tar.gz: d2175a9b628f60128295e9e4871d895ba8cb65d33202af0a3c66ac63c0aa4540a173b3b7c508f28de8db3d950f4b72604e308d5138530a79393144244c5188a1
+  metadata.gz: ba83ef5a43fa82e25d6cb248fa8076982b43d833df1d2ee62ee69c045bedd2664ff04a5b112d880344ebaf470116a176ab008bbccad9f6aab368c30b513ce5d1
+  data.tar.gz: 9699d09931ca8bac5d0242c4952b8496467d8c586032decdce6213ae956e43053b08039115a3deee7db7eaa74fd2d8a9700c32a12d794dcbaf338cbb01419c82

data/README.md

@@ -10,7 +10,13 @@ This is a codec plugin for [Logstash](https://github.com/elastic/logstash) to pa
 	bin/plugin install /path/to/logstash-codec-protobuf-$VERSION.gem
 * use the codec in your logstash config file. See details below.
 
-## Usage
+## Configuration
+
+include_path  (required): an array of strings with filenames or directory names where logstash can find your protobuf definitions. Please provide absolute paths. For directories it will only try to import files ending on .rb
+
+class_name    (required): the name of the protobuf class that is to be decoded or encoded.
+
+## Usage example: decoder
 
 Use this as a codec in any logstash input. Just provide the name of the class that your incoming objects will be encoded in, and specify the path to the compiled definition.
 Here's an example for a kafka input:
@@ -46,11 +52,11 @@ Set the class name to the parent class:
 	
 	class_name => "Foods::Dairy::Cheese"
 
-## Configuration
+## Usage example: encoder
 
-include_path	(required): an array of strings with filenames or directory names where logstash can find your protobuf definitions. Please provide absolute paths. For directories it will only try to import files ending on .rb
-
-class_name		(required): the name of the protobuf class that is to be decoded.
+The configuration of the codec for encoding logstash events for a protobuf output is pretty much the same as for the decoder input usage as demonstrated above. There are some constraints though that you need to be aware of:
+* the protobuf definition needs to contain all the fields that logstash typically adds to an event, in the corrent data type. Examples for this are @timestamp (string), @version (string), host, path, all of which depend on your input sources and filters aswell. If you do not want to add those fields to your protobuf definition then please use a [modify filter](https://www.elastic.co/guide/en/logstash/current/plugins-filters-mutate.html) to [remove](https://www.elastic.co/guide/en/logstash/current/plugins-filters-mutate.html#plugins-filters-mutate-remove_field) the undesired fields.
+* object members starting with @ are somewhat problematic in protobuf definitions. Therefore those fields will automatically be renamed to remove the at character. This also effects the important @timestamp field. Please name it just "timestamp" in your definition.
 
 
 ## Troubleshooting
@@ -59,7 +65,12 @@ class_name		(required): the name of the protobuf class that is to be decoded.
 
 If you include more than one definition class, consider the order of inclusion. This is especially relevant if you include whole directories. A definition might refer to another definition that is not loaded yet. In this case, please specify the files in the include_path variable in reverse order of reference. See 'Example with referenced definitions' above.
 
+### no protobuf output
+
+Maybe your protobuf definition does not fullfill the requirements and needs additional fields. Run logstash with the --debug flag and grep for "error 2".
+
+
+## Limitations and roadmap
 
-# #Roadmap
+* maybe add support for setting undefined fields from default values in the decoder
 
-Currently the plugin supports the decode functionality only. Maybe we'll add the encoding part also.

data/lib/logstash/codecs/protobuf.rb

@@ -12,72 +12,178 @@ class LogStash::Codecs::Protobuf < LogStash::Codecs::Base
   # Name of the class to decode
   config :class_name, :validate => :string, :required => true
 
-  
+  # For benchmarking only, not intended for public use: change encoder strategy. 
+  # valid method names are:  encoder_strategy_1 (the others are not implemented yet)
+  config :encoder_method, :validate => :string, :default => "encoder_strategy_1"
+
   def register
+    @pb_metainfo = {}
     include_path.each { |path| require_pb_path(path) }
     @obj = create_object_from_name(class_name)
     @logger.debug("Protobuf files successfully loaded.")
+
   end
 
   def decode(data)
     decoded = @obj.parse(data.to_s)
-    results = extract_vars(decoded)
+    results = keys2strings(decoded.to_hash)
     yield LogStash::Event.new(results) if block_given?
   end # def decode
 
+  def keys2strings(data)
+    if data.is_a?(::Hash)
+      new_hash = Hash.new
+      data.each{|k,v| new_hash[k.to_s] = keys2strings(v)}
+      new_hash
+    else
+      data
+    end
+  end
+
+
   def encode(event)
-    raise 'Encodeør function not implemented yet for protobuf codec. Sorry!'
-    # @on_event.call(event, event.to_s)
-    # TODO integrate
+    protobytes = generate_protobuf(event)
+    @on_event.call(event, protobytes)
   end # def encode
 
+  private
+  def generate_protobuf(event)  
+    meth = self.method(encoder_method)
+    data = meth.call(event, @class_name)
+    begin
+      msg = @obj.new(data)
+      msg.serialize_to_string
+    rescue NoMethodError
+      @logger.debug("error 2: NoMethodError. Maybe mismatching protobuf definition. Required fields are: " + event.to_hash.keys.join(", "))
+    end
+  end
 
+  def encoder_strategy_1(event, class_name)
+    _encoder_strategy_1(event.to_hash, class_name)
+
+  end
+
+  def _encoder_strategy_1(datahash, class_name)
+    fields = clean_hash_keys(datahash)
+    fields = flatten_hash_values(fields) # TODO we could merge this and the above method back into one to save one iteration, but how are we going to name it?
+    meta = get_complex_types(class_name) # returns a hash with member names and their protobuf class names
+    meta.map do | (k,typeinfo) |
+      if fields.include?(k)
+        original_value = fields[k] 
+        proto_obj = create_object_from_name(typeinfo)
+        fields[k] = 
+          if original_value.is_a?(::Array) 
+            ecs1_list_helper(original_value, proto_obj, typeinfo)
+            
+          else 
+            recursive_fix = _encoder_strategy_1(original_value, class_name)
+            proto_obj.new(recursive_fix)
+          end # if is array
+      end
+
+    end 
+    
+    fields
+  end
+
+  def ecs1_list_helper(value, proto_obj, class_name)
+    # make this field an array/list of protobuf objects
+    # value is a list of hashed complex objects, each of which needs to be protobuffed and
+    # put back into the list.
+    next unless value.is_a?(::Array)
+    value.map { |x| _encoder_strategy_1(x, class_name) } 
+    value
+  end
+
+  def flatten_hash_values(datahash)
+    # 2) convert timestamps and other objects to strings
+    next unless datahash.is_a?(::Hash)
+    
+    ::Hash[datahash.map{|(k,v)| [k, (convert_to_string?(v) ? v.to_s : v)] }]
+  end
+
+  def clean_hash_keys(datahash)
+    # 1) remove @ signs from keys 
+    next unless datahash.is_a?(::Hash)
+    
+    ::Hash[datahash.map{|(k,v)| [remove_atchar(k.to_s), v] }]
+  end #clean_hash_keys
+
+  def convert_to_string?(v)
+    !(v.is_a?(Fixnum) || v.is_a?(::Hash) || v.is_a?(::Array) || [true, false].include?(v))
+  end
+
+   
+  def remove_atchar(key) # necessary for @timestamp fields and the likes. Protobuf definition doesn't handle @ in field names well.
+    key.dup.gsub(/@/,'')
+  end
 
   private
   def create_object_from_name(name)
     begin
       @logger.debug("Creating instance of " + name)
-      return name.split('::').inject(Object) { |n,c| n.const_get c }
+      name.split('::').inject(Object) { |n,c| n.const_get c }
      end
   end
 
+  def get_complex_types(class_name)
+    @pb_metainfo[class_name]
+  end
+
+  def require_with_metadata_analysis(filename)
+    require filename
+    regex_class_name = /\s*class\s*(?<name>.+?)\s+/
+    regex_module_name = /\s*module\s*(?<name>.+?)\s+/
+    regex_pbdefs = /\s*(optional|repeated)(\s*):(?<type>.+),(\s*):(?<name>\w+),(\s*)(?<position>\d+)/
+    # now we also need to find out which class it contains and the protobuf definitions in it.
+    # We'll unfortunately need that later so that we can create nested objects.
+    begin 
+      class_name = ""
+      type = ""
+      field_name = ""
+      classname_found = false
+      File.readlines(filename).each do |line|
+        if ! (line =~ regex_module_name).nil? && !classname_found # because it might be declared twice in the file
+          class_name << $1 
+          class_name << "::"
+    
+        end
+        if ! (line =~ regex_class_name).nil? && !classname_found # because it might be declared twice in the file
+          class_name << $1
+          @pb_metainfo[class_name] = {}
+          classname_found = true
+        end
+        if ! (line =~ regex_pbdefs).nil?
+          type = $1
+          field_name = $2
+          if type =~ /::/
+            @pb_metainfo[class_name][field_name] = type.gsub!(/^:/,"")
+            
+          end
+        end
+      end
+    rescue Exception => e
+      @logger.warn("error 3: unable to read pb definition from file  " + filename+ ". Reason: #{e.inspect}. Last settings were: class #{class_name} field #{field_name} type #{type}. Backtrace: " + e.backtrace.inspect.to_s)
+    end
+    if class_name.nil?
+      @logger.warn("error 4: class name not found in file  " + filename)
+    end    
+  end
 
   def require_pb_path(dir_or_file)
     f = dir_or_file.end_with? ('.rb')
     begin
       if f
         @logger.debug("Including protobuf file: " + dir_or_file)
-        require dir_or_file
+        require_with_metadata_analysis dir_or_file
       else 
         Dir[ dir_or_file + '/*.rb'].each { |file|
           @logger.debug("Including protobuf path: " + dir_or_file + "/" + file)
-          require file 
+          require_with_metadata_analysis file 
         }
       end
     end
   end
 
 
-  def extract_vars(decoded_object)
-    return {} if decoded_object.nil?
-    results = {}
-    decoded_object.instance_variables.each do |key|
-      formatted_key = key.to_s.gsub('@', '')
-      next if (formatted_key == :set_fields || formatted_key == "set_fields")
-      instance_var = decoded_object.instance_variable_get(key)
-
-      results[formatted_key] =
-        if instance_var.is_a?(::ProtocolBuffers::Message) 
-          extract_vars(instance_var)
-        elsif instance_var.is_a?(::Hash)
-          instance_var.inject([]) { |h, (k, v)| h[k.to_s] = extract_vars(v); h }
-        elsif instance_var.is_a?(Enumerable) # is a list
-          instance_var.inject([]) { |h, v| h.push(extract_vars(v)); h }
-        else
-          instance_var
-        end
-     end
-   results
-  end
-
 end # class LogStash::Codecs::Protobuf

data/logstash-codec-protobuf.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-codec-protobuf'
-  s.version         = '0.1.1'
+  s.version         = '0.1.2'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "This codec may be used to decode (via inputs) and encode (via outputs) protobuf messages"
   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"

data/spec/codecs/protobuf_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "logstash/devutils/rspec/spec_helper"
 require "logstash/codecs/protobuf"
 require "logstash/event"
@@ -6,23 +7,199 @@ require "insist"
 
 describe LogStash::Codecs::Protobuf do
 
+
   context "#decode" do
 
-    let(:plugin) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Unicorn", "include_path" => ['spec/helpers/unicorn.pb.rb'])  }
+
+    #### Test case 1: Decode simple protobuf bytes for unicorn ####################################################################################################################
+    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Unicorn", "include_path" => ['spec/helpers/unicorn.pb.rb'])  }
     before do
-        plugin.register
+        plugin_unicorn.register      
     end
 
     it "should return an event from protobuf encoded data" do
     
-      data = {:colour => 'rainbow', :horn_length => 18, :last_seen => 1420081471}
+      data = {:colour => 'rainbow', :horn_length => 18, :last_seen => 1420081471, :has_wings => true}
       unicorn = Animal::Unicorn.new(data)
         
-      plugin.decode(unicorn.serialize_to_string) do |event|
-
+      plugin_unicorn.decode(unicorn.serialize_to_string) do |event|
         expect(event["colour"] ).to eq(data[:colour] )
         expect(event["horn_length"] ).to eq(data[:horn_length] )
+        expect(event["last_seen"] ).to eq(data[:last_seen] )
+        expect(event["has_wings"] ).to eq(data[:has_wings] )
+      end
+    end # it
+
+
+
+    #### Test case 2: Decode complex protobuf bytes for human #####################################################################################################################
+
+
+  
+ 
+    let(:plugin_human) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => ['spec/helpers/human.pb.rb'])  }
+    before do
+        plugin_human.register      
+    end
+
+    it "should return an event from complex nested protobuf encoded data" do
+    
+      data_gm = {:first_name => 'Elisabeth', :last_name => "Oliveoil", :middle_names => ["Maria","Johanna"], :vegetarian=>true}
+      grandmother = Animal::Human.new(data_gm)
+      data_m = {:first_name => 'Annemarie', :last_name => "Smørebrød", :mother => grandmother}
+      mother = Animal::Human.new(data_m)
+      data_f = {:first_name => 'Karl', :middle_names => ["Theodor-Augustin"], :last_name => "Falkenstein"}
+      father = Animal::Human.new(data_f)
+      data = {:first_name => 'Hugo', :middle_names => ["Heinz", "Peter"], :last_name => "Smørebrød",:father => father, :mother => mother}  
+      hugo = Animal::Human.new(data)
+       
+      plugin_human.decode(hugo.serialize_to_string) do |event|
+        expect(event["first_name"] ).to eq(data[:first_name] )
+        expect(event["middle_names"] ).to eq(data[:middle_names] )
+        expect(event["last_name"] ).to eq(data[:last_name] )
+        expect(event["mother"]["first_name"] ).to eq(data_m[:first_name] ) 
+        expect(event["father"]["first_name"] ).to eq(data_f[:first_name] )
+        expect(event["mother"]["last_name"] ).to eq(data_m[:last_name] )
+        expect(event["mother"]["mother"]["last_name"] ).to eq(data_gm[:last_name] )
+        expect(event["mother"]["mother"]["first_name"] ).to eq(data_gm[:first_name] )
+        expect(event["mother"]["mother"]["middle_names"] ).to eq(data_gm[:middle_names] )
+        expect(event["mother"]["mother"]["vegetarian"] ).to eq(data_gm[:vegetarian] )
+        expect(event["father"]["last_name"] ).to eq(data_f[:last_name] )
+        expect(event["father"]["middle_names"] ).to eq(data_f[:middle_names] )
       end
+    end # it
+
+
+
+
+
+
+    #### Test case 3: Decoder test for enums #####################################################################################################################
+
+
+  
+ 
+    let(:plugin_col) { LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => ['spec/helpers/ColourTestcase.pb.rb'])  }
+    before do
+        plugin_col.register      
+    end
+
+    it "should return an event from protobuf encoded data with enums" do
+    
+      data = {:least_liked => ColourProtoTest::Colour::YELLOW, :favourite_colours => \
+        [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE], :booleantest => [true, false, true]}  
+      pb = ColourProtoTest.new(data)
+       
+      plugin_col.decode(pb.serialize_to_string) do |event|
+        expect(event["least_liked"] ).to eq(data[:least_liked] )
+        expect(event["favourite_colours"] ).to eq(data[:favourite_colours] )
+        expect(event["booleantest"] ).to eq(data[:booleantest] )
+      end
+    end # it
+
+
+  end # context
+
+
+
+
+
+  #### Test case 4: Encode simple protobuf bytes for unicorn ####################################################################################################################
+
+  context "#encode" do
+    subject do
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::UnicornEvent", "include_path" => ['spec/helpers/unicorn_event.pb.rb']) 
+    end
+
+    event = LogStash::Event.new("colour" => "pink", "horn_length" => 12, "last_seen" => 1410081999, "has_wings" => true)    
+
+    it "should return protobuf encoded data from a simple event" do
+      subject.on_event do |event, data|
+        insist { data.is_a? String }
+        unicorn = Animal::UnicornEvent.parse(data) 
+    
+        expect(unicorn.colour ).to eq(event["colour"] )
+        expect(unicorn.horn_length ).to eq(event["horn_length"] )
+        expect(unicorn.last_seen ).to eq(event["last_seen"] )
+        expect(unicorn.has_wings ).to eq(event["has_wings"] )
+      
+      end # subject.on_event
+      subject.encode(event)
+    end # it
+  end # context
+
+
+
+
+  #### Test case 5: encode complex protobuf bytes for human #####################################################################################################################
+  
+  
+  context "#encode2" do
+    subject do
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => ['spec/helpers/human.pb.rb']) 
     end
-  end
+
+    event = LogStash::Event.new("first_name" => "Jimmy", "middle_names" => ["Bob", "James"], "last_name" => "Doe" \
+      , "mother" => {"first_name" => "Jane", "middle_names" => ["Elizabeth"], "last_name" => "Doe" , "age" => 83, "vegetarian"=> false} \
+      , "father" => {"first_name" => "John", "last_name" => "Doe", "@email" => "character_replacement_test@nothing" })    
+
+    it "should return protobuf encoded data from a complex event" do
+
+      subject.on_event do |event, data|
+        insist { data.is_a? String }
+        jimmy = Animal::Human.parse(data) 
+        
+        expect(jimmy.first_name ).to eq(event["first_name"] )
+        expect(jimmy.middle_names ).to eq(event["middle_names"] )
+        expect(jimmy.last_name ).to eq(event["last_name"] )
+        expect(jimmy.mother.first_name ).to eq(event["mother"]["first_name"] )
+        expect(jimmy.father.first_name ).to eq(event["father"]["first_name"] )
+        expect(jimmy.mother.middle_names ).to eq(event["mother"]["middle_names"] )
+        expect(jimmy.mother.age ).to eq(event["mother"]["age"] ) # recursion test for values
+        expect(jimmy.mother.vegetarian ).to eq(event["mother"]["vegetarian"] ) # recursion test for values
+        expect(jimmy.father.last_name ).to eq(event["father"]["last_name"] )
+        expect(jimmy.father.email ).to eq(event["father"]["@email"] ) # recursion test for keys
+        expect(jimmy.mother.last_name ).to eq(event["mother"]["last_name"] )
+      
+      end # subject.on_event
+      subject.encode(event)
+    end # it
+  end # context
+
+
+
+
+
+  #### Test case 6: encode enums #########################################################################################################################
+  
+
+ 
+  context "#encode3" do
+    subject do
+      next LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => ['spec/helpers/ColourTestcase.pb.rb'])
+    end
+
+    require 'spec/helpers/ColourTestcase.pb.rb' # otherwise we cant use the colour enums in the next line
+    event = LogStash::Event.new("booleantest" =>  [false, false, true], "least_liked" => ColourProtoTest::Colour::YELLOW,  "favourite_colours" => \
+       [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE] )    
+
+    it "should return protobuf encoded data from a complex event with enums" do
+
+      subject.on_event do |event, data|
+        insist { data.is_a? String }
+
+        colpref = ColourProtoTest.parse(data) 
+        
+        expect(colpref.booleantest ).to eq(event["booleantest"] )
+        expect(colpref.least_liked ).to eq(event["least_liked"] )
+        expect(colpref.favourite_colours ).to eq(event["favourite_colours"] )
+
+      
+      end # subject.on_event
+      subject.encode(event)
+    end # it
+  end # context
+
+
+
 end

data/spec/helpers/ColourTestcase.pb.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+# forward declarations
+class ColourProtoTest < ::ProtocolBuffers::Message; end
+
+class ColourProtoTest < ::ProtocolBuffers::Message
+  # forward declarations
+
+  # enums
+  module Colour
+    include ::ProtocolBuffers::Enum
+
+    set_fully_qualified_name "ColourProtoTest.Colour"
+
+    BLACK = 0
+    BLUE = 1
+    WHITE = 2
+    GREEN = 3
+    RED = 4
+    YELLOW = 5
+    AQUA = 6
+  end
+
+  set_fully_qualified_name "ColourProtoTest"
+
+  repeated ::ColourProtoTest::Colour, :favourite_colours, 1
+  repeated :bool, :booleantest, 2
+  optional ::ColourProtoTest::Colour, :least_liked, 3
+  optional :string, :timestamp, 4
+  optional :string, :version, 5
+end
+

data/spec/helpers/ColourTestcase.proto

@@ -0,0 +1,24 @@
+
+
+message ColourProtoTest {
+
+    enum Colour {
+          BLACK = 0;
+          BLUE = 1;
+          WHITE = 2;
+          GREEN = 3;
+          RED = 4;
+          YELLOW = 5;
+          AQUA = 6;
+
+      }
+
+    // most liked colours; test enums in arrays.
+    repeated Colour favourite_colours = 1;
+
+    // why not also test booleans in arrays while we're at it. 
+    repeated bool booleantest = 2; 
+
+    // least liked colour
+    optional Colour least_liked = 3;
+}

data/spec/helpers/human.pb.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Animal
+  # forward declarations
+  class Human < ::ProtocolBuffers::Message; end
+
+  class Human < ::ProtocolBuffers::Message
+    set_fully_qualified_name "animal.Human"
+
+    optional :string, :first_name, 1
+    repeated :string, :middle_names, 2
+    optional :string, :last_name, 3
+    optional ::Animal::Human, :mother, 4
+    optional ::Animal::Human, :father, 5
+    optional :string, :path, 6
+    optional :string, :version, 7
+    optional :string, :timestamp, 8
+    optional :string, :email, 9
+    optional :bool, :vegetarian, 10
+    optional :int32, :age, 11
+  end
+
+end

data/spec/helpers/unicorn.pb.rb

@@ -13,6 +13,7 @@ module Animal
     optional :string, :colour, 1
     optional :int32, :horn_length, 2
     optional :int32, :last_seen, 3
+    optional :bool, :has_wings, 4
   end
 
 end

data/spec/helpers/unicorn_event.pb.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+module Animal
+  # forward declarations
+  class UnicornEvent < ::ProtocolBuffers::Message; end
+
+  class UnicornEvent < ::ProtocolBuffers::Message
+    set_fully_qualified_name "animal.UnicornEvent"
+
+    optional :string, :colour, 1
+    optional :int32, :horn_length, 2
+    optional :int32, :last_seen, 3
+    optional :string, :timestamp, 4
+    optional :string, :host, 5
+    optional :string, :path, 6
+    optional :string, :version, 7
+    optional :bool, :has_wings, 8
+    
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-codec-protobuf
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Inga Feick
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-15 00:00:00.000000000 Z
+date: 2016-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-core
@@ -74,7 +74,11 @@ files:
 - lib/logstash/codecs/protobuf.rb
 - logstash-codec-protobuf.gemspec
 - spec/codecs/protobuf_spec.rb
+- spec/helpers/ColourTestcase.pb.rb
+- spec/helpers/ColourTestcase.proto
+- spec/helpers/human.pb.rb
 - spec/helpers/unicorn.pb.rb
+- spec/helpers/unicorn_event.pb.rb
 homepage:
 licenses:
 - Apache License (2.0)
@@ -103,4 +107,8 @@ specification_version: 4
 summary: This codec may be used to decode (via inputs) and encode (via outputs) protobuf messages
 test_files:
 - spec/codecs/protobuf_spec.rb
+- spec/helpers/ColourTestcase.pb.rb
+- spec/helpers/ColourTestcase.proto
+- spec/helpers/human.pb.rb
 - spec/helpers/unicorn.pb.rb
+- spec/helpers/unicorn_event.pb.rb