tingyun_rpm 1.1.4.2 → 1.2.0

data/lib/ting_yun/frameworks.rb

@@ -15,6 +15,7 @@ module TingYun
       framework.init_plugin(options)
     end
 
+
     class Framework
       include InstanceMethods
       extend ClassMethods

data/lib/ting_yun/frameworks/rails.rb

@@ -46,6 +46,8 @@ module TingYun
           # Might not be running if it does not think mongrel, thin, passenger, etc
           # is running, if it thinks it's a rake task, or if the nbs.agent_enabled is false.
           ::TingYun::Agent.logger.info("TingYun Agent is unable to run.")
+        else
+          install_browser_monitoring(rails_config)
         end
       rescue => e
         ::TingYun::Agent.logger.error("Failure during init_config for Rails. Is Rails required in a non-Rails app? Set TING_YUN_FRAMEWORK=ruby to avoid this message.",
@@ -53,6 +55,19 @@ module TingYun
                                        e)
       end
 
+      def install_browser_monitoring(config)
+        return if @browser_monitoring_installed
+        @browser_monitoring_installed = true
+        return if config.nil? || !config.respond_to?(:middleware)
+        begin
+          require 'ting_yun/middleware/browser_monitoring'
+          config.middleware.use TingYun::BrowserMonitoring
+          ::TingYun::Agent.logger.debug("Installed TingYun Browser Monitoring middleware")
+        rescue => e
+          ::TingYun::Agent.logger.error("Error installing TingYun Browser Monitoring middleware", e)
+        end
+      end
+
       protected
 
       def rails_vendor_root

data/lib/ting_yun/instrumentation/active_record.rb

@@ -1,26 +1,24 @@
 # encoding: utf-8
-
-require 'ting_yun/agent'
 require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/instrumentation/support/active_record_helper'
 require 'ting_yun/support/helper'
 require 'ting_yun/agent/method_tracer'
-
+require 'ting_yun/agent/collector/transaction_sampler'
+require 'ting_yun/agent/collector/sql_sampler'
+require 'ting_yun/agent/database'
 
 module TingYun
   module Instrumentation
     module ActiveRecord
 
-      EXPLAINER = lambda do |config, query|
-        connection = TingYun::Agent::Database.get_connection(config) do
-          ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
-                                    config)
-        end
-        if connection && connection.respond_to?(:execute)
-          return connection.execute("EXPLAIN #{query}")
-        end
+
+
+      def self.explain_plan(statement)
+        TingYun::Agent::Database.explain_plan(statement)
       end
 
+      EXPLAINER = method(:explain_plan)
+
       def self.included(instrumented_class)
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:log_without_tingyun_instrumentation)
@@ -58,18 +56,14 @@ module TingYun
             log_without_tingyun_instrumentation(*args, &block)
           ensure
             elapsed_time = (Time.now - t0).to_f
-            state.sql_duration = elapsed_time * 1000
+            state.timings.sql_duration = state.timings.sql_duration  + elapsed_time * 1000
 
-            TingYun::Agent.instance.transaction_sampler.notice_sql(sql, @config, elapsed_time,
-                                                                   state, EXPLAINER)
-            TingYun::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
-                                                           @config, elapsed_time,
-                                                           state, EXPLAINER)
+            ::TingYun::Agent::Collector::TransactionSampler.notice_sql(sql, @config, elapsed_time, state, EXPLAINER)
+            ::TingYun::Agent::Collector::SqlSampler.notice_sql(sql, scoped_metric, @config, elapsed_time, state, EXPLAINER)
           end
 
         end
       end
-
     end
   end
 end

data/lib/ting_yun/instrumentation/middleware_tracing.rb

@@ -31,7 +31,7 @@ module TingYun
 
       def capture_http_response_code(state, result)
         if result.is_a?(Array) && state.current_transaction
-          state.current_transaction.http_response_code = result[0]
+          state.current_transaction.attributes.add_agent_attribute(:httpStatus, result[0].to_s)
         end
       end
       # the trailing unless is for the benefit for Ruby 1.8.7 and can be removed
@@ -41,33 +41,27 @@ module TingYun
       def capture_response_content_type(state, result)
         if result.is_a?(Array) && state.current_transaction
           _, headers, _ = result
-          state.current_transaction.response_content_type = headers[CONTENT_TYPE]
+          state.current_transaction.attributes.add_agent_attribute(:contentType, headers[CONTENT_TYPE].to_s)
         end
       end
 
-      def capture_request(state, env)
-        if env.is_a? Hash
-
-        end
-      end
 
       def call(env)
         first_middleware = note_transaction_started(env)
-
         state = TingYun::Agent::TransactionState.tl_get
-        if first_middleware
-          capture_request(state, env)
-        end
         begin
+
+          if first_middleware
+            events.notify(:cross_app_before_call, env)
+          end
           TingYun::Agent::Transaction.start(state, category, build_transaction_options(env, first_middleware))
-          events.notify(:before_call, env) if first_middleware
 
-          result = target.call(env)
+          result = (target == self) ? traced_call(env) : target.call(env)
 
           if first_middleware
             capture_http_response_code(state, result)
             capture_response_content_type(state, result)
-            events.notify(:after_call, result)
+            events.notify(:cross_app_after_call, result)
           end
 
           result

data/lib/ting_yun/instrumentation/mongo.rb

@@ -10,8 +10,7 @@ module TingYun
 
       def install_mongo_instrumentation
         hook_instrument_methods
-        instrument_save
-        instrument_ensure_index
+        instrument
       end
 
       def hook_instrument_methods
@@ -28,56 +27,51 @@ module TingYun
 
           def record_mongo_duration(duration)
             state = TingYun::Agent::TransactionState.tl_get
-            unless state.nil?
-              state.mon_duration += duration * 1000
+            if state
+              state.timings.mon_duration = state.timings.mon_duration +  duration * 1000
             end
           end
 
-          def ting_yun_generate_metrics(operation, payload = nil)
+          def tingyun_generate_metrics(operation, payload = nil)
             payload ||= { :collection => self.name, :database => self.db.name }
             TingYun::Instrumentation::Support::MetricTranslator.metrics_for(operation, payload)
           end
 
-          def instrument_with_ting_yun_trace(name, payload = {}, &block)
-            metrics = ting_yun_generate_metrics(name, payload)
+          def instrument_with_tingyun(name, payload = {}, &block)
+            metrics = tingyun_generate_metrics(name, payload)
 
             TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, payload, method(:record_mongo_duration)) do
-              instrument_without_ting_yun_trace(name, payload, &block)
+              instrument_without_tingyun(name, payload, &block)
             end
           end
 
-          alias_method :instrument_without_ting_yun_trace, :instrument
-          alias_method :instrument, :instrument_with_ting_yun_trace
+          alias_method :instrument_without_tingyun, :instrument
+          alias_method :instrument, :instrument_with_tingyun
         end
       end
 
-      def instrument_save
+      def instrument
         ::Mongo::Collection.class_eval do
-          def save_with_ting_yun_trace(doc, opts = {}, &block)
-            metrics = ting_yun_generate_metrics(:save)
-            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, opts, method(:record_mongo_duration)) do
-              save_without_ting_yun_trace(doc, opts, &block)
+          def save_with_tingyun(doc, opts = {}, &block)
+            TingYun::Agent::MethodTracer.trace_execution_scoped(tingyun_generate_metrics(:save), opts, method(:record_mongo_duration)) do
+              save_without_tingyun(doc, opts, &block)
             end
           end
 
-          alias_method :save_without_ting_yun_trace, :save
-          alias_method :save, :save_with_ting_yun_trace
-        end
-      end
+          alias_method :save_without_tingyun, :save
+          alias_method :save, :save_with_tingyun
 
-      def instrument_ensure_index
-        ::Mongo::Collection.class_eval do
-          def ensure_index_with_ting_yun_trace(spec, opts = {}, &block)
-            metrics = ting_yun_generate_metrics(:ensureIndex)
-            TingYun::Agent::MethodTracer.trace_execution_scoped(metrics, opts, method(:record_mongo_duration)) do
-              ensure_index_with_out_ting_yun_trace(spec, opts, &block)
+          def ensure_index_with_tingyun(spec, opts = {}, &block)
+            TingYun::Agent::MethodTracer.trace_execution_scoped(tingyun_generate_metrics(:ensureIndex), opts, method(:record_mongo_duration)) do
+              ensure_index_without_tingyun(spec, opts, &block)
             end
           end
 
-          alias_method :ensure_index_with_out_ting_yun_trace, :ensure_index
-          alias_method :ensure_index, :ensure_index_with_ting_yun_trace
+          alias_method :ensure_index_without_tingyun, :ensure_index
+          alias_method :ensure_index, :ensure_index_with_tingyun
         end
       end
+
     end
   end
 end

data/lib/ting_yun/instrumentation/mongo_command_log_subscriber.rb

@@ -5,7 +5,7 @@ require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/agent/datastore/metric_helper'
 require 'ting_yun/agent/datastore/mongo'
 require 'ting_yun/instrumentation/support/event_formatter'
-
+require 'ting_yun/agent/collector/transaction_sampler'
 
 module TingYun
   module Instrumentation
@@ -27,7 +27,7 @@ module TingYun
       def completed(event)
         begin
           state = TingYun::Agent::TransactionState.tl_get
-          state.mon_duration = event.duration*1000
+          state.timings.mon_duration = state.timings.mon_duration +  event.duration * 1000
           started_event = operations.delete(event.operation_id)
 
           base, *other_metrics = metrics(started_event)
@@ -87,11 +87,15 @@ module TingYun
         # enter transaction trace node
         frame = stack.push_frame(state, :mongo_db, end_time - duration)
 
-        TingYun::Agent.instance.transaction_sampler.notice_nosql_statement(generate_statement(event),duration*1000)
+        transaction_sampler.notice_nosql_statement(generate_statement(event),duration*1000)
 
         # exit transaction trace node
         stack.pop_frame(state, frame, metric, end_time)
       end
+
+      def transaction_sampler
+        ::TingYun::Agent::Collector::TransactionSampler
+      end
     end
   end
 end

data/lib/ting_yun/instrumentation/moped.rb

@@ -63,8 +63,8 @@ module TingYun
 
       def record_mongo_duration(_1, _2, duration)
         state = TingYun::Agent::TransactionState.tl_get
-        unless state.nil?
-          state.mon_duration += duration * 1000
+        if state
+          state.timings.mon_duration = state.timings.mon_duration +  duration * 1000
         end
       end
 

data/lib/ting_yun/instrumentation/net.rb

@@ -34,10 +34,9 @@ TingYun::Support::LibraryDetection.defer do
       class << self
         def get_response_with_tingyun(uri_or_host, path = nil, port = nil, &block)
           begin
-            get_response_without_tingyun(uri_or_host, path = nil, port = nil, &block)
+            get_response_without_tingyun(uri_or_host, path , port , &block)
           rescue => e
-            klass = "External/#{uri_or_host.to_s.gsub('/','%2F')}/net%2Fhttp"
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e,klass)
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{uri_or_host.to_s.gsub('/','%2F')}/net%2Fhttp")
             raise e
           end
         end
@@ -48,13 +47,13 @@ TingYun::Support::LibraryDetection.defer do
           begin
             start_without_tingyun(address, *arg, &block)
           rescue => e
-            klass = "External/#{address.to_s.gsub('/','%2F')}/net%2Fhttp"
-            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e,klass)
+            ::TingYun::Instrumentation::Support::ExternalError.handle_error(e, "External/#{address.to_s.gsub('/','%2F')}/net%2Fhttp")
             raise e
           end
         end
         alias :start_without_tingyun :start
         alias :start :start_with_tingyun
+
       end
     end
   end

data/lib/ting_yun/instrumentation/rack.rb

@@ -60,8 +60,7 @@ module TingYun
           TingYun::Support::LibraryDetection.detect!
           ::Rack::Builder._nr_deferred_detection_ran = true
         end
-
-        result = to_app_without_tingyun
+        to_app_without_tingyun
       end
     end
   end

data/lib/ting_yun/instrumentation/rails4/active_record_subscriber.rb

@@ -3,7 +3,9 @@ require 'ting_yun/instrumentation/support/evented_subscriber'
 require 'ting_yun/agent/transaction/transaction_state'
 require 'ting_yun/instrumentation/support/active_record_helper'
 require 'ting_yun/support/helper'
-
+require 'ting_yun/agent/collector/transaction_sampler'
+require 'ting_yun/agent/collector/sql_sampler'
+require 'ting_yun/agent/database'
 
 module TingYun
   module Instrumentation
@@ -14,10 +16,14 @@ module TingYun
         def initialize
           # We cache this in an instance variable to avoid re-calling method
           # on each query.
-          @explainer = method(:get_explain_plan)
+          @explainer = method(:explain_plan)
           super
         end
 
+        def explain_plan(statement)
+          TingYun::Agent::Database.explain_plan(statement)
+        end
+
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
 
           return if payload[:name] == CACHED_QUERY_NAME
@@ -33,35 +39,23 @@ module TingYun
           config = active_record_config_for_event(event)
           base_metric = record_metrics(event, config)
           notice_sql(state, event, config, base_metric)
-        rescue => e
+        rescue Exception => e
           log_notification_error(e, name, 'finish')
         end
 
-        def get_explain_plan( config, query )
-          connection = TingYun::Agent::Database.get_connection(config) do
-            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
-                                      config)
-          end
-          if connection && connection.respond_to?(:execute)
-            return connection.execute("EXPLAIN #{query}")
-          end
-        end
 
         def notice_sql(state, event, config, metric)
           stack  = state.traced_method_stack
-          state.sql_duration = event.duration
+          state.timings.sql_duration = state.timings.sql_duration + event.duration
           # enter transaction trace node
           frame = stack.push_frame(state, :active_record, event.time)
 
-          TingYun::Agent.instance.sql_sampler \
-            .notice_sql(event.payload[:sql], metric, config,
+          sql_sampler.notice_sql(event.payload[:sql], metric, config,
                         TingYun::Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer)
+                        state, @explainer, event.payload[:binds], event.payload[:name])
 
-          TingYun::Agent.instance.transaction_sampler \
-            .notice_sql(event.payload[:sql], config,
-                        event.duration,
-                        state, @explainer)
+          transaction_sampler.notice_sql(event.payload[:sql], config, event.duration,
+                        state, @explainer, event.payload[:binds], event.payload[:name])
           # exit transaction trace node
           stack.pop_frame(state, frame, metric, event.end)
         end
@@ -93,6 +87,14 @@ module TingYun
 
           connection.instance_variable_get(:@config) if connection
         end
+
+        def transaction_sampler
+          ::TingYun::Agent::Collector::TransactionSampler
+        end
+
+        def sql_sampler
+          ::TingYun::Agent::Collector::SqlSampler
+        end
       end
     end
   end

data/lib/ting_yun/instrumentation/redis.rb

@@ -22,8 +22,8 @@ TingYun::Support::LibraryDetection.defer do
 
       def record_redis_duration(_1, _2, duration)
         state = TingYun::Agent::TransactionState.tl_get
-        unless state.nil?
-          state.rds_duration += duration * 1000
+        if state
+          state.timings.rds_duration = state.timings.rds_duration + duration * 1000
         end
       end
 

data/lib/ting_yun/instrumentation/support/controller_instrumentation.rb

@@ -22,7 +22,7 @@ module TingYun
           txn_options = create_transaction_options(trace_options, category)
 
           begin
-             txn = TingYun::Agent::Transaction.start(state, category, txn_options)
+            TingYun::Agent::Transaction.start(state, category, txn_options)
             begin
               yield
             rescue => e

data/lib/ting_yun/instrumentation/support/external_error.rb

@@ -2,50 +2,53 @@
 require 'ting_yun/agent'
 require 'ting_yun/support/exception'
 
+
 module TingYun
   module Instrumentation
     module Support
+      module Variables
+        attr_accessor :tingyun_code, :tingyun_klass, :tingyun_external, :tingyun_trace
+      end
       module ExternalError
 
-
         module_function
 
         def capture_exception(response,request,type)
-          if !response.nil? && response.code =~ /^[4,5][0-9][0-9]$/ && response.code!='401'
+          if response && response.code =~ /^[4,5][0-9][0-9]$/ && response.code!='401'
             e = TingYun::Support::Exception::InternalServerError.new("#{response.code}: #{response.message}")
             klass = "External/#{request.uri.to_s.gsub('/','%2F')}/#{type}"
-            set_attributes(e, klass)
-            e.instance_variable_set(:@tingyun_code, response.code)
+            set_attributes(e, klass, response.code)
+
             TingYun::Agent.notice_error(e)
           end
         end
 
         def handle_error(e,klass)
-
-          set_attributes(e, klass)
           case e
             when Errno::ECONNREFUSED
-              e.instance_variable_set(:@tingyun_code, 902)
+              set_attributes(e, klass, 902)
             when SocketError
-              e.instance_variable_set(:@tingyun_code, 901)
+              set_attributes(e, klass, 901)
             when OpenSSL::SSL::SSLError
-              e.instance_variable_set(:@tingyun_code, 908)
+              set_attributes(e, klass, 908)
             when Timeout::Error
-              e.instance_variable_set(:@tingyun_code, 903)
+              set_attributes(e, klass, 903)
             else
-              e.instance_variable_set(:@tingyun_code, 1000)
+              set_attributes(e, klass, 1000)
           end
 
           TingYun::Agent.notice_error(e)
         end
 
-        def set_attributes(exception, klass)
+        def set_attributes(exception, klass, code)
+          exception.instance_exec {extend TingYun::Instrumentation::Support::Variables}
           begin
-            exception.instance_variable_set(:@tingyun_klass, klass)
-            exception.instance_variable_set(:@tingyun_external, true)
+            exception.tingyun_code = code
+            exception.tingyun_klass = klass
+            exception.tingyun_external = true
             trace = caller.reject! { |t| t.include?('tingyun_rpm') }
-            trace = trace.first(40) if trace.length > 40
-            exception.instance_variable_set(:@tingyun_trace, trace)
+            trace = trace.first(20)
+            exception.tingyun_trace = trace
           rescue => e
             TingYun::Agent.logger.warn("Failed to set attributes for : #{exception}: ", e)
           end