oboe 2.7.0.3-java

data/lib/oboe/inst/dalli.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Inst
+    module Dalli
+      include Oboe::API::Memcache
+
+      def self.included(cls)
+        cls.class_eval do
+          Oboe.logger.info "[oboe/loading] Instrumenting memcache (dalli)" if Oboe::Config[:verbose]
+          if ::Dalli::Client.private_method_defined? :perform
+            alias perform_without_oboe perform
+            alias perform perform_with_oboe
+          else Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcache (Dalli).  Partial traces may occur."
+          end
+
+          if ::Dalli::Client.method_defined? :get_multi
+            alias get_multi_without_oboe get_multi
+            alias get_multi get_multi_with_oboe
+          end
+        end
+      end
+
+      def perform_with_oboe(*all_args, &blk)
+        op, key, *args = *all_args
+
+        if Oboe.tracing? and not Oboe.tracing_layer_op?(:get_multi)
+          Oboe::API.trace('memcache', { :KVOp => op, :KVKey => key }) do
+            result = perform_without_oboe(*all_args, &blk)
+
+            info_kvs = {}
+            info_kvs[:KVHit] = memcache_hit?(result) if op == :get and key.class == String
+            info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:dalli][:collect_backtraces]
+
+            Oboe::API.log('memcache', 'info', info_kvs) unless info_kvs.empty?
+            result
+          end
+        else
+          perform_without_oboe(*all_args, &blk)
+        end
+      end
+
+      def get_multi_with_oboe(*keys)
+        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', { :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
+        end
+      end
+    end
+  end
+end
+
+if defined?(Dalli) and Oboe::Config[:dalli][:enabled]
+  ::Dalli::Client.module_eval do
+    include Oboe::Inst::Dalli
+  end
+end

data/lib/oboe/inst/http.rb

@@ -0,0 +1,72 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'net/http'
+
+if Oboe::Config[:nethttp][:enabled]
+
+  Net::HTTP.class_eval do
+    def request_with_oboe(*args, &block)
+      unless started?
+        return request_without_oboe(*args, &block)
+      end
+
+      # Avoid cross host tracing for blacklisted domains
+      blacklisted = Oboe::API.blacklisted?(addr_port)
+
+      Oboe::API.trace('net-http') do
+        opts = {}
+        context = Oboe::Context.toString()
+        task_id = Oboe::XTrace.task_id(context)
+
+        # Collect KVs to report in the info event
+        if args.length and args[0]
+          req = args[0]
+
+          opts['IsService'] = 1
+          opts['RemoteProtocol'] = use_ssl? ? 'HTTPS' : 'HTTP'
+          opts['RemoteHost'] = addr_port
+          opts['ServiceArg'] = req.path
+          opts['HTTPMethod'] = req.method
+          opts['Blacklisted'] = true if blacklisted
+          opts['Backtrace'] = Oboe::API.backtrace if Oboe::Config[:nethttp][:collect_backtraces]
+
+          req['X-Trace'] = context unless blacklisted
+        end
+
+        begin
+          # The actual net::http call
+          resp = request_without_oboe(*args, &block)
+
+          # Re-attach net::http edge unless blacklisted and is a valid X-Trace ID
+          unless blacklisted
+            xtrace = resp.get_fields('X-Trace')
+            xtrace = xtrace[0] if xtrace and xtrace.is_a?(Array)
+
+            if Oboe::XTrace.valid?(xtrace) and Oboe.tracing?
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == Oboe::XTrace.task_id(xtrace)
+                Oboe::Context.fromString(xtrace)
+              else
+                Oboe.logger.debug "Mismatched returned X-Trace ID : #{xtrace}"
+              end
+            end
+          end
+
+          opts['HTTPStatus'] = resp.code
+
+          next resp
+        ensure
+          # Log the info event with the KVs in opts
+          Oboe::API.log('net-http', 'info', opts)
+        end
+      end
+    end
+
+    alias request_without_oboe request
+    alias request request_with_oboe
+
+    Oboe.logger.info "[oboe/loading] Instrumenting net/http" if Oboe::Config[:verbose]
+  end
+end

data/lib/oboe/inst/memcache.rb

@@ -0,0 +1,105 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Inst
+    module MemCache
+      include Oboe::API::Memcache
+
+      def self.included(cls)
+        Oboe.logger.info "[oboe/loading] Instrumenting memcache" if Oboe::Config[:verbose]
+
+        cls.class_eval do
+          MEMCACHE_OPS.reject { |m| not method_defined?(m) }.each do |m|
+
+            define_method("#{m}_with_oboe") do |*args|
+              report_kvs = { :KVOp => m }
+              report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcache][:collect_backtraces]
+
+              if Oboe.tracing?
+                Oboe::API.trace('memcache', report_kvs) do
+                  result = send("#{m}_without_oboe", *args)
+                end
+              else
+                result = send("#{m}_without_oboe", *args)
+              end
+              result
+            end
+
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          end
+        end
+
+        [: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: #{m}"
+          end
+        end
+      end
+
+      def get_multi_with_oboe(*args)
+        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
+        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.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
+          request_setup_without_oboe(*args)
+        end
+      end
+
+      def cache_get_with_oboe(server, cache_key)
+        result = cache_get_without_oboe(server, cache_key)
+
+        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
+
+    end # module MemCache
+  end # module Inst
+end # module Oboe
+
+if defined?(::MemCache) and Oboe::Config[:memcache][:enabled]
+  ::MemCache.class_eval do
+    include Oboe::Inst::MemCache
+  end
+end
+

data/lib/oboe/inst/memcached.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module Oboe
+  module Inst
+    module Memcached
+      include Oboe::API::Memcache
+
+      def self.included(cls)
+        Oboe.logger.info "[oboe/loading] Instrumenting memcached" if Oboe::Config[:verbose]
+
+        cls.class_eval do
+          MEMCACHE_OPS.reject { |m| not method_defined?(m) }.each do |m|
+            define_method("#{m}_with_oboe") do |*args|
+              opts = { :KVOp => m }
+
+              if args.length and args[0].class != Array
+                opts[:KVKey] = args[0].to_s
+                rhost = remote_host(args[0].to_s)
+                opts[:RemoteHost] = rhost if rhost
+              end
+
+              Oboe::API.trace('memcache', opts) do
+                result = send("#{m}_without_oboe", *args)
+
+                info_kvs = {}
+                info_kvs[:KVHit] = memcache_hit?(result) if m == :get and args.length and args[0].class == String
+                info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcached][:collect_backtraces]
+
+                Oboe::API.log('memcache', 'info', info_kvs) unless info_kvs.empty?
+                result
+              end
+            end
+
+            class_eval "alias #{m}_without_oboe #{m}"
+            class_eval "alias #{m} #{m}_with_oboe"
+          end
+        end
+      end
+
+    end # module Memcached
+
+    module MemcachedRails
+      def self.included(cls)
+        cls.class_eval do
+          if ::Memcached::Rails.method_defined? :get_multi
+            alias get_multi_without_oboe get_multi
+            alias get_multi get_multi_with_oboe
+          elsif Oboe::Config[:verbose]
+            Oboe.logger.warn "[oboe/loading] Couldn't properly instrument Memcached.  Partial traces may occur."
+          end
+        end
+      end
+
+      def get_multi_with_oboe(keys, raw=false)
+        if Oboe.tracing?
+          layer_kvs = {}
+          layer_kvs[:KVOp] = :get_multi
+
+          Oboe::API.trace('memcache', layer_kvs || {}, :get_multi) do
+            begin
+              info_kvs = {}
+              info_kvs[:KVKeyCount] = keys.flatten.length
+
+              values = get_multi_without_oboe(keys, raw)
+
+              info_kvs[:KVHitCount] = values.length
+              info_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:memcached][:collect_backtraces]
+
+              Oboe::API.log('memcache', 'info', info_kvs)
+            rescue
+              values = get_multi_without_oboe(keys, raw)
+            end
+            values
+          end
+        else
+          get_multi_without_oboe(keys, raw)
+        end
+      end
+
+    end # module MemcachedRails
+  end # module Inst
+end # module Oboe
+
+if defined?(::Memcached) and Oboe::Config[:memcached][:enabled]
+  ::Memcached.class_eval do
+    include Oboe::Inst::Memcached
+  end
+
+  if defined?(::Memcached::Rails)
+    ::Memcached::Rails.class_eval do
+      include Oboe::Inst::MemcachedRails
+    end
+  end
+end
+

data/lib/oboe/inst/mongo.rb

@@ -0,0 +1,240 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+require 'json'
+
+module Oboe
+  module Inst
+    module Mongo
+      FLAVOR = 'mongodb'
+
+      # Operations for Mongo::DB
+      DB_OPS         = [ :create_collection, :drop_collection ]
+
+      # Operations for Mongo::Cursor
+      CURSOR_OPS     = [ :count ]
+
+      # Operations for Mongo::Collection
+      COLL_WRITE_OPS = [ :find_and_modify, :insert, :map_reduce, :remove, :rename, :update ]
+      COLL_QUERY_OPS = [ :distinct, :find, :group ]
+      COLL_INDEX_OPS = [ :create_index, :drop_index, :drop_indexes, :ensure_index, :index_information ]
+    end
+  end
+end
+
+if defined?(::Mongo) and Oboe::Config[:mongo][:enabled]
+  Oboe.logger.info "[oboe/loading] Instrumenting mongo" if Oboe::Config[:verbose]
+
+  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 = {}
+
+            begin
+              report_kvs[:Flavor] = Oboe::Inst::Mongo::FLAVOR
+
+              report_kvs[:Database] = @name
+
+              # Mongo >= 1.10 uses @client instead of @connection
+              # Avoid the nil
+              if @connection
+                report_kvs[:RemoteHost] = @connection.host
+                report_kvs[:RemotePort] = @connection.port
+              elsif @client
+                report_kvs[:RemoteHost] = @client.host
+                report_kvs[:RemotePort] = @client.port
+              end
+
+              report_kvs[:QueryOp] = m
+
+              report_kvs[:New_Collection_Name] = args[0] if m == :create_collection
+              report_kvs[:Collection] = args[0]          if m == :drop_collection
+
+              report_kvs[:Backtrace] = Oboe::API.backtrace if Oboe::Config[:mongo][:collect_backtraces]
+            rescue
+            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
+      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.to_json
+                else
+                  report_kvs[:Query] = 'all'
+                end
+                report_kvs[:Limit] = @limit if @limit != 0
+              end
+            rescue
+            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
+      end
+    end
+  end
+
+  if defined?(::Mongo::Collection)
+    module ::Mongo
+      class Collection
+        include Oboe::Inst::Mongo
+
+        def oboe_collect(m, args)
+          begin
+            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 if Oboe::Config[:mongo][:collect_backtraces]
+
+            report_kvs[:QueryOp] = m
+            report_kvs[:Query] = args[0].to_json if args and not args.empty? and args[0].class == Hash
+          rescue StandardError => e
+            Oboe.logger.debug "[oboe/debug] Exception in oboe_collect KV collection: #{e.inspect}"
+          end
+          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].inspect
+              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
+
+              if m == :update
+                if args_length >= 3
+                  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
+            rescue
+            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, &blk|
+            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].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 == :group
+                unless args.empty?
+                  if args[0].is_a?(Hash)
+                    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
+              end
+            rescue
+            end
+
+            Oboe::API.trace('mongo', report_kvs) do
+              send("#{m}_without_oboe", *args, &blk)
+            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].to_json
+              end
+            rescue
+            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
+      end
+    end
+  end
+end
+