wd_newrelic_rpm 3.3.4.1

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/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,37 @@
+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
+    ## FIXME: This warning is printing on current 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.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))
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,98 @@
+require 'new_relic/agent/instrumentation/controller_instrumentation'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      # == Instrumentation for Rack
+      #
+      # New Relic will instrument a #call method as if it were a controller
+      # action, collecting transaction traces and errors.  The middleware will
+      # be identified only by it's class, so if you want to instrument multiple
+      # actions in a middleware, you need to use
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
+      #
+      # Example:
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/rack'
+      #   class Middleware
+      #     def call(env)
+      #       ...
+      #     end
+      #     # Do the include after the call method is defined:
+      #     include NewRelic::Agent::Instrumentation::Rack
+      #   end
+      #
+      # == Instrumenting Metal and Cascading Middlewares
+      #
+      # Metal apps and apps belonging to Rack::Cascade middleware
+      # follow a convention of returning a 404 for all requests except
+      # the ones they are set up to handle.  This means that New Relic
+      # needs to ignore these calls when they return a 404.
+      #
+      # In these cases, you should not include or extend the Rack
+      # module but instead include
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation.
+      # Here's how that might look for a Metal app:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class MetalApp
+      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def self.call(env)
+      #       if should_do_my_thing?
+      #         perform_action_with_newrelic_trace(:category => :rack) do
+      #           return my_response(env)
+      #         end
+      #       else
+      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+      #       end
+      #     end
+      #   end
+      #
+      # == Overriding the metric name
+      #
+      # By default the middleware is identified only by its class, but if you want to
+      # be more specific and pass in name, then omit including the Rack instrumentation
+      # and instead follow this example:
+      #
+      #   require 'newrelic_rpm'
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
+      #   class Middleware
+      #     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      #     def call(env)
+      #       ...
+      #     end
+      #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
+      #   end
+      #
+      module Rack
+        def newrelic_request_headers
+          @newrelic_request.env
+        end
+        def call_with_newrelic(*args)
+          @newrelic_request = ::Rack::Request.new(args.first)
+          perform_action_with_newrelic_trace(:category => :rack, :request => @newrelic_request) do
+            result = call_without_newrelic(*args)
+            # Ignore cascaded calls
+            MetricFrame.abort_transaction! if result.first == 404
+            result
+          end
+        end
+        def self.included middleware #:nodoc:
+          middleware.class_eval do
+            alias call_without_newrelic call
+            alias call call_with_newrelic
+          end
+        end
+        include ControllerInstrumentation
+        def self.extended middleware #:nodoc:
+          middleware.class_eval do
+            class << self
+              alias call_without_newrelic call
+              alias call call_with_newrelic
+            end
+          end
+        end
+      end
+    end
+  end
+end