tingyun_rpm 1.0.6

data/lib/ting_yun/instrumentation/rack.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/middleware_proxy'
+require 'ting_yun/support/version_number'
+
+
+
+module TingYun
+  module Instrumentation
+
+    module RackHelpers
+      extend self
+
+      def middleware_instrumentation_enabled?
+        version_supported? && !::TingYun::Agent.config[:disable_middleware_instrumentation]
+      end
+
+      def version_supported?
+        rack_version_supported?
+      end
+
+      def rack_version_supported?
+        return false unless defined? ::Rack
+
+        version = ::TingYun::Support::VersionNumber.new(::Rack.release)
+        min_version = ::TingYun::Support::VersionNumber.new('1.1.0')
+        version >= min_version
+      end
+    end
+
+    module RackBuilder
+      def run_with_tingyun(app, *args)
+        if ::TingYun::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+          wrapped_app = ::TingYun::Instrumentation::MiddlewareProxy.wrap(app, true)
+          run_without_tingyun(wrapped_app, *args)
+        else
+          run_without_tingyun(app, *args)
+        end
+      end
+
+
+      # def use_with_tingyun(middleware_class, *args, &blk)
+      #   if ::TingYun::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+      #     wrapped_middleware_class = ::TingYun::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+      #     use_without_tingyun(wrapped_middleware_class, *args, &blk)
+      #   else
+      #     use_without_tingyun(middleware_class, *args, &blk)
+      #   end
+      # end
+
+      # We patch this method for a reason that actually has nothing to do with
+      # instrumenting rack itself. It happens to be a convenient and
+      # easy-to-hook point that happens late in the startup sequence of almost
+      # every application, making it a good place to do a final call to
+      # LibraryDetection.detect!, since all libraries are likely loaded at
+      # this point.
+      def to_app_with_tingyun_deferred_dependency_detection
+        unless ::Rack::Builder._nr_deferred_detection_ran
+          TingYun::Agent.logger.info "Doing deferred library-detection before Rack startup"
+          TingYun::Support::LibraryDetection.detect!
+          ::Rack::Builder._nr_deferred_detection_ran = true
+        end
+
+        result = to_app_without_tingyun
+      end
+    end
+  end
+end
+
+
+
+
+
+TingYun::Support::LibraryDetection.defer do
+
+  named :rack
+
+  depends_on do
+    defined?(::Rack) && defined?(::Rack::Builder)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing deferred Rack instrumentation'
+
+    class ::Rack::Builder
+      class << self
+        attr_accessor :_nr_deferred_detection_ran
+      end
+
+      self._nr_deferred_detection_ran = false
+
+      include ::TingYun::Instrumentation::RackBuilder
+
+      alias_method :to_app_without_tingyun, :to_app
+      alias_method :to_app, :to_app_with_tingyun_deferred_dependency_detection
+
+      unless TingYun::Agent.config[:disable_middleware_instrumentation]
+        ::TingYun::Agent.logger.info 'Installing Rack::Builder middleware instrumentation'
+
+        alias_method :run_without_tingyun, :run
+        alias_method :run, :run_with_tingyun
+        #
+        # alias_method :use_without_tingyun, :use
+        # alias_method :use, :use_with_tingyun
+      end
+
+    end
+  end
+end

data/lib/ting_yun/instrumentation/rails3/action_controller.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require 'ting_yun/agent'
+require 'ting_yun/instrumentation/support/controller_instrumentation'
+require 'ting_yun/instrumentation/support/parameter_filtering'
+
+module TingYun
+  module Instrumentation
+    module Rails3
+      module ActionController
+
+        def tingyun_metric_path(action_name_override = nil)
+
+          return  self.env["PATH_INFO"] unless TingYun::Agent.config[:'nbs.auto_action_naming']
+
+          action = action_name_override || action_name
+          if action_name_override || self.class.action_methods.include?(action)
+            "Rails3/#{self.class.controller_path}%2F#{action}"
+          else
+            "Rails3/#{self.class.controller_path}%2F(other)"
+          end
+        end
+
+
+
+        def process_action(*args)
+          params = TingYun::Instrumentation::Support::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
+          perform_action_with_tingyun_trace(:category => :controller,
+                                            :name     => self.action_name,
+                                            :path     => tingyun_metric_path,
+                                            :params   => params,
+                                            :class_name => self.class.name) do
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails3_controller
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 3 Controller instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include TingYun::Instrumentation::Support::ControllerInstrumentation
+      include TingYun::Instrumentation::Rails3::ActionController
+    end
+  end
+end
+

data/lib/ting_yun/instrumentation/rails3/action_view.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'ting_yun/agent'
+require 'ting_yun/agent/method_tracer'
+
+module TingYun
+  module Instrumentation
+    module Rails3
+      module ActionView
+        extend self
+
+        def template_metric(identifier, options = {})
+          if options[:file]
+            "file"
+          elsif identifier.nil?
+            ::TingYun::Agent::UNKNOWN_METRIC
+          elsif identifier.include? '/' # this is a filepath
+            identifier.split('/')[-2..-1].join('/')
+          else
+            identifier
+          end
+        end
+        def render_type(file_path)
+          file = File.basename(file_path)
+          if file.starts_with?('_')
+            return 'Partial'
+          else
+            return 'Rendering'
+          end
+        end
+      end
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails31_view
+
+  # We can't be sure that this will work with future versions of Rails 3.
+  # Currently enabled for Rails 3.1 and 3.2
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+  end
+
+  executes do
+    ActionView::TemplateRenderer.class_eval do
+      # namespaced helper methods
+
+      def render_with_tingyun(context, options)
+        # This is needed for rails 3.2 compatibility
+        @details = extract_details(options) if respond_to? :extract_details, true
+        identifier = determine_template(options) ? determine_template(options).identifier : nil
+        scope_name = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(identifier, options)}/Rendering"
+        TingYun::Agent::MethodTracer.trace_execution_scoped scope_name do
+          render_without_tingyun(context, options)
+        end
+      end
+
+      alias_method :render_without_tingyun, :render
+      alias_method :render, :render_with_tingyun
+    end
+
+    ActionView::PartialRenderer.class_eval do
+
+      def instrument_with_tingyun(name, payload = {}, &block)
+        identifier = payload[:identifier]
+        scope_name = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(identifier)}/Partial"
+        TingYun::Agent::MethodTracer.trace_execution_scoped(scope_name) do
+          instrument_without_tingyun(name, payload, &block)
+        end
+      end
+
+      alias_method :instrument_without_tingyun, :instrument
+      alias_method :instrument, :instrument_with_tingyun
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails30_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 0
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
+  end
+
+  executes do
+    ActionView::Template.class_eval do
+      def render_with_tingyun(*args, &block)
+        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
+                    {:file => true }
+                  else
+                    {}
+                  end
+        str = "View/#{TingYun::Instrumentation::Rails3::ActionView.template_metric(@identifier, options)}/#{TingYun::Agent::Instrumentation::Rails3::ActionView.render_type(@identifier)}"
+        TingYun::Agent::MethodTracer.trace_execution_scoped str do
+          render_without_tingyun(*args, &block)
+        end
+      end
+
+      alias_method :render_without_tingyun, :render
+      alias_method :render, :render_with_tingyun
+
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+require 'ting_yun/instrumentation/support/queue_time'
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/instrumentation/support/evented_subscriber'
+require 'ting_yun/agent/transaction'
+
+module TingYun
+  module Instrumentation
+    module Rails4
+      class ActionControllerSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
+        def start(name, id, payload) #THREAD_LOCAL_ACCES
+          state = TingYun::Agent::TransactionState.tl_get
+          request = state.request
+          event = ControllerEvent.new(name, Time.now, nil, id, payload, request)
+          push_event(event)
+          # if state.execution_traced?
+            start_transaction(state, event)
+          # end
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+
+          event = pop_event(id)
+          event.payload.merge!(payload)
+
+          state = TingYun::Agent::TransactionState.tl_get
+
+
+          stop_transaction(state)
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def start_transaction(state, event)
+          TingYun::Agent::Transaction.start(state, :controller,
+                                            :request => event.request,
+                                            :filtered_params => event.payload[:params],
+                                            :apdex_start_time => event.queue_start,
+                                            :transaction_name => event.metric_name)
+        end
+
+        def stop_transaction(state)
+          # txn = state.current_transaction
+          TingYun::Agent::Transaction.stop(state)
+        end
+
+
+      end
+
+      class ControllerEvent < TingYun::Instrumentation::Support::Event
+        attr_accessor :parent
+        attr_reader :queue_start, :request
+
+        def initialize(name, start, ending, transaction_id, payload, request)
+          # We have a different initialize parameter list, so be explicit
+          super(name, start, ending, transaction_id, payload, nil)
+
+          @request = request
+          @controller_class = payload[:controller].split('::') \
+            .inject(Object) { |m, o| m.const_get(o) }
+
+          if request && request.respond_to?(:env)
+            @queue_start = TingYun::Instrumentation::Support::QueueTime.parse_frontend_timestamp(request.env, self.time)
+          end
+        end
+
+        def metric_name
+          if TingYun::Agent.config[:'nbs.auto_action_naming']
+            @metric_name ||= "WebAction/Rails/#{metric_path}%2F#{metric_action}"
+          else
+            path
+          end
+        end
+
+        def metric_path
+          @controller_class.controller_path
+        end
+
+        def metric_class
+          payload[:controller]
+        end
+
+        def metric_action
+          payload[:action]
+        end
+
+        def path
+          payload[:path]
+        end
+
+        def to_s
+          "#<TingYun::Instrumentation::ControllerEvent:#{object_id} name: \"#{name}\" id: #{transaction_id} payload: #{payload}}>"
+        end
+      end
+    end
+  end
+end
+
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails4_controller
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
+  end
+
+  executes do
+    ::TingYun::Instrumentation::Rails4::ActionControllerSubscriber \
+      .subscribe(/^process_action.action_controller$/)
+  end
+end
+
+

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

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+
+require 'ting_yun/instrumentation/support/evented_subscriber'
+require 'ting_yun/agent/transaction/transaction_state'
+require 'ting_yun/agent'
+
+module TingYun
+  module Instrumentation
+    module Rails4
+      class ActionViewSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
+
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+          event = RenderEvent.new(name, Time.now, nil, id, payload)
+          push_event(event)
+
+          state = TingYun::Agent::TransactionState.tl_get
+
+          if event.recordable?
+            stack = state.traced_method_stack
+            event.frame = stack.push_frame(state, :action_view, event.time)
+          end
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          event = pop_event(id)
+
+          state = TingYun::Agent::TransactionState.tl_get
+
+          if event.recordable?
+            stack = state.traced_method_stack
+            frame = stack.pop_frame(state, event.frame, event.metric_name, event.end)
+            record_metrics(event, frame)
+          end
+        rescue => e
+          log_notification_error(e, name, 'finish')
+        end
+
+        def record_metrics(event, frame)
+          exclusive = event.duration - frame.children_time
+          TingYun::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+              event.metric_name, nil, event.duration, exclusive)
+        end
+      end
+
+      class RenderEvent < TingYun::Instrumentation::Support::Event
+
+        def recordable?
+          name[0] == '!' ||
+              metric_name == 'View/text template/Rendering' ||
+              metric_name == "View/#{::TingYun::Agent::UNKNOWN_METRIC}/Partial"
+        end
+
+        def metric_name
+          if parent && (payload[:virtual_path] ||
+              (parent.payload[:identifier] =~ /template$/))
+            return parent.metric_name
+          elsif payload.key?(:virtual_path)
+            identifier = payload[:virtual_path]
+          else
+            identifier = payload[:identifier]
+          end
+
+          # memoize
+          @metric_name ||= "View/#{metric_path(identifier)}/#{metric_action(name)}"
+          @metric_name
+        end
+
+        def metric_path(identifier)
+          if identifier == nil
+            'file'
+          elsif identifier =~ /template$/
+            identifier
+          elsif (parts = identifier.split('/')).size > 1
+            parts[-2..-1].join('/')
+          else
+            ::TingYun::Agent::UNKNOWN_METRIC
+          end
+        end
+
+        def metric_action(name)
+          case name
+            when /render_template.action_view$/ then
+              'Rendering'
+            when 'render_partial.action_view' then
+              'Partial'
+            when 'render_collection.action_view' then
+              'Partial'
+          end
+        end
+      end
+    end
+  end
+end
+
+TingYun::Support::LibraryDetection.defer do
+  @name = :rails4_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    !TingYun::Agent.config[:disable_view_instrumentation] &&
+        !TingYun::Instrumentation::Rails4::ActionViewSubscriber.subscribed?
+  end
+
+  executes do
+    TingYun::Agent.logger.info 'Installing Rails 4 view instrumentation'
+  end
+
+  executes do
+    TingYun::Instrumentation::Rails4::ActionViewSubscriber.subscribe(/render_.+\.action_view$/)
+  end
+end
+#

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

@@ -0,0 +1,124 @@
+# encoding: utf-8
+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'
+
+
+module TingYun
+  module Instrumentation
+    module Rails4
+      class ActiveRecordSubscriber < TingYun::Instrumentation::Support::EventedSubscriber
+        CACHED_QUERY_NAME = 'CACHE'.freeze unless defined? CACHED_QUERY_NAME
+
+        def initialize
+          # We cache this in an instance variable to avoid re-calling method
+          # on each query.
+          @explainer = method(:get_explain_plan)
+          super
+        end
+
+        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+
+          return if payload[:name] == CACHED_QUERY_NAME
+          super
+        rescue => e
+          log_notification_error(e, name, 'start')
+        end
+
+        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+          return if payload[:name] == CACHED_QUERY_NAME
+          state = TingYun::Agent::TransactionState.tl_get
+          event = pop_event(id)
+          config = active_record_config_for_event(event)
+          base_metric = record_metrics(event, config)
+          notice_sql(state, event, config, base_metric)
+        rescue => 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
+          # 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,
+                        TingYun::Helper.milliseconds_to_seconds(event.duration),
+                        state, @explainer)
+
+          TingYun::Agent.instance.transaction_sampler \
+            .notice_sql(event.payload[:sql], config,
+                        event.duration,
+                        state, @explainer)
+          # exit transaction trace node
+          stack.pop_frame(state, frame, metric, event.end)
+        end
+
+        def record_metrics(event, config)
+          base, *other_metrics = TingYun::Instrumentation::Support::ActiveRecordHelper.metrics_for(event.payload[:name],
+                                                                                                   TingYun::Helper.correctly_encoded(event.payload[:sql]),
+                                                                                                   config && config[:adapter])
+
+          TingYun::Agent.agent.stats_engine.tl_record_scoped_and_unscoped_metrics(base, other_metrics, event.duration)
+
+          base
+        end
+
+
+        def active_record_config_for_event(event)
+          return unless event.payload[:connection_id]
+
+          connection = nil
+          connection_id = event.payload[:connection_id]
+
+          ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
+            connection = handler.connections.detect do |conn|
+              conn.object_id == connection_id
+            end
+
+            break if connection
+          end
+
+          connection.instance_variable_get(:@config) if connection
+        end
+      end
+    end
+  end
+end
+
+TingYun::Support::LibraryDetection.defer do
+  named :active_record_4
+
+
+  depends_on do
+    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+        defined?(::ActiveRecord::VERSION) &&
+        ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !TingYun::Instrumentation::Rails4::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info 'Installing ActiveRecord 4 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+                                           TingYun::Instrumentation::Rails4::ActiveRecordSubscriber.new)
+    ::TingYun::Instrumentation::Support::ActiveRecordHelper.instrument_additional_methods
+  end
+end

data/lib/ting_yun/instrumentation/rails_middleware.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+
+require 'ting_yun/instrumentation/middleware_proxy'
+
+TingYun::Support::LibraryDetection.defer do
+  named :rails_middleware
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i >= 3
+  end
+
+  depends_on do
+    !::TingYun::Agent.config[:disable_middleware_instrumentation]
+  end
+
+  executes do
+    ::TingYun::Agent.logger.info("Installing Rails 3+ middleware instrumentation")
+    module ActionDispatch
+      class MiddlewareStack
+        class Middleware
+          def build_with_ting_yun(app)
+            # MiddlewareProxy.wrap guards against double-wrapping here.
+            # We need to instrument the innermost app (usually a RouteSet),
+            # which will never itself be the return value from #build, but will
+            # instead be the initial value of the app argument.
+            wrapped_app = ::TingYun::Instrumentation::MiddlewareProxy.wrap(app)
+            result = build_without_ting_yun(wrapped_app)
+            ::TingYun::Instrumentation::MiddlewareProxy.wrap(result)
+          end
+
+          alias_method :build_without_ting_yun, :build
+          alias_method :build, :build_with_ting_yun
+        end
+      end
+    end
+  end
+end