logstash-codec-protobuf 1.1.0 → 1.2.0

data/logstash-codec-protobuf.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-codec-protobuf'
-  s.version         = '1.1.0'
+  s.version         = '1.2.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Reads protobuf messages and converts to Logstash 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"
@@ -20,7 +20,6 @@ Gem::Specification.new do |s|
 
   # Gem dependencies
   s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
-  # s.add_runtime_dependency 'google-protobuf', '3.1'
   s.add_runtime_dependency 'google-protobuf', '3.5.0.pre'
   s.add_runtime_dependency 'ruby-protocol-buffers' # for protobuf 2
   s.add_development_dependency 'logstash-devutils'

data/spec/codecs/protobuf3_spec.rb

@@ -4,30 +4,91 @@ require "logstash/codecs/protobuf"
 require "logstash/event"
 require "insist"
 
-
 require 'google/protobuf' # for protobuf3
 
+# absolute path to the protobuf helpers directory
+pb_include_path = File.expand_path(".") + "/spec/helpers"
+
+require pb_include_path + '/pb3/unicorn_pb.rb'
+unicorn_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
 
 describe LogStash::Codecs::Protobuf do
 
-  pb_include_path = "../../../spec/helpers/"
+  context ".reloadable?" do
+    subject do
+      next LogStash::Codecs::Protobuf.new(
+        "class_name" => "Unicorn",
+        "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'],
+        "protobuf_version" => 3
+      )
+    end
+
+    it "returns false" do
+      expect(subject.reloadable?).to be_falsey
+    end
+  end
+
+  context "config" do
+    context "using class_file and include_path" do
+      let(:plugin) {
+        LogStash::Codecs::Protobuf.new(
+          "class_name" => "Unicorn",
+          "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'],
+          "class_file" => pb_include_path + '/pb3/unicorn_pb.rb',
+          "protobuf_version" => 3
+        )
+      }
+
+      it "should fail to register the plugin with ConfigurationError" do
+        expect {plugin.register}.to raise_error(LogStash::ConfigurationError, /`include_path` and `class_file`/)
+      end # it
+    end
+
+    context "not using class_file or include_path" do
+      let(:plugin) {
+        LogStash::Codecs::Protobuf.new("class_name" => "Unicorn")
+      }
+
+      it "should fail to register the plugin with ConfigurationError" do
+        expect {plugin.register}.to raise_error(LogStash::ConfigurationError, /`include_path` or `class_file`/)
+      end # it
+    end
+
+    RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+
+    context "re-registering the plugin with a valid configuration" do
+      let(:plugin) { LogStash::Codecs::Protobuf.new(
+        "class_name" => "A.MessageA",
+        "class_file" => [ pb_include_path + '/pb3/messageA_pb.rb' ],
+        "protobuf_version" => 3,
+        "protobuf_root_directory" => File.expand_path(File.dirname(__FILE__) + pb_include_path + '/pb3/'))
+      }
+
+      it "should not fail" do
+        expect {
+          # this triggers the `register()` method of the plugin multiple times
+          plugin.register
+          plugin.register
+        }.not_to raise_error(RuntimeError)
+      end # it
+    end
+  end # context
 
   context "#test1_pb3" do
 
 
     #### Test case 1: Decode simple protobuf ####################################################################################################################
-    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Unicorn", "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'], "protobuf_version" => 3)  }
-    before do
-        plugin_unicorn.register      
-    end
+    let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "Unicorn", "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'], "protobuf_version" => 3)
+    }
 
     it "should return an event from protobuf encoded data" do
-    
+
       unicorn_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
-      data = {:name => 'Pinkie', :age => 18, :is_pegasus => false, :favourite_numbers => [4711,23], :fur_colour => Colour::PINK, 
+      data = {:name => 'Pinkie', :age => 18, :is_pegasus => false, :favourite_numbers => [4711,23], :fur_colour => Colour::PINK,
       :favourite_colours => [Colour::GREEN, Colour::BLUE]
       }
-      
+
       unicorn_object = unicorn_class.new(data)
       bin = unicorn_class.encode(unicorn_object)
       plugin_unicorn.decode(bin) do |event|
@@ -39,27 +100,17 @@ describe LogStash::Codecs::Protobuf do
         expect(event.get("is_pegasus") ).to eq(data[:is_pegasus] )
       end
     end # it
-  end # context 
+  end # context
 
   context "#test2_pb3" do
 
-
-
-
     #### Test case 2: decode nested protobuf ####################################################################################################################
     let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Unicorn", "include_path" => [pb_include_path + '/pb3/unicorn_pb.rb'], "protobuf_version" => 3)  }
-    before do
-        plugin_unicorn.register      
-    end
 
     it "should return an event from protobuf encoded data with nested classes" do
-    
-
-      unicorn_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
-
       father = unicorn_class.new({:name=> "Sparkle", :age => 50, :fur_colour => 3 })
-      data = {:name => 'Glitter', :fur_colour => Colour::GLITTER, :father => father}   
-     
+      data = {:name => 'Glitter', :fur_colour => Colour::GLITTER, :father => father}
+
       unicorn_object = unicorn_class.new(data)
       bin = unicorn_class.encode(unicorn_object)
       plugin_unicorn.decode(bin) do |event|
@@ -72,23 +123,23 @@ describe LogStash::Codecs::Protobuf do
       end
     end # it
 
-  end # context 
+  end # context
 
   context "#test3_pb3" do
 
     #### Test case 3: decode ProbeResult ####################################################################################################################
     let(:plugin_3) { LogStash::Codecs::Protobuf.new("class_name" => "ProbeResult", "include_path" => [pb_include_path + '/pb3/ProbeResult_pb.rb'], "protobuf_version" => 3)  }
+
     before do
-        plugin_3.register      
+        plugin_3.register
     end
 
     it "should return an event from protobuf encoded data with nested classes" do
-    
 
       probe_result_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("ProbeResult").msgclass
       ping_result_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PingIPv4Result").msgclass
 
-      ping_result_data = {:status=> PingIPv4Result::Status::ERROR, 
+      ping_result_data = {:status=> PingIPv4Result::Status::ERROR,
         :latency => 50, :ip => "8.8.8.8", :probe_ip => "127.0.0.1", :geolocation => "New York City" }
       ping_result_object = ping_result_class.new(ping_result_data)
 
@@ -104,29 +155,30 @@ describe LogStash::Codecs::Protobuf do
         expect(event.get("TaskPingIPv4Result")["geolocation"] ).to eq(ping_result_data[:geolocation] )
       end
     end # it
-  end # context 
+  end # context
 
   context "#test4_pb3" do
 
     #### Test case 4: decode PBDNSMessage ####################################################################################################################
     let(:plugin_4) { LogStash::Codecs::Protobuf.new("class_name" => "PBDNSMessage", "include_path" => [pb_include_path + '/pb3/dnsmessage_pb.rb'], "protobuf_version" => 3)  }
+
     before do
-        plugin_4.register      
+        plugin_4.register
     end
 
     it "should return an event from protobuf encoded data with nested classes" do
-    
+
 
       pbdns_message_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage").msgclass
-      dns_question_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSQuestion").msgclass
-      dns_response_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse").msgclass
-      dns_rr_class       = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse.DNSRR").msgclass
+      dns_question_class  = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSQuestion").msgclass
+      dns_response_class  = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse").msgclass
+      dns_rr_class        = Google::Protobuf::DescriptorPool.generated_pool.lookup("PBDNSMessage.DNSResponse.DNSRR").msgclass
 
       dns_question_data = {:qName => "Foo", :qType => 12345, :qClass => 67890 }
       dns_question_object = dns_question_class.new(dns_question_data)
 
-      dns_response_data = {:rcode => 12345, :appliedPolicy => "baz", :tags => ["a","b","c"], 
-        :queryTimeSec => 123, :queryTimeUsec => 456, 
+      dns_response_data = {:rcode => 12345, :appliedPolicy => "baz", :tags => ["a","b","c"],
+        :queryTimeSec => 123, :queryTimeUsec => 456,
         :appliedPolicyType => PBDNSMessage::PolicyType::NSIP}
 
       dns_rr_data = [
@@ -160,11 +212,11 @@ describe LogStash::Codecs::Protobuf do
       pbdns_message_object = pbdns_message_class.new(pbdns_message_data)
       bin = pbdns_message_class.encode(pbdns_message_object)
       plugin_4.decode(bin) do |event|
-        
-        ['messageId', 'serverIdentity','from','to','inBytes','timeUsec','timeSec','id', 'originalRequestorSubnet', 'requestorId' ,'initialRequestId','deviceIdf'].each { |n|  
+
+        ['messageId', 'serverIdentity','from','to','inBytes','timeUsec','timeSec','id', 'originalRequestorSubnet', 'requestorId' ,'initialRequestId','deviceIdf'].each { |n|
           expect(event.get(n)).to eq(pbdns_message_data[n.to_sym] ) }
 
-        # enum test: 
+        # enum test:
         expect(event.get("type") ).to eq("DNSIncomingResponseType" )
         expect(event.get("socketFamily") ).to eq("INET6" )
         expect(event.get("socketProtocol") ).to eq("TCP" )
@@ -172,11 +224,11 @@ describe LogStash::Codecs::Protobuf do
         expect(event.get("question")["qName"] ).to eq(dns_question_data[:qName] )
         expect(event.get("question")["qType"] ).to eq(dns_question_data[:qType] )
         expect(event.get("question")["qClass"] ).to eq(dns_question_data[:qClass] )
-    
+
         ['rcode', 'appliedPolicy','tags','queryTimeSec','queryTimeUsec'].each { |n|   expect(event.get('response')[n]).to eq(dns_response_data[n.to_sym] )   }
         expect(event.get("response")['appliedPolicyType'] ).to eq("NSIP" )
 
-        dns_rr_data.each_with_index { | data, index | 
+        dns_rr_data.each_with_index { | data, index |
           found = event.get("response")['rrs'][index]
           ['name', 'type','class','ttl','rdata'].each { |n|   expect(found[n]).to eq(data[n.to_sym])   }
         }
@@ -184,14 +236,15 @@ describe LogStash::Codecs::Protobuf do
       end
     end # it
 
-  end # context 
+  end # context
 
   context "#test5_pb3" do
 
-#### Test case 5: decode test case for github issue 17 ####################################################################################################################
+    #### Test case 5: decode test case for github issue 17 ####################################################################################################################
     let(:plugin_5) { LogStash::Codecs::Protobuf.new("class_name" => "com.foo.bar.IntegerTestMessage", "include_path" => [pb_include_path + '/pb3/integertest_pb.rb'], "protobuf_version" => 3)  }
+
     before do
-        plugin_5.register      
+      plugin_5.register
     end
 
     it "should return an event from protobuf encoded data with nested classes" do
@@ -206,12 +259,53 @@ describe LogStash::Codecs::Protobuf do
 
   end # context
 
+  context "#test6_pb3" do
+
+    let(:execution_context) { double("execution_context")}
+    let(:pipeline_id) {rand(36**8).to_s(36)}
+
+    # Test case 6: decode a message automatically loading the dependencies ##############################################################################
+    let(:plugin) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "A.MessageA",
+      "class_file" => [ 'messageA_pb.rb' ],
+      "protobuf_version" => 3,
+      "protobuf_root_directory" => pb_include_path + '/pb3/')
+    }
+
+    before do
+      allow(plugin).to receive(:execution_context).and_return(execution_context)
+      allow(execution_context).to receive(:pipeline_id).and_return(pipeline_id)
+
+      # this is normally done on the input plugins we "mock" it here to avoid
+      # instantiating a dummy input plugin. See
+      # https://github.com/ph/logstash/blob/37551a89b8137c1dc6fa4fbd992584c363a36065/logstash-core/lib/logstash/inputs/base.rb#L108
+      plugin.execution_context = execution_context
+    end
+
+    it "should return an event from protobuf encoded data" do
+
+      header_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("Header").msgclass
+      header_data = {:name => {'a' => 'b'}}
+      header_object = header_class.new(header_data)
+
+      message_class = Google::Protobuf::DescriptorPool.generated_pool.lookup("A.MessageA").msgclass
+      data = {:name => "Test name", :header => header_object}
+
+      message_object = message_class.new(data)
+      bin = message_class.encode(message_object)
+
+      plugin.decode(bin) do |event|
+        expect(event.get("name") ).to eq(data[:name] )
+        expect(event.get("header")['name'] ).to eq(header_data[:name])
+      end
+    end # it
+  end # context
+
 
   context "#encodePB3-a" do
 
     #### Test case 3: encode simple protobuf ####################################################################################################################
 
-
     require_relative '../helpers/pb3/unicorn_pb.rb'
 
     subject do
@@ -226,7 +320,7 @@ describe LogStash::Codecs::Protobuf do
         insist { data.is_a? String }
 
         pb_builder = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
-        decoded_data = pb_builder.decode(data) 
+        decoded_data = pb_builder.decode(data)
         expect(decoded_data.name ).to eq(event.get("name") )
         expect(decoded_data.age ).to eq(event.get("age") )
         expect(decoded_data.is_pegasus ).to eq(event.get("is_pegasus") )
@@ -234,6 +328,7 @@ describe LogStash::Codecs::Protobuf do
         expect(decoded_data.favourite_numbers ).to eq(event.get("favourite_numbers") )
         expect(decoded_data.favourite_colours ).to eq([:BLUE,:WHITE] )
       end # subject.on_event
+
       subject.encode(event3)
     end # it
 
@@ -250,7 +345,7 @@ describe LogStash::Codecs::Protobuf do
     end
 
     event4 = LogStash::Event.new("name" => "Horst", "age" => 23, "is_pegasus" => true, "mother" => \
-        {"name" => "Mom", "age" => 47}, "father" => {"name"=> "Daddy", "age"=> 50, "fur_colour" => 3 } # 3 == SILVER      
+        {"name" => "Mom", "age" => 47}, "father" => {"name"=> "Daddy", "age"=> 50, "fur_colour" => 3 } # 3 == SILVER
       )
 
     it "should return protobuf encoded data for testcase 4" do
@@ -259,8 +354,8 @@ describe LogStash::Codecs::Protobuf do
         insist { data.is_a? String }
 
         pb_builder = Google::Protobuf::DescriptorPool.generated_pool.lookup("Unicorn").msgclass
-        decoded_data = pb_builder.decode(data) 
-        
+        decoded_data = pb_builder.decode(data)
+
         expect(decoded_data.name ).to eq(event.get("name") )
         expect(decoded_data.age ).to eq(event.get("age") )
         expect(decoded_data.is_pegasus ).to eq(event.get("is_pegasus") )
@@ -270,7 +365,7 @@ describe LogStash::Codecs::Protobuf do
         expect(decoded_data.father.age ).to eq(event.get("father")["age"] )
         expect(decoded_data.father.fur_colour ).to eq(:SILVER)
 
-      
+
       end # subject4.on_event
       subject.encode(event4)
     end # it

data/spec/codecs/protobuf_spec.rb

@@ -7,27 +7,29 @@ require "insist"
 
 require 'protocol_buffers' # https://github.com/codekitchen/ruby-protocol-buffers, for protobuf2
 
+require_relative '../helpers/pb2/header/header.pb.rb'
+require_relative '../helpers/pb2/event.pb.rb'
 
-describe LogStash::Codecs::Protobuf do
 
-  pb_include_path = "../../../spec/helpers/"
+describe LogStash::Codecs::Protobuf do
 
+  pb_include_path = File.expand_path(".") + "/spec/helpers"
 
   context "#test1" do
 
-    
+
 
     #### Test case 1: Decode simple protobuf bytes for unicorn ####################################################################################################################
     let(:plugin_unicorn) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Unicorn", "include_path" => [pb_include_path + '/pb2/unicorn.pb.rb'])  }
     before do
-        plugin_unicorn.register      
+        plugin_unicorn.register
     end
 
     it "should return an event from protobuf encoded data" do
-    
+
       data = {:colour => 'rainbow', :horn_length => 18, :last_seen => 1420081471, :has_wings => true}
       unicorn = Animal::Unicorn.new(data)
-        
+
       plugin_unicorn.decode(unicorn.serialize_to_string) do |event|
         expect(event.get("colour") ).to eq(data[:colour] )
         expect(event.get("horn_length") ).to eq(data[:horn_length] )
@@ -41,29 +43,29 @@ describe LogStash::Codecs::Protobuf do
     #### Test case 2: Decode complex protobuf bytes for human #####################################################################################################################
 
   context "#test2" do
-  
- 
+
+
     let(:plugin_human) { LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => [pb_include_path + '/pb2/human.pb.rb'])  }
     before do
-        plugin_human.register      
+        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}  
+      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.get("first_name") ).to eq(data[:first_name] )
         expect(event.get("middle_names") ).to eq(data[:middle_names] )
         expect(event.get("last_name") ).to eq(data[:last_name] )
-        expect(event.get("[mother][first_name]") ).to eq(data_m[:first_name] ) 
+        expect(event.get("[mother][first_name]") ).to eq(data_m[:first_name] )
         expect(event.get("[father][first_name]") ).to eq(data_f[:first_name] )
         expect(event.get("[mother][last_name]") ).to eq(data_m[:last_name] )
         expect(event.get("[mother][mother][last_name]") ).to eq(data_gm[:last_name] )
@@ -80,19 +82,19 @@ describe LogStash::Codecs::Protobuf do
     #### Test case 3: Decoder test for enums #####################################################################################################################
 
   context "#test3" do
-  
- 
+
+
     let(:plugin_col) { LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => [pb_include_path + '/pb2/ColourTestcase.pb.rb'])  }
     before do
-        plugin_col.register      
+        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]}  
+        [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.get("least_liked") ).to eq(data[:least_liked] )
         expect(event.get("favourite_colours") ).to eq(data[:favourite_colours] )
@@ -104,28 +106,25 @@ describe LogStash::Codecs::Protobuf do
   end # context test3
 
 
-
-
-
   #### Test case 4: Encode simple protobuf bytes for unicorn ####################################################################################################################
 
   context "#encodePB2-a" do
     subject do
-      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::UnicornEvent", "include_path" => [pb_include_path + '/pb2/unicorn_event.pb.rb']) 
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::UnicornEvent", "include_path" => [pb_include_path + '/pb2/unicorn_event.pb.rb'])
     end
 
-    event = LogStash::Event.new("colour" => "pink", "horn_length" => 12, "last_seen" => 1410081999, "has_wings" => true)    
+    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) 
-    
+        unicorn = Animal::UnicornEvent.parse(data)
+
         expect(unicorn.colour ).to eq(event.get("colour") )
         expect(unicorn.horn_length ).to eq(event.get("horn_length") )
         expect(unicorn.last_seen ).to eq(event.get("last_seen") )
         expect(unicorn.has_wings ).to eq(event.get("has_wings") )
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
@@ -135,23 +134,23 @@ describe LogStash::Codecs::Protobuf do
 
 
   #### Test case 5: encode complex protobuf bytes for human #####################################################################################################################
-  
-  
+
+
   context "#encodePB2-b" do
     subject do
-      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => [pb_include_path + '/pb2/human.pb.rb']) 
+      next LogStash::Codecs::Protobuf.new("class_name" => "Animal::Human", "include_path" => [pb_include_path + '/pb2/human.pb.rb'])
     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" })    
+      , "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) 
-        
+        jimmy = Animal::Human.parse(data)
+
         expect(jimmy.first_name ).to eq(event.get("first_name") )
         expect(jimmy.middle_names ).to eq(event.get("middle_names") )
         expect(jimmy.last_name ).to eq(event.get("last_name") )
@@ -163,7 +162,7 @@ describe LogStash::Codecs::Protobuf do
         expect(jimmy.father.last_name ).to eq(event.get("[father][last_name]") )
         expect(jimmy.father.email ).to eq(event.get("[father][@email]") ) # recursion test for keys
         expect(jimmy.mother.last_name ).to eq(event.get("[mother][last_name]") )
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
@@ -174,9 +173,9 @@ describe LogStash::Codecs::Protobuf do
 
 
   #### Test case 6: encode enums #########################################################################################################################
-  
 
- 
+
+
   context "#encodePB2-c" do
     subject do
       next LogStash::Codecs::Protobuf.new("class_name" => "ColourProtoTest", "include_path" => [pb_include_path + '/pb2/ColourTestcase.pb.rb'])
@@ -184,27 +183,56 @@ describe LogStash::Codecs::Protobuf do
 
     require_relative '../helpers/pb2/ColourTestcase.pb.rb' # otherwise we cant use the colour enums in the next line
     # ^ this import is run from the spec directory, $LOGSTASH_DIR/spec/codecs/
-    
+
     event = LogStash::Event.new("booleantest" =>  [false, false, true], "least_liked" => ColourProtoTest::Colour::YELLOW,  "favourite_colours" => \
-       [ColourProtoTest::Colour::BLACK, ColourProtoTest::Colour::BLUE] )    
+       [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) 
-        
+        colpref = ColourProtoTest.parse(data)
+
         expect(colpref.booleantest ).to eq(event.get("booleantest") )
         expect(colpref.least_liked ).to eq(event.get("least_liked") )
         expect(colpref.favourite_colours ).to eq(event.get("favourite_colours") )
 
-      
+
       end # subject.on_event
       subject.encode(event)
     end # it
   end # context
 
+  #### Test case 7: decode a message automatically loading the dependencies ######################################################################################
+
+  context "#test4" do
+    let(:plugin) { LogStash::Codecs::Protobuf.new(
+      "class_name" => "Logging::Event",
+      "class_file" => [ 'event.pb.rb' ],
+      "protobuf_root_directory" => pb_include_path + '/pb2/')
+    }
+
+    before do
+      plugin.register
+    end
+
+    it "should return an event from protobuf encoded data loading the dependencies" do
+      header = Grpc::Header.new(:protocol => 'https')
+
+      data = {
+        :name => "Test",
+        :header => header,
+      }
+
+      pb = Logging::Event.new(data)
+
+      plugin.decode(pb.serialize_to_string) do |event|
+        expect(event.get("name") ).to eq(data[:name])
+        expect(event.get("header") ).to eq({"protocol"=>"https"})
+      end
+    end # it
+  end # context test4
 
 
 end # describe