newrelic_rpm 3.9.6.257 → 3.9.7.266

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

@@ -0,0 +1,18 @@
+---
+development:
+  error_collector:
+    enabled: true
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  transaction_trace:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false

data/test/multiverse/suites/delayed_job/delayed_job_sampler_test.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'multiverse_helpers'
+require 'minitest/unit'
+
+require 'new_relic/delayed_job_injection'
+
+if NewRelic::Agent::Samplers::DelayedJobSampler.supported_backend?
+  class DelayedJobSamplerTest < Minitest::Test
+    include MultiverseHelpers
+
+    TestWorker = Struct.new(:name, :read_ahead)
+
+    setup_and_teardown_agent do
+      NewRelic::DelayedJobInjection.worker_name = "delayed"
+      @worker = TestWorker.new("delayed", 1)
+      @sampler = NewRelic::Agent::Samplers::DelayedJobSampler.new
+    end
+
+    def after_teardown
+      # This appears in the base delayed_job gem even after the adapter split
+      # so it appears to be safe to call across adapters
+      Delayed::Job.delete_all
+    end
+
+    class IWantToWait
+      def take_action
+      end
+    end
+
+    def test_cant_create_without_injection
+      NewRelic::DelayedJobInjection.worker_name = nil
+      assert_raises(NewRelic::Agent::Sampler::Unsupported) do
+        NewRelic::Agent::Samplers::DelayedJobSampler.new
+      end
+    end
+
+    def test_sampler_no_failures_or_locks
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/failed_jobs"      => { :total_call_time => 0 },
+        "Workers/DelayedJob/locked_jobs"      => { :total_call_time => 0 })
+    end
+
+    def test_sampler_sees_failures
+      job = IWantToWait.new.delay.take_action
+
+      return unless job.respond_to?(:fail!)
+      job.fail!
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/failed_jobs" => { :total_call_time => 1 })
+    end
+
+    def test_sampler_sees_locks
+      IWantToWait.new.delay.take_action
+      ::Delayed::Job.reserve(@worker)
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/locked_jobs" => { :total_call_time => 1 })
+    end
+
+    def test_sampler_queue_depth_with_job
+      IWantToWait.new.delay.take_action
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/queue_length/priority/0" => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/all"        => { :total_call_time => 1 })
+    end
+
+    def test_sampler_queue_depth_with_alternate_priority
+      IWantToWait.new.delay(:priority => 7).take_action
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/queue_length/priority/7" => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/all"        => { :total_call_time => 1 })
+    end
+
+    def test_sampler_queue_depth_with_default_queue
+      return unless Delayed::Job.instance_methods.include?(:queue)
+
+      IWantToWait.new.delay.take_action
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/queue_length/name/default" => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/all"          => { :total_call_time => 1 })
+    end
+
+    def test_sampler_queue_depth_with_alternate_queues
+      return unless Delayed::Job.instance_methods.include?(:queue)
+
+      IWantToWait.new.delay(:queue => "cue").take_action
+      IWantToWait.new.delay(:queue => "cute").take_action
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/queue_length/name/cue"   => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/name/cute"  => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/all"        => { :total_call_time => 2 })
+    end
+
+    def test_sampler_queue_depth_with_queues_and_priorities
+      return unless Delayed::Job.instance_methods.include?(:queue)
+
+      IWantToWait.new.delay(:priority => 1, :queue => "cue").take_action
+      IWantToWait.new.delay(:priority => 1, :queue => "cute").take_action
+
+      @sampler.poll
+
+      assert_metrics_recorded(
+        "Workers/DelayedJob/queue_length/name/cue"   => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/name/cute"  => { :total_call_time => 1 },
+        "Workers/DelayedJob/queue_length/priority/1" => { :total_call_time => 2 },
+        "Workers/DelayedJob/queue_length/all"        => { :total_call_time => 2 })
+    end
+  end
+end

data/test/multiverse/suites/delayed_job/unsupported_backend_test.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'multiverse_helpers'
+require 'minitest/unit'
+
+require 'new_relic/delayed_job_injection'
+
+if !NewRelic::Agent::Samplers::DelayedJobSampler.supported_backend?
+  class UnsupportedBackendTest < Minitest::Test
+    include MultiverseHelpers
+
+    setup_and_teardown_agent do
+      NewRelic::DelayedJobInjection.worker_name = "delayed"
+    end
+
+    def test_unsupported_raises_on_instantiation
+      assert_raises(NewRelic::Agent::Sampler::Unsupported) do
+        NewRelic::Agent::Samplers::DelayedJobSampler.new
+      end
+    end
+  end
+end

data/test/multiverse/suites/high_security/high_security_test.rb

@@ -13,14 +13,10 @@ class HighSecurityTest < Minitest::Test
 
   include MultiverseHelpers
 
-  setup_and_teardown_agent do |_collector|
-    $collector = nil
-    setup_collector(true)
-
-    $collector.stub('connect', {
+  setup_and_teardown_agent do |collector|
+    collector.use_ssl = true
+    collector.stub('connect', {
       "agent_run_id" => 1,
-      "listen_to_server_config" => true,
-
       "agent_config" => {
         "capture_params" => true,
       }
@@ -29,9 +25,7 @@ class HighSecurityTest < Minitest::Test
 
   def test_connects_via_ssl_no_matter_what
     assert_equal 1, $collector.calls_for('connect').size
-
     trigger_agent_reconnect(:ssl => false)
-
     assert_equal 2, $collector.calls_for('connect').size
   end
 
@@ -62,5 +56,4 @@ class HighSecurityTest < Minitest::Test
     refute_nil last_transaction_trace.params[:custom_params][:'nr.trip_id']
     refute_nil last_transaction_trace.params[:custom_params][:'nr.path_hash']
   end
-
 end

data/test/multiverse/suites/rails/Envfile

@@ -1,12 +1,12 @@
 if RUBY_VERSION >= '1.9.3'
   gemfile <<-RB
-    gem 'rails', '~>4.2.0.beta2'
+    gem 'rails', '~>4.2.0.beta4'
     gem 'haml', :require => false
     gem 'minitest', '5.2.3'
   RB
 
   gemfile <<-RB
-    gem 'rails', '~>4.1.6'
+    gem 'rails', '~>4.1.7'
     # Multiverse has an incompatibility with Minitest 5.3.0, so lock here for
     # now
     gem 'minitest', '5.2.3'
@@ -16,13 +16,13 @@ if RUBY_VERSION >= '1.9.3'
   RB
 
   gemfile <<-RB
-    gem 'rails', '~>4.0.10'
+    gem 'rails', '~>4.0.11'
     gem 'haml', '4.0.2'   # Getting load issues with haml 4.0.3
   RB
 end
 
 gemfile <<-RB
-  gem 'rails', '~>3.2.16'
+  gem 'rails', '~>3.2.20'
   gem 'haml', '4.0.2'   # Getting load issues with haml 4.0.3
   gem 'minitest_tu_shim', :require => false
 RB

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

@@ -93,11 +93,11 @@ class RequestStatsTest < RailsMultiverseTest
                 :'cross_process_id' => 'boo',
                 :'encoding_key' => "\0",
                 :'trusted_account_ids' => [1]) do
-      request_headers = {
-        'X-NewRelic-ID' => Base64.encode64('1#234'),
-        'X-NewRelic-Transaction' => Base64.encode64('["8badf00d",1]')
+      rack_env = {
+        'HTTP_X_NEWRELIC_ID'          => Base64.encode64('1#234'),
+        'HTTP_X_NEWRELIC_TRANSACTION' => Base64.encode64('["8badf00d",1]')
       }
-      get '/request_stats/cross_app_action', {}, request_headers
+      get '/request_stats/cross_app_action', {}, rack_env
 
       NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
 

data/test/new_relic/agent/agent_test.rb

@@ -97,6 +97,34 @@ module NewRelic
         end
       end
 
+      def test_after_fork_should_not_start_agent_multiple_times
+        with_config(:monitor_mode => true) do
+          $queue = Queue.new
+          def @agent.setup_and_start_agent(*_)
+            $queue << 'started!'
+          end
+
+          # This is a hack to make the race condition that we're trying to test
+          # for more likely for the purposes of this test.
+          harvester = @agent.harvester
+          def harvester.mark_started
+            sleep 0.01
+            super
+          end
+
+          threads = []
+          100.times do
+            threads << Thread.new do
+              @agent.after_fork
+            end
+          end
+
+          threads.each(&:join)
+
+          assert_equal(1, $queue.size)
+        end
+      end
+
       def test_transmit_data_should_emit_before_harvest_event
         got_it = false
         @agent.events.subscribe(:before_harvest) { got_it = true }
@@ -199,7 +227,7 @@ module NewRelic
         @agent.stats_engine.expects(:merge!).never
         @agent.error_collector.expects(:merge!).never
         @agent.transaction_sampler.expects(:merge!).never
-        @agent.instance_variable_get(:@request_sampler).expects(:merge!).never
+        @agent.instance_variable_get(:@transaction_event_aggregator).expects(:merge!).never
         @agent.sql_sampler.expects(:merge!).never
         @agent.merge_data_for_endpoint(:metric_data, [])
         @agent.merge_data_for_endpoint(:transaction_sample_data, [])
@@ -232,11 +260,11 @@ module NewRelic
 
       def test_harvest_and_send_analytic_event_data_merges_in_samples_on_failure
         service = @agent.service
-        request_sampler = @agent.instance_variable_get(:@request_sampler)
+        transaction_event_aggregator = @agent.instance_variable_get(:@transaction_event_aggregator)
         samples = [mock('some analytics event')]
 
-        request_sampler.expects(:harvest!).returns(samples)
-        request_sampler.expects(:merge!).with(samples)
+        transaction_event_aggregator.expects(:harvest!).returns(samples)
+        transaction_event_aggregator.expects(:merge!).with(samples)
 
         # simulate a failure in transmitting analytics events
         service.stubs(:analytic_event_data).raises(StandardError.new)

data/test/new_relic/agent/configuration/default_source_test.rb

@@ -98,6 +98,12 @@ module NewRelic::Agent::Configuration
       assert_equal ['Foo'], result
     end
 
+    def test_convert_to_list_raises_on_totally_wrong_object
+      assert_raises(ArgumentError) do
+        DefaultSource.convert_to_list(Object.new)
+      end
+    end
+
     def test_rules_ignore_converts_comma_delimited_string_to_array
       with_config(:'rules.ignore_url_regexes' => 'Foo,Bar,Baz') do
         assert_equal [/Foo/, /Bar/, /Baz/], NewRelic::Agent.config[:'rules.ignore_url_regexes']

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -6,8 +6,9 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 
 module NewRelic::Agent
   class CrossAppMonitorTest < Minitest::Test
-    NEWRELIC_ID_HEADER        = NewRelic::Agent::CrossAppMonitor::NEWRELIC_ID_HEADER
-    NEWRELIC_TXN_HEADER       = NewRelic::Agent::CrossAppMonitor::NEWRELIC_TXN_HEADER
+    NEWRELIC_ID_HEADER        = NewRelic::Agent::CrossAppMonitor::NEWRELIC_ID_HEADER_KEY
+    NEWRELIC_TXN_HEADER       = NewRelic::Agent::CrossAppMonitor::NEWRELIC_TXN_HEADER_KEY
+    CONTENT_LENGTH_KEY        = "HTTP_CONTENT_LENGTH"
 
     AGENT_CROSS_APP_ID        = "qwerty"
     REQUEST_CROSS_APP_ID      = "42#1234"
@@ -29,19 +30,20 @@ module NewRelic::Agent
 
     def setup
       NewRelic::Agent.reset_config
-      NewRelic::Agent.instance.stats_engine.clear_stats
-      NewRelic::Agent.instance.events.clear
+      NewRelic::Agent.drop_buffered_data
+      @events = NewRelic::Agent::EventListener.new
       @response = {}
 
-      @monitor = NewRelic::Agent::CrossAppMonitor.new
+      @monitor = NewRelic::Agent::CrossAppMonitor.new(@events)
       @config = {
-        :cross_process_id    => AGENT_CROSS_APP_ID,
-        :encoding_key        => ENCODING_KEY_NOOP,
-        :trusted_account_ids => TRUSTED_ACCOUNT_IDS
+        :cross_process_id       => AGENT_CROSS_APP_ID,
+        :encoding_key           => ENCODING_KEY_NOOP,
+        :trusted_account_ids    => TRUSTED_ACCOUNT_IDS,
+        :disable_harvest_thread => true
       }
 
       NewRelic::Agent.config.add_config_for_testing(@config)
-      @monitor.on_finished_configuring
+      @events.notify(:finished_configuring)
     end
 
     def teardown
@@ -124,17 +126,13 @@ module NewRelic::Agent
     def test_includes_content_length
       with_default_timings
 
-      when_request_runs(for_id(REQUEST_CROSS_APP_ID).merge("Content-Length" => 3000))
+      when_request_runs(for_id(REQUEST_CROSS_APP_ID).merge(CONTENT_LENGTH_KEY => 3000))
       assert_equal 3000, unpacked_response[CONTENT_LENGTH_POSITION]
     end
 
     def test_finds_content_length_from_headers
-      %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH cOnTeNt-LeNgTh}.each do |key|
-        request = { key => 42 }
-
-        assert_equal(42, @monitor.content_length_from_request(request), \
-          "Failed to find header on key #{key}")
-      end
+      request = { 'HTTP_CONTENT_LENGTH' => 42 }
+      assert_equal(42, @monitor.content_length_from_request(request))
     end
 
     def test_writes_custom_parameters
@@ -181,25 +179,23 @@ module NewRelic::Agent
     def test_setting_response_headers_freezes_transaction_name
       in_transaction do
         request = for_id(REQUEST_CROSS_APP_ID)
-        event_listener = NewRelic::Agent.instance.events
-        event_listener.notify(:before_call, request)
+        @events.notify(:before_call, request)
 
         assert !NewRelic::Agent::Transaction.tl_current.name_frozen?
-        event_listener.notify(:after_call, request, [200, @response, ''])
+        @events.notify(:after_call, request, [200, @response, ''])
         assert NewRelic::Agent::Transaction.tl_current.name_frozen?
       end
     end
 
     def test_listener_in_other_thread_has_correct_txn_state
       t = Thread.new do
-        event_listener = NewRelic::Agent.instance.events
         in_transaction('transaction') do
           request = for_id(REQUEST_CROSS_APP_ID)
 
-          event_listener.notify(:before_call, request)
+          @events.notify(:before_call, request)
           # Fake out our GUID for easier comparison in tests
           NewRelic::Agent::Transaction.tl_current.stubs(:guid).returns(TRANSACTION_GUID)
-          event_listener.notify(:after_call, request, [200, @response, ''])
+          @events.notify(:after_call, request, [200, @response, ''])
         end
       end
 
@@ -229,21 +225,19 @@ module NewRelic::Agent
     #
 
     def when_request_runs(request=for_id(REQUEST_CROSS_APP_ID))
-      event_listener = NewRelic::Agent.instance.events
       in_transaction('transaction') do
-        event_listener.notify(:before_call, request)
+        @events.notify(:before_call, request)
         # Fake out our GUID for easier comparison in tests
         NewRelic::Agent::Transaction.tl_current.stubs(:guid).returns(TRANSACTION_GUID)
-        event_listener.notify(:after_call, request, [200, @response, ''])
+        @events.notify(:after_call, request, [200, @response, ''])
       end
     end
 
     def when_request_has_error(request=for_id(REQUEST_CROSS_APP_ID))
       options = {}
-      event_listener = NewRelic::Agent.instance.events
-      event_listener.notify(:before_call, request)
-      event_listener.notify(:notice_error, nil, options)
-      event_listener.notify(:after_call, request, [500, @response, ''])
+      @events.notify(:before_call, request)
+      @events.notify(:notice_error, nil, options)
+      @events.notify(:after_call, request, [500, @response, ''])
 
       options
     end

data/test/new_relic/agent/custom_event_aggregator_test.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
+
+require 'new_relic/agent/custom_event_aggregator'
+
+module NewRelic::Agent
+  class CustomEventAggregatorTest < Minitest::Test
+    def setup
+      freeze_time
+      @aggregator = NewRelic::Agent::CustomEventAggregator.new
+    end
+
+    # Helpers for DataContainerTests
+
+    def create_container
+      @aggregator
+    end
+
+    def populate_container(container, n)
+      n.times do |i|
+        container.record(:atype, { :number => i })
+      end
+    end
+
+    include NewRelic::DataContainerTests
+
+    def test_record_by_default_limit
+      max_samples = NewRelic::Agent.config[:'custom_insights_events.max_samples_stored']
+      n = max_samples + 1
+      n.times do |i|
+        @aggregator.record(:footype, :number => i)
+      end
+
+      results = @aggregator.harvest!
+      assert_equal(max_samples, results.size)
+    end
+
+    def test_lowering_limit_truncates_buffer
+      orig_max_samples = NewRelic::Agent.config[:'custom_insights_events.max_samples_stored']
+
+      orig_max_samples.times do |i|
+        @aggregator.record(:footype, :number => i)
+      end
+
+      new_max_samples = orig_max_samples - 10
+      with_config(:'custom_insights_events.max_samples_stored' => new_max_samples) do
+        results = @aggregator.harvest!
+        assert_equal(new_max_samples, results.size)
+      end
+    end
+
+    def test_merge_respects_event_limits_by_type
+      with_config(:'custom_insights_events.max_samples_stored' => 10) do
+        11.times do |i|
+          @aggregator.record(:t, :foo => :bar)
+        end
+        old_events = @aggregator.harvest!
+
+        3.times do |i|
+          @aggregator.record(:t, :foo => :bar)
+        end
+
+        @aggregator.merge!(old_events)
+
+        events = @aggregator.harvest!
+
+        assert_equal(10, events.size)
+      end
+    end
+
+    def test_record_adds_type_and_timestamp_and_source
+      t0 = Time.now
+      @aggregator.record(:type_a, :foo => :bar, :baz => :qux)
+
+      events = @aggregator.harvest!
+
+      assert_equal(1, events.size)
+      event = events.first
+
+      assert_equal({ 'type' => 'type_a', 'timestamp' => t0.to_i, 'source' => 'Agent' }, event[0])
+      assert_equal({ 'foo'  => 'bar'   , 'baz'       => 'qux'                        }, event[1])
+    end
+  end
+end