dolores_rpm 3.2.0.2

data/lib/new_relic/agent/instrumentation/rack.rb

@@ -0,0 +1,98 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # == Instrumentation for Rack
+      #
+      # New Relic will instrument a #call method as if it were a controller
+      # action, collecting transaction traces and errors.  The middleware will
+      # be identified only by it's class, so if you want to instrument multiple
+      # actions in a middleware, you need to use
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
+      #
+      # Example:
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/rack'
+      #   class Middleware
+      #     def call(env)
+      #       ...
+      #     end
+      #     # Do the include after the call method is defined:
+      #     include NewRelic::Agent::Instrumentation::Rack
+      #   end
+      #
+      # == Instrumenting Metal and Cascading Middlewares
+      #
+      # Metal apps and apps belonging to Rack::Cascade middleware
+      # follow a convention of returning a 404 for all requests except
+      # the ones they are set up to handle.  This means that New Relic
+      # needs to ignore these calls when they return a 404.
+      #
+      # In these cases, you should not include or extend the Rack
+      # module but instead include
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation.
+      # Here's how that might look for a Metal app:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class MetalApp
+      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def self.call(env)
+      #       if should_do_my_thing?
+      #         perform_action_with_newrelic_trace(:category => :rack) do
+      #           return my_response(env)
+      #         end
+      #       else
+      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+      #       end
+      #     end
+      #   end
+      #
+      # == Overriding the metric name
+      #
+      # By default the middleware is identified only by its class, but if you want to
+      # be more specific and pass in name, then omit including the Rack instrumentation
+      # and instead follow this example:
+      #
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class Middleware
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def call(env)
+      #       ...
+      #     end
+      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
+      #   end
+      #
+      module Rack
+        def newrelic_request_headers
+          @newrelic_request.env
+        end
+        def call_with_newrelic(*args)
+          @newrelic_request = ::Rack::Request.new(args.first)
+          perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
+            result = call_without_newrelic(*args)
+            # Ignore cascaded calls
+            MetricFrame.abort_transaction! if result.first == 404
+            result
+          end
+        end
+        def self.included middleware #:nodoc:
+          middleware.class_eval do
+            alias call_without_newrelic call
+            alias call call_with_newrelic
+          end
+        end
+        include ControllerInstrumentation
+        def self.extended middleware #:nodoc:
+          middleware.class_eval do
+            class << self
+              alias call_without_newrelic call
+              alias call call_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -0,0 +1,114 @@
+DependencyDetection.defer do
+  @name = :rails21_view
+  
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    defined?(ActionController) && defined?(ActionController::Base) && defined?(ActionView::PartialTemplate) && defined?(ActionView::Template) &&
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.1\./   # Rails 2.1 &&
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 2.1 View instrumentation'
+  end
+
+  executes do
+    ActionView::PartialTemplate.class_eval do
+      add_method_tracer :render, 'View/#{path_without_extension[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Partial'
+    end
+    # this is for template rendering, as opposed to partial rendering.
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :old_rails_view
+  
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    defined?(ActionController) && defined?(ActionController::Base) &&
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0 
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 1.* - 2.0 View instrumentation'
+  end
+  
+  executes do
+    ActionController::Base.class_eval do
+      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    end
+    
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails23_view
+  
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/ 
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 2.2 - 2.3 View instrumentation'
+  end
+  
+  executes do    
+    ActionView::RenderablePartial.module_eval do
+      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+    end
+    ActionView::Template.class_eval do
+      add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
+    end
+  end  
+end
+
+DependencyDetection.defer do
+  @name = :rails2_controller
+  
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+  
+  depends_on do
+    defined?(Rails) && Rails::VERSION::MAJOR.to_i == 2
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 2 Controller instrumentation'
+  end
+  
+  executes do
+    ActionController::Base.class_eval do
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      
+      # Compare with #alias_method_chain, which is not available in
+      # Rails 1.1:
+      alias_method :perform_action_without_newrelic_trace, :perform_action
+      alias_method :perform_action, :perform_action_with_newrelic_trace
+      private :perform_action
+      
+      def self.newrelic_write_attr(attr_name, value) # :nodoc:
+        write_inheritable_attribute(attr_name, value)
+      end
+      
+      def self.newrelic_read_attr(attr_name) # :nodoc:
+        read_inheritable_attribute(attr_name)
+      end
+      
+      # determine the path that is used in the metric name for
+      # the called controller action
+      def newrelic_metric_path(action_name_override = nil)
+        action_part = action_name_override || action_name
+        if action_name_override || self.class.action_methods.include?(action_part)
+          "#{self.class.controller_path}/#{action_part}"
+        else
+          "#{self.class.controller_path}/(other)"
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails/action_web_service.rb

@@ -0,0 +1,42 @@
+DependencyDetection.defer do
+  @name = :rails_action_web_service
+  
+  depends_on do
+    defined?(ActionWebService)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails ActionWebService instrumentation'
+  end  
+  
+  executes do
+    # NewRelic Agent instrumentation for WebServices
+
+    # Note Action Web Service is removed from default package in rails
+    # 2.0, this is purely here as a service to our legacy customers.
+
+    # instrumentation for Web Service martialing - XML RPC
+    ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.class_eval do
+      add_method_tracer :decode_request, "WebService/Xml Rpc/XML Decode"
+      add_method_tracer :encode_request, "WebService/Xml Rpc/XML Encode"
+      add_method_tracer :decode_response, "WebService/Xml Rpc/XML Decode"
+      add_method_tracer :encode_response, "WebService/Xml Rpc/XML Encode"
+    end
+
+    # instrumentation for Web Service martialing - Soap
+    ActionWebService::Protocol::Soap::SoapProtocol.class_eval do
+      add_method_tracer :decode_request, "WebService/Soap/XML Decode"
+      add_method_tracer :encode_request, "WebService/Soap/XML Encode"
+      add_method_tracer :decode_response, "WebService/Soap/XML Decode"
+      add_method_tracer :encode_response, "WebService/Soap/XML Encode"
+    end
+
+    if defined?(ActionController) && defined?(ActionController::Base)
+      ActionController::Base.class_eval do
+        if method_defined? :perform_invocation
+          add_method_tracer :perform_invocation, 'WebService/#{controller_name}/#{args.first}'
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails/active_record_instrumentation.rb

@@ -0,0 +1,115 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordInstrumentation
+
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            alias_method :log_without_newrelic_instrumentation, :log
+            alias_method :log, :log_with_newrelic_instrumentation
+            protected :log
+          end
+        end
+
+        def log_with_newrelic_instrumentation(sql, name, &block)
+
+          return log_without_newrelic_instrumentation(sql, name, &block) unless NewRelic::Agent.is_execution_traced?
+
+          # Capture db config if we are going to try to get the explain plans
+          if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && self.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
+            supported_config = @config
+          end
+          if name && (parts = name.split " ") && parts.size == 2
+            model = parts.first
+            operation = parts.last.downcase
+            metric_name = case operation
+                          when 'load' then 'find'
+                          when 'indexes', 'columns' then nil # fall back to DirectSQL
+                          when 'destroy', 'find', 'save', 'create' then operation
+                          when 'update' then 'save'
+                          else
+                            if model == 'Join'
+                              operation
+                            end
+                          end
+            metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+          end
+
+          if metric.nil?
+            metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+            if metric.nil?
+              if sql =~ /^(select|update|insert|delete|show)/i
+                # Could not determine the model/operation so let's find a better
+                # metric.  If it doesn't match the regex, it's probably a show
+                # command or some DDL which we'll ignore.
+                metric = "Database/SQL/#{$1.downcase}"
+              else
+                metric = "Database/SQL/other"
+              end
+            end
+          end
+
+          if !metric
+            log_without_newrelic_instrumentation(sql, name, &block)
+          else
+            metrics = [metric, "ActiveRecord/all"]
+            metrics << "ActiveRecord/#{metric_name}" if metric_name
+            self.class.trace_execution_scoped(metrics) do
+              t0 = Time.now
+              begin
+                log_without_newrelic_instrumentation(sql, name, &block)
+              ensure
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, supported_config, (Time.now - t0).to_f)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails2_active_record
+  
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 2
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['skip_ar_instrumentation']
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 2 ActiveRecord instrumentation'
+  end
+  
+  executes do
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
+    end
+  end
+
+  executes do
+    ActiveRecord::Base.class_eval do
+      class << self
+        add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
+        add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false
+      end
+    end
+  end
+end
+
+DependencyDetection.detect!

data/lib/new_relic/agent/instrumentation/rails/errors.rb

@@ -0,0 +1,42 @@
+DependencyDetection.defer do
+  @name = :rails2_error
+  
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 2
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 2 Error instrumentation'
+  end  
+  
+  executes do
+
+    ActionController::Base.class_eval do
+
+      # Make a note of an exception associated with the currently executing
+      # controller action.  Note that this used to be available on Object
+      # but we replaced that global method with NewRelic::Agent#notice_error.
+      # Use that one outside of controller actions.
+      def newrelic_notice_error(exception, custom_params = {})
+        NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :custom_params => custom_params, :request => request
+      end
+
+      def rescue_action_with_newrelic_trace(exception)
+        rescue_action_without_newrelic_trace exception
+        NewRelic::Agent::Instrumentation::MetricFrame.notice_error exception, :request => request
+      end
+
+      # Compare with #alias_method_chain, which is not available in
+      # Rails 1.1:
+      alias_method :rescue_action_without_newrelic_trace, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_newrelic_trace
+      protected :rescue_action
+
+    end
+  end
+end
+

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -0,0 +1,118 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails3
+        module ActionController
+          def self.newrelic_write_attr(attr_name, value) # :nodoc:
+            write_inheritable_attribute(attr_name, value)
+          end
+
+          def self.newrelic_read_attr(attr_name) # :nodoc:
+            read_inheritable_attribute(attr_name)
+          end
+
+          # determine the path that is used in the metric name for
+          # the called controller action
+          def newrelic_metric_path(action_name_override = nil)
+            action_part = action_name_override || action_name
+            if action_name_override || self.class.action_methods.include?(action_part)
+              "#{self.class.controller_path}/#{action_part}"
+            else
+              "#{self.class.controller_path}/(other)"
+            end
+          end
+
+          def process_action(*args)
+            # skip instrumentation if we are in an ignored action
+            if _is_filtered?('do_not_trace')
+              NewRelic::Agent.disable_all_tracing do
+                return super
+              end
+            end
+
+            perform_action_with_newrelic_trace(:category => :controller, :name => self.action_name, :path => newrelic_metric_path, :params => request.filtered_parameters, :class_name => self.class.name)  do
+              super
+            end
+          end
+
+        end
+
+        module ActionView
+          def _render_template(template, layout = nil, options = {}) #:nodoc:
+            NewRelic::Agent.trace_execution_scoped "View/#{template.virtual_path}/Rendering" do
+              super
+            end
+          end
+
+          module PartialRenderer
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.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
+    NewRelic::Agent.logger.debug 'Installing Rails 3 Controller instrumentation'
+  end  
+  
+  executes do
+    class ActionController::Base
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      include NewRelic::Agent::Instrumentation::Rails3::ActionController
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails3_view
+  
+  depends_on do
+    defined?(ActionView) && defined?(ActionView::Base) && defined?(ActionView::Partials)
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i >= 1
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 3 view instrumentation'
+  end
+  
+  executes do
+    class ActionView::Base
+      include NewRelic::Agent::Instrumentation::Rails3::ActionView
+    end
+    old_klass = ActionView::Partials::PartialRenderer
+    ActionView::Partials::PartialRenderer = Class.new(old_klass)
+    class ActionView::Partials::PartialRenderer
+      def render_partial(*args)
+        NewRelic::Agent.trace_execution_scoped "View/#{@template.virtual_path}/Partial" do
+          super
+        end
+      end
+
+      def render_collection(*args)
+        name = @template ? @template.virtual_path : "Mixed"
+        NewRelic::Agent.trace_execution_scoped "View/#{name}/Collection" do
+          super
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails3/active_record_instrumentation.rb

@@ -0,0 +1,122 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordInstrumentation
+
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
+              alias_method :log_without_newrelic_instrumentation, :log
+              alias_method :log, :log_with_newrelic_instrumentation
+              protected :log
+            end
+          end
+        end
+
+        def log_with_newrelic_instrumentation(*args, &block)
+
+          return log_without_newrelic_instrumentation(*args, &block) unless NewRelic::Agent.is_execution_traced?
+
+          sql, name, binds = args
+
+          # Capture db config if we are going to try to get the explain plans
+          if (defined?(ActiveRecord::ConnectionAdapters::MysqlAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::MysqlAdapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) && self.is_a?(ActiveRecord::ConnectionAdapters::Mysql2Adapter)) ||
+              (defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter))
+            supported_config = @config
+          end
+          if name && (parts = name.split " ") && parts.size == 2
+            model = parts.first
+            operation = parts.last.downcase
+            metric_name = case operation
+                          when 'load', 'count', 'exists' then 'find'
+                          when 'indexes', 'columns' then nil # fall back to DirectSQL
+                          when 'destroy', 'find', 'save', 'create' then operation
+                          when 'update' then 'save'
+                          else
+                            if model == 'Join'
+                              operation
+                            end
+                          end
+            metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+          end
+
+          if metric.nil?
+            metric = NewRelic::Agent::Instrumentation::MetricFrame.database_metric_name
+            if metric.nil?
+              if sql =~ /^(select|update|insert|delete|show)/i
+                # Could not determine the model/operation so let's find a better
+                # metric.  If it doesn't match the regex, it's probably a show
+                # command or some DDL which we'll ignore.
+                metric = "Database/SQL/#{$1.downcase}"
+              else
+                metric = "Database/SQL/other"
+              end
+            end
+          end
+
+          if !metric
+            log_without_newrelic_instrumentation(*args, &block)
+          else
+            metrics = [metric, "ActiveRecord/all"]
+            metrics << "ActiveRecord/#{metric_name}" if metric_name
+            self.class.trace_execution_scoped(metrics) do
+              sql, name, binds = args
+              t0 = Time.now
+              begin
+                log_without_newrelic_instrumentation(*args, &block)
+              ensure
+                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, supported_config, (Time.now - t0).to_f)
+                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric, supported_config, (Time.now - t0).to_f)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails3_active_record
+  
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+  end
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['skip_ar_instrumentation']
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_activerecord_instrumentation']
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 3 ActiveRecord instrumentation'
+  end
+  
+  executes do
+    Rails.configuration.after_initialize do
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include ::NewRelic::Agent::Instrumentation::ActiveRecordInstrumentation
+      end
+    end
+  end
+
+  executes do
+    Rails.configuration.after_initialize do
+      ActiveRecord::Base.class_eval do
+        class << self
+          add_method_tracer :find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql', :metric => false
+          add_method_tracer :transaction, 'ActiveRecord/#{self.name}/transaction', :metric => false
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -0,0 +1,37 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails3
+        module Errors
+          def newrelic_notice_error(exception, custom_params = {})
+            filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
+            filtered_params.merge!(custom_params)
+            NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails3_error
+  
+  depends_on do
+    defined?(::Rails) && ::Rails.respond_to?(:version) && ::Rails.version.to_i == 3
+  end
+
+  depends_on do
+    defined?(ActionController) && defined?(ActionController::Base)
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails3 Error instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include NewRelic::Agent::Instrumentation::Rails3::Errors
+    end
+  end
+end