sundawg_newrelic_rpm 3.5.8.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,31 @@
+# encoding: utf-8
+
+DependencyDetection.defer do
+  @name = :net
+
+  depends_on do
+    defined?(Net) && defined?(Net::HTTP)
+  end
+  
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
+    require 'new_relic/agent/cross_app_tracing'
+  end
+
+  executes do
+    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/passenger_instrumentation.rb

@@ -0,0 +1,23 @@
+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

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

@@ -0,0 +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?(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
+
+          earliest
+        end
+
+        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 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)
+          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/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 its 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

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

@@ -0,0 +1,114 @@
+DependencyDetection.defer do
+  @name = :rails21_view
+  
+  depends_on do
+    !NewRelic::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
+    ::NewRelic::Agent.logger.info 'Installing Rails 2.1 View instrumentation'
+  end
+
+  executes do
+    ActionView::PartialTemplate.class_eval do
+      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
+      add_method_tracer :render, 'View/#{(path_without_extension || @view.controller.newrelic_metric_path)[%r{^(/.*/)?(.*)$},2]}.#{@view.template_format}.#{extension}/Rendering'
+    end
+  end
+end
+
+DependencyDetection.defer do
+  @name = :old_rails_view
+  
+  depends_on do
+    !NewRelic::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
+    ::NewRelic::Agent.logger.info 'Installing Rails 1.* - 2.0 View instrumentation'
+  end
+  
+  executes do
+    ActionController::Base.class_eval do
+      add_method_tracer :render, 'View/#{newrelic_metric_path}/Rendering'
+    end
+    
+  end
+end
+
+DependencyDetection.defer do
+  @name = :rails23_view
+  
+  depends_on do
+    !NewRelic::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
+    ::NewRelic::Agent.logger.info 'Installing Rails 2.2 - 2.3 View instrumentation'
+  end
+  
+  executes do    
+    ActionView::RenderablePartial.module_eval do
+      add_method_tracer :render_partial, 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Partial'
+    end
+    ActionView::Template.class_eval do
+      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
+    ::NewRelic::Agent.logger.info 'Installing Rails 2 Controller instrumentation'
+  end
+  
+  executes do
+    ActionController::Base.class_eval do
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+      
+      # Compare with #alias_method_chain, which is not available in
+      # Rails 1.1:
+      alias_method :perform_action_without_newrelic_trace, :perform_action
+      alias_method :perform_action, :perform_action_with_newrelic_trace
+      private :perform_action
+      
+      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
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/rails/action_web_service.rb

@@ -0,0 +1,42 @@
+DependencyDetection.defer do
+  @name = :rails_action_web_service
+  
+  depends_on do
+    defined?(ActionWebService)
+  end
+  
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Rails ActionWebService instrumentation'
+  end  
+  
+  executes do
+    # NewRelic 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