newrelic_rpm 3.4.2.1 → 3.5.0

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

@@ -12,7 +12,7 @@ module NewRelic
         def self.capture
           @profiler.capture if @profiler
         end
-        
+
         class Profiler
           def initialize
             if self.class.enabled?
@@ -20,55 +20,52 @@ module NewRelic
               @last_count = call_count
             end
           end
-          
+
           def capture
             return unless self.class.enabled?
             return if !scope_stack.empty? && scope_stack.last.name == "GC/cumulative"
-            
+
             num_calls = call_count - @last_count
-            elapsed = (call_time - @last_timestamp).to_f
+            # microseconds to seconds
+            elapsed = (call_time - @last_timestamp).to_f / 1_000_000.0
             @last_timestamp = call_time
             @last_count = call_count
             reset
-            
+
             record_gc_metric(num_calls, elapsed)
+            elapsed
           end
 
           def reset; end
-          
+
           protected
-                    
+
           def record_gc_metric(num_calls, elapsed)
             if num_calls > 0
-              # microseconds to seconds
-              elapsed = elapsed / 1_000_000.0
-              # Allocate the GC time to a scope as if the GC just ended
-              # right now.
-              time = Time.now.to_f
-              gc_scope = NewRelic::Agent.instance.stats_engine.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.instance.stats_engine \
+                .get_stats('GC/cumulative', true, false,
+                           NewRelic::Agent::TransactionInfo.get.transaction_name)
               gc_stats.record_multiple_data_points(elapsed, num_calls)
-              NewRelic::Agent.instance.stats_engine.pop_scope(gc_scope, elapsed, time)
             end
           end
 
           def scope_stack
             Thread::current[:newrelic_scope_stack] ||= []
-          end        
+          end
         end
-        
+
         class RailsBench < Profiler
           def self.enabled?
             ::GC.respond_to?(:time) && ::GC.respond_to?(:collections)
           end
-          
+
           # microseconds spent in GC
           def call_time
             ::GC.time # this should already be microseconds
           end
-          
+
           def call_count
             ::GC.collections
           end
@@ -77,22 +74,22 @@ module NewRelic
             ::GC.clear_stats
           end
         end
-        
+
         class Ruby19 < Profiler
           def self.enabled?
             defined?(::GC::Profiler) && ::GC::Profiler.enabled?
           end
-          
+
           # microseconds spent in GC
           # 1.9 total_time returns seconds.  Don't trust the docs.  It's seconds.
           def call_time
             ::GC::Profiler.total_time * 1_000_000.0 # convert seconds to microseconds
           end
-          
+
           def call_count
             ::GC.count
           end
-          
+
           def reset
             ::GC::Profiler.clear
             @last_timestamp = 0
@@ -119,7 +116,7 @@ module NewRelic
             agent = ::Rubinius::Agent.loopback
             agent.get('system.gc.young.count')[1] +
               agent.get('system.gc.full.count')[1]
-          end          
+          end
         end
       end
     end

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

@@ -13,11 +13,11 @@ module Agent
         @children_time = 0
       end
     end
-    
+
     # Handles pushing and popping elements onto an internal stack that
     # tracks where time should be allocated in Transaction Traces
     module Transactions
-      
+
       # Defines methods that stub out the stats engine methods
       # when the agent is disabled
       module Shim # :nodoc:
@@ -29,34 +29,32 @@ module Agent
         def scope_name; end
         def pop_scope(*args); end
       end
-      
+
       # add a new transaction sampler, unless we're currently in a
       # transaction (then we fail)
       def transaction_sampler= sampler
         fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
         @transaction_sampler = sampler
       end
-      
+
       # removes a transaction sampler
       def remove_transaction_sampler(l)
         @transaction_sampler = nil
       end
-      
+
       # Pushes a scope onto the transaction stack - this generates a
       # TransactionSample::Segment at the end of transaction execution
       def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
         stack = scope_stack
-        stack.empty? ? GCProfiler.init : GCProfiler.capture
-        @transaction_sampler.notice_push_scope metric, time if @transaction_sampler
+        @transaction_sampler.notice_push_scope metric, time if sampler_enabled?
         scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
         stack.push scope
         scope
       end
-      
+
       # Pops a scope off the transaction stack - this updates the
       # transaction sampler that we've finished execution of a traced method
       def pop_scope(expected_scope, duration, time=Time.now.to_f)
-        GCProfiler.capture
         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
@@ -68,10 +66,14 @@ module Agent
             stack.last.children_time += scope.children_time
           end
         end
-        @transaction_sampler.notice_pop_scope(scope.name, time) if @transaction_sampler
+        @transaction_sampler.notice_pop_scope(scope.name, time) if sampler_enabled?
         scope
       end
       
+      def sampler_enabled?
+        @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
+      end
+      
       # Returns the latest ScopeStackElement
       def peek_scope
         scope_stack.last
@@ -88,7 +90,7 @@ module Agent
       def scope_name=(transaction)
         Thread::current[:newrelic_scope_name] = transaction
       end
-      
+
       # Returns the current scope name from the thread local
       def scope_name
         Thread::current[:newrelic_scope_name]
@@ -98,6 +100,7 @@ module Agent
       def start_transaction(name = nil)
         Thread::current[:newrelic_scope_stack] ||= []
         self.scope_name = name if name
+        GCProfiler.init
       end
 
       # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
@@ -105,6 +108,11 @@ module Agent
       # and is ignored.
       #
       def end_transaction
+        elapsed = GCProfiler.capture
+        if @transaction_sampler && @transaction_sampler.last_sample
+          @transaction_sampler.last_sample.params[:custom_params] ||= {}
+          @transaction_sampler.last_sample.params[:custom_params][:gc_time] = elapsed
+        end
         stack = scope_stack
 
         if stack && stack.empty?
@@ -114,7 +122,7 @@ module Agent
       end
 
       private
-      
+
       # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
         Thread::current[:newrelic_scope_stack] ||= []

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -61,8 +61,9 @@ module NewRelic
           return
         end
         @sample.root_segment.end_trace(time.to_f - @sample_start)
-        @sample.params[:custom_params] = normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters)
-        
+        @sample.params[:custom_params] ||= {}
+        @sample.params[:custom_params].merge!(normalize_params(NewRelic::Agent::Instrumentation::MetricFrame.custom_parameters))
+
         @sample.force_persist = NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
         @sample.freeze
         @current_segment = nil
@@ -102,7 +103,8 @@ module NewRelic
       end
 
       def set_transaction_cpu_time(cpu_time)
-        @sample.params[:cpu_time] = cpu_time
+        @sample.params[:custom_params] ||= {}
+        @sample.params[:custom_params][:cpu_time] = cpu_time
       end
 
       def sample

data/lib/new_relic/agent/transaction_sampler.rb

@@ -20,7 +20,6 @@ module NewRelic
       BUILDER_KEY = :transaction_sample_builder
 
       attr_accessor :random_sampling, :sampling_rate
-      attr_accessor :explain_threshold, :explain_enabled, :transaction_threshold
       attr_accessor :slow_capture_threshold
       attr_reader :samples, :last_sample, :disabled
 
@@ -36,53 +35,41 @@ module NewRelic
         # sampling - we pull 1 @random_sample in every @sampling_rate harvests
         @harvest_count = 0
         @random_sample = nil
-        @sampling_rate = 10
-        @slow_capture_threshold = 2.0
-        configure!
+        @sampling_rate = Agent.config[:sample_rate]
 
         # This lock is used to synchronize access to the @last_sample
         # and related variables. It can become necessary on JRuby or
         # any 'honest-to-god'-multithreaded system
         @samples_lock = Mutex.new
-      end
 
-      def configure!
-        # @segment_limit and @stack_trace_threshold come from the
-        # configuration file, with built-in defaults that should
-        # suffice for most customers
-        @explain_threshold     = Agent.config[:'transaction_tracer.explain_threshold']
-        @explain_enabled       = Agent.config[:'transaction_tracer.explain_enabled']
-        @transaction_threshold = Agent.config[:'transaction_tracer.transation_threshold']
+        Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
+          if enabled
+            threshold = Agent.config[:'transaction_tracer.transaction_threshold']
+            log.debug "Transaction tracing threshold is #{threshold} seconds."
+          else
+            log.debug "Transaction traces will not be sent to the New Relic service."
+          end
+        end
 
-        # Configure the sample storage policy.  Create a list of methods to be called.
-        @store_sampler_methods = [ :store_random_sample, :store_slowest_sample ]
-        if Agent.config[:developer_mode]
-          @store_sampler_methods << :store_sample_for_developer_mode
+        Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
+          if config == 'raw'
+            log.warn("Agent is configured to send raw SQL to the service")
+          end
         end
       end
 
+      def log
+        NewRelic::Control.instance.log
+      end
+
       # Returns the current sample id, delegated from `builder`
       def current_sample_id
         b=builder
         b and b.sample_id
       end
 
-      # Enable the transaction sampler - this also registers it with
-      # the statistics engine.
-      def enable
-        @disabled = false
-        NewRelic::Agent.instance.stats_engine.transaction_sampler = self
-      end
-
-      # Disable the transaction sampler - this also deregisters it
-      # with the statistics engine.
-      def disable
-        @disabled = true
-        NewRelic::Agent.instance.stats_engine.remove_transaction_sampler(self)
-      end
-
       def enabled?
-        !@disabled
+        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
       end
 
       # Set with an integer value n, this takes one in every n
@@ -98,7 +85,7 @@ module NewRelic
       # transaction sampler is disabled. Takes a time parameter for
       # the start of the transaction sample
       def notice_first_scope_push(time)
-        start_builder(time.to_f) unless disabled
+        start_builder(time.to_f) if enabled?
       end
 
       # This delegates to the builder to create a new open transaction
@@ -177,20 +164,26 @@ module NewRelic
       # @samples array, and the @slowest_sample variable if it is
       # slower than the current occupant of that slot
       def store_sample(sample)
-        @store_sampler_methods.each{|sym| send sym, sample}
+        sampler_methods = [ :store_slowest_sample ]
+        if Agent.config[:developer_mode]
+          sampler_methods << :store_sample_for_developer_mode
+        end
+        if Agent.config[:'transaction_tracer.random_sample']
+          sampler_methods << :store_random_sample
+        end
+
+        sampler_methods.each{|sym| send(sym, sample) }
+
         if NewRelic::Agent::TransactionInfo.get.force_persist_sample?(sample)
           store_force_persist(sample)
         end
-
       end
 
       # Only active when random sampling is true - this is very rarely
       # used. Always store the most recent sample so that random
       # sampling can pick a few of the samples to store, upon harvest
       def store_random_sample(sample)
-        if @random_sampling
-          @random_sample = sample
-        end
+        @random_sample = sample if Agent.config[:'transaction_tracer.random_sample']
       end
 
       def store_force_persist(sample)
@@ -237,7 +230,7 @@ module NewRelic
       # Delegates to the builder to store the path, uri, and
       # parameters if the sampler is active
       def notice_transaction(path, uri=nil, params={})
-        builder.set_transaction_info(path, uri, params) if !disabled && builder
+        builder.set_transaction_info(path, uri, params) if enabled? && builder
       end
 
       # Tells the builder to ignore a transaction, if we are currently
@@ -337,9 +330,10 @@ module NewRelic
       #
       # random sampling is very, very seldom used
       def add_random_sample_to(result)
-        return unless @random_sampling && @sampling_rate && @sampling_rate.to_i > 0
+        return unless @random_sample &&
+          Agent.config[:sample_rate] && Agent.config[:sample_rate].to_i > 0
         @harvest_count += 1
-        if (@harvest_count.to_i % @sampling_rate.to_i) == 0
+        if (@harvest_count.to_i % Agent.config[:sample_rate].to_i) == 0
           result << @random_sample if @random_sample
           @harvest_count = 0
         end
@@ -355,7 +349,7 @@ module NewRelic
       # elements - one element unless random sampling is enabled. The
       # sample returned will be the slowest sample among those
       # available during this harvest
-      def add_samples_to(result, slow_threshold)
+      def add_samples_to(result)
         # pull out force persist
         force_persist = result.select {|sample| sample.force_persist} || []
         result.reject! {|sample| sample.force_persist}
@@ -364,7 +358,9 @@ module NewRelic
 
 
         # Now get the slowest sample
-        if @slowest_sample && @slowest_sample.duration >= slow_threshold
+        if @slowest_sample &&
+            @slowest_sample.duration >=
+            Agent.config[:'transaction_tracer.transaction_threshold']
           result << @slowest_sample
         end
 
@@ -380,14 +376,14 @@ module NewRelic
 
       # get the set of collected samples, merging into previous samples,
       # and clear the collected sample list. Truncates samples to a
-      # specified @segment_limit to save memory and bandwith
+      # specified segment_limit to save memory and bandwith
       # transmitting samples to the server.
-      def harvest(previous = [], slow_threshold = 2.0)
-        return [] if disabled
+      def harvest(previous=[])
+        return [] if !enabled?
         result = Array(previous)
 
         @samples_lock.synchronize do
-          result = add_samples_to(result, slow_threshold)
+          result = add_samples_to(result)
 
           # clear previous transaction samples
           @slowest_sample = nil
@@ -437,7 +433,7 @@ module NewRelic
       # new transaction sample builder with the stated time as a
       # starting point and saves it in the thread local variable
       def start_builder(time=nil)
-        if disabled || !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
+        if !enabled? || !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
           clear_builder
         else
           Thread::current[BUILDER_KEY] ||= TransactionSampleBuilder.new(time)

data/lib/new_relic/control/frameworks/rails.rb

@@ -21,14 +21,19 @@ module NewRelic
           ::RAILS_DEFAULT_LOGGER
         end
 
+        def rails_config
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            ::Rails.configuration
+          else
+            @config
+          end
+        end
+
         # In versions of Rails prior to 2.0, the rails config was only available to
         # the init.rb, so it had to be passed on from there.  This is a best effort to
         # find a config and use that.
         def init_config(options={})
-          rails_config = options[:config]
-          if !rails_config && defined?(::Rails) && ::Rails.respond_to?(:configuration)
-            rails_config = ::Rails.configuration
-          end
+          @config = options[:config]
           # Install the dependency detection,
           if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
             rails_config.after_initialize do