appoptics_apm 4.0.3 → 4.0.4

data/test/instrumentation/sidekiq-client_test.rb

@@ -1,159 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-if RUBY_VERSION >= '2.0' && !defined?(JRUBY_VERSION)
-  require 'minitest_helper'
-  require 'sidekiq'
-  require_relative "../jobs/sidekiq/remote_call_worker_job"
-  require_relative "../jobs/sidekiq/db_worker_job"
-  require_relative "../jobs/sidekiq/error_worker_job"
-
-  class SidekiqClientTest < Minitest::Test
-    def setup
-      clear_all_traces
-      AppOpticsAPM::Context.clear
-      @collect_backtraces = AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces]
-      @log_args = AppOpticsAPM::Config[:sidekiqclient][:log_args]
-      @tracing_mode = AppOpticsAPM::Config[:tracing_mode]
-    end
-
-    def teardown
-      AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces] = @collect_backtraces
-      AppOpticsAPM::Config[:sidekiqclient][:log_args] = @log_args
-      AppOpticsAPM::Config[:tracing_mode] = @tracing_mode
-    end
-
-    def refined_trace_count(traces)
-      # we expect 23 traces, but it looks like there are cases where an extra 2 or 4 redis traces slip in
-      # This method will allow the tests to pass despite the inconsistency in counts and also log some information
-
-      redis_traces = traces.select { |h| h['Layer'] == 'redis' }
-      traces.count - redis_traces.count
-    end
-
-    def test_enqueue
-      # Queue up a job to be run
-      jid, _ = ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 21, refined_trace_count(traces)
-      assert valid_edges?(traces), "Invalid edge in traces"
-
-      assert_equal 'sidekiq-client',       traces[1]['Layer']
-      assert_equal 'entry',                traces[1]['Label']
-
-      assert_equal 'pushq',                traces[1]['Spec']
-      assert_equal 'sidekiq',              traces[1]['Flavor']
-      assert_equal 'critical',             traces[1]['Queue']
-      assert_equal jid,                    traces[1]['MsgID']
-      assert_equal '[1, 2, 3]',            traces[1]['Args']
-      assert_equal "RemoteCallWorkerJob",  traces[1]['JobName']
-      assert_equal 'false',                traces[1]['Retry']
-      assert_equal false,                  traces[1].key?('Backtrace')
-
-      assert_equal 'sidekiq-client',       traces[2]['Layer']
-      assert_equal 'exit',                 traces[2]['Label']
-    end
-
-    def test_collect_backtraces_default_value
-      assert_equal AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces], false, "default backtrace collection"
-    end
-
-    def test_log_args_default_value
-      assert_equal AppOpticsAPM::Config[:sidekiqclient][:log_args], true, "log_args default "
-    end
-
-    def test_obey_collect_backtraces_when_false
-      AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces] = false
-
-      # Queue up a job to be run
-      ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 21, refined_trace_count(traces)
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal 'sidekiq-client',   traces[1]['Layer']
-      assert_equal false,              traces[1].key?('Backtrace')
-    end
-
-    def test_obey_collect_backtraces_when_true
-      AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces] = true
-
-      # Queue up a job to be run
-      ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 21, refined_trace_count(traces)
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal 'sidekiq-client',   traces[1]['Layer']
-      assert_equal true,               traces[1].key?('Backtrace')
-    end
-
-    def test_obey_log_args_when_false
-      AppOpticsAPM::Config[:sidekiqclient][:log_args] = false
-
-      # Queue up a job to be run
-      ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 21, refined_trace_count(traces)
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal false, traces[1].key?('Args')
-    end
-
-    def test_obey_log_args_when_true
-      AppOpticsAPM::Config[:sidekiqclient][:log_args] = true
-
-      # Queue up a job to be run
-      ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 21, refined_trace_count(traces)
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal true,         traces[1].key?('Args')
-      assert_equal '[1, 2, 3]',  traces[1]['Args']
-    end
-
-    def test_dont_log_when_not_sampling
-      AppOpticsAPM::Config[:sidekiqclient][:log_args] = true
-      AppOpticsAPM::Config[:tracing_mode] = 'never'
-
-      ::AppOpticsAPM::API.start_trace(:enqueue_test) do
-        Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-      end
-
-      sleep 3
-      traces = get_all_traces
-
-      # FIXME: the sidekiq worker is not respecting the AppOpticsAPM::Config[:tracing_mode] = 'never' setting
-      # ____ instead of no traces we are getting 17, that is 4 less than we would get with tracing
-      # assert_equal 0, traces.count
-      assert_equal 17, refined_trace_count(traces)
-    end
-  end
-end

data/test/instrumentation/sidekiq-worker_test.rb

@@ -1,180 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-if RUBY_VERSION >= '2.0' && !defined?(JRUBY_VERSION)
-  require 'minitest_helper'
-  require 'sidekiq'
-  require_relative "../jobs/sidekiq/remote_call_worker_job"
-  require_relative "../jobs/sidekiq/db_worker_job"
-  require_relative "../jobs/sidekiq/error_worker_job"
-
-  class SidekiqWorkerTest < Minitest::Test
-    def setup
-      clear_all_traces
-      @collect_backtraces = AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces]
-      @log_args = AppOpticsAPM::Config[:sidekiqworker][:log_args]
-    end
-
-    def teardown
-      AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces] = @collect_backtraces
-      AppOpticsAPM::Config[:sidekiqworker][:log_args] = @log_args
-    end
-
-    def test_reports_version_init
-      init_kvs = ::AppOpticsAPM::Util.build_init_report
-      assert init_kvs.key?('Ruby.sidekiq.Version')
-      assert_equal ::Sidekiq::VERSION, init_kvs['Ruby.sidekiq.Version']
-    end
-
-    def test_job_run
-      # Queue up a job to be run
-      jid = Sidekiq::Client.push('queue' => 'critical', 'class' => RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 17, traces.count, "Trace count"
-      validate_outer_layers(traces, "sidekiq-worker")
-      assert valid_edges?(traces), "Invalid edge in traces"
-
-      # Validate entry layer KVs
-      assert_equal 'always_sampled', traces[0]['TraceOrigin'],       "is always_sampled"
-      assert_equal true,             traces[0].key?('SampleRate'),   "has SampleRate KV"
-      assert_equal true,             traces[0].key?('SampleSource'), "has SampleSource KV"
-
-      # Validate Webserver Spec KVs
-      assert_equal Socket.gethostname,    traces[0]['HTTP-Host']
-      assert_equal "Sidekiq_critical",    traces[0]['Controller']
-      assert_equal "RemoteCallWorkerJob", traces[0]['Action']
-      assert_equal "/sidekiq/critical/RemoteCallWorkerJob", traces[0]['URL']
-
-      # Validate Job Spec KVs
-      assert_equal "job",                 traces[0]['Spec']
-      assert_equal 'sidekiq',             traces[0]['Flavor']
-      assert_equal "RemoteCallWorkerJob", traces[0]['JobName']
-      assert_equal jid,                   traces[0]['MsgID']
-      assert_equal "critical",            traces[0]['Queue']
-      assert_equal "[1, 2, 3]",           traces[0]['Args']
-      assert_equal "false",               traces[0]['Retry']
-
-      assert_equal false,                 traces[0].key?('Backtrace')
-      assert_equal "net-http",            traces[4]['Layer']
-      assert_equal "entry",               traces[4]['Label']
-      assert_equal "memcache",            traces[15]['Layer']
-    end
-
-    def test_jobs_with_errors
-      # Queue up a job to be run
-      jid = Sidekiq::Client.push('queue' => 'critical', 'class' => ErrorWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 3, traces.count, "Trace count"
-      validate_outer_layers(traces, "sidekiq-worker")
-      assert valid_edges?(traces), "Invalid edge in traces"
-
-      # Validate Webserver Spec KVs
-      assert_equal Socket.gethostname,                  traces[0]['HTTP-Host']
-      assert_equal "Sidekiq_critical",                  traces[0]['Controller']
-      assert_equal "ErrorWorkerJob",                    traces[0]['Action']
-      assert_equal "/sidekiq/critical/ErrorWorkerJob",  traces[0]['URL']
-
-      # Validate Job Spec KVs
-      assert_equal "job",             traces[0]['Spec']
-      assert_equal 'sidekiq',         traces[0]['Flavor']
-      assert_equal "ErrorWorkerJob",  traces[0]['JobName']
-      assert_equal jid,               traces[0]['MsgID']
-      assert_equal "critical",        traces[0]['Queue']
-      assert_equal "[1, 2, 3]",       traces[0]['Args']
-      assert_equal "false",           traces[0]['Retry']
-
-      assert_equal traces[1]['Layer'], 'sidekiq-worker'
-      assert_equal traces[1]['Label'], 'error'
-      assert_equal traces[1]['ErrorClass'], "RuntimeError"
-      assert traces[1].key?('ErrorMsg')
-      assert traces[1].key?('Backtrace')
-    end
-
-    def test_collect_backtraces_default_value
-      assert_equal AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces], false, "default backtrace collection"
-    end
-
-    def test_log_args_default_value
-      assert_equal AppOpticsAPM::Config[:sidekiqworker][:log_args], true, "log_args default "
-    end
-
-    def test_obey_collect_backtraces_when_false
-      AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces] = false
-
-      # Queue up a job to be run
-      Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 17, traces.count, "Trace count"
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal 'sidekiq-worker',   traces[0]['Layer']
-      assert_equal false,              traces[0].key?('Backtrace')
-    end
-
-    def test_obey_collect_backtraces_when_true
-      # FIXME: This can't be tested with the current Sidekiq minitest integration (e.g. already booted
-      # sidekiq in a different process)
-      skip
-
-      AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces] = true
-
-      # Queue up a job to be run
-      Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 17, traces.count, "Trace count"
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal 'sidekiq-worker',   traces[0]['Layer']
-      assert_equal true,               traces[0].key?('Backtrace')
-    end
-
-    def test_obey_log_args_when_false
-      # FIXME: This can't be tested with the current Sidekiq minitest integration (e.g. already booted
-      # sidekiq in a different process)
-      skip
-
-      AppOpticsAPM::Config[:sidekiqworker][:log_args] = false
-
-      # Queue up a job to be run
-      Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 17, traces.count, "Trace count"
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal false, traces[0].key?('Args')
-    end
-
-    def test_obey_log_args_when_true
-      AppOpticsAPM::Config[:sidekiqworker][:log_args] = true
-
-      # Queue up a job to be run
-      Sidekiq::Client.push('queue' => 'critical', 'class' => ::RemoteCallWorkerJob, 'args' => [1, 2, 3], 'retry' => false)
-
-      # Allow the job to be run
-      sleep 5
-
-      traces = get_all_traces
-      assert_equal 17, traces.count, "Trace count"
-      assert valid_edges?(traces), "Invalid edge in traces"
-      assert_equal true,         traces[0].key?('Args')
-      assert_equal '[1, 2, 3]',  traces[0]['Args']
-    end
-  end
-end

data/test/instrumentation/twitter-cassandra_test.rb

@@ -1,424 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-require 'minitest_helper'
-
-unless ENV['APPOPTICS_CASSANDRA_SERVER']
-  ENV['APPOPTICS_CASSANDRA_SERVER'] = "127.0.0.1:9160"
-end
-
-# The cassandra-rb client doesn't support JRuby
-# https://github.com/cassandra-rb/cassandra
-
-# exclude cassandra tests for now
-# TODO: they need refactoring to use the 'cassandra-driver' gem instead of the 'cassandra' gem,
-# ____  which hasn't had a commit since 09/2014
-
-if defined?(::Cassandra) and !defined?(JRUBY_VERSION)
-  describe "Cassandra" do
-    before do
-      clear_all_traces
-
-      @client = Cassandra.new("system", ENV['APPOPTICS_CASSANDRA_SERVER'], { :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' => ENV['APPOPTICS_CASSANDRA_SERVER'].split(':')[0],
-          'RemotePort' => ENV['APPOPTICS_CASSANDRA_SERVER'].split(':')[1] }
-
-      @exit_kvs = { 'Layer' => 'cassandra', 'Label' => 'exit' }
-      @collect_backtraces = AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-    end
-
-    after do
-      AppOpticsAPM::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 'Cassandra should have appoptics_apm 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_appoptics").must_equal true
-      end
-      # Special 'exists?' case
-      ::Cassandra.method_defined?("exists_with_appoptics?").must_equal true
-    end
-
-    it 'shouldn\'t break when NOT tracing' do
-      begin
-        user = {'screen_name' => 'larry', "blah" => "ok"}
-        @client.insert(:Users, '5', user, { :ttl => 600, :consistency => 1})
-        @client.remove(:Users, '5', 'blah')
-        @client.count_columns(:Statuses, '12', :count => 50)
-        @client.get_columns(:Statuses, '12', ['body'])
-        @client.multi_get_columns(:Users, ['12', '5'], ['body'])
-        @client.get(:Statuses, '12', :reversed => true)
-        @client.get_range_keys(:Statuses, :key_count => 4)
-        @client.create_index(@ks_name, 'Statuses', 'x', 'LongType')
-        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
-        @client.exists?(:Statuses, '12')
-        @client.exists?(:Statuses, '12', 'body')
-        @client.drop_index(@ks_name, 'Statuses', 'column_name')
-        @client.drop_keyspace(@ks_name)
-      rescue => e
-        # My crappy way to detect and fail if an exception
-        # was raised.  I swear there was a Minitest assertion for
-        # this but can't find it.
-        e.must_be_nil 'broken when NOT tracing'
-        raise
-      end
-    end
-
-    it 'should trace insert' do
-      AppOpticsAPM::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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace remove' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.remove(:Users, '5', 'blah')
-      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 "remove"
-      traces[1]['Cf'].must_equal "Users"
-      traces[1]['Key'].must_equal "\"5\""
-      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace count_columns' do
-      @client.insert(:Statuses, '12', {'body' => 'v1', 'user' => 'v2'})
-
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.count_columns(:Statuses, '12', :count => 50)
-      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 "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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace get_columns' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.get_columns(:Statuses, '12', ['body'])
-      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_columns"
-      traces[1]['Cf'].must_equal "Statuses"
-      traces[1]['Key'].must_equal "\"12\""
-      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace multi_get_columns' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.multi_get_columns(:Users, ['12', '5'], ['body'])
-      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 "multi_get_columns"
-      traces[1]['Cf'].must_equal "Users"
-      traces[1]['Key'].must_equal "[\"12\", \"5\"]"
-      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace get' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.get(:Statuses, '12', :reversed => true)
-      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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace exists?' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.exists?(:Statuses, '12')
-        @client.exists?(:Statuses, '12', 'body')
-      end
-
-      traces = get_all_traces
-
-      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 AppOpticsAPM::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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-    end
-
-    it 'should trace get_range_keys' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.get_range_keys(:Statuses, :key_count => 4)
-      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_range_batch"
-      traces[1]['Cf'].must_equal "Statuses"
-      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace create_index' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
-      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 "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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-
-      # Clean up
-      @client.drop_index(@ks_name, 'Statuses', 'column_name')
-    end
-
-    it 'should trace drop_index' do
-      # Prep
-      @client.create_index(@ks_name, 'Statuses', 'column_name', 'LongType')
-
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.drop_index(@ks_name, 'Statuses', 'column_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 "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 AppOpticsAPM::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')
-      AppOpticsAPM::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 AppOpticsAPM::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)
-
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.add_column_family(cf_def)
-        @client.drop_column_family(cf_name)
-      end
-
-      traces = get_all_traces
-
-      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 AppOpticsAPM::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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-    end
-
-    it 'should trace adding a keyspace' do
-      ks_name = (0...10).map{ ('a'..'z').to_a[rand(26)] }.join
-      ks_def = CassandraThrift::KsDef.new(:name => ks_name,
-                                          :strategy_class => "org.apache.cassandra.locator.SimpleStrategy",
-                                          :strategy_options => { 'replication_factor' => '2' },
-                                          :cf_defs => [])
-
-      AppOpticsAPM::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 AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it 'should trace the removal of a keyspace' do
-      AppOpticsAPM::API.start_trace('cassandra_test', '', {}) do
-        @client.drop_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 "drop_keyspace"
-      traces[1]['Name'].must_equal @ks_name
-      traces[1].has_key?('Backtrace').must_equal AppOpticsAPM::Config[:cassandra][:collect_backtraces]
-      validate_event_keys(traces[2], @exit_kvs)
-    end
-
-    it "should obey :collect_backtraces setting when true" do
-      AppOpticsAPM::Config[:cassandra][:collect_backtraces] = true
-
-      AppOpticsAPM::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
-      layer_has_key(traces, 'cassandra', 'Backtrace')
-    end
-
-    it "should obey :collect_backtraces setting when false" do
-      AppOpticsAPM::Config[:cassandra][:collect_backtraces] = false
-
-      AppOpticsAPM::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
-      layer_doesnt_have_key(traces, 'cassandra', 'Backtrace')
-    end
-
-  end
-end