newrelic_rpm 3.4.2.1 → 3.5.0

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

@@ -1,4 +1,5 @@
 require 'new_relic/control/frameworks/rails'
+require 'new_relic/rack/error_collector'
 module NewRelic
   class Control
     module Frameworks
@@ -30,6 +31,15 @@ module NewRelic
           ::Rails.logger
         end
 
+        def init_config(options={})
+          super
+          if Agent.config[:agent_enabled] && Agent.config[:'error_collector.enabled']
+            if !rails_config.middleware.respond_to?(:include?) ||
+                !rails_config.middleware.include?(NewRelic::Rack::ErrorCollector)
+              rails_config.middleware.use NewRelic::Rack::ErrorCollector
+            end
+          end
+        end
 
         def log!(msg, level=:info)
           if should_log?

data/lib/new_relic/noticed_error.rb

@@ -2,28 +2,38 @@
 class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
   attr_accessor :path, :timestamp, :params, :exception_class, :message
+  attr_reader :exception_id
 
   def initialize(path, data, exception, timestamp = Time.now)
-    self.path = path
-    self.params = NewRelic::NoticedError.normalize_params(data)
+    @exception_id = exception.object_id
+    @path = path
+    @params = NewRelic::NoticedError.normalize_params(data)
 
-    self.exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
+    @exception_class = exception.is_a?(Exception) ? exception.class.name : 'Error'
 
     if exception.respond_to?('original_exception')
-      self.message = exception.original_exception.message.to_s
+      @message = exception.original_exception.message.to_s
     else
-      self.message = (exception || '<no message>').to_s
+      @message = (exception || '<no message>').to_s
     end
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
-    self.message = self.message[0..4095] if self.message.length > 4096
+    @message = @message[0..4095] if @message.length > 4096
     
     # obfuscate error message if necessary
     if NewRelic::Agent.config[:high_security]
-      self.message = NewRelic::Agent::Database.obfuscate_sql(self.message)
+      @message = NewRelic::Agent::Database.obfuscate_sql(@message)
     end
     
-    self.timestamp = timestamp
+    @timestamp = timestamp
+  end
+
+  def ==(other)
+    if other.respond_to?(:exception_id)
+      @exception_id == other.exception_id
+    else
+      false
+    end
   end
 end

data/lib/new_relic/rack.rb

@@ -0,0 +1,4 @@
+module NewRelic
+  module Rack
+  end
+end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -59,6 +59,8 @@ module NewRelic::Rack
           # otherwise put the header right above body start
           body_start
         end
+        # otherwise put the header right above body start
+        head_pos ||= body_start
 
         # check that head_pos is less than body close.  If it's not something
         # is really weird and we should punt.

data/lib/new_relic/rack/error_collector.rb

@@ -0,0 +1,56 @@
+module NewRelic::Rack
+  class ErrorCollector
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      request = Rack::Request.new(env)
+      if !should_ignore_error?(exception, request)
+        NewRelic::Agent.instance.error_collector.notice_error(exception,
+                                                              :uri => request.path,
+                                                          :referer => request.referer,
+                                                   :request_params => request.params)
+      end
+      raise exception
+    end
+
+    def should_ignore_error?(error, request)
+      NewRelic::Agent.instance.error_collector.error_is_ignored?(error) ||
+        ignored_in_controller?(error, request)
+    end
+
+    def ignored_in_controller?(exception, request)
+      if request.env['action_dispatch.request.parameters']
+        ignore_actions = newrelic_ignore_for_controller(request.env['action_dispatch.request.parameters']['controller'])
+        action_name = request.env['action_dispatch.request.parameters']['action']
+
+        case ignore_actions
+        when nil; false
+        when Hash
+          only_actions = Array(ignore_actions[:only])
+          except_actions = Array(ignore_actions[:except])
+          only_actions.include?(action_name.to_sym) ||
+            (except_actions.any? &&
+             !except_actions.include?(action_name.to_sym))
+        else
+          true
+        end
+      end
+    end
+
+    def newrelic_ignore_for_controller(controller_name)
+      if controller_name
+        controller_constant_name = (controller_name + "_controller").camelize
+        if Object.const_defined?(controller_constant_name)
+          controller = controller_constant_name.constantize
+          controller.instance_variable_get(:@do_not_trace)
+        end
+      end
+    rescue NameError
+      nil
+    end
+  end
+end

data/lib/new_relic/version.rb

@@ -2,9 +2,9 @@
 module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
-    MINOR = 4
-    TINY  = 2
-    BUILD = 1 # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    MINOR = 5
+    TINY  = 0
+    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic.yml

@@ -87,19 +87,7 @@ common: &default_settings
   # use a non-blocking lookup, so in a worst case, if you have DNS
   # problems, your app may block indefinitely.
   # verify_certificate: true
-  
-  # Set your application's Apdex threshold value with the 'apdex_t'
-  # setting, in seconds. The apdex_t value determines the buckets used
-  # to compute your overall Apdex score. 
-  # Requests that take less than apdex_t seconds to process will be
-  # classified as Satisfying transactions; more than apdex_t seconds
-  # as Tolerating transactions; and more than four times the apdex_t
-  # value as Frustrating transactions. 
-  # For more about the Apdex standard, see
-  # http://newrelic.com/docs/general/apdex
 
-  apdex_t: 0.5
-  
   #============================== Browser Monitoring ===============================
   # New Relic Real User Monitoring gives you insight into the performance real users are
   # experiencing with your website. This is accomplished by measuring the time it takes for

data/newrelic_rpm.gemspec

@@ -5,10 +5,10 @@
 
 Gem::Specification.new do |s|
   s.name = "newrelic_rpm"
-  s.version = "3.4.2.1"
+  s.version = "3.5.0"
 
   s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson", "Rob Saul"]
-  s.date = "2012-09-12"
+  s.date = "2012-10-04"
   s.description = "New Relic is a performance management system, developed by New Relic,\nInc (http://www.newrelic.com).  New Relic provides you with deep\ninformation about the performance of your web application as it runs\nin production. The New Relic Ruby Agent is dual-purposed as a either a\nGem or plugin, hosted on\nhttp://github.com/newrelic/rpm/\n"
   s.email = "support@newrelic.com"
   s.executables = ["newrelic_cmd", "newrelic", "mongrel_rpm"]
@@ -118,8 +118,10 @@ Gem::Specification.new do |s|
     "lib/new_relic/metric_spec.rb",
     "lib/new_relic/metrics.rb",
     "lib/new_relic/noticed_error.rb",
+    "lib/new_relic/rack.rb",
     "lib/new_relic/rack/browser_monitoring.rb",
     "lib/new_relic/rack/developer_mode.rb",
+    "lib/new_relic/rack/error_collector.rb",
     "lib/new_relic/recipes.rb",
     "lib/new_relic/stats.rb",
     "lib/new_relic/timer_lib.rb",
@@ -208,6 +210,7 @@ Gem::Specification.new do |s|
     "test/new_relic/rack/browser_monitoring_test.rb",
     "test/new_relic/rack/developer_mode_helper_test.rb",
     "test/new_relic/rack/developer_mode_test.rb",
+    "test/new_relic/rack/error_collector_test.rb",
     "test/new_relic/stats_test.rb",
     "test/new_relic/transaction_analysis/segment_summary_test.rb",
     "test/new_relic/transaction_analysis_test.rb",
@@ -304,7 +307,7 @@ Gem::Specification.new do |s|
     "vendor/gems/metric_parser-0.1.0.pre1/lib/new_relic/metric_parser/web_transaction.rb"
   ]
   s.homepage = "http://www.github.com/newrelic/rpm"
-  s.post_install_message = "\nPLEASE NOTE:\n\nDeveloper Mode is now a Rack middleware.\n\nDeveloper Mode is no longer available in Rails 2.1 and earlier.\nHowever, starting in version 2.12 you can use Developer Mode in any\nRack based framework, in addition to Rails.  To install developer mode\nin a non-Rails application, just add NewRelic::Rack::DeveloperMode to\nyour middleware stack.\n\nIf you are using JRuby, we recommend using at least version 1.4 or \nlater because of issues with the implementation of the timeout library.\n\nRefer to the README.md file for more information.\n\nPlease see http://github.com/newrelic/rpm/blob/master/CHANGELOG\nfor a complete description of the features and enhancements available\nin version 3.4 of the Ruby Agent.\n  \n"
+  s.post_install_message = "\nPLEASE NOTE:\n\nDeveloper Mode is now a Rack middleware.\n\nDeveloper Mode is no longer available in Rails 2.1 and earlier.\nHowever, starting in version 2.12 you can use Developer Mode in any\nRack based framework, in addition to Rails.  To install developer mode\nin a non-Rails application, just add NewRelic::Rack::DeveloperMode to\nyour middleware stack.\n\nIf you are using JRuby, we recommend using at least version 1.4 or \nlater because of issues with the implementation of the timeout library.\n\nRefer to the README.md file for more information.\n\nPlease see http://github.com/newrelic/rpm/blob/master/CHANGELOG\nfor a complete description of the features and enhancements available\nin version 3.5 of the Ruby Agent.\n  \n"
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "New Relic Ruby Agent"]
   s.require_paths = ["lib"]
   s.summary = "New Relic Ruby Agent"

data/test/new_relic/agent/agent/connect_test.rb

@@ -14,7 +14,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     @sql_sampler = NewRelic::Agent::SqlSampler.new
     server = NewRelic::Control::Server.new('localhost', 30303)
     @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
-    log.stubs(:warn)
+    log.stubs(:warn => true, :info => true, :debug => true)
   end
 
   def control
@@ -169,97 +169,70 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_configure_error_collector_base
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(false)
-    fake_collector.expects(:enabled=).with(false)
-    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
-    configure_error_collector!(false)
+    error_collector = NewRelic::Agent::ErrorCollector.new
+    NewRelic::Control.instance.log.stubs(:debug)
+    NewRelic::Control.instance.log.expects(:debug) \
+      .with("Errors will not be sent to the New Relic service.").at_least_once
+    with_config(:'error_collector.enabled' => false) do
+      # noop
+    end
   end
 
   def test_configure_error_collector_enabled
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(true)
-    fake_collector.expects(:enabled=).with(true)
-    log.expects(:debug).with("Errors will be sent to the New Relic service.")
-    configure_error_collector!(true)
+    with_config(:'error_collector.enabled' => false) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      NewRelic::Control.instance.log.stubs(:debug)
+      NewRelic::Control.instance.log.expects(:debug) \
+        .with("Errors will be sent to the New Relic service.").at_least_once
+      with_config(:'error_collector.enabled' => true) do
+        # noop
+      end
+    end
   end
 
   def test_configure_error_collector_server_disabled
-    fake_collector = mocked_error_collector
-    fake_collector.expects(:config_enabled).returns(true)
-    fake_collector.expects(:enabled=).with(false)
-    log.expects(:debug).with("Errors will not be sent to the New Relic service.")
-    configure_error_collector!(false)
-  end
-
-  def test_enable_random_samples
-    sampling_rate = 10
-    ts = @transaction_sampler = mock('ts')
-    ts.expects(:random_sampling=).with(true)
-    ts.expects(:sampling_rate=).with(sampling_rate)
-    ts.expects(:sampling_rate).returns(sampling_rate)
-    log.expects(:info).with("Transaction sampling enabled, rate = 10")
-    enable_random_samples!(sampling_rate)
-  end
-
-  def test_enable_random_samples_with_no_sampling_rate
-    # testing that we set a sane default for sampling rate
-    sampling_rate = 0
-    ts = @transaction_sampler = mock('ts')
-    ts.expects(:random_sampling=).with(true)
-    ts.expects(:sampling_rate=).with(10)
-    ts.expects(:sampling_rate).returns(10)
-    log.expects(:info).with("Transaction sampling enabled, rate = 10")
-    enable_random_samples!(sampling_rate)
-  end
-
-  def test_config_transaction_tracer
-    test_config = {
-      'transaction_tracer.enabled' => true,
-      'transaction_tracer.random_sampler' => false,
-      'transaction_tracer.explain_threshold' => 0.75,
-      'transaction_tracer.explain_enabled' => true
-    }
-    with_config(test_config) do
-      config_transaction_tracer
-      assert @transaction_sampler.enabled?
-      assert_equal 0.75, @transaction_sampler.explain_threshold
-      assert @transaction_sampler.explain_enabled
+    error_collector = NewRelic::Agent::ErrorCollector.new
+    NewRelic::Control.instance.log.stubs(:debug)
+    NewRelic::Control.instance.log.expects(:debug) \
+      .with("Errors will not be sent to the New Relic service.").at_least_once
+    config = NewRelic::Agent::Configuration::ServerSource.new('collect_errors' => false)
+    with_config(config) do
+      # noop
     end
   end
 
   def test_configure_transaction_tracer_with_random_sampling
-    @config_should_send_samples = true
-    @should_send_random_samples = true
-    @slowest_transaction_threshold = 5
-    log.stubs(:debug)
-    self.expects(:enable_random_samples!).with(10)
-    configure_transaction_tracer!(true, 10)
-    assert @should_send_samples
-    assert_equal 5, @transaction_sampler.slow_capture_threshold
+    with_config(:'transaction_tracer.transaction_threshold' => 5,
+                :'transaction_tracer.random_sample' => true) do
+      log.stubs(:debug)
+      sample = TransactionSampleTestHelper.make_sql_transaction
+      @transaction_sampler.store_sample(sample)
+
+      assert_equal sample, @transaction_sampler.instance_variable_get(:@random_sample)
+    end
   end
 
   def test_configure_transaction_tracer_positive
-    @config_should_send_samples = true
-    @slowest_transaction_threshold = 5
-    log.stubs(:debug)
-    configure_transaction_tracer!(true, 10)
-    assert @should_send_samples
-    assert_equal 5, @transaction_sampler.slow_capture_threshold
+    with_config(:'transaction_tracer.enabled' => true) do
+      assert @transaction_sampler.enabled?
+    end
   end
 
   def test_configure_transaction_tracer_negative
-    @config_should_send_samples = false
-    log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
-    configure_transaction_tracer!(true, 10)
-    assert !@should_send_samples
+    with_config(:'transaction_tracer.enabled' => false) do
+      assert @transaction_sampler.enabled?
+    end
   end
 
   def test_configure_transaction_tracer_server_disabled
-    @config_should_send_samples = true
+    @transaction_sampler.stubs(:log).returns(log)
+    log.stubs(:debug)
     log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
-    configure_transaction_tracer!(false, 10)
-    assert !@should_send_samples
+    config = NewRelic::Agent::Configuration::ServerSource.new('collect_traces' => false,
+                                                              'developer_mode' => false)
+    with_config(config) do
+      assert !@transaction_sampler.enabled?
+    end
   end
 
   def test_apdex_f
@@ -270,58 +243,39 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
 
   def test_set_sql_recording_default
     with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
-      self.expects(:log_sql_transmission_warning?)
-      set_sql_recording!
-      assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+      assert_equal(:obfuscated, NewRelic::Agent::Database.record_sql_method,
+                   "should default to :obfuscated, was #{NewRelic::Agent::Database.record_sql_method}")
     end
   end
 
   def test_set_sql_recording_off
     with_config(:'transaction_tracer.record_sql' => 'off') do
-      self.expects(:log_sql_transmission_warning?)
-      set_sql_recording!
-      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
     end
   end
 
   def test_set_sql_recording_none
     with_config(:'transaction_tracer.record_sql' => 'none') do
-      self.expects(:log_sql_transmission_warning?)
-      set_sql_recording!
-      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
     end
   end
 
   def test_set_sql_recording_raw
     with_config(:'transaction_tracer.record_sql' => 'raw') do
-      self.expects(:log_sql_transmission_warning?)
-      set_sql_recording!
-      assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+      assert_equal(:raw, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :raw, was #{NewRelic::Agent::Database.record_sql_method}")
     end
   end
 
   def test_set_sql_recording_falsy
     with_config(:'transaction_tracer.record_sql' => false) do
-      self.expects(:log_sql_transmission_warning?)
-      set_sql_recording!
-      assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+      assert_equal(:off, NewRelic::Agent::Database.record_sql_method,
+                   "should be set to :off, was #{NewRelic::Agent::Database.record_sql_method}")
     end
   end
 
-  def test_log_sql_transmission_warning_negative
-    log = mocked_log
-    @record_sql = :obfuscated
-    log.expects(:warn).never
-    log_sql_transmission_warning?
-  end
-
-  def test_log_sql_transmission_warning_positive
-    log = mocked_log
-    @record_sql = :raw
-    log.expects(:warn).with('Agent is configured to send raw SQL to the service')
-    log_sql_transmission_warning?
-  end
-
   def test_query_server_for_configuration
     self.expects(:connect_to_server).returns("so happy")
     self.expects(:finish_setup).with("so happy")
@@ -329,9 +283,9 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_connect_to_server_gets_config_from_collector
+    NewRelic::Agent.manual_start
     service = NewRelic::FakeService.new
     NewRelic::Agent::Agent.instance.service = service
-    NewRelic::Agent.manual_start
     service.mock['connect'] = {'agent_run_id' => 23, 'config' => 'a lot'}
 
     response = NewRelic::Agent.agent.connect_to_server
@@ -345,26 +299,40 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def test_finish_setup
     config = {
       'agent_run_id' => 'fishsticks',
-      'data_report_period' => 'pasta sauce',
-      'url_rules' => 'tamales',
       'collect_traces' => true,
       'collect_errors' => true,
-      'sample_rate' => 10
+      'sample_rate' => 10,
+      'agent_config' => { 'transaction_tracer.record_sql' => 'raw' }
     }
     self.expects(:log_connection!).with(config)
-    self.expects(:configure_transaction_tracer!).with(true, 10)
-    self.expects(:configure_error_collector!).with(true)
     @transaction_sampler = stub('transaction sampler', :configure! => true,
                                 :config => {})
     @sql_sampler = stub('sql sampler', :configure! => true)
     with_config(:'transaction_tracer.enabled' => true) do
       finish_setup(config)
       assert_equal 'fishsticks', @service.agent_id
-      assert_equal 'pasta sauce', @report_period
-      assert_equal 'tamales', @url_rules
+      assert_equal 'raw', NewRelic::Agent.config[:'transaction_tracer.record_sql']
     end
   end
 
+  def test_logging_collector_messages
+    NewRelic::Agent.manual_start
+    service = NewRelic::FakeService.new
+    NewRelic::Agent::Agent.instance.service = service
+    service.mock['connect'] = {
+      'agent_run_id' => 23, 'config' => 'a lot',
+      'messages' => [{ 'message' => 'beep boop', 'level' => 'INFO' },
+                     { 'message' => 'ha cha cha', 'level' => 'WARN' }]
+    }
+
+    NewRelic::Control.instance.log.stubs(:info)
+    NewRelic::Control.instance.log.expects(:info).with('beep boop')
+    NewRelic::Control.instance.log.expects(:warn).with('ha cha cha')
+
+    NewRelic::Agent.agent.query_server_for_configuration
+    NewRelic::Agent.shutdown
+  end
+
   def test_finish_setup_without_config
     @service.agent_id = 'blah'
     finish_setup(nil)
@@ -377,10 +345,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     def test_set_apdex_t_from_server
       service = NewRelic::FakeService.new
       NewRelic::Agent::Agent.instance.service = service
-      service.mock['connect'] = {
-        'apdex_t' => 0.5,
-        'listen_to_server_config' => true
-      }
+      service.mock['connect'] = { 'apdex_t' => 0.5 }
       with_config(:sync_startup => true, :monitor_mode => true,
                   :license_key => 'a' * 40) do
         NewRelic::Agent.manual_start