logstash-integration-rabbitmq 7.0.2-java → 7.3.0-java

data/lib/logstash/outputs/rabbitmq.rb

@@ -1,14 +1,12 @@
 # encoding: UTF-8
 require "logstash/pipeline"
 require_relative '../plugin_mixins/rabbitmq_connection'
-java_import java.util.concurrent.TimeoutException
-java_import com.rabbitmq.client.AlreadyClosedException
 
 require 'back_pressure'
 
 # Push events to a RabbitMQ exchange. Requires RabbitMQ 2.x
 # or later version (3.x is recommended).
-# 
+#
 # Relevant links:
 #
 # * http://www.rabbitmq.com/[RabbitMQ]
@@ -16,10 +14,14 @@ require 'back_pressure'
 module LogStash
   module Outputs
     class RabbitMQ < LogStash::Outputs::Base
+
+      java_import java.util.concurrent.TimeoutException
+      java_import com.rabbitmq.client.AlreadyClosedException
+
       include LogStash::PluginMixins::RabbitMQConnection
 
       config_name "rabbitmq"
-      
+
       concurrency :shared
 
       # The default codec for this plugin is JSON. You can override this to suit your particular needs however.
@@ -46,6 +48,8 @@ module LogStash
       config :message_properties, :validate => :hash, :default => {}
 
       def register
+        @message_properties_template = MessagePropertiesTemplate.new(symbolize(@message_properties).merge(:persistent => @persistent))
+
         connect!
         @hare_info.exchange = declare_exchange!(@hare_info.channel, @exchange, @exchange_type, @durable)
         # The connection close should close all channels, so it is safe to store thread locals here without closing them
@@ -67,14 +71,13 @@ module LogStash
 
       def publish(event, message)
         raise ArgumentError, "No exchange set in HareInfo!!!" unless @hare_info.exchange
+        routing_key = event.sprintf(@key)
+        message_properties = @message_properties_template.build(event)
         @gated_executor.execute do
-          local_exchange.publish(message, :routing_key => event.sprintf(@key), :properties => symbolize(@message_properties.merge(:persistent => @persistent)))
+          local_exchange.publish(message, :routing_key => routing_key, :properties => message_properties)
         end
       rescue MarchHare::Exception, IOError, AlreadyClosedException, TimeoutException => e
-        @logger.error("Error while publishing. Will retry.",
-                      :message => e.message,
-                      :exception => e.class,
-                      :backtrace => e.backtrace)
+        @logger.error("Error while publishing, will retry", error_details(e, backtrace: true))
 
         sleep_for_retry
         retry
@@ -126,6 +129,64 @@ module LogStash
           end
         end
       end
+
+      ##
+      # A `MessagePropertiesTemplate` efficiently produces per-event message properties from the
+      # provided template Hash.
+      #
+      # In order to efficiently reuse constant-value objects, returned values may be frozen.
+      class MessagePropertiesTemplate
+        ##
+        # Creates a new `MessagePropertiesTemplate` from the provided `template`
+        # @param template [Hash{Symbol=>Object}]
+        def initialize(template)
+          constant_properties = template.reject { |_,v| templated?(v) }
+          variable_properties = template.select { |_,v| templated?(v) }
+
+          @constant_properties = normalize(constant_properties).freeze
+          @variable_properties = variable_properties
+        end
+
+        ##
+        # Builds a property mapping for the given `event`, including templated values.
+        #
+        # @param event [LogStash::Event]: the event with which to populated templated values, if any.
+        # @return [Hash{Symbol=>Object}] a possibly-frozen properties hash for the provided `event`.
+        def build(event)
+          return @constant_properties if @variable_properties.empty?
+
+          properties = @variable_properties.each_with_object(@constant_properties.dup) do |(k,v), memo|
+            memo.store(k, event.sprintf(v))
+          end
+
+          return normalize(properties)
+        end
+
+        private
+
+        ##
+        # Normalize the provided property mapping with respect to the value types the underlying
+        # client expects.
+        #
+        # @api private
+        # @param properties [Hash{Symbol=>Object}]: a possibly-frozen Hash whose values may need type-coercion.
+        # @return [Hash{Symbol=>Object}]
+        def normalize(properties)
+          if properties[:priority] && properties[:priority].kind_of?(String)
+            properties = properties.merge(:priority => properties[:priority].to_i)
+          end
+
+          properties
+        end
+
+        ##
+        # @api private
+        # @param [Object]: an object, which may or may not be a template `String`
+        # @return [Boolean]: returns `true` IFF `value` is a template `String`
+        def templated?(value)
+          value.kind_of?(String) && value.include?('%{')
+        end
+      end
     end
   end
-end
+end

data/lib/logstash/plugin_mixins/rabbitmq_connection.rb

@@ -2,6 +2,7 @@
 require "logstash/namespace"
 require "march_hare"
 require "java"
+require "stud/interval"
 
 # Common functionality for the rabbitmq input/output
 module LogStash
@@ -104,17 +105,17 @@ module LogStash
       def rabbitmq_settings
         return @rabbitmq_settings if @rabbitmq_settings
 
+
         s = {
           :vhost => @vhost,
-          :hosts => @host,
-          :port  => @port,
-          :user  => @user,
+          :addresses => addresses_from_hosts_and_port(@host, @port),
+          :username  => @user,
           :automatic_recovery => @automatic_recovery,
-          :pass => @password ? @password.value : "guest",
+          :password => @password ? @password.value : "guest",
         }
 
-        s[:timeout] = @connection_timeout || 0
-        s[:heartbeat] = @heartbeat || 0
+        s[:connection_timeout] = @connection_timeout || 0
+        s[:requested_heartbeat] = @heartbeat || 0
 
         if @ssl
           s[:tls] = @ssl_version
@@ -133,10 +134,15 @@ module LogStash
         @rabbitmq_settings = s
       end
 
+      def addresses_from_hosts_and_port(hosts, port)
+        hosts.map {|host| host.include?(':') ? host : "#{host}:#{port}"}
+      end
+
+
       def connect!
         @hare_info = connect() unless @hare_info # Don't duplicate the conn!
       rescue MarchHare::Exception, java.io.IOException => e
-        error_message = if e.message.empty? && e.is_a?(java.io.IOException)
+        message = if e.message.empty? && e.is_a?(java.io.IOException)
           # IOException with an empty message is probably an instance of
           # these problems:
           # https://github.com/logstash-plugins/logstash-output-rabbitmq/issues/52
@@ -145,21 +151,12 @@ module LogStash
           # Best guess is to help the user understand that there is probably
           # some kind of configuration problem causing the error, but we
           # can't really offer any more detailed hints :\
-          "An unknown error occurred. RabbitMQ gave no hints as to the cause. Maybe this is a configuration error (invalid vhost, for example). I recommend checking the RabbitMQ server logs for clues about this failure."
+          "An unknown RabbitMQ error occurred, maybe this is a configuration error (invalid vhost, for example) - please check the RabbitMQ server logs for clues about this failure"
         else
-          e.message
+          "RabbitMQ connection error, will retry"
         end
 
-        if @logger.debug?
-          @logger.error("RabbitMQ connection error, will retry.",
-                        :error_message => error_message,
-                        :exception => e.class.name,
-                        :backtrace => e.backtrace)
-        else
-          @logger.error("RabbitMQ connection error, will retry.",
-                        :error_message => error_message,
-                        :exception => e.class.name)
-        end
+        @logger.error(message, error_details(e))
 
         sleep_for_retry
         retry
@@ -173,48 +170,43 @@ module LogStash
         @hare_info && @hare_info.connection && @hare_info.connection.open?
       end
 
-      def connected?
-        return nil unless @hare_info && @hare_info.connection
-        @hare_info.connection.connected?
-      end
-
       private
 
       def declare_exchange!(channel, exchange, exchange_type, durable)
-        @logger.debug? && @logger.debug("Declaring an exchange", :name => exchange,
-                      :type => exchange_type, :durable => durable)
-        exchange = channel.exchange(exchange, :type => exchange_type.to_sym, :durable => durable)
-        @logger.debug? && @logger.debug("Exchange declared")
-        exchange
-      rescue StandardError => e
-        @logger.error("Could not declare exchange!",
-                      :exchange => exchange, :type => exchange_type,
-                      :durable => durable, :error_class => e.class.name,
-                      :error_message => e.message, :backtrace => e.backtrace)
+        @logger.debug? && @logger.debug("Declaring an exchange", :name => exchange, :type => exchange_type, :durable => durable)
+        channel.exchange(exchange, :type => exchange_type.to_sym, :durable => durable)
+      rescue => e
+        @logger.error("Could not declare exchange", error_details(e, :exchange => exchange, :type => exchange_type, :durable => durable))
+
         raise e
       end
 
       def connect
-        @logger.debug? && @logger.debug("Connecting to RabbitMQ. Settings: #{rabbitmq_settings.inspect}")
-
-        connection = MarchHare.connect(rabbitmq_settings)
+        @logger.debug? && @logger.debug("Connecting to RabbitMQ", rabbitmq_settings)
+
+        # disable MarchHare's attempt to provide a "better" exception logging experience:
+        settings = rabbitmq_settings.merge :exception_handler => com.rabbitmq.client.impl.ForgivingExceptionHandler.new
+        connection = MarchHare.connect(settings) # MarchHare::Session.connect
+        # we could pass down the :logger => logger but that adds an extra:
+        #   `logger.info("Using TLS/SSL version #{tls}")` which isn't useful
+        # the rest of MH::Session logging is mostly debug level details
+        #
+        # NOTE: effectively redirects MarchHare's default std-out logging to LS
+        #       (MARCH_HARE_LOG_LEVEL=debug no longer has an effect)
+        connection.instance_variable_set(:@logger, LoggerAdapter.new(logger))
 
         connection.on_shutdown do |conn, cause|
-           @logger.warn("RabbitMQ connection was closed!",
-                          :url => connection_url(conn),
-                          :automatic_recovery => @automatic_recovery,
-                          :cause => cause)
+           @logger.warn("RabbitMQ connection was closed", url: connection_url(conn), automatic_recovery: @automatic_recovery, cause: cause)
         end
         connection.on_blocked do
-          @logger.warn("RabbitMQ connection blocked! Check your RabbitMQ instance!",
-                       :url => connection_url(connection))
+          @logger.warn("RabbitMQ connection blocked - please check the RabbitMQ server logs", url: connection_url(connection))
         end
         connection.on_unblocked do
-          @logger.warn("RabbitMQ connection unblocked!", :url => connection_url(connection))
+          @logger.warn("RabbitMQ connection unblocked", url: connection_url(connection))
         end
 
         channel = connection.create_channel
-        @logger.info("Connected to RabbitMQ at #{rabbitmq_settings[:host]}")
+        @logger.info("Connected to RabbitMQ", url: connection_url(connection))
 
         HareInfo.new(connection, channel)
       end
@@ -229,6 +221,44 @@ module LogStash
       def sleep_for_retry
         Stud.stoppable_sleep(@connect_retry_interval) { @rabbitmq_connection_stopping }
       end
+
+      def error_details(e, info = {})
+        details = info.merge(:exception => e.class, :message => e.message)
+        if e.is_a?(MarchHare::Exception) && e.cause
+          details[:cause] = e.cause # likely a Java exception
+        end
+        details[:backtrace] = e.backtrace if @logger.debug? || info[:backtrace] == true
+        details
+      end
+
+      # @private adapting MarchHare's Ruby Logger assumptions
+      class LoggerAdapter < SimpleDelegator
+
+        java_import java.lang.Throwable
+
+        [:trace, :debug, :info, :warn, :error, :fatal].each do |level|
+          # sample logging used by MarchHare that we're after:
+          #
+          #   rescue Exception => e
+          #     logger.error("Caught exception when recovering queue #{q.name}")
+          #     logger.error(e)
+          #   end
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{level}(arg)
+              if arg.is_a?(Exception) || arg.is_a?(Throwable)
+                details = { :exception => arg.class }
+                details[:cause] = arg.cause if arg.cause
+                details[:backtrace] = arg.backtrace
+                __getobj__.#{level}(arg.message.to_s, details)
+              else
+                __getobj__.#{level}(arg) # String
+              end
+            end
+          RUBY
+        end
+
+      end
+
     end
   end
 end

data/logstash-integration-rabbitmq.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name            = 'logstash-integration-rabbitmq'
-  s.version         = '7.0.2'
+  s.version         = '7.3.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Integration with RabbitMQ - input and output plugins"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline "+
@@ -47,7 +47,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'stud', '~> 0.0.22'
   s.add_runtime_dependency 'back_pressure', '~> 1.0'
 
-  s.add_development_dependency 'logstash-devutils'
+  s.add_development_dependency 'logstash-devutils', '~>2.0'
   s.add_development_dependency 'logstash-input-generator'
   s.add_development_dependency 'logstash-codec-plain'
 end

data/spec/inputs/rabbitmq_spec.rb

@@ -21,8 +21,13 @@ describe LogStash::Inputs::RabbitMQ do
       "prefetch_count" => 123
     }
   }
-  let(:instance) { klass.new(rabbitmq_settings) }
+  subject(:instance) { klass.new(rabbitmq_settings) }
   let(:hare_info) { instance.instance_variable_get(:@hare_info) }
+  let(:instance_logger) { double("Logger").as_null_object }
+
+  before do
+    allow_any_instance_of(klass).to receive(:logger).and_return(instance_logger)
+  end
 
   context "when connected" do
     let(:connection) { double("MarchHare Connection") }
@@ -39,6 +44,11 @@ describe LogStash::Inputs::RabbitMQ do
       allow(connection).to receive(:on_shutdown)
       allow(connection).to receive(:on_blocked)
       allow(connection).to receive(:on_unblocked)
+      allow(connection).to receive(:close)
+      allow(connection).to receive(:host).and_return host
+      allow(connection).to receive(:port).and_return port
+      allow(connection).to receive(:vhost).and_return nil
+      allow(connection).to receive(:user).and_return 'guest'
       allow(channel).to receive(:exchange).and_return(exchange)
       allow(channel).to receive(:queue).and_return(queue)
       allow(channel).to receive(:prefetch=)
@@ -74,7 +84,7 @@ describe LogStash::Inputs::RabbitMQ do
       context "with an exchange declared" do
         let(:exchange) { "exchange" }
         let(:key) { "routing key" }
-        let(:rabbitmq_settings) { super.merge("exchange" => exchange, "key" => key, "exchange_type" => "fanout") }
+        let(:rabbitmq_settings) { super().merge("exchange" => exchange, "key" => key, "exchange_type" => "fanout") }
 
         before do
           allow(instance).to receive(:declare_exchange!)
@@ -127,11 +137,193 @@ describe LogStash::Inputs::RabbitMQ do
       end
     end
   end
+
+  context '#register' do
+    let(:rabbitmq_settings) { super().merge(metadata_enabled_override) }
+    let(:metadata_enabled_override) { { "metadata_enabled" => metadata_enabled } }
+    before do
+      instance.register
+    end
+
+    shared_examples('`metadata_enabled => none`') do
+      context 'metadata_level' do
+        subject(:metadata_level) { instance.metadata_level }
+        it { is_expected.to be_empty }
+        it { is_expected.to be_frozen }
+      end
+    end
+
+    shared_examples('`metadata_enabled => basic`') do
+      context 'metadata_level' do
+        subject(:metadata_level) { instance.metadata_level }
+        it { is_expected.to include :headers }
+        it { is_expected.to include :properties }
+        it { is_expected.to_not include :payload }
+        it { is_expected.to be_frozen }
+      end
+    end
+
+    shared_examples("deprecated `metadata_enabled` setting") do |deprecated_value|
+      context 'the logger' do
+        subject(:logger) { instance_logger }
+        it 'receives a useful deprecation warning' do
+          expect(logger).to have_received(:warn).with(/Deprecated value `#{Regexp.escape(deprecated_value)}`/)
+        end
+      end
+    end
+
+    context 'when `metadata_enabled` is `true`' do
+      let(:metadata_enabled) { "true" }
+      it_behaves_like '`metadata_enabled => basic`'
+      include_examples "deprecated `metadata_enabled` setting", "true"
+    end
+
+    context 'when `metadata_enabled` is `false`' do
+      let(:metadata_enabled) { "false" }
+      it_behaves_like '`metadata_enabled => none`'
+      include_examples "deprecated `metadata_enabled` setting", "false"
+    end
+
+    context 'when `metadata_enabled` is not provided' do
+      let(:metadata_enabled_override) { Hash.new }
+      it_behaves_like '`metadata_enabled => none`'
+    end
+
+    context 'when `metadata_enabled` is `basic`' do
+      let(:metadata_enabled) { "basic" }
+      include_examples '`metadata_enabled => basic`'
+    end
+
+    context 'when `metadata_enabled` is `none`' do
+      let(:metadata_enabled) { "none" }
+      include_examples '`metadata_enabled => none`'
+    end
+
+    context 'when `metadata_enabled` is `extended`' do
+      let(:metadata_enabled) { "extended" }
+      context 'metadata_level' do
+        subject(:metadata_level) { instance.metadata_level }
+        it { is_expected.to include :headers }
+        it { is_expected.to include :properties }
+        it { is_expected.to include :payload }
+        it { is_expected.to be_frozen }
+      end
+    end
+  end
+
+  describe "#decorate(event, metadata, data)" do
+    let(:rabbitmq_settings) do
+      super().merge("metadata_enabled" => metadata_enabled)
+    end
+    before(:each) { instance.register }
+
+    let(:metadata) { double("METADATA") }
+    let(:headers) { Hash("header_key"=>"header_value") }
+    let(:properties) { Hash("property_key"=>"property_value") }
+
+    let(:data) { %Q({"message"=>"fubar"}\n) }
+
+    before do
+      allow(instance).to receive(:get_headers).with(metadata).and_return(headers)
+      allow(instance).to receive(:get_properties).with(metadata).and_return(properties)
+    end
+
+    describe 'the decorated event' do
+      subject(:decorated_event) do
+        LogStash::Event.new("message"=>"fubar").tap do |e|
+          instance.decorate(e, metadata, data)
+        end
+      end
+
+      matcher :include_field do |fieldref|
+        match do |event|
+          # setting `@actual` makes failure messages clearer
+          @actual = event.to_hash_with_metadata
+
+          break false unless event.include?(fieldref)
+          break true unless @specific_value
+
+          values_match?(@expected_value, event.get(fieldref))
+        end
+        chain :with_value do |expected_value|
+          @specific_value = true
+          @expected_value = expected_value
+        end
+        description do
+          desc = "include field `#{fieldref}`"
+          desc += " with value matching `#{@expected_value.inspect}`" if @specific_value
+          desc
+        end
+      end
+
+      shared_examples('core decoration features') do
+        let(:rabbitmq_settings) do
+          super().merge("type" => "decorated_type",
+                        "add_field" => {"added_field" => "field_value"})
+        end
+        it 'has been decorated with core decoration features' do
+          expect(decorated_event).to include_field("added_field").with_value("field_value")
+          expect(decorated_event).to include_field("type").with_value("decorated_type")
+        end
+      end
+
+      let(:headers_fieldref) { "[@metadata][rabbitmq_headers]" }
+      let(:properties_fieldref) { "[@metadata][rabbitmq_properties]" }
+      let(:payload_fieldref) { "[@metadata][rabbitmq_payload]" }
+
+      shared_examples('`metadata_enabled => none`') do
+        it { is_expected.to_not include_field(headers_fieldref) }
+        it { is_expected.to_not include_field(properties_fieldref) }
+        it { is_expected.to_not include_field(payload_fieldref) }
+
+        include_examples 'core decoration features'
+      end
+
+      shared_examples('`metadata_enabled => basic`') do
+        it { is_expected.to include_field(headers_fieldref).with_value(headers) }
+        it { is_expected.to include_field(properties_fieldref).with_value(properties) }
+        it { is_expected.to_not include_field(payload_fieldref) }
+
+        include_examples 'core decoration features'
+      end
+
+      context "with `metadata_enabled => none`" do
+        let(:metadata_enabled) { "none" }
+        include_examples '`metadata_enabled => none`'
+      end
+
+      context "with `metadata_enabled => basic`" do
+        let(:metadata_enabled) { "basic" }
+        include_examples '`metadata_enabled => basic`'
+      end
+
+      context 'with `metadata_enabled => extended`' do
+        let(:metadata_enabled) { "extended" }
+        it { is_expected.to include_field(headers_fieldref).with_value(headers) }
+        it { is_expected.to include_field(properties_fieldref).with_value(properties) }
+        it { is_expected.to include_field(payload_fieldref).with_value(data) }
+        include_examples 'core decoration features'
+      end
+
+      # Deprecated alias: false -> none
+      context "with `metadata_enabled => false`" do
+        let(:metadata_enabled) { "false" }
+        it_behaves_like '`metadata_enabled => none`'
+      end
+
+      # Deprecated alias: true -> basic
+      context "with `metadata_enabled => true`" do
+        let(:metadata_enabled) { "true" }
+        it_behaves_like '`metadata_enabled => basic`'
+      end
+    end
+  end
 end
 
-describe "with a live server", :integration => true do
+describe "LogStash::Inputs::RabbitMQ with a live server", :integration => true do
   let(:klass) { LogStash::Inputs::RabbitMQ }
-  let(:config) { {"host" => "127.0.0.1", "auto_delete" => true, "codec" => "plain", "add_field" => {"[@metadata][foo]" => "bar"} } }
+  let(:rabbitmq_host) { ENV["RABBITMQ_HOST"] || "127.0.0.1" }
+  let(:config) { {"host" => rabbitmq_host, "auto_delete" => true, "codec" => "plain", "add_field" => {"[@metadata][foo]" => "bar"} } }
   let(:instance) { klass.new(config) }
   let(:hare_info) { instance.instance_variable_get(:@hare_info) }
   let(:output_queue) { Queue.new }
@@ -147,7 +339,7 @@ describe "with a live server", :integration => true do
     }
 
     20.times do
-      instance.connected? ? break : sleep(0.1)
+      instance.send(:connection_open?) ? break : sleep(0.1)
     end
 
     # Extra time to make sure the consumer can attach
@@ -176,16 +368,16 @@ describe "with a live server", :integration => true do
 
   context "using defaults" do
     it "should start, connect, and stop cleanly" do
-      expect(instance.connected?).to be_truthy
+      expect(instance.send(:connection_open?)).to be_truthy
     end
   end
 
   it "should have the correct prefetch value" do
-    expect(instance.instance_variable_get(:@hare_info).channel.prefetch).to eql(256)
+    expect(hare_info.channel.prefetch).to eql(256)
   end
 
   describe "receiving a message with a queue + exchange specified" do
-    let(:config) { super.merge("queue" => queue_name, "exchange" => exchange_name, "exchange_type" => "fanout", "metadata_enabled" => true) }
+    let(:config) { super().merge("queue" => queue_name, "exchange" => exchange_name, "exchange_type" => "fanout", "metadata_enabled" => "true") }
     let(:event) { output_queue.pop }
     let(:exchange) { test_channel.exchange(exchange_name, :type => "fanout") }
     let(:exchange_name) { "logstash-input-rabbitmq-#{rand(0xFFFFFFFF)}" }
@@ -237,7 +429,7 @@ describe "with a live server", :integration => true do
         expect(event).to include("@metadata")
         expect(event.get("@metadata")).to include("rabbitmq_properties")
 
-        props = event.get("[@metadata][rabbitmq_properties")
+        props = event.get("[@metadata][rabbitmq_properties]")
         expect(props["app-id"]).to eq(app_id)
         expect(props["delivery-mode"]).to eq(1)
         expect(props["exchange"]).to eq(exchange_name)
@@ -273,7 +465,34 @@ describe "with a live server", :integration => true do
     end
   end
 
+  context "(MarchHare) error logging" do
+
+    let(:error) do
+      MarchHare::Exception.new('TEST ERROR').tap do |error|
+        allow( error ).to receive(:cause).and_return(error_cause)
+      end
+    end
+    let(:error_cause) { java.io.IOException.new('TEST CAUSE') }
+    let(:logger) { instance.logger }
+
+    before do
+      queues = hare_info.channel.instance_variable_get(:@queues)
+      expect( queue = queues.values.first ).to_not be nil
+      # emulate an issue during recovery (to trigger logger.error calls)
+      allow( queue ).to receive(:recover_from_network_failure).and_raise(error)
+      allow( logger ).to receive(:error)
+    end
+
+    it "gets redirected to plugin logger" do
+      hare_info.channel.recover_queues
+      expect( logger ).to have_received(:error).with(/Caught exception when recovering queue/i)
+      expect( logger ).to have_received(:error).with('TEST ERROR', hash_including(exception: MarchHare::Exception, cause: error_cause))
+    end
+
+  end
+
   describe LogStash::Inputs::RabbitMQ do
+    require "logstash/devutils/rspec/shared_examples"
     it_behaves_like "an interruptible input plugin"
   end
 end