wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/lib/new_relic/agent/transaction_sampler.rb

@@ -19,8 +19,7 @@ module NewRelic
 
       BUILDER_KEY = :transaction_sample_builder
 
-      attr_accessor :stack_trace_threshold, :random_sampling, :sampling_rate
-      attr_accessor :explain_threshold, :explain_enabled, :transaction_threshold
+      attr_accessor :random_sampling, :sampling_rate
       attr_accessor :slow_capture_threshold
       attr_reader :samples, :last_sample, :disabled
 
@@ -36,38 +35,27 @@ 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
-
-        # enable if config.fetch('enabled', true)
 
-        @segment_limit = config.fetch('limit_segments', 4000)
-        @stack_trace_threshold = config.fetch('stack_trace_threshold', 0.500).to_f
-        @explain_threshold = config.fetch('explain_threshold', 0.5).to_f
-        @explain_enabled = config.fetch('explain_enabled', true)
-        @transaction_threshold = config.fetch('transation_threshold', 2.0)
-
-        # Configure the sample storage policy.  Create a list of methods to be called.
-        @store_sampler_methods = [ :store_random_sample, :store_slowest_sample ]
-        if NewRelic::Control.instance.developer_mode?
-          @store_sampler_methods << :store_sample_for_developer_mode
+        Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
+          if enabled
+            threshold = Agent.config[:'transaction_tracer.transaction_threshold']
+            ::NewRelic::Agent.logger.debug "Transaction tracing threshold is #{threshold} seconds."
+          else
+            ::NewRelic::Agent.logger.debug "Transaction traces will not be sent to the New Relic service."
+          end
         end
-      end
 
-      def config
-        NewRelic::Control.instance.fetch('transaction_tracer', {})
+        Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
+          if config == 'raw'
+            ::NewRelic::Agent.logger.warn("Agent is configured to send raw SQL to the service")
+          end
+        end
       end
 
       # Returns the current sample id, delegated from `builder`
@@ -76,22 +64,8 @@ module NewRelic
         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
@@ -107,7 +81,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
@@ -121,14 +95,14 @@ module NewRelic
 
         builder.trace_entry(scope, time.to_f)
 
-        capture_segment_trace if NewRelic::Control.instance.developer_mode?
+        capture_segment_trace if Agent.config[:developer_mode]
       end
 
       # 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
       def capture_segment_trace
-        return unless NewRelic::Control.instance.developer_mode?
+        return unless Agent.config[:developer_mode]
         segment = builder.current_segment
         if segment
           # Strip stack frames off the top that match /new_relic/agent/
@@ -166,7 +140,6 @@ module NewRelic
       # It sets various instance variables to the finished sample,
       # depending on which settings are active. See `store_sample`
       def notice_scope_empty(time=Time.now)
-
         last_builder = builder
         return unless last_builder
 
@@ -187,20 +160,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)
@@ -216,7 +195,7 @@ module NewRelic
       # Samples take up a ton of memory, so we only store a lot of
       # them in developer mode - we truncate to @max_samples
       def store_sample_for_developer_mode(sample)
-        return unless NewRelic::Control.instance.developer_mode?
+        return unless Agent.config[:developer_mode]
         @samples = [] unless @samples
         @samples << sample
         truncate_samples
@@ -230,7 +209,7 @@ module NewRelic
         end
       end
 
-      # Checks to see if the old sample exists, or if it's duration is
+      # Checks to see if the old sample exists, or if its duration is
       # less than the new sample
       def slowest_sample?(old_sample, new_sample)
         old_sample.nil? || (new_sample.duration > old_sample.duration)
@@ -247,7 +226,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
@@ -316,7 +295,10 @@ module NewRelic
       # Appends a backtrace to a segment if that segment took longer
       # than the specified duration
       def append_backtrace(segment, duration)
-        segment[:backtrace] = caller.join("\n") if (duration >= @stack_trace_threshold || Thread.current[:capture_deep_tt])
+        if (duration >= Agent.config[:'transaction_tracer.stack_trace_threshold'] ||
+            Thread.current[:capture_deep_tt])
+          segment[:backtrace] = caller.join("\n")
+        end
       end
 
       # some statements (particularly INSERTS with large BLOBS
@@ -344,9 +326,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
@@ -362,8 +345,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}
@@ -372,7 +354,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
 
@@ -388,14 +372,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
@@ -409,7 +393,7 @@ module NewRelic
 
         # Truncate the samples at 2100 segments. The UI will clamp them at 2000 segments anyway.
         # This will save us memory and bandwidth.
-        result.each { |sample| sample.truncate(@segment_limit) }
+        result.each { |sample| sample.truncate(Agent.config[:'transaction_tracer.limit_segments']) }
         result
       end
 
@@ -445,7 +429,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/agent/worker_loop.rb

@@ -6,23 +6,22 @@ module NewRelic
     # A task is a proc or block with a specified call period in seconds.
     class WorkerLoop
 
-      def initialize
-        @log = log
+      # Optional argument :duration (in seconds) for how long the worker loop runs
+      # or :limit (integer) for max number of iterations
+      def initialize(opts={})
         @should_run = true
         @next_invocation_time = Time.now
         @period = 60.0
+        @deadline = Time.now + opts[:duration] if opts[:duration]
+        @limit = opts[:limit] if opts[:limit]
+        @iterations = 0
       end
-      
+
       # returns a class-level memoized mutex to make sure we don't run overlapping
       def lock
         @@lock ||= Mutex.new
       end
-      
-      # a helper to access the NewRelic::Control.instance.log
-      def log
-        NewRelic::Control.instance.log
-      end
-      
+
       # Run infinitely, calling the registered tasks at their specified
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
@@ -30,28 +29,37 @@ module NewRelic
         @period = period if period
         @next_invocation_time = (Time.now + @period)
         @task = block
-        while keep_running do
-          now = Time.now
-          while now < @next_invocation_time
+        while keep_running? do
+          while @now < @next_invocation_time
             # sleep until this next task's scheduled invocation time
-            sleep_time = @next_invocation_time - now
+            sleep_time = @next_invocation_time - @now
             sleep sleep_time if sleep_time > 0
-            now = Time.now
+            @now = Time.now
           end
-          run_task if keep_running
+          run_task if keep_running?
+          @iterations += 1 if !@limit.nil?
         end
       end
-      
+
       # a simple accessor for @should_run
-      def keep_running
-        @should_run
+      def keep_running?
+        @now = Time.now
+        @should_run && under_duration? && under_limit?
+      end
+
+      def under_duration?
+        !@deadline || @now < @deadline
+      end
+
+      def under_limit?
+        !@limit || @iterations < @limit
       end
-      
+
       # Sets @should_run to false. Returns false
       def stop
         @should_run = false
       end
-      
+
       # Executes the block given to the worker loop, and handles many
       # possible errors. Also updates the execution time so that the
       # next run occurs on schedule, even if we execute at some odd time
@@ -61,23 +69,21 @@ module NewRelic
             @task.call
           end
         rescue ServerError => e
-          log.debug "Server Error: #{e}"
+          ::NewRelic::Agent.logger.debug "Server Error:", e
         rescue NewRelic::Agent::ForceRestartException, NewRelic::Agent::ForceDisconnectException
           # blow out the loop
           raise
         rescue RuntimeError => e
           # This is probably a server error which has been logged in the server along
           # with your account name.
-          log.error "Error running task in worker loop, likely a server error (#{e})"
-          log.debug e.backtrace.join("\n")
+          ::NewRelic::Agent.logger.error "Error running task in worker loop, likely a server error:", e
         rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
           # Want to ignore these because they are handled already
         rescue SystemExit, NoMemoryError, SignalException
           raise
         rescue => e
           # Don't blow out the stack for anything that hasn't already propagated
-          log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}"
-          log.debug e.backtrace.join("\n")
+          ::NewRelic::Agent.logger.error "Error running task in Agent Worker Loop:", e
         end
         now = Time.now
         while @next_invocation_time <= now && @period > 0

data/lib/new_relic/collection_helper.rb

@@ -33,7 +33,7 @@ module NewRelic
   # Return nil if there is no backtrace
 
   def strip_nr_from_backtrace(backtrace)
-    if backtrace && !NewRelic::Control.instance.disable_backtrace_cleanup?
+    if backtrace && !Agent.config[:disable_backtrace_cleanup]
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
       backtrace = backtrace.map &:to_s

data/lib/new_relic/commands/deployments.rb

@@ -11,7 +11,7 @@ require 'rexml/document'
 require 'new_relic/control' unless defined? NewRelic::Control
 
 class NewRelic::Command::Deployments < NewRelic::Command
-  attr_reader :config
+  attr_reader :control
   def self.command; "deployments"; end
 
   # Initialize the deployment uploader with command line args.
@@ -24,12 +24,18 @@ class NewRelic::Command::Deployments < NewRelic::Command
   # Will throw CommandFailed exception if there's any error.
   #
   def initialize command_line_args
-    @config = NewRelic::Control.instance
+    @control = NewRelic::Control.instance
     super(command_line_args)
     @description ||= @leftover && @leftover.join(" ")
     @user ||= ENV['USER']
-    config.env = @environment if @environment
-    @appname ||= config.app_names[0] || config.env || 'development'
+    control.env = @environment if @environment
+    load_yaml_from_env(control.env)
+    @appname ||= NewRelic::Agent.config.app_names[0] || control.env || 'development'
+  end
+
+  def load_yaml_from_env(env)
+    yaml = NewRelic::Agent::Configuration::YamlSource.new(NewRelic::Agent.config[:config_path], env)
+    NewRelic::Agent.config.replace_or_add_config(yaml, 1)
   end
 
   # Run the Deployment upload in New Relic via Active Resource.
@@ -48,12 +54,15 @@ class NewRelic::Command::Deployments < NewRelic::Command
       }.each do |k, v|
         create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
       end
-      http = config.http_connection(config.api_server)
+      http = control.http_connection(control.api_server)
 
       uri = "/deployments.xml"
 
-      raise "license_key was not set in newrelic.yml for #{config.env}" if config['license_key'].nil?
-      request = Net::HTTP::Post.new(uri, {'x-license-key' => config['license_key']})
+      if NewRelic::Agent.config[:license_key].nil? ||
+          NewRelic::Agent.config[:license_key].empty?
+        raise "license_key was not set in newrelic.yml for #{control.env}"
+      end
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => NewRelic::Agent.config[:license_key]})
       request.content_type = "application/octet-stream"
 
       request.set_form_data(create_params)
@@ -68,12 +77,12 @@ class NewRelic::Command::Deployments < NewRelic::Command
       end
     rescue SystemCallError, SocketError => e
       # These include Errno connection errors
-      err_string = "Transient error attempting to connect to #{config.api_server} (#{e})"
+      err_string = "Transient error attempting to connect to #{control.api_server} (#{e})"
       raise NewRelic::Command::CommandFailure.new(err_string)
     rescue NewRelic::Command::CommandFailure
       raise
     rescue => e
-      err "Unexpected error attempting to connect to #{config.api_server}"
+      err "Unexpected error attempting to connect to #{control.api_server}"
       info "#{e}: #{e.backtrace.join("\n   ")}"
       raise NewRelic::Command::CommandFailure.new(e.to_s)
     end
@@ -89,7 +98,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
              "Default is app_name setting in newrelic.yml") { | e | @appname = e }
       o.on("-e", "--environment=name", String,
                "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
-               "currently: #{config.env}") { | e | @environment = e }
+               "currently: #{control.env}") { | e | @environment = e }
       o.on("-u", "--user=USER", String,
              "Specify the user deploying, for information only",
              "Default: #{@user || '<none>'}") { | u | @user = u }

data/lib/new_relic/control.rb

@@ -2,6 +2,7 @@ require 'yaml'
 require 'conditional_vendored_metric_parser'
 require 'conditional_vendored_dependency_detection'
 require 'new_relic/local_environment'
+require 'new_relic/helper'
 
 require 'singleton'
 require 'erb'
@@ -10,8 +11,6 @@ require 'net/https'
 require 'logger'
 require 'new_relic/control/frameworks'
 require 'new_relic/control/profiling'
-require 'new_relic/control/logging_methods'
-require 'new_relic/control/configuration'
 require 'new_relic/control/server_methods'
 require 'new_relic/control/instrumentation'
 require 'new_relic/control/class_methods'
@@ -35,7 +34,6 @@ module NewRelic
     # extend ClassMethods
     # include InstanceMethods
     # include Profiling
-    # include LoggingMethods
     # include Configuration
     # include ServerMethods
     # include Instrumentation