protobuf 2.8.0 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1793f24401f3a3def50cf704b6beb4bb27887efc
-  data.tar.gz: 6dbc2f1080b4d2a3f3c01cfa2248ea8945aec972
+  metadata.gz: 1d622f286e789d42300ea06beabd355cdab3530e
+  data.tar.gz: 6d4a9e0fe5fc77d8bd8c65eec0befba2ff6cf9c3
 SHA512:
-  metadata.gz: 6107077595047bd1ce774463faf020075b3a3d1b494ce8a814dac9eab5d124b36a6eb6dfc7fd3f9010c0a54d9c7ea6bbc18d4c04181a07827814c3609dc4bd94
-  data.tar.gz: c2598cb57886e62c86fb77cccdbfc8629ca9c78c3a26eabb8c9cd675be58000cddbc7c71928d53a3e0245b34cccbc4670334f5ebd9869c2b94831f2cf914c68b
+  metadata.gz: 2aa2229e5701441dce3d776080f00f3306796440e55f7b085cafa03539fcbc1e35c0067d5d14de7d0285ebbdced0b708cd854b88579af2330974a587dd6e012e
+  data.tar.gz: 2080bb81394099f161a98ec44622f54343333ac3381a09da2d327041d7f46fae9b2c45a1ed0936bac9dd5ce96e442afa13b6ffbc9c9b7750182448e7f3aedbda

data/CHANGES.md

@@ -1,3 +1,11 @@
+2.8.1
+----------
+
+- Improve `ServiceDirectory` lookup speed ~10x, lookups now done in constant time (devin-c).
+- Add Timestamp to end of rpc stat log (represents ending time of request processing).
+- Set `request_size` in the rpc stat within ZMQ Worker (previously missing).
+- Ensure `request_size` and `response_size` are set on rpc stat for client requests.
+
 2.8.0
 -----------
 

data/Rakefile

@@ -1,5 +1,5 @@
-$:.push File.expand_path("./", File.dirname(__FILE__))
-$:.push File.expand_path("./spec", File.dirname(__FILE__))
+$: << ::File.expand_path('../', __FILE__)
+$: << ::File.expand_path('../spec', __FILE__)
 
 require "rubygems"
 require "rubygems/package_task"
@@ -13,17 +13,3 @@ task :default => :spec
 
 desc "Run specs"
 RSpec::Core::RakeTask.new(:spec)
-
-##
-# rake-compiler
-#
-spec = Gem::Specification.load("protobuf.gemspec")
-
-Gem::PackageTask.new(spec) do |pkg|
-end
-
-if RUBY_PLATFORM =~ /java/
-  require "rake/javaextensiontask"
-else
-  require "rake/extensiontask"
-end

data/lib/protobuf/rpc/connectors/common.rb

@@ -74,6 +74,7 @@ module Protobuf
           log_debug { sign_message("Parsing response from server (connection closed)") }
 
           # Parse out the raw response
+          @stats.response_size = @response_data.size
           response_wrapper = Protobuf::Socketrpc::Response.decode(@response_data)
 
           # Determine success or failure based on parsed data
@@ -120,6 +121,7 @@ module Protobuf
         def setup_connection
           initialize_stats
           @request_data = request_bytes
+          @stats.request_size = request_bytes.size
         end
 
         def succeed(response)

data/lib/protobuf/rpc/connectors/socket.rb

@@ -55,7 +55,6 @@ module Protobuf
           return if error?
           response_buffer = ::Protobuf::Rpc::Buffer.new(:read)
           response_buffer << read_data
-          @stats.response_size = response_buffer.size
           @response_data = response_buffer.data
           parse_response if response_buffer.flushed?
         end

data/lib/protobuf/rpc/connectors/zmq.rb

@@ -115,7 +115,6 @@ module Protobuf
         def send_request_with_lazy_pirate
           attempt = 0
           timeout = options[:timeout].to_f
-          @stats.request_size = @request_data.size
 
           begin
             attempt += 1

data/lib/protobuf/rpc/server.rb

@@ -67,6 +67,7 @@ module Protobuf
       # Parse the incoming request object into our expected request object
       def parse_request_from_buffer
         log_debug { sign_message("Parsing request from buffer: #{@request_data}") }
+        @stats.request_size = @request_data.size
         @request.decode(@request_data)
       rescue => error
         exc = ::Protobuf::Rpc::BadRequestData.new("Unable to parse request: #{error.message}")

data/lib/protobuf/rpc/servers/evented/server.rb

@@ -19,7 +19,6 @@ module Protobuf
 
           @request_buffer << data
           @request_data = @request_buffer.data
-          @stats.request_size = @request_buffer.size
 
           handle_client if @request_buffer.flushed?
         end

data/lib/protobuf/rpc/servers/socket/worker.rb

@@ -20,8 +20,6 @@ module Protobuf
           request_buffer << read_data
           @request_data = request_buffer.data
 
-          @stats.request_size = request_buffer.size
-
           log_debug { sign_message("handling request") }
           handle_client if request_buffer.flushed?
         end

data/lib/protobuf/rpc/service_directory.rb

@@ -1,6 +1,7 @@
 require 'delegate'
 require 'singleton'
 require 'socket'
+require 'set'
 require 'thread'
 require 'timeout'
 
@@ -21,20 +22,32 @@ module Protobuf
         attr_reader :expires_at
 
         def initialize(server)
-          @server = server
-          @expires_at = Time.now.to_i + ttl
+          update(server)
         end
 
         def current?
           !expired?
         end
 
+        def eql?(other)
+          uuid.eql?(other.uuid)
+        end
+
         def expired?
           Time.now.to_i >= @expires_at
         end
 
+        def hash
+          uuid.hash
+        end
+
         def ttl
-          [super.to_i, 3].max
+          [super.to_i, 1].max
+        end
+
+        def update(server)
+          @server = server
+          @expires_at = Time.now.to_i + ttl
         end
 
         def __getobj__
@@ -65,70 +78,22 @@ module Protobuf
         self.instance.stop
       end
 
+      #
       # Instance Methods
       #
       def initialize
-        @listings = {}
-        @mutex = Mutex.new
-      end
-
-      def add_listing_for(server)
-        if server && server.uuid
-          @mutex.synchronize do
-            action = @listings.key?(server.uuid) ? :updated : :added
-            log_debug { sign_message("#{action} server: #{server.inspect}") }
-
-            listing = Listing.new(server)
-            @listings[server.uuid] = listing
-            trigger(action, listing)
-          end
-        else
-          log_info { sign_message("Cannot add server without uuid: #{server.inspect}") }
-        end
+        reset
       end
 
       def each_listing(&block)
-        @listings.each_value(&block)
+        @listings_by_uuid.each_value(&block)
       end
 
       def lookup(service)
         if running?
-          @mutex.synchronize do
-            listings = @listings.values.select do |listing|
-              listing.services.any? do |listed_service|
-                listing.current? && listed_service == service.to_s
-              end
-            end
-
-            listings.sample
-          end
-        end
-      end
-
-      def remove_expired_listings
-        @mutex.synchronize do
-          @listings.delete_if do |uuid, listing|
-            if listing.expired?
-              trigger(:removed, listing)
-              true
-            else
-              false
-            end
-          end
-        end
-      end
-
-      def remove_listing_for(server)
-        if server && server.uuid
-          log_debug { sign_message("Removing server: #{server.inspect}") }
-
-          @mutex.synchronize do
-            deleted_listing = @listings.delete(server.uuid)
-            trigger(:removed, deleted_listing)
+          if @listings_by_service.key?(service)
+            @listings_by_service[service].entries.sample
           end
-
-        else
-          log_info { sign_message("Cannot remove server without uuid: #{server.inspect}") }
         end
       end
 
@@ -154,18 +119,34 @@ module Protobuf
       def stop
         log_info { sign_message("Stopping directory") }
 
-        @mutex.synchronize do
-          @thread.try(:kill)
-          @thread = nil
-          @listings = {}
-        end
-
+        @thread.try(:kill).try(:join)
         @socket.try(:close)
-        @socket = nil
+
+        reset
       end
 
       private
 
+      def add_or_update_listing(uuid, server)
+        listing = @listings_by_uuid[uuid]
+
+        if listing
+          action = :updated
+          listing.update(server)
+        else
+          action = :added
+          listing = Listing.new(server)
+          @listings_by_uuid[uuid] = listing
+        end
+
+        listing.services.each do |service|
+          @listings_by_service[service] << listing
+        end
+
+        trigger(action, listing)
+        log_debug { sign_message("#{action} server: #{server.inspect}") }
+      end
+
       def init_socket
         @socket = UDPSocket.new
         @socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEADDR, true)
@@ -178,39 +159,80 @@ module Protobuf
       end
 
       def process_beacon(beacon)
-        case beacon.beacon_type
-        when ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT
-          add_listing_for(beacon.server)
-        when ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE
-          remove_listing_for(beacon.server)
+        server = beacon.server
+        uuid = server.try(:uuid)
+
+        if server && uuid
+          case beacon.beacon_type
+          when ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT
+            add_or_update_listing(uuid, server)
+          when ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE
+            remove_listing(uuid)
+          end
+        else
+          log_info { sign_message("Ignoring incomplete beacon: #{beacon.inspect}") }
+        end
+      end
+
+      def read_beacon
+        data, addr = @socket.recvfrom(2048)
+
+        beacon = ::Protobuf::Rpc::DynamicDiscovery::Beacon.decode(data)
+
+        # Favor the address captured by the socket
+        beacon.try(:server).try(:address=, addr[3])
+
+        beacon
+      end
+
+      def remove_expired_listings
+        log_debug { sign_message("Removing expired listings") }
+        @listings_by_uuid.each do |uuid, listing|
+          remove_listing(uuid) if listing.expired?
         end
       end
 
+      def remove_listing(uuid)
+        listing = @listings_by_uuid[uuid] or return
+
+        log_debug { sign_message("Removing listing: #{listing.inspect}") }
+
+        @listings_by_service.each do |service, listings|
+          listings.delete(listing)
+        end
+
+        trigger(:removed, @listings_by_uuid.delete(uuid))
+      end
+
+      def reset
+        @thread = nil
+        @socket = nil
+        @listings_by_uuid = {}
+        @listings_by_service = Hash.new { |h, k| h[k] = Set.new }
+      end
+
       def run
+        sweep_interval = 1 # sweep expired listings every 1 second
+        next_sweep = Time.now.to_i + sweep_interval
+
         loop do
-          beacon = wait_for_beacon
-          process_beacon(beacon)
-          remove_expired_listings
+          timeout = [next_sweep - Time.now.to_i, 0.1].max
+          readable = IO.select([@socket], nil, nil, timeout)
+          process_beacon(read_beacon) if readable
+
+          if Time.now.to_i >= next_sweep
+            remove_expired_listings
+            next_sweep = Time.now.to_i + sweep_interval
+          end
         end
       rescue => e
-        log_debug { sign_message("error: (#{e.class}) #{e.message}") }
+        log_debug { sign_message("ERROR: (#{e.class}) #{e.message}\n#{e.backtrace.join("\n")}") }
         retry
       end
 
       def trigger(action, listing)
         ::Protobuf::Lifecycle.trigger("directory.listing.#{action}", listing)
       end
-
-      def wait_for_beacon
-        data, addr = @socket.recvfrom(2048)
-
-        beacon = ::Protobuf::Rpc::DynamicDiscovery::Beacon.decode(data)
-
-        # Favor the address captured by the socket
-        beacon.try(:server).try(:address=, addr[3])
-
-        beacon
-      end
     end
   end
 end

data/lib/protobuf/rpc/stat.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'time'
 require 'protobuf/logger'
 
 module Protobuf
@@ -11,6 +12,8 @@ module Protobuf
 
       def initialize(mode = :SERVER)
         @mode = mode
+        @request_size = 0
+        @response_size = 0
         start
       end
 
@@ -43,16 +46,20 @@ module Protobuf
       end
 
       def sizes
-        "#{@request_size || 0}B/#{@response_size || 0}B" if stopped?
+        if stopped?
+          "#{@request_size}B/#{@response_size}B"
+        else
+          "#{@request_size}B/-"
+        end
       end
 
       def start
-        @start_time ||= Time.now
+        @start_time ||= ::Time.now
       end
 
       def stop
         start unless @start_time
-        @end_time ||= Time.now
+        @end_time ||= ::Time.now
       end
 
       def stopped?
@@ -77,13 +84,14 @@ module Protobuf
           server? ? client : server,
           trace_id,
           rpc,
+          sizes,
           elapsed_time,
-          sizes
+          @end_time.try(:iso8601)
         ].compact.join(' - ')
       end
 
       def trace_id
-        Thread.current.object_id.to_s(16)
+        ::Thread.current.object_id.to_s(16)
       end
 
     end

data/lib/protobuf/version.rb

@@ -1,4 +1,4 @@
 module Protobuf
-  VERSION = '2.8.0'
-  PROTOC_VERSION = '2.4.1'
+  VERSION = '2.8.1'
+  PROTOC_VERSION = '2.5.0'
 end

data/protobuf.gemspec

@@ -27,9 +27,9 @@ require "protobuf/version"
   s.add_development_dependency 'ffi-rzmq'
   s.add_development_dependency 'pry-nav'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'rake-compiler'
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
+  s.add_development_dependency 'timecop'
   # s.add_development_dependency 'perftools.rb'
 end

data/spec/lib/protobuf/code_generator_spec.rb

@@ -15,8 +15,8 @@ describe ::Protobuf::CodeGenerator do
     let(:output_file1) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/foo.pb.rb') }
     let(:output_file2) { COMPILER::CodeGeneratorResponse::File.new(:name => 'test/bar.pb.rb') }
 
-    let(:file_generator1) { mock('file generator 1', :generate_output_file => output_file1) }
-    let(:file_generator2) { mock('file generator 2', :generate_output_file => output_file2) }
+    let(:file_generator1) { double('file generator 1', :generate_output_file => output_file1) }
+    let(:file_generator2) { double('file generator 2', :generate_output_file => output_file2) }
 
     let(:request_bytes) do
       COMPILER::CodeGeneratorRequest.encode(:proto_file => [ input_file1, input_file2 ])

data/spec/lib/protobuf/generators/base_spec.rb

@@ -5,10 +5,10 @@ require 'protobuf/generators/base'
 
 describe ::Protobuf::Generators::Base do
 
-  subject { described_class.new(mock) }
+  subject { described_class.new(double) }
 
   context 'namespaces' do
-    let(:descriptor) { mock(:name => 'Baz') }
+    let(:descriptor) { double(:name => 'Baz') }
     subject { described_class.new(descriptor, 0, :namespace => [ :foo, :bar ]) }
     its(:type_namespace) { should eq [ :foo, :bar, 'Baz' ] }
     its(:fully_qualified_type_namespace) { should eq '.foo.bar.Baz' }
@@ -55,7 +55,7 @@ describe ::Protobuf::Generators::Base do
       end
     end
 
-    subject { ToStringTest.new(mock) }
+    subject { ToStringTest.new(double) }
 
     it 'compiles and returns the contents' do
       10.times do

data/spec/lib/protobuf/generators/extension_generator_spec.rb

@@ -7,9 +7,9 @@ describe ::Protobuf::Generators::ExtensionGenerator do
 
   let(:field_descriptors) {
     [
-      mock('field descriptor 1', :to_s => "  field 1\n"),
-      mock('field descriptor 2', :to_s => "  field 2\n"),
-      mock('field descriptor 3', :to_s => "  field 3\n")
+      double('field descriptor 1', :to_s => "  field 1\n"),
+      double('field descriptor 2', :to_s => "  field 2\n"),
+      double('field descriptor 3', :to_s => "  field 3\n")
     ]
   }
   let(:message_type) { 'FooBar' }

data/spec/lib/protobuf/rpc/connectors/zmq_spec.rb

@@ -12,20 +12,20 @@ describe ::Protobuf::Rpc::Connectors::Zmq do
     :port => "9400"
   }}
 
-  let(:socket_mock) do
-    sm = mock(::ZMQ::Socket)
+  let(:socket_double) do
+    sm = double(::ZMQ::Socket)
     sm.stub(:connect).and_return(0)
     sm
   end
 
-  let(:zmq_context_mock) do
-    zc = mock(::ZMQ::Context)
-    zc.stub(:socket).and_return(socket_mock)
+  let(:zmq_context_double) do
+    zc = double(::ZMQ::Context)
+    zc.stub(:socket).and_return(socket_double)
     zc
   end
 
   before do
-    ::ZMQ::Context.stub(:new).and_return(zmq_context_mock)
+    ::ZMQ::Context.stub(:new).and_return(zmq_context_double)
   end
 
   describe "#lookup_server_uri" do

data/spec/lib/protobuf/rpc/service_directory_spec.rb

@@ -3,185 +3,268 @@ require 'spec_helper'
 require 'protobuf/rpc/service_directory'
 
 describe ::Protobuf::Rpc::ServiceDirectory do
-  let(:instance) { ::Protobuf::Rpc::ServiceDirectory.instance }
-
-  def listings
-    instance.instance_variable_get(:@listings)
+  subject { described_class.instance }
+
+  let(:echo_server) {
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => 'echo',
+      :address => '127.0.0.1',
+      :port => '1111',
+      :ttl => 10,
+      :services => %w[EchoService]
+    )
+  }
+
+  let(:hello_server) {
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "hello",
+      :address => '127.0.0.1',
+      :port => "1112",
+      :ttl => 10,
+      :services => %w[HelloService]
+    )
+  }
+
+  let(:hello_server_with_short_ttl) {
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "hello_server_with_short_ttl",
+      :address => '127.0.0.1',
+      :port => '1113',
+      :ttl => 1,
+      :services => %w[HelloService]
+    )
+  }
+
+  let(:combo_server) {
+    ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+      :uuid => "combo",
+      :address => '127.0.0.1',
+      :port => '1114',
+      :ttl => 10,
+      :services => %w[HelloService EchoService]
+    )
+  }
+
+  before(:all) do
+    @address = "127.0.0.1"
+    @port = 33333
+    @socket = UDPSocket.new
+
+    described_class.address = @address
+    described_class.port = @port
   end
 
-  def duration
-    start = Time.now.to_f
-    yield
-    Time.now.to_f - start
+  def expect_event_trigger(event)
+    ::Protobuf::Lifecycle
+      .should_receive(:trigger)
+      .with(event,
+            an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing))
+      .once
   end
 
-  after do
-    instance.stop
+  def send_beacon(type, server)
+    type = type.to_s.upcase
+    beacon = ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
+      :server => server,
+      :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType.fetch(type)
+    )
+
+    @socket.send(beacon.encode, 0, @address, @port)
+    sleep 0.01 # give the service directory time to process the beacon
   end
 
-  it "is a singleton" do
-    instance.should be_a_kind_of(Singleton)
+  it "should be a singleton" do
+    subject.should be_a_kind_of(Singleton)
   end
 
-  describe "#lookup" do
-    let(:server) { double('server', :uuid => '123',
-                          :services => ['Known::Service'],
-                          :address => "0.0.0.0",
-                          :port => 9999,
-                          :ttl => 15) }
-    let(:listing) { ::Protobuf::Rpc::ServiceDirectory::Listing.new(server) }
+  it "should be configured to listen to address 127.0.0.1" do
+    described_class.address.should eq '127.0.0.1'
+  end
 
-    before do
-      instance.stub(:running?) { true }
-    end
+  it "should be configured to listen to port 33333" do
+    described_class.port.should eq 33333
+  end
 
-    it "returns a listing for the given service" do
-      instance.add_listing_for(server)
-      instance.lookup("Known::Service").should eq listing
-    end
+  it "should defer .start to the instance#start" do
+    described_class.instance.should_receive(:start)
+    described_class.start
+  end
 
-    it "returns random listings" do
-      instance.add_listing_for double(:uuid => 1, :ttl => 5, :services => ["Test"])
-      instance.add_listing_for double(:uuid => 2, :ttl => 5, :services => ["Test"])
+  it "should yeild itself to blocks passed to .start" do
+    described_class.instance.stub(:start)
+    expect { |b| described_class.start(&b) }.to yield_with_args(described_class)
+  end
 
-      uuids = 100.times.map { instance.lookup("Test").uuid }
-      uuids.count(1).should be_within(25).of(50)
-      uuids.count(2).should be_within(25).of(50)
-    end
+  it "should defer .stop to the instance#stop" do
+    described_class.instance.should_receive(:stop)
+    described_class.stop
+  end
 
-    it "does not return expired listings" do
-      instance.instance_variable_set(:@listings, {
-        '1' => double(:current? => false, :services => ["Test"]),
-      })
+  context "stopped" do
+    before { subject.stop }
 
-      instance.lookup("Test").should be_nil
+    describe "#lookup" do
+      it "should return nil" do
+        send_beacon(:heartbeat, echo_server)
+        subject.lookup("EchoService").should be_nil
+      end
     end
-  end
 
-  describe '#add_listing_for' do
-    let(:server) { double('server', { :uuid => '123',
-                                      :services => ['Known::Service'],
-                                      :address => "0.0.0.0",
-                                      :port => 9999,
-                                      :ttl => 15 }) }
-
-    it 'adds the listing to the known @listings' do
-      expect {
-        ::Protobuf::Lifecycle.should_receive(:trigger)
-                              .with('directory.listing.added', an_instance_of(::Protobuf::Rpc::ServiceDirectory::Listing))
-                              .once
-        instance.add_listing_for(server)
-      }.to change(listings, :size).from(0).to(1)
+    describe "#restart" do
+      it "should start the service" do
+        subject.restart
+        subject.should be_running
+      end
     end
-  end
-
-  describe '#each_listing' do
-    let(:listing_doubles) { { '1' => double('listing 1'),
-                              '2' => double('listing 2'),
-                              '3' => double('listing 3') } }
 
-    before do
-      instance.instance_variable_set(:@listings, listing_doubles)
+    describe "#running" do
+      it "should be false" do
+        subject.should_not be_running
+      end
     end
 
-    it 'invokes the given block for each listing known by the directory' do
-      yielded_listings = []
-      instance.each_listing do |listing|
-        yielded_listings << listing
+    describe "#stop" do
+      it "has no effect" do
+        subject.stop
       end
-      yielded_listings.should eq(listing_doubles.values)
     end
   end
 
-  describe "#remove_expired_listings" do
-    let(:listing_doubles) { { '1' => double(:expired? => true),
-                              '2' => double(:expired? => true),
-                              '3' => double(:expired? => false) } }
+  context "started" do
+    before { subject.start }
+    after { subject.stop }
 
-    before do
-      instance.instance_variable_set(:@listings, listing_doubles)
-    end
+    it { should be_running }
 
-    it "removes expired listings" do
-      expect {
-        ::Protobuf::Lifecycle.should_receive(:trigger)
-                              .with('directory.listing.removed', an_instance_of(RSpec::Mocks::Mock))
-                              .twice
-        instance.remove_expired_listings
-      }.to change(listings, :size).from(3).to(1)
-      listings.keys.should eq ['3']
+    it "should trigger added events" do
+      expect_event_trigger("directory.listing.added")
+      send_beacon(:heartbeat, echo_server)
     end
-  end
 
-  describe "#start" do
-    it "creates a thread" do
-      Thread.should_receive(:new)
-      instance.start
+    it "should trigger updated events" do
+      send_beacon(:heartbeat, echo_server)
+      expect_event_trigger("directory.listing.updated")
+      send_beacon(:heartbeat, echo_server)
     end
 
-    it "initializes the socket" do
-      instance.should_receive :init_socket
-      instance.start
+    it "should trigger removed events" do
+      send_beacon(:heartbeat, echo_server)
+      expect_event_trigger("directory.listing.removed")
+      send_beacon(:flatline, echo_server)
     end
 
-    it "calls #run" do
-      instance.should_receive(:run)
-      instance.start
-      sleep 0.01
-    end
+    describe "#each_listing" do
+      it "should yield to a block for each listing" do
+        send_beacon(:heartbeat, hello_server)
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
 
-    it "changes the running state" do
-      expect {
-        instance.start
-      }.to change(instance, :running?).from(false).to(true)
+        expect { |block|
+          subject.each_listing(&block)
+        }.to yield_control.exactly(3).times
+      end
     end
-  end
 
-  describe "a running service directory" do
-    let(:socket) { UDPSocket.new }
+    describe "#lookup" do
+      it "should provide listings by service" do
+        send_beacon(:heartbeat, hello_server)
+        subject.lookup("HelloService").to_hash.should eq hello_server.to_hash
+      end
+
+      it "should return random listings" do
+        send_beacon(:heartbeat, hello_server)
+        send_beacon(:heartbeat, combo_server)
+
+        uuids = 100.times.map { subject.lookup("HelloService").uuid }
+        uuids.count("hello").should be_within(25).of(50)
+        uuids.count("combo").should be_within(25).of(50)
+      end
+
+      it "should not return expired listings" do
+        send_beacon(:heartbeat, hello_server_with_short_ttl)
+        sleep 1
+        subject.lookup("HelloService").should be_nil
+      end
+
+      it "should not return flatlined servers" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        send_beacon(:flatline, echo_server)
+
+        uuids = 100.times.map { subject.lookup("EchoService").uuid }
+        uuids.count("combo").should eq 100
+      end
+
+      it "should return up-to-date listings" do
+        send_beacon(:heartbeat, echo_server)
+        echo_server.port = "7777"
+        send_beacon(:heartbeat, echo_server)
 
-    def thread
-      instance.instance_variable_get(:@thread)
+        subject.lookup("EchoService").port.should eq "7777"
+      end
     end
 
-    before do
-      described_class.start do |config|
-        config.address = "127.0.0.1"
-        config.port = 33333
+    describe "#restart" do
+      it "should clear all listings" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        subject.restart
+        subject.lookup("EchoService").should be_nil
       end
+    end
 
-      socket.connect described_class.address, described_class.port
+    describe "#running" do
+      it "should be true" do
+        subject.should be_running
+      end
     end
 
-    context "receiving a heartbeat" do
-      let(:server) { ::Protobuf::Rpc::DynamicDiscovery::Server.new(:uuid => 'heartbeat', :address => '127.0.0.1') }
-      let(:beacon) { ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
-        :server => server,
-        :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::HEARTBEAT
-      )}
-      let(:payload) { beacon.encode }
+    describe "#stop" do
+      it "should clear all listings" do
+        send_beacon(:heartbeat, echo_server)
+        send_beacon(:heartbeat, combo_server)
+        subject.stop
+        subject.lookup("EchoService").should be_nil
+      end
 
-      it "adds a listing" do
-        instance.should_receive(:add_listing_for).with(server)
-        instance.should_receive(:remove_expired_listings)
-        socket.send(payload, 0)
-        sleep 0.01
+      it "should stop the server" do
+        subject.stop
+        subject.should_not be_running
       end
     end
+  end
+
+  if ENV.key?("BENCH")
+    context "performance" do
+      let(:servers) {
+        100.times.collect do |x|
+          ::Protobuf::Rpc::DynamicDiscovery::Server.new(
+            :uuid => server_name = "performance_server#{x + 1}",
+            :address => '127.0.0.1',
+            :port => (5555 + x).to_s,
+            :ttl => rand(1..5),
+            :services => 10.times.collect { |y| "PerformanceService#{y}" }
+          )
+        end
+      }
+
+      before do
+        require 'benchmark'
+        subject.start
+        servers.each { |server| send_beacon(:heartbeat, server) }
+      end
+
+      after do
+        subject.stop
+      end
 
-    context "receiving a flatline" do
-      let(:server) { ::Protobuf::Rpc::DynamicDiscovery::Server.new(:uuid => 'flatline', :address => '127.0.0.1') }
-      let(:beacon) { ::Protobuf::Rpc::DynamicDiscovery::Beacon.new(
-        :server => server,
-        :beacon_type => ::Protobuf::Rpc::DynamicDiscovery::BeaconType::FLATLINE
-      )}
-      let(:payload) { beacon.encode }
-
-      it "removes a listing" do
-        instance.should_receive(:remove_listing_for).with(server)
-        instance.should_receive(:remove_expired_listings)
-        socket.send(payload, 0)
-        sleep 0.01
+      it "should perform lookups in constant time" do
+        print "\n\n"
+        Benchmark.bm(17) do |x|
+          x.report("  1_000 lookups:") {   1_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report(" 10_000 lookups:") {  10_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+          x.report("100_000 lookups:") { 100_000.times { subject.lookup("PerformanceService#{rand(0..9)}") } }
+        end
       end
     end
   end

data/spec/lib/protobuf/rpc/service_dispatcher_spec.rb

@@ -67,7 +67,7 @@ describe Protobuf::Rpc::ServiceDispatcher do
 
       context 'an object that responds to to_hash but is not a hash' do
         let(:hashable) do
-          mock('hashable', :to_hash => { :name => 'hashable' })
+          double('hashable', :to_hash => { :name => 'hashable' })
         end
         before { subject.callable_method.should_receive(:call) }
         before { subject.service.stub(:response).and_return(hashable) }
@@ -78,7 +78,7 @@ describe Protobuf::Rpc::ServiceDispatcher do
 
       context 'an object that responds to to_proto' do
         let(:protoable) do
-          mock('protoable', :to_proto => Test::Resource.new(:name => 'protoable'))
+          double('protoable', :to_proto => Test::Resource.new(:name => 'protoable'))
         end
         before { subject.callable_method.should_receive(:call) }
         before { subject.service.stub(:response).and_return(protoable) }

data/spec/lib/protobuf/rpc/stat_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'timecop'
+require 'active_support/core_ext/numeric/time'
+
+describe ::Protobuf::Rpc::Stat do
+
+  before(:all) do
+    unless defined?(BarService)
+      class BarService < ::Struct.new(:method_name); end
+    end
+  end
+
+  describe 'server mode' do
+    it 'describes a server response to a client' do
+      ::Timecop.freeze(10.minutes.ago) do
+        stats = ::Protobuf::Rpc::Stat.new(:SERVER)
+        stats.client = 'myserver1'
+        stats.dispatcher = double('dispatcher', :service => BarService.new(:find_bars))
+        stats.request_size = 43
+        stats.response_size = 1302
+
+        ::Timecop.freeze(1.62.seconds.from_now) do
+          stats.stop
+          stats.to_s.should eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/1302B - 1.62s - #{::Time.now.iso8601}"
+        end
+      end
+    end
+
+    context 'when request is still running' do
+      it 'omits response size, duration, and timestamp' do
+        stats = ::Protobuf::Rpc::Stat.new(:SERVER)
+        stats.client = 'myserver1'
+        stats.dispatcher = double('dispatcher', :service => BarService.new(:find_bars))
+        stats.request_size = 43
+        stats.to_s.should eq "[SRV] - myserver1 - #{stats.trace_id} - BarService#find_bars - 43B/-"
+      end
+    end
+  end
+
+  describe 'client mode' do
+    it 'describes a client request to a server' do
+      ::Timecop.freeze(10.minutes.ago) do
+        stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        stats.server = ['30000', 'myserver1.myhost.com']
+        stats.service = 'Foo::BarService'
+        stats.method_name = 'find_bars'
+        stats.request_size = 37
+        stats.response_size = 12345
+
+        ::Timecop.freeze(0.832.seconds.from_now) do
+          stats.stop
+          stats.to_s.should eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/12345B - 0.832s - #{::Time.now.iso8601}"
+        end
+
+      end
+    end
+
+    context 'when request is still running' do
+      it 'omits response size, duration, and timestamp' do
+        stats = ::Protobuf::Rpc::Stat.new(:CLIENT)
+        stats.server = ['30000', 'myserver1.myhost.com']
+        stats.service = 'Foo::BarService'
+        stats.method_name = 'find_bars'
+        stats.request_size = 37
+        stats.to_s.should eq "[CLT] - myserver1.myhost.com:30000 - #{stats.trace_id} - Foo::BarService#find_bars - 37B/-"
+      end
+    end
+  end
+
+end

data/spec/support/test/google_unittest.pb.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 ##
 # This file is auto-generated. DO NOT EDIT!
 #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protobuf
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.8.1
 platform: ruby
 authors:
 - BJ Neilsen
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -111,7 +111,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -125,7 +125,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -139,7 +139,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -153,7 +153,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -317,6 +317,7 @@ files:
 - spec/lib/protobuf/rpc/service_dispatcher_spec.rb
 - spec/lib/protobuf/rpc/service_filters_spec.rb
 - spec/lib/protobuf/rpc/service_spec.rb
+- spec/lib/protobuf/rpc/stat_spec.rb
 - spec/lib/protobuf_spec.rb
 - spec/spec_helper.rb
 - spec/support/all.rb
@@ -409,6 +410,7 @@ test_files:
 - spec/lib/protobuf/rpc/service_dispatcher_spec.rb
 - spec/lib/protobuf/rpc/service_filters_spec.rb
 - spec/lib/protobuf/rpc/service_spec.rb
+- spec/lib/protobuf/rpc/stat_spec.rb
 - spec/lib/protobuf_spec.rb
 - spec/spec_helper.rb
 - spec/support/all.rb