newrelic_rpm 2.14.1 → 3.0.0.beta1

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

@@ -25,7 +25,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActsAsSolr::ParserMethods)
   end
-  
+
   depends_on do
     defined?(ActsAsSolr::ClassMethods)
   end
@@ -33,7 +33,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(ActsAsSolr::CommonMethods)
   end
-  
+
   executes do
     ActsAsSolr::ParserMethods.module_eval do
       include NewRelic::Instrumentation::ActsAsSolrInstrumentation::ParserMethodsInstrumentation
@@ -41,7 +41,7 @@ DependencyDetection.defer do
       alias :parse_query :parse_query_with_newrelic
     end
   end
-  
+
   executes do
     ActsAsSolr::ClassMethods.module_eval do
       %w[find_by_solr find_id_by_solr multi_solr_search count_by_solr].each do |method|

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

@@ -264,11 +264,7 @@ module NewRelic
             # Look for a metric frame in the thread local and process it.
             # Clear the thread local when finished to ensure it only gets called once.
             frame_data.record_apdex unless _is_filtered?('ignore_apdex')
-            
-            if Thread::current[:browser_request]
-              NewRelic::Agent.instance.stats_engine.get_stats_no_scope("HttpDispatcherWithBrowser").record_data_point(Time.now - frame_data.start)
-            end
-            
+
             frame_data.pop
           end
         end
@@ -387,10 +383,12 @@ module NewRelic
         # now is a Time instance to fall back on if no other candidate
         # for the start time is found.
         def _detect_upstream_wait(now)
+          queue_start = nil
           if newrelic_request_headers
-            parse_frontend_headers(newrelic_request_headers)
+            queue_start = parse_frontend_headers(newrelic_request_headers)
+            Thread.current[:newrelic_queue_time] = (now.to_f - queue_start.to_f) if queue_start
           end
-          now
+          queue_start || now
         rescue Exception => e
           NewRelic::Control.instance.log.error("Error detecting upstream wait time: #{e}")
           NewRelic::Control.instance.log.debug("#{e.backtrace[0..20]}")

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

@@ -53,7 +53,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(DataMapper::Collection)
   end
-  
+
   executes do
     DataMapper::Model.class_eval do
       add_method_tracer :get,      'ActiveRecord/#{self.name}/get'
@@ -117,13 +117,13 @@ DependencyDetection.defer do
 end
 
 DependencyDetection.defer do
-  
+
   depends_on do
     defined?(DataMapper) && defined?(DataMapper::Adapters) && defined?(DataMapper::Adapters::DataObjectsAdapter)
   end
-  
+
   executes do
-    
+
     # Catch the two entry points into DM::Repository::Adapter that bypass CRUD
     # (for when SQL is run directly).
     DataMapper::Adapters::DataObjectsAdapter.class_eval do
@@ -140,7 +140,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(DataMapper) && defined?(DataMapper::Validations) && defined?(DataMapper::Validations::ClassMethods)
   end
-  
+
   # DM::Validations overrides Model#create, but currently in a way that makes it
   # impossible to instrument from one place.  I've got a patch pending inclusion
   # to make it instrumentable by putting the create method inside ClassMethods.
@@ -158,7 +158,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(DataMapper) && defined?(DataMapper::Transaction)
   end
-  
+
   # NOTE: DM::Transaction basically calls commit() twice, so as-is it will show
   # up in traces twice -- second time subordinate to the first's scope.  Works
   # well enough.
@@ -219,11 +219,11 @@ module NewRelic
 end # NewRelic
 
 DependencyDetection.defer do
-  
+
   depends_on do
     defined?(DataObjects) && defined?(DataObjects::Connection)
   end
-  
+
   executes do
     DataObjects::Connection.class_eval do
       include ::NewRelic::Agent::Instrumentation::DataMapperInstrumentation

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

@@ -8,7 +8,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(::Delayed) && defined?(::Delayed::Job)
   end
-  
+
   executes do
     Delayed::Job.class_eval do
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation

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

@@ -11,7 +11,7 @@ module NewRelic
       module Memcache
         module_function
         def instrument_method(the_class, method_name)
-          return unless the_class.method_defined? method_name.to_sym          
+          return unless the_class.method_defined? method_name.to_sym
                      the_class.class_eval <<-EOD
                        def #{method_name}_with_newrelic_trace(*args)
                          metrics = ["MemCache/#{method_name}",

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -5,7 +5,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(Merb) && defined?(Merb::Controller)
   end
-  
+
   executes do
     require 'merb-core/controller/merb_controller'
 

data/lib/new_relic/agent/instrumentation/merb/errors.rb

@@ -18,6 +18,6 @@ DependencyDetection.defer do
     }
     Merb::Dispatcher::DefaultException.before error_notifier
     Exceptions.before error_notifier
-    
+
   end
 end

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

@@ -138,6 +138,7 @@ module NewRelic
               NewRelic::Agent.instance.transaction_sampler.notice_scope_empty
             end
             NewRelic::Agent.instance.stats_engine.end_transaction
+            Thread.current[:newrelic_start_time] = (Thread.current[:newrelic_metric_frame].start rescue nil)
             Thread.current[:newrelic_metric_frame] = nil
           else # path stack not empty
             # change the transaction name back to whatever was on the stack.

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

@@ -9,7 +9,7 @@ module NewRelic
           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/'
@@ -24,24 +24,22 @@ module NewRelic
           # 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(current_time, env)
-          parse_middleware_time_from(env)
-          parse_queue_time_from(env)
-          parse_server_time_from(env)
+          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
-        
-        def current_time
-          Time.now
-        end
-        
+
         # 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
@@ -51,30 +49,31 @@ module NewRelic
           matches = get_matches_from_header(MIDDLEWARE_HEADER, env)
 
           record_individual_middleware_stats(end_time, matches)
-          record_rollup_middleware_stat(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(find_oldest_time(matches), env)
+          add_end_time_header(oldest_time, env)
+          oldest_time
         end
 
         def parse_queue_time_from(env)
-          first_time = nil          
+          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)
-            first_time = (end_time - alternate_length) # should be a time
+            oldest_time = (end_time - alternate_length) # should be a time
           else
             matches = get_matches_from_header(QUEUE_HEADER, env)
-            record_rollup_queue_stat(end_time, matches)
-            first_time = find_oldest_time(matches)
+            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(first_time, env)
+          add_end_time_header(oldest_time, env)
+          oldest_time
         end
 
         def check_for_alternate_queue_length(env)
@@ -115,7 +114,7 @@ module NewRelic
             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.
@@ -132,7 +131,7 @@ module NewRelic
         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)
@@ -147,17 +146,18 @@ module NewRelic
         end
 
         def record_rollup_stat_of_type(metric, end_time, matches)
-          first_time = find_oldest_time(matches) || end_time
-          record_time_stat(metric, first_time, end_time)
+          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
@@ -195,7 +195,7 @@ module NewRelic
           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

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

@@ -24,7 +24,7 @@ DependencyDetection.defer do
       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

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

@@ -6,7 +6,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(Rails) && Rails::VERSION::MAJOR.to_i == 2
   end
-  
+
   executes do
 
     ActionController::Base.class_eval do

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

@@ -45,11 +45,11 @@ DependencyDetection.defer do
   depends_on do
     defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
   end
-  
+
   depends_on do
     defined?(ActionController) && defined?(ActionController::Base)
   end
-  
+
   executes do
     class ActionController::Base
       include NewRelic::Agent::Instrumentation::ControllerInstrumentation

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

@@ -4,7 +4,7 @@ DependencyDetection.defer do
   depends_on do
     defined?(::Sinatra) && defined?(::Sinatra::Base)
   end
-  
+
   executes do
     ::Sinatra::Base.class_eval do
       include NewRelic::Agent::Instrumentation::Sinatra

data/lib/new_relic/agent/method_tracer.rb

@@ -92,7 +92,7 @@ module NewRelic
         end
 
         alias trace_method_execution_no_scope trace_execution_unscoped #:nodoc:
-        
+
         module TraceExecutionScoped
           def agent_instance
             NewRelic::Agent.instance
@@ -101,7 +101,7 @@ module NewRelic
           def traced?
             NewRelic::Agent.is_execution_traced?
           end
-          
+
           def trace_disabled?(options)
             !(traced? || options[:force])
           end
@@ -120,7 +120,7 @@ module NewRelic
           def main_stat(metric, options)
             get_stats_scoped(metric, options[:scoped_metric_only])
           end
-          
+
           def get_metric_stats(metrics, options)
             metrics = Array(metrics)
             first_name = metrics.shift
@@ -146,8 +146,8 @@ module NewRelic
           def log_errors(code_area, metric)
             yield
           rescue => e
-            log.error("Caught exception in #{code_area}. Metric name = #{metric}, exception = #{e}")
-            log.error(e.backtrace.join("\n"))
+            NewRelic::Control.instance.log.error("Caught exception in #{code_area}. Metric name = #{metric}, exception = #{e}")
+            NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
           end
 
           def trace_execution_scoped_header(metric, options, t0=Time.now.to_f)
@@ -163,7 +163,7 @@ module NewRelic
           def trace_execution_scoped_footer(t0, first_name, metric_stats, expected_scope, forced, t1=Time.now.to_f)
             log_errors("trace_method_execution footer", first_name) do
               duration = t1 - t0
-              
+
               pop_flag!(forced)
               if expected_scope
                 scope = stat_engine.pop_scope(expected_scope, duration, t1)
@@ -195,7 +195,7 @@ module NewRelic
               trace_execution_scoped_footer(start_time, first_name, metric_stats, expected_scope, options[:force])
             end
           end
-          
+
         end
         include TraceExecutionScoped
 
@@ -274,11 +274,11 @@ module NewRelic
 
         module AddMethodTracer
           ALLOWED_KEYS = [:force, :metric, :push_scope, :deduct_call_time_from_parent, :code_header, :code_footer, :scoped_metric_only].freeze
-          
+
           def unrecognized_keys(expected, given)
             given.keys - expected
           end
-          
+
           def any_unrecognized_keys?(expected, given)
             unrecognized_keys(expected, given).any?
           end
@@ -288,7 +288,7 @@ module NewRelic
               raise "Unrecognized options in add_method_tracer_call: #{unrecognized_keys(ALLOWED_KEYS, options).join(', ')}"
             end
           end
-          
+
           def set_deduct_call_time_based_on_metric(options)
             {:deduct_call_time_from_parent => !!options[:metric]}.merge(options)
           end
@@ -300,7 +300,7 @@ module NewRelic
           end
 
           DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :force => false, :code_header => "", :code_footer => "", :scoped_metric_only => false}.freeze
-          
+
           def validate_options(options)
             raise TypeError.new("provided options must be a Hash") unless options.is_a?(Hash)
             check_for_illegal_keys!(options)
@@ -308,12 +308,12 @@ module NewRelic
             check_for_push_scope_and_metric(options)
             options
           end
-          
+
           # Default to the class where the method is defined.
           def default_metric_name_code(method_name)
             "Custom/#{self.name}/#{method_name.to_s}"
           end
-          
+
           def method_exists?(method_name)
             exists = method_defined?(method_name) || private_method_defined?(method_name)
             NewRelic::Control.instance.log.warn("Did not trace #{self.name}##{method_name} because that method does not exist") unless exists
@@ -380,10 +380,10 @@ module NewRelic
         def add_method_tracer(method_name, metric_name_code=nil, options = {})
           return unless method_exists?(method_name)
           metric_name_code ||= default_metric_name_code(method_name)
-          return if traced_method_exists?(method_name, metric_name_code)          
+          return if traced_method_exists?(method_name, metric_name_code)
 
           traced_method = code_to_eval(method_name, metric_name_code, options)
-          
+
           class_eval traced_method, __FILE__, __LINE__
           alias_method _untraced_method_name(method_name, metric_name_code), method_name
           alias_method method_name, _traced_method_name(method_name, metric_name_code)

data/lib/new_relic/agent/shim_agent.rb

@@ -20,6 +20,8 @@ module NewRelic
       def shutdown; end
       def push_trace_execution_flag(*args); end
       def pop_trace_execution_flag(*args); end
+      def browser_timing_header; "" end
+      def browser_timing_footer; "" end
     end
   end
 end