oneapm_rpm 1.1.0

data/lib/one_apm/inst/rack/rack.rb

@@ -0,0 +1,44 @@
+module OneApm
+  module Agent
+    module Instrumentation
+      module Rack
+        include TransactionBase
+
+        def oneapm_request_headers(_)
+          @oneapm_request.env
+        end
+
+        def call_with_oneapm(*args)
+          @oneapm_request = ::Rack::Request.new(args.first)
+          perform_action_with_oneapm_trace(:category => :middleware, :request => @oneapm_request) do
+            result = call_without_oneapm(*args)
+            # Ignore cascaded calls
+            Transaction.abort_transaction! if result.first == 404
+            result
+          end
+        end
+
+        def self.included middleware
+          middleware.class_eval do
+            alias call_without_oneapm call
+            alias call call_with_oneapm
+          end
+        end
+
+        def self.extended middleware
+          middleware.class_eval do
+            class << self
+              alias call_without_oneapm call
+              alias call call_with_oneapm
+            end
+          end
+        end
+
+        def _oa_has_middleware_tracing
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/one_apm/inst/rack/rack_builder.rb

@@ -0,0 +1,51 @@
+module OneApm
+  module Agent
+    module Instrumentation
+      module RackBuilder
+
+        def run_with_oneapm(app, *args)
+          unless OneApm::Agent.config[:disable_rack_middleware]
+            wrapped_app = ::OneApm::Rack::MiddlewareWrapper.wrap(app, true)
+            run_without_oneapm(wrapped_app, *args)
+          else
+            run_without_oneapm(app, *args)
+          end
+        end
+
+        def use_with_oneapm(middleware_class, *args, &blk)
+          unless OneApm::Agent.config[:disable_rack_middleware]
+            wrapped_middleware_class = ::OneApm::Rack::MiddlewareWrapper.wrap_class(middleware_class)
+            use_without_oneapm(wrapped_middleware_class, *args, &blk)
+          else
+            use_without_oneapm(middleware_class, *args, &blk)
+          end
+        end
+
+        # defered detection to avoid something later required
+        def to_app_with_oneapm_deferred_library_detection
+          unless ::Rack::Builder._oa_deferred_detection_ran
+            OneApm::Agent.logger.info "Doing deferred library-detection before Rack startup"
+            LibraryDetection.detect!
+            ::Rack::Builder._oa_deferred_detection_ran = true
+          end
+
+          result = to_app_without_oneapm
+          _check_for_late_instrumentation(result)
+
+          result
+        end
+
+        def _check_for_late_instrumentation(app)
+          return if @checked_for_late_instrumentation
+          @checked_for_late_instrumentation = true
+          unless ::OneApm::Agent.config[:disable_rack_middleware]
+            if ::OneApm::Rack::MiddlewareWrapper.needs_wrapping?(app)
+              # TODO Fix it in the future
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/one_apm/inst/rails/action_controller.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :rails21_view
+
+  depends_on do
+    !OneApm::Agent.config[: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
+    ::OneApm::Agent.logger.info 'Installing Rails 2.1 View instrumentation'
+  end
+
+  executes do
+    ActionView::PartialTemplate.class_eval do
+      include OneApm::Support::MethodTracer
+      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
+      include OneApm::Support::MethodTracer
+      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.oneapm_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :old_rails_view
+
+  depends_on do
+    !OneApm::Agent.config[: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
+    ::OneApm::Agent.logger.info 'Installing Rails 1.* - 2.0 View instrumentation'
+  end
+
+  executes do
+    ActionController::Base.class_eval do
+      include OneApm::Support::MethodTracer
+      add_method_tracer :render, 'View/#{oneapm_metric_path}/Rendering'
+    end
+  end
+end
+
+LibraryDetection.defer do
+  @name = :rails23_view
+
+  depends_on do
+    !OneApm::Agent.config[:disable_view_instrumentation] &&
+    defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
+    defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 2.2 - 2.3 View instrumentation'
+  end
+
+  executes do
+    ActionView::RenderablePartial.module_eval do
+      include OneApm::Support::MethodTracer
+      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+    end
+
+    ActionView::Template.class_eval do
+      include OneApm::Support::MethodTracer
+      add_method_tracer :render, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering'
+    end
+  end
+end
+
+LibraryDetection.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
+    ::OneApm::Agent.logger.info 'Installing Rails 2 Controller instrumentation'
+  end
+
+  executes do
+    ActionController::Base.class_eval do
+      include OneApm::Agent::Instrumentation::TransactionBase
+
+      def perform_action_with_oneapm_trace_wrapper
+        options = {}
+        options[:params] = (respond_to?(:filter_parameters)) ? filter_parameters(params) : params
+        perform_action_with_oneapm_trace(options) { perform_action_without_oneapm_trace }
+      end
+
+      alias_method :perform_action_without_oneapm_trace, :perform_action
+      alias_method :perform_action, :perform_action_with_oneapm_trace_wrapper
+      private :perform_action
+
+      # determine the path that is used in the metric name for
+      # the called controller action
+      def oneapm_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/one_apm/inst/rails/action_web_service.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+LibraryDetection.defer do
+  @name = :rails_action_web_service
+
+  depends_on do
+    defined?(ActionWebService)
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails ActionWebService instrumentation'
+  end
+
+  executes do
+    # OneApm 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/one_apm/inst/rails/errors.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+LibraryDetection.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
+    ::OneApm::Agent.logger.info '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 OneApm::Agent#notice_error.
+      # Use that one outside of controller actions.
+      def oneapm_notice_error(exception, custom_params = {})
+        OneApm::Transaction.notice_error exception, :custom_params => custom_params, :request => request
+      end
+
+      def rescue_action_with_oneapm_trace(exception)
+        rescue_action_without_oneapm_trace exception
+        OneApm::Transaction.notice_error exception, :request => request
+      end
+
+      # Compare with #alias_method_chain, which is not available in
+      # Rails 1.1:
+      alias_method :rescue_action_without_oneapm_trace, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_oneapm_trace
+      protected :rescue_action
+
+    end
+  end
+end

data/lib/one_apm/inst/rails3/action_controller.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+module OneApm
+  module Agent
+    module Instrumentation
+      module Rails3
+        module ActionController
+          # determine the path that is used in the metric name for
+          # the called controller action
+          def oneapm_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) #THREAD_LOCAL_ACCESS
+            perform_action_with_oneapm_trace(:category   => :controller,
+                                             :name       => self.action_name,
+                                             :path       => oneapm_metric_path,
+                                             :params     => request.filtered_parameters,
+                                             :class_name => self.class.name)  do
+              super
+            end
+          end
+
+        end
+
+        module ActionView
+          module OneApm
+            extend self
+            def template_metric(identifier, options = {})
+              if options[:file]
+                "file"
+              elsif identifier.nil?
+                OneApm::Transaction::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
+  end
+end
+
+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
+    ::OneApm::Agent.logger.info 'Installing Rails 3 Controller instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include OneApm::Agent::Instrumentation::TransactionBase
+      include OneApm::Agent::Instrumentation::Rails3::ActionController
+    end
+  end
+end
+LibraryDetection.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
+    !OneApm::Agent.config[:disable_view_instrumentation]
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
+  end
+
+  executes do
+    ActionView::Template.class_eval do
+      include OneApm::Support::MethodTracer
+      def render_with_oneapm(*args, &block)
+        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
+          {:file => true }
+        else
+          {}
+        end
+        template_metric = OneApm::Agent::Instrumentation::Rails3::ActionView::OneApm.template_metric(@identifier, options)
+        render_type = OneApm::Agent::Instrumentation::Rails3::ActionView::OneApm.render_type(@identifier)
+        str = "View/#{template_metric}/#{render_type}"
+        trace_execution_scoped str do
+          render_without_oneapm(*args, &block)
+        end
+      end
+
+      alias_method :render_without_oneapm, :render
+      alias_method :render, :render_with_oneapm
+
+    end
+  end
+end
+
+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
+
+  depends_on do
+    !OneApm::Agent.config[:disable_view_instrumentation]
+  end
+
+  executes do
+    ::OneApm::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+  end
+
+  executes do
+    ActionView::TemplateRenderer.class_eval do
+      include OneApm::Support::MethodTracer
+      # namespaced helper methods
+
+      def render_with_oneapm(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/#{OneApm::Agent::Instrumentation::Rails3::ActionView::OneApm.template_metric(identifier, options)}/Rendering"
+        trace_execution_scoped scope_name do
+          render_without_oneapm(context, options)
+        end
+      end
+
+      alias_method :render_without_oneapm, :render
+      alias_method :render, :render_with_oneapm
+    end
+
+    ActionView::PartialRenderer.class_eval do
+      include OneApm::Support::MethodTracer
+
+      def instrument_with_oneapm(name, payload = {}, &block)
+        identifier = payload[:identifier]
+        scope_name = "View/#{OneApm::Agent::Instrumentation::Rails3::ActionView::OneApm.template_metric(identifier)}/Partial"
+        trace_execution_scoped(scope_name) do
+          instrument_without_oneapm(name, payload, &block)
+        end
+      end
+
+      alias_method :instrument_without_oneapm, :instrument
+      alias_method :instrument, :instrument_with_oneapm
+    end
+  end
+end