tingyun_rpm 1.6.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 125910726e0cd29ecbd1f8ef11554ef3b12ce308
-  data.tar.gz: 0640b5631a7cf7789b3d0a8cd4d6beeb755616a9
+  metadata.gz: abc0dca8754928314bff5a8b5d2fc180b6b53390
+  data.tar.gz: 53015247182d5fada5c509200b25c2d773a80057
 SHA512:
-  metadata.gz: 1f649dac233f8bc87b8f37551e171c922299655d817b2052b06380bbccdd1486f2b171709bedd2f5c3ba962073603d5030b53c6cf06d25a4f8a3e4a711e56a0a
-  data.tar.gz: ecc612b7b540842486799eac571faa5f6d3e7ec96fb202fc9c650f8a42f8427fa0df5ddd3bae560ca20d8c23a282570664d1fae53b43a7b241142573e98058b5
+  metadata.gz: ae165e0439b4709fdb24783966d24ca6c932af82fc1d3cd240ae4c3725b243771f5ab4fff9fb35e80c82b305424deec6288d2cef21eafdef3b3a8350a70fa66a
+  data.tar.gz: 49c9a80f11cc20db3541750b89916ad5b0596f4ab74816513eec3aadf90ffb3bf0834ebb5e1d1e3e67a0164997465fe5084f34b77001e4322a1c685093b9bc3c

data/lib/ting_yun/agent.rb

@@ -63,7 +63,7 @@ module TingYun
     # This method is safe to use from any thread.
     #
     # @api public
-    def record_metric(metric_name, value, is_scoped=false ) #THREAD_LOCAL_ACCESS
+    def record_metricV2(metric_name, value, is_scoped=false ) #THREAD_LOCAL_ACCESS
       return unless agent
       stats = TingYun::Metrics::Stats.create_from_hash(value) if value.is_a?(Hash)
       if is_scoped
@@ -73,6 +73,9 @@ module TingYun
       end
     end
 
+    def record_metric(metric_name, value, is_scoped=false ) #THREAD_LOCAL_ACCESS
+    end
+
     # Manual agent configuration and startup/shutdown
 
     # Call this to manually start the Agent in situations where the Agent does
@@ -94,7 +97,7 @@ module TingYun
     #
     def manual_start(options={})
       raise "Options must be a hash" unless Hash === options
-      TingYun::Frameworks.init_start({ :'nbs.agent_enabled' => true, :sync_startup => true }.merge(options))
+      TingYun::Frameworks.init_start({ :'agent_enabled' => true, :sync_startup => true }.merge(options))
     end
 
     # Yield to a block that is run with a database metric name context.  This means
@@ -206,5 +209,9 @@ module TingYun
       TingYun::Agent::TransactionState.tl_get.execution_traced?
     end
 
+    def upload
+      agent.transmit_data
+    end
+
   end
 end

data/lib/ting_yun/agent/agent.rb

@@ -37,7 +37,7 @@ module TingYun
         @started = false
         @environment_report = nil
         @service = TingYunService.new
-        @connect_state = :pending #[:pending, :connected, :disconnected]
+        @connect_state = :first #[:first, :pending, :connected, :disconnected]
         @events  = TingYun::Agent::Event::EventListener.new
         @after_fork_lock = Mutex.new
         @dispatcher = TingYun::Agent::Dispatcher.new(@events)
@@ -89,8 +89,9 @@ module TingYun
       rescue Exception => error
         ::TingYun::Agent.logger.error "Exception of unexpected type during Agent#connect! :", error
         log_error(error)
+        raise
         if opts[:keep_retrying]
-          ::TingYun::Agent.logger.info "Will re-attempt in 60 seconds"
+          ::TingYun::Agent.logger.info "Will re-attempt in 30 seconds"
           raise
         end
       end

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

@@ -123,7 +123,7 @@ module TingYun
         end
 
         def request_params
-          return {}  unless TingYun::Agent.config['nbs.capture_params']
+          return {}  unless TingYun::Agent.config['action_tracer.capture_params']
           attributes.request_params
         end
 

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

@@ -48,9 +48,9 @@ module TingYun
           data = state.sql_sampler_transaction_data
           return unless data
           threshold = duration*1000
-          if threshold > TingYun::Agent.config[:'nbs.action_tracer.slow_sql_threshold'] && state.sql_recorded?
+          if threshold > TingYun::Agent.config[:'action_tracer.slow_sql_threshold'] && state.sql_recorded?
             backtrace = ''
-            if threshold > TingYun::Agent.config[:'nbs.action_tracer.stack_trace_threshold']
+            if threshold > TingYun::Agent.config[:'action_tracer.stack_trace_threshold']
               backtrace = caller.reject! { |t| t.include?('tingyun_rpm') }
               backtrace = backtrace.first(20).join("\n")
             end

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

@@ -23,7 +23,7 @@ module TingYun
         end
 
         def harvest!
-          return [] unless TingYun::Agent.config[:'nbs.action_tracer.enabled']
+          return [] unless TingYun::Agent.config[:'action_tracer.enabled']
 
           samples = @lock.synchronize do
             @last_sample = nil
@@ -65,7 +65,7 @@ module TingYun
         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']
+          return unless last_builder && TingYun::Agent.config[:'action_tracer.enabled']
 
           last_builder.finish_trace(time)
 

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

@@ -22,7 +22,7 @@ module TingYun
 
 
           def on_start_transaction(state, time)
-            if TingYun::Agent.config[:'nbs.action_tracer.enabled']
+            if TingYun::Agent.config[:'action_tracer.enabled']
               state.transaction_sample_builder ||= TingYun::Agent::TransactionSampleBuilder.new(time)
             else
               state.transaction_sample_builder = nil
@@ -48,15 +48,15 @@ module TingYun
           end
 
           # duration{:type => sec}
-          def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
+          def notice_nosql(config, duration,key) #THREAD_LOCAL_ACCESS
             builder = tl_builder
-            action_tracer_segment(builder, key, duration, :key)
+            action_tracer_segment(builder, config, duration, key)
           end
 
           # duration{:type => sec}
-          def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
+          def notice_nosql_statement(statement, duration,key =:statement) #THREAD_LOCAL_ACCESS
             builder = tl_builder
-            action_tracer_segment(builder, statement, duration, :statement)
+            action_tracer_segment(builder, statement, duration,key )
           end
 
 
@@ -79,9 +79,24 @@ module TingYun
                   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.klass = message.config[:product]
+                  node.method = message.config[:operation]
+                  node.type = message.config[:type]
+                  node.params_data.merge!(:vendor => message.config[:product],
+                                                  :instance=>"#{message.config[:host]}:#{message.config[:port]}/#{message.config[:database]}",
+                                                  :operation => message.sql)
                   node[:sql] =  message
                 end
+              elsif key == :nosql
+                # message is expected to have been pre-truncated by notice_sql
+                node.klass = message[:product]
+                node[:method] = message[:operation]
+                node.type = message[:type]
+                node.params_data.merge!(:vendor => message[:product],
+                                        :instance=>"#{message[:host]}:#{message[:port]}/#{message[:database]}",
+                                        :operation => message[:nosql])
               else
+
                 node[key] = truncate_message(message)
               end
               append_backtrace(node, duration)
@@ -105,10 +120,10 @@ module TingYun
           # 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']
+            if duration*1000 >= Agent.config[:'action_tracer.stack_trace_threshold']
               trace = caller.reject! { |t| t.include?('tingyun_rpm') }
               trace = trace.first(20)
-              node[:stacktrace] = trace
+              node.backtrace = trace
             end
           end
 

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

@@ -14,9 +14,9 @@ module TingYun
             CAPACITY
           end
 
-          def allow_sample?(sample)
-            sample.threshold && sample.duration >= sample.threshold
-          end
+          # def allow_sample?(sample)
+          #   sample.threshold && sample.duration >= sample.threshold
+          # end
 
         end
       end

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

@@ -34,7 +34,7 @@ module TingYun
             reset!
           end
 
-          def store(sample)
+          def storeV2(sample)
             return unless enabled?
             if allow_sample?(sample)
               add_sample(sample)
@@ -42,7 +42,12 @@ module TingYun
             end
           end
 
-          def store_previous(previous_samples)
+          def store(sample)
+            return unless enabled?
+            add_sample(sample)
+          end
+
+          def store_previousV2(previous_samples)
             return unless enabled?
             previous_samples.each do |sample|
               add_sample(sample) if allow_sample?(sample)
@@ -50,6 +55,14 @@ module TingYun
             truncate_samples_if_needed
           end
 
+          def store_previous(previous_samples)
+            return unless enabled?
+            previous_samples.each do |sample|
+              add_sample(sample)
+            end
+          end
+
+
           def truncate_samples_if_needed
             truncate_samples if full?
           end

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

@@ -11,8 +11,8 @@ module TingYun
     class CrossAppMonitor < TingYun::Agent::InboundRequestMonitor
 
 
-      TY_ID_HEADER = 'HTTP_X_TINGYUN_ID'.freeze
-      TY_DATA_HEADER = 'X-Tingyun-Tx-Data'.freeze
+      TY_ID_HEADER = 'HTTP_X_TINGYUN'.freeze
+      TY_DATA_HEADER = 'X-Tingyun-Data'.freeze
 
 
       def on_finished_configuring(events)
@@ -29,7 +29,9 @@ module TingYun
         events.subscribe(:cross_app_before_call) do |env| #THREAD_LOCAL_ACCESS
           if TingYun::Agent::CrossAppTracing.cross_app_enabled?
             state = TingYun::Agent::TransactionState.tl_get
-            state.save_referring_transaction_info(env[TY_ID_HEADER].split(';')) if env[TY_ID_HEADER]
+            if env[TY_ID_HEADER]
+              state.save_referring_transaction_info(env[TY_ID_HEADER].split(';'))
+            end
           end
         end
 
@@ -40,7 +42,7 @@ module TingYun
       end
 
 
-      def insert_response_header(response_headers)
+      def insert_response_headerV2(response_headers)
         state = TingYun::Agent::TransactionState.tl_get
         if state.same_account?
           txn = state.current_transaction
@@ -52,27 +54,28 @@ module TingYun
         end
       end
 
+      def insert_response_header(response_headers)
+        state = TingYun::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        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
+      end
+
 
       def build_payload(state)
         timings = state.timings
 
         payload = {
-          :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
-          }
+          :id => TingYun::Agent.config[:idSecret],
+          :tname => state.transaction_name,
+          :tid => state.current_transaction.guid,
+          :rid => state.trace_id,
+          :duration => timings.app_time_in_millis
         }
-        payload[:tr] = 1 if timings.slow_action_tracer?
-        payload[:r] = state.client_req_id unless state.client_req_id.nil?
+
         payload
       end
 

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

@@ -6,6 +6,7 @@ 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'
+require 'ting_yun/instrumentation/support/external_helper'
 
 
 module TingYun
@@ -13,14 +14,15 @@ module TingYun
     module CrossAppTracing
 
       extend ::TingYun::Instrumentation::Support::ExternalError
+      extend ::TingYun::Instrumentation::Support::ExternalHelper
 
       # Exception raised if there is a problem with cross app transactions.
       class Error < RuntimeError; end
 
       # The cross app id header for "outgoing" calls
 
-      TY_ID_HEADER = 'X-Tingyun-Id'.freeze
-      TY_DATA_HEADER = 'X-Tingyun-Tx-Data'.freeze
+      TY_ID_HEADER = 'X-Tingyun'.freeze
+      TY_DATA_HEADER = 'X-Tingyun-Data'.freeze
 
 
       module_function
@@ -30,7 +32,6 @@ module TingYun
         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)
@@ -43,14 +44,13 @@ module TingYun
       end
 
       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)
-
+        inject_request_headers(state, request) if cross_app_enabled?
         return node
       end
 
-      def finish_trace(state, t0, node, request, response)
+      def finish_traceV2(state, t0, node, request, response)
 
         t1 = Time.now.to_f
         duration = (t1- t0) * 1000
@@ -65,7 +65,7 @@ module TingYun
             tx_data = TingYun::Support::Serialize::JSONWrapper.load(get_ty_data_header(response).gsub("'",'"')) || {}
             # net_block_duration = tx_data["time"]? duration - tx_data["time"]["duration"]- tx_data["time"]["qu"] : duration
             # net_block_duration = duration if net_block_duration < 0
-            ::TingYun::Agent.instance.stats_engine.record_scoped_and_unscoped_metrics(state, node_name, metrics, duration)
+            # ::TingYun::Agent.instance.stats_engine.record_scoped_and_unscoped_metrics(state, node_name, metrics, duration)
             if cross_app
               _duration =  tx_data["time"]["duration"] + tx_data["time"]["qu"] + 0.1
               metrics_cross_app = metrics_for_cross_app(request, response)
@@ -89,11 +89,46 @@ module TingYun
         end
       end
 
+      def finish_trace(state, t0, node, request, response)
+
+        t1 = Time.now.to_f
+        duration = (t1- t0) * 1000
+        state.timings.external_duration = duration
+
+        begin
+          if request
+            cross_app = response_is_cross_app?(response)
+            tx_data = TingYun::Support::Serialize::JSONWrapper.load(get_ty_data_header(response).gsub("'",'"')) || {}
+            # net_block_duration = tx_data["time"]? duration - tx_data["time"]["duration"]- tx_data["time"]["qu"] : duration
+            # net_block_duration = duration if net_block_duration < 0
+            # ::TingYun::Agent.instance.stats_engine.record_scoped_and_unscoped_metrics(state, node_name, metrics, duration)
+            # if cross_app
+            #   _duration =  tx_data["time"]["duration"] + tx_data["time"]["qu"] + 0.1
+            #   metrics_for_cross_app(request, response)
+            #   # txn = state.current_transaction
+            #   # txn.metrics.record_scoped(metrics_cross_app.pop, duration, _duration)
+            #   # txn.metrics.record_unscoped(metrics_cross_app, _duration)
+            # end
+            if node
+              node.name ="#{request.from}/#{request.uri.to_s}"
+              add_transaction_trace_info(request, response, cross_app, tx_data)
+            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
+      end
 
       def add_transaction_trace_info(request, response, cross_app, tx_data)
         state = TingYun::Agent::TransactionState.tl_get
         ::TingYun::Agent::Collector::TransactionSampler.add_node_info(:uri => TingYun::Agent::HTTPClients::URIUtil.filter_uri(request.uri))
         if cross_app
+          state.add_current_node_paramsV3(:txData=> TingYun::Support::Serialize::JSONWrapper.dump(tx_data))
           ::TingYun::Agent::Collector::TransactionSampler.tl_builder.set_txId_and_txData(state.client_transaction_id || state.request_guid, tx_data)
         end
       end
@@ -103,7 +138,8 @@ module TingYun
         my_data =  TingYun::Support::Serialize::JSONWrapper.load get_ty_data_header(response).gsub("'",'"')
         metrics = ["ExternalTransaction/NULL/#{my_data["id"]}",
                    "ExternalTransaction/http/#{my_data["id"]}"]
-        metrics << "ExternalTransaction/#{request.uri.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/#{my_data["id"]}%2F#{my_data["action"].to_s.gsub(/\/\z/,'')}"
+        metrics << "ExternalTransaction/#{request.uri.to_s.gsub(/\/\z/,'')}/#{my_data["id"]}/#{my_data["action"].to_s
+                                                                                                   .gsub(/\/\z/,'')}"
       end
 
       def metrics_for(request)
@@ -113,23 +149,21 @@ module TingYun
         else
           metrics << "External/NULL/AllBackground"
         end
-        metrics << "External/#{request.uri.to_s.gsub(/\/\z/,'').gsub('/','%2F')}/#{request.from}"
+        metrics << "External/#{request.uri.to_s.gsub(/\/\z/,'')}/#{request.from}"
         return metrics
       end
 
 
 
       def cross_app_enabled?
-        TingYun::Agent.config[:tingyunIdSecret] && TingYun::Agent.config[:tingyunIdSecret].size > 0 &&
-            TingYun::Agent.config[:'nbs.action_tracer.enabled'] &&
+        TingYun::Agent.config[:idSecret] && TingYun::Agent.config[:idSecret].size > 0 &&
+            TingYun::Agent.config[:'action_tracer.enabled'] &&
             TingYun::Agent.config[:'nbs.transaction_tracer.enabled']
       end
 
       # Inject the X-Process header into the outgoing +request+.
       def inject_request_headers(state, request)
-        cross_app_id  = TingYun::Agent.config[:tingyunIdSecret]
-
-        request[TY_ID_HEADER] = "#{cross_app_id};c=1;x=#{state.request_guid}"
+        request[TY_ID_HEADER] = create_tingyun_id(nil,nil,request)
       end
 
       # Returns +true+ if Cross Application Tracing is enabled, and the given +response+

data/lib/ting_yun/agent/database.rb

@@ -87,7 +87,7 @@ module TingYun
       end
 
       def sql_sampler_enabled?
-        Agent.config[:'nbs.action_tracer.enabled'] &&
+        Agent.config[:'action_tracer.enabled'] &&
             Agent.config[:'nbs.action_tracer.slow_sql'] &&
             should_record_sql?('nbs.action_tracer.record_sql')
       end