oboe 1.3.9.1 → 1.4.0.2

data/lib/oboe/inst/mongo.rb

@@ -20,210 +20,207 @@ module Oboe
   end
 end
 
-if defined?(::Mongo::DB)
-  module ::Mongo
-    class DB
-      include Oboe::Inst::Mongo
-      
-      # Instrument DB operations
-      Oboe::Inst::Mongo::DB_OPS.reject { |m| not method_defined?(m) }.each do |m|
-        define_method("#{m}_with_oboe") do |*args|
-          report_kvs = {}
+if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
+  puts "[oboe/loading] Instrumenting mongo" if Oboe::Config[:verbose]
 
-          begin
-            report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
+  if defined?(::Mongo::DB)
+    module ::Mongo
+      class DB
+        include Oboe::Inst::Mongo
+        
+        # Instrument DB operations
+        Oboe::Inst::Mongo::DB_OPS.reject { |m| not method_defined?(m) }.each do |m|
+          define_method("#{m}_with_oboe") do |*args|
+            report_kvs = {}
 
-            report_kvs[:Database] = @name
-            report_kvs[:RemoteHost] = @connection.host
-            report_kvs[:RemotePort] = @connection.port
-            
-            report_kvs[:QueryOp] = m 
+            begin
+              report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
 
-            report_kvs[:New_Collection_Name] = args[0] if m == :create_collection
-            report_kvs[:Collection_Name] = args[0]     if m == :drop_collection
+              report_kvs[:Database] = @name
+              report_kvs[:RemoteHost] = @connection.host
+              report_kvs[:RemotePort] = @connection.port
+              
+              report_kvs[:QueryOp] = m 
 
-            report_kvs[:Backtrace] = Oboe::API.backtrace
-          rescue
-            logger.warn "[oboe/error] Problem processing mongo args (#{m})" if defined?(logger)
-          end
+              report_kvs[:New_Collection_Name] = args[0] if m == :create_collection
+              report_kvs[:Collection_Name] = args[0]     if m == :drop_collection
+
+              report_kvs[:Backtrace] = Oboe::API.backtrace
+            rescue
+            end
 
-          Oboe::API.trace('mongo', report_kvs) do
-            send("#{m}_without_oboe", *args)
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args)
+            end
           end
+          
+          class_eval "alias #{m}_without_oboe #{m}"
+          class_eval "alias #{m} #{m}_with_oboe"
         end
-        
-        class_eval "alias #{m}_without_oboe #{m}"
-        class_eval "alias #{m} #{m}_with_oboe"
       end
     end
   end
-end
 
-if defined?(::Mongo::Cursor)
-  module ::Mongo
-    class Cursor
-      include Oboe::Inst::Mongo
-      
-      # Instrument DB cursor operations
-      Oboe::Inst::Mongo::CURSOR_OPS.reject { |m| not method_defined?(m) }.each do |m|
-        define_method("#{m}_with_oboe") do |*args|
-          report_kvs = {}
-          
-          begin
-            report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
-
-            report_kvs[:Database] = @db.name
-            report_kvs[:RemoteHost] = @connection.host
-            report_kvs[:RemotePort] = @connection.port
-
-            report_kvs[:QueryOp] = m 
-            if m == :count
-              unless @selector.empty?
-                report_kvs[:Query] = @selector.try(:to_json) 
-              else
-                report_kvs[:Query] = 'all'
+  if defined?(::Mongo::Cursor)
+    module ::Mongo
+      class Cursor
+        include Oboe::Inst::Mongo
+        
+        # Instrument DB cursor operations
+        Oboe::Inst::Mongo::CURSOR_OPS.reject { |m| not method_defined?(m) }.each do |m|
+          define_method("#{m}_with_oboe") do |*args|
+            report_kvs = {}
+            
+            begin
+              report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
+
+              report_kvs[:Database] = @db.name
+              report_kvs[:RemoteHost] = @connection.host
+              report_kvs[:RemotePort] = @connection.port
+
+              report_kvs[:QueryOp] = m 
+              if m == :count
+                unless @selector.empty?
+                  report_kvs[:Query] = @selector.try(:to_json) 
+                else
+                  report_kvs[:Query] = 'all'
+                end
+                report_kvs[:Limit] = @limit if @limit != 0
               end
-              report_kvs[:Limit] = @limit if @limit != 0
+            rescue
+            end
+            
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args)
             end
-
-          rescue
-            logger.warn "[oboe/error] Problem processing mongo args (#{m})" if defined?(logger)
           end
           
-          Oboe::API.trace('mongo', report_kvs) do
-            send("#{m}_without_oboe", *args)
-          end
+          class_eval "alias #{m}_without_oboe #{m}"
+          class_eval "alias #{m} #{m}_with_oboe"
         end
-        
-        class_eval "alias #{m}_without_oboe #{m}"
-        class_eval "alias #{m} #{m}_with_oboe"
       end
     end
   end
-end
 
-if defined?(::Mongo::Collection)
-  module ::Mongo
-    class Collection
-      include Oboe::Inst::Mongo
+  if defined?(::Mongo::Collection)
+    module ::Mongo
+      class Collection
+        include Oboe::Inst::Mongo
 
-      def oboe_collect(m, args)
-        report_kvs = {}
-        report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
-
-        report_kvs[:Database] = @db.name
-        report_kvs[:RemoteHost] = @db.connection.host
-        report_kvs[:RemotePort] = @db.connection.port
-        report_kvs[:Collection] = @name
+        def oboe_collect(m, args)
+          report_kvs = {}
+          report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
+
+          report_kvs[:Database] = @db.name
+          report_kvs[:RemoteHost] = @db.connection.host
+          report_kvs[:RemotePort] = @db.connection.port
+          report_kvs[:Collection] = @name
+              
+          report_kvs[:Backtrace] = Oboe::API.backtrace
+
+          report_kvs[:QueryOp] = m 
+          report_kvs[:Query] = args[0].try(:to_json) if args and not args.empty? and args[0].class == Hash
+          report_kvs
+        end
+        
+        # Instrument Collection write operations
+        Oboe::Inst::Mongo::COLL_WRITE_OPS.reject { |m| not method_defined?(m) }.each do |m|
+          define_method("#{m}_with_oboe") do |*args|
+            report_kvs = oboe_collect(m, args)
+            args_length = args.length
             
-        report_kvs[:Backtrace] = Oboe::API.backtrace
-
-        report_kvs[:QueryOp] = m 
-        report_kvs[:Query] = args[0].try(:to_json) if args and not args.empty? and args[0].class == Hash
-        report_kvs
-      end
-      
-      # Instrument Collection write operations
-      Oboe::Inst::Mongo::COLL_WRITE_OPS.reject { |m| not method_defined?(m) }.each do |m|
-        define_method("#{m}_with_oboe") do |*args|
-          report_kvs = oboe_collect(m, args)
-          args_length = args.length
-          
-          begin
-            if m == :find_and_modify and args[0] and args[0].has_key?(:update)
-              report_kvs[:Update_Document] = args[0][:update]
-            end
+            begin
+              if m == :find_and_modify and args[0] and args[0].has_key?(:update)
+                report_kvs[:Update_Document] = args[0][:update]
+              end
 
-            if m == :map_reduce
-              report_kvs[:Map_Function]    = args[0] 
-              report_kvs[:Reduce_Function] = args[1]
-              report_kvs[:Limit] = args[2][:limit] if args[2] and args[2].has_key?(:limit)
-            end
+              if m == :map_reduce
+                report_kvs[:Map_Function]    = args[0] 
+                report_kvs[:Reduce_Function] = args[1]
+                report_kvs[:Limit] = args[2][:limit] if args[2] and args[2].has_key?(:limit)
+              end
 
-            report_kvs[:New_Collection_Name] = args[0] if m == :rename
+              report_kvs[:New_Collection_Name] = args[0] if m == :rename
 
-            if m == :update
-              if args_length >= 3
-                report_kvs[:Update_Document] = args[1].try(:to_json)
-                report_kvs[:Multi] = args[2][:multi] if args[2] and args[2].has_key?(:multi)
+              if m == :update
+                if args_length >= 3
+                  report_kvs[:Update_Document] = args[1].try(:to_json)
+                  report_kvs[:Multi] = args[2][:multi] if args[2] and args[2].has_key?(:multi)
+                end
               end
+            rescue
+            end
+            
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args)
             end
-          rescue
-            logger.warn "[oboe/error] Problem processing mongo args (#{m})" if defined?(logger)
-          end
-          
-          Oboe::API.trace('mongo', report_kvs) do
-            send("#{m}_without_oboe", *args)
           end
-        end
-
-        class_eval "alias #{m}_without_oboe #{m}"
-        class_eval "alias #{m} #{m}_with_oboe"
-      end
-      
-      # Instrument Collection query operations
-      Oboe::Inst::Mongo::COLL_QUERY_OPS.reject { |m| not method_defined?(m) }.each do |m|
-        define_method("#{m}_with_oboe") do |*args|
-          begin
-            report_kvs = oboe_collect(m, args)
-            args_length = args.length
 
-            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
-            end
+          class_eval "alias #{m}_without_oboe #{m}"
+          class_eval "alias #{m} #{m}_with_oboe"
+        end
+        
+        # Instrument Collection query operations
+        Oboe::Inst::Mongo::COLL_QUERY_OPS.reject { |m| not method_defined?(m) }.each do |m|
+          define_method("#{m}_with_oboe") do |*args|
+            begin
+              report_kvs = oboe_collect(m, args)
+              args_length = args.length
+
+              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
+              end
 
-            if m == :find and args_length > 0
-              report_kvs[:Limit] = args[0][:limit] if !args[0].nil? and args[0].has_key?(:limit)
-            end
+              if m == :find and args_length > 0
+                report_kvs[:Limit] = args[0][:limit] if !args[0].nil? and args[0].has_key?(:limit)
+              end
 
-            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_Reduce]    = args[0][:reduce]                if args[0].has_key?(:reduce) 
+              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_Reduce]    = args[0][:reduce]                if args[0].has_key?(:reduce) 
+                  end
                 end
               end
+            rescue
             end
-          rescue
-            logger.warn "[oboe/error] Problem processing mongo args (#{m})" if defined?(logger)
-          end
 
-          Oboe::API.trace('mongo', report_kvs) do
-            send("#{m}_without_oboe", *args)
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args)
+            end
           end
+
+          class_eval "alias #{m}_without_oboe #{m}"
+          class_eval "alias #{m} #{m}_with_oboe"
         end
+        
+        # Instrument Collection index operations
+        Oboe::Inst::Mongo::COLL_INDEX_OPS.reject { |m| not method_defined?(m) }.each do |m|
+          define_method("#{m}_with_oboe") do |*args|
+            report_kvs = oboe_collect(m, args)
+            _args = args || []
+           
+            begin
+              if [:create_index, :ensure_index, :drop_index].include? m and not _args.empty?
+                report_kvs[:Index] = _args[0].try(:to_json)
+              end
+            rescue
+            end
 
-        class_eval "alias #{m}_without_oboe #{m}"
-        class_eval "alias #{m} #{m}_with_oboe"
-      end
-      
-      # Instrument Collection index operations
-      Oboe::Inst::Mongo::COLL_INDEX_OPS.reject { |m| not method_defined?(m) }.each do |m|
-        define_method("#{m}_with_oboe") do |*args|
-          report_kvs = oboe_collect(m, args)
-          _args = args || []
-         
-          begin
-            if [:create_index, :ensure_index, :drop_index].include? m and not _args.empty?
-              report_kvs[:Index] = _args[0].try(:to_json)
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args)
             end
-          rescue
-            logger.warn "[oboe/error] Problem processing mongo args (#{m})" if defined?(logger)
           end
 
-          Oboe::API.trace('mongo', report_kvs) do
-            send("#{m}_without_oboe", *args)
-          end
+          class_eval "alias #{m}_without_oboe #{m}"
+          class_eval "alias #{m} #{m}_with_oboe"
         end
-
-        class_eval "alias #{m}_without_oboe #{m}"
-        class_eval "alias #{m} #{m}_with_oboe"
       end
     end
   end
-  puts "[oboe/loading] Instrumenting mongo" if Oboe::Config[:verbose]
 end
 

data/lib/oboe/inst/moped.rb

@@ -22,394 +22,396 @@ module Oboe
   end
 end
 
-puts "[oboe/loading] Instrumenting moped" if Oboe::Config[:verbose] and defined?(::Moped)
-
-if defined?(::Moped::Database)
-  module ::Moped
-    class Database
-      include Oboe::Inst::Moped
-      
-      def extract_trace_details(op)
-        report_kvs = {}
-        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(':')
-          report_kvs[:Database] = name
-          report_kvs[:QueryOp] = op.to_s
-        rescue
+if defined?(::Moped) and Oboe::Config[:moped][:enabled]
+  puts "[oboe/loading] Instrumenting moped" if Oboe::Config[:verbose]
+
+  if defined?(::Moped::Database)
+    module ::Moped
+      class Database
+        include Oboe::Inst::Moped
+        
+        def extract_trace_details(op)
+          report_kvs = {}
+          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(':')
+            report_kvs[:Database] = name
+            report_kvs[:QueryOp] = op.to_s
+          rescue
+          end
+          report_kvs
         end
-        report_kvs
-      end
-     
-      def command_with_oboe(command)
-        if Oboe::Config.tracing? and not Oboe::Context.layer_op and command.has_key?(:mapreduce)
-          report_kvs = extract_trace_details(:map_reduce)
-          report_kvs[:Map_Function] = command[:map]
-          report_kvs[:Reduce_Function] = command[:reduce]
-
-          Oboe::API.trace('mongo', report_kvs) do
+       
+        def command_with_oboe(command)
+          if Oboe.tracing? and not Oboe::Context.layer_op and command.has_key?(:mapreduce)
+            report_kvs = extract_trace_details(:map_reduce)
+            report_kvs[:Map_Function] = command[:map]
+            report_kvs[:Reduce_Function] = command[:reduce]
+
+            Oboe::API.trace('mongo', report_kvs) do
+              command_without_oboe(command)
+            end
+          else
             command_without_oboe(command)
           end
-        else
-          command_without_oboe(command)
         end
-      end
 
-      def drop_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:drop_database)
+        def drop_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:drop_database)
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              drop_without_oboe
+            end
+          else
             drop_without_oboe
           end
-        else
-          drop_without_oboe
         end
-      end
-      
-      Oboe::Inst::Moped::DB_OPS.each do |m|
-        if method_defined?(m)
-          class_eval "alias #{m}_without_oboe #{m}"
-          class_eval "alias #{m} #{m}_with_oboe"
-        else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+        
+        Oboe::Inst::Moped::DB_OPS.each do |m|
+          if method_defined?(m)
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+          end
         end
       end
     end
   end
-end
 
-if defined?(::Moped::Indexes)
-  module ::Moped
-    class Indexes 
-      include Oboe::Inst::Moped
-      
-      def extract_trace_details(op)
-        report_kvs = {}
-        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[:QueryOp] = op.to_s
-        rescue
+  if defined?(::Moped::Indexes)
+    module ::Moped
+      class Indexes 
+        include Oboe::Inst::Moped
+        
+        def extract_trace_details(op)
+          report_kvs = {}
+          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[:QueryOp] = op.to_s
+          rescue
+          end
+          report_kvs
         end
-        report_kvs
-      end
-      
-      def create_with_oboe(key, options = {})
-        if Oboe::Config.tracing?
-          # We report :create_index here to be consistent
-          # with other mongo implementations
-          report_kvs = extract_trace_details(:create_index)
-          report_kvs[:Key] = key.try(:to_json)
-          report_kvs[:Options] = options.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs, :create_index) do
+        
+        def create_with_oboe(key, options = {})
+          if Oboe.tracing?
+            # We report :create_index here to be consistent
+            # with other mongo implementations
+            report_kvs = extract_trace_details(:create_index)
+            report_kvs[:Key] = key.try(:to_json)
+            report_kvs[:Options] = options.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs, :create_index) do
+              create_without_oboe(key, options = {})
+            end
+          else
             create_without_oboe(key, options = {})
           end
-        else
-          create_without_oboe(key, options = {})
         end
-      end
-      
-      def drop_with_oboe(key = nil)
-        if Oboe::Config.tracing?
-          # 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.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def drop_with_oboe(key = nil)
+          if Oboe.tracing?
+            # 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.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              drop_without_oboe(key = nil)
+            end
+          else
             drop_without_oboe(key = nil)
           end
-        else
-          drop_without_oboe(key = nil)
         end
-      end
 
-      Oboe::Inst::Moped::INDEX_OPS.each do |m|
-        if method_defined?(m)
-          class_eval "alias #{m}_without_oboe #{m}"
-          class_eval "alias #{m} #{m}_with_oboe"
-        else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+        Oboe::Inst::Moped::INDEX_OPS.each do |m|
+          if method_defined?(m)
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+          end
         end
       end
     end
   end
-end
 
-if defined?(::Moped::Query)
-  module ::Moped
-    class Query
-      include Oboe::Inst::Moped
-
-
-      def extract_trace_details(op)
-        report_kvs = {}
-        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(':')
-          report_kvs[:Database] = collection.database.name
-          report_kvs[:Collection_Name] = collection.name
-          report_kvs[:QueryOp] = op.to_s
-        rescue
+  if defined?(::Moped::Query)
+    module ::Moped
+      class Query
+        include Oboe::Inst::Moped
+
+
+        def extract_trace_details(op)
+          report_kvs = {}
+          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(':')
+            report_kvs[:Database] = collection.database.name
+            report_kvs[:Collection_Name] = collection.name
+            report_kvs[:QueryOp] = op.to_s
+          rescue
+          end
+          report_kvs
         end
-        report_kvs
-      end
-      
-      def count_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:count)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def count_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:count)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              count_without_oboe
+            end
+          else
             count_without_oboe
           end
-        else
-          count_without_oboe
         end
-      end
 
-      def sort_with_oboe(sort)
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:sort)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
-          report_kvs[:Order] = sort.to_s
+        def sort_with_oboe(sort)
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:sort)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+            report_kvs[:Order] = sort.to_s
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              sort_without_oboe(sort)
+            end
+          else
             sort_without_oboe(sort)
           end
-        else
-          sort_without_oboe(sort)
         end
-      end
-      
-      def limit_with_oboe(limit)
-        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?(:explain)
-          report_kvs = extract_trace_details(:limit)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
-          report_kvs[:Limit] = limit.to_s
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def limit_with_oboe(limit)
+          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:explain)
+            report_kvs = extract_trace_details(:limit)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+            report_kvs[:Limit] = limit.to_s
+
+            Oboe::API.trace('mongo', report_kvs) do
+              limit_without_oboe(limit)
+            end
+          else
             limit_without_oboe(limit)
           end
-        else
-          limit_without_oboe(limit)
         end
-      end
 
-      def distinct_with_oboe(key)
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:distinct)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
-          report_kvs[:Key] = key.to_s
+        def distinct_with_oboe(key)
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:distinct)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+            report_kvs[:Key] = key.to_s
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              distinct_without_oboe(key)
+            end
+          else
             distinct_without_oboe(key)
           end
-        else
-          distinct_without_oboe(key)
         end
-      end
-      
-      def update_with_oboe(change, flags = nil)
-        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?([:update_all, :upsert])
-          report_kvs = extract_trace_details(:update)
-          report_kvs[:Flags] = flags.to_s if flags
-          report_kvs[:Update_Document] = change.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def update_with_oboe(change, flags = nil)
+          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?([:update_all, :upsert])
+            report_kvs = extract_trace_details(:update)
+            report_kvs[:Flags] = flags.to_s if flags
+            report_kvs[:Update_Document] = change.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              update_without_oboe(change, flags = nil)
+            end
+          else
             update_without_oboe(change, flags = nil)
           end
-        else
-          update_without_oboe(change, flags = nil)
         end
-      end
-      
-      def update_all_with_oboe(change)
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:update_all)
-          report_kvs[:Update_Document] = change.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs, :update_all) do
+        
+        def update_all_with_oboe(change)
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:update_all)
+            report_kvs[:Update_Document] = change.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs, :update_all) do
+              update_all_without_oboe(change)
+            end
+          else
             update_all_without_oboe(change)
           end
-        else
-          update_all_without_oboe(change)
         end
-      end
 
-      def upsert_with_oboe(change)
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:upsert)
-          report_kvs[:Query] = selector.try(:to_json)
-          report_kvs[:Update_Document] = change.try(:to_json)
+        def upsert_with_oboe(change)
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:upsert)
+            report_kvs[:Query] = selector.try(:to_json)
+            report_kvs[:Update_Document] = change.try(:to_json)
 
-          Oboe::API.trace('mongo', report_kvs, :upsert) do
+            Oboe::API.trace('mongo', report_kvs, :upsert) do
+              upsert_without_oboe(change)
+            end
+          else
             upsert_without_oboe(change)
           end
-        else
-          upsert_without_oboe(change)
         end
-      end
 
-      def explain_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:explain)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+        def explain_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:explain)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
 
-          Oboe::API.trace('mongo', report_kvs, :explain) do
+            Oboe::API.trace('mongo', report_kvs, :explain) do
+              explain_without_oboe
+            end
+          else
             explain_without_oboe
           end
-        else
-          explain_without_oboe
         end
-      end
-
-      def modify_with_oboe(change, options = {})
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:modify)
-          report_kvs[:Update_Document] = selector.try(:empty?) ? "all" : selector.try(:to_json)
-          report_kvs[:Change] = change.try(:to_json)
-          report_kvs[:Options] = options.try(:to_json)
 
-          Oboe::API.trace('mongo', report_kvs) do
+        def modify_with_oboe(change, options = {})
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:modify)
+            report_kvs[:Update_Document] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+            report_kvs[:Change] = change.try(:to_json)
+            report_kvs[:Options] = options.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              modify_without_oboe(change, options)
+            end
+          else
             modify_without_oboe(change, options)
           end
-        else
-          modify_without_oboe(change, options)
         end
-      end
-      
-      def remove_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:remove)
-          report_kvs[:Query] = selector.try(:to_json)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def remove_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:remove)
+            report_kvs[:Query] = selector.try(:to_json)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              remove_without_oboe
+            end
+          else
             remove_without_oboe
           end
-        else
-          remove_without_oboe
         end
-      end
 
-      def remove_all_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:remove_all)
-          report_kvs[:Query] = selector.try(:to_json)
+        def remove_all_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:remove_all)
+            report_kvs[:Query] = selector.try(:to_json)
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              remove_all_without_oboe
+            end
+          else
             remove_all_without_oboe
           end
-        else
-          remove_all_without_oboe
         end
-      end
 
-      Oboe::Inst::Moped::QUERY_OPS.each do |m|
-        if method_defined?(m)
-          class_eval "alias #{m}_without_oboe #{m}"
-          class_eval "alias #{m} #{m}_with_oboe"
-        else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+        Oboe::Inst::Moped::QUERY_OPS.each do |m|
+          if method_defined?(m)
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+          end
         end
       end
     end
-  end
-end # ::Moped::Query
-
-
-if defined?(::Moped::Collection)
-  module ::Moped
-    class Collection
-      include Oboe::Inst::Moped
-
-      def extract_trace_details(op)
-        report_kvs = {}
-        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] = @name
-          report_kvs[:QueryOp] = op.to_s
-        rescue
+  end # ::Moped::Query
+
+
+  if defined?(::Moped::Collection)
+    module ::Moped
+      class Collection
+        include Oboe::Inst::Moped
+
+        def extract_trace_details(op)
+          report_kvs = {}
+          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] = @name
+            report_kvs[:QueryOp] = op.to_s
+          rescue
+          end
+          report_kvs
         end
-        report_kvs
-      end
 
-      def drop_with_oboe
-        if Oboe::Config.tracing?
-          # We report :drop_collection here to be consistent
-          # with other mongo implementations
-          report_kvs = extract_trace_details(:drop_collection)
+        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)
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              drop_without_oboe
+            end
+          else
             drop_without_oboe
           end
-        else
-          drop_without_oboe
         end
-      end
 
-      def find_with_oboe(selector = {})
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:find)
-          report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
+        def find_with_oboe(selector = {})
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:find)
+            report_kvs[:Query] = selector.try(:empty?) ? "all" : selector.try(:to_json)
 
-          Oboe::API.trace('mongo', report_kvs) do
+            Oboe::API.trace('mongo', report_kvs) do
+              find_without_oboe(selector)
+            end
+          else
             find_without_oboe(selector)
           end
-        else
-          find_without_oboe(selector)
         end
-      end
-      
-      def indexes_with_oboe
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:indexes)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def indexes_with_oboe
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:indexes)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              indexes_without_oboe
+            end
+          else
             indexes_without_oboe
           end
-        else
-          indexes_without_oboe
         end
-      end
-      
-      def insert_with_oboe(documents, flags = nil)
-        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?(:create_index)
-          report_kvs = extract_trace_details(:insert)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def insert_with_oboe(documents, flags = nil)
+          if Oboe.tracing? and not Oboe::Context.tracing_layer_op?(:create_index)
+            report_kvs = extract_trace_details(:insert)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              insert_without_oboe(documents, flags)
+            end
+          else
             insert_without_oboe(documents, flags)
           end
-        else
-          insert_without_oboe(documents, flags)
         end
-      end
-      
-      def aggregate_with_oboe(pipeline)
-        if Oboe::Config.tracing?
-          report_kvs = extract_trace_details(:aggregate)
-
-          Oboe::API.trace('mongo', report_kvs) do
+        
+        def aggregate_with_oboe(pipeline)
+          if Oboe.tracing?
+            report_kvs = extract_trace_details(:aggregate)
+
+            Oboe::API.trace('mongo', report_kvs) do
+              aggregate_without_oboe(pipeline)
+            end
+          else
             aggregate_without_oboe(pipeline)
           end
-        else
-          aggregate_without_oboe(pipeline)
         end
-      end
-      
-      Oboe::Inst::Moped::COLLECTION_OPS.each do |m|
-        if method_defined?(m)
-          class_eval "alias #{m}_without_oboe #{m}"
-          class_eval "alias #{m} #{m}_with_oboe"
-        else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+        
+        Oboe::Inst::Moped::COLLECTION_OPS.each do |m|
+          if method_defined?(m)
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          else puts "[oboe/loading] Couldn't properly instrument moped (#{m}).  Partial traces may occur."
+          end
         end
       end
     end
-  end
-end # ::Moped::Collection
+  end # ::Moped::Collection
+end