appoptics_apm 4.0.2

data/test/instrumentation/moped_test.rb

@@ -0,0 +1,517 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'minitest_helper'
+
+unless ENV['APPOPTICS_MONGO_SERVER']
+  ENV['APPOPTICS_MONGO_SERVER'] = "127.0.0.1:27017"
+end
+
+if RUBY_VERSION >= '1.9.3'
+  # Moped is tested against MRI 2.3.1 and 2.4.1
+
+  describe "Moped" do
+    before do
+      clear_all_traces
+      @session = Moped::Session.new([ ENV['APPOPTICS_MONGO_SERVER'] ])
+      @session.use :moped_test
+      @users = @session[:users]
+      @users.drop
+      @users.insert({ :name => "Syd", :city => "Boston" })
+
+      # These are standard entry/exit KVs that are passed up with all moped operations
+      @entry_kvs = {
+        'Layer' => 'mongo',
+        'Label' => 'entry',
+        'Flavor' => 'mongodb',
+        'Database' => 'moped_test',
+        'RemoteHost' => ENV['APPOPTICS_MONGO_SERVER'] }
+
+      @exit_kvs = { 'Layer' => 'mongo', 'Label' => 'exit' }
+      @collect_backtraces = AppOpticsAPM::Config[:moped][:collect_backtraces]
+    end
+
+    after do
+      AppOpticsAPM::Config[:moped][:collect_backtraces] = @collect_backtraces
+    end
+
+    it 'Stock Moped should be loaded, defined and ready' do
+      defined?(::Moped).wont_match nil
+      defined?(::Moped::Database).wont_match nil
+      defined?(::Moped::Indexes).wont_match nil
+      defined?(::Moped::Query).wont_match nil
+      defined?(::Moped::Collection).wont_match nil
+    end
+
+    it 'Moped should have appoptics_apm methods defined' do
+      #::Moped::Database
+      AppOpticsAPM::Inst::Moped::DB_OPS.each do |m|
+        ::Moped::Database.method_defined?("#{m}_with_appoptics").must_equal true
+      end
+      ::Moped::Database.method_defined?(:extract_trace_details).must_equal true
+      ::Moped::Database.method_defined?(:command_with_appoptics).must_equal true
+      ::Moped::Database.method_defined?(:drop_with_appoptics).must_equal true
+
+      #::Moped::Indexes
+      AppOpticsAPM::Inst::Moped::INDEX_OPS.each do |m|
+        ::Moped::Indexes.method_defined?("#{m}_with_appoptics").must_equal true
+      end
+      ::Moped::Indexes.method_defined?(:extract_trace_details).must_equal true
+      ::Moped::Indexes.method_defined?(:create_with_appoptics).must_equal true
+      ::Moped::Indexes.method_defined?(:drop_with_appoptics).must_equal true
+
+      #::Moped::Query
+      AppOpticsAPM::Inst::Moped::QUERY_OPS.each do |m|
+        ::Moped::Query.method_defined?("#{m}_with_appoptics").must_equal true
+      end
+      ::Moped::Query.method_defined?(:extract_trace_details).must_equal true
+
+      #::Moped::Collection
+      AppOpticsAPM::Inst::Moped::COLLECTION_OPS.each do |m|
+        ::Moped::Collection.method_defined?("#{m}_with_appoptics").must_equal true
+      end
+      ::Moped::Collection.method_defined?(:extract_trace_details).must_equal true
+    end
+
+    it 'should trace command' do
+      # TODO: This randomly fails for a yet unknown reason. Does it?
+      # skip
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        command = {}
+        command[:mapreduce] = "users"
+        command[:map] = "function() { emit(this.name, 1); }"
+        command[:reduce] = "function(k, vals) { var sum = 0; for(var i in vals) sum += vals[i]; return sum; }"
+        command[:out] = "inline: 1"
+        @session.command(command)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "map_reduce"
+      traces[1]['Map_Function'].must_equal "function() { emit(this.name, 1); }"
+      traces[1]['Reduce_Function'].must_equal "function(k, vals) { var sum = 0;" +
+        " for(var i in vals) sum += vals[i]; return sum; }"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace drop_collection' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.drop
+        @session.drop
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "drop_collection"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "drop_database"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace create_index, indexes and drop_indexes' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.indexes.create({:name => 1}, {:unique => true})
+        @users.indexes.drop
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 10
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "indexes"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "create_index"
+      traces[3]['Key'].must_equal "{\"name\":1}"
+      traces[3]['Options'].must_equal "{\"unique\":true}"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+
+      validate_event_keys(traces[5], @entry_kvs)
+      traces[5]['QueryOp'].must_equal "indexes"
+      traces[5]['Collection'].must_equal "users"
+      traces[5].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[6], @exit_kvs)
+
+      validate_event_keys(traces[7], @entry_kvs)
+      traces[7]['QueryOp'].must_equal "drop_indexes"
+      traces[7]['Key'].must_equal "all"
+      traces[7].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[8], @exit_kvs)
+    end
+
+    it 'should trace find and count' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find.count
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "count"
+      traces[3]['Query'].must_equal "all"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find and sort' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").sort(:city => 1, :created_at => -1)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "sort"
+      traces[3]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Order'].must_equal "{:city=>1, :created_at=>-1}"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find with limit' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").limit(1)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "limit"
+      traces[3]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Limit'].must_equal "1"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find with distinct' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").distinct(:city)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "distinct"
+      traces[3]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Key'].must_equal "city"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find and update' do
+      2.times { @users.insert(:name => "Mary") }
+      mary_count = @users.find(:name => "Mary").count
+      mary_count.wont_equal 0
+
+      tool_count = @users.find(:name => "Tool").count
+      tool_count.must_equal 0
+
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        old_attrs = { :name => "Mary" }
+        new_attrs = { :name => "Tool" }
+        @users.find(old_attrs).update({ '$set' => new_attrs }, { :multi => true })
+      end
+
+      new_tool_count = @users.find(:name => "Tool").count
+      new_tool_count.must_equal mary_count
+
+      new_mary_count = @users.find(:name => "Mary").count
+      new_mary_count.must_equal 0
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "update"
+      traces[3]['Update_Document'].must_equal "{\"$set\":{\"name\":\"Tool\"}}"
+      traces[3]['Flags'].must_equal "{:multi=>true}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find and update_all' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").update_all({:name => "Tool"})
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "update_all"
+      traces[3]['Update_Document'].must_equal "{\"name\":\"Tool\"}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find and upsert' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Tool").upsert({:name => "Mary"})
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Tool\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "upsert"
+      traces[3]['Query'].must_equal "{\"name\":\"Tool\"}"
+      traces[3]['Update_Document'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace find and explain' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").explain
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "explain"
+      traces[3]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace 3 types of find and modify calls' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:likes => 1).modify({ "$set" => { :name => "Tool" }}, :upsert => true)
+        @users.find.modify({ "$inc" => { :likes => 1 }}, :new => true)
+        @users.find.modify({:query => {}}, :remove => true)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 14
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"likes\":1}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "modify"
+      traces[3]['Update_Document'].must_equal "{\"likes\":1}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3]['Options'].must_equal "{\"upsert\":true}"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+
+      validate_event_keys(traces[7], @entry_kvs)
+      traces[7]['QueryOp'].must_equal "modify"
+      traces[7]['Update_Document'].must_equal "all"
+      traces[7]['Collection'].must_equal "users"
+      traces[7]['Options'].must_equal "{\"new\":true}"
+      traces[7]['Change'].must_equal "{\"$inc\":{\"likes\":1}}"
+      traces[7].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[8], @exit_kvs)
+
+      validate_event_keys(traces[11], @entry_kvs)
+      traces[11]['Collection'].must_equal "users"
+      traces[11]['QueryOp'].must_equal "modify"
+      traces[11]['Update_Document'].must_equal "all"
+      traces[11]['Change'].must_equal "{\"query\":{}}"
+      traces[11]['Options'].must_equal "{\"remove\":true}"
+      traces[11].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[12], @exit_kvs)
+    end
+
+    it 'should trace remove' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Tool").remove
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Tool\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "remove"
+      traces[3]['Query'].must_equal "{\"name\":\"Tool\"}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace remove_all' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").remove_all
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "find"
+      traces[1]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+
+      validate_event_keys(traces[3], @entry_kvs)
+      traces[3]['QueryOp'].must_equal "remove_all"
+      traces[3]['Query'].must_equal "{\"name\":\"Mary\"}"
+      traces[3]['Collection'].must_equal "users"
+      traces[3].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace aggregate' do
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.aggregate(
+          {'$match' => {:name => "Mary"}},
+          {'$group' => {"_id" => "$name"}}
+        )
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'moped_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['QueryOp'].must_equal "aggregate"
+      traces[1]['Query'].must_equal "[{\"$match\"=>{:name=>\"Mary\"}}, {\"$group\"=>{\"_id\"=>\"$name\"}}]"
+      traces[1]['Collection'].must_equal "users"
+      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:moped][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it "should obey :collect_backtraces setting when true" do
+      AppOpticsAPM::Config[:moped][:collect_backtraces] = true
+
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").limit(1)
+      end
+
+      traces = get_all_traces
+      layer_has_key(traces, 'mongo', 'Backtrace')
+    end
+
+    it "should obey :collect_backtraces setting when false" do
+      AppOpticsAPM::Config[:moped][:collect_backtraces] = false
+
+      AppOpticsAPM::API.start_trace('moped_test', '', {}) do
+        @users.find(:name => "Mary").limit(1)
+      end
+
+      traces = get_all_traces
+      layer_doesnt_have_key(traces, 'mongo', 'Backtrace')
+    end
+  end
+
+end

data/test/instrumentation/rack_test.rb

@@ -0,0 +1,165 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'minitest_helper'
+require 'rack/test'
+require 'rack/lobster'
+require 'appoptics_apm/inst/rack'
+require 'mocha/mini_test'
+
+class RackTestApp < Minitest::Test
+  include Rack::Test::Methods
+
+  def app
+    @app = Rack::Builder.new {
+      use Rack::CommonLogger
+      use Rack::ShowExceptions
+      use AppOpticsAPM::Rack
+      map "/lobster" do
+        use Rack::Lint
+        run Rack::Lobster.new
+      end
+    }
+  end
+
+  def teardown
+    AppOpticsAPM::Config[:tracing_mode] = :always
+  end
+
+  def test_get_the_lobster
+    skip("FIXME: broken on travis only") if ENV['TRAVIS'] == "true"
+
+    clear_all_traces
+
+    get "/lobster"
+
+    traces = get_all_traces
+    traces.count.must_equal 3
+
+    validate_outer_layers(traces, 'rack')
+
+    kvs = {}
+    kvs["Label"] = "entry"
+    kvs["URL"] = "/lobster"
+    validate_event_keys(traces[0], kvs)
+
+    kvs.clear
+    kvs["Layer"] = "rack"
+    kvs["Label"] = "info"
+    kvs["HTTP-Host"] = "example.org"
+    kvs["Port"] = 80
+    kvs["Proto"] = "http"
+    kvs["Method"] = "GET"
+    kvs["ClientIP"] = "127.0.0.1"
+    validate_event_keys(traces[1], kvs)
+
+    assert traces[0].has_key?('SampleRate')
+    assert traces[0].has_key?('SampleSource')
+    assert traces[1].has_key?('ProcessID')
+    assert traces[1].has_key?('ThreadID')
+
+    assert traces[2]["Label"] == 'exit'
+    assert traces[2]["Status"] == 200
+
+    assert last_response.ok?
+
+    assert last_response['X-Trace']
+  end
+
+  def test_must_return_xtrace_header
+    clear_all_traces
+    get "/lobster"
+    xtrace = last_response['X-Trace']
+    assert xtrace
+    assert AppOpticsAPM::XTrace.valid?(xtrace)
+  end
+
+  def test_log_args_when_false
+    clear_all_traces
+
+    @log_args = AppOpticsAPM::Config[:rack][:log_args]
+    AppOpticsAPM::Config[:rack][:log_args] = false
+
+    get "/lobster?blah=1"
+
+    traces = get_all_traces
+
+    xtrace = last_response['X-Trace']
+    assert xtrace
+    assert AppOpticsAPM::XTrace.valid?(xtrace)
+
+    traces[0]['URL'].must_equal "/lobster"
+
+    AppOpticsAPM::Config[:rack][:log_args] = @log_args
+  end
+
+  def test_log_args_when_true
+    clear_all_traces
+
+    @log_args = AppOpticsAPM::Config[:rack][:log_args]
+    AppOpticsAPM::Config[:rack][:log_args] = true
+
+    get "/lobster?blah=1"
+
+    traces = get_all_traces
+
+    xtrace = last_response['X-Trace']
+    assert xtrace
+    assert AppOpticsAPM::XTrace.valid?(xtrace)
+
+    traces[0]['URL'].must_equal "/lobster?blah=1"
+
+    AppOpticsAPM::Config[:rack][:log_args] = @log_args
+  end
+
+  def test_has_header_when_not_tracing
+    clear_all_traces
+
+    AppOpticsAPM::Config[:tracing_mode] = :never
+
+    get "/lobster?blah=1"
+
+    traces = get_all_traces
+    assert_equal(0, traces.size)
+
+    assert last_response['X-Trace'], "X-Trace header is missing"
+    assert not_sampled?(last_response['X-Trace']), "X-Trace sampling flag is not '00'"
+  end
+
+  def test_sends_path_in_http_span_when_no_controller
+    test_action, test_url, test_status, test_method, test_error = nil, nil, nil, nil, nil
+
+    AppOpticsAPM::Span.expects(:createHttpSpan).with do |action, url, _duration, status, method, error|
+      test_action = action
+      test_url = url
+      test_status = status
+      test_method = method
+      test_error = error
+    end.once
+
+    get "/no/controller/here"
+
+    assert_equal nil, test_action
+    assert_equal "http://example.org/no/controller/here", test_url
+    assert_equal 404, test_status
+    assert_equal "GET", test_method
+    assert_equal 0, test_error
+  end
+
+  def test_does_not_send_http_span_for_static_assets
+    AppOpticsAPM::Span.expects(:createHttpSpan).never
+
+    get "/assets/static_asset.png"
+  end
+
+  # the status returned by @app.call(env) is usually an integer, but there are cases where it is a string
+  # encountered by this app: https://github.com/librato/api which proxies requests "through to a java service by rack"
+  def test_status_can_be_a_string
+    Rack::URLMap.any_instance.stubs(:call).returns(["200", {"Content-Length"=>"592"}, "the body"])
+
+    result = get '/lobster'
+
+    assert_equal 200, result.status
+  end
+end
+