wd_newrelic_rpm 3.5.6 → 3.5.8

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

@@ -300,17 +300,30 @@ module NewRelic
         end
 
         def self.record_apdex(current_metric, action_duration, total_duration, is_error)
-          summary_stat = agent.stats_engine.get_custom_stats("Apdex", NewRelic::ApdexStats)
-          controller_stat = agent.stats_engine.get_custom_stats(current_metric.apdex_metric_path, NewRelic::ApdexStats)
+          summary_stat = agent.stats_engine.lookup_stats("Apdex") ||
+            initialize_apdex("Apdex")
           update_apdex(summary_stat, total_duration, is_error)
+
+          controller_stat = agent.stats_engine.lookup_stats(current_metric.apdex_metric_path) ||
+            initialize_apdex(current_metric.apdex_metric_path)
           update_apdex(controller_stat, action_duration, is_error)
         end
 
+        # Apdex min and max values should be initialized to the
+        # current apdex_t
+        def self.initialize_apdex(metric_name)
+          stats = agent.stats_engine.get_stats_no_scope(metric_name)
+          apdex_t = TransactionInfo.get.apdex_t
+          stats.min_call_time = apdex_t
+          stats.max_call_time = apdex_t
+          return stats
+        end
+
         # Record an apdex value for the given stat.  when `failed`
         # the apdex should be recorded as a failure regardless of duration.
         def self.update_apdex(stat, duration, failed)
           duration = duration.to_f
-          apdex_t = Agent.config[:apdex_t]
+          apdex_t = TransactionInfo.get.apdex_t
           case
           when failed
             stat.record_apdex_f

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 DependencyDetection.defer do
   @name = :net
 
@@ -7,23 +9,23 @@ DependencyDetection.defer do
   
   executes do
     ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
   end
-  
+
   executes do
-    Net::HTTP.class_eval do
-      def request_with_newrelic_trace(*args, &block)
-        metrics = ["External/#{@address}/Net::HTTP/#{args[0].method}", "External/#{@address}/all", "External/all"]
-        if NewRelic::Agent::Instrumentation::MetricFrame.recording_web_transaction?
-          metrics << "External/allWeb"
-        else
-          metrics << "External/allOther"
-        end
-        self.class.trace_execution_scoped metrics do
-          request_without_newrelic_trace(*args, &block)
+    class Net::HTTP
+
+      # Instrument outgoing HTTP requests and fire associated events back
+      # into the Agent.
+      def request_with_newrelic_trace(request, *args, &block)
+        NewRelic::Agent::CrossAppTracing.trace_http_request( self, request ) do
+          request_without_newrelic_trace( request, *args, &block )
         end
       end
+
       alias request_without_newrelic_trace request
       alias request request_with_newrelic_trace
+
     end
   end
 end

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

@@ -1,210 +1,68 @@
 module NewRelic
   module Agent
     module Instrumentation
+      # https://newrelic.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?(MAIN_HEADER)
-          MAIN_HEADER = 'HTTP_X_REQUEST_START'
-          MIDDLEWARE_HEADER = 'HTTP_X_MIDDLEWARE_START'
-          QUEUE_HEADER = 'HTTP_X_QUEUE_START'
-          ALT_QUEUE_HEADER = 'HTTP_X_QUEUE_TIME'
-          HEROKU_QUEUE_HEADER = 'HTTP_X_HEROKU_QUEUE_WAIT_TIME'
-          APP_HEADER = 'HTTP_X_APPLICATION_START'
-
-          HEADER_REGEX = /([^\s\/,(t=)]+)? ?t=([0-9\.]+)/
-          SERVER_METRIC = 'WebFrontend/WebServer/'
-          MIDDLEWARE_METRIC = 'Middleware/'
-          # no individual queue metric - more than one queue?!
-          ALL_SERVER_METRIC = 'WebFrontend/WebServer/all'
-          ALL_MIDDLEWARE_METRIC = 'Middleware/all'
-          ALL_QUEUE_METRIC = 'WebFrontend/QueueTime'
-        end
-
-        def parse_frontend_headers(headers)
-          # these methods add internal state, so we dup so other parts
-          # of the app don't have to worry about it.
-          # May have performance implications with very large env hashes
-          env = headers.dup
-          add_end_time_header(Time.now, env)
-          middleware_start = parse_middleware_time_from(env)
-          queue_start = parse_queue_time_from(env)
-          server_start = parse_server_time_from(env)
-          # returned for the controller instrumentation
-          [middleware_start, queue_start, server_start].min
-        end
-
-        private
-
-        # main method to extract server time info from env hash,
-        # records individual server metrics and one roll-up for all servers
-        def parse_server_time_from(env)
-          end_time = parse_end_time(env)
-          matches = get_matches_from_header(MAIN_HEADER, env)
-
-          record_individual_server_stats(end_time, matches)
-          record_rollup_server_stat(end_time, matches)
-        end
-
-        def parse_middleware_time_from(env)
-          end_time = parse_end_time(env)
-          matches = get_matches_from_header(MIDDLEWARE_HEADER, env)
-
-          record_individual_middleware_stats(end_time, matches)
-          oldest_time = record_rollup_middleware_stat(end_time, matches)
-          # notice this bit: we reset the end time to the earliest
-          # middleware tag so that other frontend metrics don't
-          # include this time.
-          add_end_time_header(oldest_time, env)
-          oldest_time
-        end
-
-        def parse_queue_time_from(env)
-          oldest_time = nil
-          end_time = parse_end_time(env)
-          alternate_length = check_for_alternate_queue_length(env)
-          if alternate_length
-            # skip all that fancy-dan stuff
-            NewRelic::Agent.get_stats(ALL_QUEUE_METRIC).trace_call(alternate_length)
-            oldest_time = (end_time - alternate_length) # should be a time
-          else
-            matches = get_matches_from_header(QUEUE_HEADER, env)
-            oldest_time = record_rollup_queue_stat(end_time, matches)
+        unless defined?(REQUEST_START_HEADER)
+          REQUEST_START_HEADER    = 'HTTP_X_REQUEST_START'
+          QUEUE_START_HEADER      = 'HTTP_X_QUEUE_START'
+          QUEUE_DURATION_HEADER   = 'HTTP_X_QUEUE_TIME'
+          MIDDLEWARE_START_HEADER = 'HTTP_X_MIDDLEWARE_START'
+          ALL_QUEUE_METRIC        = 'WebFrontend/QueueTime'
+          # any timestamps before this are thrown out and the parser
+          # will try again with a larger unit (2000/1/1 UTC)
+          EARLIEST_ACCEPTABLE_TIMESTAMP = 946684800
+        end
+
+        module_function
+
+        def parse_frontend_timestamp(headers, now=Time.now)
+          candidate_headers = [ REQUEST_START_HEADER, QUEUE_START_HEADER,
+                                MIDDLEWARE_START_HEADER ]
+          earliest = candidate_headers.map do |header|
+            if headers[header]
+              parse_timestamp(timestamp_string_from_header_value(headers[header]))
+            end
+          end.compact.min
+
+          if earliest && earliest > now
+            NewRelic::Agent.logger.debug("Negative queue time detected, treating as zero: start=#{earliest.to_f} > now=#{now.to_f}")
+            earliest = now
           end
-          # notice this bit: we reset the end time to the earliest
-          # queue tag or the start time minus the queue time so that
-          # other frontend metrics don't include this time.
-          add_end_time_header(oldest_time, env)
-          oldest_time
-        end
 
-        def check_for_alternate_queue_length(env)
-          heroku_length = check_for_heroku_queue_length(env)
-          return heroku_length if heroku_length
-          header = env[ALT_QUEUE_HEADER]
-          return nil unless header
-          (header.gsub('t=', '').to_i / 1_000_000.0)
+          earliest
         end
 
-        def check_for_heroku_queue_length(env)
-          header = env[HEROKU_QUEUE_HEADER]
-          return nil unless header
-          (header.gsub(/[^0-9]/, '').to_i / 1_000.0)
+        def record_frontend_metrics(start_time, now=Time.now)
+          NewRelic::Agent.instance.stats_engine.get_stats(ALL_QUEUE_METRIC) \
+            .record_data_point((now - start_time).to_f)
         end
 
-        def get_matches_from_header(header, env)
-          return [] if env.nil?
-          get_matches(env[header]).map do |name, time|
-            convert_to_name_time_pair(name, time.sub('.', ''))
+        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 get_matches(string)
-          string.to_s.scan(HEADER_REGEX)
-        end
-
-        def convert_to_name_time_pair(name, time)
-          [name, convert_from_microseconds(time.to_i)]
-        end
-
-        def record_individual_stat_of_type(type, end_time, matches)
-          matches = matches.sort_by {|name, time| time }
-          matches.reverse!
-          matches.inject(end_time) {|end_time, pair|
-            name, time = pair
-            self.send(type, name, time, end_time) if name
-            time
-          }
-        end
-
-        # goes through the list of servers and records each one in
-        # reverse order, subtracting the time for each successive
-        # server from the earlier ones in the list.
-        # an example because it's complicated:
-        # start data:
-        # [['a', Time.at(1000)], ['b', Time.at(1001)]], start time: Time.at(1002)
-        # initial run: Time.at(1002), ['b', Time.at(1001)]
-        # next: Time.at(1001), ['a', Time.at(1000)]
-        # see tests for more
-        def record_individual_server_stats(end_time, matches) # (Time, [[String, Time]]) -> nil
-          record_individual_stat_of_type(:record_server_time_for, end_time, matches)
-        end
-
-        def record_individual_middleware_stats(end_time, matches)
-          record_individual_stat_of_type(:record_middleware_time_for, end_time, matches)
-        end
-
-        # records the total time for all servers in a rollup metric
-        def record_rollup_server_stat(end_time, matches) # (Time, [String, Time]) -> nil
-          record_rollup_stat_of_type(ALL_SERVER_METRIC, end_time, matches)
-        end
-
-        def record_rollup_middleware_stat(end_time, matches)
-          record_rollup_stat_of_type(ALL_MIDDLEWARE_METRIC, end_time, matches)
-        end
-
-        def record_rollup_queue_stat(end_time, matches)
-          record_rollup_stat_of_type(ALL_QUEUE_METRIC, end_time, matches)
-        end
-
-        def record_rollup_stat_of_type(metric, end_time, matches)
-          oldest_time = find_oldest_time(matches) || end_time
-          record_time_stat(metric, oldest_time, end_time)
-          oldest_time
-        end
-
-        # searches for the first server to touch a request
-        def find_oldest_time(matches) # [[String, Time]] -> Time
-          matches.map do |name, time|
-            time
-          end.min
-        end
-
-        # basically just assembles the metric name
-        def record_server_time_for(name, start_time, end_time) # (Maybe String, Time, Time) -> nil
-          record_time_stat(SERVER_METRIC + name, start_time, end_time) if name
-        end
-
-        def record_middleware_time_for(name, start_time, end_time)
-          record_time_stat(MIDDLEWARE_METRIC + name, start_time, end_time)
-        end
-
-        # Checks that the time is not negative, and does the actual
-        # data recording
-        def record_time_stat(name, start_time, end_time) # (String, Time, Time) -> nil
-          total_time = end_time - start_time
-          if total_time < 0
-            raise "should not provide an end time less than start time: #{end_time.strftime('%s.%N')} is less than #{start_time.strftime('%s.%N')}. total time is #{total_time}."
-          else
-            NewRelic::Agent.get_stats(name).trace_call(total_time)
-          end
-        end
-
-        def add_end_time_header(end_time, env) # (Time, Env) -> nil
-          return unless end_time
-          env[APP_HEADER] = "t=#{convert_to_microseconds(end_time)}"
-        end
-
-        def parse_end_time(env)
-          header = env[APP_HEADER]
-          return Time.now unless header
-          convert_from_microseconds(header.gsub('t=', '').to_i)
-        end
-
-        # convert a time to the value provided by the header, for convenience
-        def convert_to_microseconds(time) # Time -> Int
-          raise TypeError.new('Cannot convert a non-time into microseconds') unless time.is_a?(Time) || time.is_a?(Numeric)
-          return time if time.is_a?(Numeric)
-          (time.to_f * 1_000_000).to_i
-        end
-
-        # convert a time from the header value (time in microseconds)
-        # into a ruby time object
-        def convert_from_microseconds(int) # Int -> Time
-          raise TypeError.new('Cannot convert a non-number into a time') unless int.is_a?(Time) || int.is_a?(Numeric)
-          return int if int.is_a?(Time)
-          Time.at((int / 1_000_000.0))
+        def parse_timestamp(string)
+          cut_off = Time.at(EARLIEST_ACCEPTABLE_TIMESTAMP)
+          [1_000_000, 1_000, 1].map do |divisor|
+            begin
+              Time.at(string.to_f / divisor)
+            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.
+              nil
+            end
+          end.compact.find { |candidate| candidate > cut_off }
         end
       end
     end
   end
 end
-

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

@@ -0,0 +1,145 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module Rails4
+        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 = :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
+    ::NewRelic::Agent.logger.info 'Installing Rails 4 Controller instrumentation'
+  end
+
+  executes do
+    class ActionController::Base
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      include NewRelic::Agent::Instrumentation::Rails4::ActionController
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails40_view
+
+  depends_on do
+    defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_view_instrumentation]
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Rails 4 view instrumentation'
+  end
+
+  executes do
+    ActionView::TemplateRenderer.class_eval do
+      include NewRelic::Agent::MethodTracer
+      # namespaced helper methods
+
+      def render_with_newrelic(context, options)
+        @details = extract_details(options) if respond_to? :extract_details, true
+        identifier = determine_template(options) ? determine_template(options).identifier : nil
+        str = "View/#{NewRelic::Agent::Instrumentation::Rails4::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::Rails4::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