ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,9 +1,12 @@
 require 'new_relic/agent'
 require 'new_relic/control'
 require 'new_relic/agent/transaction_sample_builder'
+
 module NewRelic
   module Agent
 
+    # This class contains the logic of sampling a transaction -
+    # creation and modification of transaction samples
     class TransactionSampler
 
       # Module defining methods stubbed out when the agent is disabled
@@ -17,12 +20,16 @@ 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 :slow_capture_threshold
       attr_reader :samples, :last_sample, :disabled
 
       def initialize
+
         # @samples is an array of recent samples up to @max_samples in
         # size - it's only used by developer mode
         @samples = []
+        @force_persist = []
         @max_samples = 100
 
         # @harvest_count is a count of harvests used for random
@@ -30,14 +37,8 @@ module NewRelic
         @harvest_count = 0
         @random_sample = nil
         @sampling_rate = 10
-
-        # @segment_limit and @stack_trace_threshold come from the
-        # configuration file, with built-in defaults that should
-        # suffice for most customers
-        config = NewRelic::Control.instance
-        sampler_config = config.fetch('transaction_tracer', {})
-        @segment_limit = sampler_config.fetch('limit_segments', 4000)
-        @stack_trace_threshold = sampler_config.fetch('stack_trace_threshold', 0.500).to_f
+        @slow_capture_threshold = 2.0
+        configure!
 
         # This lock is used to synchronize access to the @last_sample
         # and related variables. It can become necessary on JRuby or
@@ -45,6 +46,30 @@ module NewRelic
         @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
+        end
+      end
+
+      def config
+        NewRelic::Control.instance.fetch('transaction_tracer', {})
+      end
+
       # Returns the current sample id, delegated from `builder`
       def current_sample_id
         b=builder
@@ -65,6 +90,10 @@ module NewRelic
         NewRelic::Agent.instance.stats_engine.remove_transaction_sampler(self)
       end
 
+      def enabled?
+        !@disabled
+      end
+
       # Set with an integer value n, this takes one in every n
       # harvested samples. It also resets the harvest count to a
       # random integer between 0 and (n-1)
@@ -137,7 +166,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
 
@@ -158,9 +186,11 @@ 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_random_sample(sample)
-        store_sample_for_developer_mode(sample)
-        store_slowest_sample(sample)
+        @store_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
@@ -172,6 +202,16 @@ module NewRelic
         end
       end
 
+      def store_force_persist(sample)
+        @force_persist << sample
+
+        # WARNING - this clamp should be configurable
+        if @force_persist.length > 15
+          @force_persist.sort! {|a,b| b.duration <=> a.duration}
+          @force_persist = @force_persist[0..14]
+        end
+      end
+
       # 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)
@@ -184,7 +224,9 @@ module NewRelic
       # Sets @slowest_sample to the passed in sample if it is slower
       # than the current sample in @slowest_sample
       def store_slowest_sample(sample)
-        @slowest_sample = sample if slowest_sample?(@slowest_sample, sample)
+        if slowest_sample?(@slowest_sample, sample)
+          @slowest_sample = sample
+        end
       end
 
       # Checks to see if the old sample exists, or if it's duration is
@@ -234,7 +276,14 @@ module NewRelic
         return unless builder
         segment = builder.current_segment
         if segment
-          segment[key] = truncate_message(append_new_message(segment[key], message))
+          new_message = truncate_message(append_new_message(segment[key],
+                                                            message))
+          if key == :sql && config.respond_to?(:has_key?) && config.has_key?(:adapter)
+            segment[key] = Database::Statement.new(new_message)
+            segment[key].adapter = config[:adapter]
+          else
+            segment[key] = new_message
+          end
           segment[config_key] = config if config_key
           append_backtrace(segment, duration)
         end
@@ -266,7 +315,7 @@ 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
+        segment[:backtrace] = caller.join("\n") if (duration >= @stack_trace_threshold || Thread.current[:capture_deep_tt])
       end
 
       # some statements (particularly INSERTS with large BLOBS
@@ -298,24 +347,41 @@ module NewRelic
         @harvest_count += 1
         if (@harvest_count.to_i % @sampling_rate.to_i) == 0
           result << @random_sample if @random_sample
+          @harvest_count = 0
         end
-        result.uniq!
         nil # don't assume this method returns anything
       end
 
+      def add_force_persist_to(result)
+        result.concat(@force_persist)
+        @force_persist = []
+      end
+
       # Returns an array of slow samples, with either one or two
       # 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)
+        # pull out force persist
+        force_persist = result.select {|sample| sample.force_persist} || []
+        result.reject! {|sample| sample.force_persist}
+
+        force_persist.each {|sample| store_force_persist(sample)}
+
+
+        # Now get the slowest sample
         if @slowest_sample && @slowest_sample.duration >= slow_threshold
           result << @slowest_sample
         end
+
         result.compact!
         result = result.sort_by { |x| x.duration }
-        result = result[-1..-1] || []
+        result = result[-1..-1] || []               # take the slowest sample
+
         add_random_sample_to(result)
-        result
+        add_force_persist_to(result)
+
+        result.uniq
       end
 
       # get the set of collected samples, merging into previous samples,
@@ -325,19 +391,43 @@ module NewRelic
       def harvest(previous = [], slow_threshold = 2.0)
         return [] if disabled
         result = Array(previous)
+
         @samples_lock.synchronize do
           result = add_samples_to(result, slow_threshold)
+
           # clear previous transaction samples
           @slowest_sample = nil
           @random_sample = nil
           @last_sample = nil
         end
+
+        # Clamp the number of TTs we'll keep in memory and send
+        #
+        result = clamp_number_tts(result, 20) if result.length > 20
+
         # 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
       end
 
+      # JON - THIS CODE NEEDS A UNIT TEST
+      def clamp_number_tts(tts, limit)
+        tts.sort! do |a,b|
+          if a.force_persist && b.force_persist
+            b.duration <=> a.duration
+          elsif a.force_persist
+            -1
+          elsif b.force_persist
+            1
+          else
+            b.duration <=> a.duration
+          end
+        end
+
+        tts[0..(limit-1)]
+      end
+
       # reset samples without rebooting the web server
       def reset!
         @samples = []
@@ -346,8 +436,6 @@ module NewRelic
         @slowest_sample = nil
       end
 
-      private
-
       # Checks to see if the transaction sampler is disabled, if
       # transaction trace recording is disabled by a thread local, or
       # if execution is untraced - if so it clears the transaction

data/lib/new_relic/agent/worker_loop.rb

@@ -12,14 +12,17 @@ module NewRelic
         @next_invocation_time = Time.now
         @period = 60.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.
@@ -38,15 +41,20 @@ module NewRelic
           run_task if keep_running
         end
       end
-
+      
+      # a simple accessor for @should_run
       def keep_running
         @should_run
       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
       def run_task
         begin
           lock.synchronize do
@@ -66,7 +74,7 @@ module NewRelic
           # Want to ignore these because they are handled already
         rescue SystemExit, NoMemoryError, SignalException
           raise
-        rescue Exception => e
+        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")

data/lib/new_relic/collection_helper.rb

@@ -1,23 +1,27 @@
+require 'new_relic/control'
+
 module NewRelic
   module CollectionHelper
-  DEFAULT_TRUNCATION_SIZE=256
-  DEFAULT_ARRAY_TRUNCATION_SIZE=1024
+  DEFAULT_TRUNCATION_SIZE=16 * 1024
+  DEFAULT_ARRAY_TRUNCATION_SIZE=128
   # Transform parameter hash into a hash whose values are strictly
   # strings
   def normalize_params(params)
     case params
+      when Hash
+        # optimize for empty hash since that is often what this is called with.
+        return params if params.empty?
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
+        end
+        new_params
       when Symbol, FalseClass, TrueClass, nil
         params
       when Numeric
         truncate(params.to_s)
       when String
         truncate(params)
-      when Hash
-        new_params = {}
-        params.each do | key, value |
-          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
-        end
-        new_params
       when Array
         params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
     else
@@ -29,12 +33,16 @@ module NewRelic
   # Return nil if there is no backtrace
 
   def strip_nr_from_backtrace(backtrace)
-    if backtrace
+    if backtrace && !NewRelic::Control.instance.disable_backtrace_cleanup?
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
-      backtrace = backtrace.reject {|line| line =~ /new_?relic/ }
+      backtrace = backtrace.map &:to_s
+      backtrace = backtrace.reject do |line|
+        line.include?(NewRelic::Control.newrelic_root) or
+        line =~ /^newrelic_rpm\s/
+      end
       # rename methods back to their original state
-      backtrace = backtrace.collect {|line| line.to_s.gsub(/_without_(newrelic|trace)/, "")}
+      backtrace = backtrace.collect {|line| line.gsub(/_without_(newrelic|trace)/, "")}
     end
     backtrace
   end

data/lib/new_relic/command.rb

@@ -38,7 +38,7 @@ module NewRelic
         @leftover = @options.parse(command_line_args)
       end
     rescue OptionParser::ParseError => e
-      raise CommandFailure.new e.message, @options
+      raise CommandFailure.new(e.message, @options)
     end
 
     @commands = []

data/lib/new_relic/commands/deployments.rb

@@ -17,7 +17,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
   # Initialize the deployment uploader with command line args.
   # Use -h to see options.
   # When command_line_args is a hash, we are invoking directly and
-  # it's treated as an options with optional sttring values for
+  # it's treated as an options with optional string values for
   # :user, :description, :appname, :revision, :environment,
   # and :changes.
   #
@@ -72,7 +72,7 @@ class NewRelic::Command::Deployments < NewRelic::Command
       raise NewRelic::Command::CommandFailure.new(err_string)
     rescue NewRelic::Command::CommandFailure
       raise
-    rescue Exception => e
+    rescue => e
       err "Unexpected error attempting to connect to #{config.api_server}"
       info "#{e}: #{e.backtrace.join("\n   ")}"
       raise NewRelic::Command::CommandFailure.new(e.to_s)

data/lib/new_relic/commands/install.rb

@@ -52,21 +52,10 @@ at www.newrelic.com, and replace the newrelic.yml file with the one
 you receive upon registration.
     EOF
     puts <<-EOF unless quiet
-
+    
 E-mail support@newrelic.com with any problems or questions.
-
-    EOF
-    puts <<-EOF
-
-Installing the plugin from Rubyforge is deprecated. This repository will not be updated after January 2011
-
-Please use one of the following options:
-
-Gems: gem install newrelic_rpm
-
-Github! git clone git://github.com/newrelic/rpm.git vendor/plugins/newrelic_rpm
-
     EOF
+    
   end
 
   def content

data/lib/new_relic/control.rb

@@ -2,12 +2,14 @@ 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'
 require 'socket'
 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'
@@ -30,9 +32,6 @@ module NewRelic
   # The Control also implements some of the public API for the agent.
   #
   class Control
-    # used for framework-specific subclasses
-    module Frameworks; end
-
     # done in a subfile for load order purposes
     # extend ClassMethods
     # include InstanceMethods

data/lib/new_relic/control/class_methods.rb

@@ -1,16 +1,20 @@
 module NewRelic
   class Control
+    # class-level methods for lazy creation of NewRelic::Control and
+    # NewRelic::LocalEnvironment instances.
     module ClassMethods
-      # Access the Control singleton, lazy initialized
-      def instance
-        @instance ||= new_instance
+      # Access the Control singleton, lazy initialized.  Default will instantiate a new
+      # instance or pass false to defer
+      def instance(create=true)
+        @instance ||= create && new_instance
       end
-
+      
+      # Access the LocalEnvironment singleton, lazy initialized
       def local_env
         @local_env ||= NewRelic::LocalEnvironment.new
       end
 
-      # Create the concrete class for environment specific behavior:
+      # Create the concrete class for environment specific behavior
       def new_instance
         if local_env.framework == :test
           load_test_framework
@@ -25,7 +29,9 @@ module NewRelic
         require "config/test_control"
         NewRelic::Control::Frameworks::Test.new(local_env, config)
       end
-
+      
+      # Loads the specified framework class from the
+      # NewRelic::Control::Frameworks module
       def load_framework_class(framework)
         begin
           require "new_relic/control/frameworks/#{framework}"