traceview 3.0.0-java

data/lib/traceview/frameworks/rails/inst/connection_adapters/utils.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+    module ConnectionAdapters
+      module Utils
+
+        def extract_trace_details(sql, name = nil, binds = [])
+          opts = {}
+
+          begin
+            if TraceView::Config[:sanitize_sql]
+              # Sanitize SQL and don't report binds
+              opts[:Query] = sql.gsub(/\'[\s\S][^\']*\'/, '?')
+            else
+              # Report raw SQL and any binds if they exist
+              opts[:Query] = sql.to_s
+              opts[:QueryArgs] = binds.map { |col, val| type_cast(val, col) } unless binds.empty?
+            end
+
+            opts[:Name] = name.to_s if name
+            opts[:Backtrace] = TraceView::API.backtrace if TraceView::Config[:active_record][:collect_backtraces]
+
+            if ::Rails::VERSION::MAJOR == 2
+              config = ::Rails.configuration.database_configuration[::Rails.env]
+            else
+              config = ::Rails.application.config.database_configuration[::Rails.env]
+            end
+
+            opts[:Database]   = config['database'] if config.key?('database')
+            opts[:RemoteHost] = config['host']     if config.key?('host')
+            opts[:Flavor]     = config['adapter']  if config.key?('adapter')
+          rescue StandardError => e
+            TraceView.logger.debug "Exception raised capturing ActiveRecord KVs: #{e.inspect}"
+            TraceView.logger.debug e.backtrace.join('\n')
+          end
+
+          return opts || {}
+        end
+
+        # We don't want to trace framework caches.  Only instrument SQL that
+        # directly hits the database.
+        def ignore_payload?(name)
+          %w(SCHEMA EXPLAIN CACHE).include?(name.to_s) ||
+            (name && name.to_sym == :skip_logging) ||
+              name == 'ActiveRecord::SchemaMigration Load'
+        end
+
+        # def cfg
+        #   @config
+        # end
+
+        def execute_with_traceview(sql, name = nil)
+          if TraceView.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name)
+            TraceView::API.trace('activerecord', opts || {}) do
+              execute_without_traceview(sql, name)
+            end
+          else
+            execute_without_traceview(sql, name)
+          end
+        end
+
+        def exec_query_with_traceview(sql, name = nil, binds = [])
+          if TraceView.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            TraceView::API.trace('activerecord', opts || {}) do
+              exec_query_without_traceview(sql, name, binds)
+            end
+          else
+            exec_query_without_traceview(sql, name, binds)
+          end
+        end
+
+        def exec_delete_with_traceview(sql, name = nil, binds = [])
+          if TraceView.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            TraceView::API.trace('activerecord', opts || {}) do
+              exec_delete_without_traceview(sql, name, binds)
+            end
+          else
+            exec_delete_without_traceview(sql, name, binds)
+          end
+        end
+
+        def exec_insert_with_traceview(sql, name = nil, binds = [], *args)
+          if TraceView.tracing? && !ignore_payload?(name)
+
+            opts = extract_trace_details(sql, name, binds)
+            TraceView::API.trace('activerecord', opts || {}) do
+              exec_insert_without_traceview(sql, name, binds, *args)
+            end
+          else
+            exec_insert_without_traceview(sql, name, binds, *args)
+          end
+        end
+
+        def begin_db_transaction_with_traceview
+          if TraceView.tracing?
+            opts = {}
+
+            opts[:Query] = 'BEGIN'
+            TraceView::API.trace('activerecord', opts || {}) do
+              begin_db_transaction_without_traceview
+            end
+          else
+            begin_db_transaction_without_traceview
+          end
+        end
+      end # Utils
+    end
+  end
+end

data/lib/traceview/frameworks/rails.rb

@@ -0,0 +1,145 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Rails
+    module Helpers
+      extend ActiveSupport::Concern if defined?(::Rails) and ::Rails::VERSION::MAJOR > 2
+
+      @@rum_xhr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_ajax_header.js.erb')
+      @@rum_hdr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_header.js.erb')
+      @@rum_ftr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_footer.js.erb')
+
+      def traceview_rum_header
+        begin
+          return unless TraceView::Config.rum_id
+          if TraceView.tracing?
+            if request.xhr?
+              return raw(ERB.new(@@rum_xhr_tmpl).result)
+            else
+              return raw(ERB.new(@@rum_hdr_tmpl).result)
+            end
+          end
+        rescue StandardError => e
+          TraceView.logger.warn "traceview_rum_header: #{e.message}."
+          return ""
+        end
+      end
+
+      def traceview_rum_footer
+        begin
+          return unless TraceView::Config.rum_id
+          if TraceView.tracing?
+            # Even though the footer template is named xxxx.erb, there are no ERB tags in it so we'll
+            # skip that step for now
+            return raw(@@rum_ftr_tmpl)
+          end
+        rescue StandardError => e
+          TraceView.logger.warn "traceview_rum_footer: #{e.message}."
+          return ""
+        end
+      end
+    end # Helpers
+
+    def self.load_initializer
+      # Force load the TraceView Rails initializer if there is one
+      # Prefer traceview.rb but give priority to the legacy tracelytics.rb if it exists
+      if ::Rails::VERSION::MAJOR > 2
+        rails_root = "#{::Rails.root.to_s}"
+      else
+        rails_root = "#{RAILS_ROOT}"
+      end
+
+      #
+      # We've been through 3 initializer names.  Try each one.
+      #
+      if File.exists?("#{rails_root}/config/initializers/tracelytics.rb")
+        tr_initializer = "#{rails_root}/config/initializers/tracelytics.rb"
+
+      elsif File.exists?("#{rails_root}/config/initializers/oboe.rb")
+        tr_initializer = "#{rails_root}/config/initializers/oboe.rb"
+
+      else
+        tr_initializer = "#{rails_root}/config/initializers/traceview.rb"
+      end
+      require tr_initializer if File.exists?(tr_initializer)
+    end
+
+    def self.load_instrumentation
+      # Load the Rails specific instrumentation
+      pattern = File.join(File.dirname(__FILE__), 'rails/inst', '*.rb')
+      Dir.glob(pattern) do |f|
+        begin
+          require f
+        rescue => e
+          TraceView.logger.error "[traceview/loading] Error loading rails insrumentation file '#{f}' : #{e}"
+        end
+      end
+
+      TraceView.logger.info "TraceView gem #{TraceView::Version::STRING} successfully loaded."
+    end
+
+    def self.include_helpers
+      # TBD: This would make the helpers available to controllers which is occasionally desired.
+      # ActiveSupport.on_load(:action_controller) do
+      #   include TraceView::Rails::Helpers
+      # end
+      if ::Rails::VERSION::MAJOR > 2
+        ActiveSupport.on_load(:action_view) do
+          include TraceView::Rails::Helpers
+        end
+      else
+        ActionView::Base.send :include, TraceView::Rails::Helpers
+      end
+    end
+
+  end # Rails
+end # TraceView
+
+if defined?(::Rails)
+  require 'traceview/inst/rack'
+
+  if ::Rails::VERSION::MAJOR > 2
+    module TraceView
+      class Railtie < ::Rails::Railtie
+
+        initializer 'traceview.helpers' do
+          TraceView::Rails.include_helpers
+        end
+
+        initializer 'traceview.rack' do |app|
+          TraceView.logger.info "[traceview/loading] Instrumenting rack" if TraceView::Config[:verbose]
+          app.config.middleware.insert 0, "TraceView::Rack"
+        end
+
+        config.after_initialize do
+          TraceView.logger = ::Rails.logger if ::Rails.logger
+
+          TraceView::Loading.load_access_key
+          TraceView::Inst.load_instrumentation
+          TraceView::Rails.load_instrumentation
+
+          # Report __Init after fork when in Heroku
+          TraceView::API.report_init unless TraceView.heroku?
+        end
+      end
+    end
+  else
+    TraceView.logger = ::Rails.logger if ::Rails.logger
+
+    TraceView::Rails.load_initializer
+    TraceView::Loading.load_access_key
+
+    Rails.configuration.after_initialize do
+      TraceView.logger.info "[traceview/loading] Instrumenting rack" if TraceView::Config[:verbose]
+      Rails.configuration.middleware.insert 0, "TraceView::Rack"
+
+      TraceView::Inst.load_instrumentation
+      TraceView::Rails.load_instrumentation
+      TraceView::Rails.include_helpers
+
+      # Report __Init after fork when in Heroku
+      TraceView::API.report_init unless TraceView.heroku?
+    end
+  end
+end

data/lib/traceview/frameworks/sinatra/templates.rb

@@ -0,0 +1,56 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Sinatra
+    module Templates
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :render, ::Sinatra::Templates)
+      end
+
+      def render_with_traceview(engine, data, options = {}, locals = {}, &block)
+        if TraceView.tracing?
+          report_kvs = {}
+
+          report_kvs[:engine] = engine
+          report_kvs[:template] = data
+
+          if TraceView.tracing_layer_op?('render')
+            # For recursive calls to :render (for sub-partials and layouts),
+            # use method profiling.
+            begin
+              name = data
+              report_kvs[:FunctionName] = :render
+              report_kvs[:Class]        = :Templates
+              report_kvs[:Module]       = 'Sinatra::Templates'
+              report_kvs[:File]         = __FILE__
+              report_kvs[:LineNumber]   = __LINE__
+            rescue StandardError => e
+              ::TraceView.logger.debug e.message
+              ::TraceView.logger.debug e.backtrace.join(", ")
+            end
+
+            TraceView::API.profile(name, report_kvs, false) do
+              render_without_traceview(engine, data, options, locals, &block)
+            end
+
+          else
+            # Fall back to the raw tracing API so we can pass KVs
+            # back on exit (a limitation of the TraceView::API.trace
+            # block method) This removes the need for an info
+            # event to send additonal KVs
+            ::TraceView::API.log_entry('render', {}, 'render')
+
+            begin
+              render_without_traceview(engine, data, options, locals, &block)
+            ensure
+              ::TraceView::API.log_exit('render', report_kvs)
+            end
+          end
+        else
+          render_without_traceview(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end

data/lib/traceview/frameworks/sinatra.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2013 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Sinatra
+    module Base
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :dispatch!,         ::Sinatra::Base)
+        ::TraceView::Util.method_alias(klass, :handle_exception!, ::Sinatra::Base)
+      end
+
+      def dispatch_with_traceview
+        if TraceView.tracing?
+          report_kvs = {}
+
+          report_kvs[:Controller] = self.class
+          report_kvs[:Action] = env['PATH_INFO']
+
+          # Fall back to the raw tracing API so we can pass KVs
+          # back on exit (a limitation of the TraceView::API.trace
+          # block method) This removes the need for an info
+          # event to send additonal KVs
+          ::TraceView::API.log_entry('sinatra', {})
+
+          begin
+            dispatch_without_traceview
+          ensure
+            ::TraceView::API.log_exit('sinatra', report_kvs)
+          end
+        else
+          dispatch_without_traceview
+        end
+      end
+
+      def handle_exception_with_traceview(boom)
+        TraceView::API.log_exception(nil, boom) if TraceView.tracing?
+        handle_exception_without_traceview(boom)
+      end
+
+      @@rum_xhr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_ajax_header.js.erb')
+      @@rum_hdr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_header.js.erb')
+      @@rum_ftr_tmpl = File.read(File.dirname(__FILE__) + '/rails/helpers/rum/rum_footer.js.erb')
+
+      def traceview_rum_header
+        return unless TraceView::Config.rum_id
+        if TraceView.tracing?
+          if request.xhr?
+            return ERB.new(@@rum_xhr_tmpl).result
+          else
+            return ERB.new(@@rum_hdr_tmpl).result
+          end
+        end
+      rescue StandardError => e
+        TraceView.logger.warn "traceview_rum_header: #{e.message}."
+        return ''
+      end
+
+      def traceview_rum_footer
+        return unless TraceView::Config.rum_id
+        if TraceView.tracing?
+          # Even though the footer template is named xxxx.erb, there are no ERB tags in it so we'll
+          # skip that step for now
+          return @@rum_ftr_tmpl
+        end
+      rescue StandardError => e
+        TraceView.logger.warn "traceview_rum_footer: #{e.message}."
+        return ''
+      end
+    end
+  end
+end
+
+if defined?(::Sinatra)
+  require 'traceview/inst/rack'
+  require 'traceview/frameworks/sinatra/templates'
+
+  TraceView.logger.info '[traceview/loading] Instrumenting Sinatra' if TraceView::Config[:verbose]
+
+  TraceView::Loading.load_access_key
+  TraceView::Inst.load_instrumentation
+
+  ::Sinatra::Base.use TraceView::Rack
+
+  # When in the gem TEST environment, we load this instrumentation regardless.
+  # Otherwise, only when Padrino isn't around.
+  unless defined?(::Padrino) and not (ENV.key?('TRACEVIEW_GEM_TEST'))
+    # Padrino has 'enhanced' routes and rendering so the Sinatra
+    # instrumentation won't work anyways.  Only load for pure Sinatra apps.
+    ::TraceView::Util.send_include(::Sinatra::Base,      ::TraceView::Sinatra::Base)
+    ::TraceView::Util.send_include(::Sinatra::Templates, ::TraceView::Sinatra::Templates)
+
+    # Report __Init after fork when in Heroku
+    TraceView::API.report_init unless TraceView.heroku?
+  end
+end

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
+
+