mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/instrumentation/queue_time.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      # https://mmtrix.com/docs/features/tracking-front-end-time
+      # Record queue time metrics based on any of three headers
+      # which can be set on the request.
+      module QueueTime
+        unless defined?(REQUEST_START_HEADER)
+          REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'.freeze
+          QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'.freeze
+          MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'.freeze
+          ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'.freeze
+          # any timestamps before this are thrown out and the parser
+          # will try again with a larger unit (2000/1/1 UTC)
+          EARLIEST_ACCEPTABLE_TIME = Time.at(946684800)
+
+          CANDIDATE_HEADERS = [
+            REQUEST_START_HEADER,
+            QUEUE_START_HEADER,
+            MIDDLEWARE_START_HEADER
+          ].freeze
+
+          DIVISORS = [1_000_000, 1_000, 1]
+        end
+
+        module_function
+
+        def parse_frontend_timestamp(headers, now=Time.now)
+          earliest = nil
+
+          CANDIDATE_HEADERS.each do |header|
+            if headers[header]
+              parsed = parse_timestamp(timestamp_string_from_header_value(headers[header]))
+              if parsed && (!earliest || parsed < earliest)
+                earliest = parsed
+              end
+            end
+          end
+
+          if earliest && earliest > now
+            Mmtrix::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            earliest = now
+          end
+
+          earliest
+        end
+
+        def timestamp_string_from_header_value(value)
+          case value
+          when /^\s*([\d+\.]+)\s*$/ then $1
+          # following regexp intentionally unanchored to handle
+          # (ie ignore) leading server names
+          when /t=([\d+\.]+)/       then $1
+          end
+        end
+
+        def parse_timestamp(string)
+          DIVISORS.each do |divisor|
+            begin
+              t = Time.at(string.to_f / divisor)
+              return t if t > EARLIEST_ACCEPTABLE_TIME
+            rescue RangeError
+              # On Ruby versions built with a 32-bit time_t, attempting to
+              # instantiate a Time object in the far future raises a RangeError,
+              # in which case we know we've chosen the wrong divisor.
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/agent/instrumentation/controller_instrumentation'
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      # == Instrumentation for Rack
+      #
+      # Since version 3.9.0, Mmtrix instruments Rack middlewares by default.
+      # As a result, this entire module has been deprecated.
+      #
+      # @api public
+      # @deprecated
+      #
+      module Rack
+        include ControllerInstrumentation
+
+        def mmtrix_request_headers(_)
+          @mmtrix_request.env
+        end
+
+        def call_with_mmtrix(*args)
+          @mmtrix_request = ::Rack::Request.new(args.first)
+          perform_action_with_mmtrix_trace(:category => :middleware, :request => @mmtrix_request) do
+            result = call_without_mmtrix(*args)
+            # Ignore cascaded calls
+            Transaction.abort_transaction! if result.first == 404
+            result
+          end
+        end
+
+        def self.included middleware #:nodoc:
+          middleware.class_eval do
+            alias call_without_mmtrix call
+            alias call call_with_mmtrix
+          end
+        end
+
+        def self.extended middleware #:nodoc:
+          middleware.class_eval do
+            class << self
+              alias call_without_mmtrix call
+              alias call call_with_mmtrix
+            end
+          end
+        end
+
+        def _nr_has_middleware_tracing
+          true
+        end
+      end
+
+      module RackHelpers
+        def self.rack_version_supported?
+          version = ::Mmtrix::VersionNumber.new(::Rack.release)
+          min_version = ::Mmtrix::VersionNumber.new('1.1.0')
+          version >= min_version
+        end
+
+        def self.middleware_instrumentation_enabled?
+          rack_version_supported? && !::Mmtrix::Agent.config[:disable_middleware_instrumentation]
+        end
+
+        def self.check_for_late_instrumentation(app)
+          return if @checked_for_late_instrumentation
+          @checked_for_late_instrumentation = true
+          if middleware_instrumentation_enabled?
+            if ::Mmtrix::Agent::Instrumentation::MiddlewareProxy.needs_wrapping?(app)
+              ::Mmtrix::Agent.logger.info("We weren't able to instrument all of your Rack middlewares.",
+                                            "To correct this, ensure you 'require \"mmtrix_rpm\"' before setting up your middleware stack.")
+            end
+          end
+        end
+      end
+
+      module RackBuilder
+        def run_with_mmtrix(app, *args)
+          if ::Mmtrix::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            wrapped_app = ::Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
+            run_without_mmtrix(wrapped_app, *args)
+          else
+            run_without_mmtrix(app, *args)
+          end
+        end
+
+        def use_with_mmtrix(middleware_class, *args, &blk)
+          if ::Mmtrix::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+            wrapped_middleware_class = ::Mmtrix::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
+            use_without_mmtrix(wrapped_middleware_class, *args, &blk)
+          else
+            use_without_mmtrix(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
+        # DependencyDetection.detect!, since all libraries are likely loaded at
+        # this point.
+        def to_app_with_mmtrix_deferred_dependency_detection
+          unless ::Rack::Builder._nr_deferred_detection_ran
+            Mmtrix::Agent.logger.info "Doing deferred dependency-detection before Rack startup"
+            DependencyDetection.detect!
+            ::Rack::Builder._nr_deferred_detection_ran = true
+          end
+
+          result = to_app_without_mmtrix
+          ::Mmtrix::Agent::Instrumentation::RackHelpers.check_for_late_instrumentation(result)
+
+          result
+        end
+      end
+
+      module RackURLMap
+        def self.generate_traced_map(map)
+          map.inject({}) do |traced_map, (url, handler)|
+            traced_map[url] = Mmtrix::Agent::Instrumentation::MiddlewareProxy.wrap(handler, true)
+            traced_map
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :rack
+
+  depends_on do
+    defined?(::Rack) && defined?(::Rack::Builder)
+  end
+
+  executes do
+    ::Mmtrix::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 ::Mmtrix::Agent::Instrumentation::RackBuilder
+
+      alias_method :to_app_without_mmtrix, :to_app
+      alias_method :to_app, :to_app_with_mmtrix_deferred_dependency_detection
+
+      if ::Mmtrix::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled?
+        ::Mmtrix::Agent.logger.info 'Installing Rack::Builder middleware instrumentation'
+        alias_method :run_without_mmtrix, :run
+        alias_method :run, :run_with_mmtrix
+
+        alias_method :use_without_mmtrix, :use
+        alias_method :use, :use_with_mmtrix
+      end
+    end
+
+  end
+end
+
+DependencyDetection.defer do
+  named :rack_urlmap
+
+  depends_on do
+    defined?(::Rack) && defined?(::Rack::URLMap)
+  end
+
+  depends_on do
+    ::Mmtrix::Agent::Instrumentation::RackHelpers.middleware_instrumentation_enabled? &&
+      !::Mmtrix::Agent.config[:disable_rack]
+  end
+
+  executes do
+    class ::Rack::URLMap
+      alias_method :initialize_without_mmtrix, :initialize
+
+      def initialize(map = {})
+        traced_map = ::Mmtrix::Agent::Instrumentation::RackURLMap.generate_traced_map(map)
+        initialize_without_mmtrix(traced_map)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  @name = :rails21_view
+
+  depends_on do
+    !Mmtrix::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
+    ::Mmtrix::Agent.logger.info 'Installing Rails 2.1 View instrumentation'
+  end
+
+  executes do
+    ActionView::PartialTemplate.class_eval do
+      include Mmtrix::Agent::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 Mmtrix::Agent::MethodTracer
+      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.mmtrix_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :old_rails_view
+
+  depends_on do
+    !Mmtrix::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
+    ::Mmtrix::Agent.logger.info 'Installing Rails 1.* - 2.0 View instrumentation'
+  end
+
+  executes do
+    ActionController::Base.class_eval do
+      include Mmtrix::Agent::MethodTracer
+      add_method_tracer :render, 'View/#{mmtrix_metric_path}/Rendering'
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails23_view
+
+  depends_on do
+    !Mmtrix::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
+    ::Mmtrix::Agent.logger.info 'Installing Rails 2.2 - 2.3 View instrumentation'
+  end
+
+  executes do
+    ActionView::RenderablePartial.module_eval do
+      include Mmtrix::Agent::MethodTracer
+      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+    end
+
+    ActionView::Template.class_eval do
+      include Mmtrix::Agent::MethodTracer
+      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
+    ::Mmtrix::Agent.logger.info 'Installing Rails 2 Controller instrumentation'
+  end
+
+  executes do
+    ActionController::Base.class_eval do
+      include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+
+      def perform_action_with_mmtrix_trace_wrapper
+        munged_params = (respond_to?(:filter_parameters)) ? filter_parameters(params) : params
+        munged_params = Mmtrix::Agent::ParameterFiltering.filter_rails_request_parameters(munged_params)
+
+        perform_action_with_mmtrix_trace(:params => munged_params) do
+          perform_action_without_mmtrix_trace
+        end
+      end
+
+      alias_method :perform_action_without_mmtrix_trace, :perform_action
+      alias_method :perform_action, :perform_action_with_mmtrix_trace_wrapper
+      private :perform_action
+
+      # determine the path that is used in the metric name for
+      # the called controller action
+      def mmtrix_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/mmtrix/agent/instrumentation/rails/action_web_service.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  @name = :rails_action_web_service
+
+  depends_on do
+    defined?(ActionWebService)
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Rails ActionWebService instrumentation'
+  end
+
+  executes do
+    # Mmtrix 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/mmtrix/agent/instrumentation/rails/errors.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+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
+    ::Mmtrix::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 Mmtrix::Agent#notice_error.
+      # Use that one instead.
+      #
+      # @api public
+      # @deprecated
+      def mmtrix_notice_error(exception, custom_params = {})
+        Mmtrix::Agent::Deprecator.deprecate("ActionController#mmtrix_notice_error",
+                                              "Mmtrix::Agent#notice_error")
+
+        Mmtrix::Agent::Transaction.notice_error exception, :custom_params => custom_params
+      end
+
+      def rescue_action_with_mmtrix_trace(exception)
+        rescue_action_without_mmtrix_trace exception
+        Mmtrix::Agent::Transaction.notice_error exception
+      end
+
+      # Compare with #alias_method_chain, which is not available in
+      # Rails 1.1:
+      alias_method :rescue_action_without_mmtrix_trace, :rescue_action
+      alias_method :rescue_action, :rescue_action_with_mmtrix_trace
+      protected :rescue_action
+
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      module Rails3
+        module ActionController
+          # determine the path that is used in the metric name for
+          # the called controller action
+          def mmtrix_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
+            munged_params = Mmtrix::Agent::ParameterFiltering.filter_rails_request_parameters(request.filtered_parameters)
+            perform_action_with_mmtrix_trace(:category => :controller,
+                                               :name => self.action_name,
+                                               :path => mmtrix_metric_path,
+                                               :params => munged_params,
+                                               :class_name => self.class.name)  do
+              super
+            end
+          end
+
+        end
+
+        module ActionView
+          module Mmtrix
+            extend self
+            def template_metric(identifier, options = {})
+              if options[:file]
+                "file"
+              elsif identifier.nil?
+                ::Mmtrix::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
+  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
+    ::Mmtrix::Agent.logger.info 'Installing Rails 3 Controller instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+      include Mmtrix::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
+    !Mmtrix::Agent.config[:disable_view_instrumentation]
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Rails 3.0 view instrumentation'
+  end
+
+  executes do
+    ActionView::Template.class_eval do
+      include Mmtrix::Agent::MethodTracer
+      def render_with_mmtrix(*args, &block)
+        options = if @virtual_path && @virtual_path.starts_with?('/') # file render
+          {:file => true }
+        else
+          {}
+        end
+        str = "View/#{Mmtrix::Agent::Instrumentation::Rails3::ActionView::Mmtrix.template_metric(@identifier, options)}/#{Mmtrix::Agent::Instrumentation::Rails3::ActionView::Mmtrix.render_type(@identifier)}"
+        trace_execution_scoped str do
+          render_without_mmtrix(*args, &block)
+        end
+      end
+
+      alias_method :render_without_mmtrix, :render
+      alias_method :render, :render_with_mmtrix
+
+    end
+  end
+end
+
+DependencyDetection.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
+    !Mmtrix::Agent.config[:disable_view_instrumentation]
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Rails 3.1/3.2 view instrumentation'
+  end
+
+  executes do
+    ActionView::TemplateRenderer.class_eval do
+      include Mmtrix::Agent::MethodTracer
+      # namespaced helper methods
+
+      def render_with_mmtrix(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/#{Mmtrix::Agent::Instrumentation::Rails3::ActionView::Mmtrix.template_metric(identifier, options)}/Rendering"
+        trace_execution_scoped scope_name do
+          render_without_mmtrix(context, options)
+        end
+      end
+
+      alias_method :render_without_mmtrix, :render
+      alias_method :render, :render_with_mmtrix
+    end
+
+    ActionView::PartialRenderer.class_eval do
+      include Mmtrix::Agent::MethodTracer
+
+      def instrument_with_mmtrix(name, payload = {}, &block)
+        identifier = payload[:identifier]
+        scope_name = "View/#{Mmtrix::Agent::Instrumentation::Rails3::ActionView::Mmtrix.template_metric(identifier)}/Partial"
+        trace_execution_scoped(scope_name) do
+          instrument_without_mmtrix(name, payload, &block)
+        end
+      end
+
+      alias_method :instrument_without_mmtrix, :instrument
+      alias_method :instrument, :instrument_with_mmtrix
+    end
+  end
+end