oboe 2.2.6 → 2.3.2

data/test/instrumentation/memcached_test.rb

@@ -0,0 +1,218 @@
+require 'minitest_helper'
+
+if (RUBY_VERSION =~ /^1./) == 0
+  describe Oboe::Inst::Memcached do
+    require 'memcached'
+    require 'memcached/rails'
+  
+    before do
+      clear_all_traces 
+      @mc = ::Memcached::Rails.new(:servers => ['localhost'])
+
+      # These are standard entry/exit KVs that are passed up with all mongo operations
+      @entry_kvs = {
+        'Layer' => 'memcache',
+        'Label' => 'entry' }
+
+      @info_kvs = {
+        'Layer' => 'memcache',
+        'Label' => 'info' }
+
+      @exit_kvs = { 'Layer' => 'memcache', 'Label' => 'exit' }
+      @collect_backtraces = Oboe::Config[:memcached][:collect_backtraces]
+    end
+
+    after do
+      Oboe::Config[:memcached][:collect_backtraces] = @collect_backtraces
+    end
+
+    it 'Stock Memcached should be loaded, defined and ready' do
+      defined?(::Memcached).wont_match nil 
+      defined?(::Memcached::Rails).wont_match nil 
+    end
+
+    it 'Memcached should have oboe methods defined' do
+      Oboe::API::Memcache::MEMCACHE_OPS.each do |m|
+        if ::Memcached.method_defined?(m)
+          ::Memcached.method_defined?("#{m}_with_oboe").must_equal true 
+        end
+        ::Memcached::Rails.method_defined?(:get_multi_with_oboe).must_equal true 
+      end
+    end
+
+    it "should trace set" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.set('testKey', 'blah')
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+    
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "set"
+      traces[1]['KVKey'].must_equal "testKey"
+    end
+    
+    it "should trace get" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.get('msg')
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "get"
+      traces[1]['KVKey'].must_equal "msg"
+    end
+    
+    it "should trace get_multi" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.get_multi(['one', 'two', 'three', 'four', 'five', 'six'])
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 5
+    
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @info_kvs)
+      validate_event_keys(traces[3], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "get_multi"
+      
+      traces[2]['KVKeyCount'].must_equal "6"
+      traces[2].has_key?('KVHitCount').must_equal true
+    end
+    
+    it "should trace add for existing key" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.add('testKey', 'x', 1200)
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 5
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[3], @exit_kvs)
+
+      traces[1]['KVOp'].must_equal "add"
+      traces[1]['KVKey'].must_equal "testKey"
+      
+      traces[2]['ErrorClass'].must_equal "Memcached::NotStored"
+      traces[2]['Message'].must_equal "Memcached::NotStored"
+    end
+    
+    it "should trace append" do
+      @mc.set('rawKey', "Peanut Butter ", 600, :raw => true)
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.append('rawKey', "Jelly")
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "append"
+      traces[1]['KVKey'].must_equal "rawKey"
+    end
+    
+    it "should trace decr" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.decr('some_key_counter', 1)
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "decr"
+      traces[1]['KVKey'].must_equal "some_key_counter"
+    end
+  
+    it "should trace increment" do
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.incr("some_key_counter", 1)
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+
+      traces[1]['KVOp'].must_equal "incr"
+      traces[1]['KVKey'].must_equal "some_key_counter"
+    end
+  
+    it "should trace replace" do
+      @mc.set('some_key', 'blah')
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.replace("some_key", "woop")
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+      
+      traces[1]['KVOp'].must_equal "replace"
+      traces[1]['KVKey'].must_equal "some_key"
+    end
+
+    it "should trace delete" do
+      @mc.set('some_key', 'blah')
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.delete("some_key")
+      end
+      
+      traces = get_all_traces
+      traces.count.must_equal 4
+      
+      validate_outer_layers(traces, 'memcached_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      validate_event_keys(traces[2], @exit_kvs)
+
+      traces[1]['KVOp'].must_equal "delete"
+      traces[1]['KVKey'].must_equal "some_key"
+    end
+    
+    it "should obey :collect_backtraces setting when true" do
+      Oboe::Config[:memcached][:collect_backtraces] = true
+
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.set('some_key', 1)
+      end
+
+      traces = get_all_traces
+      layer_has_key(traces, 'memcache', 'Backtrace')
+    end
+
+    it "should obey :collect_backtraces setting when false" do
+      Oboe::Config[:memcached][:collect_backtraces] = false
+
+      Oboe::API.start_trace('memcached_test', '', {}) do
+        @mc.set('some_key', 1)
+      end
+
+      traces = get_all_traces
+      layer_doesnt_have_key(traces, 'memcache', 'Backtrace')
+    end
+  end
+end

data/test/instrumentation/mongo_test.rb

@@ -0,0 +1,406 @@
+require 'minitest_helper'
+
+describe Oboe::Inst::Mongo do
+  before do
+    clear_all_traces 
+    @connection = Mongo::Connection.new("localhost", 27017, :slave_ok => true)
+    @db = @connection.db("test-#{ENV['RACK_ENV']}")
+
+    # These are standard entry/exit KVs that are passed up with all mongo operations
+    @entry_kvs = {
+      'Layer' => 'mongo',
+      'Label' => 'entry',
+      'Flavor' => 'mongodb',
+      'Database' => 'test-test',
+      'RemoteHost' => 'localhost',
+      'RemotePort' => '27017' }
+
+    @exit_kvs = { 'Layer' => 'mongo', 'Label' => 'exit' }
+    @collect_backtraces = Oboe::Config[:mongo][:collect_backtraces]
+  end
+  
+  after do
+    Oboe::Config[:mongo][:collect_backtraces] = @collect_backtraces
+  end
+
+  it 'Stock Mongo should be loaded, defined and ready' do
+    defined?(::Mongo).wont_match nil 
+    defined?(::Mongo::DB).wont_match nil
+    defined?(::Mongo::Cursor).wont_match nil
+    defined?(::Mongo::Collection).wont_match nil
+  end
+
+  it 'Mongo should have oboe methods defined' do
+    Oboe::Inst::Mongo::DB_OPS.each do |m|
+      ::Mongo::DB.method_defined?("#{m}_with_oboe").must_equal true
+    end
+    Oboe::Inst::Mongo::CURSOR_OPS.each do |m|
+      ::Mongo::Cursor.method_defined?("#{m}_with_oboe").must_equal true
+    end
+    Oboe::Inst::Mongo::COLL_WRITE_OPS.each do |m|
+      ::Mongo::Collection.method_defined?("#{m}_with_oboe").must_equal true
+    end
+    Oboe::Inst::Mongo::COLL_QUERY_OPS.each do |m|
+      ::Mongo::Collection.method_defined?("#{m}_with_oboe").must_equal true
+    end
+    Oboe::Inst::Mongo::COLL_INDEX_OPS.each do |m|
+      ::Mongo::Collection.method_defined?("#{m}_with_oboe").must_equal true
+    end
+    ::Mongo::Collection.method_defined?(:oboe_collect).must_equal true
+  end
+
+  it "should trace create_collection" do
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      @db.create_collection("create_and_drop_collection_test")
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[1]['QueryOp'].must_equal "create_collection"
+    traces[1]['New_Collection_Name'].must_equal "create_and_drop_collection_test"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+  end
+
+  it "should trace drop_collection" do
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      @db.drop_collection("create_and_drop_collection_test")
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[1]['QueryOp'].must_equal "drop_collection"
+    traces[1]['Collection'].must_equal "create_and_drop_collection_test"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+  end
+
+  it "should trace count" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.count(:query => {:name => "MyName"})
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 6
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[3]['QueryOp'].must_equal "count"
+  end
+  
+  it "should trace find_and_modify" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.find_and_modify({ :query => { :name => "MyName" }, :update => { :count => 203 }})
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "find_and_modify"
+    traces[1]['Update_Document'].must_equal "{:count=>203}"
+  end
+  
+  it "should trace insert" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      doc = {"name" => "MyName", "type" => "MyType", "count" => 1, "info" => {"x" => 203, "y" => '102'}}
+      id = coll.insert(doc)
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "insert"
+    traces[1]['Query'].must_equal "{\"name\":\"MyName\",\"type\":\"MyType\",\"count\":1,\"info\":{\"x\":203,\"y\":\"102\"}}"
+  end
+  
+  it "should trace map_reduce" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      map    = "function() { emit(this.name, 1); }"
+      reduce = "function(k, vals) { var sum = 0; for(var i in vals) sum += vals[i]; return sum; }"
+      coll.map_reduce(map, reduce, { :out => "mr_results", :limit => 100, :read => :primary })
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    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]['Limit'].must_equal "100"
+  end
+  
+  it "should trace remove" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.remove(:name => "SaveOp")
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "remove"
+    traces[1]['Query'].must_equal "{\"name\":\"SaveOp\"}"
+  end
+  
+  it "should trace rename" do
+    coll = @db.collection("testCollection")
+    new_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.rename(new_name)
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "rename"
+    traces[1]['New_Collection_Name'].must_equal new_name
+    
+    # Clean up after test and set collection name back to original
+    coll.rename("testCollection")
+  end
+
+  it "should trace update" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      # Two types of update calls
+      coll.update({"_id" => 1}, { "$set" => {"name" => "MongoDB Ruby"}}, :multi => true)
+      
+      doc = {"name" => "MyOtherName", "type" => "MyType", "count" => 1, "info" => {"x" => 203, "y" => '102'}}
+      coll.update({"_id" => 1}, doc)
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 6
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "update"
+    traces[1]['Query'].must_equal "{\"_id\":1}"
+    
+    validate_event_keys(traces[3], @entry_kvs)
+    validate_event_keys(traces[4], @exit_kvs)
+
+    traces[3].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[3]['QueryOp'].must_equal "update"
+    traces[3]['Query'].must_equal "{\"_id\":1}"
+  end
+  
+  it "should trace distinct" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.distinct("count")
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "distinct"
+  end
+  
+  it "should trace find" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.find(:name => "MyName", :limit => 1)
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "find"
+    traces[1]['Query'].must_equal "{\"name\":\"MyName\",\"limit\":1}"
+    traces[1]['Limit'].must_equal "1"
+  end
+  
+  it "should trace group" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.group( :key =>  :type,
+                  :cond => { :count => 1 },
+                  :initial =>  { :count => 0 },
+                  :reduce => 'function(obj,prev) { prev.count += obj.c; }')
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "group"
+    traces[1]['Query'].must_equal "{\"key\":\"type\",\"cond\":{\"count\":1},\"initial\":{\"count\":0},\"reduce\":\"function(obj,prev) { prev.count += obj.c; }\"}"
+  end
+
+  it "should trace create, ensure and drop index" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.create_index("i")
+      coll.ensure_index("i")
+      coll.drop_index("i_1")
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 8
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "create_index"
+
+    validate_event_keys(traces[3], @entry_kvs)
+    validate_event_keys(traces[4], @exit_kvs)
+
+    traces[3]['Collection'].must_equal "testCollection"
+    traces[3].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[3]['QueryOp'].must_equal "ensure_index"
+
+    validate_event_keys(traces[5], @entry_kvs)
+    validate_event_keys(traces[6], @exit_kvs)
+
+    traces[5]['Collection'].must_equal "testCollection"
+    traces[5].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[5]['QueryOp'].must_equal "drop_index"
+  end
+  
+  it "should trace drop_indexes" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.drop_indexes
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "drop_indexes"
+  end
+  
+  it "should trace index_information" do
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      coll.index_information
+    end
+    
+    traces = get_all_traces
+    traces.count.must_equal 4
+
+    validate_outer_layers(traces, 'mongo_test')
+    validate_event_keys(traces[1], @entry_kvs)
+    validate_event_keys(traces[2], @exit_kvs)
+    
+    traces[1]['Collection'].must_equal "testCollection"
+    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:mongo][:collect_backtraces]
+    traces[1]['QueryOp'].must_equal "index_information"
+  end
+  
+  it "should obey :collect_backtraces setting when true" do
+    Oboe::Config[:mongo][:collect_backtraces] = true
+    
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      doc = {"name" => "MyName", "type" => "MyType", "count" => 1, "info" => {"x" => 203, "y" => '102'}}
+      id = coll.insert(doc)
+    end
+
+    traces = get_all_traces
+    layer_has_key(traces, 'mongo', 'Backtrace')
+  end
+
+  it "should obey :collect_backtraces setting when false" do
+    Oboe::Config[:mongo][:collect_backtraces] = false
+    
+    coll = @db.collection("testCollection")
+
+    Oboe::API.start_trace('mongo_test', '', {}) do
+      doc = {"name" => "MyName", "type" => "MyType", "count" => 1, "info" => {"x" => 203, "y" => '102'}}
+      id = coll.insert(doc)
+    end
+
+    traces = get_all_traces
+    layer_doesnt_have_key(traces, 'mongo', 'Backtrace')
+  end
+end