logstash-output-rabbitmq 1.0.1-java → 1.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 196e13c70544a6e6b7429647f627d2909ca4b5df
-  data.tar.gz: 3e6871d57fdcb9afde9a531058728e0f57b252f8
+  metadata.gz: 89989010433ce0b5c2eb56006cefbb38eb71e465
+  data.tar.gz: 004f589a86bbbcb901167a38976c411c2b1d7dab
 SHA512:
-  metadata.gz: 28810116ec622545494f279bb88107edf73e74d8f9886f533a8cf51c2e42dd096255ebcffbbefd8ae97b64031a024c6279128923280a53f5ad31e0b6c3fec87b
-  data.tar.gz: 4088c7f9ebdf63d9458effc176127df3c4fa3a8cd9acb6299d3e60ac47c4efb71f58935be1d49db8a341673bba6e29c5768f284e3a69871551b8938cd9ed4d62
+  metadata.gz: 9cce7f5bd69bd54c440b21f0cb1c89879fec275b58c63c17cc30536e9d2c61646e74e33f968f247e7d44dcd99606704168251aa4f54a31cafc4a08c62483d06d
+  data.tar.gz: de07d8b894eb6c93bbeb2ed82d70587a5ffd764a2dc924021134e6dae629718c085b496ecfe58f31fce16fd9892e58bfa057c7f9d6c2714b8dbc3e650b0b3138

data/CHANGELOG.md

@@ -1,2 +1,5 @@
+* 1.1.0
+ - Many internal refactors
+ - Bump march hare version to 2.11.0
 * 1.0.1
  - Fix connection leakage/failure to reconnect on disconnect

data/CONTRIBUTORS

@@ -13,6 +13,7 @@ Contributors:
 * Pier-Hugues Pellerin (ph)
 * Richard Pijnenburg (electrical)
 * avleen
+* ssc-
 
 Note: If you've sent us patches, bug reports, or otherwise contributed to
 Logstash, and you aren't on the list above and want to be, please let us know

data/examples/sample.conf

@@ -0,0 +1,11 @@
+input {
+  stdin {}
+}
+
+output {
+  rabbitmq {
+    host => "127.0.0.1"
+    exchange => "foo"
+    exchange_type => "topic"
+  }
+}

data/lib/logstash/outputs/rabbitmq.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 require "logstash/outputs/base"
 require "logstash/namespace"
+require "march_hare"
+require "java"
 
 # Push events to a RabbitMQ exchange. Requires RabbitMQ 2.x
 # or later version (3.x is recommended).
@@ -9,16 +11,12 @@ require "logstash/namespace"
 #
 # * http://www.rabbitmq.com/[RabbitMQ]
 # * http://rubymarchhare.info[March Hare]
-# * http://rubybunny.info[Bunny]
 class LogStash::Outputs::RabbitMQ < LogStash::Outputs::Base
   EXCHANGE_TYPES = ["fanout", "direct", "topic"]
 
-  config_name "rabbitmq"
-
+  HareInfo = Struct.new(:connection, :channel, :exchange)
 
-  #
-  # Connection
-  #
+  config_name "rabbitmq"
 
   # RabbitMQ server address
   config :host, :validate => :string, :required => true
@@ -44,12 +42,8 @@ class LogStash::Outputs::RabbitMQ < LogStash::Outputs::Base
   # Enable or disable logging
   config :debug, :validate => :boolean, :default => false, :deprecated => "Use the logstash --debug flag for this instead."
 
-
-
-  #
-  # Exchange
-  #
-
+  # Try to automatically recovery from broken connections. You almost certainly don't want to override this!!!
+  config :automatic_recovery, :validate => :boolean, :default => true
 
   # The exchange type (fanout, topic, direct)
   config :exchange_type, :validate => EXCHANGE_TYPES, :required => true
@@ -68,7 +62,8 @@ class LogStash::Outputs::RabbitMQ < LogStash::Outputs::Base
   # Should RabbitMQ persist messages to disk?
   config :persistent, :validate => :boolean, :default => true
 
-
+  # Time in seconds to wait before retrying a connection
+  config :connect_retry_interval, :validate => :number, :default => 1
 
   def initialize(params)
     params["codec"] = "json" if !params["codec"]
@@ -76,20 +71,108 @@ class LogStash::Outputs::RabbitMQ < LogStash::Outputs::Base
     super
   end
 
-  # Use MarchHare on JRuby to avoid IO#select CPU spikes
-  # (see github.com/ruby-amqp/bunny/issues/95).
-  #
-  # On MRI, use Bunny.
-  #
-  # See http://rubybunny.info and http://rubymarchhare.info
-  # for the docs.
-  if RUBY_ENGINE == "jruby"
-    require "logstash/outputs/rabbitmq/march_hare"
+  public
+  def register
+    connect!
+    @codec.on_event(&method(:publish))
+  end
+
+  public
+  def receive(event)
+    return unless output?(event)
+
+    @codec.encode(event)
+  rescue StandardError => e
+    @logger.warn("Error encoding event", :exception => e, :event => event)
+  end
+
+  private
+  def publish(event, message)
+    @hare_info.exchange.publish(message, :routing_key => event.sprintf(@key), :properties => { :persistent => @persistent })
+  rescue MarchHare::Exception, IOError, com.rabbitmq.client.AlreadyClosedException => e
+    return if terminating?
+
+    @logger.error("Error while publishing. Will retry.",
+                  :message => e.message,
+                  :exception => e.class,
+                  :backtrace => e.backtrace)
+
+    sleep_for_retry
+    connect!
+    retry
+  end
 
-    include MarchHareImpl
-  else
-    require "logstash/outputs/rabbitmq/bunny"
+  public
+  def to_s
+    return "<LogStash::RabbitMQ::Output: amqp://#{@user}@#{@host}:#{@port}#{@vhost}/#{@exchange_type}/#{@exchange}\##{@key}>"
+  end
+
+  public
+  def teardown
+    @hare_info.connection.close if connection_open?
+
+    finished
+  end
+
+  private
+  def settings
+    return @settings if @settings
+
+    s = {
+      :vhost => @vhost,
+      :host  => @host,
+      :port  => @port,
+      :user  => @user,
+      :automatic_recovery => @automatic_recovery,
+      :pass => @password ? @password.value : "guest",
+    }
+    s[:tls] = @ssl if @ssl
+    @settings = s
+  end
+
+  private
+  def connect
+    @logger.debug("Connecting to RabbitMQ. Settings: #{settings.inspect}, queue: #{@queue.inspect}")
+
+
+    connection = MarchHare.connect(settings)
+    connection.on_blocked { @logger.warn("RabbitMQ output blocked! Check your RabbitMQ instance!") }
+    connection.on_unblocked { @logger.warn("RabbitMQ output unblocked!") }
+
+    channel = connection.create_channel
+    @logger.info("Connected to RabbitMQ at #{settings[:host]}")
+
+    @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("Exchange declared")
+
+    HareInfo.new(connection, channel, exchange)
+  end
+
+  private
+  def connect!
+    @hare_info = connect() unless connection_open?
+  rescue MarchHare::Exception => e
+    return if terminating?
+
+    @logger.error("RabbitMQ connection error, will retry.",
+                  :message => e.message,
+                  :exception => e.class.name,
+                  :backtrace => e.backtrace)
+
+    sleep_for_retry
+    retry
+  end
+
+  private
+  def connection_open?
+    @hare_info && @hare_info.connection && @hare_info.connection.open?
+  end
 
-    include BunnyImpl
+  private
+  def sleep_for_retry
+    sleep @connect_retry_interval
   end
-end # class LogStash::Outputs::RabbitMQ
+end

data/logstash-output-rabbitmq.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-output-rabbitmq'
-  s.version         = '1.0.1'
+  s.version         = '1.1.0'
   s.licenses        = ['Apache License (2.0)']
   s.summary         = "Push events to a RabbitMQ exchange"
   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"
@@ -22,12 +22,8 @@ Gem::Specification.new do |s|
   # Gem dependencies
   s.add_runtime_dependency "logstash-core", '>= 1.4.0', '< 2.0.0'
 
-  if RUBY_PLATFORM == 'java'
-    s.platform = RUBY_PLATFORM
-    s.add_runtime_dependency 'march_hare', ['~> 2.5.1'] #(MIT license)
-  else
-    s.add_runtime_dependency 'bunny', ['>= 1.6.0'] #(MIT license)
-  end
+  s.platform = RUBY_PLATFORM
+  s.add_runtime_dependency 'march_hare', ['~> 2.11.0'] #(MIT license)
 
   s.add_development_dependency 'logstash-devutils'
   s.add_development_dependency 'logstash-input-generator'

data/spec/outputs/rabbitmq_spec.rb

@@ -4,129 +4,160 @@ require "logstash/pipeline"
 require "logstash/outputs/rabbitmq"
 
 describe LogStash::Outputs::RabbitMQ do
+  let(:klass) { LogStash::Outputs::RabbitMQ }
+  let(:host) { "localhost" }
+  let(:port) { 5672 }
+  let(:exchange_type) { "topic" }
+  let(:exchange) { "myexchange" }
+  let(:key) { "mykey" }
+  let(:persistent) { true }
+  let(:settings) {
+    {
+      "host" => host,
+      "port" => port,
+      "exchange_type" => exchange_type,
+      "exchange" => exchange,
+      "key" => key,
+      "persistent" => persistent
+    }
+  }
+  let(:instance) { klass.new(settings) }
+  let(:hare_info) { instance.instance_variable_get(:@hare_info) }
 
-  describe "rabbitmq static key" do
-    config <<-END
-      input {
-        generator {
-          count => 1
-        }
-      }
-      output {
-        rabbitmq {
-          host => "localhost"
-          exchange_type => "topic"
-          exchange => "foo"
-          key => "bar"
-        }
-      }
-    END
-
-    it "should use defined key" do
-      exchange = double("exchange")
-      expect_any_instance_of(LogStash::Outputs::RabbitMQ).to receive(:connect).and_return(nil)
-      expect_any_instance_of(LogStash::Outputs::RabbitMQ).to receive(:declare_exchange).and_return(exchange)
-
-      expect(exchange).to receive(:publish).with(an_instance_of(String), {:routing_key => "bar", :properties => {:persistent => true}})
-
-      # we need to set expectations before running the pipeline, this is why we cannot use the
-      # "agent" spec construct here so we do it manually
-      pipeline = LogStash::Pipeline.new(config)
-      pipeline.run
-    end
-
-  end
+  context "when connected" do
+    let(:connection) { double("MarchHare Connection") }
+    let(:channel) { double("Channel") }
+    let(:exchange) { double("Exchange") }
 
-  describe "rabbitmq key with dynamic field" do
-    config <<-END
-      input {
-        generator {
-          count => 1
-          add_field => ["foo", "bar"]
-        }
-      }
-      output {
-        rabbitmq {
-          host => "localhost"
-          exchange_type => "topic"
-          exchange => "foo"
-          key => "%{foo}"
-        }
-      }
-    END
-
-    it "should populate the key with the content of the event foo field" do
-      exchange = double("exchange")
-      expect_any_instance_of(LogStash::Outputs::RabbitMQ).to receive(:connect).and_return(nil)
-      expect_any_instance_of(LogStash::Outputs::RabbitMQ).to receive(:declare_exchange).and_return(exchange)
-
-      expect(exchange).to receive(:publish).with(an_instance_of(String), {:routing_key => "bar", :properties => {:persistent => true}})
-
-      # we need to set expectations before running the pipeline, this is why we cannot use the
-      # "agent" spec construct here so we do it manually
-      pipeline = LogStash::Pipeline.new(config)
-      pipeline.run
+    before do
+      allow(instance).to receive(:connect!).and_call_original
+      allow(::MarchHare).to receive(:connect).and_return(connection)
+      allow(connection).to receive(:create_channel).and_return(channel)
+      allow(connection).to receive(:on_blocked)
+      allow(connection).to receive(:on_unblocked)
+      allow(channel).to receive(:exchange).and_return(exchange)
+
+      instance.register
     end
 
-  end
+    describe "#register" do
+      subject { instance }
 
-  # TODO: Redo all this
-  # This is a crazy test to fix an urgent bug. It tests that we actually to change the
-  # store exchange value when an exception happens
-  # This should be a small number of lines, but until we refactor we must jump through hoops
-  # to put the plugin in the proper state and extract the proper state to test
-  describe "retrying a publish" do
-    let(:settings) {
-      {
-        "host" => "localhost",
-        "exchange_type" => "topic",
-        "exchange" => "foo",
-        "key" => "%{foo}"
-      }
-    }
-    let(:event) { LogStash::Event.new("foo" => "bar")}
+      it "should create cleanly" do
+        expect(subject).to be_a(klass)
+      end
 
-    subject { LogStash::Outputs::RabbitMQ.new(settings) }
+      it "should connect" do
+        expect(subject).to have_received(:connect!).once
+      end
+    end
 
-    before do
-      allow(subject).to receive(:connect) {
-                          subject.instance_variable_get(:@connected).set(true)
-                        }
+    describe "#connect!" do
+      subject { hare_info }
 
-      exchange_invocation = 0
+      it "should set @hare_info correctly" do
+        expect(subject).to be_a(LogStash::Outputs::RabbitMQ::HareInfo)
+      end
 
-      @most_recent_exchange = nil
+      it "should set @connection correctly" do
+        expect(subject.connection).to eql(connection)
+      end
 
-      allow(subject).to receive(:declare_exchange) do
-        exchange_invocation += 1
-        @most_recent_exchange = double("exchange #{exchange_invocation}")
+      it "should set the channel correctly" do
+        expect(subject.channel).to eql(channel)
       end
 
-      subject.register
+      it "should set the exchange correctly" do
+        expect(subject.exchange).to eql(exchange)
+      end
     end
 
-    context "when the connection aborts once" do
-      before do
-        i = 0
-        allow(subject).to receive(:attempt_publish_serialized) do
-          i+=1
-          if i == 1 # Raise an exception once
-           raise MarchHare::Exception, "First"
-          else
-            "nope"
-          end
+    describe "#publish_encoded" do
+      let(:event) { LogStash::Event.new("foo" => "bar") }
+      let(:sprinted_key) { double("sprinted key") }
+      let(:encoded_event) { LogStash::Json.dump(event) }
+
+      describe "issuing the publish" do
+        before do
+          allow(exchange).to receive(:publish).with(any_args)
+          allow(event).to receive(:sprintf).with(key).and_return(sprinted_key)
+          instance.send(:publish, event, encoded_event)
         end
 
-        subject.publish_serialized(event, "hello")
+        it "should send the correct message" do
+          expect(exchange).to have_received(:publish).with(encoded_event, anything)
+        end
+
+        it "should send the correct metadata" do
+          expected_metadata = {:routing_key => sprinted_key, :properties => {:persistent => persistent }}
+
+          expect(exchange).to have_received(:publish).with(anything, expected_metadata)
+        end
       end
 
-      it "should re-declare the exchange" do
-        expect(subject).to have_received(:declare_exchange).twice
+      context "when a MarchHare::Exception is encountered" do
+        before do
+          i = 0
+          allow(instance).to receive(:connect!)
+          allow(instance).to receive(:sleep_for_retry)
+          allow(exchange).to receive(:publish).with(any_args) do
+            i += 1
+            raise(MarchHare::Exception, "foo") if i == 1
+          end
+
+          instance.send(:publish, event, encoded_event)
+        end
+
+        it "should execute publish twice due to a retry" do
+          expect(exchange).to have_received(:publish).twice
+        end
+
+        it "should sleep for the retry" do
+          expect(instance).to have_received(:sleep_for_retry).once
+        end
+
+        it "should send the correct message (twice)" do
+          expect(exchange).to have_received(:publish).with(encoded_event, anything).twice
+        end
+
+        it "should send the correct metadata (twice)" do
+          expected_metadata = {:routing_key => event.sprintf(key), :properties => {:persistent => persistent }}
+
+          expect(exchange).to have_received(:publish).with(anything, expected_metadata).twice
+        end
       end
+    end
+  end
+
+  # If the connection encounters an exception during its initial
+  # connection attempt we must handle that. Subsequent errors should be
+  # handled by the automatic retry mechanism built-in to MarchHare
+  describe "initial connection exceptions" do
+    subject { instance }
+
+    before do
+      allow(subject).to receive(:sleep_for_retry)
+
 
-      it "should set the exchange to the second double" do
-        expect(subject.instance_variable_get(:@x)).to eql(@most_recent_exchange)
+      i = 0
+      allow(subject).to receive(:connect) do
+        i += 1
+        if i == 1
+          raise(MarchHare::ConnectionRefused, "Error!")
+        else
+          double("connection")
+        end
       end
+
+      subject.send(:connect!)
+    end
+
+    it "should retry its connection when conn fails" do
+      expect(subject).to have_received(:connect).twice
+    end
+
+    it "should sleep between retries" do
+      expect(subject).to have_received(:sleep_for_retry).once
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-output-rabbitmq
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: java
 authors:
 - Elastic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-07-16 00:00:00.000000000 Z
+date: 2015-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-core
@@ -36,12 +36,12 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: 2.11.0
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: 2.11.0
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency
@@ -100,10 +100,8 @@ files:
 - NOTICE.TXT
 - README.md
 - Rakefile
+- examples/sample.conf
 - lib/logstash/outputs/rabbitmq.rb
-- lib/logstash/outputs/rabbitmq/bunny.rb
-- lib/logstash/outputs/rabbitmq/hot_bunnies.rb
-- lib/logstash/outputs/rabbitmq/march_hare.rb
 - logstash-output-rabbitmq.gemspec
 - spec/outputs/rabbitmq_spec.rb
 homepage: http://www.elastic.co/guide/en/logstash/current/index.html

data/lib/logstash/outputs/rabbitmq/bunny.rb

@@ -1,138 +0,0 @@
-# encoding: utf-8
-
-require "logstash/json"
-
-class LogStash::Outputs::RabbitMQ
-  module BunnyImpl
-
-    #
-    # API
-    #
-
-    def register
-      require "bunny"
-
-      @logger.info("Registering output", :plugin => self)
-
-      connect
-      declare_exchange
-    end # def register
-
-
-    def receive(event)
-      return unless output?(event)
-
-      @logger.debug("Sending event", :destination => to_s, :event => event, :key => key)
-      key = event.sprintf(@key) if @key
-
-      begin
-        publish_serialized(event.to_json, key)
-      rescue LogStash::Json::GeneratorError => e
-        @logger.warn("Trouble converting event to JSON", :exception => e,
-                     :event => event)
-      end
-    end
-
-    def publish_serialized(message, key = @key)
-      begin
-        if @x
-          @x.publish(message, :persistent => @persistent, :routing_key => key)
-        else
-          @logger.warn("Tried to send a message, but not connected to RabbitMQ yet.")
-        end
-      rescue Bunny::NetworkFailure, Bunny::ConnectionClosedError, Bunny::ConnectionLevelException, Bunny::TCPConnectionFailed => e
-        n = Bunny::Session::DEFAULT_NETWORK_RECOVERY_INTERVAL * 2
-
-        @logger.error("RabbitMQ connection error: #{e.message}. Will attempt to reconnect in #{n} seconds...",
-                      :exception => e,
-                      :backtrace => e.backtrace)
-        return if terminating?
-
-        sleep n
-        connect
-        declare_exchange
-        retry
-      end
-    end
-
-    def to_s
-      return "amqp://#{@user}@#{@host}:#{@port}#{@vhost}/#{@exchange_type}/#{@exchange}\##{@key}"
-    end
-
-    def teardown
-      @conn.close if @conn && @conn.open?
-      @conn = nil
-
-      finished
-    end
-
-
-
-    #
-    # Implementation
-    #
-
-    def connect
-      @vhost       ||= Bunny::DEFAULT_HOST
-      # 5672. Will be switched to 5671 by Bunny if TLS is enabled.
-      @port        ||= AMQ::Protocol::DEFAULT_PORT
-      @routing_key ||= "#"
-
-      @settings = {
-        :vhost => @vhost,
-        :host  => @host,
-        :port  => @port,
-        :automatically_recover => false
-      }
-      @settings[:user]      = @user || Bunny::DEFAULT_USER
-      @settings[:pass]      = if @password
-                                @password.value
-                              else
-                                Bunny::DEFAULT_PASSWORD
-                              end
-
-      @settings[:log_level] = if @debug || @logger.debug?
-                                :debug
-                              else
-                                :error
-                              end
-
-      @settings[:tls]        = @ssl if @ssl
-      @settings[:verify_ssl] = @verify_ssl if @verify_ssl
-
-      proto                  = if @ssl
-                                 "amqp"
-                               else
-                                 "amqps"
-                               end
-      @connection_url        = "#{proto}://#{@user}@#{@host}:#{@port}#{vhost}/#{@queue}"
-
-      begin
-        @conn = Bunny.new(@settings)
-
-        @logger.debug("Connecting to RabbitMQ. Settings: #{@settings.inspect}, queue: #{@queue.inspect}")
-        return if terminating?
-        @conn.start
-
-        @ch = @conn.create_channel
-        @logger.info("Connected to RabbitMQ at #{@settings[:host]}")
-      rescue Bunny::NetworkFailure, Bunny::ConnectionClosedError, Bunny::ConnectionLevelException, Bunny::TCPConnectionFailed => e
-        n = Bunny::Session::DEFAULT_NETWORK_RECOVERY_INTERVAL * 2
-
-        @logger.error("RabbitMQ connection error: #{e.message}. Will attempt to reconnect in #{n} seconds...",
-                      :exception => e,
-                      :backtrace => e.backtrace)
-        return if terminating?
-
-        sleep n
-        retry
-      end
-    end
-
-    def declare_exchange
-      @logger.debug("Declaring an exchange", :name => @exchange, :type => @exchange_type,
-                    :durable => @durable)
-      @x = @ch.exchange(@exchange, :type => @exchange_type.to_sym, :durable => @durable)
-    end
-  end # BunnyImpl
-end # LogStash::Outputs::RabbitMQ

data/lib/logstash/outputs/rabbitmq/hot_bunnies.rb

@@ -1 +0,0 @@
-require "logstash/outputs/rabbitmq/march_hare"

data/lib/logstash/outputs/rabbitmq/march_hare.rb

@@ -1,142 +0,0 @@
-# encoding: utf-8
-class LogStash::Outputs::RabbitMQ
-  module MarchHareImpl
-
-
-    #
-    # API
-    #
-
-    def register
-      require "march_hare"
-      require "java"
-
-      @logger.info("Registering output", :plugin => self)
-
-      @connected = java.util.concurrent.atomic.AtomicBoolean.new
-
-      connect
-      @x = declare_exchange
-
-      @connected.set(true)
-
-      @codec.on_event(&method(:publish_serialized))
-    end
-
-
-    def receive(event)
-      return unless output?(event)
-
-      begin
-        @codec.encode(event)
-      rescue => e
-        @logger.warn("Error encoding event", :exception => e, :event => event)
-      end
-    end
-
-    def publish_serialized(event, message)
-      attempt_publish_serialized(event, message)
-    rescue MarchHare::Exception, IOError, com.rabbitmq.client.AlreadyClosedException => e
-      @connected.set(false)
-      n = 10
-
-      @logger.error("RabbitMQ connection error: #{e.message}. Will attempt to reconnect in #{n} seconds...",
-                    :exception => e,
-                    :backtrace => e.backtrace)
-      return if terminating?
-
-      sleep n
-
-      connect
-      @x = declare_exchange
-      retry
-    end
-
-    def attempt_publish_serialized(event, message)
-      if @connected.get
-        @x.publish(message, :routing_key => event.sprintf(@key), :properties => { :persistent => @persistent })
-      else
-        @logger.warn("Tried to send a message, but not connected to RabbitMQ.")
-      end
-    end
-
-    def to_s
-      return "amqp://#{@user}@#{@host}:#{@port}#{@vhost}/#{@exchange_type}/#{@exchange}\##{@key}"
-    end
-
-    def teardown
-      @connected.set(false)
-      @conn.close if @conn && @conn.open?
-      @conn = nil
-
-      finished
-    end
-
-
-
-    #
-    # Implementation
-    #
-
-    def connect
-      return if terminating?
-
-      @vhost       ||= "127.0.0.1"
-      # 5672. Will be switched to 5671 by Bunny if TLS is enabled.
-      @port        ||= 5672
-
-      @settings = {
-        :vhost => @vhost,
-        :host  => @host,
-        :port  => @port,
-        :user  => @user,
-        :automatic_recovery => false
-      }
-      @settings[:pass]      = if @password
-                                @password.value
-                              else
-                                "guest"
-                              end
-
-      @settings[:tls]        = @ssl if @ssl
-      proto                  = if @ssl
-                                 "amqp"
-                               else
-                                 "amqps"
-                               end
-      @connection_url        = "#{proto}://#{@user}@#{@host}:#{@port}#{vhost}/#{@queue}"
-
-      begin
-        @conn = MarchHare.connect(@settings) unless @conn && @conn.open?
-
-        @logger.debug("Connecting to RabbitMQ. Settings: #{@settings.inspect}, queue: #{@queue.inspect}")
-
-        @ch = @conn.create_channel
-        @logger.info("Connected to RabbitMQ at #{@settings[:host]}")
-      rescue MarchHare::Exception => e
-        @connected.set(false)
-        n = 10
-
-        @logger.error("RabbitMQ connection error: #{e.message}. Will attempt to reconnect in #{n} seconds...",
-                      :exception => e,
-                      :backtrace => e.backtrace)
-        return if terminating?
-
-        sleep n
-        retry
-      end
-    end
-
-    def declare_exchange
-      @logger.debug("Declaring an exchange", :name => @exchange, :type => @exchange_type,
-                    :durable => @durable)
-      x = @ch.exchange(@exchange, :type => @exchange_type.to_sym, :durable => @durable)
-
-      # sets @connected to true during recovery. MK.
-      @connected.set(true)
-
-      x
-    end
-
-  end # MarchHareImpl
-end