tingyun_rpm 1.0.6

data/lib/ting_yun/agent/threading/agent_thread.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# This file is distributed under Ting Yun's license terms.
+
+module TingYun
+  module Agent
+    module Threading
+      class AgentThread
+
+        def self.create(label, &blk)
+          TingYun::Agent.logger.debug("Creating Ting Yun thread: #{label}")
+          wrapped_blk = Proc.new do
+            begin
+              blk.call
+            rescue => e
+              TingYun::Agent.logger.error("Thread #{label} exited with error", e)
+            rescue Exception => e
+              TingYun::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
+              raise
+            ensure
+              TingYun::Agent.logger.debug("Exiting TingYun thread: #{label}")
+            end
+          end
+
+          thread = backing_thread_class.new(&wrapped_blk)
+          thread[:TingYun_label] = label
+          thread
+        end
+
+        # Simplifies testing if we don't directly use ::Thread.list, so keep
+        # the accessor for it here on AgentThread to use and stub.
+        def self.list
+          backing_thread_class.list
+        end
+
+        # To allow tests to swap out Thread for a synchronous alternative,
+        # surface the backing class we'll use from the class level.
+        @backing_thread_class = ::Thread
+
+        def self.backing_thread_class
+          @backing_thread_class
+        end
+
+        def self.backing_thread_class=(clazz)
+          @backing_thread_class = clazz
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/attributes.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    class Transaction
+      class Attributes
+
+        attr_accessor :agent_attributes
+        def initialize
+          @agent_attributes  = {}
+          @custom_attributes = {}
+        end
+
+        def add_agent_attribute(key, value)
+          return if value.nil?
+          @agent_attributes[key] = value
+        end
+
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/request_attributes.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'ting_yun/support/http_clients/uri_util'
+
+module TingYun
+  module Agent
+    class Transaction
+      class RequestAttributes
+
+        attr_reader :request_path, :referer, :accept, :content_length, :host,
+                    :port, :user_agent, :request_method, :query_string
+
+        HTTP_ACCEPT_HEADER_KEY = 'HTTP_ACCEPT'.freeze
+
+        def initialize request
+          @request_path = path_from_request request
+          @referer = referer_from_request request
+          @accept = attribute_from_env request, HTTP_ACCEPT_HEADER_KEY
+          @content_length = content_length_from_request request
+          @host = attribute_from_request request, :host
+          @port = port_from_request request
+          @user_agent = attribute_from_request request, :user_agent
+          @request_method = attribute_from_request request, :request_method
+          @query_string = attribute_from_request request, :query_string
+        end
+
+        def assign_agent_attributes(txn)
+
+          if request_path
+            txn.add_agent_attribute :request_path, request_path
+          end
+
+          if referer
+            txn.add_agent_attribute :referer, referer
+          end
+
+          if accept
+            txn.add_agent_attribute :accept, accept
+          end
+
+          if content_length
+            txn.add_agent_attribute :contentLength, content_length
+          end
+
+          if host
+            txn.add_agent_attribute :host, host
+          end
+
+          if port
+            txn.add_agent_attribute :port, port
+          end
+
+          if user_agent
+            txn.add_agent_attribute :userAgent, user_agent
+          end
+
+          if request_method
+            txn.add_agent_attribute :method, request_method
+          end
+
+          if query_string
+            txn.add_agent_attribute :request_params, request_params
+          end
+        end
+
+
+        private
+
+        # Make a safe attempt to get the referer from a request object, generally successful when
+        # it's a Rack request.
+
+        def request_params
+          hash = {}
+          return hash if @query_string.empty?
+          query_string.split('&').each do |param|
+            _k,_v = param.strip.split('=')
+            hash[_k] = _v unless _v.nil?
+          end
+
+          hash
+        end
+
+        def referer_from_request request
+          if referer = attribute_from_request(request, :referer)
+            TingYun::Agent::HTTPClients::URIUtil.strip_query_string referer.to_s
+          end
+        end
+
+
+
+        ROOT_PATH = "/".freeze
+
+        def path_from_request request
+          path = attribute_from_request(request, :path) || ''
+          path = TingYun::Agent::HTTPClients::URIUtil.strip_query_string(path)
+          path.empty? ? ROOT_PATH : path
+        end
+
+        def content_length_from_request request
+          if content_length = attribute_from_request(request, :content_length)
+            content_length.to_i
+          end
+        end
+
+        def port_from_request request
+          if port = attribute_from_request(request, :port)
+            port.to_i
+          end
+        end
+
+        def attribute_from_request request, attribute_method
+          if request.respond_to? attribute_method
+            request.send(attribute_method)
+          end
+        end
+
+        def attribute_from_env request, key
+          if env = attribute_from_request(request, :env)
+            env[key]
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/trace.rb

@@ -0,0 +1,125 @@
+  # encoding: utf-8
+require 'ting_yun/agent/transaction/trace_node'
+require 'ting_yun/support/helper'
+require 'ting_yun/support/coerce'
+require 'ting_yun/agent/database'
+module TingYun
+  module Agent
+    class Transaction
+      class Trace
+
+        attr_accessor :node_count, :threshold, :metric_name, :uri, :guid, :attributes, :start_time, :finished, :tx_id
+
+        attr_reader  :root_node
+
+        def initialize(start_time)
+          @start_time = start_time
+          @node_count = 0
+          @root_node = TingYun::Agent::Transaction::TraceNode.new(0.0, 'ROOT')
+          @prepared = false
+          @guid = generate_guid
+        end
+
+        def create_node(time_since_start, metric_name = nil)
+          @node_count += 1
+          TingYun::Agent::Transaction::TraceNode.new(time_since_start, metric_name)
+        end
+
+        def duration
+          @root_node.duration
+        end
+
+
+
+        include TingYun::Support::Coerce
+        
+        def trace_tree
+          [
+              duration,
+              request_params,
+              custom_params,
+              @root_node.to_array
+          ]
+        end
+
+        def to_collector_array(encoder)
+          [
+              @start_time.round,
+              duration,
+              TingYun::Helper.correctly_encoded(metric_name),
+              TingYun::Helper.correctly_encoded(uri),
+              encoder.encode(trace_tree),
+              tx_id || '',
+              guid
+          ]
+        end
+
+        def prepare_to_send!
+          return self if @prepared
+
+          if TingYun::Agent::Database.should_record_sql?('nbs.action_tracer.record_sql')
+            collect_explain_plans!
+            prepare_sql_for_transmission!
+          else
+            @root_node.each_call do |node|
+              node.params.delete(:sql)
+            end
+          end
+          @prepared = true
+          self
+        end
+
+        def collect_explain_plans!
+          return unless TingYun::Agent::Database.should_action_collect_explain_plans?
+          threshold = TingYun::Agent.config[:'nbs.action_tracer.action_threshold']
+          @root_node.each_call do |node|
+            if node[:sql] && node.duration > threshold
+              node[:explainPlan] = node.explain_sql
+            end
+          end
+        end
+
+        def prepare_sql_for_transmission!(&block)
+          strategy = TingYun::Agent::Database.record_sql_method('nbs.action_tracer.record_sql')
+          @root_node.each_call do |node|
+            next unless node[:sql]
+
+            case strategy
+              when :obfuscated
+                node[:sql] = TingYun::Agent::Database.obfuscate_sql(node[:sql])
+              when :raw
+                node[:sql] = node[:sql].sql.to_s
+              else
+                node[:sql] = nil
+            end
+          end
+        end
+
+        def custom_params
+          {
+              :threadName => string(attributes.agent_attributes[:threadName]),
+              :httpStatus => int(attributes.agent_attributes[:httpStatus]),
+              :referer    => string(attributes.agent_attributes[:referer]) || ''
+          }
+        end
+
+        def request_params
+          attributes.agent_attributes[:request_params]
+        end
+
+        HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+        GUID_LENGTH = 16
+
+        # generate a random 64 bit uuid
+        private
+        def generate_guid
+          guid = ''
+          GUID_LENGTH.times do
+            guid << HEX_DIGITS[rand(16)]
+          end
+          guid
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/trace_node.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+require 'ting_yun/support/helper'
+require 'ting_yun/support/coerce'
+require 'ting_yun/agent/database'
+
+
+module TingYun
+  module Agent
+    class Transaction
+      class TraceNode
+
+        attr_reader :entry_timestamp, :parent_node, :called_nodes
+        attr_accessor :metric_name, :exit_timestamp, :uri, :count, :klass, :method
+
+
+
+        UNKNOWN_NODE_NAME = '<unknown>'.freeze
+
+
+        def initialize(timestamp, metric_name)
+          @entry_timestamp = timestamp
+          @metric_name     = metric_name || UNKNOWN_NODE_NAME
+          @called_nodes    = nil
+          @count           = 1
+        end
+
+        def add_called_node(s)
+          @called_nodes ||= []
+          @called_nodes << s
+          s.parent_node = self
+        end
+
+        def end_trace(timestamp)
+          @exit_timestamp = timestamp
+        end
+
+        # return the total duration of this node
+        def duration
+          TingYun::Helper.time_to_millis(@exit_timestamp - @entry_timestamp)
+        end
+
+
+        def to_array
+          [TingYun::Helper.time_to_millis(entry_timestamp),
+           TingYun::Helper.time_to_millis(exit_timestamp),
+           TingYun::Support::Coerce.string(metric_name),
+           TingYun::Support::Coerce.string(uri)||'',
+           TingYun::Support::Coerce.int(count),
+           TingYun::Support::Coerce.string(klass)||TingYun::Support::Coerce.string(metric_name),
+           TingYun::Support::Coerce.string(method)||'',
+           params] +
+           [(@called_nodes ? @called_nodes.map{|s| s.to_array} : [])]
+        end
+
+        def custom_params
+          {}
+        end
+
+        def request_params
+          {}
+        end
+
+        def []=(key, value)
+          # only create a parameters field if a parameter is set; this will save
+          # bandwidth etc as most nodes have no parameters
+          params[key] = value
+        end
+
+        def [](key)
+          params[key]
+        end
+
+        def params
+          @params ||= {}
+        end
+
+        def params=(p)
+          @params = p
+        end
+
+        def each_call(&blk)
+          blk.call self
+
+          if @called_nodes
+            @called_nodes.each do |node|
+              node.each_call(&blk)
+            end
+          end
+        end
+
+        def explain_sql
+          return params[:explainPlan] if params.key?(:explainPlan)
+
+          statement = params[:sql]
+          return nil unless statement.respond_to?(:config) &&
+              statement.respond_to?(:explainer)
+
+          TingYun::Agent::Database.explain_sql(statement.sql,
+                                                statement.config,
+                                                statement.explainer)
+        end
+
+        protected
+        def parent_node=(s)
+          @parent_node = s
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/traced_method_stack.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    class TracedMethodFrame
+      attr_reader :tag
+      attr_accessor :name, :start_time, :children_time
+      def initialize(tag, start_time)
+        @tag = tag
+        @start_time = start_time
+        @children_time = 0
+      end
+    end
+
+    class TracedMethodStack
+      def initialize
+        @stack = []
+      end
+
+      def push_frame(state, tag, time = Time.now.to_f)
+        transaction_sampler.notice_push_frame(state, time) if sampler_enabled?
+        frame = TracedMethodFrame.new(tag, time)
+        @stack.push frame
+        frame
+      end
+
+      def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
+        frame = fetch_matching_frame(expected_frame)
+        note_children_time(frame, time, deduct_call_time_from_parent)
+        transaction_sampler.notice_pop_frame(state, name, time) if sampler_enabled?
+        frame.name = name
+        frame
+      end
+
+      def fetch_matching_frame(expected_frame)
+        while frame = @stack.pop
+          if frame == expected_frame
+            return frame
+          else
+            TingYun::Agent.logger.info("Unexpected frame in traced method stack: #{frame.inspect} expected to be #{expected_frame.inspect}")
+            TingYun::Agent.logger.debug do
+              ["Backtrace for unexpected frame: ", caller.join("\n")]
+            end
+          end
+        end
+
+        raise "Frame not found in blame stack: #{expected_frame.inspect}"
+      end
+
+      def note_children_time(frame, time, deduct_call_time_from_parent)
+        if !@stack.empty?
+          if deduct_call_time_from_parent
+            @stack.last.children_time += (time - frame.start_time)*1000
+          else
+            @stack.last.children_time += frame.children_time
+          end
+        end
+      end
+
+
+      def sampler_enabled?
+        TingYun::Agent.config[:'nbs.action_tracer.enabled']
+      end
+
+
+
+      def transaction_sampler
+        TingYun::Agent.instance.transaction_sampler
+      end
+
+      def clear
+        @stack.clear
+      end
+
+      def empty?
+        @stack.empty?
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/transaction_metrics.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require 'ting_yun/metrics/stats'
+
+module TingYun
+  module Agent
+    class TransactionMetrics
+      DEFAULT_PROC = Proc.new { |hash, name| hash[name] = TingYun::Metrics::Stats.new }
+
+      def initialize
+        @unscoped = Hash.new(&DEFAULT_PROC)
+        @scoped   = Hash.new(&DEFAULT_PROC)
+      end
+
+      def record_scoped(names, value=nil, aux=nil, &blk)
+        _record_metrics(names, value, aux, @scoped, &blk)
+      end
+
+      def record_unscoped(names, value=nil, aux=nil, &blk)
+        _record_metrics(names, value, aux, @unscoped, &blk)
+      end
+
+      def has_key?(key)
+        @unscoped.has_key?(key)
+      end
+
+      def [](key)
+        @unscoped[key]
+      end
+
+      def each_unscoped
+        @unscoped.each { |name, stats| yield name, stats }
+      end
+
+      def each_scoped
+        @scoped.each { |name, stats| yield name, stats }
+      end
+
+      def _record_metrics(names, value, aux, target, &blk)
+        # This looks dumb, but we're avoiding an extra Array allocation.
+        case names
+          when Array
+            names.each do |name|
+              target[name].record(value, aux, &blk)
+            end
+          else
+            target[names].record(value, aux, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/ting_yun/agent/transaction/transaction_sample_builder.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'ting_yun/agent/transaction/trace'
+
+
+module TingYun
+  module Agent
+    class TransactionSampleBuilder
+      attr_reader :current_node, :trace
+
+      def initialize(time=Time.now)
+        @trace = TingYun::Agent::Transaction::Trace.new(time.to_f)
+        @trace_start = time.to_f
+        @current_node = @trace.root_node
+      end
+
+      def trace_entry(time)
+        if @trace.node_count < node_limit
+          node = @trace.create_node(time.to_f - @trace_start)
+          @current_node.add_called_node(node)
+          @current_node = node
+
+          if @trace.node_count == node_limit
+            ::TingYun::Agent.logger.debug("Node limit of #{node_limit} reached, ceasing collection.")
+          end
+        end
+        @current_node
+      end
+
+      def trace_exit(metric_name, time)
+        @current_node.metric_name = metric_name
+        @current_node.end_trace(time.to_f - @trace_start)
+        @current_node = @current_node.parent_node
+      end
+
+      def finish_trace(time=Time.now.to_f)
+
+        if @trace.finished
+          ::TingYun::Agent.logger.error "Unexpected double-finish_trace of Transaction Trace Object: \n#{@trace.to_s}"
+          return
+        end
+
+        @trace.root_node.end_trace(time - @trace_start)
+
+        @trace.threshold = transaction_trace_threshold
+        @trace.finished = true
+        @current_node = nil
+      end
+
+
+      def transaction_trace_threshold
+        Agent.config[:'nbs.action_tracer.action_threshold']
+      end
+
+
+
+
+      def node_limit
+        Agent.config[:'transaction_tracer.limit_segments']
+      end
+    end
+  end
+end