oboe 2.7.6.2 → 2.7.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bbafabb39decad386dc3d7f69fe5bf05c37f871
-  data.tar.gz: cdc1a52a1853ed4a41e0293deb13393659b667c0
+  metadata.gz: e12e0be2eaca4139071f49e208ec204361471e53
+  data.tar.gz: fcfbe0144510290a381a8fbc35920e4d3bdec921
 SHA512:
-  metadata.gz: 6a67d61562e9906c6cdd62fba61e35a5461525a422fcc18cdc52b84fffed0537b4f6477310e961a2e42775ec603db1e6ff24f4c42429ed30518e7fbb3ed5d5d5
-  data.tar.gz: 2109d23dffb9c361964fdcecf459a2ca0e4d07991d6c217c91c693480c7f9715d980986f2416472d440181a78458611c087e6f70ab1519a8d2282d906e5e288d
+  metadata.gz: 4678a5789e8b976ce37ff8581121172eca657aace4f8f061b848e4fc09bfbcc42e111bae4133dedd53e2ed8dd0b1514d5c5dfe4b1eb4d2a976cfd37d3742ab76
+  data.tar.gz: a44ed9f77128673584d096a169f47098b77f8406495af01117dc81c8cecf294c483969123f143e01997003a6bd50583e39cf6b14ab3799e8c06ea75dd907a98b

data/.travis.yml

@@ -28,8 +28,6 @@ before_install:
   - echo "127.0.0.1 " `hostname` | sudo tee /etc/hosts
   - sudo service cassandra start
 
-before_script: sleep 10
-
 install:
   - wget https://www.tracelytics.com/install_tracelytics.sh
   - sudo sh ./install_tracelytics.sh f51e2a43-0ee5-4851-8a54-825773b3218e
@@ -38,6 +36,9 @@ install:
 before_script:
   - bundle install --without development
   - bundle exec rake compile
+  - psql -c 'create database travis_ci_test;' -U postgres
+  - mysql -e 'create database travis_ci_test;'
+  - sleep 10
 
 script: "bundle exec rake test"
 

data/Gemfile

@@ -30,9 +30,20 @@ gem 'redis'
 gem 'faraday'
 gem 'excon'
 gem 'typhoeus'
+gem 'sequel'
+
+# Database adapter gems needed by sequel
+if defined?(JRUBY_VERSION)
+  gem 'jdbc-postgresql'
+  gem 'jdbc-mysql'
+else
+  gem 'mysql'
+  gem 'mysql2'
+  gem 'pg'
+end
 
 if RUBY_VERSION >= '1.9'
-  gem 'moped', '1.3.2'
+  gem 'moped'
   gem 'eventmachine'
   gem 'em-synchrony'
   gem 'em-http-request'

data/Rakefile

@@ -97,6 +97,7 @@ desc "Rebuild the gem's c extension"
 task :recompile => [ :distclean, :compile ]
 
 task :console do
+  ENV['OBOE_GEM_VERBOSE'] = 'true'
   Bundler.require(:default, :development)
   Oboe::Config[:tracing_mode] = :always
   ARGV.clear

data/lib/oboe/api/logging.rb

@@ -153,6 +153,9 @@ module Oboe
           event.addInfo('Layer', layer.to_s) if layer
           event.addInfo('Label', label.to_s)
 
+          Oboe.layer = layer if label == 'entry'
+          Oboe.layer = nil   if label == 'exit'
+
           opts.each do |k, v|
             event.addInfo(k.to_s, v.to_s) if valid_key? k
           end if !opts.nil? && opts.any?

data/lib/oboe/base.rb

@@ -33,6 +33,7 @@ module OboeBase
   attr_accessor :loaded
   attr_accessor :sample_source
   attr_accessor :sample_rate
+  thread_local :layer
   thread_local :layer_op
 
   # The following accessors indicate the incoming tracing state received
@@ -99,6 +100,17 @@ module OboeBase
     end
   end
 
+  ##
+  # tracing_layer?
+  #
+  # Queries the thread local variable about the current
+  # layer being traced.  This is used in cases of recursive
+  # operation tracing or one instrumented operation calling another.
+  #
+  def tracing_layer?(layer)
+    return Oboe.layer == layer
+  end
+
   ##
   # tracing_layer_op?
   #

data/lib/oboe/config.rb

@@ -13,7 +13,7 @@ module Oboe
 
     @@instrumentation = [:action_controller, :action_view, :active_record,
                          :cassandra, :dalli, :em_http_request, :faraday, :nethttp, :memcached,
-                         :memcache, :mongo, :moped, :rack, :redis, :resque, :typhoeus]
+                         :memcache, :mongo, :moped, :rack, :redis, :resque, :sequel, :typhoeus]
     ##
     # Return the raw nested hash.
     #
@@ -48,6 +48,7 @@ module Oboe
       Oboe::Config[:nethttp][:collect_backtraces] = true
       Oboe::Config[:redis][:collect_backtraces] = false
       Oboe::Config[:resque][:collect_backtraces] = true
+      Oboe::Config[:sequel][:collect_backtraces] = true
       Oboe::Config[:typhoeus][:collect_backtraces] = false
 
       # Special instrument specific flags

data/lib/oboe/inst/sequel.rb

@@ -0,0 +1,159 @@
+module Oboe
+  module Inst
+    module Sequel
+      def extract_trace_details(sql, opts)
+        kvs = {}
+
+        if Oboe::Config[:sanitize_sql]
+          # Sanitize SQL and don't report binds
+          if sql.is_a?(Symbol)
+            kvs[:Query] = sql
+          else
+            kvs[:Query] = sql.gsub(/('[\s\S][^\']*\'|\d*\.\d*)/, '?')
+          end
+        else
+          # Report raw SQL and any binds if they exist
+          kvs[:Query] = sql.to_s
+          kvs[:QueryArgs] = opts[:arguments] if opts.is_a?(Hash) and opts.key?(:arguments)
+        end
+        kvs[:IsPreparedStatement] = true if sql.is_a?(Symbol)
+
+        kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:sequel][:collect_backtraces]
+
+        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
+          db_opts = @opts
+        elsif @pool
+          db_opts = @pool.db.opts
+        else
+          db_opts = @db.opts
+        end
+
+        kvs[:Database]   = db_opts[:database]
+        kvs[:RemoteHost] = db_opts[:host]
+        kvs[:RemotePort] = db_opts[:port] if db_opts.key?(:port)
+        kvs[:Flavor]     = db_opts[:adapter]
+      rescue => e
+        Oboe.logger.debug "[oboe/debug Error capturing Sequel KVs: #{e.message}" if Oboe::Config[:verbose]
+      ensure
+        return kvs
+      end
+    end
+
+    module SequelDatabase
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :run, ::Sequel::Database)
+        ::Oboe::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
+        ::Oboe::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
+        ::Oboe::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
+      end
+
+      def run_with_oboe(sql, opts=::Sequel::OPTS)
+        kvs = extract_trace_details(sql, opts)
+
+        Oboe::API.log_entry('sequel', kvs)
+
+        run_without_oboe(sql, opts)
+      rescue => e
+        Oboe::API.log_exception('sequel', e)
+        raise e
+      ensure
+        Oboe::API.log_exit('sequel')
+      end
+
+      def exec_with_oboe(method, sql, opts=::Sequel::OPTS, &block)
+        kvs = extract_trace_details(sql, opts)
+
+        Oboe::API.log_entry('sequel', kvs)
+
+        send(method, sql, opts, &block)
+      rescue => e
+        Oboe::API.log_exception('sequel', e)
+        raise e
+      ensure
+        Oboe::API.log_exit('sequel')
+      end
+
+      def execute_ddl_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_ddl_without_oboe(sql, opts, &block) if Oboe.tracing_layer?('sequel')
+
+        exec_with_oboe(:execute_ddl_without_oboe, sql, opts, &block)
+      end
+
+      def execute_dui_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_dui_without_oboe(sql, opts, &block) if Oboe.tracing_layer?('sequel')
+
+        exec_with_oboe(:execute_dui_without_oboe, sql, opts, &block)
+      end
+
+      def execute_insert_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_insert_without_oboe(sql, opts, &block) if Oboe.tracing_layer?('sequel')
+
+        exec_with_oboe(:execute_insert_without_oboe, sql, opts, &block)
+      end
+    end # module SequelDatabase
+
+    module SequelDataset
+
+      def self.included(klass)
+        ::Oboe::Util.method_alias(klass, :execute, ::Sequel::Dataset)
+        ::Oboe::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
+        ::Oboe::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
+        ::Oboe::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
+      end
+
+      def exec_with_oboe(method, sql, opts=::Sequel::OPTS, &block)
+        kvs = extract_trace_details(sql, opts)
+
+        Oboe::API.log_entry('sequel', kvs)
+
+        send(method, sql, opts, &block)
+      rescue => e
+        Oboe::API.log_exception('sequel', e)
+        raise e
+      ensure
+        Oboe::API.log_exit('sequel')
+      end
+
+      def execute_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        exec_with_oboe(:execute_without_oboe, sql, opts, &block)
+      end
+
+      def execute_ddl_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        exec_with_oboe(:execute_ddl_without_oboe, sql, opts, &block)
+      end
+
+      def execute_dui_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        exec_with_oboe(:execute_dui_without_oboe, sql, opts, &block)
+      end
+
+      def execute_insert_with_oboe(sql, opts=::Sequel::OPTS, &block)
+        exec_with_oboe(:execute_insert_without_oboe, sql, opts, &block)
+      end
+
+    end # module SequelDataset
+  end # module Inst
+end # module Oboe
+
+if Oboe::Config[:sequel][:enabled]
+  if defined?(::Sequel) && ::Sequel::VERSION < "4.0.0"
+    # For versions before 4.0.0, Sequel::OPTS wasn't defined.
+    # Define it as an empty hash for backwards compatibility.
+    module ::Sequel
+      OPTS = {}
+    end
+  end
+
+  if defined?(::Sequel)
+    Oboe.logger.info '[oboe/loading] Instrumenting sequel' if Oboe::Config[:verbose]
+    ::Oboe::Util.send_include(::Sequel::Database, ::Oboe::Inst::Sequel)
+    ::Oboe::Util.send_include(::Sequel::Database, ::Oboe::Inst::SequelDatabase)
+    ::Oboe::Util.send_include(::Sequel::Dataset, ::Oboe::Inst::Sequel)
+    ::Oboe::Util.send_include(::Sequel::Dataset, ::Oboe::Inst::SequelDataset)
+  end
+end

data/lib/oboe/util.rb

@@ -46,7 +46,8 @@ module Oboe
               alias_method "#{method}", with_oboe
             end
           end
-        else Oboe.logger.warn "[oboe/loading] Couldn't properly instrument #{name}.  Partial traces may occur."
+        else
+          Oboe.logger.warn "[oboe/loading] Couldn't properly instrument #{name}.#{method}.  Partial traces may occur."
         end
       end
 

data/lib/oboe/version.rb

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

data/test/instrumentation/sequel_mysql2_test.rb

@@ -0,0 +1,320 @@
+require 'minitest_helper'
+
+unless defined?(JRUBY_VERSION)
+
+  if ENV.key?('TRAVIS_MYSQL_PASS')
+    MYSQL2_DB = Sequel.connect("mysql2://root:#{ENV['TRAVIS_MYSQL_PASS']}@127.0.0.1:3306/travis_ci_test")
+  else
+    MYSQL2_DB = Sequel.connect('mysql2://root@127.0.0.1:3306/travis_ci_test')
+  end
+
+  unless MYSQL2_DB.table_exists?(:items)
+    MYSQL2_DB.create_table :items do
+      primary_key :id
+      String :name
+      Float :price
+    end
+  end
+
+  describe "Oboe::Inst::Sequel (mysql2)" do
+    before do
+      clear_all_traces
+
+      # These are standard entry/exit KVs that are passed up with all sequel operations
+      @entry_kvs = {
+        'Layer' => 'sequel',
+        'Label' => 'entry',
+        'Database' => 'travis_ci_test',
+        'RemoteHost' => '127.0.0.1',
+        'RemotePort' => '3306' }
+
+      @exit_kvs = { 'Layer' => 'sequel', 'Label' => 'exit' }
+      @collect_backtraces = Oboe::Config[:sequel][:collect_backtraces]
+      @sanitize_sql = Oboe::Config[:sanitize_sql]
+    end
+
+    after do
+      Oboe::Config[:sequel][:collect_backtraces] = @collect_backtraces
+      Oboe::Config[:sanitize_sql] = @sanitize_sql
+    end
+
+    it 'Stock sequel should be loaded, defined and ready' do
+      defined?(::Sequel).wont_match nil
+    end
+
+    it 'sequel should have oboe methods defined' do
+      # Sequel::Database
+      ::Sequel::Database.method_defined?(:run_with_oboe).must_equal true
+
+      # Sequel::Dataset
+      ::Sequel::Dataset.method_defined?(:execute_with_oboe).must_equal true
+      ::Sequel::Dataset.method_defined?(:execute_ddl_with_oboe).must_equal true
+      ::Sequel::Dataset.method_defined?(:execute_dui_with_oboe).must_equal true
+      ::Sequel::Dataset.method_defined?(:execute_insert_with_oboe).must_equal true
+    end
+
+    it "should obey :collect_backtraces setting when true" do
+      Oboe::Config[:sequel][:collect_backtraces] = true
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.run('select 1')
+      end
+
+      traces = get_all_traces
+      layer_has_key(traces, 'sequel', 'Backtrace')
+    end
+
+    it "should obey :collect_backtraces setting when false" do
+      Oboe::Config[:sequel][:collect_backtraces] = false
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.run('select 1')
+      end
+
+      traces = get_all_traces
+      layer_doesnt_have_key(traces, 'sequel', 'Backtrace')
+    end
+
+    it 'should trace MYSQL2_DB.run insert' do
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.run("insert into items (name, price) values ('blah', '12')")
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "insert into items (name, price) values ('blah', '12')"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace MYSQL2_DB.run select' do
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.run("select 1")
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "select 1"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace a dataset insert and count' do
+      items = MYSQL2_DB[:items]
+      items.count
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        items.insert(:name => 'abc', :price => 2.514461383352462)
+        items.count
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      if RUBY_VERSION < "1.9"
+        traces[1]['Query'].must_equal "INSERT INTO `items` (`price`, `name`) VALUES (2.51446138335246, 'abc')"
+      else
+        traces[1]['Query'].must_equal "INSERT INTO `items` (`name`, `price`) VALUES ('abc', 2.514461383352462)"
+      end
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      traces[2]['Layer'].must_equal "sequel"
+      traces[2]['Label'].must_equal "exit"
+      traces[3]['Query'].downcase.must_equal "select count(*) as `count` from `items` limit 1"
+      validate_event_keys(traces[4], @exit_kvs)
+    end
+
+    it 'should trace a dataset insert and obey query privacy' do
+      Oboe::Config[:sanitize_sql] = true
+      items = MYSQL2_DB[:items]
+      items.count
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        items.insert(:name => 'abc', :price => 2.514461383352462)
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      if RUBY_VERSION < "1.9"
+        traces[1]['Query'].must_equal "INSERT INTO `items` (`price`, `name`) VALUES (?, ?)"
+      else
+        traces[1]['Query'].must_equal "INSERT INTO `items` (`name`, `price`) VALUES (?, ?)"
+      end
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace a dataset filter' do
+      items = MYSQL2_DB[:items]
+      items.count
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        items.filter(:name => 'abc').all
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "SELECT * FROM `items` WHERE (`name` = 'abc')"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace create table' do
+      # Drop the table if it already exists
+      MYSQL2_DB.drop_table(:fake) if MYSQL2_DB.table_exists?(:fake)
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.create_table :fake do
+          primary_key :id
+          String :name
+          Float :price
+        end
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "CREATE TABLE `fake` (`id` integer PRIMARY KEY AUTO_INCREMENT, `name` varchar(255), `price` double precision)"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace add index' do
+      # Drop the table if it already exists
+      MYSQL2_DB.drop_table(:fake) if MYSQL2_DB.table_exists?(:fake)
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        MYSQL2_DB.create_table :fake do
+          primary_key :id
+          String :name
+          Float :price
+        end
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "CREATE TABLE `fake` (`id` integer PRIMARY KEY AUTO_INCREMENT, `name` varchar(255), `price` double precision)"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should capture and report exceptions' do
+      begin
+        Oboe::API.start_trace('sequel_test', '', {}) do
+          MYSQL2_DB.run("this is bad sql")
+        end
+      rescue
+        # Do nothing - we're testing exception logging
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 5
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "this is bad sql"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      traces[2]['Layer'].must_equal "sequel"
+      traces[2]['Label'].must_equal "error"
+      traces[2].has_key?('Backtrace').must_equal true
+      traces[2]['ErrorClass'].must_equal "Sequel::DatabaseError"
+      validate_event_keys(traces[3], @exit_kvs)
+    end
+
+    it 'should trace placeholder queries with bound vars' do
+      items = MYSQL2_DB[:items]
+      items.count
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        ds = items.where(:name=>:$n)
+        ds.call(:select, :n=>'abc')
+        ds.call(:delete, :n=>'cba')
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 6
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "SELECT * FROM `items` WHERE (`name` = 'abc')"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      traces[3]['Query'].must_equal "DELETE FROM `items` WHERE (`name` = 'cba')"
+      traces[3].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace prepared statements' do
+      ds = MYSQL2_DB[:items].filter(:name=>:$n)
+      ps = ds.prepare(:select, :select_by_name)
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        ps.call(:n=>'abc')
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "select_by_name"
+      if RUBY_VERSION < "1.9"
+        traces[1]['QueryArgs'].must_equal "abc"
+      else
+        traces[1]['QueryArgs'].must_equal "[\"abc\"]"
+      end
+      traces[1]['IsPreparedStatement'].must_equal "true"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+
+    it 'should trace prep\'d stmnts and obey query privacy' do
+      Oboe::Config[:sanitize_sql] = true
+      ds = MYSQL2_DB[:items].filter(:name=>:$n)
+      ps = ds.prepare(:select, :select_by_name)
+
+      Oboe::API.start_trace('sequel_test', '', {}) do
+        ps.call(:n=>'abc')
+      end
+
+      traces = get_all_traces
+
+      traces.count.must_equal 4
+      validate_outer_layers(traces, 'sequel_test')
+
+      validate_event_keys(traces[1], @entry_kvs)
+      traces[1]['Query'].must_equal "select_by_name"
+      traces[1]['QueryArgs'].must_equal nil
+      traces[1]['IsPreparedStatement'].must_equal "true"
+      traces[1].has_key?('Backtrace').must_equal Oboe::Config[:sequel][:collect_backtraces]
+      validate_event_keys(traces[2], @exit_kvs)
+    end
+  end
+end