oboe 1.3.6 → 1.3.7

data/lib/oboe/api/logging.rb

@@ -82,12 +82,12 @@ module Oboe
         xtrace
       end
   
-      def log_entry(layer, opts={}, protect_op=false)
-        Oboe::Context.layer_op = opts[:Op] if protect_op and opts.has_key?(:Op)
+      def log_entry(layer, opts={}, protect_op=nil)
+        Oboe::Context.layer_op = protect_op if protect_op
         log_event(layer, 'entry', Oboe::Context.createEvent, opts)
       end
 
-      def log_exit(layer, opts={}, protect_op=false)
+      def log_exit(layer, opts={}, protect_op=nil)
         Oboe::Context.layer_op = nil if protect_op
         log_event(layer, 'exit', Oboe::Context.createEvent, opts)
       end

data/lib/oboe/api/tracing.rb

@@ -11,6 +11,8 @@ module Oboe
       # layer - The layer the block of code belongs to.
       # opts - A hash containing key/value pairs that will be reported along
       # with the first event of this layer (optional).
+      # protect_op - specify the operating being traced.  Used to avoid
+      # double tracing between operations that call each other
       #
       # Example
       #
@@ -28,7 +30,7 @@ module Oboe
       #   result = computation_with_oboe(1000)
       #
       # Returns the result of the block.
-      def trace(layer, opts={}, protect_op=false)
+      def trace(layer, opts={}, protect_op=nil)
         log_entry(layer, opts, protect_op)
         begin 
           yield

data/lib/oboe/frameworks/rails/inst/cassandra.rb

@@ -83,7 +83,7 @@ module Oboe
       def get_columns_with_oboe(column_family, key, *columns_and_options)
         args = [column_family, key] + columns_and_options
         
-        if Oboe::Config.tracing? and not Oboe::Context.layer_op?(:multi_get_columns)
+        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?(:multi_get_columns)
           report_kvs = extract_trace_details(:get_columns, column_family, key, columns_and_options)
 
           Oboe::API.trace('cassandra', report_kvs) do
@@ -100,7 +100,7 @@ module Oboe
         if Oboe::Config.tracing?
           report_kvs = extract_trace_details(:multi_get_columns, column_family, key, columns_and_options)
 
-          Oboe::API.trace('cassandra', report_kvs, true) do
+          Oboe::API.trace('cassandra', report_kvs, :multi_get_columns) do
             send :multi_get_columns_without_oboe, *args
           end
         else
@@ -114,7 +114,7 @@ module Oboe
         if Oboe::Config.tracing?
           report_kvs = extract_trace_details(:get, column_family, key, columns_and_options)
 
-          Oboe::API.trace('cassandra', report_kvs, true) do
+          Oboe::API.trace('cassandra', report_kvs, :get) do
             send :get_without_oboe, *args
           end
         else
@@ -125,7 +125,7 @@ module Oboe
       def multi_get_with_oboe(column_family, key, *columns_and_options)
         args = [column_family, key] + columns_and_options
         
-        if Oboe::Config.tracing? and not Oboe::Context.layer_op?(:get)
+        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?(:get)
           report_kvs = extract_trace_details(:multi_get, column_family, key, columns_and_options)
 
           Oboe::API.trace('cassandra', report_kvs) do
@@ -151,7 +151,7 @@ module Oboe
       end
       
       def get_range_single_with_oboe(column_family, options = {})
-        if Oboe::Config.tracing? and not Oboe::Context.layer_op?(:get_range_batch)
+        if Oboe::Config.tracing? and not Oboe::Context.tracing_layer_op?(:get_range_batch)
           report_kvs = extract_trace_details(:get_range_single, column_family, nil, nil)
           args = [column_family, options]
 
@@ -168,7 +168,7 @@ module Oboe
           report_kvs = extract_trace_details(:get_range_batch, column_family, nil, nil)
           args = [column_family, options]
 
-          Oboe::API.trace('cassandra', report_kvs, true) do
+          Oboe::API.trace('cassandra', report_kvs, :get_range_batch) do
             get_range_batch_without_oboe(column_family, options)
           end
         else

data/lib/oboe/frameworks/rails/inst/moped.rb

@@ -0,0 +1,415 @@
+# Copyright (c) 2012 by Tracelytics, Inc.
+# All rights reserved.
+
+module Oboe
+  module Inst
+    module Moped
+      FLAVOR = 'mongodb'
+
+      # Moped::Database
+      DB_OPS         = [ :command, :drop ]
+
+      # Moped::Indexes
+      INDEX_OPS      = [ :create, :drop ]
+
+      # Moped::Query
+      QUERY_OPS      = [ :count, :sort, :limit, :distinct, :update, :update_all, :upsert, 
+                         :explain, :modify, :remove, :remove_all ]
+
+      # Moped::Collection
+      COLLECTION_OPS = [ :drop, :find, :indexes, :insert, :aggregate ]
+    end
+  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
+        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
+            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)
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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."
+        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
+        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
+            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
+            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."
+        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
+        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
+            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
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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
+            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
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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
+            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
+            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)
+
+          Oboe::API.trace('mongo', report_kvs, :upsert) do
+            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)
+
+          Oboe::API.trace('mongo', report_kvs, :explain) do
+            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
+            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
+            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)
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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."
+        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
+        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)
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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)
+
+          Oboe::API.trace('mongo', report_kvs) do
+            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
+            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
+            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
+            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."
+        end
+      end
+    end
+  end
+end # ::Moped::Collection

data/lib/oboe/version.rb

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

data/lib/oboe_metal.rb

@@ -18,15 +18,19 @@ module Oboe_metal
     end
 
     def self.layer_op=(op)
-      @layer_op = op.to_s
+      @layer_op = op
     end
 
     def self.layer_op
       @layer_op
     end
 
-    def self.layer_op?(operation)
-      @layer_op == operation.to_s
+    def self.tracing_layer_op?(operation)
+      if operation.is_a?(Array)
+        return operation.include?(@layer_op)
+      else
+        return @layer_op == operation
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oboe
 version: !ruby/object:Gem::Version
-  version: 1.3.6
+  version: 1.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -35,6 +35,7 @@ files:
 - lib/oboe/frameworks/rails/inst/http.rb
 - lib/oboe/frameworks/rails/inst/rack.rb
 - lib/oboe/frameworks/rails/inst/action_controller.rb
+- lib/oboe/frameworks/rails/inst/moped.rb
 - lib/oboe/frameworks/rails/inst/dalli.rb
 - lib/oboe/frameworks/rails/inst/active_record.rb
 - lib/oboe/frameworks/rails/inst/action_view.rb