tingyun_rpm 1.1.4.2 → 1.2.0

data/lib/ting_yun/agent/collector/transaction_sampler/slowest_sample_buffer.rb

@@ -8,7 +8,7 @@ module TingYun
       class TransactionSampler
         class SlowestSampleBuffer < TransactionSampleBufferBase
 
-          CAPACITY = 20
+          CAPACITY = 500
 
           def capacity
             CAPACITY

data/lib/ting_yun/agent/collector/transaction_sampler/transaction_sample_buffer_base.rb

@@ -7,7 +7,7 @@ module TingYun
       class TransactionSampler
         class TransactionSampleBufferBase
 
-          SINGLE_BUFFER_MAX = 20
+          SINGLE_BUFFER_MAX = 1000
           NO_SAMPLES = [].freeze
 
           def initialize

data/lib/ting_yun/agent/cross_app/cross_app_monitor.rb

@@ -19,113 +19,63 @@ module TingYun
         register_event_listeners(events)
       end
 
+
       # Expected sequence of events:
       #   :before_call will save our cross application request id to the thread
       #   :after_call will write our response headers/metrics and clean up the thread
       def register_event_listeners(events)
         TingYun::Agent.logger.debug("Wiring up Cross Application Tracing to events after finished configuring")
 
-        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
-          if cross_app_enabled?
+        events.subscribe(:cross_app_before_call) do |env| #THREAD_LOCAL_ACCESS
+          if TingYun::Agent::CrossAppTracing.cross_app_enabled?
             state = TingYun::Agent::TransactionState.tl_get
-            save_referring_transaction_info(state, env)  unless env[TY_ID_HEADER].nil?
+            state.save_referring_transaction_info(env[TY_ID_HEADER].split(';')) if env[TY_ID_HEADER]
           end
         end
 
-        events.subscribe(:after_call) do |_status_code, headers, _body| #THREAD_LOCAL_ACCESS
-          state = TingYun::Agent::TransactionState.tl_get
-          state.queue_duration = state.current_transaction.queue_time * 1000
-          state.web_duration = (Time.now - state.current_transaction.start_time) * 1000
-          insert_response_header(state, headers)
+        events.subscribe(:cross_app_after_call) do |_status_code, headers, _body| #THREAD_LOCAL_ACCESS
+          insert_response_header(headers) if TingYun::Agent::CrossAppTracing.cross_app_enabled?
         end
 
       end
 
 
-      def cross_app_enabled?
-        TingYun::Agent::CrossAppTracing.cross_app_enabled?
-      end
-
-
-      def save_referring_transaction_info(state,request)
-
-        info = request[TY_ID_HEADER].split(';')
-        tingyun_id_secret = info[0]
-        client_transaction_id = info.find do |e|
-          e.match(/x=/)
-        end.split('=')[1] rescue nil
-        client_req_id = info.find do |e|
-          e.match(/r=/)
-        end.split('=')[1] rescue nil
-
-        state.client_tingyun_id_secret = tingyun_id_secret
-        state.client_transaction_id = client_transaction_id
-        state.transaction_sample_builder.trace.tx_id = client_transaction_id
-        state.client_req_id = client_req_id
-      end
-
-
-      def insert_response_header(state, response_headers)
-        if same_account?(state)
+      def insert_response_header(response_headers)
+        state = TingYun::Agent::TransactionState.tl_get
+        if state.same_account?
           txn = state.current_transaction
-          unless txn.nil?
-            set_response_headers(state, response_headers)
+          if txn
+            # set_response_headers
+            response_headers[TY_DATA_HEADER] = TingYun::Support::Serialize::JSONWrapper.dump build_payload(state)
+            TingYun::Agent.logger.debug("now,cross app will send response_headers  #{response_headers[TY_DATA_HEADER]}")
           end
-          clear_client_tingyun_id_secret(state)
-        end
-      end
-
-      def clear_client_tingyun_id_secret(state)
-        state.client_tingyun_id_secret = nil
-      end
-
-      def same_account?(state)
-        server_info = TingYun::Agent.config[:tingyunIdSecret].split('|')
-        client_info = (state.client_tingyun_id_secret || '').split('|')
-        if !server_info[0].nil? && server_info[0] == client_info[0] && !server_info[0].empty?
-          return true
-        else
-          return false
         end
       end
 
-      def set_response_headers(state, response_headers)
-        response_headers[TY_DATA_HEADER] = TingYun::Support::Serialize::JSONWrapper.dump build_payload(state)
-        TingYun::Agent.logger.debug("now,cross app will send response_headers  #{response_headers[TY_DATA_HEADER]}")
-      end
 
       def build_payload(state)
+        timings = state.timings
+
         payload = {
-            :id => TingYun::Agent.config[:tingyunIdSecret].split('|')[1],
-            :action => state.current_transaction.best_name,
-            :trId => state.transaction_sample_builder.trace.guid,
-            :time => {
-                :duration => state.web_duration,
-                :qu => state.queue_duration,
-                :db => state.sql_duration,
-                :ex => state.external_duration,
-                :rds => state.rds_duration,
-                :mc => state.mc_duration,
-                :mon => state.mon_duration,
-                :code => execute_duration(state)
-            }
+          :id => TingYun::Agent.config[:tingyunIdSecret].split('|')[1],
+          :action => state.transaction_name,
+          :trId => state.trace_id,
+          :time => {
+            :duration => timings.app_time_in_millis,
+            :qu => timings.queue_time_in_millis,
+            :db => timings.sql_duration,
+            :ex => timings.external_duration,
+            :rds => timings.rds_duration,
+            :mc => timings.mc_duration,
+            :mon => timings.mon_duration,
+            :code => timings.app_execute_duration
+          }
         }
-        payload[:tr] = 1 if slow_action_tracer?(state)
+        payload[:tr] = 1 if timings.slow_action_tracer?
         payload[:r] = state.client_req_id unless state.client_req_id.nil?
         payload
       end
 
-      def slow_action_tracer?(state)
-        if state.web_duration > TingYun::Agent.config[:'nbs.action_tracer.action_threshold']
-          return true
-        else
-          return false
-        end
-      end
-
-      def execute_duration(state)
-        state.web_duration - state.queue_duration - state.sql_duration - state.external_duration - state.rds_duration - state.mc_duration - state.mon_duration
-      end
     end
   end
 end

data/lib/ting_yun/agent/cross_app/cross_app_tracing.rb

@@ -5,6 +5,7 @@ require 'ting_yun/agent/transaction'
 require 'ting_yun/support/http_clients/uri_util'
 require 'ting_yun/support/serialize/json_wrapper'
 require 'ting_yun/instrumentation/support/external_error'
+require 'ting_yun/agent/collector/transaction_sampler'
 
 
 module TingYun
@@ -22,26 +23,22 @@ module TingYun
       TY_DATA_HEADER = 'X-Tingyun-Tx-Data'.freeze
 
 
-
-
       module_function
 
 
-
       def tl_trace_http_request(request)
-        t0 = Time.now.to_f
         state = TingYun::Agent::TransactionState.tl_get
         return yield unless state.execution_traced?
         return yield unless state.current_transaction #如果还没有创建Transaction，就发生跨应用，就直接先跳过跟踪。
 
+        t0 = Time.now.to_f
         begin
           node = start_trace(state, t0, request)
           response = yield
-          capture_exception(response,request,'net%2Fhttp')
+          capture_exception(response, request, 'net%2Fhttp')
         rescue => e
           klass = "External/#{request.uri.to_s.gsub('/','%2F')}/net%2Fhttp"
-          handle_error(e,klass)
-          raise e
+          handle_error(e, klass)
         ensure
           finish_trace(state, t0, node, request, response)
         end
@@ -51,7 +48,7 @@ module TingYun
       def start_trace(state, t0, request)
         inject_request_headers(state, request) if cross_app_enabled?
         stack = state.traced_method_stack
-        node = stack.push_frame(state,:http_request,t0)
+        node = stack.push_frame(state, :http_request, t0)
 
         return node
       end
@@ -59,49 +56,55 @@ module TingYun
       def finish_trace(state, t0, node, request, response)
         t1 = Time.now.to_f
         duration = (t1- t0) * 1000
-        state.external_duration = duration
+        state.timings.external_duration = duration
 
         begin
           if request
-            metrics = metrics_for(state, request, response)
+            cross_app = response_is_cross_app?(response)
+
+            metrics = metrics_for(request, response, cross_app)
             node_name = metrics.pop
             scoped_metric = metrics.pop
 
-            stats_engine.record_scoped_and_unscoped_metrics(state, scoped_metric, metrics, duration)
+            ::TingYun::Agent.instance.stats_engine.record_scoped_and_unscoped_metrics(state, scoped_metric, metrics, duration)
 
             if node
               node.name = node_name
-              add_transaction_trace_info(request, response)
+              add_transaction_trace_info(request, response, cross_app)
             end
           end
+        rescue => err
+          TingYun::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
         ensure
           if node
             stack = state.traced_method_stack
             stack.pop_frame(state, node, node_name, t1)
           end
         end
-      rescue => err
-        TingYun::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
-        raise
       end
 
 
-
-      def add_transaction_trace_info(request, response)
+      def add_transaction_trace_info(request, response, cross_app)
         state = TingYun::Agent::TransactionState.tl_get
-        filtered_uri = TingYun::Agent::HTTPClients::URIUtil.filter_uri request.uri
-        transaction_sampler.add_node_info(:uri => filtered_uri)
-        if response && response_is_cross_app?( response )
-          transaction_sampler.tl_builder.current_node[:txId] = state.client_transaction_id || state.request_guid
-          my_data = TingYun::Support::Serialize::JSONWrapper.load response[TY_DATA_HEADER].gsub("'",'"')
-          transaction_sampler.tl_builder.current_node[:txData] = my_data
+        ::TingYun::Agent::Collector::TransactionSampler.add_node_info(:uri => TingYun::Agent::HTTPClients::URIUtil.filter_uri(request.uri))
+        if cross_app
+          ::TingYun::Agent::Collector::TransactionSampler.tl_builder.set_txId_and_txData(state.client_transaction_id || state.request_guid,
+                                                             TingYun::Support::Serialize::JSONWrapper.load(response[TY_DATA_HEADER].gsub("'",'"')))
         end
       end
 
-      def metrics_for(state, request, response)
-        metrics = common_metrics(request)
 
-        if response && response_is_cross_app?( response )
+      def metrics_for(request, response, cross_app)
+
+        metrics = [ "External/NULL/ALL" ]
+
+        if TingYun::Agent::Transaction.recording_web_transaction?
+          metrics << "External/NULL/AllWeb"
+        else
+          metrics << "External/NULL/AllBackground"
+        end
+
+        if cross_app
           begin
             metrics.concat metrics_for_cross_app_response( request, response )
           rescue => err
@@ -117,20 +120,8 @@ module TingYun
         return metrics
       end
 
-      def common_metrics(request)
-        metrics = [ "External/NULL/ALL" ]
-
-        if TingYun::Agent::Transaction.recording_web_transaction?
-          metrics << "External/NULL/AllWeb"
-        else
-          metrics << "External/NULL/AllBackground"
-        end
-
-        return metrics
-      end
 
       def metrics_for_regular_request( request )
-        state = TingYun::Agent::TransactionState.tl_get
         metrics = []
         metrics << "External/#{request.uri.to_s.gsub('/','%2F')}/net%2Fhttp"
         metrics << "External/#{request.uri.to_s.gsub('/','%2F')}/net%2Fhttp"
@@ -138,29 +129,11 @@ module TingYun
         return metrics
       end
 
-      def stats_engine
-        ::TingYun::Agent.instance.stats_engine
-      end
-
-      def transaction_sampler
-        ::TingYun::Agent.instance.transaction_sampler
-      end
-
 
       def cross_app_enabled?
-        valid_tingyun_secret_id? && web_action_tracer_enabled? && cross_application_tracer_enabled?
-      end
-
-      def web_action_tracer_enabled?
-        TingYun::Agent.config[:'nbs.action_tracer.enabled']
-      end
-
-      def cross_application_tracer_enabled?
-        TingYun::Agent.config[:'nbs.transaction_tracer.enabled']
-      end
-
-      def valid_tingyun_secret_id?
-        TingYun::Agent.config[:tingyunIdSecret] && TingYun::Agent.config[:tingyunIdSecret].size > 0
+        TingYun::Agent.config[:tingyunIdSecret] && TingYun::Agent.config[:tingyunIdSecret].size > 0 &&
+            TingYun::Agent.config[:'nbs.action_tracer.enabled'] &&
+            TingYun::Agent.config[:'nbs.transaction_tracer.enabled']
       end
 
       # Inject the X-Process header into the outgoing +request+.
@@ -168,25 +141,22 @@ module TingYun
         cross_app_id  = TingYun::Agent.config[:tingyunIdSecret] or
             raise TingYun::Agent::CrossAppTracing::Error, "no tingyunIdSecret configured"
 
-        txn_guid =  state.client_transaction_id || state.request_guid
-        state.transaction_sample_builder.trace.tx_id = txn_guid
-        request[TY_ID_HEADER] = "#{cross_app_id};c=1;x=#{txn_guid}"
+        request[TY_ID_HEADER] = "#{cross_app_id};c=1;x=#{state.request_guid}"
       end
 
       # Returns +true+ if Cross Application Tracing is enabled, and the given +response+
       # has the appropriate headers.
       def response_is_cross_app?( response )
+        return false unless response
+        return false unless response[TY_DATA_HEADER]
         return false unless cross_app_enabled?
-        unless response[TY_DATA_HEADER]
-          return false
-        end
+
         return true
       end
 
       # Return the set of metric objects appropriate for the given cross app
       # +response+.
       def metrics_for_cross_app_response(request, response )
-        state = TingYun::Agent::TransactionState.tl_get
         my_data =  TingYun::Support::Serialize::JSONWrapper.load response[TY_DATA_HEADER].gsub("'",'"')
         uri = "#{request.uri.to_s.gsub('/','%2F')}/net%2Fhttp"
         metrics = []

data/lib/ting_yun/agent/database.rb

@@ -1,8 +1,13 @@
 # encoding: utf-8
 
 require 'ting_yun/support/helper'
+require 'ting_yun/agent/database/connection_manager'
+require 'ting_yun/agent/database/statement'
+require 'ting_yun/agent/database/obfuscator'
+
 module TingYun
   module Agent
+    # sql explain plan
     module Database
 
       MAX_QUERY_LENGTH = 16384
@@ -10,8 +15,31 @@ module TingYun
       extend self
 
 
+      def explain_sql(statement)
+        return nil unless statement.sql && statement.explainer && statement.config
+        statement.sql = statement.sql.split(";\n")[0] # only explain the first
+        return statement.explain || {"dialect"=> nil, "keys"=>[], "values"=>[]}
+      end
+
+      def explain_plan(statement)
+        connection = get_connection(statement.config) do
+          ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
+                                    statement.config)
+        end
+        if connection
+          if connection.respond_to?(:exec_query)
+            return connection.exec_query("EXPLAIN #{statement.sql}",
+                                         "Explain #{statement.name}",
+                                         statement.binds)
+          elsif connection.respond_to?(:execute)
+            return connection.execute("EXPLAIN #{statement.sql}")
+          end
+        end
+      end
+
+
       def obfuscate_sql(sql)
-        Obfuscator.instance.obfuscator.call(sql)
+        TingYun::Agent::Database::Obfuscator.instance.obfuscator.call(sql)
       end
 
 
@@ -28,11 +56,6 @@ module TingYun
       end
 
 
-      RECORD_FOR = [:raw, :obfuscated].freeze
-
-      def should_record_sql?(key)
-        RECORD_FOR.include?(record_sql_method(key.to_sym))
-      end
 
       def record_sql_method(key)
 
@@ -46,363 +69,32 @@ module TingYun
         end
       end
 
-      def should_action_collect_explain_plans?
-        should_record_sql?("nbs.action_tracer.record_sql") &&
-            Agent.config["nbs.action_tracer.explain_enabled".to_sym]
-      end
-
-      def explain_sql(sql, config, explainer=nil)
-        return nil unless sql && explainer && config
-        _sql = sql.split(";\n")[0] # only explain the first
-        explain_plan = explain(_sql, config, explainer)
-        return explain_plan || {"dialect"=> nil, "keys"=>[], "values"=>[]}
-      end
-
-      SUPPORTED_ADAPTERS_FOR_EXPLAIN = %w[postgres postgresql mysql2 mysql sqlite].freeze
-
-      def explain(sql, config, explainer=nil)
-
-        return unless explainer && is_select?(sql)
-
-        if sql[-3,3] == '...'
-          TingYun::Agent.logger.debug('Unable to collect explain plan for truncated query.')
-          return
-        end
-
-        if parameterized?(sql)
-          TingYun::Agent.logger.debug('Unable to collect explain plan for parameterized query.')
-          return
-        end
-
-        adapter = adapter_from_config(config)
-        if !SUPPORTED_ADAPTERS_FOR_EXPLAIN.include?(adapter)
-          TingYun::Agent.logger.debug("Not collecting explain plan because an unknown connection adapter ('#{adapter}') was used.")
-          return
-        end
-
-        handle_exception_in_explain do
-          plan = explainer.call(config, sql)
-          return process_resultset(plan, adapter) if plan
-        end
-      end
-
-      def adapter_from_config(config)
-        if config[:adapter]
-          return config[:adapter].to_s
-        elsif config[:uri] && config[:uri].to_s =~ /^jdbc:([^:]+):/
-          # This case is for Sequel with the jdbc-mysql, jdbc-postgres, or
-          # jdbc-sqlite3 gems.
-          return $1
-        end
-      end
-
-
-      def parameterized?(sql)
-        Obfuscator.instance.obfuscate_single_quote_literals(sql) =~ /\$\d+/
-      end
-
-      def is_select?(sql)
-        parse_operation_from_query(sql) == 'select'
-      end
-
-      def process_resultset(results ,adapter)
-        case adapter.to_s
-          when 'postgres', 'postgresql'
-            process_explain_results_postgres(results)
-          when 'mysql2'
-            process_explain_results_mysql2(results)
-          when 'mysql'
-            process_explain_results_mysql(results)
-          when 'sqlite'
-            process_explain_results_sqlite(results)
-        end
-      end
-
-      QUERY_PLAN = 'QUERY PLAN'.freeze
-
-      def process_explain_results_postgres(results)
-        if results.is_a?(String)
-          query_plan_string = results
-        else
-          lines = []
-          results.each { |row| lines << row[QUERY_PLAN] }
-          query_plan_string = lines.join("\n")
-        end
-
-        unless record_sql_method("nbs.action_tracer.record_sql") == :raw
-          query_plan_string = Obfuscator.instance.obfuscate_postgres_explain(query_plan_string)
-        end
-        values = query_plan_string.split("\n").map { |line| [line] }
-
-        {"dialect"=> "PostgreSQL", "keys"=>[QUERY_PLAN], "values"=>values}
-      end
-
-      def string_explain_plan_results(adpater, results)
-        {"dialect"=> adpater, "keys"=>[], "values"=>[results]}
-      end
-
-      def process_explain_results_mysql2(results)
-        return string_explain_plan_results("MySQL", results) if results.is_a?(String)
-        headers = results.fields
-        values  = []
-        results.each { |row| values << row }
-        {"dialect"=> "MySQL", "keys"=>headers, "values"=>values}
-      end
-
-      def process_explain_results_mysql(results)
-        return string_explain_plan_results("MySQL", results) if results.is_a?(String)
-        headers = []
-        values  = []
-        if results.is_a?(Array)
-          # We're probably using the jdbc-mysql gem for JRuby, which will give
-          # us an array of hashes.
-          headers = results.first.keys
-          results.each do |row|
-            values << headers.map { |h| row[h] }
-          end
-        else
-          # We're probably using the native mysql driver gem, which will give us
-          # a Mysql::Result object that responds to each_hash
-          results.each_hash do |row|
-            headers = row.keys
-            values << headers.map { |h| row[h] }
-          end
-        end
-        {"dialect"=> "MySQL", "keys"=>headers, "values"=>values}
-      end
-
-      SQLITE_EXPLAIN_COLUMNS = %w[addr opcode p1 p2 p3 p4 p5 comment]
-
-      def process_explain_results_sqlite(results)
-        return string_explain_plan_results("sqlite", results) if results.is_a?(String)
-        headers = SQLITE_EXPLAIN_COLUMNS
-        values  = []
-        results.each do |row|
-          values << headers.map { |h| row[h] }
-        end
-        {"dialect"=> "sqlite", "keys"=>headers, "values"=>values}
-      end
-
-
-
-      KNOWN_OPERATIONS = [
-          'alter',
-          'select',
-          'update',
-          'delete',
-          'insert',
-          'create',
-          'show',
-          'set',
-          'exec',
-          'execute',
-          'call'
-      ]
-
-      SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze
-      EMPTY_STRING      = ''.freeze
-
-      def parse_operation_from_query(sql)
-        sql = TingYun::Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
-        if sql =~ /(\w+)/
-          op = $1.downcase
-          return op if KNOWN_OPERATIONS.include?(op)
-        end
-      end
-
-
-      def handle_exception_in_explain
-        yield
-      rescue => e
-        ::TingYun::Agent.logger.error("Error getting query plan:", e)
-        nil
-      end
-
 
       def get_connection(config, &connector)
-        ConnectionManager.instance.get_connection(config, &connector)
+        TingYun::Agent::Database::ConnectionManager.instance.get_connection(config, &connector)
       end
 
       def close_connections
-        ConnectionManager.instance.close_connections
+        TingYun::Agent::Database::ConnectionManager.instance.close_connections
       end
 
-      # Returns a cached connection for a given ActiveRecord
-      # configuration - these are stored or reopened as needed, and if
-      # we cannot get one, we ignore it and move on without explaining
-      # the sql
-      class ConnectionManager
-        include Singleton
-
-        def get_connection(config, &connector)
-          @connections ||= {}
-
-          connection = @connections[config]
-
-          return connection if connection
 
-          begin
-            @connections[config] = connector.call(config)
-          rescue => e
-            ::TingYun::Agent.logger.error("Caught exception trying to get connection to DB for explain.", e)
-            nil
-          end
-        end
 
-        # Closes all the connections in the internal connection cache
-        def close_connections
-          @connections ||= {}
-          @connections.values.each do |connection|
-            begin
-              connection.disconnect!
-            rescue
-            end
-          end
+      RECORD_FOR = [:raw, :obfuscated].freeze
 
-          @connections = {}
-        end
+      def should_record_sql?(key)
+        RECORD_FOR.include?(record_sql_method(key.to_sym))
       end
 
-      class Statement
-        attr_accessor :sql, :config, :explainer
-
-        def initialize(sql, config={}, explainer=nil)
-          @sql = TingYun::Agent::Database.capture_query(sql)
-          @config = config
-          @explainer = explainer
-        end
-
-        def adapter
-          config && config[:adapter]
-        end
+      def sql_sampler_enabled?
+        Agent.config[:'nbs.action_tracer.enabled'] &&
+            Agent.config[:'nbs.action_tracer.slow_sql'] &&
+            should_record_sql?('nbs.action_tracer.record_sql')
       end
 
-      #混淆器
-      class Obfuscator
-        include Singleton
-
-        attr_reader :obfuscator
-
-        def initialize
-          reset
-        end
-
-        def reset
-          @obfuscator = method(:default_sql_obfuscator)
-        end
-
-        QUERY_TOO_LARGE_MESSAGE     = "Query too large (over 16k characters) to safely obfuscate"
-        FAILED_TO_OBFUSCATE_MESSAGE = "Failed to obfuscate SQL query - quote characters remained after obfuscation"
-
-        def default_sql_obfuscator(sql)
-          stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
-
-          if stmt.sql[-3,3] == '...'
-            return QUERY_TOO_LARGE_MESSAGE
-          end
-
-          obfuscate_double_quotes = stmt.adapter.to_s !~ /postgres|sqlite/
-
-          obfuscated = obfuscate_numeric_literals(stmt.sql)
-
-          if obfuscate_double_quotes
-            obfuscated = obfuscate_quoted_literals(obfuscated)
-            obfuscated = remove_comments(obfuscated)
-            if contains_quotes?(obfuscated)
-              obfuscated = FAILED_TO_OBFUSCATE_MESSAGE
-            end
-          else
-            obfuscated = obfuscate_single_quote_literals(obfuscated)
-            obfuscated = remove_comments(obfuscated)
-            if contains_single_quotes?(obfuscated)
-              obfuscated = FAILED_TO_OBFUSCATE_MESSAGE
-            end
-          end
-
-
-          obfuscated.to_s # return back to a regular String
-        end
-
-        QUOTED_STRINGS_REGEX = /'(?:[^']|'')*'|"(?:[^"]|"")*"/
-        LABEL_LINE_REGEX     = /^([^:\n]*:\s+).*$/.freeze
-
-        def obfuscate_postgres_explain(explain)
-          explain.gsub!(QUOTED_STRINGS_REGEX) do |match|
-            match.start_with?('"') ? match : '?'
-          end
-          explain.gsub!(LABEL_LINE_REGEX,   '\1?')
-          explain
-        end
-
-        module ObfuscationHelpers
-          # Note that the following two regexes are applied to a reversed version
-          # of the query. This is why the backslash escape sequences (\' and \")
-          # appear reversed within them.
-          #
-          # Note that some database adapters (notably, PostgreSQL with
-          # standard_conforming_strings on and MySQL with NO_BACKSLASH_ESCAPES on)
-          # do not apply special treatment to backslashes within quoted string
-          # literals. We don't have an easy way of determining whether the
-          # database connection from which a query was captured was operating in
-          # one of these modes, but the obfuscation is done in such a way that it
-          # should not matter.
-          #
-          # Reversing the query string before obfuscation allows us to get around
-          # the fact that a \' appearing within a string may or may not terminate
-          # the string, because we know that a string cannot *start* with a \'.
-          REVERSE_SINGLE_QUOTES_REGEX = /'(?:''|'\\|[^'])*'/
-          REVERSE_ANY_QUOTES_REGEX    = /'(?:''|'\\|[^'])*'|"(?:""|"\\|[^"])*"/
-
-          NUMERICS_REGEX = /\b\d+\b/
-
-          # We take a conservative, overly-aggressive approach to obfuscating
-          # comments, and drop everything from the query after encountering any
-          # character sequence that could be a comment initiator. We do this after
-          # removal of string literals to avoid accidentally over-obfuscating when
-          # a string literal contains a comment initiator.
-          SQL_COMMENT_REGEX = Regexp.new('(?:/\*|--|#).*', Regexp::MULTILINE).freeze
-
-          # We use these to check whether the query contains any quote characters
-          # after obfuscation. If so, that's a good indication that the original
-          # query was malformed, and so our obfuscation can't reliabily find
-          # literals. In such a case, we'll replace the entire query with a
-          # placeholder.
-          LITERAL_SINGLE_QUOTE = "'".freeze
-          LITERAL_DOUBLE_QUOTE = '"'.freeze
-
-          PLACEHOLDER = '?'.freeze
-
-          def obfuscate_single_quote_literals(sql)
-            obfuscated = sql.reverse
-            obfuscated.gsub!(REVERSE_SINGLE_QUOTES_REGEX, PLACEHOLDER)
-            obfuscated.reverse!
-            obfuscated
-          end
-
-          def obfuscate_quoted_literals(sql)
-            obfuscated = sql.reverse
-            obfuscated.gsub!(REVERSE_ANY_QUOTES_REGEX, PLACEHOLDER)
-            obfuscated.reverse!
-            obfuscated
-          end
-
-          def obfuscate_numeric_literals(sql)
-            sql.gsub(NUMERICS_REGEX, PLACEHOLDER)
-          end
-
-          def remove_comments(sql)
-            sql.gsub(SQL_COMMENT_REGEX, PLACEHOLDER)
-          end
-
-          def contains_single_quotes?(str)
-            str.include?(LITERAL_SINGLE_QUOTE)
-          end
-
-          def contains_quotes?(str)
-            str.include?(LITERAL_SINGLE_QUOTE) || str.include?(LITERAL_DOUBLE_QUOTE)
-          end
-        end
-        include ObfuscationHelpers
+      def should_action_collect_explain_plans?
+        should_record_sql?("nbs.action_tracer.record_sql") &&
+            Agent.config["nbs.action_tracer.explain_enabled".to_sym]
       end
 
     end