wd_newrelic_rpm 3.3.4.1

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/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,180 @@
+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
+          module NewRelic
+            extend self
+            def template_metric(identifier, options = {})
+              if options[:file]
+                "file"
+              elsif identifier.nil?
+                "(unknown)"
+              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
+  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 = :rails30_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails::VERSION::MINOR.to_i == 0
+  end
+
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 3.0 view instrumentation'
+  end
+
+  executes do
+    ActionView::Template.class_eval do
+      include NewRelic::Agent::MethodTracer
+      def render_with_newrelic(*args, &block)
+        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
+          {:file => true }
+        else
+          {}
+        end
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(@identifier, options)}/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.render_type(@identifier)}"
+        trace_execution_scoped str do
+          render_without_newrelic(*args, &block)
+        end
+      end
+
+      alias_method :render_without_newrelic, :render
+      alias_method :render, :render_with_newrelic
+
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails31_view
+
+  # We can't be sure that this wil 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
+
+  depends_on do
+    !NewRelic::Control.instance['disable_view_instrumentation']
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Rails 3.1/3.2 view instrumentation'
+  end
+
+  executes do
+    ActionView::TemplateRenderer.class_eval do
+      include NewRelic::Agent::MethodTracer
+      # namespaced helper methods
+
+      def render_with_newrelic(context, options)
+        # This is needed for rails 3.2 compatibility
+        @details = extract_details(options) if respond_to? :extract_details
+        identifier = determine_template(options) ? determine_template(options).identifier : nil
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
+        trace_execution_scoped str do
+          render_without_newrelic(context, options)
+        end
+      end
+
+      alias_method :render_without_newrelic, :render
+      alias_method :render, :render_with_newrelic
+    end
+
+    ActionView::PartialRenderer.class_eval do
+      include NewRelic::Agent::MethodTracer
+
+      def render_with_newrelic(*args, &block)
+        setup(*args, &block)
+        identifier = find_partial ? find_partial.identifier : nil
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier)}/Partial"
+        trace_execution_scoped str do
+          render_without_newrelic(*args, &block)
+        end
+      end
+
+      alias_method :render_without_newrelic, :render
+      alias_method :render, :render_with_newrelic
+    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

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

@@ -0,0 +1,78 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Sinatra) && defined?(::Sinatra::Base) && !defined?(::WeaselDiesel) &&
+      Sinatra::Base.private_method_defined?(:dispatch!)
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Sinatra instrumentation'
+  end
+
+  executes do
+    ::Sinatra::Base.class_eval do
+      include NewRelic::Agent::Instrumentation::Sinatra
+      alias dispatch_without_newrelic dispatch!
+      alias dispatch! dispatch_with_newrelic
+    end
+  end
+end
+
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # NewRelic instrumentation for Sinatra applications.  Sinatra actions will
+      # appear in the UI similar to controller actions, and have breakdown charts
+      # and transaction traces.
+      #
+      # The actions in the UI will correspond to the pattern expression used
+      # to match them.  HTTP operations are not distinguished.  Multiple matches
+      # will all be tracked as separate actions.
+      module Sinatra
+        include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+                
+        def dispatch_with_newrelic
+          txn_name = NewRelic.transaction_name(self.class.routes, @request) do |pattern, keys, conditions|
+            process_route(pattern, keys, conditions) do
+              pattern.source
+            end
+          end
+          
+          perform_action_with_newrelic_trace(:category => :sinatra,
+                                             :name => txn_name,
+                                             :params => @request.params) do
+            dispatch_without_newrelic
+          end
+        end
+
+        module NewRelic
+          extend self
+          
+          def http_verb(request)
+            request.request_method if request.respond_to?(:request_method)
+          end
+          
+          def transaction_name(routes, request)
+            name = '(unknown)'
+            verb = http_verb(request)
+            
+            Array(routes[verb]).each do |pattern, keys, conditions, block|
+              if pattern = yield(pattern, keys, conditions)
+                name = pattern
+              end
+            end
+            
+            name.gsub!(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
+            if verb
+              name = verb + ' ' + name
+            end
+            
+            name
+          end
+        end
+      end
+    end
+  end
+end