roundtrip 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in roundtrip.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dotan Nahum
+
+MIT License
+
+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,115 @@
+# Roundtrip
+
+Roundtrip is a business process tracking and measurement service
+especially useful for tracking distributed systems and services.
+
+
+For a simple and useful explanation, check out [this blog
+post](http://blog.paracode.com/2012/12/02/tracking-your-business/)
+before you start.
+
+
+<img src="https://github.com/jondot/roundtrip/raw/master/examples/roundtrip-schema.png" />
+
+With it, you can answer these questions, in real-time:
+
+* How is each part of my processing pipeline performing? How is the
+entire pipeline performing?
+* What out of my running transactions didn't end? isn't ending within X
+amount of time?
+
+
+## Installation
+
+You have a couple of options of running Roundtrip.
+
+### Clone and run
+
+Roundtrip currently supports HTTP as its RPC mechanism. This means you
+can host it using your favorite battle-tested Ruby stack -- anything that can
+run a Rack application.
+
+    $ git clone git://github.com/jondot/roundtrip.git
+    $ cd roundtrip
+    $ bundle
+
+Now feel free to edit `config.ru` for Redis and Statsd configuration.
+
+    $ bundle exec rackup
+
+### Install gem
+
+You can install the `roundtrip` gem, and then use the web interface
+within your existing Rack applications (for example, in Rails, you can
+mount it).
+
+    $ gem install roundtrip
+
+```ruby
+require 'roundtrip'
+# set up the default Redis and Statsd components
+Roundtrip.options[:redis] = { :host  => 'localhost' }
+Roundtrip.options[:statsd] = { :host => 'localhost', :port => 8125 }
+
+require 'roundtrip/web'
+# now mount/run Roundtrip::Web
+```
+
+
+
+## API Usage
+
+I'll use `curl` just for illustration purposes. You should use what ever
+HTTP library you feel comfertable with, within your code.
+
+For usage examples on various platforms check out `/examples`.
+
+
+Supply your own ID
+
+```
+curl -XPOST -d id=id-xyz&route=invoicing http://localhost:9292/trips
+{"id":"id-xyz","route":"invoicing","started_at":"2012-11-30T18:23:23.814014+02:00"}
+```
+
+Or let roundtrip generate one for you
+
+```
+curl -XPOST -d route=invoicing http://localhost:9292/trips
+{"id":"cf1999e8bfbd37963b1f92c527a8748e","route":"invoicing","started_at":"2012-11-30T18:23:23.814014+02:00"}
+```
+
+
+Using the generated ID, lets add checkpoints:
+
+```
+curl -XPATCH -dcheckpoint=generated.pdf http://localhost:9292/trips/cf1999e8bfbd37963b1f92c527a8748e
+{"ok":true}
+```
+
+```
+curl -XPATCH -dcheckpoint=emailed.customer http://localhost:9292/trips/cf1999e8bfbd37963b1f92c527a8748e
+{"ok":true}
+```
+
+Let's finish this off, don't forget to do something with the JSON you
+get back.
+
+```
+curl -XDELETE http://localhost:9292/trips/cf1999e8bfbd37963b1f92c527a8748e
+{"id":"cf1999e8bfbd37963b1f92c527a8748e","route":"invoicing","started_at":"2012-11-30T18:54:20.098477+02:00","checkpoints":[["generated.pdf","2012-11-30T19:08:26.138140+02:00"],
+["emailed.customer","2012-11-30T19:12:41.332270+02:00"]]}
+```
+
+
+# Contributing
+
+Fork, implement, add tests, pull request, get my everlasting thanks and a respectable place here :).
+
+
+# Copyright
+
+
+Copyright (c) 2012 [Dotan Nahum](http://gplus.to/dotan) [@jondot](http://twitter.com/jondot). See MIT-LICENSE for further details.
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/benchmark/redis_store

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+require 'benchmark'
+require 'roundtrip'
+require 'roundtrip/core'
+require 'roundtrip/store/redis'
+require 'roundtrip/metrics/statsd'
+
+
+
+
+#       user     system      total        real
+#   0.270000   0.010000   0.280000 (  0.268505)  ; baseline
+#   0.650000   0.540000   1.190000 (  1.419452)  ; start/end
+#   2.050000   1.440000   3.490000 (  4.284264)  ; start/3xcheckpoint/end
+
+# after adding metrics and statsd
+#        user     system      total        real
+#   0.260000   0.000000   0.260000 (  0.263847)
+#   0.770000   0.510000   1.280000 (  1.476628)
+#   2.080000   1.580000   3.660000 (  4.488898)
+#
+
+core = Roundtrip::Core.new(Roundtrip::Store::Redis.new, Roundtrip::Metrics::Statsd.new)
+Benchmark.bm do |x|
+  x.report do
+    10000.times{Roundtrip::Core.new(Roundtrip::Store::Redis.new, Roundtrip::Metrics::Statsd.new)}
+  end
+
+  x.report do
+    1000.times{ item = core.start('benchmark');     core.end(item.id) }
+  end
+
+
+  x.report do
+    1000.times do
+      item = core.start('benchmark')
+      core.checkpoint(item.id, 'foo1')
+      core.checkpoint(item.id, 'foo2')
+      core.checkpoint(item.id, 'foo3')
+      core.end(item.id)
+    end
+  end
+
+end
+

data/bin/roundtrip

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "roundtrip/cli"
+
+Roundtrip::CLI.start

data/conf/roundtrip.yml

@@ -0,0 +1,5 @@
+development:
+
+production:
+
+

data/config.ru

@@ -0,0 +1,9 @@
+$:<< 'lib'
+
+require 'roundtrip'
+Roundtrip.options[:redis] = { :host  => 'localhost' }
+Roundtrip.options[:statsd] = { :host => 'localhost', :port => 8125 }
+
+require 'roundtrip/web'
+run Roundtrip::Web
+

data/examples/Gemfile

@@ -0,0 +1,2 @@
+source :gemcutter
+gem 'httparty'

data/examples/ruby_httparty.rb

@@ -0,0 +1,18 @@
+require 'httparty'
+
+#
+# run Roundtrip on localhost:9292 (default rack).
+#
+
+resp = HTTParty.post 'http://localhost:9292/trips', :body => { :route => 'invoicing' }
+
+# carry this ID around with you.
+id = resp["id"]
+
+HTTParty.patch "http://localhost:9292/trips/#{id}", :body => { :checkpoint => 'generate.pdf' }
+HTTParty.patch "http://localhost:9292/trips/#{id}", :body => { :checkpoint => 'create.invoice' }
+
+resp = HTTParty.delete "http://localhost:9292/trips/#{id}"
+
+puts resp
+

data/lib/roundtrip.rb

@@ -0,0 +1,12 @@
+require "roundtrip/version"
+
+module Roundtrip
+  def self.options
+    @options ||= {}
+  end
+end
+
+require 'roundtrip/trip'
+require 'roundtrip/core'
+require 'roundtrip/store'
+require 'roundtrip/metrics'

data/lib/roundtrip/cli.rb

@@ -0,0 +1,23 @@
+require 'roundtrip'
+require 'thor'
+require 'roundtrip/store/redis'
+
+class Roundtrip::CLI < Thor
+
+  desc "start [ROUTE]", "starts a new trip on a given route"
+  def start(route)
+    t = core.start(route)
+    say t.to_h
+  end
+
+  desc "end [TRIP_ID]", "ends a trip"
+  def end(trip_id)
+    t = core.end(trip_id)
+    say t.to_h
+  end
+
+private 
+  def core
+    @core = Roundtrip::Core.new(Roundtrip::Store::Redis.new)
+  end
+end

data/lib/roundtrip/core.rb

@@ -0,0 +1,61 @@
+require 'roundtrip/trip'
+
+class Roundtrip::Core
+  def initialize(store, metrics=Roundtrip::Metrics::Null.new)
+    @store = store
+    @metrics = metrics
+  end
+
+  def start(route, opts={})
+    must_be_present! route
+
+    t = Roundtrip::Trip.generate(route, opts)
+    @store.add(t)
+    t
+  end
+
+  def checkpoint(id, at)
+    must_be_present! id, at
+    trip = @store.get(id)
+    if trip
+      res = @store.add_checkpoint(trip, at)
+      @metrics.time(trip.route, at, msec(res[1] - trip.started_at))
+      res
+    end
+  end
+
+  def end(id)
+    must_be_present! id
+
+    trip = @store.get(id)
+    end_trip(trip) if trip
+    trip
+  end
+
+  def pending(route, older_than=0)
+    must_be_present! route
+
+    @store.pending_trips(route, older_than)
+  end
+
+  def purge(route, older_than=0)
+    pending_trips = pending(route, older_than)
+    pending_trips.each{ |trip| end_trip(trip) }
+    pending_trips
+  end
+
+private
+  def end_trip(trip)
+    @store.remove(trip)
+    @metrics.time(trip.route, 'end', msec(Time.now - trip.started_at))
+  end
+
+  def msec(floating_delta)
+    (floating_delta*1000).floor
+  end
+  def must_be_present!(*things)
+    things.each do |thing|
+      raise "parameter must be present" unless thing && thing.strip != ""
+    end
+  end
+end

data/lib/roundtrip/metrics.rb

@@ -0,0 +1,5 @@
+module Roundtrip::Metrics
+  class Null
+    def time(route, event, time);end
+  end
+end

data/lib/roundtrip/metrics/statsd.rb

@@ -0,0 +1,13 @@
+require 'statsd'
+
+
+class Roundtrip::Metrics::Statsd
+  def initialize(opts={:statsd => {:host => 'localhost', :port => 8125}})
+    @statsd =opts[:statsd][:connection] || ::Statsd.new(opts[:statsd][:host], opts[:statsd][:port])
+  end
+
+  def time(route, event, time)
+    @statsd.timing("#{route}.#{event}", time)
+  end
+end
+

data/lib/roundtrip/store.rb

@@ -0,0 +1,5 @@
+module Roundtrip::Store
+end
+
+
+

data/lib/roundtrip/store/redis.rb

@@ -0,0 +1,68 @@
+require 'roundtrip/store'
+require 'redis'
+
+
+class Roundtrip::Store::Redis
+  def initialize(opts={:redis => {:host => 'localhost'}})
+    @conn = opts[:redis][:connection]  || Redis.new(opts[:redis])
+  end
+
+  def get(id)
+    blob = @conn.get(trip_key(id))
+    trip = Marshal.load(blob) if blob
+    if trip
+      trip.checkpoints = @conn.zrange(checkpoints_key(id), "0", "-1", :withscores => true).map{|pair| [pair[0], Time.at(pair[1])]}
+    end
+    trip
+  end
+
+  def add(trip)
+    @conn.multi do
+      @conn.set(trip_key(trip.id), Marshal.dump(trip))
+      @conn.zadd(route_key(trip.route), trip.started_at.to_i, trip.id)
+    end
+  end
+
+  def add_checkpoint(trip, at)
+    time = Time.now
+    @conn.zadd(checkpoints_key(trip.id), time.to_f, at)
+    [at, time]
+  end
+
+  def remove(trip)
+    res = @conn.multi do
+      @conn.del(trip_key(trip.id))
+      @conn.del(checkpoints_key(trip.id))
+      @conn.zrem(route_key(trip.route), trip.id)
+    end
+    res.count == 3 && res[0] == 1 && res[2] == true
+  end
+
+  def pending_trips(prod, older_than=0)
+    start_stamp = Time.now.to_i - older_than
+    ids = @conn.zrangebyscore(route_key(prod), 0, start_stamp.to_s)
+    return [] if ids.empty?
+
+    tripsdata = @conn.mget(ids.map{|k| trip_key(k) })
+    tripsdata.map { |blob| Marshal.load(blob) }
+  end
+
+  def prune_old_trips(prod, timespan)
+
+  end
+
+
+
+private
+  def trip_key(trip_id)
+    "rt:trip:#{trip_id}"
+  end
+
+  def route_key(route)
+    "rt:route:#{route}"
+  end
+
+  def checkpoints_key(trip_id)
+    "rt:cp:#{trip_id}"
+  end
+end

data/lib/roundtrip/trip.rb

@@ -0,0 +1,37 @@
+require 'securerandom'
+require 'time'
+
+
+class Roundtrip::Trip
+  attr_accessor :id, :route, :started_at, :checkpoints
+
+  def initialize(id, route, started_at)
+    self.id = id
+    self.route = route
+    self.started_at = started_at
+    self.checkpoints = []
+  end
+
+
+  def to_json(*a)
+    to_h.to_json(*a)
+  end
+
+  def to_h
+    {
+      :id  => id, 
+      :route => route, 
+      :started_at => started_at.iso8601(6), 
+      :checkpoints => checkpoints.map{|cp| [cp[0], cp[1].iso8601(6)] }
+    }
+  end
+
+  def ==(o)
+    o.class == self.class && o.to_h == to_h
+  end
+  alias_method :eql?, :==
+
+  def self.generate(route, opts={})
+    new(opts[:id] || SecureRandom.hex, route, Time.now)
+  end
+end

data/lib/roundtrip/version.rb

@@ -0,0 +1,3 @@
+module Roundtrip
+  VERSION = "0.0.1"
+end

data/lib/roundtrip/web.rb

@@ -0,0 +1,122 @@
+require 'roundtrip'
+require 'roundtrip/store/redis'
+require 'roundtrip/metrics/statsd'
+
+
+require 'sinatra'
+require 'json'
+require 'atom'
+
+# XXX
+# put on heroku
+# change url to be provider based at admin
+# set up configuration for redis to one of the test instances
+# check cross-cycle
+#
+class Roundtrip::Web < Sinatra::Base
+
+  configure do
+    store = Roundtrip::Store::Redis.new(Roundtrip.options)
+    stats = Roundtrip::Metrics::Statsd.new(Roundtrip.options)
+
+    set :core, Roundtrip::Core.new(store, stats)
+  end
+
+  post '/trips' do
+    content_type :json
+    route = params[:route]
+    must_exist!(route)
+
+    id = params[:id]
+
+    trip = core.start(route, :id => id)
+    # XXX add location: header
+    json trip
+  end
+
+  patch '/trips/:id' do
+    content_type :json
+    id = params[:id]
+    checkpoint = params[:checkpoint]
+    must_exist! id
+    must_exist! checkpoint
+
+    core.checkpoint(id, checkpoint)
+    json(:ok => true)
+  end
+
+  delete '/trips/:id' do
+    content_type :json
+    id = params[:id]
+    must_exist!(id)
+
+    trip = core.end(id)
+    json trip
+  end
+
+  delete '/trips' do
+    # XXX nastily un-dry. will fix later
+    content_type :json
+    route = params[:route]
+    older_than = params[:older_than_secs]
+
+    must_exist!(route)
+
+    res = core.purge(route, (older_than || 0).to_i)
+
+    json res
+  end
+
+  get '/trips.json' do
+    content_type :json
+    route = params[:route]
+    older_than = params[:older_than_secs]
+
+    must_exist!(route)
+
+    res = core.pending(route, (older_than || 0).to_i)
+    json res
+  end
+
+  get '/trips.rss' do
+    content_type 'text/xml'
+    route = params[:route]
+    must_exist!(route)
+
+    older_than = params[:older_than_secs]
+
+    res = core.pending(route, (older_than || "0").to_i)
+
+    feed = Atom::Feed.new do |f|
+      f.title = "Roundtrip #{route}"
+      f.links << Atom::Link.new(:href => "http://example.com/roundtrip/#{route}/")
+
+      res.each do |p|
+        f.entries << Atom::Entry.new do |e|
+          e.title = p.id
+          e.links << Atom::Link.new(:href => "http://example.com/#{p.id}")
+          e.id = p.id
+          e.updated = p.started_at.iso8601(6)
+          e.summary = p.started_at.iso8601(6)
+        end
+      end
+    end
+    feed.to_xml
+  end
+
+private
+  def core
+    settings.core
+  end
+
+  def json(obj)
+    obj.to_json
+  end
+
+  def must_exist!(thing)
+    # XXX say which param. accept :param => val hash
+    halt 406, {:error => "Parameter must be present."}.to_json unless thing && thing.strip != ""
+  end
+end
+
+

data/roundtrip.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'roundtrip/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "roundtrip"
+  gem.version       = Roundtrip::VERSION
+  gem.authors       = ["Dotan Nahum"]
+  gem.email         = ["jondotan@gmail.com"]
+  gem.description   = %q{Simple business process/transactions tracking and metrics service}
+  gem.summary       = %q{Simple business process/transactions tracking and metrics service}
+  gem.homepage      = "https://github.com/jondot/roundtrip"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "thor"
+  gem.add_dependency "sinatra"
+  gem.add_dependency "redis-namespace"
+  gem.add_dependency "redis"
+  gem.add_dependency "json"
+  gem.add_dependency "ratom"
+  gem.add_dependency "thor"
+  gem.add_dependency "statsd-ruby"
+
+  gem.add_development_dependency "guard-minitest"
+  gem.add_development_dependency "rr"
+  gem.add_development_dependency "timecop"
+
+end

data/spec/roundtrip/core_spec.rb

@@ -0,0 +1,122 @@
+
+require 'spec_helper'
+require 'roundtrip/core'
+
+
+module Roundtrip
+  describe Core do
+    let(:trip_id) { 'C0FFEEBABE' }
+    let(:trip) do
+      Trip.new(trip_id, 'prod', Time.now)
+    end
+
+    describe "#start" do
+      it "should start" do
+        mock(Roundtrip::Trip).generate('prod', {}){ trip }
+        store = Object.new
+        mock(store).add(trip){true}
+        core = Core.new(store)
+        core.start('prod').must_equal(trip)
+      end
+      it "should start with an explicit ID given it was supplied" do
+        mock(Roundtrip::Trip).generate('prod', {:id => 'id-xyz'}){ trip }
+        store = Object.new
+        mock(store).add(trip){true}
+        core = Core.new(store)
+        core.start('prod', :id => 'id-xyz').must_equal(trip)
+      end
+   end
+
+    describe "#checkpoint" do
+      it "should add a new checkpoint to a started trip" do
+        store = Object.new
+        mock(store).get("id-xyz"){ trip }
+        time = Time.now
+        mock(store).add_checkpoint(trip, 'generate_invoice'){ ['generate_invoice', time] }
+
+        core = Core.new(store)
+        t = core.checkpoint('id-xyz', 'generate_invoice')
+        t.must_equal ['generate_invoice', time]
+      end
+
+      it "should not add a new checkpoint to a missing trip" do
+        store = Object.new
+        mock(store).get("id-xyz"){ nil }
+
+        core = Core.new(store)
+        core.checkpoint('id-xyz', 'generate_invoice').must_be_nil
+      end
+    end
+    describe "#end" do
+      it "should not end given it never started" do
+        store = Object.new
+        mock(store).get('bad-trip'){ nil }
+        core = Core.new(store)
+        core.end('bad-trip').must_be_nil
+      end
+
+
+      it "should end the exact ID that has been started" do
+        t = Time.now
+        trip = Trip.new('key-1', 'prod', t)
+        mock(Roundtrip::Trip).generate('key-1', {}){ trip }
+        store = Object.new
+        mock(store).add(trip){ true }
+        mock(store).get(trip.id){ trip }
+        mock(store).remove(trip){ true }
+
+        core = Core.new(store)
+
+        core.start('key-1')
+        core.end('key-1').must_equal(trip)
+      end
+    end
+
+    describe "#pending" do
+      it "should list all open trips" do
+        store = Object.new
+        pending = [ :foo ]
+        mock(store).pending_trips('prod', 0){ pending }
+
+        core = Core.new(store)
+
+        core.pending('prod', 0).must_equal(pending)
+      end
+
+    end
+
+    describe "#purge" do
+      it "should do nothing given no pending trips" do
+        store = Object.new
+        pending = []
+        mock(store).pending_trips('prod', 0){ pending }
+
+        core = Core.new(store)
+        core.purge('prod', 0).must_equal(pending)
+      end
+
+      it "should purge pending trips given staleness" do
+        store = Object.new
+        trip1 = Trip.new('key-1', 'prod', Time.now)
+        pending = [trip1]
+        mock(store).pending_trips('prod', 30){ pending }
+        mock(store).remove(trip1)
+
+        core = Core.new(store)
+        core.purge('prod', 30).must_equal(pending)
+      end
+
+      it "should purge all pending trips given no staleness" do
+        store = Object.new
+        trip1 = Trip.new('key-1', 'prod', Time.now)
+        pending = [trip1]
+        mock(store).pending_trips('prod', 0){ pending }
+        mock(store).remove(trip1)
+
+        core = Core.new(store)
+        core.purge('prod').must_equal(pending)
+      end
+    end
+  end
+end
+

data/spec/roundtrip/metrics/statsd_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'roundtrip/metrics/statsd'
+require 'timecop'
+
+module Roundtrip
+  describe Metrics::Statsd do
+    it "should time checkpoints" do
+      trip = Trip.new('trip', 'prod', Time.at(1354366786.0090559))
+
+      statsd = Object.new
+      mock(statsd).timing("prod.invoice.created", 2789)
+      metrics = Metrics::Statsd.new(:statsd => { :connection => statsd })
+
+      store = Object.new
+      mock(store).get('id-xyz'){ trip }
+      mock(store).add_checkpoint(trip, 'invoice.created'){ [trip, Time.at(1354366788.7987247)] }
+
+      core = Core.new(store, metrics)
+      core.checkpoint('id-xyz', 'invoice.created')
+    end
+
+    it "should time end" do
+      trip = Trip.new('trip', 'prod', Time.at(1354366786.0090559))
+
+      statsd = Object.new
+      mock(statsd).timing("prod.end", 2789)
+      metrics = Metrics::Statsd.new(:statsd => { :connection => statsd })
+
+      Timecop.freeze(Time.at(1354366788.7987247)) do
+        store = Object.new
+        mock(store).get('id-xyz'){ trip }
+        mock(store).remove(trip)
+
+        core = Core.new(store, metrics)
+        core.end('id-xyz')
+      end
+    end
+  end
+end

data/spec/roundtrip/store/redis_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'roundtrip/store/redis'
+require 'redis'
+require 'redis/namespace'
+require 'timecop'
+
+
+# dirty test. requires running a local redis
+# todo: check how redis rb  does its tests. (and how integrates with travis-ci)
+module Roundtrip
+  describe Store::Redis do
+
+    before do
+      @redis = ::Redis::Namespace.new('roundtrip-testing', :redis => Redis.new)
+      ks = @redis.keys "rt:*"
+      @redis.pipelined do
+        ks.each{ |k| @redis.del k }
+      end
+    end
+
+    let(:store){ Store::Redis.new({ :redis => { :connection => @redis }}) }
+
+    it "should add and get trips" do
+      t = Trip.new('trip', 'prod', Time.now)
+      store.add(t)
+      store.get(t.id).must_equal(t)
+    end
+
+    it "should get a trip by ID" do
+      t = Trip.new('trip', 'prod', Time.now)
+      id = store.add(t)
+
+      r = store.get('trip')
+      r.id.must_equal 'trip'
+      r.route.must_equal 'prod'
+    end
+
+    it "should remove a trip by ID" do
+      t = Trip.new('trip', 'prod', Time.now)
+      id = store.add(t)
+      store.remove(t).must_equal(true)
+    end
+
+    it "should add a checkpoint" do
+      t = Trip.new('trip', 'id-xyz', Time.now)
+      store.add(t)
+      time = Time.now
+      Timecop.freeze(time) do
+        store.add_checkpoint(t, 'generate.invoice')
+        trip = store.get(t.id)
+        checkpoint, ts = trip.checkpoints[0]
+        checkpoint.must_equal 'generate.invoice'
+        ts.to_f.must_equal time.to_f
+      end
+    end
+
+
+    describe "#pending_trips" do
+      it "should fetch pending trips" do
+        t = Trip.new('trip', 'prod', Time.now)
+        id = store.add(t)
+        pending = store.pending_trips('prod')
+        pending.first.must_equal t
+      end
+
+      it "should return empty for nonexisting route" do
+        t = Trip.new('trip', 'prod', Time.now)
+        id = store.add(t)
+        pending = store.pending_trips('nonexisting')
+        pending.must_equal []
+      end
+
+      it "should fetch pending trips older than a point in time" do
+        t = Trip.new('trip', 'prod', Time.now-400)
+        id = store.add(t)
+        pending = store.pending_trips('prod', 300)
+        pending.first.must_equal t
+      end
+
+    end
+
+    it "should not have side-effects" do
+      t = Trip.new('trip', 'prod', Time.now)
+      id = store.add(t)
+      store.remove(t).must_equal(true)
+      store.pending_trips('prod').must_equal []
+    end
+  end
+end

data/spec/roundtrip/trip_spec.rb

@@ -0,0 +1,22 @@
+
+require 'spec_helper'
+require 'roundtrip/trip'
+
+
+module Roundtrip
+  describe Trip do
+    describe "::generate" do
+      it "should generate with a random ID if none given" do
+        t1 = Trip.generate("foo")
+        t2 = Trip.generate("foo", :invalid_option => 'poo')
+        t1.route.must_equal "foo"
+        t1.id.wont_equal t2.id
+      end
+      it "should generate with the specified ID" do
+        t = Trip.generate("foo", :id => 'poo')
+        t.route.must_equal "foo"
+        t.id.must_equal 'poo'
+      end
+   end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+require 'rr'
+require 'roundtrip'
+require 'minitest/autorun'
+require 'timecop'
+
+class MiniTest::Unit::TestCase
+  include RR::Adapters::MiniTest
+end
+
+

metadata

@@ -0,0 +1,257 @@
+--- !ruby/object:Gem::Specification
+name: roundtrip
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dotan Nahum
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ratom
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: statsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple business process/transactions tracking and metrics service
+email:
+- jondotan@gmail.com
+executables:
+- roundtrip
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- Procfile
+- README.md
+- Rakefile
+- benchmark/redis_store
+- bin/roundtrip
+- conf/roundtrip.yml
+- config.ru
+- examples/Gemfile
+- examples/roundtrip-schema.png
+- examples/ruby_httparty.rb
+- lib/roundtrip.rb
+- lib/roundtrip/cli.rb
+- lib/roundtrip/core.rb
+- lib/roundtrip/metrics.rb
+- lib/roundtrip/metrics/statsd.rb
+- lib/roundtrip/store.rb
+- lib/roundtrip/store/redis.rb
+- lib/roundtrip/trip.rb
+- lib/roundtrip/version.rb
+- lib/roundtrip/web.rb
+- roundtrip.gemspec
+- spec/roundtrip/core_spec.rb
+- spec/roundtrip/metrics/statsd_spec.rb
+- spec/roundtrip/store/redis_spec.rb
+- spec/roundtrip/trip_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jondot/roundtrip
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple business process/transactions tracking and metrics service
+test_files:
+- spec/roundtrip/core_spec.rb
+- spec/roundtrip/metrics/statsd_spec.rb
+- spec/roundtrip/store/redis_spec.rb
+- spec/roundtrip/trip_spec.rb
+- spec/spec_helper.rb