tingyun_rpm 1.1.4.2 → 1.2.0

data/lib/ting_yun/agent/collector/sql_sampler/slow_sql.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require 'ting_yun/agent/database'
+module TingYun
+  module Agent
+    module Collector
+      class SlowSql
+        attr_reader :statement
+        attr_reader :metric_name
+        attr_reader :duration
+        attr_reader :backtrace
+        attr_reader :start_time
+
+
+        def initialize(statement, metric_name, duration, time,  backtrace=nil)
+          @start_time = time
+          @statement = statement
+          @metric_name = metric_name
+          @duration = duration
+          @backtrace = backtrace
+        end
+
+        def sql
+          statement.sql
+        end
+
+        def obfuscate
+          TingYun::Agent::Database.obfuscate_sql(statement)
+        end
+
+
+        def normalize
+          TingYun::Agent::Database::Obfuscator.instance.default_sql_obfuscator(statement)
+        end
+
+        def explain
+          TingYun::Agent::Database.explain_sql(statement) if statement.config && statement.explainer
+        end
+
+        # We can't serialize the explainer, so clear it before we transmit
+        def prepare_to_send
+          statement.explainer = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/ting_yun/agent/collector/sql_sampler/sql_trace.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'ting_yun/metrics/stats'
+require 'ting_yun/support/helper'
+require 'ting_yun/support/coerce'
+
+module TingYun
+  module Agent
+    module Collector
+
+      class SqlTrace < TingYun::Metrics::Stats
+
+        attr_reader :action_metric_name
+        attr_reader :uri
+        attr_reader :sql
+        attr_reader :slow_sql
+        attr_reader :params
+
+        def initialize(normalized_query, slow_sql, action_name, uri)
+          super()
+          @params = {}
+
+          @action_metric_name = action_name
+          @slow_sql = slow_sql
+          @sql = normalized_query
+          @uri = uri
+          @params[:stacktrace] = slow_sql.backtrace
+          record_data_point(float(slow_sql.duration))
+        end
+
+        def aggregate(slow_sql, action_name, uri)
+          duration = slow_sql.duration
+          if duration > max_call_time
+            @action_metric_name = action_name
+            @slow_sql = slow_sql
+            @uri = uri
+            @params[:stacktrace] = slow_sql.backtrace
+          end
+          record_data_point(float(duration))
+        end
+
+
+        def prepare_to_send
+          @sql = @slow_sql.sql unless Agent.config[:'nbs.action_tracer.record_sql'].to_s == 'obfuscated'
+          @params[:explainPlan] = @slow_sql.explain if need_to_explain?
+        end
+
+
+        def need_to_explain?
+          Agent.config[:'nbs.action_tracer.explain_enabled'] &&  @slow_sql.duration * 1000 > TingYun::Agent.config[:'nbs.action_tracer.explain_threshold']
+        end
+
+
+        include TingYun::Support::Coerce
+
+        def to_collector_array(encoder)
+          [
+              @slow_sql.start_time,
+              string(@action_metric_name),
+              string(@slow_sql.metric_name),
+              string(@uri||@action_metric_name),
+              string(@sql),
+              int(@call_count),
+              TingYun::Helper.time_to_millis(@total_call_time),
+              TingYun::Helper.time_to_millis(@max_call_time),
+              TingYun::Helper.time_to_millis(@min_call_time),
+              encoder.encode(@params)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/sql_sampler/transaction_sql_data.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    module Collector
+      class TransactionSqlData
+        attr_reader :metric_name
+        attr_reader :uri
+        attr_reader :sql_data
+
+        def initialize(uri)
+          @sql_data = []
+          @uri = uri
+        end
+
+        def set_transaction_info(uri)
+          @uri = uri
+        end
+
+        def set_transaction_name(name)
+          @metric_name = name
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/collector/stats_engine/metric_stats.rb

@@ -126,16 +126,17 @@ module TingYun
 
           def reset!
             with_stats_lock do
-              old = @stats_hash
               @stats_hash = StatsHash.new
-              old
             end
           end
 
           def harvest!
-            now = Time.now
-            snapshot = reset!
-            snapshot.harvested_at = now
+            snapshot = nil
+            with_stats_lock do
+              snapshot = @stats_hash
+              snapshot.harvested_at = Time.now
+              @stats_hash = StatsHash.new
+            end
             snapshot
           end
 

data/lib/ting_yun/agent/collector/stats_engine/stats_hash.rb

@@ -109,7 +109,7 @@ module TingYun
         end
 
         class StatsHashLookupError < TingYun::Support::Exception::InternalAgentError
-          def initialize(original_error, hash, metric_spec)
+          def initialize(original_error, metric_spec)
             super("Lookup error in StatsHash: #{original_error.class}: #{original_error.message}. Falling back adding #{metric_spec.inspect}")
           end
         end
@@ -157,7 +157,7 @@ module TingYun
           # This only happen in the case of a corrupted default_proc
           # Side-step it manually, notice the issue, and carry on....
           ::TingYun::Agent.instance.error_collector. \
-          notice_agent_error(StatsHashLookupError.new(error, hash, key))
+          notice_agent_error(StatsHashLookupError.new(error, key))
           stats = TingYun::Metrics::Stats.new
           hash[key] = stats
           # Try to restore the default_proc so we won't continually trip the error

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

@@ -2,7 +2,7 @@
 
 require 'ting_yun/agent/transaction/transaction_sample_builder'
 require 'ting_yun/agent/collector/transaction_sampler/slowest_sample_buffer'
-
+require 'ting_yun/agent/collector/transaction_sampler/class_method'
 require 'ting_yun/agent/transaction/transaction_state'
 
 
@@ -11,6 +11,7 @@ module TingYun
     module Collector
       class TransactionSampler
 
+        extend TingYun::Agent::Collector::TransactionSampler::ClassMethod
 
         attr_accessor :last_sample
 
@@ -21,151 +22,8 @@ module TingYun
           @sample_buffers << TingYun::Agent::Collector::TransactionSampler::SlowestSampleBuffer.new
         end
 
-
-        def notice_push_frame(state, time=Time.now)
-          builder = state.transaction_sample_builder
-          return unless builder
-          builder.trace_entry(time.to_f)
-        end
-
-        # Informs the transaction sample builder about the end of a traced frame
-        def notice_pop_frame(state, frame, time = Time.now)
-          builder = state.transaction_sample_builder
-          return unless builder
-          builder.trace_exit(frame, time.to_f)
-        end
-
-        def enabled?
-          TingYun::Agent.config[:'nbs.action_tracer.enabled']
-        end
-
-        def on_start_transaction(state, time)
-          start_builder(state, time)
-        end
-
-        def start_builder(state, time=nil)
-          if enabled?
-            state.transaction_sample_builder ||= TingYun::Agent::TransactionSampleBuilder.new(time)
-          else
-            state.transaction_sample_builder = nil
-          end
-        end
-
-
-        def on_finishing_transaction(state, txn, time=Time.now.to_f)
-          last_builder = state.transaction_sample_builder
-          return unless last_builder && enabled?
-
-          last_builder.finish_trace(time)
-
-          state.transaction_sample_builder = nil
-
-
-          final_trace = last_builder.trace
-          final_trace.metric_name = txn.best_name
-          final_trace.uri = txn.request_path
-          final_trace.attributes = txn.attributes
-
-
-          @lock.synchronize do
-            @last_sample = final_trace
-
-            store_sample(@last_sample)
-            @last_sample
-          end
-        end
-
-        def store_sample(sample)
-          @sample_buffers.each do |sample_buffer|
-            sample_buffer.store(sample)
-          end
-        end
-
-
-        # Attaches an SQL query on the current transaction trace node.
-        # @param sql [String] the SQL query being recorded
-        # @param config [Object] the driver configuration for the connection
-        # @param duration [Float] number of seconds the query took to execute
-        # @param explainer [Proc] for internal use only - 3rd-party clients must
-        #                         not pass this parameter.
-        # duration{:type => sec}
-        def notice_sql(sql, config, duration, state=nil, explainer=nil)
-          # some statements (particularly INSERTS with large BLOBS
-          # may be very large; we should trim them to a maximum usable length
-          state ||= TingYun::Agent::TransactionState.tl_get
-          builder = state.transaction_sample_builder
-          if state.sql_recorded?
-            statement = TingYun::Agent::Database::Statement.new(sql, config, explainer)
-            action_tracer_segment(builder, statement, duration, :sql)
-          end
-        end
-
-        # duration{:type => sec}
-        def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
-          builder = tl_builder
-          return unless builder
-          action_tracer_segment(builder, key, duration, :key)
-        end
-
-        # duration{:type => sec}
-        def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
-          builder = tl_builder
-          return unless builder
-          action_tracer_segment(builder, statement, duration, :statement)
-        end
-
-
-
-        MAX_DATA_LENGTH = 16384
-        # This method is used to record metadata into the currently
-        # active node like a sql query, memcache key, or Net::HTTP uri
-        #
-        # duration is milliseconds, float value.
-        # duration{:type => sec}
-        def action_tracer_segment(builder, message, duration, key)
-          return unless builder
-          node = builder.current_node
-          if node
-            if key == :sql
-              statement = node[:sql]
-              if statement && !statement.sql.empty?
-                statement.sql = self.class.truncate_message(statement.sql + "\n#{message.sql}") if statement.sql.length <= MAX_DATA_LENGTH
-              else
-                # message is expected to have been pre-truncated by notice_sql
-                node[:sql] =  message
-              end
-            else
-              node[key] = self.class.truncate_message(message)
-            end
-            append_backtrace(node, duration)
-          end
-        end
-
-        # Truncates the message to `MAX_DATA_LENGTH` if needed, and
-        # appends an ellipsis because it makes the trucation clearer in
-        # the UI
-        def self.truncate_message(message)
-          if message.length > (MAX_DATA_LENGTH - 4)
-            message.slice!(MAX_DATA_LENGTH - 4..message.length)
-            message << '...'
-          else
-            message
-          end
-        end
-
-        # Appends a backtrace to a node if that node took longer
-        # than the specified duration
-        def append_backtrace(node, duration)
-          if duration*1000 >= Agent.config[:'nbs.action_tracer.stack_trace_threshold']
-            trace =  caller.reject! { |t| t.include?('tingyun_rpm') }
-            trace = trace.first(20)
-            node[:stacktrace] = trace
-          end
-
-        end
-
         def harvest!
-          return [] unless enabled?
+          return [] unless TingYun::Agent.config[:'nbs.action_tracer.enabled']
 
           samples = @lock.synchronize do
             @last_sample = nil
@@ -174,53 +32,59 @@ module TingYun
 
           prepare_samples(samples)
         end
-
         def harvest_from_sample_buffers
           result = []
           @sample_buffers.each { |buffer| result.concat(buffer.harvest_samples) }
           result.uniq
         end
-
         def prepare_samples(samples)
           samples.select do |sample|
             begin
               sample.prepare_to_send!
             rescue => e
-
               TingYun::Agent.logger.error('Failed to prepare transaction trace. Error: ', e)
-
               false
             else
               true
             end
           end
         end
-
         def merge!(previous)
-
           @lock.synchronize do
             @sample_buffers.each do |buffer|
               buffer.store_previous(previous)
             end
           end
         end
-
         def reset!
           @lock.synchronize do
             @sample_buffers.each { |sample| sample.reset! }
           end
         end
 
+        def on_finishing_transaction(state, txn, time=Time.now.to_f)
+          last_builder = state.transaction_sample_builder
+          return unless last_builder && TingYun::Agent.config[:'nbs.action_tracer.enabled']
 
-        def add_node_info(params)
-          builder = tl_builder
-          return unless builder
-          params.each { |k,v| builder.current_node.instance_variable_set(('@'<<k.to_s).to_sym, v)  }
-        end
+          last_builder.finish_trace(time)
+
+          final_trace = last_builder.trace
+          final_trace.attributes = txn.attributes
+
+
+          @lock.synchronize do
+            @last_sample = final_trace
 
-        def tl_builder
-          TingYun::Agent::TransactionState.tl_get.transaction_sample_builder
+            store_sample(@last_sample)
+            @last_sample
+          end
         end
+        def store_sample(sample)
+          @sample_buffers.each do |sample_buffer|
+            sample_buffer.store(sample)
+          end
+        end
+
 
       end
     end

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

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    module Collector
+      class TransactionSampler
+        module ClassMethod
+
+
+          def notice_push_frame(state, time=Time.now)
+            builder = state.transaction_sample_builder
+            return unless builder
+            builder.trace_entry(time.to_f)
+          end
+
+          # Informs the transaction sample builder about the end of a traced frame
+          def notice_pop_frame(state, frame, time = Time.now)
+            builder = state.transaction_sample_builder
+            return unless builder
+            builder.trace_exit(frame, time.to_f)
+          end
+
+
+          def on_start_transaction(state, time)
+            if TingYun::Agent.config[:'nbs.action_tracer.enabled']
+              state.transaction_sample_builder ||= TingYun::Agent::TransactionSampleBuilder.new(time)
+            else
+              state.transaction_sample_builder = nil
+            end
+          end
+
+          # Attaches an SQL query on the current transaction trace node.
+          # @param sql [String] the SQL query being recorded
+          # @param config [Object] the driver configuration for the connection
+          # @param duration [Float] number of seconds the query took to execute
+          # @param explainer [Proc] for internal use only - 3rd-party clients must
+          #                         not pass this parameter.
+          # duration{:type => sec}
+          def notice_sql(sql, config, duration, state=nil, explainer=nil, binds=[], name="SQL")
+            # some statements (particularly INSERTS with large BLOBS
+            # may be very large; we should trim them to a maximum usable length
+            state ||= TingYun::Agent::TransactionState.tl_get
+            builder = state.transaction_sample_builder
+            if state.sql_recorded?
+              statement = TingYun::Agent::Database::Statement.new(sql, config, explainer, binds, name)
+              action_tracer_segment(builder, statement, duration, :sql)
+            end
+          end
+
+          # duration{:type => sec}
+          def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
+            builder = tl_builder
+            action_tracer_segment(builder, key, duration, :key)
+          end
+
+          # duration{:type => sec}
+          def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
+            builder = tl_builder
+            action_tracer_segment(builder, statement, duration, :statement)
+          end
+
+
+
+
+
+          MAX_DATA_LENGTH = 16384
+          # This method is used to record metadata into the currently
+          # active node like a sql query, memcache key, or Net::HTTP uri
+          #
+          # duration is milliseconds, float value.
+          # duration{:type => sec}
+          def action_tracer_segment(builder, message, duration, key)
+            return unless builder
+            node = builder.current_node
+            if node
+              if key == :sql
+                statement = node[:sql]
+                if statement && !statement.sql.empty?
+                  statement.sql = truncate_message(statement.sql + "\n#{message.sql}") if statement.sql.length <= MAX_DATA_LENGTH
+                else
+                  # message is expected to have been pre-truncated by notice_sql
+                  node[:sql] =  message
+                end
+              else
+                node[key] = truncate_message(message)
+              end
+              append_backtrace(node, duration)
+            end
+          end
+
+          # Truncates the message to `MAX_DATA_LENGTH` if needed, and
+          # appends an ellipsis because it makes the trucation clearer in
+          # the UI
+          def truncate_message(message)
+            size = MAX_DATA_LENGTH - 4
+            if message.length > size
+              message.slice!(size..message.length)
+              message << '...'
+            else
+              message
+            end
+          end
+
+
+          # Appends a backtrace to a node if that node took longer
+          # than the specified duration
+          def append_backtrace(node, duration)
+            if duration*1000 >= Agent.config[:'nbs.action_tracer.stack_trace_threshold']
+              trace = caller.reject! { |t| t.include?('tingyun_rpm') }
+              trace = trace.first(20)
+              node[:stacktrace] = trace
+            end
+          end
+
+          def add_node_info(params)
+            builder = tl_builder
+            return unless builder
+            params.each { |k,v| builder.current_node.instance_variable_set(('@'<<k.to_s).to_sym, v)  }
+          end
+
+          def tl_builder
+            TingYun::Agent::TransactionState.tl_get.transaction_sample_builder
+          end
+
+        end
+      end
+    end
+  end
+end
+