bunny 0.9.0.pre10 → 0.9.0.pre11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83dfd362f0b0debb9919c5970dca6755de1d0604
+  data.tar.gz: cc5877189c28c76efd33bc6a04cb09801b144220
+SHA512:
+  metadata.gz: 2ea6375cc2de43483d8f50ad1fcc7395ebd54b0fd590d262bf8962a2872874bd7688790fd84d65b0a71ef027a6edc44d80193232d8b13d2c7179ffbbc3108e12
+  data.tar.gz: 97ec376b03d8cacfaa805c689da8ee5eb7f82bfce40a7f900fc055317fb314ca73c8e4f57c7d256f3ff95aa094bdfd700a35471ac19c7f13c0642ef386a3b071

data/.ruby-version

@@ -1 +1 @@
-1.9.3@amqp
+2.0@amqp

data/.travis.yml

@@ -2,13 +2,12 @@ bundler_args: --without development
 before_script: "./bin/ci/before_build.sh"
 script: "bundle exec rspec -c spec"
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - ruby-head
-  - rbx-18mode
+  - "2.0"
+  - "1.9.3"
   - rbx-19mode
   - jruby-19mode
+  - "1.9.2"
+  - "1.8.7"
 notifications:
   email: michael@defprotocol.org
 services:
@@ -16,6 +15,4 @@ services:
 branches:
   only:
     - master
-    - 0.8.x-stable
     - 0.9.x-stable
-    - migrate_to_amq_protocol

data/ChangeLog.md

@@ -1,7 +1,86 @@
+## Changes between Bunny 0.9.0.pre10 and 0.9.0.pre11
+
+### Bunny::Session#create_channel Now Accepts Consumer Work Pool Size
+
+`Bunny::Session#create_channel` now accepts consumer work pool size as
+the second argument:
+
+``` ruby
+# nil means channel id will be allocated by Bunny.
+# 8 is the number of threads in the consumer work pool this channel will use.
+ch = conn.create_channel(nil, 8)
+```
+
+### Heartbeat Fix For Long Running Consumers
+
+Long running consumers that don't send any data will no longer
+suffer from connections closed by RabbitMQ because of skipped
+heartbeats.
+
+Activity tracking now takes sent frames into account.
+
+
+### Time-bound continuations
+
+If a network loop exception causes "main" session thread to never
+receive a response, methods such as `Bunny::Channel#queue` will simply time out
+and raise Timeout::Error now, which can be handled.
+
+It will not start automatic recovery for two reasons:
+
+ * It will be started in the network activity loop anyway
+ * It may do more damage than good
+
+Kicking off network recovery manually is a matter of calling
+`Bunny::Session#handle_network_failure`.
+
+The main benefit of this implementation is that it will never
+block the main app/session thread forever, and it is really
+efficient on JRuby thanks to a j.u.c. blocking queue.
+
+Fixes #112.
+
+
+### Logging Support
+
+Every Bunny connection now has a logger. By default, Bunny will use STDOUT
+as logging device. This is configurable using the `:log_file` option:
+
+``` ruby
+require "bunny"
+
+conn = Bunny.new(:log_level => :warn)
+```
+
+or the `BUNNY_LOG_LEVEL` environment variable that can take one of the following
+values:
+
+ * `debug` (very verbose)
+ * `info`
+ * `warn`
+ * `error`
+ * `fatal` (least verbose)
+
+Severity is set to `warn` by default. To disable logging completely, set the level
+to `fatal`.
+
+To redirect logging to a file or any other object that can act as an I/O entity,
+pass it to the `:log_file` option.
+
+
 ## Changes between Bunny 0.9.0.pre9 and 0.9.0.pre10
 
 This release contains a **breaking API change**.
 
+### Concurrency Improvements On JRuby
+
+On JRuby, Bunny now will use `java.util.concurrent`-backed implementations
+of some of the concurrency primitives. This both improves client stability
+(JDK concurrency primitives has been around for 9 years and have
+well-defined, documented semantics) and opens the door to solving
+some tricky failure handling problems in the future.
+
+
 ### Explicitly Closed Sockets
 
 Bunny now will correctly close the socket previous connection had

data/Gemfile

@@ -26,7 +26,9 @@ gem "effin_utf8"
 
 group :development do
   gem "yard"
+
   gem "redcarpet", :platform => :mri
+  gem "ruby-prof", :platform => :mri
 end
 
 group :test do
@@ -40,7 +42,7 @@ gemspec
 def custom_gem(name, options = Hash.new)
   local_path = File.expand_path("../vendor/#{name}", __FILE__)
   if File.exist?(local_path)
-    puts "Using #{name} from #{local_path}..."
+    # puts "Using #{name} from #{local_path}..."
     gem name, options.merge(:path => local_path).delete_if { |key, _| [:git, :branch].include?(key) }
   else
     gem name, options

data/README.md

@@ -62,7 +62,7 @@ ch = conn.create_channel
 # declare a queue
 q  = ch.queue("test1")
 
-# declare default direct exchange which is bound to all queues
+# default direct exchange is automatically bound to all queues
 e  = ch.default_exchange
 
 # publish a message to the exchange which then gets routed to the queue

data/benchmarks/basic_publish/with_128K_messages.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 50_000
+ch = conn.create_channel
+x  = ch.default_exchange
+s  = "z" * (1024 * 128)
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+16000.times { x.publish(s, :routing_key => "anything") }
+
+# give OS, the server and so on some time to catch
+# up
+sleep 2.0
+
+t  = Benchmark.realtime do
+  n.times { x.publish(s, :routing_key => "anything") }
+end
+r  = (n.to_f/t.to_f)
+
+puts "Publishing rate with #{s.bytesize} bytes/msg: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/basic_publish/with_1k_messages.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 50_000
+ch = conn.create_channel
+x  = ch.default_exchange
+s  = "z" * 1024
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+16000.times { x.publish(s, :routing_key => "anything") }
+
+# give OS, the server and so on some time to catch
+# up
+sleep 2.0
+
+t  = Benchmark.realtime do
+  n.times { x.publish(s, :routing_key => "anything") }
+end
+r  = (n.to_f/t.to_f)
+
+puts "Publishing rate with #{s.bytesize} bytes/msg: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/basic_publish/with_4K_messages.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 50_000
+ch = conn.create_channel
+x  = ch.default_exchange
+s  = "z" * 4096
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+16000.times { x.publish(s, :routing_key => "anything") }
+
+# give OS, the server and so on some time to catch
+# up
+sleep 2.0
+
+t  = Benchmark.realtime do
+  n.times { x.publish(s, :routing_key => "anything") }
+end
+r  = (n.to_f/t.to_f)
+
+puts "Publishing rate with #{s.bytesize} bytes/msg: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/basic_publish/with_64K_messages.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 50_000
+ch = conn.create_channel
+x  = ch.default_exchange
+s  = "z" * (1024 * 64)
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+16000.times { x.publish(s, :routing_key => "anything") }
+
+# give OS, the server and so on some time to catch
+# up
+sleep 2.0
+
+t  = Benchmark.realtime do
+  n.times { x.publish(s, :routing_key => "anything") }
+end
+r  = (n.to_f/t.to_f)
+
+puts "Publishing rate with #{s.bytesize} bytes/msg: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/channel_open.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 500
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+1000.times { conn.create_channel }
+
+t  = Benchmark.realtime do
+  n.times { conn.create_channel }
+end
+r  = (n.to_f/t.to_f)
+
+puts "channel.open rate: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/queue_declare.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+ch   = conn.create_channel
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 4000
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+n.times { ch.queue("", :exclusive => true) }
+
+t  = Benchmark.realtime do
+  n.times { ch.queue("", :exclusive => true) }
+end
+r  = (n.to_f/t.to_f)
+
+puts "queue.declare (server-named, exclusive = true) rate: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/queue_declare_and_bind.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+ch   = conn.create_channel
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 4000
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+n.times { ch.queue("", :exclusive => true).bind("amq.fanout") }
+
+t  = Benchmark.realtime do
+  n.times { ch.queue("", :exclusive => true).bind("amq.fanout") }
+end
+r  = (n.to_f/t.to_f)
+
+puts "queue.declare + queue.bind rate: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/queue_declare_bind_and_delete.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require "bunny"
+require "benchmark"
+
+conn = Bunny.new
+conn.start
+ch   = conn.create_channel
+
+puts
+puts "-" * 80
+puts "Benchmarking on #{RUBY_DESCRIPTION}"
+
+n  = 4000
+
+# warm up the JIT, etc
+puts "Doing a warmup run..."
+n.times { ch.queue("", :exclusive => true).bind("amq.fanout").delete }
+
+t  = Benchmark.realtime do
+  n.times { ch.queue("", :exclusive => true).bind("amq.fanout").delete }
+end
+r  = (n.to_f/t.to_f)
+
+puts "queue.declare + queue.bind + queue.delete rate: #{(r / 1000).round(2)} KGHz"
+puts
+puts "-" * 80

data/benchmarks/write_vs_write_nonblock.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require "benchmark"
+
+# This tests demonstrates throughput difference of
+# IO#write and IO#write_nonblock. Note that the two
+# may not be equivalent depending on your
+
+r, w = IO.pipe
+
+# buffer size
+b    = 65536
+
+read_loop = Thread.new do
+  loop do
+    begin
+      r.read_nonblock(b)
+    rescue Errno::EWOULDBLOCK, Errno::EAGAIN => e
+      IO.select([r])
+      retry
+    end
+  end
+end
+
+n = 10_000
+# 7 KB
+s = "a" * (7 * 1024)
+Benchmark.bm do |meter|
+  meter.report("write:") do
+    n.times { w.write(s.dup) }
+  end
+  meter.report("write + flush:") do
+    n.times { w.write(s.dup); w.flush }
+  end
+  meter.report("write_nonblock:") do
+    n.times do
+      s2 = s.dup
+      begin
+        while !s2.empty?
+          written = w.write_nonblock(s2)
+          s2.slice!(0, written)
+        end
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        IO.select([], [w])
+        retry
+      end
+    end
+  end
+end