rereplay 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+.bundle
+*.gem
+*.rbc

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem "eventmachine", "~>0.12.10"
+gem "em-http-request", "~>0.2.14"
+
+group :test do
+	gem "rspec", "~>2.0"
+	gem "webmock", "~>1.4.0"
+	gem "activesupport", "~>3.0.1"
+#	gem "autotest"
+#	gem "test_notifier"
+end
+

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.1)
+    addressable (2.2.2)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    em-http-request (0.2.14)
+      addressable (>= 2.0.0)
+      eventmachine (>= 0.12.9)
+    eventmachine (0.12.10)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    webmock (1.4.0)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.0.1)
+  em-http-request (~> 0.2.14)
+  eventmachine (~> 0.12.10)
+  rspec (~> 2.0)
+  webmock (~> 1.4.0)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Max Aller <nanodeath@gmail.com>
+
+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.

data/README.md

@@ -0,0 +1,40 @@
+# ReReplay
+
+ReReplay is for replaying production traffic (or any scripted traffic pattern, for that matter).  You simply input a list of URLs that you want ReReplay to hit, and their associated times to make the request, and run it.
+
+There are a couple other main features as well.  You can provide Request Monitors to ReReplay -- these are executed before and/or after every request.  There are also Periodic Monitors, which execute on regular intervals (for monitoring memory usage, or something).  Lastly, you can provide a rampup strategy as well.  For example, you could start out making requests at the "regular" rate, and by the end of the run be making requests at double the rate presribed in the original input.
+
+# Examples
+
+(It's assumed you've already require'd "rereplay")
+
+## Simple
+    input = [
+    	[0, 	:get, "http://www.google.com/"],
+    	[0.5, :get, "http://www.microsoft.com/"],
+    	[0.9, :get, "http://www.amazon.com/"]
+    ]
+    r = ReReplay.new(input)
+    r.run
+    # and done!    
+
+Of course, this doesn't actually track any output, so...let's monitor the request time using the request_time_monitor:
+
+## Request Monitor
+    require "rereplay/monitors/request_time_monitor"
+    input = [same as in Simple]
+    mon = RequestTimeMonitor.new
+    r = ReReplay.new(input)
+    r.request_monitors << mon
+    r.run
+    puts mon.results.inspect
+
+This will print out the results from the RequestTimeMonitor instance, which includes the url, the duration of the request, and its scheduled start time.
+
+## Specs
+
+Specs have more examples and probably more up-to-date, too.  They're fairly simple -- start with basic.rb.
+
+# License
+
+Licensed under the permissive MIT license, provided in the LICENSE file.

data/design

@@ -0,0 +1,22 @@
+First, we have to acquire our initial input.  Anything that implements #readlines (and returns an array of strings) can be used.  Note, this should be provided by Rereplay -- can either be a stream via ARGF or a filename.
+
+Next we need a processor to turn our input into an array of arrays: each array element must match this pattern: [seconds offset (float), method (lowercase symbol), url (string), [optional: headers (hash)], (optional: post data, string)]
+
+Next, we can filter this input with 1..n filters.  Each filter must have a #filter method that takes an array and return a new array, which will be used instead; nil, if the string is to be removed; or true if the original input should be used.
+
+After all of the filters have run, we will have our input.  At this point, a profile is consumed that determines some runtime behavior.  Keys include:
+ - time_for_setup: integer (seconds) (default 5s)
+ - timer_granularity: integer (milliseconds) (default 50ms)
+ - run_for: integer (minutes) (default 5m)
+ - when_input_consumed: enum (one of: loop, stop:default)
+ - monitors_enabled: array (list of monitor classes) default:[]
+ 
+RequestMonitors are ruby classes that implement this interface:
+ - [#start(request:{url, scheduled_start, actual_start, index})=>nil] optional
+ - [#finish(request:{url, scheduled_start, actual_start, finish, index})=>nil] optional
+ - [#results=>whatever] optional
+ 
+Periodic Monitors are also special ruby classes that provide some additional statistics that can be used.  They must implement this interface:
+ - #tick(time:float)=>nil, returns nothing (executed every fixed interval).  time is seconds since start.
+ - [#results()=>[[]], returns an array of arrays, where the first element is a time and the second is a string.] optional
+ - [#interval()=>time:integer], optional, returns the interval at which this monitor should be run, in seconds, default 5

data/lib/rereplay/monitors/delay_monitor.rb

@@ -0,0 +1,13 @@
+# Simple request monitor that tracks the delays of requests
+module ReReplay
+	class DelayMonitor
+		attr_reader :results
+		def initialize
+			@results = []
+		end
+	
+		def start(request)
+			@results[request.index] = [request.url, request.actual_start - request.scheduled_start]
+		end
+	end
+end

data/lib/rereplay/monitors/memory_monitor.rb

@@ -0,0 +1,16 @@
+# Simple periodic monitor that tracks ongoing memory usage
+module ReReplay
+	class MemoryMonitor
+		attr_reader :results
+		attr_accessor :interval
+	
+		def initialize
+			@results = []
+		end
+		def tick(time)
+			# http://laurelfan.com/2008/1/15/ruby-memory-usage
+			memory_usage = `ps -o rss= -p #{Process.pid}`.to_i
+			@results << [time, memory_usage]
+		end
+	end
+end

data/lib/rereplay/monitors/request_time_monitor.rb

@@ -0,0 +1,13 @@
+# Simple request monitor that tracks how long requests take
+module ReReplay
+	class RequestTimeMonitor
+		attr_reader :results
+		def initialize
+			@results = []
+		end
+	
+		def finish(request)
+			@results[request.index] = [request.url, request.finish - request.actual_start, request.scheduled_start, request.actual_start]
+		end
+	end
+end

data/lib/rereplay/monitors/timeout_failer.rb

@@ -0,0 +1,17 @@
+module ReReplay
+	class TimeoutFailer
+		def initialize(max_timeouts=1)
+			@max_timeouts = max_timeouts
+			@timeouts = 0
+		end
+	
+		def finish(request)
+			if(request.status == :timeout)
+				@timeouts += 1
+			end
+			if(@timeouts >= @max_timeouts)
+				raise "TimeoutFailer triggered because timeout limit #{@max_timeouts} was reached"
+			end
+		end
+	end
+end

data/lib/rereplay/monitors/verbose_monitor.rb

@@ -0,0 +1,12 @@
+# Prints out start and stop times of requests
+module ReReplay
+	class VerboseMonitor
+		def start(request)
+			puts "started request #{request.index}:(#{request.url}) at #{request.actual_start}"
+		end
+	
+		def finish(request)
+			puts " - finished request #{request.index}, status #{request.status}"
+		end
+	end
+end

data/lib/rereplay/monitors.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), "monitors/*.rb")].each do |monitor|
+	require monitor
+end

data/lib/rereplay/runner.rb

@@ -0,0 +1,200 @@
+module ReReplay
+	class Runner
+		attr_accessor :periodic_monitors
+		attr_accessor :request_monitors
+
+		def initialize(input=nil)
+			if(!input.nil?)
+				self.input = input
+			end
+			@periodic_monitors = []
+			@request_monitors = []
+		end
+
+		def input=(input)
+			if(input.is_a? Array)
+				@input = input
+			elsif(input.respond_to? :readlines)
+				@input = input.readlines
+			elsif(input.respond_to? :split)
+				@input = input.split("\n").map do |i| 
+					i = i.strip.split(",").map {|j| j.strip}
+					i[0] = i[0].to_f
+					i[1] = i[1].to_sym
+					i
+				end
+			else
+				raise "Invalid input, expected Array, #readlines, or #split"
+			end
+		end
+	
+		def validate_input
+			if(@input.nil? || @input.empty?)
+				raise ArgumentError, "Nothing to process (input was empty)"
+			end
+			valid_methods = [:get, :head]
+			@input.each_with_index do |a, i|
+				if(!a[0].is_a? Numeric)
+					raise ArgumentError, "Expected element at index 0 of input #{i+1} to be Numeric; was #{a[0]}"
+				end
+				if(!a[1].is_a?(Symbol) || !valid_methods.include?(a[1]))
+					raise ArgumentError, "Expected element at index 1 of input #{i+1} to be a symbol in #{valid_methods.inspect}; was #{a[1].inspect}"
+				end
+				if(!a[2].is_a? String)
+					raise ArgumentError, "Expected element at index 2 of input #{i+1} to be a String; was #{a[2]}"
+				end
+				if(!a[3].nil? && !a[3].is_a?(Hash))
+					raise ArgumentError, "Expected element at index 3 of input #{i+1} to be nil or a Hash; was #{a[3]}"
+				end
+				# TODO post data
+			end
+		end
+	
+		def run
+			validate_input
+			p = profile
+			done_count = 0
+			# request monitors with a start method
+			request_monitors_start = request_monitors.select {|mon| mon.respond_to? :start}
+			# request monitors with a finish method
+			request_monitors_finish = request_monitors.select {|mon| mon.respond_to? :finish}
+			EM::run do
+				EM.set_quantum(p[:timer_granularity])
+				start = Time.now
+				setup_time = p[:time_for_setup]
+				actual_start = start + setup_time
+			
+				loop_count = 1
+			
+				max_time = @input.max {|a,b| a[0] <=> b[0]}[0]
+				#avg_time = @input.inject(0){|memo, i| i[0] + memo}.to_f / @input.length
+				if(p[:when_input_consumed] == :loop)
+					if(max_time < p[:run_for])
+						loop_count = (p[:run_for].to_f / max_time).ceil
+					end
+				end
+			
+				if(loop_count > 1)
+					# If we need to have multiple iterations of the data,
+					# we pad that on here
+					new_inputs = []
+					2.upto(loop_count) do |loop|
+						new_input = @input.map do |i|
+							new_i = i.dup
+							new_i[0] += max_time * (loop - 1)
+							new_i
+						end
+						new_inputs << new_input
+					end
+					new_inputs.each {|input| @input += input}
+				end
+				real_max_time = [max_time * loop_count, p[:run_for]].min
+				if(p[:rampup][0] != p[:rampup][1] || p[:rampup][0] != 1.0)
+					case p[:rampup_method]
+					when :linear
+						sr = 1.0 / p[:rampup][0]
+						fr = 1.0 / p[:rampup][1]
+						prev_time = 0
+						new_prev_time = 0
+						@input.map! do |a|
+							time = a[0].to_f
+							percent = time / real_max_time
+							fraction = sr + (fr - sr)*(time / real_max_time)
+							tmp = a[0]
+							a[0] = (time - prev_time)*fraction + new_prev_time
+							prev_time = tmp
+							new_prev_time = a[0]
+							a
+						end
+					end
+				end
+				total_urls = @input.length
+				
+				requests = []
+				# pregenerate requests
+				@input.each do |a|
+					requests << EventMachine::HttpRequest.new(a[2])
+				end
+
+				@input.each_with_index do |a, i|
+					scheduled_start = a[0]
+					request = OpenStruct.new(:url => a[2], :scheduled_start => scheduled_start, :index => i, :http_method => a[1])
+					delay = actual_start + scheduled_start
+					if(delay < Time.now)
+						raise "Not enough time allotted for setup!  Try increasing time_for_setup in your profile."
+					end
+					delay -= Time.now
+					EM::add_timer(delay) do
+						EM.defer do
+							begin
+								request.actual_start = Time.now - actual_start
+								http = requests[i].send(request.http_method, :timeout => p[:timeout])
+								request_monitors_start.each {|mon| mon.start(request)}
+							rescue => e
+								EM.next_tick do
+									raise e
+								end
+							end
+							callback = lambda {
+								time_finished = Time.now - actual_start
+								request.finish = time_finished
+								request.status = http.response_header.status
+								if(request.status == 0)
+									request.status = :timeout
+								end
+								begin
+									request_monitors_finish.each {|mon|	mon.finish(request)}
+								rescue => e
+									EM.next_tick do
+										raise e
+									end
+								end
+								done_count += 1
+								if(done_count == total_urls && p[:when_input_consumed] == :stop)
+									EM.stop
+								end
+							}
+							http.errback { callback.call }
+							http.callback { callback.call }
+						end
+					end
+				end
+				periodic_monitors.each do |mon|
+					interval = mon.respond_to?(:interval) ? mon.interval : 5
+					EM::add_timer(actual_start - Time.now - interval) do
+						EM::add_periodic_timer(interval) do
+							mon.tick(Time.now - actual_start)
+						end
+					end
+				end
+				run_for = actual_start + p[:run_for] - Time.now
+				EM::add_timer(run_for) do
+					#puts "run_for hit (#{run_for})"
+					EM.stop
+				end
+			end
+		end
+
+		def profile=(new_profile)
+			@profile = {
+				:time_for_setup => 1,
+				:timer_granularity => 50,
+				:run_for => 5,
+				:when_input_consumed => :stop,
+				:timeout => 1,
+				:rampup => [1.0, 1.0],
+				:rampup_method => :linear
+			}
+			if(new_profile.is_a? Hash)
+				@profile.merge!(new_profile)
+			end
+			# TODO validate profile
+		end
+		def profile
+			if(@profile.nil?)
+				self.profile = {}
+			end
+			@profile
+		end
+	end
+end

data/lib/rereplay/version.rb

@@ -0,0 +1,3 @@
+module ReReplay
+	VERSION = "0.1"
+end

data/lib/rereplay.rb

@@ -0,0 +1,5 @@
+require 'ostruct'
+require 'eventmachine'
+require 'em-http'
+
+require 'rereplay/runner'

data/rereplay.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rereplay/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rereplay"
+  s.version     = ReReplay::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Max Aller"]
+  s.email       = ["nanodeath@gmail.com"]
+  s.homepage    = "http://github.com/nanodeath/ReReplay"
+  s.summary     = %q{Replay your prod traffic}
+  s.description = %q{Replay or script traffic in order to track performance of your site over time.}
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_runtime_dependency "eventmachine", ">= 0.12.10", "< 0.13"
+  s.add_runtime_dependency "em-http-request", ">= 0.2.14", "< 0.3"
+	
+  s.add_development_dependency "rspec", ">= 2.0", "< 3"
+  s.add_development_dependency "webmock", ">= 1.4.0", "< 1.5"
+  s.add_development_dependency "active_support", ">= 3.0.1", "< 3.1"
+
+  s.files              = `git ls-files`.split("\n")
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths      = ["lib"]
+end

data/spec/advanced.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+
+describe ReReplay, "advanced functions" do
+	it "should support linear rampup" do
+		input = generate_input(10, :start_at_0 => true)
+		
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:rampup => [1.0, 2.0]
+		}
+		r.profile = profile
+		lambda { r.run }.should take_between(1.65.seconds).and(1.8.seconds)
+		validate_input(10)
+	end
+	
+	it "should support linear rampup from <1 to >1" do
+		input = generate_input(10, :start_at_0 => true)
+		
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:rampup => [0.5, 2]
+		}
+		r.profile = profile
+		lambda { r.run }.should take_between(2.05.seconds).and(2.2.seconds)
+		validate_input(10)
+	end
+	
+	it "should play nicely with run_for and :loop" do
+		input = generate_input(10, :start_at_0 => true)
+		
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:rampup => [0.5, 2],
+			:run_for => 2,
+			:when_input_consumed => :loop
+		}
+		r.profile = profile
+		lambda { r.run }.should take_between(3.seconds).and(3.1.seconds)
+		validate_input(10, 2)
+	end
+end
+

data/spec/basic.rb

@@ -0,0 +1,38 @@
+require 'spec/spec_helper'
+
+describe ReReplay, "basic functions" do
+	it "should process input from array" do
+		urls = ["google", "microsoft", "amazon"].map {|u| "http://#{u}.com/"}
+		
+		urls.each {|url| stub_request(:get, url)}
+		
+		interval = 0.0
+		input = urls.map {|i| [interval += 0.1, :get, i]}
+		
+		r = ReReplay::Runner.new(input)
+		lambda { r.run }.should take_between(1.second).and(2.seconds)
+		
+		urls.each {|url| WebMock.should have_requested(:get, url)}
+	end
+	
+	it "should process input from string" do
+		input = <<EOF
+		0.1, get, http://www.google.com/
+		0.6, get, http://www.amazon.com/
+EOF
+		
+		stub_request(:get, "http://www.google.com/")
+		stub_request(:get, "http://www.amazon.com/")
+		
+		r = ReReplay::Runner.new(input)
+		lambda { r.run }.should take_between(1.second).and(2.seconds)
+		
+		WebMock.should have_requested(:get, "http://www.google.com/")
+		WebMock.should have_requested(:get, "http://www.amazon.com/")
+	end
+	
+	it "should throw exception on empty input" do
+		r = ReReplay::Runner.new
+		lambda { r.run }.should raise_error(ArgumentError, /input was empty/)
+	end
+end

data/spec/monitor.rb

@@ -0,0 +1,56 @@
+require 'spec/spec_helper'
+
+describe ReReplay, "periodic monitors" do
+	it "should work" do
+		mem_monitor = ReReplay::MemoryMonitor.new
+		mem_monitor.interval = 0.2
+		
+		input = generate_input(3, :interval => 0.25)
+		r = ReReplay::Runner.new(input)
+		r.periodic_monitors << mem_monitor
+		
+		# the periodic monitor will start around `time_for_setup` (1 second)
+		# and run once every ~0.23s thereafter.
+		# Because the final request will finish around 1.75, this run four times
+		r.run
+		validate_input(3)
+		mem_monitor.results.length.should == 4
+	end
+end
+
+describe ReReplay, "request monitors" do
+	it "should work" do
+		req_mon = ReReplay::RequestTimeMonitor.new
+		delay_mon = ReReplay::DelayMonitor.new
+		
+		input = generate_input(3, :interval => 0.25)
+		r = ReReplay::Runner.new(input)
+		r.request_monitors << req_mon << delay_mon
+		# the periodic monitor will start around `time_for_setup` (1 second)
+		# and run once every ~0.23s thereafter.
+		# Because the final request will finish around 1.75, this run four times
+		r.run
+		validate_input(3)
+		req_mon.results.length.should == 3
+		delay_mon.results.length.should == 3
+	end
+	
+	describe ReReplay::VerboseMonitor do
+		it "should be verbose" do
+			input = generate_input(3, :interval => 0.25)
+			r = ReReplay::Runner.new(input)
+			r.request_monitors << ReReplay::VerboseMonitor.new
+			expected = Regexp.new(<<EOF, Regexp::MULTILINE)
+started request 0:\\(http://google.com/\\) at [\\d\\.]+
+ - finished request 0, status 200
+started request 1:\\(http://microsoft.com/\\) at [\\d\\.]+
+ - finished request 1, status 200
+started request 2:\\(http://amazon.com/\\) at [\\d\\.]+
+ - finished request 2, status 200
+EOF
+			capture_stdout { r.run }.should match(expected)
+			validate_input(3)
+		end
+	end
+end
+

data/spec/profile.rb

@@ -0,0 +1,90 @@
+require 'spec/spec_helper'
+
+describe ReReplay, "profile options" do
+	it "respects 'time_for_setup' parameter" do
+		input = generate_input(2)
+		
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:time_for_setup => 0.25
+		}
+		r.profile = profile
+		lambda { r.run }.should take_between(0.45.seconds).and(0.6.seconds)
+		validate_input(2)
+	end
+	it "respects 'timer_granularity' parameter" do
+		input = generate_input(2)
+		
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:timer_granularity => 1000
+		}
+		r.profile = profile
+		
+		# normally this would finish at around 1.2 seconds, but with such a high
+		# timer resolution, it rounds up from 0.1 to 1
+		lambda { r.run }.should take_between(2.seconds).and(3.seconds)
+		validate_input(2)
+	end
+	it "respects 'run_for' parameter" do
+		input = generate_input(3, :interval => 1)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 1
+		}
+		r.profile = profile
+		
+		# normally this would run for the full 4 seconds, but with run_for fixed at 2,
+		# it will stop then
+		lambda { r.run }.should take_between(2.seconds).and(2.1.seconds)
+		validate_input(1)
+	end
+	
+	it "respects 'when_input_consumed' parameter when :stop" do
+		input = generate_input(3, :interval => 0.5)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 10,
+			:when_input_consumed => :stop
+		}
+		r.profile = profile
+		
+		lambda { r.run }.should take_between(2.5.seconds).and(2.7.seconds)
+		validate_input(3)
+	end
+	
+	it "respects 'when_input_consumed' parameter when :loop" do
+		input = generate_input(1, :interval => 0.5)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:run_for => 1.1,
+			:when_input_consumed => :loop
+		}
+		r.profile = profile
+		req_mon = ReReplay::RequestTimeMonitor.new
+		r.request_monitors << req_mon
+		
+		# normally this would take 1.5 seconds with :stop, but we're forcing it to loop and take 2 seconds
+		lambda { r.run }.should take_between(2.seconds).and(2.2.seconds)
+		req_mon.results.length.should == 2
+		validate_input(1, 2)
+	end
+	
+	# eh, this isn't that good a test because WebMock causes #to_timeout requests to timeout immediately
+	it "respects 'timeout' parameter" do
+		input = generate_input(1, :interval => 0.25, :timeout => true)
+		r = ReReplay::Runner.new(input)
+		profile = {
+			:timeout => 10,
+			:time_for_setup => 0.25
+		}
+		r.profile = profile
+		r.request_monitors << ReReplay::TimeoutFailer.new
+		
+		# normally this would take 4 seconds with :stop, but after 2 seconds we hit the timeout
+		
+		lambda { lambda { r.run }.should raise_error(StandardError, /TimeoutFailer/) }.should take_between(0.5.seconds).and(0.7.seconds)
+		validate_input(1)
+	end
+
+end

data/spec/spec_custom_matchers.rb

@@ -0,0 +1,35 @@
+# Custom matchers
+module CustomMatchers
+	class TimeTaken
+		def initialize(lower_seconds, upper_seconds=nil)
+			@lower_seconds = lower_seconds
+			@upper_seconds = upper_seconds
+		end
+	
+		def matches?(given_proc)
+			range = @lower_seconds..@upper_seconds
+			start = Time.now
+			given_proc.call
+			fin = Time.now
+			@diff = fin - start
+			range.include?(@diff)
+		end
+
+		def and(upper_seconds)
+			@upper_seconds = upper_seconds
+			self
+		end
+	
+		def failure_message_for_should
+			"expected block to take between #{@lower_seconds} and #{@upper_seconds} seconds, but took #{@diff} seconds"
+		end
+	
+		def failure_message_for_should_not
+			"expected block not to take between #{@lower_seconds} and #{@upper_seconds} seconds, but took #{@diff} seconds"
+		end	
+	end
+
+	def take_between(lower_seconds, upper_seconds=nil)
+		TimeTaken.new(lower_seconds, upper_seconds)
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+require "rereplay"
+require "rereplay/monitors/memory_monitor"
+require "rereplay/monitors/request_time_monitor"
+require "rereplay/monitors/delay_monitor"
+require "rereplay/monitors/verbose_monitor"
+require "rereplay/monitors/timeout_failer"
+
+require "rspec"
+require "webmock/rspec"
+require 'active_support/time'
+require 'spec_custom_matchers'
+
+RSpec.configure do |config|
+	config.include WebMock::API
+	config.include CustomMatchers
+end
+
+def generate_input(length, opts={})
+	interval = opts[:start] || 0.0
+	interval_increment = opts[:interval] || 0.1
+	urls = ["google", "microsoft", "amazon", "mint", "yahoo", "windowshop", "xbox", "samsung", "qwest", "comcast"][0...length].map {|u| "http://#{u}.com/"}
+	if(opts[:timeout])
+		urls.each {|url| stub_request(:get, url).to_timeout}
+	else
+		urls.each {|url| stub_request(:get, url)}
+	end
+	if(opts[:start_at_0])
+		interval -= interval_increment
+	end
+	input = urls.map {|i| [interval += interval_increment, :get, i]}
+	input
+end
+
+def validate_input(length, count=1)
+	urls = ["google", "microsoft", "amazon"][0...length].map {|u| "http://#{u}.com/"}
+	urls.each {|u| WebMock.should have_requested(:get, u).times(count)}
+end
+
+def capture_stdout
+	s = StringIO.new
+	$stdout = s
+	yield
+	s.string
+ensure
+	$stdout = STDOUT
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification 
+name: rereplay
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Max Aller
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 13
+        version: "0.13"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 2
+        - 14
+        version: 0.2.14
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 3
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        version: "3"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        - 0
+        version: 1.4.0
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: active_support
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 1
+        version: "3.1"
+  type: :development
+  version_requirements: *id005
+description: Replay or script traffic in order to track performance of your site over time.
+email: 
+- nanodeath@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- design
+- lib/rereplay.rb
+- lib/rereplay/monitors.rb
+- lib/rereplay/monitors/delay_monitor.rb
+- lib/rereplay/monitors/memory_monitor.rb
+- lib/rereplay/monitors/request_time_monitor.rb
+- lib/rereplay/monitors/timeout_failer.rb
+- lib/rereplay/monitors/verbose_monitor.rb
+- lib/rereplay/runner.rb
+- lib/rereplay/version.rb
+- rereplay.gemspec
+- spec/advanced.rb
+- spec/basic.rb
+- spec/monitor.rb
+- spec/profile.rb
+- spec/spec_custom_matchers.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/nanodeath/ReReplay
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Replay your prod traffic
+test_files: []
+