oboe 2.6.8 → 2.7.0.3

data/lib/oboe.rb

@@ -12,11 +12,11 @@ begin
   unless defined?(Oboe_metal)
     begin
       if RUBY_PLATFORM == 'java'
-        require 'joboe_metal'
         require '/usr/local/tracelytics/tracelyticsagent.jar'
+        require 'joboe_metal'
       else
-        require 'oboe_metal'
         require 'oboe_metal.so'
+        require 'oboe_metal'
       end
     rescue LoadError
       Oboe.loaded = false

data/lib/oboe/api/logging.rb

@@ -62,7 +62,7 @@ module Oboe
       def log_start(layer, xtrace, opts={})
         return if Oboe.never? or (opts.has_key?(:URL) and ::Oboe::Util.static_asset?(opts[:URL]))
 
-        if xtrace
+        if xtrace and not xtrace.to_s.empty?
           Oboe::Context.fromString(xtrace)
         end
 
@@ -86,12 +86,12 @@ module Oboe
       end
 
       def log_entry(layer, opts={}, protect_op=nil)
-        Oboe::Context.layer_op = protect_op if protect_op
+        Oboe.layer_op = protect_op if protect_op
         log_event(layer, 'entry', Oboe::Context.createEvent, opts)
       end
 
       def log_exit(layer, opts={}, protect_op=nil)
-        Oboe::Context.layer_op = nil if protect_op
+        Oboe.layer_op = nil if protect_op
         log_event(layer, 'exit', Oboe::Context.createEvent, opts)
       end
 

data/lib/oboe/api/tracing.rb

@@ -11,7 +11,7 @@ module Oboe
       # layer - The layer the block of code belongs to.
       # opts - A hash containing key/value pairs that will be reported along
       # with the first event of this layer (optional).
-      # protect_op - specify the operating being traced.  Used to avoid
+      # protect_op - specify the operation being traced.  Used to avoid
       # double tracing between operations that call each other
       #
       # Example
@@ -73,7 +73,7 @@ module Oboe
       # Returns a list of length two, the first element of which is the result
       # of the block, and the second element of which is the oboe context that
       # was set when the block completed execution.
-      def start_trace(layer, xtrace, opts={})
+      def start_trace(layer, xtrace=nil, opts={})
         log_start(layer, xtrace, opts)
         begin
           result = yield

data/lib/oboe/frameworks/padrino/templates.rb

@@ -21,7 +21,7 @@ module Oboe
             report_kvs[:template] = engine
           end
 
-          if Oboe::Context.tracing_layer_op?('render')
+          if Oboe.tracing_layer_op?('render')
             # For recursive calls to :render (for sub-partials and layouts),
             # use method profiling.
             begin

data/lib/oboe/frameworks/sinatra/templates.rb

@@ -15,7 +15,7 @@ module Oboe
           report_kvs[:engine] = engine
           report_kvs[:template] = data
 
-          if Oboe::Context.tracing_layer_op?('render')
+          if Oboe.tracing_layer_op?('render')
             # For recursive calls to :render (for sub-partials and layouts),
             # use method profiling.
             begin

data/lib/oboe/inst/cassandra.rb

@@ -77,7 +77,7 @@ module Oboe
       def get_columns_with_oboe(column_family, key, *columns_and_options)
         args = [column_family, key] + columns_and_options
 
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:multi_get_columns)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:multi_get_columns)
           report_kvs = extract_trace_details(:get_columns, column_family, key, columns_and_options)
 
           Oboe::API.trace('cassandra', report_kvs) do
@@ -113,7 +113,7 @@ module Oboe
       def multi_get_with_oboe(column_family, key, *columns_and_options)
         args = [column_family, key] + columns_and_options
 
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:get)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:get)
           report_kvs = extract_trace_details(:multi_get, column_family, key, columns_and_options)
 
           Oboe::API.trace('cassandra', report_kvs) do
@@ -136,7 +136,7 @@ module Oboe
       end
 
       def get_range_single_with_oboe(column_family, options = {})
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:get_range_batch)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:get_range_batch)
           report_kvs = extract_trace_details(:get_range_single, column_family, nil, nil)
           args = [column_family, options]
 

data/lib/oboe/inst/dalli.rb

@@ -25,7 +25,7 @@ module Oboe
       def perform_with_oboe(*all_args, &blk)
         op, key, *args = *all_args
 
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:get_multi)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:get_multi)
           Oboe::API.trace('memcache', { :KVOp => op, :KVKey => key }) do
             result = perform_without_oboe(*all_args, &blk)
 

data/lib/oboe/inst/memcache.rb

@@ -70,7 +70,7 @@ module Oboe
       end
 
       def request_setup_with_oboe(*args)
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:get_multi)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:get_multi)
           server, cache_key = request_setup_without_oboe(*args)
 
           info_kvs = { :KVKey => cache_key, :RemoteHost => server.host }

data/lib/oboe/inst/moped.rb

@@ -37,7 +37,12 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
           begin
             report_kvs[:Flavor] = Oboe::Inst::Moped::FLAVOR
             # FIXME: We're only grabbing the first of potentially multiple servers here
-            report_kvs[:RemoteHost], report_kvs[:RemotePort] = session.cluster.seeds.first.split(':')
+            if ::Moped::VERSION < "2.0.0"
+              report_kvs[:RemoteHost], report_kvs[:RemotePort] = session.cluster.seeds.first.split(':')
+            else
+              report_kvs[:RemoteHost] = session.cluster.seeds.first.address.host
+              report_kvs[:RemotePort] = session.cluster.seeds.first.address.port
+            end
             report_kvs[:Database] = name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
@@ -48,7 +53,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
 
         def command_with_oboe(command)
-          if Oboe.tracing? and not Oboe::Context.layer_op and command.has_key?(:mapreduce)
+          if Oboe.tracing? and not Oboe.layer_op and command.has_key?(:mapreduce)
             begin
               report_kvs = extract_trace_details(:map_reduce)
               report_kvs[:Map_Function] = command[:map]
@@ -96,7 +101,12 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
           begin
             report_kvs[:Flavor] = Oboe::Inst::Moped::FLAVOR
             # FIXME: We're only grabbing the first of potentially multiple servers here
-            report_kvs[:RemoteHost], report_kvs[:RemotePort] = database.session.cluster.seeds.first.split(':')
+            if ::Moped::VERSION < "2.0.0"
+              report_kvs[:RemoteHost], report_kvs[:RemotePort] = database.session.cluster.seeds.first.split(':')
+            else
+              report_kvs[:RemoteHost] = database.session.cluster.seeds.first.address.host
+              report_kvs[:RemotePort] = database.session.cluster.seeds.first.address.port
+            end
             report_kvs[:Database] = database.name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
@@ -162,7 +172,12 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
           begin
             report_kvs[:Flavor] = Oboe::Inst::Moped::FLAVOR
             # FIXME: We're only grabbing the first of potentially multiple servers here
-            report_kvs[:RemoteHost], report_kvs[:RemotePort] = collection.database.session.cluster.seeds.first.split(':')
+            if ::Moped::VERSION < "2.0.0"
+              report_kvs[:RemoteHost], report_kvs[:RemotePort] = collection.database.session.cluster.seeds.first.split(':')
+            else
+              report_kvs[:RemoteHost] = collection.database.session.cluster.seeds.first.address.host
+              report_kvs[:RemotePort] = collection.database.session.cluster.seeds.first.address.port
+            end
             report_kvs[:Database] = collection.database.name
             report_kvs[:Collection] = collection.name
             report_kvs[:QueryOp] = op.to_s
@@ -205,7 +220,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
 
         def limit_with_oboe(limit)
-          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:explain)
+          if Oboe.tracing? and not Oboe.tracing_layer_op?(:explain)
             begin
               report_kvs = extract_trace_details(:limit)
               report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
@@ -239,7 +254,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
 
         def update_with_oboe(change, flags = nil)
-          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?([:update_all, :upsert])
+          if Oboe.tracing? and not Oboe.tracing_layer_op?([:update_all, :upsert])
             begin
               report_kvs = extract_trace_details(:update)
               report_kvs[:Flags] = flags.to_s if flags
@@ -371,9 +386,14 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
           begin
             report_kvs[:Flavor] = Oboe::Inst::Moped::FLAVOR
             # FIXME: We're only grabbing the first of potentially multiple servers here
-            report_kvs[:RemoteHost], report_kvs[:RemotePort] = @database.session.cluster.seeds.first.split(':')
-            report_kvs[:Database] = @database.name
-            report_kvs[:Collection] = @name
+            if ::Moped::VERSION < "2.0.0"
+              report_kvs[:RemoteHost], report_kvs[:RemotePort] = database.session.cluster.seeds.first.split(':')
+            else
+              report_kvs[:RemoteHost] = database.session.cluster.seeds.first.address.host
+              report_kvs[:RemotePort] = database.session.cluster.seeds.first.address.port
+            end
+            report_kvs[:Database] = database.name
+            report_kvs[:Collection] = name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
           rescue StandardError => e
@@ -420,7 +440,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
 
         def insert_with_oboe(documents, flags = nil)
-          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:create_index)
+          if Oboe.tracing? and not Oboe.tracing_layer_op?(:create_index)
             report_kvs = extract_trace_details(:insert)
 
             Oboe::API.trace('mongo', report_kvs) do

data/lib/oboe/inst/resque.rb

@@ -51,7 +51,7 @@ module Oboe
       end
 
       def enqueue_to_with_oboe(queue, klass, *args)
-        if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:enqueue)
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:enqueue)
           report_kvs = extract_trace_details(:enqueue_to, klass, args)
           report_kvs[:Queue] = queue.to_s if queue
 

data/lib/oboe/version.rb

@@ -4,9 +4,9 @@
 module Oboe
   module Version
     MAJOR = 2
-    MINOR = 6
-    PATCH = 8
-    BUILD = nil
+    MINOR = 7
+    PATCH = 0
+    BUILD = 3
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end

data/lib/oboe_metal.rb

@@ -38,6 +38,41 @@ module Oboe
     def self.sendReport(evt)
       Oboe.reporter.sendReport(evt)
     end
+
+    ##
+    # clear_all_traces
+    #
+    # Truncates the trace output file to zero
+    #
+    def self.clear_all_traces
+      File.truncate($trace_file, 0)
+    end
+
+    ##
+    # get_all_traces
+    #
+    # Retrieves all traces written to the trace file
+    #
+    def self.get_all_traces
+      io = File.open($trace_file, "r")
+      contents = io.readlines(nil)
+
+      return contents if contents.empty?
+
+      s = StringIO.new(contents[0])
+
+      traces = []
+
+      until s.eof?
+        if ::BSON.respond_to? :read_bson_document
+          traces << BSON.read_bson_document(s)
+        else
+          traces << BSON::Document.from_bson(s)
+        end
+      end
+
+      traces
+    end
   end
 
   class Event

data/oboe.gemspec

@@ -12,13 +12,14 @@ Gem::Specification.new do |s|
   s.email = %q{traceviewsupport@appneta.com}
   s.homepage = %q{http://www.appneta.com/products/traceview/}
   s.summary = %q{AppNeta TraceView performance instrumentation gem for Ruby}
-  s.description = %q{The oboe gem provides TraceView instrumentation for Ruby and Ruby frameworks.}
+  s.description = %q{The oboe gem provides TraceView instrumentation for MRI Ruby, JRuby and related frameworks.}
 
   s.extra_rdoc_files = ["LICENSE"]
   s.files = `git ls-files`.split("\n")
   s.test_files  = Dir.glob("{test}/**/*.rb")
-    
-  s.extensions = ['ext/oboe_metal/extconf.rb']
+
+  s.platform   = defined?(JRUBY_VERSION) ? 'java' : Gem::Platform::RUBY
+  s.extensions = ['ext/oboe_metal/extconf.rb'] unless defined?(JRUBY_VERSION)
 
   s.add_runtime_dependency('json', '>= 0')
   s.add_development_dependency('rake', '>= 0')

data/test/frameworks/apps/grape_simple.rb

@@ -8,5 +8,3 @@ class GrapeSimple < Grape::API
   end
 end
 
-use GrapeSimple
-

data/test/instrumentation/cassandra_test.rb

@@ -1,377 +1,381 @@
 require 'minitest_helper'
 
-describe Oboe::Inst::Cassandra do
-  before do
-    clear_all_traces
-
-    @client = Cassandra.new("system", "127.0.0.1:9160", { :timeout => 10 })
-    @client.disable_node_auto_discovery!
-
-    @ks_name = "AppNetaCassandraTest"
-
-    ks_def = CassandraThrift::KsDef.new(:name => @ks_name,
-              :strategy_class => "SimpleStrategy",
-              :strategy_options => { 'replication_factor' => '2' },
-              :cf_defs => [])
-
-    @client.add_keyspace(ks_def) unless @client.keyspaces.include? @ks_name
-    @client.keyspace = @ks_name
-
-    unless @client.column_families.include? "Users"
-      cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => "Users")
-      @client.add_column_family(cf_def)
+# The cassandra-rb client doesn't support JRuby
+# https://github.com/cassandra-rb/cassandra
+unless defined?(JRUBY_VERSION)
+  describe Oboe::Inst::Cassandra do
+    before do
+      clear_all_traces
+
+      @client = Cassandra.new("system", "127.0.0.1:9160", { :timeout => 10 })
+      @client.disable_node_auto_discovery!
+
+      @ks_name = "AppNetaCassandraTest"
+
+      ks_def = CassandraThrift::KsDef.new(:name => @ks_name,
+                :strategy_class => "SimpleStrategy",
+                :strategy_options => { 'replication_factor' => '2' },
+                :cf_defs => [])
+
+      @client.add_keyspace(ks_def) unless @client.keyspaces.include? @ks_name
+      @client.keyspace = @ks_name
+
+      unless @client.column_families.include? "Users"
+        cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => "Users")
+        @client.add_column_family(cf_def)
+      end
+
+      unless @client.column_families.include? "Statuses"
+        cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => "Statuses")
+        @client.add_column_family(cf_def)
+      end
+
+      # These are standard entry/exit KVs that are passed up with all mongo operations
+      @entry_kvs = {
+        'Layer' => 'cassandra',
+        'Label' => 'entry',
+        'RemoteHost' => '127.0.0.1',
+        'RemotePort' => '9160' }
+
+      @exit_kvs = { 'Layer' => 'cassandra', 'Label' => 'exit' }
+      @collect_backtraces = Oboe::Config[:cassandra][:collect_backtraces]
     end
 
-    unless @client.column_families.include? "Statuses"
-      cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => "Statuses")
-      @client.add_column_family(cf_def)
+    after do
+      Oboe::Config[:cassandra][:collect_backtraces] = @collect_backtraces
+      @client.disconnect!
     end
 
-    # These are standard entry/exit KVs that are passed up with all mongo operations
-    @entry_kvs = {
-      'Layer' => 'cassandra',
-      'Label' => 'entry',
-      'RemoteHost' => '127.0.0.1',
-      'RemotePort' => '9160' }
-
-    @exit_kvs = { 'Layer' => 'cassandra', 'Label' => 'exit' }
-    @collect_backtraces = Oboe::Config[:cassandra][:collect_backtraces]
-  end
-
-  after do
-    Oboe::Config[:cassandra][:collect_backtraces] = @collect_backtraces
-    @client.disconnect!
-  end
-
-  it 'Stock Cassandra should be loaded, defined and ready' do
-    defined?(::Cassandra).wont_match nil
-  end
+    it 'Stock Cassandra should be loaded, defined and ready' do
+      defined?(::Cassandra).wont_match nil
+    end
 
-  it 'Cassandra should have oboe methods defined' do
-    [ :insert, :remove, :count_columns, :get_columns, :multi_get_columns, :get,
-      :multi_get, :get_range_single, :get_range_batch, :get_indexed_slices,
-      :create_index, :drop_index, :add_column_family, :drop_column_family,
-      :add_keyspace, :drop_keyspace ].each do |m|
-      ::Cassandra.method_defined?("#{m}_with_oboe").must_equal true
+    it 'Cassandra should have oboe methods defined' do
+      [ :insert, :remove, :count_columns, :get_columns, :multi_get_columns, :get,
+        :multi_get, :get_range_single, :get_range_batch, :get_indexed_slices,
+        :create_index, :drop_index, :add_column_family, :drop_column_family,
+        :add_keyspace, :drop_keyspace ].each do |m|
+        ::Cassandra.method_defined?("#{m}_with_oboe").must_equal true
+      end
+      # Special 'exists?' case
+      ::Cassandra.method_defined?("exists_with_oboe?").must_equal true
     end
-    # Special 'exists?' case
-    ::Cassandra.method_defined?("exists_with_oboe?").must_equal true
-  end
 
-  it 'should trace insert' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      user = {'screen_name' => 'larry', "blah" => "ok"}
-      @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+    it 'should trace insert' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        user = {'screen_name' => 'larry', "blah" => "ok"}
+        @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "insert"
+      traces[1]['Cf'].must_equal "Users"
+      traces[1]['Key'].must_equal "\"5\""
+      traces[1]['Consistency'].must_equal "1"
+      traces[1]['Ttl'].must_equal "600"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace remove' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.remove(:Users, '5', 'blah')
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "insert"
-    traces[1]['Cf'].must_equal "Users"
-    traces[1]['Key'].must_equal "\"5\""
-    traces[1]['Consistency'].must_equal "1"
-    traces[1]['Ttl'].must_equal "600"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace remove' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.remove(:Users, '5', 'blah')
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "remove"
+      traces[1]['Cf'].must_equal "Users"
+      traces[1]['Key'].must_equal "\"5\""
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace count_columns' do
+      @client.insert(:Statuses, '12', {'body' => 'v1', 'user' => 'v2'})
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.count_columns(:Statuses, '12', :count => 50)
+      end
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "remove"
-    traces[1]['Cf'].must_equal "Users"
-    traces[1]['Key'].must_equal "\"5\""
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces = get_all_traces
 
-  it 'should trace count_columns' do
-    @client.insert(:Statuses, '12', {'body' => 'v1', 'user' => 'v2'})
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.count_columns(:Statuses, '12', :count => 50)
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "count_columns"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Key'].must_equal "\"12\""
+      traces[1]['Count'].must_equal "50"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace get_columns' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.get_columns(:Statuses, '12', ['body'])
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "count_columns"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Key'].must_equal "\"12\""
-    traces[1]['Count'].must_equal "50"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace get_columns' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.get_columns(:Statuses, '12', ['body'])
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "get_columns"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Key'].must_equal "\"12\""
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace multi_get_columns' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.multi_get_columns(:Users, ['12', '5'], ['body'])
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "get_columns"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Key'].must_equal "\"12\""
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace multi_get_columns' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.multi_get_columns(:Users, ['12', '5'], ['body'])
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "multi_get_columns"
+      traces[1]['Cf'].must_equal "Users"
+      traces[1]['Key'].must_equal "[\"12\", \"5\"]"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace get' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.get(:Statuses, '12', :reversed => true)
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "multi_get_columns"
-    traces[1]['Cf'].must_equal "Users"
-    traces[1]['Key'].must_equal "[\"12\", \"5\"]"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace get' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.get(:Statuses, '12', :reversed => true)
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "get"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Key'].must_equal "\"12\""
+      traces[1]['Reversed'].must_equal "true"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
-
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
-
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "get"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Key'].must_equal "\"12\""
-    traces[1]['Reversed'].must_equal "true"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
-
-  it 'should trace exists?' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.exists?(:Statuses, '12')
-      @client.exists?(:Statuses, '12', 'body')
-    end
+    it 'should trace exists?' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.exists?(:Statuses, '12')
+        @client.exists?(:Statuses, '12', 'body')
+      end
 
-    traces = get_all_traces
+      traces = get_all_traces
 
-    traces.count.must_equal 6
-    validate_outer_layers(traces, 'cassandra_test')
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'cassandra_test')
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "exists?"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Key'].must_equal "\"12\""
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "exists?"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Key'].must_equal "\"12\""
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
 
-    traces[3]['Op'].must_equal "exists?"
-    traces[3]['Cf'].must_equal "Statuses"
-    traces[3]['Key'].must_equal "\"12\""
-    traces[3].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-  end
-
-  it 'should trace get_range_keys' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.get_range_keys(:Statuses, :key_count => 4)
+      traces[3]['Op'].must_equal "exists?"
+      traces[3]['Cf'].must_equal "Statuses"
+      traces[3]['Key'].must_equal "\"12\""
+      traces[3].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
     end
 
-    traces = get_all_traces
+    it 'should trace get_range_keys' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.get_range_keys(:Statuses, :key_count => 4)
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "get_range_batch"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace create_index' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "get_range_batch"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
-
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+    it 'should trace create_index' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
+      end
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "create_index"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Keyspace'].must_equal @ks_name
-    traces[1]['Column_name'].must_equal "column_name"
-    traces[1]['Validation_class'].must_equal "LongType"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
+      traces = get_all_traces
 
-    # Clean up
-    @client.drop_index(@ks_name, 'Statuses', 'column_name')
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace drop_index' do
-    # Prep
-    @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "create_index"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Keyspace'].must_equal @ks_name
+      traces[1]['Column_name'].must_equal "column_name"
+      traces[1]['Validation_class'].must_equal "LongType"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
 
-    Oboe::API.start_trace('cassandra_test', '', {}) do
+      # Clean up
       @client.drop_index(@ks_name, 'Statuses', 'column_name')
     end
 
-    traces = get_all_traces
+    it 'should trace drop_index' do
+      # Prep
+      @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.drop_index(@ks_name, 'Statuses', 'column_name')
+      end
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "drop_index"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1]['Keyspace'].must_equal @ks_name
-    traces[1]['Column_name'].must_equal "column_name"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces = get_all_traces
 
-  it 'should trace get_indexed_slices' do
-    @client.create_index(@ks_name, 'Statuses', 'x', 'LongType')
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      expressions   =  [
-                         { :column_name => 'x',
-                           :value => [0,20].pack("NN"),
-                           :comparison => "=="},
-                         { :column_name => 'non_indexed',
-                           :value => [5].pack("N*"),
-                           :comparison => ">"} ]
-      @client.get_indexed_slices(:Statuses, expressions).length
-    end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-    traces = get_all_traces
-
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "drop_index"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1]['Keyspace'].must_equal @ks_name
+      traces[1]['Column_name'].must_equal "column_name"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "get_indexed_slices"
-    traces[1]['Cf'].must_equal "Statuses"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+    it 'should trace get_indexed_slices' do
+      @client.create_index(@ks_name, 'Statuses', 'x', 'LongType')
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        expressions   =  [
+                           { :column_name => 'x',
+                             :value => [0,20].pack("NN"),
+                             :comparison => "=="},
+                           { :column_name => 'non_indexed',
+                             :value => [5].pack("N*"),
+                             :comparison => ">"} ]
+        @client.get_indexed_slices(:Statuses, expressions).length
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "get_indexed_slices"
+      traces[1]['Cf'].must_equal "Statuses"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
 
-  it 'should trace add and remove of column family' do
-    cf_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
-    cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => cf_name)
+    it 'should trace add and remove of column family' do
+      cf_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
+      cf_def = CassandraThrift::CfDef.new(:keyspace => @ks_name, :name => cf_name)
 
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.add_column_family(cf_def)
-      @client.drop_column_family(cf_name)
-    end
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.add_column_family(cf_def)
+        @client.drop_column_family(cf_name)
+      end
 
-    traces = get_all_traces
+      traces = get_all_traces
 
-    traces.count.must_equal 6
-    validate_outer_layers(traces, 'cassandra_test')
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'cassandra_test')
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "add_column_family"
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "add_column_family"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
 
-    traces[3]['Op'].must_equal "drop_column_family"
-    traces[3]['Cf'].must_equal cf_name
-    traces[3].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-  end
+      traces[3]['Op'].must_equal "drop_column_family"
+      traces[3]['Cf'].must_equal cf_name
+      traces[3].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+    end
 
-  it 'should trace adding a keyspace' do
-    ks_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
-    column_families = [{:name =>"a"}, {:name => "b", :type => :super}]
-    ks_def = CassandraThrift::KsDef.new(:name => ks_name,
-              :strategy_class => "org.apache.cassandra.locator.SimpleStrategy",
-              :strategy_options => { 'replication_factor' => '2' },
-              :cf_defs => [])
-
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.add_keyspace(ks_def)
-      @client.keyspace = ks_name
+    it 'should trace adding a keyspace' do
+      ks_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
+      column_families = [{:name =>"a"}, {:name => "b", :type => :super}]
+      ks_def = CassandraThrift::KsDef.new(:name => ks_name,
+                :strategy_class => "org.apache.cassandra.locator.SimpleStrategy",
+                :strategy_options => { 'replication_factor' => '2' },
+                :cf_defs => [])
+
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.add_keyspace(ks_def)
+        @client.keyspace = ks_name
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "add_keyspace"
+      traces[1]['Name'].must_equal ks_name
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it 'should trace the removal of a keyspace' do
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        @client.drop_keyspace(@ks_name)
+      end
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      traces = get_all_traces
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "add_keyspace"
-    traces[1]['Name'].must_equal ks_name
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'cassandra_test')
 
-  it 'should trace the removal of a keyspace' do
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      @client.drop_keyspace(@ks_name)
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Op'].must_equal "drop_keyspace"
+      traces[1]['Name'].must_equal @ks_name
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
     end
 
-    traces = get_all_traces
+    it "should obey :collect_backtraces setting when true" do
+      Oboe::Config[:cassandra][:collect_backtraces] = true
 
-    traces.count.must_equal 4
-    validate_outer_layers(traces, 'cassandra_test')
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        user = {'screen_name' => 'larry', "blah" => "ok"}
+        @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+      end
 
-    validate_event_keys(traces[1], @entry_kvs)
-    traces[1]['Op'].must_equal "drop_keyspace"
-    traces[1]['Name'].must_equal @ks_name
-    traces[1].has_key?('Backtrace').must_equal Oboe::Config[:cassandra][:collect_backtraces]
-    validate_event_keys(traces[2], @exit_kvs)
-  end
-
-  it "should obey :collect_backtraces setting when true" do
-    Oboe::Config[:cassandra][:collect_backtraces] = true
-
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      user = {'screen_name' => 'larry', "blah" => "ok"}
-      @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+      traces = get_all_traces
+      layer_has_key(traces, 'cassandra', 'Backtrace')
     end
 
-    traces = get_all_traces
-    layer_has_key(traces, 'cassandra', 'Backtrace')
-  end
+    it "should obey :collect_backtraces setting when false" do
+      Oboe::Config[:cassandra][:collect_backtraces] = false
 
-  it "should obey :collect_backtraces setting when false" do
-    Oboe::Config[:cassandra][:collect_backtraces] = false
+      Oboe::API.start_trace('cassandra_test', '', {}) do
+        user = {'screen_name' => 'larry', "blah" => "ok"}
+        @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+      end
 
-    Oboe::API.start_trace('cassandra_test', '', {}) do
-      user = {'screen_name' => 'larry', "blah" => "ok"}
-      @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
+      traces = get_all_traces
+      layer_doesnt_have_key(traces, 'cassandra', 'Backtrace')
     end
 
-    traces = get_all_traces
-    layer_doesnt_have_key(traces, 'cassandra', 'Backtrace')
   end
-
 end