dolores_rpm 3.2.0.2

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

@@ -0,0 +1,80 @@
+require 'new_relic/agent/instrumentation'
+module NewRelic
+  module Agent
+    module Instrumentation
+      class MetricFrame
+        module Pop
+
+          def clear_thread_metric_frame!
+            Thread.current[:newrelic_metric_frame] = nil
+          end
+
+          def set_new_scope!(metric)
+            agent.stats_engine.scope_name = metric
+          end
+
+          def log_underflow
+            NewRelic::Agent.logger.error "Underflow in metric frames: #{caller.join("\n   ")}"
+          end
+
+          def notice_scope_empty
+            transaction_sampler.notice_scope_empty
+            sql_sampler.notice_scope_empty
+          end
+
+          def record_transaction_cpu
+            burn = cpu_burn
+            transaction_sampler.notice_transaction_cpu_time(burn) if burn
+          end
+
+          def normal_cpu_burn
+            return unless @process_cpu_start
+            process_cpu - @process_cpu_start
+          end
+
+          def jruby_cpu_burn
+            return unless @jruby_cpu_start
+            burn = (jruby_cpu_time - @jruby_cpu_start)
+            record_jruby_cpu_burn(burn)
+            burn
+          end
+
+          # we need to do this here because the normal cpu sampler
+          # process doesn't work on JRuby. See the cpu_sampler.rb file
+          # to understand where cpu is recorded for non-jruby processes
+          def record_jruby_cpu_burn(burn)
+            NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).record_data_point(burn)
+          end
+
+          def cpu_burn
+            normal_cpu_burn || jruby_cpu_burn
+          end
+
+          def end_transaction!
+            agent.stats_engine.end_transaction
+          end
+
+          def notify_transaction_sampler(web_transaction)
+            record_transaction_cpu
+            notice_scope_empty
+          end
+
+          def traced?
+            NewRelic::Agent.is_execution_traced?
+          end
+
+          def handle_empty_path_stack(metric)
+            raise 'path stack not empty' unless @path_stack.empty?
+            notify_transaction_sampler(metric.is_web_transaction?) if traced?
+            end_transaction!
+            clear_thread_metric_frame!
+          end
+
+          def current_stack_metric
+            metric_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,332 @@
+require 'new_relic/agent/instrumentation/metric_frame/pop'
+
+# A struct holding the information required to measure a controller
+# action.  This is put on the thread local.  Handles the issue of
+# re-entrancy, or nested action calls.
+#
+# This class is not part of the public API.  Avoid making calls on it directly.
+#
+module NewRelic
+  module Agent
+    module Instrumentation
+      class MetricFrame
+        # helper module refactored out of the `pop` method
+        include Pop
+
+        attr_accessor :start       # A Time instance for the start time, never nil
+        attr_accessor :apdex_start # A Time instance used for calculating the apdex score, which
+        # might end up being @start, or it might be further upstream if
+        # we can find a request header for the queue entry time
+        attr_accessor :exception,
+        :filtered_params, :force_flag,
+        :jruby_cpu_start, :process_cpu_start, :database_metric_name
+
+        # Give the current metric frame a request context.  Use this to
+        # get the URI and referer.  The request is interpreted loosely
+        # as a Rack::Request or an ActionController::AbstractRequest.
+        attr_accessor :request
+
+
+        @@check_server_connection = false
+        def self.check_server_connection=(value)
+          @@check_server_connection = value
+        end
+        # Return the currently active metric frame, or nil.  Call with +true+
+        # to create a new metric frame if one is not already on the thread.
+        def self.current(create_if_empty=nil)
+          f = Thread.current[:newrelic_metric_frame]
+          return f if f || !create_if_empty
+
+          # Reconnect to the server if necessary.  This is only done
+          # for old versions of passenger that don't implement an explicit after_fork
+          # event.
+          agent.after_fork(:keep_retrying => false) if @@check_server_connection
+
+          Thread.current[:newrelic_metric_frame] = new
+        end
+
+        # This is the name of the model currently assigned to database
+        # measurements, overriding the default.
+        def self.database_metric_name
+          current && current.database_metric_name
+        end
+
+        def self.referer
+          current && current.referer
+        end
+
+        def self.agent
+          NewRelic::Agent.instance
+        end
+
+        @@java_classes_loaded = false
+
+        if defined? JRuby
+          begin
+            require 'java'
+            include_class 'java.lang.management.ManagementFactory'
+            include_class 'com.sun.management.OperatingSystemMXBean'
+            @@java_classes_loaded = true
+          rescue Exception => e
+          end
+        end
+
+        attr_reader :depth
+
+        def initialize
+          Thread.current[:newrelic_start_time] = @start = Time.now
+          @path_stack = [] # stack of [controller, path] elements
+          @jruby_cpu_start = jruby_cpu_time
+          @process_cpu_start = process_cpu
+        end
+
+        def agent
+          NewRelic::Agent.instance
+        end
+
+        def transaction_sampler
+          agent.transaction_sampler
+        end
+        
+        def sql_sampler
+          agent.sql_sampler
+        end
+
+        private :agent
+        private :transaction_sampler
+        private :sql_sampler        
+
+        # Indicate that we are entering a measured controller action or task.
+        # Make sure you unwind every push with a pop call.
+        def push(m)
+          transaction_sampler.notice_first_scope_push(start)
+          sql_sampler.notice_first_scope_push(start)
+          @path_stack.push NewRelic::MetricParser::MetricParser.for_metric_named(m)
+        end
+
+        # Indicate that you don't want to keep the currently saved transaction
+        # information
+        def self.abort_transaction!
+          current.abort_transaction! if current
+        end
+
+        # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
+        def uri
+          @uri ||= self.class.uri_from_request(@request) unless @request.nil?
+        end
+
+        # For the current web transaction, return the full referer, minus the host string, or nil.
+        def referer
+          @referer ||= self.class.referer_from_request(@request)
+        end
+
+        # Call this to ensure that the current transaction is not saved
+        def abort_transaction!
+          transaction_sampler.ignore_transaction
+        end
+        # This needs to be called after entering the call to trace the
+        # controller action, otherwise the controller action blames
+        # itself.  It gets reset in the normal #pop call.
+        def start_transaction
+          agent.stats_engine.start_transaction metric_name
+          # Only push the transaction context info once, on entry:
+          if @path_stack.size == 1
+            transaction_sampler.notice_transaction(metric_name, uri, filtered_params)
+            sql_sampler.notice_transaction(metric_name, uri, filtered_params)
+          end
+        end
+
+        def current_metric
+          @path_stack.last
+        end
+
+        # Return the path, the part of the metric after the category
+        def path
+          @path_stack.last.last
+        end
+
+        # Unwind one stack level.  It knows if it's back at the outermost caller and
+        # does the appropriate wrapup of the context.
+        def pop
+          metric = @path_stack.pop
+          log_underflow if metric.nil?
+          if @path_stack.empty?
+            handle_empty_path_stack(metric)
+          else
+            set_new_scope!(current_stack_metric)
+          end
+        end
+
+        # If we have an active metric frame, notice the error and increment the error metric.
+        # Options:
+        # * <tt>:request</tt> => Request object to get the uri and referer
+        # * <tt>:uri</tt> => The request path, minus any request params or query string.
+        # * <tt>:referer</tt> => The URI of the referer
+        # * <tt>:metric</tt> => The metric name associated with the transaction
+        # * <tt>:request_params</tt> => Request parameters, already filtered if necessary
+        # * <tt>:custom_params</tt> => Custom parameters
+        # Anything left over is treated as custom params
+
+        def self.notice_error(e, options={})
+          request = options.delete(:request)
+          if request
+            options[:referer] = referer_from_request(request)
+            options[:uri] = uri_from_request(request)
+          end
+          if current
+            current.notice_error(e, options)
+          else
+            agent.error_collector.notice_error(e, options)
+          end
+        end
+
+        # Do not call this.  Invoke the class method instead.
+        def notice_error(e, options={}) # :nodoc:
+          params = custom_parameters
+          options[:referer] = referer if referer
+          options[:request_params] = filtered_params if filtered_params
+          options[:uri] = uri if uri
+          options[:metric] = metric_name
+          options.merge!(custom_parameters)
+          if exception != e
+            result = agent.error_collector.notice_error(e, options)
+            self.exception = result if result
+          end
+        end
+
+        # Add context parameters to the metric frame.  This information will be passed in to errors
+        # and transaction traces.  Keys and Values should be strings, numbers or date/times.
+        def self.add_custom_parameters(p)
+          current.add_custom_parameters(p) if current
+        end
+
+        def self.custom_parameters
+          (current && current.custom_parameters) ? current.custom_parameters : {}
+        end
+
+        def record_apdex()
+          return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
+          t = Time.now
+          self.class.record_apdex(current_metric, t - start, t - apdex_start, !exception.nil?)
+        end
+
+        def metric_name
+          return nil if @path_stack.empty?
+          current_metric.name
+        end
+
+        # Return the array of metrics to record for the current metric frame.
+        def recorded_metrics
+          metrics = [ metric_name ]
+          metrics += current_metric.summary_metrics if @path_stack.size == 1
+          metrics
+        end
+
+        # Yield to a block that is run with a database metric name context.  This means
+        # the Database instrumentation will use this for the metric name if it does not
+        # otherwise know about a model.  This is re-entrant.
+        #
+        # * <tt>model</tt> is the DB model class
+        # * <tt>method</tt> is the name of the finder method or other method to identify the operation with.
+        #
+        def with_database_metric_name(model, method)
+          previous = @database_metric_name
+          model_name = case model
+                       when Class
+                         model.name
+                       when String
+                         model
+                       else
+                         model.to_s
+                       end
+          @database_metric_name = "ActiveRecord/#{model_name}/#{method}"
+          yield
+        ensure
+          @database_metric_name=previous
+        end
+
+        def custom_parameters
+          @custom_parameters ||= {}
+        end
+
+        def add_custom_parameters(p)
+          custom_parameters.merge!(p)
+        end
+
+        def self.recording_web_transaction?
+          c = Thread.current[:newrelic_metric_frame]
+          if c
+            c.recording_web_transaction?
+          end
+        end
+
+        def recording_web_transaction?
+          current_metric && current_metric.is_web_transaction?
+        end
+
+        def is_web_transaction?(metric)
+          0 == metric.index("Controller")
+        end
+
+        # Make a safe attempt to get the referer from a request object, generally successful when
+        # it's a Rack request.
+        def self.referer_from_request(request)
+          if request && request.respond_to?(:referer)
+            request.referer.to_s.split('?').first
+          end
+        end
+
+        # Make a safe attempt to get the URI, without the host and query string.
+        def self.uri_from_request(request)
+          approximate_uri = case
+                            when request.respond_to?(:fullpath) then request.fullpath
+                            when request.respond_to?(:path) then request.path
+                            when request.respond_to?(:request_uri) then request.request_uri
+                            when request.respond_to?(:uri) then request.uri
+                            when request.respond_to?(:url) then request.url
+                            end
+          return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri # '
+        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)
+          update_apdex(summary_stat, total_duration, is_error)
+          update_apdex(controller_stat, action_duration, is_error)
+        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 = NewRelic::Control.instance.apdex_t
+          case
+          when failed
+            stat.record_apdex_f
+          when duration <= apdex_t
+            stat.record_apdex_s
+          when duration <= 4 * apdex_t
+            stat.record_apdex_t
+          else
+            stat.record_apdex_f
+          end
+        end
+
+        private
+
+        def process_cpu
+          return nil if defined? JRuby
+          p = Process.times
+          p.stime + p.utime
+        end
+
+        def jruby_cpu_time # :nodoc:
+          return nil unless @@java_classes_loaded
+          threadMBean = ManagementFactory.getThreadMXBean()
+          java_utime = threadMBean.getCurrentThreadUserTime()  # ns
+          -1 == java_utime ? 0.0 : java_utime/1e9
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+DependencyDetection.defer do
+  @name = :net
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+  
+  executes do
+    NewRelic::Agent.logger.debug 'Installing Net instrumentation'
+  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)
+        end
+      end
+      alias request_without_newrelic_trace request
+      alias request request_with_newrelic_trace
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+DependencyDetection.defer do
+  @name = :passenger
+  
+  depends_on do
+    defined?(PhusionPassenger)
+  end
+
+  executes do
+    NewRelic::Agent.logger.debug "Installing Passenger event hooks."
+
+    PhusionPassenger.on_event(:stopping_worker_process) do
+      NewRelic::Agent.logger.debug "Passenger stopping this process, shutdown the agent."
+      NewRelic::Agent.instance.shutdown
+    end
+
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+      # We want to reset the stats from the stats engine in case any carried
+      # over into the spawned process.  Don't clear them in case any were
+      # cached.  We do this even in conservative spawning.
+      NewRelic::Agent.after_fork(:force_reconnect => true)
+    end
+  end
+end
+
+DependencyDetection.defer do
+  depends_on do
+    defined?(::Passenger) && defined?(::Passenger::AbstractServer) || defined?(::IN_PHUSION_PASSENGER)
+  end
+
+  executes do
+    # We're on an older version of passenger
+    NewRelic::Agent.logger.warn "An older version of Phusion Passenger has been detected.  We recommend using at least release 2.1.1."
+
+    NewRelic::Agent::Instrumentation::MetricFrame.check_server_connection = true
+  end
+end

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

@@ -0,0 +1,210 @@
+module NewRelic
+  module Agent
+    module Instrumentation
+      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)
+          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)
+        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)
+        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)
+          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} is less than #{start_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))
+        end
+      end
+    end
+  end
+end
+