tingyun_rpm 1.4.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42cfa48ff65b496435593ce17a380b7bff332c65
-  data.tar.gz: f5afe74bed3f331d60977bebfdf4c51da40c3a47
+  metadata.gz: bdc5d84fba459da89f499abfdfce47cf81995046
+  data.tar.gz: bade661f66b85afb9e4f5f0ab9c1088424343fb4
 SHA512:
-  metadata.gz: ba7ada9279f07888fbacfe7f1ed7334f66143d99138a7395448225f7d98e0ef2cb9db4596c8e84b3cc53ac7567477452dd6a0614b6d40d0460e0c1a55b34cc5a
-  data.tar.gz: 12c24299ef09a1698720cca513e4b5bdfbd2b7065cec4e1d1e350ce06a69fc4f2adb40b02acca889735933d58b9367fd9046e786369ee3fdf0c4924d62d25e5d
+  metadata.gz: a87bbc8cb3dc20381701255dc19773731d73415556861e977c1f483e8d7546ca9cfd9e435bbbf87a14047af5630f962ade76d3c37b55f3306ec1026003b00e6e
+  data.tar.gz: 57f728853e98684bd7c6188a29d53367194caea82fcf8a40f1b9896054e7b2e887ae7a17403e1f0275b65dfb4b345074060d50de9cdbd7c6af183ca9d6aa94ec

data/lib/ting_yun/agent.rb

@@ -123,11 +123,13 @@ module TingYun
     #
     # @api public
     #
-    def notice_error(exception, options={})
+    def notice_error(exception, options={:type =>:exception})
       TingYun::Agent::Transaction.notice_error(exception, options)
       nil # don't return a noticed error datastructure. it can only hurt.
     end
 
+
+
     # Register this method as a callback for processes that fork
     # jobs.
     #
@@ -200,5 +202,9 @@ module TingYun
       txn.attributes.add_custom_params(key, value) if txn
     end
 
+    def tl_is_execution_traced?
+      TingYun::Agent::TransactionState.tl_get.execution_traced?
+    end
+
   end
 end

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

@@ -10,12 +10,17 @@ module TingYun
     module Collector
       class ErrorCollector
         ERRORS_ACTION = "Errors/Count/".freeze
-
-
-
         ERRORS_ALL = "Errors/Count/All".freeze
         ERRORS_ALL_WEB = "Errors/Count/AllWeb".freeze
         ERRORS_ALL_BACK_GROUND = "Errors/Count/AllBackground".freeze
+        ERRORS_TYPE = "Errors/Type:".freeze
+
+        EXCEPTIONS_ACTION = "Exception/Count/".freeze
+        EXCEPTIONS_ALL = "Exception/Count/All".freeze
+        EXCEPTIONS_ALL_WEB = "Exception/Count/AllWeb".freeze
+        EXCEPTIONS_ALL_BACK_GROUND = "Exception/Count/AllBackground".freeze
+        EXCEPTIONS_TYPE = "Exception/Type:".freeze
+
 
         # Maximum possible length of the queue - defaults to 20, may be
         MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
@@ -54,60 +59,131 @@ module TingYun
             metric_names
           end
 
-          def action_metric_name(txn)
-            "#{ERRORS_ACTION}#{txn.best_name}" if txn
+          def action_metric_names(txn,exception)
+            names =  ["#{ERRORS_ACTION}#{txn.best_name}"]
+            if exception.respond_to? :tingyun_klass
+              names <<  "#{ERRORS_ACTION}#{exception.tingyun_klass}"
+            end
+            names
+          end
+
+          def aggregated_type_count(exception,txn)
+            names  =  ["#{ERRORS_TYPE}#{exception.class.to_s}/#{txn.best_name}"]
+            if exception.respond_to? :tingyun_klass
+              names << "#{ERRORS_TYPE}#{exception.tingyun_code}/#{exception.tingyun_klass}"
+            end
+            names
+          end
+          def aggregated_exception_metric_names(txn)
+            metric_names = [EXCEPTIONS_ALL]
+            return metric_names unless txn
+
+            if TingYun::Agent::Transaction.recording_web_transaction?
+              metric_names << EXCEPTIONS_ALL_WEB
+            else
+              metric_names << EXCEPTIONS_ALL_BACK_GROUND
+            end
+
+            metric_names
+          end
+          def action_exception_metric_names(txn)
+            "#{EXCEPTIONS_ACTION}#{txn.best_name}"
+          end
+
+          def aggregated_exception_type_count(exception,txn)
+            if exception.respond_to? :tingyun_klass
+              names = ["#{EXCEPTIONS_TYPE}External #{exception.tingyun_code}/#{txn.best_name}"]
+              names << "#{ERRORS_TYPE}#{exception.tingyun_code}/#{exception.tingyun_klass}"
+              names << "#{ERRORS_ACTION}External/#{exception.tingyun_klass}"
+            else
+              names = ["#{EXCEPTIONS_TYPE}#{exception.class.to_s}/#{txn.best_name}"]
+            end
+            names
           end
 
         end
         include Metric
 
-        attr_reader :error_trace_array, :external_error_array
+        attr_reader :error_trace_array, :external_error_array,:exception_error_array
 
         def initialize
           @error_trace_array = ::TingYun::Agent::Collector::ErrorTraceArray.new(MAX_ERROR_QUEUE_LENGTH)
           @external_error_array = ::TingYun::Agent::Collector::ErrorTraceArray.new(MAX_ERROR_QUEUE_LENGTH)
+          @exception_error_array = ::TingYun::Agent::Collector::ErrorTraceArray.new(MAX_ERROR_QUEUE_LENGTH)
         end
 
         # See TingYun::Agent.notice_error for options and commentary
         def notice_error(exception, options={})
           tag_exception(exception)
           state = ::TingYun::Agent::TransactionState.tl_get
-          increment_error_count(state)
-          noticed_error = create_noticed_error(exception, options)
+          increment_error_count(exception,state,options[:type])
+          _error = create_noticed_error(exception, options)
+          noticed_error = _error.clone
           if noticed_error.is_external_error
-            external_error_array.add_to_error_queue(noticed_error)
+            noticed_error.is_external_error = nil
+            external_error_array.add_to_error_queue(_error)
+          end
+          if noticed_error.type && noticed_error.type == :exception
+             exception_error_array.add_to_error_queue(noticed_error)
           else
             error_trace_array.add_to_error_queue(noticed_error)
           end
+
+
         rescue => e
           ::TingYun::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
           nil
         end
 
         # Increments a statistic that tracks total error rate
-        def increment_error_count(state)
-          txn = state.current_transaction
-
-          metric_names = aggregated_metric_names(txn)
-
-          action_metric = action_metric_name(txn)
-          metric_names << action_metric if action_metric
 
-          stats_engine = TingYun::Agent.agent.stats_engine
-          stats_engine.record_unscoped_metrics(state, metric_names) do |stats|
-            stats.increment_count
+        # Notice the error with the given available options:
+        #
+        # * <tt>:type</tt> => default nil; :exception,:error
+        #
+        def increment_error_count(exception,state, type)
+          txn = state.current_transaction
+          if type && type==:exception
+            exception_metric_names = aggregated_exception_metric_names(txn)
+            exception_metric_names.concat aggregated_exception_type_count(exception,txn)
+            exception_metric_names << action_exception_metric_names(txn)
+            stats_engine = TingYun::Agent.agent.stats_engine
+            stats_engine.record_unscoped_metrics(state, exception_metric_names) do |stats|
+              stats.increment_count
+            end
+          else
+            metric_names = aggregated_metric_names(txn)
+            metric_names.concat aggregated_type_count(exception,txn)
+            metric_names.concat action_metric_names(txn,exception)
+            stats_engine = TingYun::Agent.agent.stats_engine
+            stats_engine.record_unscoped_metrics(state, metric_names) do |stats|
+              stats.increment_count
+            end
           end
         end
 
         EMPTY_STRING = ''.freeze
 
         def create_noticed_error(exception, options)
-          attributes = options[:attributes]
-          error_metric = attributes.agent_attributes[:metric_name] || EMPTY_STRING
-          noticed_error = TingYun::Agent::Collector::NoticedError.new(error_metric, exception)
-          noticed_error.attributes  = attributes
-          noticed_error.stack_trace = extract_stack_trace(exception)
-          noticed_error
+          if options[:type] && options[:type]==:exception
+            attributes = options[:attributes]
+            error_metric = options[:attributes].agent_attributes[:metric_name] || EMPTY_STRING
+            noticed_error = TingYun::Agent::Collector::NoticedError.new(error_metric, exception)
+            noticed_error.attributes  = attributes
+            noticed_error.stack_trace = extract_stack_trace(exception) if ::TingYun::Agent.config[:'nbs.exception.stack_enabled']
+            noticed_error.type = options[:type]
+            noticed_error
+          else
+            attributes = options[:attributes]
+            error_metric = attributes.agent_attributes[:metric_name] || EMPTY_STRING
+            noticed_error = TingYun::Agent::Collector::NoticedError.new(error_metric, exception)
+            noticed_error.attributes  = attributes
+            noticed_error.stack_trace = extract_stack_trace(exception)
+            noticed_error.type = options[:type]
+            noticed_error.code = attributes.agent_attributes[:httpStatus]
+            noticed_error
+          end
+
         end
 
 
@@ -146,6 +222,8 @@ module TingYun
           @external_error_array.reset!
           nil
         end
+
+
       end
     end
   end

data/lib/ting_yun/agent/collector/error_collector/error_trace_array.rb

@@ -12,6 +12,8 @@ module TingYun
           @errors = []
         end
 
+
+
         def enabled?
           ::TingYun::Agent.config[:'nbs.error_collector.enabled']
         end

data/lib/ting_yun/agent/collector/error_collector/noticed_error.rb

@@ -16,7 +16,7 @@ module TingYun
 
         attr_accessor :metric_name, :timestamp, :message, :exception_class_name,
                       :stack_trace, :attributes_from_notice_error, :attributes,
-                      :count_error, :is_external_error, :external_metric_name, :code, :trace
+                      :count_error, :is_external_error, :external_metric_name, :code, :trace, :type, :http_code
 
         attr_reader :exception_id, :is_internal
 
@@ -27,11 +27,12 @@ module TingYun
           @stack_trace = []
           @count_error = 1
           @exception_id = exception.object_id
-          @exception_class_name = exception.is_a?(Exception) ? exception.class.name : 'Error'
+          @exception_class_name = exception.is_a?(Exception)? exteneral_error?(exception)? "External #{exception.tingyun_code}" : exception.class.name : 'Error'
           @is_external_error = exception.respond_to?(:tingyun_external)? exception.tingyun_external : false
+          @code = 0
           if @is_external_error
             @external_metric_name = exception.tingyun_klass
-            @code = exception.tingyun_code
+            @http_code = exception.tingyun_code
             @trace = exception.tingyun_trace
           end
           # It's critical that we not hold onto the exception class constant in this
@@ -80,7 +81,7 @@ module TingYun
           if  is_external_error
             [timestamp.to_i,
              string(external_metric_name),
-             int(code),
+             int(http_code),
              string(exception_class_name),
              count_error,
              string(metric_name),
@@ -89,12 +90,13 @@ module TingYun
           else
             [timestamp.to_i,
              string(metric_name),
-             int(attributes.agent_attributes[:httpStatus]),
+             int(code),
              string(exception_class_name),
              string(message),
              count_error,
              string(attributes.agent_attributes[:request_path]||metric_name),
-             encoder.encode(error_params)
+             encoder.encode(error_params),
+             attributes.agent_attributes[:trace_id]
             ]
           end
         end
@@ -104,7 +106,7 @@ module TingYun
               :params => custom_params
           }
           if is_external_error
-            hash[:stacktrace] = trace
+              hash[:stacktrace] = trace
           else
             hash[:stacktrace] = stack_trace
             hash[:requestParams] = request_params
@@ -113,13 +115,10 @@ module TingYun
         end
 
         def custom_params
+          return {} if type ==:exception
           hash = {:threadName => string(attributes.agent_attributes[:threadName])}
-          if is_external_error
-            hash[:httpStatus] = int(code)
-          else
-            hash[:httpStatus] = int(attributes.agent_attributes[:httpStatus])
-            hash[:referer] = string(attributes.agent_attributes[:referer]) || ''
-          end
+          hash[:httpStatus] = int(code)
+          hash[:referer] = string(attributes.agent_attributes[:referer]) || ''
           hash
         end
 
@@ -128,6 +127,14 @@ module TingYun
           attributes.request_params
         end
 
+        def exteneral_error? exception
+          if defined? ::Thrift::ApplicationException
+           exception.is_a?(TingYun::Support::Exception::InternalServerError) or exception.is_a?(::Thrift::ApplicationException)
+          else
+            exception.is_a?(TingYun::Support::Exception::InternalServerError)
+          end
+        end
+
       end
     end
   end

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

@@ -62,7 +62,8 @@ module TingYun
           end
         end
 
-        def on_finishing_transaction(state, txn, time=Time.now.to_f)
+        def on_finishing_transaction(state, txn, time=Time.now.to_f, exceptions)
+
           last_builder = state.transaction_sample_builder
           return unless last_builder && TingYun::Agent.config[:'nbs.action_tracer.enabled']
 
@@ -70,6 +71,8 @@ module TingYun
 
           final_trace = last_builder.trace
           final_trace.attributes = txn.attributes
+          final_trace.array_size = exceptions.errors_and_exceptions
+          final_trace.add_errors(exceptions.errors.keys)
 
 
           @lock.synchronize do

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

@@ -7,17 +7,17 @@ module TingYun
         module ClassMethod
 
 
-          def notice_push_frame(state, time=Time.now)
+          def notice_push_frame(state, time=Time.now.to_f)
             builder = state.transaction_sample_builder
             return unless builder
-            builder.trace_entry(time.to_f)
+            builder.trace_entry(time)
           end
 
           # Informs the transaction sample builder about the end of a traced frame
-          def notice_pop_frame(state, frame, time = Time.now, klass_name=nil)
+          def notice_pop_frame(state, frame, time = Time.now.to_f, klass_name=nil, error = nil)
             builder = state.transaction_sample_builder
             return unless builder
-            builder.trace_exit(frame, time.to_f, klass_name)
+            builder.trace_exit(frame, time, klass_name, error)
           end
 
 

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

@@ -36,9 +36,6 @@ module TingYun
           node = start_trace(state, t0, request)
           response = yield
           capture_exception(response, request)
-        rescue => e
-          klass = "External/#{request.uri.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/#{request.from}"
-          handle_error(e, klass)
         ensure
           finish_trace(state, t0, node, request, response)
         end
@@ -54,6 +51,7 @@ module TingYun
       end
 
       def finish_trace(state, t0, node, request, response)
+
         t1 = Time.now.to_f
         duration = (t1- t0) * 1000
         state.timings.external_duration = duration

data/lib/ting_yun/agent/instance_methods/container_data_manager.rb

@@ -51,6 +51,7 @@ module TingYun
           @service.session do # use http keep-alive
             harvest_and_send_errors
             harvest_and_send_external_errors
+            harvest_and_send_exceptions
             harvest_and_send_timeslice_data
             harvest_and_send_transaction_traces
             harvest_and_send_slowest_sql
@@ -65,6 +66,11 @@ module TingYun
           harvest_and_send_from_container(@error_collector.error_trace_array, :error_data)
         end
 
+        def harvest_and_send_exceptions
+          harvest_and_send_from_container(@error_collector.exception_error_array, :exception_data)
+        end
+
+
         def harvest_and_send_external_errors
           harvest_and_send_from_container(@error_collector.external_error_array, :external_error_data)
         end

data/lib/ting_yun/agent/method_tracer_helpers.rb

@@ -13,7 +13,6 @@ module TingYun
         yield
       rescue => e
         ::TingYun::Agent.logger.error("Caught exception in #{code_area}.", e)
-        ::TingYun::Agent.notice_error(e, method: code_area, path: "ting_yun/agent/method_tracer_helpers")
       end
 
       def trace_execution_scoped_header(state, t0)
@@ -23,12 +22,12 @@ module TingYun
         end
       end
 
-      def trace_execution_scoped_footer(state, t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f, klass_name=nil)
+      def trace_execution_scoped_footer(state, t0, first_name, metric_names, expected_frame, options, t1=Time.now.to_f, klass_name=nil, error = nil)
         log_errors(:trace_execution_scoped_footer) do
           if expected_frame
             stack = state.traced_method_stack
             create_metrics = options.has_key?(:metric) ? options[:metric] : true
-            frame = stack.pop_frame(state, expected_frame, first_name, t1, create_metrics, klass_name)
+            frame = stack.pop_frame(state, expected_frame, first_name, t1, create_metrics, klass_name, error)
 
             if create_metrics
               duration = (t1 - t0)*1000
@@ -73,12 +72,15 @@ module TingYun
 
         begin
           yield
+        rescue => e
+          TingYun::Agent.notice_error(e,:type=>:exception)
+          raise e
         ensure
           elapsed_time = (Time.now.to_f - start_time)
           if callback
             callback.call(elapsed_time)
           end
-          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options, Time.now.to_f, klass_name)
+          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options, Time.now.to_f, klass_name,e)
         end
       end
 

data/lib/ting_yun/agent/transaction.rb

@@ -31,7 +31,7 @@ module TingYun
       TASK_PREFIX = 'OtherTransaction/Background/'.freeze
       RACK_PREFIX = 'Rack/'.freeze
       SINATRA_PREFIX = 'WebAction/Sinatra/'.freeze
-      MIDDLEWARE_PREFIX = 'Middleware/Rack/'.freeze
+      MIDDLEWARE_PREFIX = 'Middleware/'.freeze
       GRAPE_PREFIX = 'WebAction/Grape/'.freeze
       RAKE_PREFIX = 'WebAction/Rake'.freeze
       CABLE_PREFIX = 'WebAction/ActionCable'.freeze
@@ -66,7 +66,7 @@ module TingYun
 
 
       def initialize(category, client_transaction_id, options)
-        @start_time = Time.now
+        @start_time = Time.now.to_f
 
         @exceptions = TingYun::Agent::Transaction::Exceptions.new
         @metrics = TingYun::Agent::TransactionMetrics.new
@@ -129,21 +129,21 @@ module TingYun
           trace_options = TRACE_OPTIONS_UNSCOPED
         end
 
-        if name.start_with?(MIDDLEWARE_PREFIX)
-          summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
-        else
-          summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
-        end
-        summary_metrics_with_exclusive_time = summary_metrics unless summary_metrics.empty?
+        # if name.start_with?(MIDDLEWARE_PREFIX)
+        #   summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
+        # else
+        #   summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
+        # end
+        # summary_metrics_with_exclusive_time = summary_metrics unless summary_metrics.empty?
 
         TingYun::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
             state,
-            start_time.to_f,
+            start_time,
             name,
-            summary_metrics_with_exclusive_time,
+            EMPTY_SUMMARY_METRICS,
             outermost_frame,
             trace_options,
-            end_time.to_f)
+            end_time)
 
         commit(state, end_time, name)
       end
@@ -151,20 +151,20 @@ module TingYun
 
       def commit(state, end_time, outermost_node_name)
 
-        assign_agent_attributes
+        assign_agent_attributes(state)
 
 
-        TingYun::Agent.instance.transaction_sampler.on_finishing_transaction(state, self, end_time)
+        TingYun::Agent.instance.transaction_sampler.on_finishing_transaction(state, self, end_time,@exceptions)
 
         TingYun::Agent.instance.sql_sampler.on_finishing_transaction(state, @frozen_name)
 
-        record_summary_metrics(state, outermost_node_name, end_time)
+        record_summary_metrics(state, outermost_node_name, end_time) unless @exceptions.had_error?
         @apdex.record_apdex(@frozen_name, end_time, @exceptions.had_error?)
         @exceptions.record_exceptions(@attributes)
 
 
         TingYun::Agent.instance.stats_engine.merge_transaction_metrics!(@metrics, best_name)
-        TingYun::Agent.instance.stats_engine.record_base_quantile(@base_quantile_hash) if @exceptions.exceptions.empty?
+        TingYun::Agent.instance.stats_engine.record_base_quantile(@base_quantile_hash) unless @exceptions.had_error?
       end
 
     end