oboe 2.3.4.1 → 2.4.0.1

data/lib/oboe/inst/dalli.rb

@@ -24,13 +24,9 @@ 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)
-          opts = {}
-          opts[:KVOp] = op
-          opts[:KVKey] = key 
-
-          Oboe::API.trace('memcache', opts || {}) do
+          Oboe::API.trace('memcache', { :KVOp => op, :KVKey => key }) do
             result = perform_without_oboe(*all_args, &blk)
 
             info_kvs = {}
@@ -46,32 +42,26 @@ module Oboe
       end
 
       def get_multi_with_oboe(*keys)
-        if Oboe.tracing?
-          layer_kvs = {}
-          layer_kvs[:KVOp] = :get_multi
+        return get_multi_without_oboe(keys) unless Oboe.tracing?
+          
+        info_kvs = {}
+          
+        begin
+          info_kvs[:KVKeyCount] = keys.flatten.length 
+          info_kvs[:KVKeyCount] = (info_kvs[:KVKeyCount] - 1) if keys.last.is_a?(Hash) || keys.last.nil?
+        rescue
+          Oboe.logger.debug "[oboe/debug] Error collecting info keys: #{e.message}"
+          Oboe.logger.debug e.backtrace
+        end
 
-          Oboe::API.trace('memcache', layer_kvs || {}, :get_multi) do
-            begin
-              info_kvs = {}
-               
-              if keys.last.is_a?(Hash) || keys.last.nil?
-                info_kvs[:KVKeyCount] = keys.flatten.length - 1
-              else
-                info_kvs[:KVKeyCount] = keys.flatten.length 
-              end
+        Oboe::API.trace('memcache', { :KVOp => :get_multi }, :get_multi) do
+          values = get_multi_without_oboe(keys)
+          
+          info_kvs[:KVHitCount] = values.length
+          info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:dalli][:collect_backtraces]
+          Oboe::API.log('memcache', 'info', info_kvs)
 
-              values = get_multi_without_oboe(keys)
-              
-              info_kvs[:KVHitCount] = values.length
-              info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:dalli][:collect_backtraces]
-              Oboe::API.log('memcache', 'info', info_kvs)
-            rescue
-              values = get_multi_without_oboe(keys)
-            end
-            values 
-          end
-        else
-          get_multi_without_oboe(keys)
+          values 
         end
       end
     end

data/lib/oboe/inst/memcache.rb

@@ -29,72 +29,58 @@ module Oboe
             class_eval "alias #{m}_without_oboe #{m}"
             class_eval "alias #{m} #{m}_with_oboe"
           end
-
-          if ::MemCache.method_defined? :request_setup
-            alias request_setup_without_oboe request_setup
-            alias request_setup request_setup_with_oboe
-          elsif Oboe::Config[:verbose]
-            Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcache.  Partial traces may occur."
-          end
-
-          if ::MemCache.method_defined? :cache_get
-            alias cache_get_without_oboe cache_get
-            alias cache_get cache_get_with_oboe
-          elsif Oboe::Config[:verbose]
-            Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcache.  Partial traces may occur." 
-          end
+        end
           
-          if ::MemCache.method_defined? :get_multi
-            alias get_multi_without_oboe get_multi
-            alias get_multi get_multi_with_oboe
+        [:request_setup, :cache_get, :get_multi].each do |m|
+          if ::MemCache.method_defined? :request_setup
+            cls.class_eval "alias #{m}_without_oboe #{m}"
+            cls.class_eval "alias #{m} #{m}_with_oboe"
           elsif Oboe::Config[:verbose]
-            Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcache.  Partial traces may occur." 
+            Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcache: #{m}"
           end
         end
       end
 
       def get_multi_with_oboe(*args)
-        if Oboe.tracing?
-          layer_kvs = {}
-          layer_kvs[:KVOp] = :get_multi
-
-          Oboe::API.trace('memcache', layer_kvs || {}, :get_multi) do
-            begin
-              info_kvs = {}
-              info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcache][:collect_backtraces]
-               
-              if args.last.is_a?(Hash) || args.last.nil?
-                info_kvs[:KVKeyCount] = args.flatten.length - 1
-              else
-                info_kvs[:KVKeyCount] = args.flatten.length 
-              end
-
-              values = get_multi_without_oboe(args)
-              
-              info_kvs[:KVHitCount] = values.length
-              Oboe::API.log('memcache', 'info', info_kvs)
-            rescue
-              values = get_multi_without_oboe(args)
-            end
-            values 
+        return get_multi_without_oboe(args) unless Oboe.tracing?
+          
+        info_kvs = {}
+          
+        begin
+          info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcache][:collect_backtraces]
+           
+          if args.last.is_a?(Hash) || args.last.nil?
+            info_kvs[:KVKeyCount] = args.flatten.length - 1
+          else
+            info_kvs[:KVKeyCount] = args.flatten.length 
           end
-        else
-          get_multi_without_oboe(args)
+        rescue StandardError => e
+          Oboe.logger.debug "[oboe/debug] Error collecting info keys: #{e.message}"
+          Oboe.logger.debug e.backtrace
+        end
+
+        Oboe::API.trace('memcache', {:KVOp => :get_multi}, :get_multi) do
+          values = get_multi_without_oboe(args)
+          
+          info_kvs[:KVHitCount] = values.length
+          Oboe::API.log('memcache', 'info', info_kvs)
+          
+          values 
         end
       end
       
       def request_setup_with_oboe(*args)
         if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:get_multi)
           server, cache_key = request_setup_without_oboe(*args)
-
+          
           info_kvs = { :KVKey => cache_key, :RemoteHost => server.host }
           info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcache][:collect_backtraces]
-
           Oboe::API.log('memcache', 'info', info_kvs)
+
+          [server, cache_key]
         else
-          server, cache_key = request_setup_without_oboe(*args)
+          request_setup_without_oboe(*args) 
         end
-        return [server, cache_key]
       end
 
       def cache_get_with_oboe(server, cache_key)
@@ -103,6 +89,7 @@ module Oboe
         info_kvs = { :KVHit => memcache_hit?(result) }
         info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcache][:collect_backtraces]
         Oboe::API.log('memcache', 'info', info_kvs)
+
         result
       end
 

data/lib/oboe/inst/mongo.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2013 AppNeta, Inc.
 # All rights reserved.
 
+require 'json'
+
 module Oboe
   module Inst
     module Mongo
@@ -81,7 +83,7 @@ if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
               report_kvs[:QueryOp] = m 
               if m == :count
                 unless @selector.empty?
-                  report_kvs[:Query] = @selector.try(:to_json) 
+                  report_kvs[:Query] = @selector.to_json
                 else
                   report_kvs[:Query] = 'all'
                 end
@@ -148,7 +150,7 @@ if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
 
               if m == :update
                 if args_length >= 3
-                  report_kvs[:Update_Document] = args[1].try(:to_json)
+                  report_kvs[:Update_Document] = args[1].to_json
                   report_kvs[:Multi] = args[2][:multi] if args[2] and args[2].has_key?(:multi)
                 end
               end
@@ -173,7 +175,7 @@ if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
 
               if m == :distinct and args_length >= 2
                 report_kvs[:Key]   = args[0]
-                report_kvs[:Query] = args[1].try(:to_json) if args[1] and args[1].class == Hash
+                report_kvs[:Query] = args[1].to_json if args[1] and args[1].class == Hash
               end
 
               if m == :find and args_length > 0
@@ -183,9 +185,9 @@ if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
               if m == :group
                 unless args.empty?
                   if args[0].is_a?(Hash) 
-                    report_kvs[:Group_Key]       = args[0][:key].try(:to_json)     if args[0].has_key?(:key)
-                    report_kvs[:Group_Condition] = args[0][:cond].try(:to_json)    if args[0].has_key?(:cond) 
-                    report_kvs[:Group_Initial]   = args[0][:initial].try(:to_json) if args[0].has_key?(:initial)
+                    report_kvs[:Group_Key]       = args[0][:key].to_json     if args[0].has_key?(:key)
+                    report_kvs[:Group_Condition] = args[0][:cond].to_json    if args[0].has_key?(:cond) 
+                    report_kvs[:Group_Initial]   = args[0][:initial].to_json if args[0].has_key?(:initial)
                     report_kvs[:Group_Reduce]    = args[0][:reduce]                if args[0].has_key?(:reduce) 
                   end
                 end
@@ -210,7 +212,7 @@ if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
            
             begin
               if [:create_index, :ensure_index, :drop_index].include? m and not _args.empty?
-                report_kvs[:Index] = _args[0].try(:to_json)
+                report_kvs[:Index] = _args[0].to_json
               end
             rescue
             end

data/lib/oboe/inst/moped.rb

@@ -41,7 +41,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
             report_kvs[:Database] = name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
-          rescue Exception => e
+          rescue StandardError => e
             Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
           end
           report_kvs
@@ -53,7 +53,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
               report_kvs = extract_trace_details(:map_reduce)
               report_kvs[:Map_Function] = command[:map]
               report_kvs[:Reduce_Function] = command[:reduce]
-            rescue Exception => e
+            rescue StandardError => e
               Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
             end
 
@@ -66,13 +66,11 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
 
         def drop_with_oboe
-          if Oboe.tracing?
-            report_kvs = extract_trace_details(:drop_database)
+          return drop_without_oboe unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs) do
-              drop_without_oboe
-            end
-          else
+          report_kvs = extract_trace_details(:drop_database)
+
+          Oboe::API.trace('mongo', report_kvs) do
             drop_without_oboe
           end
         end
@@ -102,47 +100,43 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
             report_kvs[:Database] = database.name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
-          rescue Exception => e
+          rescue StandardError => e
             Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
           end
           report_kvs
         end
         
         def create_with_oboe(key, options = {})
-          if Oboe.tracing?
-            begin
-              # We report :create_index here to be consistent
-              # with other mongo implementations
-              report_kvs = extract_trace_details(:create_index)
-              report_kvs[:Key] = key.to_json
-              report_kvs[:Options] = options.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return create_without_oboe(key, options = {}) unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs, :create_index) do
-              create_without_oboe(key, options = {})
-            end
-          else
+          begin
+            # We report :create_index here to be consistent
+            # with other mongo implementations
+            report_kvs = extract_trace_details(:create_index)
+            report_kvs[:Key] = key.to_json
+            report_kvs[:Options] = options.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
+
+          Oboe::API.trace('mongo', report_kvs, :create_index) do
             create_without_oboe(key, options = {})
           end
         end
         
         def drop_with_oboe(key = nil)
-          if Oboe.tracing?
-            begin
-              # We report :drop_indexes here to be consistent
-              # with other mongo implementations
-              report_kvs = extract_trace_details(:drop_indexes)
-              report_kvs[:Key] = key.nil? ? "all" : key.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return drop_without_oboe(key = nil) unless Oboe.tracing?
+            
+          begin
+            # We report :drop_indexes here to be consistent
+            # with other mongo implementations
+            report_kvs = extract_trace_details(:drop_indexes)
+            report_kvs[:Key] = key.nil? ? "all" : key.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs) do
-              drop_without_oboe(key = nil)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             drop_without_oboe(key = nil)
           end
         end
@@ -173,43 +167,39 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
             report_kvs[:Collection] = collection.name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
-          rescue Exception => e
+          rescue StandardError => e
             Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
           end
           report_kvs
         end
         
         def count_with_oboe
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:count)
-              report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return count_without_oboe unless Oboe.tracing?
+            
+          begin
+            report_kvs = extract_trace_details(:count)
+            report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs) do
-              count_without_oboe
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             count_without_oboe
           end
         end
 
         def sort_with_oboe(sort)
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:sort)
-              report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
-              report_kvs[:Order] = sort.to_s
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return sort_without_oboe(sort) unless Oboe.tracing?
+            
+          begin
+            report_kvs = extract_trace_details(:sort)
+            report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
+            report_kvs[:Order] = sort.to_s
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs) do
-              sort_without_oboe(sort)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             sort_without_oboe(sort)
           end
         end
@@ -220,32 +210,30 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
               report_kvs = extract_trace_details(:limit)
               report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
               report_kvs[:Limit] = limit.to_s
-            rescue Exception => e
+            rescue StandardError => e
               Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
             end
 
             Oboe::API.trace('mongo', report_kvs) do
               limit_without_oboe(limit)
             end
-          else
-            limit_without_oboe(limit)
+          else 
+            limit_without_oboe(limit) 
           end
         end
 
         def distinct_with_oboe(key)
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:distinct)
-              report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
-              report_kvs[:Key] = key.to_s
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return distinct_without_oboe(key) unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs) do
-              distinct_without_oboe(key)
-            end
-          else
+          begin
+            report_kvs = extract_trace_details(:distinct)
+            report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
+            report_kvs[:Key] = key.to_s
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
+
+          Oboe::API.trace('mongo', report_kvs) do
             distinct_without_oboe(key)
           end
         end
@@ -256,7 +244,7 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
               report_kvs = extract_trace_details(:update)
               report_kvs[:Flags] = flags.to_s if flags
               report_kvs[:Update_Document] = change.to_json
-            rescue Exception => e
+            rescue StandardError => e
               Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
             end
 
@@ -269,106 +257,94 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
         
         def update_all_with_oboe(change)
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:update_all)
-              report_kvs[:Update_Document] = change.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return update_all_without_oboe(change) unless Oboe.tracing?
+            
+          begin
+            report_kvs = extract_trace_details(:update_all)
+            report_kvs[:Update_Document] = change.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs, :update_all) do
-              update_all_without_oboe(change)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs, :update_all) do
             update_all_without_oboe(change)
           end
         end
 
         def upsert_with_oboe(change)
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:upsert)
-              report_kvs[:Query] = selector.to_json
-              report_kvs[:Update_Document] = change.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return upsert_without_oboe(change) unless Oboe.tracing?
+          
+          begin
+            report_kvs = extract_trace_details(:upsert)
+            report_kvs[:Query] = selector.to_json
+            report_kvs[:Update_Document] = change.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs, :upsert) do
-              upsert_without_oboe(change)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs, :upsert) do
             upsert_without_oboe(change)
           end
         end
 
         def explain_with_oboe
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:explain)
-              report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return explain_without_oboe unless Oboe.tracing?
+          
+          begin
+            report_kvs = extract_trace_details(:explain)
+            report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs, :explain) do
-              explain_without_oboe
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs, :explain) do
             explain_without_oboe
           end
         end
 
         def modify_with_oboe(change, options = {})
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:modify)
-              report_kvs[:Update_Document] = selector.empty? ? "all" : selector.to_json
-              report_kvs[:Change] = change.to_json
-              report_kvs[:Options] = options.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return modify_without_oboe(change, options) unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs) do
-              modify_without_oboe(change, options)
-            end
-          else
+          begin
+            report_kvs = extract_trace_details(:modify)
+            report_kvs[:Update_Document] = selector.empty? ? "all" : selector.to_json
+            report_kvs[:Change] = change.to_json
+            report_kvs[:Options] = options.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
+
+          Oboe::API.trace('mongo', report_kvs) do
             modify_without_oboe(change, options)
           end
         end
         
         def remove_with_oboe
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:remove)
-              report_kvs[:Query] = selector.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return remove_without_oboe unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs) do
-              remove_without_oboe
-            end
-          else
+          begin
+            report_kvs = extract_trace_details(:remove)
+            report_kvs[:Query] = selector.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
+
+          Oboe::API.trace('mongo', report_kvs) do
             remove_without_oboe
           end
         end
 
         def remove_all_with_oboe
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:remove_all)
-              report_kvs[:Query] = selector.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return remove_all_without_oboe unless Oboe.tracing?
 
-            Oboe::API.trace('mongo', report_kvs) do
-              remove_all_without_oboe
-            end
-          else
+          begin
+            report_kvs = extract_trace_details(:remove_all)
+            report_kvs[:Query] = selector.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
+
+          Oboe::API.trace('mongo', report_kvs) do
             remove_all_without_oboe
           end
         end
@@ -400,51 +376,45 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
             report_kvs[:Collection] = @name
             report_kvs[:QueryOp] = op.to_s
             report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:moped][:collect_backtraces]
-          rescue Exception => e
+          rescue StandardError => e
             Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
           end
           report_kvs
         end
 
         def drop_with_oboe
-          if Oboe.tracing?
-            # We report :drop_collection here to be consistent
-            # with other mongo implementations
-            report_kvs = extract_trace_details(:drop_collection)
+          return drop_without_oboe unless Oboe.tracing?
+            
+          # We report :drop_collection here to be consistent
+          # with other mongo implementations
+          report_kvs = extract_trace_details(:drop_collection)
 
-            Oboe::API.trace('mongo', report_kvs) do
-              drop_without_oboe
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             drop_without_oboe
           end
         end
 
         def find_with_oboe(selector = {})
-          if Oboe.tracing?
-            begin
-              report_kvs = extract_trace_details(:find)
-              report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
-            rescue Exception => e
-              Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
-            end
+          return find_without_oboe(selector) unless Oboe.tracing?
+            
+          begin
+            report_kvs = extract_trace_details(:find)
+            report_kvs[:Query] = selector.empty? ? "all" : selector.to_json
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Moped KV collection error: #{e.inspect}"
+          end
 
-            Oboe::API.trace('mongo', report_kvs) do
-              find_without_oboe(selector)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             find_without_oboe(selector)
           end
         end
         
         def indexes_with_oboe
-          if Oboe.tracing?
-            report_kvs = extract_trace_details(:indexes)
+          return indexes_without_oboe unless Oboe.tracing?
+            
+          report_kvs = extract_trace_details(:indexes)
 
-            Oboe::API.trace('mongo', report_kvs) do
-              indexes_without_oboe
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             indexes_without_oboe
           end
         end
@@ -462,13 +432,11 @@ if defined?(::Moped) and Oboe::Config[:moped][:enabled]
         end
         
         def aggregate_with_oboe(pipeline)
-          if Oboe.tracing?
-            report_kvs = extract_trace_details(:aggregate)
+          return aggregate_without_oboe(pipeline) unless Oboe.tracing?
+            
+          report_kvs = extract_trace_details(:aggregate)
 
-            Oboe::API.trace('mongo', report_kvs) do
-              aggregate_without_oboe(pipeline)
-            end
-          else
+          Oboe::API.trace('mongo', report_kvs) do
             aggregate_without_oboe(pipeline)
           end
         end