tingyun_rpm 1.1.4.2 → 1.2.0

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'ting_yun/support/helper'
+module TingYun
+  module Agent
+
+    class Transaction
+      class Apdex
+        APDEX_TXN_METRIC_PREFIX = 'Apdex/'.freeze
+
+        attr_accessor :apdex_start, :transaction_start_time
+
+        def initialize(start, transaction_start)
+          @apdex_start = start || transaction_start
+          @transaction_start_time = transaction_start
+        end
+
+        def record_apdex(metric_name, end_time, failed)
+          total_duration = TingYun::Helper.time_to_millis(end_time - apdex_start)
+          if TingYun::Agent::Transaction.recording_web_transaction?
+            record_apdex_metrics(APDEX_TXN_METRIC_PREFIX, total_duration, TingYun::Agent.config[:apdex_t], metric_name, failed)
+          end
+        end
+
+        def record_apdex_metrics(transaction_prefix, total_duration, current_apdex_t, metric_name, failed)
+          return unless current_apdex_t
+          return unless metric_name.start_with?(CONTROLLER_PREFIX)
+
+          apdex_bucket_global = apdex_bucket(total_duration, failed, current_apdex_t)
+          txn_apdex_metric = metric_name.sub(/^[^\/]+\//, transaction_prefix)
+          ::TingYun::Agent::Transaction.metrics.record_unscoped(txn_apdex_metric, apdex_bucket_global, current_apdex_t)
+        end
+
+
+        def apdex_bucket(duration, failed, apdex_t)
+          case
+            when failed
+              :apdex_f
+            when duration <= apdex_t
+              :apdex_s
+            when duration <= 4 * apdex_t
+              :apdex_t
+            else
+              :apdex_f
+          end
+        end
+
+        def queue_time
+          @transaction_start_time - @apdex_start
+        end
+      end
+    end
+  end
+end

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

@@ -11,14 +11,15 @@ module TingYun
           @request_params = {}
         end
 
+        # no longer to care about the value if nil or not
         def add_agent_attribute(key, value)
-          return if value.nil?
           @agent_attributes[key] = value
         end
 
         def merge_request_parameters(hash)
           @request_params.merge!(hash) if hash
         end
+
       end
     end
   end

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

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    class Transaction
+    # web transaction
+      module ClassMethod
+
+        def tl_current
+          TingYun::Agent::TransactionState.tl_get.current_transaction
+        end
+
+        def metrics
+          txn = tl_current
+          txn && txn.metrics
+        end
+
+
+        def recording_web_transaction? #THREAD_LOCAL_ACCESS
+          txn = tl_current
+          txn && txn.web_category?(txn.category)
+        end
+
+        # See TingYun::Agent.notice_error for options and commentary
+        def notice_error(e, options={})
+          state = TingYun::Agent::TransactionState.tl_get
+          txn = state.current_transaction
+          if txn
+            txn.exceptions.notice_error(e, options)
+          elsif TingYun::Agent.instance
+            TingYun::Agent.instance.error_collector.notice_error(e, options)
+          end
+        end
+
+
+        def stop(state, end_time = Time.now)
+
+          txn = state.current_transaction
+
+          unless txn
+            TingYun::Agent.logger.error("Failed during Transaction.stop because there is no current transaction")
+            return
+          end
+
+          nested_frame = txn.frame_stack.pop
+
+          if txn.frame_stack.empty?
+            txn.stop(state, end_time, nested_frame)
+            state.reset
+          else
+            nested_name = nested_transaction_name(nested_frame.name)
+
+            if nested_name.start_with?(MIDDLEWARE_PREFIX)
+              summary_metrics = MIDDLEWARE_SUMMARY_METRICS
+            else
+              summary_metrics = EMPTY_SUMMARY_METRICS
+            end
+
+            TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
+                state,
+                nested_frame.start_time.to_f,
+                nested_name,
+                summary_metrics,
+                nested_frame,
+                NESTED_TRACE_STOP_OPTIONS,
+                end_time.to_f)
+
+          end
+
+          :transaction_stopped
+        rescue => e
+          state.reset
+          TingYun::Agent.logger.error("Exception during Transaction.stop", e)
+          nil
+        end
+
+        def wrap(state, name, category, options = {})
+          Transaction.start(state, category, options.merge(:transaction_name => name))
+
+          begin
+            # We shouldn't raise from Transaction.start, but only wrap the yield
+            # to be absolutely sure we don't report agent problems as app errors
+            yield
+          rescue => e
+            Transaction.notice_error(e)
+            raise e
+          ensure
+            Transaction.stop(state)
+          end
+        end
+
+
+        def start(state, category, options)
+          category ||= :controller
+          txn = state.current_transaction
+          if txn
+            txn.create_nested_frame(state, category, options)
+          else
+            txn = start_new_transaction(state, category, options)
+          end
+
+          # merge params every step into here
+          txn.attributes.merge_request_parameters(options[:filtered_params])
+
+          txn
+        rescue => e
+          TingYun::Agent.logger.error("Exception during Transaction.start", e)
+        end
+
+        def start_new_transaction(state, category, options)
+          txn = Transaction.new(category, state.client_transaction_id, options)
+          state.reset(txn)
+          txn.start(state)
+          txn
+        end
+
+        def nested_transaction_name(name)
+          if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(RAKE_TRANSACTION_PREFIX)
+            "#{SUBTRANSACTION_PREFIX}#{name}"
+          else
+            name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    class Transaction
+      class Exceptions
+        attr_accessor :exceptions
+
+        def initialize
+          @exceptions = {}
+        end
+
+        def record_exceptions(attributes)
+          unless @exceptions.empty?
+            @exceptions.each do |exception, options|
+              options[:attributes]      = attributes
+              ::TingYun::Agent.instance.error_collector.notice_error(exception, options)
+            end
+          end
+        end
+
+        # Do not call this.  Invoke the class method instead.
+        def notice_error(error, options={}) # :nodoc:
+          if @exceptions[error]
+            @exceptions[error].merge! options
+          else
+            @exceptions[error] = options
+          end
+        end
+
+        #collector error
+        def had_error?
+          if @exceptions.empty?
+            return false
+          else
+            return true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+module TingYun
+  module Agent
+    class Transaction
+      module InstanceMethod
+
+        def create_nested_frame(state, category, options)
+          @has_children = true
+          frame_stack.push TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
+          name_last_frame(options[:transaction_name])
+
+          set_default_transaction_name(options[:transaction_name], category)
+        end
+
+
+        def set_default_transaction_name(name, category)
+          if @frozen_name
+            TingYun::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
+            return
+          end
+          if influences_transaction_name?(category)
+            @default_name = name
+            @category = category if category
+          end
+        end
+
+
+        def name_last_frame(name)
+          frame_stack.last.name = name
+        end
+
+
+        def best_name
+          @frozen_name || @default_name || ::TingYun::Agent::UNKNOWN_METRIC
+        end
+
+
+        def influences_transaction_name?(category)
+          !category || frame_stack.size == 1 || similar_category?(category)
+        end
+
+        WEB_TRANSACTION_CATEGORIES = [:controller, :uri, :rack, :sinatra, :grape, :middleware, :thrift].freeze
+
+        def web_category?(category)
+          WEB_TRANSACTION_CATEGORIES.include?(category)
+        end
+
+        def similar_category?(category)
+          web_category?(@category) == web_category?(category)
+        end
+
+
+        def needs_middleware_summary_metrics?(name)
+          name.start_with?(MIDDLEWARE_PREFIX)
+        end
+
+        alias_method :ignore, :needs_middleware_summary_metrics?
+
+        def record_summary_metrics(outermost_node_name,end_time)
+          unless @frozen_name == outermost_node_name
+            @metrics.record_unscoped(@frozen_name, TingYun::Helper.time_to_millis(end_time.to_f - start_time.to_f))
+          end
+        end
+
+        def assign_agent_attributes
+
+          @attributes.add_agent_attribute(:threadName,  "pid-#{$$}");
+
+          if @request_attributes
+            @request_attributes.assign_agent_attributes @attributes
+          end
+
+          @attributes.add_agent_attribute(:tx_id,  @guid);
+          @attributes.add_agent_attribute(:metric_name,  best_name);
+
+        end
+
+
+        # This transaction-local hash may be used as temprory storage by
+        # instrumentation that needs to pass data from one instrumentation point
+        # to another.
+        #
+        # For example, if both A and B are instrumented, and A calls B
+        # but some piece of state needed by the instrumentation at B is only
+        # available at A, the instrumentation at A may write into the hash, call
+        # through, and then remove the key afterwards, allowing the
+        # instrumentation at B to read the value in between.
+        #
+        # Keys should be symbols, and care should be taken to not generate key
+        # names dynamically, and to ensure that keys are removed upon return from
+        # the method that creates them.
+        #
+        def instrumentation_state
+          @instrumentation_state ||= {}
+        end
+
+        def with_database_metric_name(model, method, product=nil)
+          previous = self.instrumentation_state[:datastore_override]
+          model_name = case model
+                         when Class
+                           model.name
+                         when String
+                           model
+                         else
+                           model.to_s
+                       end
+          @instrumentation_state[:datastore_override] = [method, model_name, product]
+          yield
+        ensure
+          @instrumentation_state[:datastore_override] = previous
+        end
+
+        def freeze_name_and_execute
+          unless @frozen_name
+            @frozen_name = best_name
+          end
+
+          yield if block_given?
+        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/request_attributes.rb

@@ -25,41 +25,15 @@ module TingYun
           @cookie = set_cookie(request)
         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
-
-
+        def assign_agent_attributes(attributes)
+          attributes.add_agent_attribute :request_path, request_path
+          attributes.add_agent_attribute :referer, referer
+          attributes.add_agent_attribute :accept, accept
+          attributes.add_agent_attribute :contentLength, content_length
+          attributes.add_agent_attribute :host, host
+          attributes.add_agent_attribute :port, port
+          attributes.add_agent_attribute :userAgent, user_agent
+          attributes.add_agent_attribute :method, request_method
         end
 
 
@@ -68,16 +42,12 @@ module TingYun
         # Make a safe attempt to get the referer from a request object, generally successful when
         # it's a Rack request.
 
-
-
         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