traceview 3.0.0

data/lib/traceview/inst/cassandra.rb

@@ -0,0 +1,279 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module Cassandra
+      def extract_trace_details(op, column_family, keys, args, options = {})
+        report_kvs = {}
+
+        begin
+          report_kvs[:Op] = op.to_s
+          report_kvs[:Cf] = column_family.to_s if column_family
+          report_kvs[:Key] = keys.inspect if keys
+
+          # Open issue - how to handle multiple Cassandra servers
+          report_kvs[:RemoteHost], report_kvs[:RemotePort] = @servers.first.split(':')
+
+          report_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:cassandra][:collect_backtraces]
+
+          if options.empty? && args.is_a?(Array)
+            options = args.last if args.last.is_a?(Hash)
+          end
+
+          unless options.empty?
+            [:start_key, :finish_key, :key_count, :batch_size, :columns, :count, :start,
+             :stop, :finish, :finished, :reversed, :consistency, :ttl].each do |k|
+              report_kvs[k.to_s.capitalize] = options[k] if options.key?(k)
+            end
+
+            if op == :get_indexed_slices
+              index_clause = columns_and_options[:index_clause] || {}
+              unless index_clause.empty?
+                [:column_name, :value, :comparison].each do |k|
+                  report_kvs[k.to_s.capitalize] = index_clause[k] if index_clause.key?(k)
+                end
+              end
+            end
+          end
+        rescue
+        end
+
+        report_kvs
+      end
+
+      def insert_with_traceview(column_family, key, hash, options = {})
+        return insert_without_traceview(column_family, key, hash, options = {}) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:insert, column_family, key, hash, options)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          insert_without_traceview(column_family, key, hash, options = {})
+        end
+      end
+
+      def remove_with_traceview(column_family, key, *columns_and_options)
+        return send :remove_without_traceview, *args unless TraceView.tracing?
+
+        args = [column_family, key] + columns_and_options
+        report_kvs = extract_trace_details(:remove, column_family, key, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          send :remove_without_traceview, *args
+        end
+      end
+
+      def count_columns_with_traceview(column_family, key, *columns_and_options)
+        return send :count_columns_without_traceview, *args unless TraceView.tracing?
+
+        args = [column_family, key] + columns_and_options
+        report_kvs = extract_trace_details(:count_columns, column_family, key, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          send :count_columns_without_traceview, *args
+        end
+      end
+
+      def get_columns_with_traceview(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:multi_get_columns)
+          report_kvs = extract_trace_details(:get_columns, column_family, key, columns_and_options)
+
+          TraceView::API.trace('cassandra', report_kvs) do
+            send :get_columns_without_traceview, *args
+          end
+        else
+          send :get_columns_without_traceview, *args
+        end
+      end
+
+      def multi_get_columns_with_traceview(column_family, key, *columns_and_options)
+        return send :multi_get_columns_without_traceview, *args unless TraceView.tracing?
+
+        args = [column_family, key] + columns_and_options
+        report_kvs = extract_trace_details(:multi_get_columns, column_family, key, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs, :multi_get_columns) do
+          send :multi_get_columns_without_traceview, *args
+        end
+      end
+
+      def get_with_traceview(column_family, key, *columns_and_options)
+        return send :get_without_traceview, *args unless TraceView.tracing?
+
+        args = [column_family, key] + columns_and_options
+        report_kvs = extract_trace_details(:get, column_family, key, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs, :get) do
+          send :get_without_traceview, *args
+        end
+      end
+
+      def multi_get_with_traceview(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:get)
+          report_kvs = extract_trace_details(:multi_get, column_family, key, columns_and_options)
+
+          TraceView::API.trace('cassandra', report_kvs) do
+            send :multi_get_without_traceview, *args
+          end
+        else
+          send :multi_get_without_traceview, *args
+        end
+      end
+
+      def exists_with_traceview?(column_family, key, *columns_and_options)
+        return send :exists_without_traceview?, *args unless TraceView.tracing?
+
+        args = [column_family, key] + columns_and_options
+        report_kvs = extract_trace_details(:exists?, column_family, key, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          send :exists_without_traceview?, *args
+        end
+      end
+
+      def get_range_single_with_traceview(column_family, options = {})
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:get_range_batch)
+          report_kvs = extract_trace_details(:get_range_single, column_family, nil, nil)
+
+          TraceView::API.trace('cassandra', report_kvs) do
+            get_range_single_without_traceview(column_family, options)
+          end
+        else
+          get_range_single_without_traceview(column_family, options)
+        end
+      end
+
+      def get_range_batch_with_traceview(column_family, options = {})
+        return get_range_batch_without_traceview(column_family, options) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:get_range_batch, column_family, nil, nil)
+
+        TraceView::API.trace('cassandra', report_kvs, :get_range_batch) do
+          get_range_batch_without_traceview(column_family, options)
+        end
+      end
+
+      def get_indexed_slices_with_traceview(column_family, index_clause, *columns_and_options)
+        return send :get_indexed_slices_without_traceview, *args unless TraceView.tracing?
+
+        args = [column_family, index_clause] + columns_and_options
+        report_kvs = extract_trace_details(:get_indexed_slices, column_family, nil, columns_and_options)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          send :get_indexed_slices_without_traceview, *args
+        end
+      end
+
+      def create_index_with_traceview(keyspace, column_family, column_name, validation_class)
+        unless TraceView.tracing?
+          return create_index_without_traceview(keyspace, column_family, column_name, validation_class)
+        end
+
+        report_kvs = extract_trace_details(:create_index, column_family, nil, nil)
+        begin
+          report_kvs[:Keyspace] = keyspace.to_s
+          report_kvs[:Column_name] = column_name.to_s
+          report_kvs[:Validation_class] = validation_class.to_s
+        rescue
+        end
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          create_index_without_traceview(keyspace, column_family, column_name, validation_class)
+        end
+      end
+
+      def drop_index_with_traceview(keyspace, column_family, column_name)
+        return drop_index_without_traceview(keyspace, column_family, column_name) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:drop_index, column_family, nil, nil)
+        begin
+          report_kvs[:Keyspace] = keyspace.to_s
+          report_kvs[:Column_name] = column_name.to_s
+        rescue
+        end
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          drop_index_without_traceview(keyspace, column_family, column_name)
+        end
+      end
+
+      def add_column_family_with_traceview(cf_def)
+        return add_column_family_without_traceview(cf_def) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:add_column_family, nil, nil, nil)
+        begin
+          report_kvs[:Cf] = cf_def[:name] if cf_def.is_a?(Hash) && cf_def.key?(:name)
+        rescue
+        end
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          add_column_family_without_traceview(cf_def)
+        end
+      end
+
+      def drop_column_family_with_traceview(column_family)
+        return drop_column_family_without_traceview(column_family) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:drop_column_family, column_family, nil, nil)
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          drop_column_family_without_traceview(column_family)
+        end
+      end
+
+      def add_keyspace_with_traceview(ks_def)
+        return add_keyspace_without_traceview(ks_def) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:add_keyspace, nil, nil, nil)
+        report_kvs[:Name] = ks_def.name rescue ''
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          add_keyspace_without_traceview(ks_def)
+        end
+      end
+
+      def drop_keyspace_with_traceview(keyspace)
+        return drop_keyspace_without_traceview(keyspace) unless TraceView.tracing?
+
+        report_kvs = extract_trace_details(:drop_keyspace, nil, nil, nil)
+        report_kvs[:Name] = keyspace.to_s rescue ''
+
+        TraceView::API.trace('cassandra', report_kvs) do
+          drop_keyspace_without_traceview(keyspace)
+        end
+      end
+    end
+  end
+end
+
+if defined?(::Cassandra) && TraceView::Config[:cassandra][:enabled]
+  TraceView.logger.info '[traceview/loading] Instrumenting cassandra' if TraceView::Config[:verbose]
+
+  class ::Cassandra
+    include TraceView::Inst::Cassandra
+
+    [:insert, :remove, :count_columns, :get_columns, :multi_get_columns, :get,
+     :multi_get, :get_range_single, :get_range_batch, :get_indexed_slices,
+     :create_index, :drop_index, :add_column_family, :drop_column_family,
+     :add_keyspace, :drop_keyspace].each do |m|
+      if method_defined?(m)
+        class_eval "alias #{m}_without_traceview #{m}"
+        class_eval "alias #{m} #{m}_with_traceview"
+      else TraceView.logger.warn "[traceview/loading] Couldn't properly instrument Cassandra (#{m}).  Partial traces may occur."
+      end
+    end
+
+    # Special case handler for question mark methods
+    if method_defined?(:exists?)
+      alias exists_without_traceview? exists?
+      alias exists? exists_with_traceview?
+    else TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument Cassandra (exists?).  Partial traces may occur.'
+    end
+  end # class Cassandra
+end
+
+

data/lib/traceview/inst/dalli.rb

@@ -0,0 +1,86 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module Dalli
+      include TraceView::API::Memcache
+
+      def self.included(cls)
+        cls.class_eval do
+          TraceView.logger.info '[traceview/loading] Instrumenting memcache (dalli)' if TraceView::Config[:verbose]
+          if ::Dalli::Client.private_method_defined? :perform
+            alias perform_without_traceview perform
+            alias perform perform_with_traceview
+          else TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument Memcache (Dalli).  Partial traces may occur.'
+          end
+
+          if ::Dalli::Client.method_defined? :get_multi
+            alias get_multi_without_traceview get_multi
+            alias get_multi get_multi_with_traceview
+          end
+        end
+      end
+
+      def perform_with_traceview(*all_args, &blk)
+        op, key, *args = *all_args
+
+        report_kvs = {}
+        report_kvs[:KVOp] = op
+        report_kvs[:KVKey] = key
+        if @servers.is_a?(Array) && !@servers.empty?
+          report_kvs[:RemoteHost] = @servers.join(", ")
+        end
+
+        if TraceView.tracing? && !TraceView.tracing_layer_op?(:get_multi)
+          TraceView::API.trace('memcache', report_kvs) do
+            result = perform_without_traceview(*all_args, &blk)
+
+            # Clear the hash for a potential info event
+            report_kvs.clear
+            report_kvs[:KVHit] = memcache_hit?(result) if op == :get && key.class == String
+            report_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:dalli][:collect_backtraces]
+
+            TraceView::API.log('memcache', 'info', report_kvs) unless report_kvs.empty?
+            result
+          end
+        else
+          perform_without_traceview(*all_args, &blk)
+        end
+      end
+
+      def get_multi_with_traceview(*keys)
+        return get_multi_without_traceview(keys) unless TraceView.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?
+          if @servers.is_a?(Array) && !@servers.empty?
+            info_kvs[:RemoteHost] = @servers.join(", ")
+          end
+        rescue
+          TraceView.logger.debug "[traceview/debug] Error collecting info keys: #{e.message}"
+          TraceView.logger.debug e.backtrace
+        end
+
+        TraceView::API.trace('memcache', { :KVOp => :get_multi }, :get_multi) do
+          values = get_multi_without_traceview(keys)
+
+          info_kvs[:KVHitCount] = values.length
+          info_kvs[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:dalli][:collect_backtraces]
+          TraceView::API.log('memcache', 'info', info_kvs)
+
+          values
+        end
+      end
+    end
+  end
+end
+
+if defined?(Dalli) && TraceView::Config[:dalli][:enabled]
+  ::Dalli::Client.module_eval do
+    include TraceView::Inst::Dalli
+  end
+end

data/lib/traceview/inst/em-http-request.rb

@@ -0,0 +1,99 @@
+module TraceView
+  module Inst
+    module EventMachine
+      module HttpConnection
+        def setup_request_with_traceview(*args, &block)
+          report_kvs = {}
+          context = TraceView::Context.toString
+          blacklisted = TraceView::API.blacklisted?(@uri)
+
+          begin
+            report_kvs['IsService'] = 1
+            report_kvs['RemoteURL'] = @uri
+            report_kvs['HTTPMethod'] = args[0]
+            report_kvs['Blacklisted'] = true if blacklisted
+
+            if TraceView::Config[:em_http_request][:collect_backtraces]
+              report_kvs[:Backtrace] = TraceView::API.backtrace
+            end
+          rescue => e
+            TraceView.logger.debug "[traceview/debug] em-http-request KV error: #{e.inspect}"
+          end
+
+          ::TraceView::API.log_entry('em-http-request', report_kvs)
+          client = setup_request_without_traceview(*args, &block)
+          client.req.headers['X-Trace'] = context unless blacklisted
+          client
+        end
+      end
+
+      module HttpClient
+        def parse_response_header_with_traceview(*args, &block)
+          report_kvs = {}
+          xtrace = nil
+          blacklisted = TraceView::API.blacklisted?(@uri)
+
+          begin
+            report_kvs[:HTTPStatus] = args[2]
+            report_kvs[:Async] = 1
+          rescue => e
+            TraceView.logger.debug "[traceview/debug] em-http-request KV error: #{e.inspect}"
+          end
+
+          parse_response_header_without_traceview(*args, &block)
+
+          unless blacklisted
+            headers = args[0]
+            context = TraceView::Context.toString
+            task_id = TraceView::XTrace.task_id(context)
+
+            if headers.is_a?(Hash) && headers.key?('X-Trace')
+              xtrace = headers['X-Trace']
+            end
+
+            if TraceView::XTrace.valid?(xtrace) && TraceView.tracing?
+
+              # Assure that we received back a valid X-Trace with the same task_id
+              if task_id == TraceView::XTrace.task_id(xtrace)
+                TraceView::Context.fromString(xtrace)
+              else
+                TraceView.logger.debug "Mismatched returned X-Trace ID : #{xtrace}"
+              end
+            end
+
+          end
+
+          ::TraceView::API.log_exit('em-http-request', report_kvs)
+        end
+      end
+    end
+  end
+end
+
+if RUBY_VERSION >= '1.9'
+  if defined?(::EventMachine::HttpConnection) && defined?(::EventMachine::HttpClient) && TraceView::Config[:em_http_request][:enabled]
+    TraceView.logger.info '[traceview/loading] Instrumenting em-http-request' if TraceView::Config[:verbose]
+
+    class ::EventMachine::HttpConnection
+      include TraceView::Inst::EventMachine::HttpConnection
+
+      if method_defined?(:setup_request)
+        class_eval 'alias :setup_request_without_traceview :setup_request'
+        class_eval 'alias :setup_request :setup_request_with_traceview'
+      else
+        TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument em-http-request (:setup_request).  Partial traces may occur.'
+      end
+    end
+
+    class ::EventMachine::HttpClient
+      include TraceView::Inst::EventMachine::HttpClient
+
+      if method_defined?(:parse_response_header)
+        class_eval 'alias :parse_response_header_without_traceview :parse_response_header'
+        class_eval 'alias :parse_response_header :parse_response_header_with_traceview'
+      else
+        TraceView.logger.warn '[traceview/loading] Couldn\'t properly instrument em-http-request (:parse_response_header).  Partial traces may occur.'
+      end
+    end
+  end
+end