right_support 2.6.17 → 2.7.0

data/spec/spec_helper.rb

@@ -0,0 +1,181 @@
+# Copyright (c) 2012- RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'rubygems'
+require 'bundler/setup'
+require 'flexmock'
+require 'ruby-debug'
+require 'syntax'
+require 'right_develop'
+
+$:.unshift(File.expand_path('../../../lib', __FILE__)) #ensure we load THIS project's code, not an installed gem
+require 'right_support'
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end
+
+def read_fixture(fn)
+  basedir = File.expand_path('../..', __FILE__)
+  fixtures_dir = File.join(basedir, 'spec', 'fixtures')
+  File.read(File.join(fixtures_dir, fn))
+end
+
+def corrupt(key, factor=4)
+  d = key.size / 2
+
+  key[0..(d-factor)] + key[d+factor..-1]
+end
+
+RSpec::Matchers.define :have_green_endpoint do |endpoint|
+  match do |balancer|
+    stack = balancer.instance_variable_get(:@stack)
+    state = stack.instance_variable_get(:@endpoints)
+    state = state[endpoint] if state.respond_to?(:[])
+    unless stack && state && state.key?(:n_level)
+      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
+    end
+    state[:n_level] == 0
+  end
+end
+
+RSpec::Matchers.define :have_yellow_endpoint do |endpoint, n|
+  match do |balancer|
+    stack = balancer.instance_variable_get(:@stack)
+    max_n = stack.instance_variable_get(:@yellow_states)
+    state = stack.instance_variable_get(:@endpoints)
+    state = state[endpoint] if state.respond_to?(:[])
+    unless max_n && stack && state && state.key?(:n_level)
+      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
+    end
+
+    if n
+      state[:n_level].should == n
+    else
+      (1...max_n).should include(state[:n_level])
+    end
+  end
+end
+
+RSpec::Matchers.define :have_red_endpoint do |endpoint|
+  match do |balancer|
+    stack = balancer.instance_variable_get(:@stack)
+    max_n = stack.instance_variable_get(:@yellow_states)
+    state = stack.instance_variable_get(:@endpoints)
+    state = state[endpoint] if state.respond_to?(:[])
+    unless max_n && stack && state && state.key?(:n_level)
+      raise ArgumentError, "Custom matcher is incompatible with new HealthCheck implementation!"
+    end
+    min = 1
+    state[:n_level].should == max_n
+  end
+end
+
+def find_empirical_distribution(trials=2500, list=[1,2,3,4,5])
+  seen = {}
+
+  trials.times do
+    value = yield
+    seen[value] ||= 0
+    seen[value] += 1
+  end
+
+  seen
+end
+
+def test_random_distribution(trials=25000, list=[1,2,3,4,5], &block)
+  seen = find_empirical_distribution(trials, &block)
+  should_be_chosen_fairly(seen,trials,list.size)
+end
+
+def should_be_chosen_fairly(seen, trials, size)
+  #Load should be evenly distributed
+  chance = 1.0 / size
+  seen.each_pair do |_, count|
+    (Float(count) / Float(trials)).should be_within(0.025).of(chance) #allow 5% margin of error
+  end
+end
+
+RANDOM_KEY_CLASSES   = [String, Integer, Float, TrueClass, FalseClass]
+RANDOM_VALUE_CLASSES = RANDOM_KEY_CLASSES + [Array, Hash]
+
+def random_value(klass=nil, depth=0)
+  if klass.nil?
+    if depth < 5
+      klasses = RANDOM_VALUE_CLASSES
+    else
+      klasses = RANDOM_KEY_CLASSES
+    end
+
+    klass = klasses[rand(klasses.size)]
+  end
+
+  if klass == String
+    result = ''
+    io = StringIO.new(result, 'w')
+    rand(40).times { io.write(0x61 + rand(26)) }
+    io.close
+  elsif klass == Integer
+    result = rand(0xffffff)
+  elsif klass == Float
+    result = rand(0xffffff) * rand
+  elsif klass == TrueClass
+    result = true
+  elsif klass == FalseClass
+    result = false
+  elsif klass == Array
+    result = []
+    rand(10).times { result << random_value(nil, depth+1) }
+  elsif klass == Hash
+    result = {}
+    key_type = RANDOM_KEY_CLASSES[rand(RANDOM_KEY_CLASSES.size)]
+    rand(10).times { result[random_value(key_type, depth+1)] = random_value(nil, depth+1) }
+  else
+    raise ArgumentError, "Unknown random value type #{klass}"
+  end
+
+  result
+end
+
+def mock_logger
+  logger = flexmock(Logger.new(StringIO.new))
+end
+
+module SpecHelper
+  module SocketMocking
+    def mock_getaddrinfo(hostname, result, times=1)
+      boring_args = [nil, Socket::AF_INET, Socket::SOCK_STREAM, Socket::IPPROTO_TCP]
+
+      if result.is_a?(Class) && result.ancestors.include?(Exception)
+        e = result.new("Mock exception raised by getaddrinfo")
+        flexmock(Socket).should_receive(:getaddrinfo).with(hostname, *boring_args).times(times).ordered.and_raise(e)
+      else
+        infos = []
+
+        result.each do |addr|
+          infos << [0,0,0,addr]
+        end
+
+        flexmock(Socket).should_receive(:getaddrinfo).with(hostname, *boring_args).times(times).ordered.and_return(infos)
+      end
+    end
+  end
+end

data/spec/stats/activity_spec.rb

@@ -0,0 +1,193 @@
+#
+# Copyright (c) 2009-2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe RightSupport::Stats::Activity do
+
+  include FlexMock::ArgumentTypes
+
+  before(:all) do
+    @original_recent_size = RightSupport::Stats::Activity::RECENT_SIZE
+    RightSupport::Stats::Activity.instance_eval { remove_const(:RECENT_SIZE) }
+    RightSupport::Stats::Activity.const_set(:RECENT_SIZE, 10)
+  end
+
+  after(:all) do
+    RightSupport::Stats::Activity.instance_eval { remove_const(:RECENT_SIZE) }
+    RightSupport::Stats::Activity.const_set(:RECENT_SIZE, @original_recent_size)
+  end
+
+  before(:each) do
+    @now = 1000000
+    flexmock(Time).should_receive(:now).and_return(@now).by_default
+    @stats = RightSupport::Stats::Activity.new
+  end
+
+  it "initializes stats data" do
+    @stats.instance_variable_get(:@interval).should == 0.0
+    @stats.instance_variable_get(:@last_start_time).should == @now
+    @stats.instance_variable_get(:@avg_duration).should be_nil
+    @stats.instance_variable_get(:@total).should == 0
+    @stats.instance_variable_get(:@count_per_type).should == {}
+  end
+
+  it "updates count and interval information" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update
+    @stats.instance_variable_get(:@interval).should == 1.0
+    @stats.instance_variable_get(:@last_start_time).should == @now + 10
+    @stats.instance_variable_get(:@avg_duration).should be_nil
+    @stats.instance_variable_get(:@total).should == 1
+    @stats.instance_variable_get(:@count_per_type).should == {}
+  end
+
+  it "updates weight the average interval toward recent activity" do
+  end
+
+  it "updates counts per type when type provided" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update("test")
+    @stats.instance_variable_get(:@interval).should == 1.0
+    @stats.instance_variable_get(:@last_start_time).should == @now + 10
+    @stats.instance_variable_get(:@avg_duration).should be_nil
+    @stats.instance_variable_get(:@total).should == 1
+    @stats.instance_variable_get(:@count_per_type).should == {"test" => 1}
+  end
+
+  it "doesn't update counts when type contains 'stats'" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update("my stats")
+    @stats.instance_variable_get(:@interval).should == 0.0
+    @stats.instance_variable_get(:@last_start_time).should == @now
+    @stats.instance_variable_get(:@avg_duration).should be_nil
+    @stats.instance_variable_get(:@total).should == 0
+    @stats.instance_variable_get(:@count_per_type).should == {}
+  end
+
+  it "limits length of type string when submitting update" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update("test 12345678901234567890123456789012345678901234567890123456789")
+    @stats.instance_variable_get(:@total).should == 1
+    @stats.instance_variable_get(:@count_per_type).should ==
+            {"test 1234567890123456789012345678901234567890123456789012..." => 1}
+  end
+
+  it "doesn't convert symbol or boolean to string when submitting update" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update(:test)
+    @stats.update(true)
+    @stats.update(false)
+    @stats.instance_variable_get(:@total).should == 3
+    @stats.instance_variable_get(:@count_per_type).should == {:test => 1, true => 1, false => 1}
+  end
+
+  it "converts arbitrary type value to limited-length string when submitting update" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update({1 => 11, 2 => 22})
+    @stats.update({1 => 11, 2 => 22, 3 => 12345678901234567890123456789012345678901234567890123456789})
+    @stats.instance_variable_get(:@total).should == 2
+    @stats.instance_variable_get(:@count_per_type).should == {"{1=>11, 2=>22}" => 1,
+                                                              "{1=>11, 2=>22, 3=>123456789012345678901234567890123456789..." => 1}
+  end
+
+  it "doesn't measure rate if disabled" do
+    @stats = RightSupport::Stats::Activity.new(false)
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update
+    @stats.instance_variable_get(:@interval).should == 0.0
+    @stats.instance_variable_get(:@last_start_time).should == @now + 10
+    @stats.instance_variable_get(:@avg_duration).should be_nil
+    @stats.instance_variable_get(:@total).should == 1
+    @stats.instance_variable_get(:@count_per_type).should == {}
+    @stats.all.should == {"last" => {"elapsed"=>0}, "total" => 1}
+  end
+
+  it "updates duration when finish using internal start time by default" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.finish
+    @stats.instance_variable_get(:@interval).should == 0.0
+    @stats.instance_variable_get(:@last_start_time).should == @now
+    @stats.instance_variable_get(:@avg_duration).should == 1.0
+    @stats.instance_variable_get(:@total).should == 0
+    @stats.instance_variable_get(:@count_per_type).should == {}
+  end
+
+  it "updates duration when finish using specified start time" do
+    flexmock(Time).should_receive(:now).and_return(1000030)
+    @stats.avg_duration.should be_nil
+    @stats.finish(1000010)
+    @stats.instance_variable_get(:@interval).should == 0.0
+    @stats.instance_variable_get(:@last_start_time).should == @now
+    @stats.instance_variable_get(:@avg_duration).should == 2.0
+    @stats.instance_variable_get(:@total).should == 0
+    @stats.instance_variable_get(:@count_per_type).should == {}
+  end
+
+  it "converts interval to rate" do
+    flexmock(Time).should_receive(:now).and_return(1000020)
+    @stats.avg_rate.should be_nil
+    @stats.update
+    @stats.instance_variable_get(:@interval).should == 2.0
+    @stats.avg_rate.should == 0.5
+  end
+
+  it "reports number of seconds since last update or nil if no updates" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.last.should be_nil
+    @stats.update
+    @stats.last.should == {"elapsed" => 0}
+  end
+
+  it "reports number of seconds since last update and last type" do
+    @stats.update("test")
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.last.should == {"elapsed" => 10, "type" => "test"}
+  end
+
+  it "reports whether last activity is still active" do
+    @stats.update("test", "token")
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => true}
+    @stats.finish(@now - 10, "token")
+    @stats.last.should == {"elapsed" => 10, "type" => "test", "active" => false}
+    @stats.instance_variable_get(:@avg_duration).should == 2.0
+  end
+
+  it "converts count per type to percentages" do
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    @stats.update("foo")
+    @stats.instance_variable_get(:@total).should == 1
+    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1}
+    @stats.percentage.should == {"total" => 1, "percent" => {"foo" => 100.0}}
+    @stats.update("bar")
+    @stats.instance_variable_get(:@total).should == 2
+    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 1, "bar" => 1}
+    @stats.percentage.should == {"total" => 2, "percent" => {"foo" => 50.0, "bar" => 50.0}}
+    @stats.update("foo")
+    @stats.update("foo")
+    @stats.instance_variable_get(:@total).should == 4
+    @stats.instance_variable_get(:@count_per_type).should == {"foo" => 3, "bar" => 1}
+    @stats.percentage.should == {"total" => 4, "percent" => {"foo" => 75.0, "bar" => 25.0}}
+  end
+
+end # RightSupport::Stats::Activity

data/spec/stats/exceptions_spec.rb

@@ -0,0 +1,123 @@
+#
+# Copyright (c) 2009-2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe RightSupport::Stats::Exceptions do
+
+  include FlexMock::ArgumentTypes
+
+  before(:each) do
+    @now = 1000000
+    flexmock(Time).should_receive(:now).and_return(@now).by_default
+    @stats = RightSupport::Stats::Exceptions.new
+    @exception = Exception.new("Test error")
+  end
+
+  it "initializes stats data" do
+    @stats.stats.should be_nil
+    @stats.instance_variable_get(:@callback).should be_nil
+  end
+
+  it "tracks submitted exception information by category" do
+    @stats.track("testing", @exception)
+    @stats.stats.should == {"testing" => {"total" => 1,
+                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                        "when" => @now, "where" => nil}]}}
+  end
+
+  it "recognizes and counts repeated exceptions" do
+    @stats.track("testing", @exception)
+    @stats.stats.should == {"testing" => {"total" => 1,
+                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                        "when" => @now, "where" => nil}]}}
+    flexmock(Time).should_receive(:now).and_return(1000010)
+    category = "another"
+    backtrace = ["here", "and", "there"]
+    4.times do |i|
+      begin
+        raise ArgumentError, "badarg"
+      rescue Exception => e
+        flexmock(e).should_receive(:backtrace).and_return(backtrace)
+        @stats.track(category, e)
+        backtrace.shift(2) if i == 1
+        category = "testing" if i == 2
+      end
+    end
+    @stats.stats.should == {"testing" => {"total" => 2,
+                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                        "when" => @now, "where" => nil},
+                                                       {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                                        "when" => @now + 10, "where" => "there"}]},
+                            "another" => {"total" => 3,
+                                          "recent" => [{"count" => 2, "type" => "ArgumentError", "message" => "badarg",
+                                                        "when" => @now + 10, "where" => "here"},
+                                                       {"count" => 1, "type" => "ArgumentError", "message" => "badarg",
+                                                        "when" => @now + 10, "where" => "there"}]}}
+  end
+
+  it "limits the number of exceptions stored by eliminating older exceptions" do
+    (RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1).times do |i|
+      begin
+        raise ArgumentError, "badarg"
+      rescue Exception => e
+        flexmock(e).should_receive(:backtrace).and_return([i.to_s])
+        @stats.track("testing", e)
+      end
+    end
+    stats = @stats.stats
+    stats["testing"]["total"].should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS + 1
+    stats["testing"]["recent"].size.should == RightSupport::Stats::Exceptions::MAX_RECENT_EXCEPTIONS
+    stats["testing"]["recent"][0]["where"].should == "1"
+  end
+
+  it "makes callback if callback and message defined" do
+    called = 0
+    callback = lambda do |exception, message, server|
+      called += 1
+      exception.should == @exception
+      message.should == "message"
+      server.should == "server"
+    end
+    @stats = RightSupport::Stats::Exceptions.new("server", callback)
+    @stats.track("testing", @exception, "message")
+    @stats.stats.should == {"testing" => {"total" => 1,
+                                          "recent" => [{"count" => 1, "type" => "Exception", "message" => "Test error",
+                                                        "when" => @now, "where" => nil}]}}
+    called.should == 1
+  end
+
+  it "catches any exceptions raised internally and log them" do
+    begin
+      logger = flexmock("logger")
+      logger.should_receive(:error).with(/Failed to track exception 'Test error' \(Exception: bad IN/).once
+      RightSupport::Log::Mixin.default_logger = logger
+      flexmock(@exception).should_receive(:backtrace).and_raise(Exception.new("bad"))
+      @stats = RightSupport::Stats::Exceptions.new
+      @stats.track("testing", @exception, "message")
+      @stats.stats["testing"]["total"].should == 1
+    ensure
+      RightSupport::Log::Mixin.default_logger = nil
+    end
+  end
+
+end # RightSupport::Stats::Exceptions