newrelic_rpm 3.4.1 → 3.4.2.beta1

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

@@ -4,7 +4,7 @@ DependencyDetection.defer do
   @name = :delayed_job
   
   depends_on do
-    !NewRelic::Control.instance['disable_dj']
+    !NewRelic::Agent.config[:disable_dj]
   end
 
   depends_on do

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

@@ -32,7 +32,7 @@ module NewRelic
          end      
         end
         def memcache_key_snippet(method_name)
-          return "" unless NewRelic::Control.instance['capture_memcache_keys']
+          return "" unless NewRelic::Agent.config[:capture_memcache_keys]
           "NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil"
         end
       end
@@ -44,7 +44,7 @@ DependencyDetection.defer do
   @name = :memcache
   
   depends_on do
-    !NewRelic::Control.instance['disable_memcache_instrumentation']
+    !NewRelic::Agent.config[:disable_memcache_instrumentation]
   end
 
   depends_on do

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

@@ -320,7 +320,7 @@ module NewRelic
         # the apdex should be recorded as a failure regardless of duration.
         def self.update_apdex(stat, duration, failed)
           duration = duration.to_f
-          apdex_t = NewRelic::Control.instance.apdex_t
+          apdex_t = Agent.config[:apdex_t]
           case
           when failed
             stat.record_apdex_f

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

@@ -2,7 +2,7 @@ DependencyDetection.defer do
   @name = :rails21_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) && defined?(ActionView::PartialTemplate) && defined?(ActionView::Template) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.1\./   # Rails 2.1 &&
   end
@@ -26,7 +26,7 @@ DependencyDetection.defer do
   @name = :old_rails_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0 
   end
@@ -47,7 +47,7 @@ DependencyDetection.defer do
   @name = :rails23_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/ 
   end

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

@@ -96,7 +96,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do
@@ -135,7 +135,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do

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

@@ -2,7 +2,7 @@ DependencyDetection.defer do
   @name = :resque
   
   depends_on do
-    defined?(::Resque::Job) && !NewRelic::Control.instance['disable_resque']  &&
+    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]  &&
       !NewRelic::LanguageSupport.using_version?('1.9.1')
   end
 

data/lib/new_relic/agent/method_tracer.rb

@@ -497,7 +497,7 @@ module NewRelic
         # from when they were added, or else other tracers that were added to the same method
         # may get removed as well.
         def remove_method_tracer(method_name, metric_name_code) # :nodoc:
-          return unless NewRelic::Control.instance.agent_enabled?
+          return unless Agent.config[:agent_enabled]
           if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
             alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
             undef_method "#{_traced_method_name(method_name, metric_name_code)}"

data/lib/new_relic/agent/new_relic_service.rb

@@ -17,10 +17,10 @@ module NewRelic
       attr_reader :collector
       attr_accessor :agent_id
       
-      def initialize(license_key=control.license_key, collector=control.server)
-        @license_key = license_key
+      def initialize(license_key=nil, collector=control.server)
+        @license_key = license_key || Agent.config[:license_key]
         @collector = collector
-        @request_timeout = NewRelic::Control.instance.fetch('timeout', 2 * 60)
+        @request_timeout = Agent.config[:timeout]
       end
       
       def connect(settings={})
@@ -119,11 +119,9 @@ module NewRelic
       # big payloads get all the compression possible, to stay under
       # the 2,000,000 byte post threshold
       def compress_data(object)
-        dump = Marshal.dump(object)
+        dump = marshal_data(object)
 
-        dump_size = dump.size
-
-        return [dump, 'identity'] if dump_size < (64*1024)
+        return [dump, 'identity'] if dump.size < (64*1024)
 
         compressed_dump = Zlib::Deflate.deflate(dump, Zlib::DEFAULT_COMPRESSION)
 
@@ -133,11 +131,20 @@ module NewRelic
         [compressed_dump, 'deflate']
       end
 
+      def marshal_data(data)
+        NewRelic::LanguageSupport.with_cautious_gc do
+          Marshal.dump(data)
+        end
+      rescue => e
+        log.debug("#{e.class.name} : #{e.message} when marshalling #{object}")
+        raise
+      end
+
       # Raises a PostTooBigException if the post_string is longer
       # than the limit configured in the control object
       def check_post_size(post_string)
         # TODO: define this as a config option on the server side
-        return if post_string.size < control.post_size_limit
+        return if post_string.size < Agent.config[:post_size_limit]
         log.warn "Tried to send too much data: #{post_string.size} bytes"
         raise PostTooBigException
       end
@@ -200,7 +207,9 @@ module NewRelic
       # so we can handle it in nonlocally
       def check_for_exception(response)
         dump = decompress_response(response)
-        value = Marshal.load(dump)
+        value = NewRelic::LanguageSupport.with_cautious_gc do
+          Marshal.load(dump)
+        end
         raise value if value.is_a? Exception
         value
       end

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -41,7 +41,10 @@ module NewRelic
 
         def write(data)
           @out.close unless @out.closed?
-          @in << Marshal.dump(data) + "\n\n"
+          @in << NewRelic::LanguageSupport.with_cautious_gc do
+            Marshal.dump(data)
+          end
+          @in << "\n\n"
         end
         
         def read
@@ -137,11 +140,7 @@ module NewRelic
         end
 
         def unmarshal(data)
-          if NewRelic::LanguageSupport.broken_gc?
-            NewRelic::LanguageSupport.with_disabled_gc do
-              Marshal.load(data)
-            end
-          else
+          NewRelic::LanguageSupport.with_cautious_gc do
             Marshal.load(data)
           end
         rescue StandardError => e

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -14,7 +14,7 @@ module NewRelic
       class DelayedJobSampler < NewRelic::Agent::Sampler
         def initialize
           super :delayed_job_queue
-          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj']
+          raise Unsupported, "DJ instrumentation disabled" if Agent.config[:disable_dj]
           raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
         end
 
@@ -33,9 +33,6 @@ module NewRelic
           local_env.dispatcher_instance_id
         end
 
-        def queued_jobs
-          Delayed::Job.count(:conditions => ['run_at < ? and failed_at is NULL', Time.now])
-        end
         def failed_jobs
           Delayed::Job.count(:conditions => 'failed_at is not NULL')
         end
@@ -62,7 +59,7 @@ module NewRelic
 
         def record_queue_length_across_dimension(column)
           all_count = 0
-          Delayed::Job.count(:group => column).each do | column_val, count |
+          Delayed::Job.count(:group => column, :conditions => ['run_at < ? and failed_at is NULL', Time.now]).each do | column_val, count |
             all_count += count
             record stats_engine.get_stats("Workers/DelayedJob/queue_length/#{column == 'queue' ? 'name' : column}/#{column_val}", false), count
           end

data/lib/new_relic/agent/sql_sampler.rb

@@ -27,38 +27,18 @@ module NewRelic
         # any 'honest-to-god'-multithreaded system
         @samples_lock = Mutex.new
       end
-      
+
       def configure!
-        @explain_threshold = config.fetch('explain_threshold', 0.5).to_f
-        @explain_enabled = config.fetch('explain_enabled', true)
-        @stack_trace_threshold = config.fetch('stack_trace_threshold',
-                                              0.5).to_f
-        if config.fetch('enabled', true) &&
-            NewRelic::Control.instance['transaction_tracer'] &&
-            NewRelic::Control.instance['transaction_tracer'].fetch('enabled',
-                                                                   true) &&
-            NewRelic::Control.instance.fetch('collect_traces', true)
+        @explain_threshold = Agent.config[:'slow_sql.explain_threshold']
+        @explain_enabled = Agent.config[:'sloq_sql.explain_enabled']
+        @stack_trace_threshold = Agent.config[:'slow_sql.stack_trace_threshold']
+        if Agent.config[:'slow_sql.enabled']
           enable
         else
           disable
         end
       end
-      
-      def config
-        self.class.config
-      end
-      
-      def self.config
-        control = NewRelic::Control.instance
-        txn_config = control.fetch('transaction_tracer', {})
 
-        if txn_config.fetch('enabled', true) && control.has_slow_sql_config?
-          txn_config['enabled'] = control['slow_sql']['enabled']
-        end
-        
-        txn_config
-      end
-                  
       # Enable the sql sampler - this also registers it with
       # the statistics engine.
       def enable
@@ -152,7 +132,7 @@ module NewRelic
         @samples_lock.synchronize do
           result = @sql_traces.values
           @sql_traces = {}
-        end        
+        end
         slowest = result.sort{|a,b| b.max_call_time <=> a.max_call_time}[0,10]
         slowest.each {|trace| trace.prepare_to_send }
         slowest
@@ -243,24 +223,20 @@ module NewRelic
 
         record_data_point slow_sql.duration
       end
-      
+
       def prepare_to_send
         params[:explain_plan] = @slow_sql.explain if need_to_explain?
         @sql = @slow_sql.obfuscate if need_to_obfuscate?
       end
-      
-      def agent_config
-        NewRelic::Agent::SqlSampler.config
-      end
-      
+
       def need_to_obfuscate?
-        agent_config['record_sql'] == 'obfuscated'
+        Agent.config[:'slow_sql.record_sql'].to_s == 'obfuscated'
       end
 
       def need_to_explain?
-        agent_config['explain_enabled']
+        Agent.config[:'slow_sql.explain_enabled']
       end
-      
+
       def to_json(*a)
         [@path, @url, @sql_id, @sql, @database_metric_name, @call_count, @total_call_time, @min_call_time, @max_call_time, @params].to_json(*a)
       end

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

@@ -46,6 +46,7 @@ module Agent
       # 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
         scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
         stack.push scope
@@ -55,6 +56,7 @@ module Agent
       # 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
@@ -96,7 +98,6 @@ 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.
@@ -104,7 +105,6 @@ module Agent
       # and is ignored.
       #
       def end_transaction
-        GCProfiler.capture
         stack = scope_stack
 
         if stack && stack.empty?

data/lib/new_relic/agent/transaction_info.rb

@@ -11,14 +11,15 @@ module NewRelic
         @guid = ""
         @transaction_name = "(unknown)"
         @start_time = Time.now
+        @ignore_end_user = false
       end
 
       def force_persist_sample?(sample)
-        token && sample.duration > NewRelic::Control.instance.apdex_t
+        token && sample.duration > Agent.config[:apdex_t]
       end
 
       def include_guid?
-        token && duration > NewRelic::Control.instance.apdex_t
+        token && duration > Agent.config[:apdex_t]
       end
 
       def guid
@@ -32,6 +33,14 @@ module NewRelic
       def duration
         Time.now - start_time
       end
+      
+      def ignore_end_user?
+        @ignore_end_user
+      end
+      
+      def ignore_end_user=(value)
+        @ignore_end_user = value
+      end
 
       def self.get()
         Thread.current[:newrelic_transaction_info] ||= TransactionInfo.new
@@ -57,17 +66,28 @@ module NewRelic
         return nil unless request
         
         agent_flag = request.cookies['NRAGENT']
-        if agent_flag
+        if agent_flag and agent_flag.instance_of? String 
           s = agent_flag.split("=")
           if s.length == 2
             if s[0] == "tk" && s[1]
-              ERB::Util.h(s[1])
+              ERB::Util.h(sanitize_token(s[1]))
             end
           end
         else
           nil
         end
       end
+
+      # Run through a collection of unsafe characters ( in the context of the token ) 
+      # and set the token to an empty string if any of them are found in the token so that
+      # potential XSS attacks via the token are avoided
+      def self.sanitize_token(token)
+
+        if ( /[<>'"]/ =~ token )
+          token.replace("")
+        end
+        token
+      end
     end
   end
 end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -17,8 +17,7 @@ module NewRelic
         @sample = NewRelic::TransactionSample.new(time.to_f)
         @sample_start = time.to_f
         @current_segment = @sample.root_segment
-        @segment_limit = NewRelic::Control.instance.fetch('transaction_tracer', {}) \
-          .fetch('limit_segments', 4000)
+        @segment_limit = Agent.config[:'transaction_tracer.limit_segments']
       end
 
       def sample_id
@@ -93,7 +92,7 @@ module NewRelic
       def set_transaction_info(path, uri, params)
         @sample.params[:path] = path
 
-        if NewRelic::Control.instance.capture_params
+        if Agent.config[:capture_params]
           params = normalize_params params
 
           @sample.params[:request_params].merge!(params)

data/lib/new_relic/agent/transaction_sampler.rb

@@ -50,26 +50,19 @@ module NewRelic
         # @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)
+        @segment_limit         = Agent.config[:'transaction_tracer.limit_segments']
+        @stack_trace_threshold = Agent.config[:'transaction_tracer.stack_trace_threshold']
+        @explain_threshold     = Agent.config[:'transaction_tracer.explain_threshold']
+        @explain_enabled       = Agent.config[:'transaction_tracer.explain_enabled']
+        @transaction_threshold = Agent.config[:'transaction_tracer.transation_threshold']
 
         # 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?
+        if Agent.config[: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
@@ -121,14 +114,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/
@@ -215,7 +208,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