newrelic_rpm 3.5.6.48.beta → 3.5.6.55

data/newrelic_rpm.gemspec

@@ -40,4 +40,11 @@ EOS
   s.rubygems_version = Gem::VERSION
   s.summary = "New Relic Ruby Agent"
   s.post_install_message = NewRelic::LatestChanges.read
+
+  # Only sign with our private key if you can find it
+  signing_key_path = File.expand_path('~/.ssh/newrelic_rpm-private_key.pem')
+  if File.exists?(signing_key_path)
+    s.signing_key   = signing_key_path
+    s.cert_chain    = ['gem-public_cert.pem']
+  end
 end

data/test/multiverse/lib/multiverse/environment.rb

@@ -4,7 +4,7 @@ module Multiverse
   ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
   $: << File.expand_path(File.join(ROOT, 'lib'))
 
-  # Include from our unit testing path to share fake_collector and fake_service
+  # Include from our unit testing path to share fake_collector
   $: << File.expand_path(File.join(ROOT, '..', 'new_relic'))
 
   SUITES_DIRECTORY = ENV['SUITES_DIRECTORY'] || File.join(ROOT, '/suites')

data/test/multiverse/suites/agent_only/logging_test.rb

@@ -45,6 +45,25 @@ class LoggingTest < Test::Unit::TestCase
 
   end
 
+  def test_logs_ssl_warning
+    running_agent_writes_to_log(
+      {:ssl => false},
+      "Agent is configured not to use SSL when communicating with New Relic's servers") do
+
+      NewRelic::Agent.config.apply_config(:ssl => false)
+    end
+  end
+
+  def test_logs_ssl_verify_cert_warning
+    running_agent_writes_to_log(
+      {:ssl => false, :verify_certificate => false},
+      "Agent is configured to use SSL but to skip certificate validation when communicating with New Relic's servers") do
+
+      NewRelic::Agent.config.apply_config(:ssl => true, :verify_certificate => false)
+    end
+  end
+
+
   def test_logs_if_sending_errors_on_change
     running_agent_writes_to_log(
       {:'error_collector.enabled' => false},

data/test/multiverse/suites/agent_only/ssl_test.rb

@@ -0,0 +1,22 @@
+class SSLTest < Test::Unit::TestCase
+
+  def setup
+    # This is similar to how jruby 1.6.8 behaves when jruby-openssl isn't
+    # installed
+    @original_ssl_config = NewRelic::Agent.config[:ssl]
+    NewRelic::Agent.config.apply_config(:ssl => true)
+    NewRelic::Agent.agent = NewRelic::Agent::Agent.new
+    Net::HTTPSession.any_instance.stubs('use_ssl=').raises(LoadError)
+  end
+
+  def teardown
+    NewRelic::Agent.config.apply_config(:ssl => @original_ssl_config)
+  end
+
+  def test_agent_shuts_down_when_ssl_is_on_but_unavailable
+    ::NewRelic::Agent.agent.expects(:shutdown)
+    ::NewRelic::Agent.expects(:finish_setup).never
+    ::NewRelic::Agent.agent.connect_in_foreground
+  ensure
+  end
+end

data/test/multiverse/suites/rails/config/newrelic.yml

@@ -1,165 +1,32 @@
-#
-# This file configures the NewRelic RPM Agent, NewRelic RPM monitors Rails 
-# applications with deep visibility and low overhead.  For more information, 
-# visit www.newrelic.com.
-#
-# 
-#
-# here are the settings that are common to all environments
 common: &default_settings
-
-  # ============================== LICENSE KEY ===============================
-  # You must specify the licence key associated with your New Relic account.
-  # This key binds your Agent's data to your account in the New Relic RPM service.
-
-  #license_key: 'bootstrap_newrelic_admin_license_key_000'
-  #host: localhost
-  #port: 3000
-
   license_key: 'bd0e1d52adade840f7ca727d29a86249e89a6f1c'
-  host: localhost
-
-  # Agent Enabled
-  # Use this setting to force the agent to run or not run.
-  # Default is 'auto' which means the agent will install and run only if a
-  # valid dispatcher such as Mongrel is running.  This prevents it from running
-  # with Rake or the console.  Set to false to completely turn the agent off
-  # regardless of the other settings.  Valid values are true, false and auto.
-  # agent_enabled: auto
-  
-  # Application Name
-  # Set this to be the name of your application as you'd like it show up in RPM.
-  # RPM will then auto-map instances of your application into a RPM "application"
-  # on your home dashboard page. This setting does not prevent you from manually
-  # defining applications.
+  host: 127.0.0.1
+  port: <%= 30_000 + ($$ % 10_000) %>
   app_name: Rails 3 view test ap
-
-  # When 'enabled' is turned on, the agent collects performance data by inserting lightweight
-  # tracers on key methods inside the rails framework and asynchronously aggregating
-  # and reporting this performance data to the NewRelic RPM service at newrelic.com.
-  enabled: false
-
-  # The newrelic agent generates its own log file to keep its logging information
-  # separate from that of your application.  Specify its log level here.
+  enabled: true
   log_level: debug
-  
-  # The newrelic agent communicates with the RPM service via http by default.
-  # If you want to communicate via https to increase security, then turn on
-  # SSL by setting this value to true.  Note, this will result in increased
-  # CPU overhead to perform the encryption involved in SSL communication, but this
-  # work is done asynchronously to the threads that process your application code, so
-  # it should not impact response times.
   ssl: false
-  
-  # 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://support.newrelic.com/faqs/general/apdex
   apdex_t: 1.0
-    
-
-  # Proxy settings for connecting to the RPM server.
-  #
-  # If a proxy is used, the host setting is required.  Other settings are optional.  Default
-  # port is 8080.
-  #
-  # proxy_host: hostname
-  # proxy_port: 8080
-  # proxy_user:
-  # proxy_pass:
-
-  
-  # Tells transaction tracer and error collector (when enabled) whether or not to capture HTTP params. 
-  # When true, the RoR filter_parameter_logging mechanism is used so that sensitive parameters are not recorded
   capture_params: true
-
-
-  # Transaction tracer captures deep information about slow
-  # transactions and sends this to the RPM service once a minute. Included in the
-  # transaction is the exact call sequence of the transactions including any SQL statements
-  # issued.
   transaction_tracer:
-  
-    # Transaction tracer is enabled by default. Set this to false to turn it off. This feature
-    # is only available at the Silver and above product levels.
     enabled: true
-    
-    # Threshold in seconds for when to collect a transaction trace. When the response time of
-    # a controller action exceeds this threshold, a transaction trace will be recorded and sent
-    # to RPM. Valid values are any float value, or (default) "apdex_f", which will use the
-    # threshold for an dissatisfying Apdex controller action - four times the Apdex T value.
     transaction_threshold: apdex_f
- 
-    # When transaction tracer is on, SQL statements can optionally be recorded. The recorder
-    # has three modes, "off" which sends no SQL, "raw" which sends the SQL statement in its 
-    # original form, and "obfuscated", which strips out numeric and string literals
     record_sql: obfuscated
-    
-    # Threshold in seconds for when to collect stack trace for a SQL call. In other words, 
-    # when SQL statements exceed this threshold, then capture and send to RPM the current
-    # stack trace. This is helpful for pinpointing where long SQL calls originate from  
     stack_trace_threshold: 0.500
-  
-  # Error collector captures information about uncaught exceptions and sends them to RPM for
-  # viewing
   error_collector:
-    
-    # Error collector is enabled by default. Set this to false to turn it off. This feature
-    # is only available at the Silver and above product levels
     enabled: true
-    
-    # Tells error collector whether or not to capture a source snippet around the place of the
-    # error when errors are View related.
     capture_source: true    
-    
-    # To stop specific errors from reporting to RPM, set this property to comma separated 
-    # values
-    #
-    #ignore_errors: ActionController::RoutingError, ...
     ignore_errors: IgnoredError
 
-  # (Advanced) Uncomment this to ensure the cpu and memory samplers won't run.  Useful when you
-  # are using the agent to monitor an external resource
-  # disable_samplers: true
-
-# override default settings based on your application's environment
-
-# NOTE if your application has other named environments, you should
-# provide newrelic conifguration settings for these enviromnents here.
-
 development:
   <<: *default_settings
-  # turn off communication to RPM service in development mode.
-  # NOTE: for initial evaluation purposes, you may want to temporarily turn
-  # the agent on in development mode.
-  enabled: true
-
-  # When running in Developer Mode, the New Relic Agent will present 
-  # performance information on the last 100 transactions you have 
-  # executed since starting the mongrel.  to view this data, go to 
-  # http://localhost:3000/newrelic
   developer: true
 
 test:
   <<: *default_settings
-  # it almost never makes sense to turn on the agent when running unit, functional or
-  # integration tests or the like.
-  enabled: true
-  log_level: debug
 
-# Turn on the agent in production for 24x7 monitoring.  NewRelic testing shows
-# an average performance impact of < 5 ms per transaction, you you can leave this on
-# all the time without incurring any user-visible performance degredation.
 production:
   <<: *default_settings
-  enabled: true
 
-# many applications have a staging environment which behaves identically to production.
-# Support for that environment is provided here.  By default, the staging environment has
-# the agent turned on.
 staging:
   <<: *default_settings
-  enabled: true
-  app_name: My Application (Staging)

data/test/multiverse/suites/rails/error_tracing_test.rb

@@ -1,7 +1,7 @@
 # https://newrelic.atlassian.net/browse/RUBY-747
 
 require 'rails/test_help'
-require 'fake_service'
+require 'fake_collector'
 
 class ErrorController < ApplicationController
   include Rails.application.routes.url_helpers
@@ -42,24 +42,31 @@ class ServerIgnoredError < StandardError; end
 
 class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
   def setup
-    NewRelic::Agent::Agent.instance_variable_set(:@instance, NewRelic::Agent::Agent.new)
-
-    @service = NewRelic::FakeService.new
-    NewRelic::Agent::Agent.instance.service = @service
-
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    setup_collector
+    $collector.run
+
+    NewRelic::Agent.reset_config
+    NewRelic::Agent.instance_variable_set(:@agent, nil)
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
     NewRelic::Agent.manual_start
 
     reset_error_collector
   end
 
+  # Let base class override this without moving where we start the agent
+  def setup_collector
+    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
+  end
+
   def teardown
     NewRelic::Agent::Agent.instance.shutdown if NewRelic::Agent::Agent.instance
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
   end
 
   def reset_error_collector
-    @error_collector = NewRelic::Agent.instance.error_collector
-    NewRelic::Agent.instance.error_collector \
-      .instance_variable_set(:@ignore_filter, nil)
+    @error_collector = NewRelic::Agent::Agent.instance.error_collector
 
     # sanity checks
     assert(@error_collector.enabled?,
@@ -96,6 +103,16 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
     assert_error_reported_once('this error should be noticed')
   end
 
+  # Important choice of controllor_error, since this goes through both the
+  # metric_frame and the rack error collector, so risks multiple counting!
+  def test_should_capture_multiple_errors
+    40.times do
+      get '/error/controller_error'
+    end
+
+    assert_errors_reported('this is an uncaught controller error', 20, 40)
+  end
+
   def test_should_capture_manually_noticed_error
     NewRelic::Agent.notice_error(RuntimeError.new('this is a noticed error'))
     assert_error_reported_once('this is a noticed error')
@@ -143,29 +160,30 @@ class ErrorsWithoutSSCTest < ActionDispatch::IntegrationTest
 
  protected
 
+  def assert_errors_reported(message, queued_count, total_count=queued_count)
+    error_count = NewRelic::Agent::Agent.instance.stats_engine.get_stats("Errors/all")
+    assert_equal total_count, error_count.call_count
+
+    assert_equal(queued_count,
+      @error_collector.errors.select{|error| error.message == message}.size,
+      "Wrong number of errors with message '#{message} found'")
+  end
+
   def assert_error_reported_once(message)
-    assert_equal(message,
-                 @error_collector.errors[0].message,
-                 'This error type was not detected')
-    assert_equal(1, @error_collector.errors.size,
-                 'Too many of this error type was detected')
+    assert_errors_reported(message, 1)
   end
 end
 
 class ErrorsWithSSCTest < ErrorsWithoutSSCTest
-  def setup
-    super
-    @service.mock['connect'] = {
+  def setup_collector
+    $collector.mock['connect'] = [200, {'return_value' => {
       "listen_to_server_config" => true,
       "agent_run_id" => 1,
       "error_collector.ignore_errors" => 'IgnoredError,ServerIgnoredError',
       "error_collector.enabled" => true,
       "error_collector.capture_source" => true,
       "collect_errors" => true
-    }
-
-    # Force us to apply the mocked connect values to our configuration
-    NewRelic::Agent.instance.query_server_for_configuration
+    }}]
   end
 
   def test_should_notice_server_ignored_error_if_no_server_side_config

data/test/multiverse/suites/rails/gc_instrumentation_test.rb

@@ -7,22 +7,13 @@ if (defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise/) ||
 class GcController < ApplicationController
   include Rails.application.routes.url_helpers
   def gc_action
-    GC.disable
-
     long_string = "01234567" * 100_000
     long_string = nil
     another_long_string = "01234567" * 100_000
 
-    start = Time.now
-    GC.enable
     GC.start
-    stop = Time.now
-
-    @duration = stop.to_f - start.to_f
 
-    render :text => @duration.to_s
-  ensure
-    GC.enable
+    render :text => 'ha'
   end
 end
 
@@ -33,8 +24,7 @@ class GCRailsInstrumentationTest < ActionController::TestCase
 
     @controller = GcController.new
     NewRelic::Agent.instance.stats_engine.reset_stats
-    NewRelic::Agent.instance.transaction_sampler \
-      .instance_variable_set(:@samples, [])
+    NewRelic::Agent.instance.transaction_sampler.instance_variable_set(:@samples, [])
     NewRelic::Agent.manual_start
   end
 
@@ -43,26 +33,38 @@ class GCRailsInstrumentationTest < ActionController::TestCase
   end
 
   def test_records_accurate_time_for_gc_activity
+    start = Time.now
     get :gc_action
+    elapsed = Time.now.to_f - start.to_f
 
-    assert_in_delta(assigns[:duration],
-                    NewRelic::Agent.agent.stats_engine \
-                      .get_stats('GC/cumulative') \
-                      .total_call_time, 0.2,
-                    'problem with unscoped GC metric')
-    assert_in_delta(assigns[:duration],
-                    NewRelic::Agent.agent.stats_engine \
-                      .get_stats('GC/cumulative', true, false,
-                                 'Controller/gc/gc_action') \
-                      .total_call_time, 0.2,
-                    'problem with scoped GC metric')
+    assert_in_range(elapsed, get_call_time('GC/cumulative'))
+    assert_in_range(elapsed, get_call_time('GC/cumulative', 'Controller/gc/gc_action'))
   end
 
   def test_records_transaction_param_for_gc_activity
+    start = Time.now.to_f
     get :gc_action
+    elapsed = Time.now.to_f - start
 
     trace = NewRelic::Agent.instance.transaction_sampler.last_sample
-    assert_in_delta(assigns[:duration], trace.params[:custom_params][:gc_time], 0.2)
+    assert_in_range(elapsed, trace.params[:custom_params][:gc_time])
+  end
+
+  def assert_in_range(duration, gc_time)
+    assert gc_time > 0.0, "GC Time wasn't recorded!"
+
+    # This is a guess for a reasonable threshold here.
+    # Since these are timing based, we can revise or ditch as evidence ditacts
+    # One CI failure we saw at least had duration=0.314 and gc_time=0.088
+    ratio = gc_time / duration
+    assert(ratio > 0.1 && ratio < 1.0,
+      "Problem with GC/duration ratio. #{gc_time}/#{duration} = #{ratio} not between 0.1 and 1.0")
+  end
+
+  def get_call_time(name, scope=nil)
+    NewRelic::Agent.agent.stats_engine.
+      get_stats(name, true, false, scope).
+      total_call_time
   end
 
   def enable_gc_stats

data/test/multiverse/suites/resque/Rakefile

@@ -1,2 +1,8 @@
 require File.join(File.dirname(__FILE__), 'resque_setup')
 require 'resque/tasks'
+
+task "resque:setup" do
+  if ENV['BROKEN_AFTER_FORK']
+    Resque.before_fork = Proc.new { 'doot de doo' }
+  end
+end

data/test/multiverse/suites/resque/instrumentation_test.rb

@@ -28,15 +28,19 @@ class ResqueTest < Test::Unit::TestCase
   end
 
   def start_worker(opts={})
-    opts[:background] ? start_worker_background : start_worker_child
+    if opts[:background]
+      start_worker_background(opts[:env_vars])
+    else
+      start_worker_child(opts[:env_vars])
+    end
   end
 
   def stop_worker(opts={})
     opts[:background] ? stop_worker_background : stop_worker_child
   end
 
-  def start_worker_child
-    worker_cmd = "NEWRELIC_DISPATCHER=resque QUEUE=* bundle exec rake resque:work"
+  def start_worker_child(env_vars=nil)
+    worker_cmd = "NEWRELIC_DISPATCHER=resque #{env_vars} QUEUE=* bundle exec rake resque:work"
     @worker_pid = Process.fork
     Process.exec(worker_cmd) if @worker_pid.nil?
   end
@@ -46,9 +50,9 @@ class ResqueTest < Test::Unit::TestCase
     Process.waitpid(@worker_pid)
   end
 
-  def start_worker_background
+  def start_worker_background(env_vars=nil)
     worker_cmd = "PIDFILE=#{@pidfile} TERM_CHILD=1 RESQUE_TERM_TIMEOUT=1 BACKGROUND=1 " +
-      "NEWRELIC_DISPATCHER=resque QUEUE=* bundle exec rake resque:work"
+      "NEWRELIC_DISPATCHER=resque #{env_vars} QUEUE=* bundle exec rake resque:work"
     system(worker_cmd)
   end
 
@@ -123,6 +127,15 @@ class ResqueTest < Test::Unit::TestCase
     assert_metric_and_call_count('OtherTransaction/ResqueJob/all', JOB_COUNT)
   end
 
+  def test_log_properly_when_fork_callbacks_are_broken
+    log_path = File.join(File.dirname(__FILE__), 'agent.log', 'newrelic_agent.log')
+    File.delete(log_path)
+
+    run_worker(:env_vars => 'BROKEN_AFTER_FORK=true')
+
+    assert File.read(log_path).include?('Unable to send data to parent process')
+  end
+
   if RUBY_VERSION >= '1.9'
     def test_all_jobs_ran_background
       run_worker(:background => true)