newrelic_rpm 2.13.0.beta5 → 2.13.1

data/lib/new_relic/agent/stats_engine/transactions.rb

@@ -1,10 +1,10 @@
 module NewRelic
 module Agent
   class StatsEngine
-        
+
     # Defines methods that stub out the stats engine methods
     # when the agent is disabled
-    
+
     class ScopeStackElement
       attr_reader :name, :deduct_call_time_from_parent
       attr_accessor :children_time
@@ -14,7 +14,7 @@ module Agent
         @children_time = 0
       end
     end
-    
+
     module Transactions
       module Shim # :nodoc:
         def start_transaction(*args); end
@@ -25,18 +25,18 @@ module Agent
         def scope_name; end
         def pop_scope(*args); end
       end
-      
+
       def transaction_sampler= sampler
         fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
         @transaction_sampler = sampler
       end
-      
+
       def remove_transaction_sampler(l)
         @transaction_sampler = nil
       end
-      
+
       def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
-        
+
         stack = scope_stack
         if collecting_gc?
           if stack.empty?
@@ -52,14 +52,14 @@ module Agent
         stack.push scope
         scope
       end
-      
+
       def pop_scope(expected_scope, duration, time=Time.now.to_f)
         capture_gc_time if collecting_gc?
         stack = scope_stack
         scope = stack.pop
         fail "unbalanced pop from blame stack, got #{scope ? scope.name : 'nil'}, expected #{expected_scope ? expected_scope.name : 'nil'}" if scope != expected_scope
-        
-        if !stack.empty? 
+
+        if !stack.empty?
           if scope.deduct_call_time_from_parent
             stack.last.children_time += duration
           else
@@ -69,53 +69,53 @@ module Agent
         @transaction_sampler.notice_pop_scope(scope.name, time) if @transaction_sampler
         scope
       end
-      
+
       def peek_scope
         scope_stack.last
       end
-      
+
       # set the name of the transaction for the current thread, which will be used
       # to define the scope of all traced methods called on this thread until the
-      # scope stack is empty.  
+      # scope stack is empty.
       #
-      # currently the transaction name is the name of the controller action that 
+      # currently the transaction name is the name of the controller action that
       # is invoked via the dispatcher, but conceivably we could use other transaction
       # names in the future if the traced application does more than service http request
       # via controller actions
       def scope_name=(transaction)
         Thread::current[:newrelic_scope_name] = transaction
       end
-      
+
       def scope_name
         Thread::current[:newrelic_scope_name]
       end
-      
+
       # Start a new transaction, unless one is already in progress
       def start_transaction(name = nil)
         Thread::current[:newrelic_scope_stack] ||= []
         self.scope_name = name if name
       end
-      
+
       # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
       # If it looks like a transaction is still in progress, then maybe this is an inner transaction
       # and is ignored.
       #
       def end_transaction
         stack = scope_stack
-        
+
         if stack && stack.empty?
           Thread::current[:newrelic_scope_stack] = nil
           Thread::current[:newrelic_scope_name] = nil
         end
       end
-      
+
       private
-      
+
       # Make sure we don't do this in a multi-threaded environment
       def collecting_gc?
-        @@collecting_gc ||= GC.respond_to?(:time) && GC.respond_to?(:collections) && !NewRelic::Control.instance.multi_threaded?  
+        @@collecting_gc ||= GC.respond_to?(:time) && GC.respond_to?(:collections) && !NewRelic::Control.instance.multi_threaded?
       end
-      
+
       # Assumes collecting_gc?
       def capture_gc_time
         # Skip this if we are already in this segment
@@ -133,16 +133,16 @@ module Agent
           gc_scope = push_scope("GC/cumulative", time - elapsed)
           # GC stats are collected into a blamed metric which allows
           # us to show the stats controller by controller
-          gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)  
+          gc_stats = NewRelic::Agent.get_stats(gc_scope.name, true)
           gc_stats.record_multiple_data_points(elapsed, num_calls)
           pop_scope(gc_scope, elapsed, time)
         end
       end
-      
+
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []
       end
-      
+
     end
   end
 end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,8 +1,8 @@
 module NewRelic
 module Agent
-  
+
   class TransactionSampler
-    
+
     # Module defining methods stubbed out when the agent is disabled
     module Shim #:nodoc:
       def notice_first_scope_push(*args); end
@@ -10,12 +10,12 @@ module Agent
       def notice_pop_scope(*args); end
       def notice_scope_empty(*args); end
     end
-    
+
     BUILDER_KEY = :transaction_sample_builder
 
     attr_accessor :stack_trace_threshold, :random_sampling, :sampling_rate
     attr_reader :samples, :last_sample, :disabled
-    
+
     def initialize
       @samples = []
       @harvest_count = 0
@@ -27,7 +27,7 @@ module Agent
       @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
       @samples_lock = Mutex.new
     end
-    
+
     def current_sample_id
       b=builder
       b and b.sample_id
@@ -42,22 +42,22 @@ module Agent
       @disabled = true
       NewRelic::Agent.instance.stats_engine.remove_transaction_sampler self
     end
-    
+
     def sampling_rate=(val)
       @sampling_rate = val
       @harvest_count = rand(val)
     end
-    
+
     def notice_first_scope_push(time)
       start_builder(time.to_f) unless disabled
     end
-    
-    def notice_push_scope(scope, time=Time.now.to_f)
-      
+
+    def notice_push_scope(scope, time=Time.now)
+
       return unless builder
-      
-      builder.trace_entry(scope, time)
-      
+
+      builder.trace_entry(scope, time.to_f)
+
       # in developer mode, capture the stack trace with the segment.
       # this is cpu and memory expensive and therefore should not be
       # turned on in production mode
@@ -69,66 +69,66 @@ module Agent
           while trace.first =~/\/lib\/new_relic\/agent\//
             trace.shift
           end
-          
+
           trace = trace[0..39] if trace.length > 40
           segment[:backtrace] = trace
         end
       end
     end
-    
+
     def scope_depth
       return 0 unless builder
 
       builder.scope_depth
     end
-  
-    def notice_pop_scope(scope, time = Time.now.to_f)
+
+    def notice_pop_scope(scope, time = Time.now)
       return unless builder
       raise "frozen already???" if builder.sample.frozen?
-      builder.trace_exit(scope, time)
+      builder.trace_exit(scope, time.to_f)
     end
-    
+
     # This is called when we are done with the transaction.  We've
     # unwound the stack to the top level.
-    def notice_scope_empty(time=Time.now.to_f)
-      
+    def notice_scope_empty(time=Time.now)
+
       last_builder = builder
       return unless last_builder
 
-      last_builder.finish_trace(time)
+      last_builder.finish_trace(time.to_f)
       clear_builder
       return if last_builder.ignored?
-    
+
       @samples_lock.synchronize do
         @last_sample = last_builder.sample
-        
+
         @random_sample = @last_sample if @random_sampling
-        
+
         # ensure we don't collect more than a specified number of samples in memory
         @samples << @last_sample if NewRelic::Control.instance.developer_mode?
         @samples.shift while @samples.length > @max_samples
-        
+
         if @slowest_sample.nil? || @slowest_sample.duration < @last_sample.duration
           @slowest_sample = @last_sample
         end
       end
     end
-    
+
     def notice_transaction(path, uri=nil, params={})
       builder.set_transaction_info(path, uri, params) if !disabled && builder
     end
-    
+
     def ignore_transaction
       builder.ignore_transaction if builder
     end
     def notice_profile(profile)
       builder.set_profile(profile) if builder
     end
-    
+
     def notice_transaction_cpu_time(cpu_time)
       builder.set_transaction_cpu_time(cpu_time) if builder
     end
-    
+
     MAX_DATA_LENGTH = 16384
     # duration is seconds, float value.
     def notice_extra_data(message, duration, key, config=nil, config_key=nil)
@@ -148,7 +148,7 @@ module Agent
     end
 
     private :notice_extra_data
-        
+
     # some statements (particularly INSERTS with large BLOBS
     # may be very large; we should trim them to a maximum usable length
     # config is the driver configuration for the connection
@@ -164,34 +164,34 @@ module Agent
     def notice_nosql(key, duration)
       notice_extra_data(key, duration, :key)
     end
-    
+
     # get the set of collected samples, merging into previous samples,
-    # and clear the collected sample list. 
-    
+    # and clear the collected sample list.
+
     def harvest(previous = nil, slow_threshold = 2.0)
       return [] if disabled
       result = []
       previous ||= []
-      
+
       previous = [previous] unless previous.is_a?(Array)
-      
+
       previous_slowest = previous.inject(nil) {|a,ts| (a) ? ((a.duration > ts.duration) ? a : ts) : ts}
-      
+
       @samples_lock.synchronize do
-        
-        if @random_sampling        
+
+        if @random_sampling
           @harvest_count += 1
-          
+
           if (@harvest_count % @sampling_rate) == 0
             result << @random_sample if @random_sample
           else
             @random_sample = nil   # if we don't nil this out, then we won't send the slowest if slowest == @random_sample
           end
         end
-        
+
         slowest = @slowest_sample
         @slowest_sample = nil
-        
+
         if slowest && slowest != @random_sample && slowest.duration >= slow_threshold
           if previous_slowest.nil? || previous_slowest.duration < slowest.duration
             result << slowest
@@ -215,13 +215,13 @@ module Agent
       @last_sample = nil
     end
 
-    private 
-    
+    private
+
       def start_builder(time=nil)
         if disabled || Thread::current[:record_tt] == false || !NewRelic::Agent.is_execution_traced?
           clear_builder
         else
-          Thread::current[BUILDER_KEY] ||= TransactionSampleBuilder.new(time) 
+          Thread::current[BUILDER_KEY] ||= TransactionSampleBuilder.new(time)
         end
       end
       def builder
@@ -230,7 +230,7 @@ module Agent
       def clear_builder
         Thread::current[BUILDER_KEY] = nil
       end
-      
+
   end
 
   # a builder is created with every sampled transaction, to dynamically
@@ -238,13 +238,12 @@ module Agent
   # accessed by any other thread so no need for synchronization.
   class TransactionSampleBuilder
     attr_reader :current_segment, :sample
-    
+
     include NewRelic::CollectionHelper
-    
-    def initialize(time=nil)
-      time ||= Time.now.to_f
-      @sample = NewRelic::TransactionSample.new(time)
-      @sample_start = time
+
+    def initialize(time=Time.now)
+      @sample = NewRelic::TransactionSample.new(time.to_f)
+      @sample_start = time.to_f
       @current_segment = @sample.root_segment
     end
 
@@ -252,13 +251,13 @@ module Agent
       @sample.sample_id
     end
     def ignored?
-      @ignore || @sample.params[:path].nil? 
+      @ignore || @sample.params[:path].nil?
     end
     def ignore_transaction
       @ignore = true
     end
     def trace_entry(metric_name, time)
-      segment = @sample.create_segment(time - @sample_start, metric_name)
+      segment = @sample.create_segment(time.to_f - @sample_start, metric_name)
       @current_segment.add_called_segment(segment)
       @current_segment = segment
     end
@@ -267,10 +266,10 @@ module Agent
       if metric_name != @current_segment.metric_name
         fail "unbalanced entry/exit: #{metric_name} != #{@current_segment.metric_name}"
       end
-      @current_segment.end_trace(time - @sample_start)
+      @current_segment.end_trace(time.to_f - @sample_start)
       @current_segment = @current_segment.parent_segment
     end
-    
+
     def finish_trace(time)
       # This should never get called twice, but in a rare case that we can't reproduce in house it does.
       # log forensics and return gracefully
@@ -279,53 +278,53 @@ module Agent
         log.error "Unexpected double-freeze of Transaction Trace Object: \n#{@sample.to_s}"
         return
       end
-      @sample.root_segment.end_trace(time - @sample_start)
+      @sample.root_segment.end_trace(time.to_f - @sample_start)
       @sample.params[:custom_params] = normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters)
       @sample.freeze
       @current_segment = nil
     end
-    
+
     def scope_depth
       depth = -1        # have to account for the root
       current = @current_segment
-      
+
       while(current)
         depth += 1
         current = current.parent_segment
       end
-      
+
       depth
     end
-    
+
     def freeze
       @sample.freeze unless sample.frozen?
     end
-    
+
     def set_profile(profile)
       @sample.profile = profile
     end
-    
+
     def set_transaction_info(path, uri, params)
       @sample.params[:path] = path
-      
+
       if NewRelic::Control.instance.capture_params
         params = normalize_params params
-        
+
         @sample.params[:request_params].merge!(params)
         @sample.params[:request_params].delete :controller
         @sample.params[:request_params].delete :action
       end
-      @sample.params[:uri] ||= uri || params[:uri] 
+      @sample.params[:uri] ||= uri || params[:uri]
     end
-    
+
     def set_transaction_cpu_time(cpu_time)
       @sample.params[:cpu_time] = cpu_time
     end
-    
+
     def sample
       @sample
     end
-    
+
   end
 end
 end