newrelic_rpm 3.7.2.190.beta → 3.7.2.192

data/lib/new_relic/agent/transaction_sampler.rb

@@ -211,9 +211,6 @@ module NewRelic
           statement.adapter = config[:adapter]
           statement.config = config
         end
-        if Agent.config[:override_sql_obfuscation_adapter]
-          statement.adapter = Agent.config[:override_sql_obfuscation_adapter]
-        end
         statement.explainer = explainer
 
         statement

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -67,6 +67,9 @@ module Sequel
       engine.record_metrics( metrics, duration, :scoped => false )
     end
 
+    THREAD_SAFE_CONNECTION_POOL_CLASSES = [
+      (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool),
+    ].compact.freeze
 
     # Record the given +sql+ within a new scope, using the given +start+ and
     # +finish+ times.
@@ -77,12 +80,16 @@ module Sequel
 
       begin
         scope = agent.stats_engine.push_scope( :sequel, start )
-        agent.transaction_sampler.notice_sql( sql, self.opts, duration ) do |*|
-          self[ sql ].explain
-        end
-        agent.sql_sampler.notice_sql( sql, metric, self.opts, duration ) do |*|
-          self[ sql ].explain
+        explainer = Proc.new do |*|
+          if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
+            self[ sql ].explain
+          else
+            NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, "Not running SQL explains because Sequel is not in recognized multi-threaded mode")
+            nil
+          end
         end
+        agent.transaction_sampler.notice_sql( sql, self.opts, duration, &explainer )
+        agent.sql_sampler.notice_sql( sql, metric, self.opts, duration, &explainer )
       ensure
         agent.stats_engine.pop_scope( scope, metric, finish )
       end

data/test/helpers/mongo_metric_builder.rb

@@ -15,7 +15,7 @@ module NewRelic
         )
       end
 
-      def metrics_with_attributes(metrics, attributes)
+      def metrics_with_attributes(metrics, attributes = { :call_count => 1 })
         metric_attributes = {}
 
         metrics.each do |metric|

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

@@ -70,7 +70,7 @@ class ThreadProfilingTest < MiniTest::Unit::TestCase
 
     profile_data = $collector.calls_for('profile_data')[0]
     assert_equal('666', profile_data.run_id, "Missing run_id, profile_data was #{profile_data.inspect}")
-    assert(profile_data.sample_count > 10, "Expected sample_count > 10, but was #{profile_data.sample_count}")
+    assert(profile_data.sample_count >= 2, "Expected sample_count >= 2, but was #{profile_data.sample_count}")
 
     assert_saw_traces(profile_data, "OTHER")
     assert_saw_traces(profile_data, "AGENT")
@@ -90,7 +90,7 @@ class ThreadProfilingTest < MiniTest::Unit::TestCase
 
     profile_data = $collector.calls_for('profile_data')[0]
     assert_equal('666', profile_data.run_id, "Missing run_id, profile_data was #{profile_data.inspect}")
-    assert(profile_data.sample_count > 10, "Expected sample_count > 10, but was #{profile_data.sample_count}")
+    assert(profile_data.sample_count >= 2, "Expected sample_count >= 2, but was #{profile_data.sample_count}")
 
     assert_saw_traces(profile_data, "OTHER")
     assert_saw_traces(profile_data, "AGENT")

data/test/multiverse/suites/mongo/Envfile

@@ -17,13 +17,24 @@ RB
 require 'timeout'
 require 'socket'
 
-ENV["MONGO_HOST"] = "localhost" unless ENV["MONGO_HOST"]
-ENV["MONGO_PORT"] = "27017" unless ENV["MONGO_PORT"]
+class PreExistingMongo
+  attr_reader :host, :port
+
+  def initialize(host, port)
+    @host = host
+    @port = port
+  end
+
+  def stop(*_)
+  end
+end
+
+$mongo = PreExistingMongo.new("localhost", 27017)
 
 def mongo_running?
   Timeout::timeout(1) do
     begin
-      TCPSocket.new(ENV["MONGO_HOST"], ENV["MONGO_PORT"].to_i).close
+      TCPSocket.new($mongo.host, $mongo.port).close
       true
     rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
       false
@@ -33,34 +44,14 @@ rescue Timeout::Error
   false
 end
 
-def wait_for_mongo
-  Timeout::timeout(10) do
-    until mongo_running? do
-      sleep(0.1)
-    end
-  end
-end
-
 before_suite do
-  if mongo_running?
-    $started_mongo = false
-  else
-    puts "Starting Mongo for you, will shut down after tests"
-    `mkdir -p tmp`
-    `mongod --port #{ENV["MONGO_PORT"]} --pidfilepath tmp/mongo.pid &`
-    wait_for_mongo
-
-    $started_mongo = true
-    puts "Mongo Mongo Mongo!"
+  if !mongo_running?
+    require File.join(File.dirname(__FILE__), 'helpers', 'mongo_server')
+    $mongo = MongoServer.new
+    $mongo.start(false)
   end
 end
 
 after_suite do
-  if $started_mongo
-    puts "Shutting down test initiated Mongo."
-    mongo_pid = `cat tmp/mongo.pid`
-    `kill -9 #{mongo_pid}`
-    `rm tmp/mongo.pid`
-    puts "Mongo Mongo Mongo!"
-  end
+  $mongo.stop
 end

data/test/multiverse/suites/mongo/helpers/mongo_operation_tests.rb

@@ -0,0 +1,437 @@
+# 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.
+
+module MongoOperationTests
+  def test_records_metrics_for_insert
+    @collection.insert(@tribble)
+
+    metrics = build_test_metrics(:insert)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_find
+    @collection.insert(@tribble)
+    NewRelic::Agent.drop_buffered_data
+
+    @collection.find(@tribble).to_a
+
+    metrics = build_test_metrics(:find)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_find_one
+    @collection.insert(@tribble)
+    NewRelic::Agent.drop_buffered_data
+
+    @collection.find_one
+
+    metrics = build_test_metrics(:findOne)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_remove
+    @collection.insert(@tribble)
+    NewRelic::Agent.drop_buffered_data
+
+    @collection.remove(@tribble).to_a
+
+    metrics = build_test_metrics(:remove)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_save
+    @collection.save(@tribble)
+
+    metrics = build_test_metrics(:save)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_save_does_not_record_insert
+    @collection.save(@tribble)
+
+    metrics = build_test_metrics(:save)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_not_recorded(['Datastore/operation/MongoDB/insert'])
+  end
+
+  def test_records_metrics_for_update
+    updated = @tribble.dup
+    updated['name'] = 'codemonkey'
+
+    @collection.update(@tribble, updated)
+
+    metrics = build_test_metrics(:update)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_distinct
+    @collection.distinct('name')
+
+    metrics = build_test_metrics(:distinct)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_count
+    @collection.count
+
+    metrics = build_test_metrics(:count)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_group
+    @collection.group({:key => "name",
+                       :initial => {:count => 0},
+                       :reduce => "function(k,v) { v.count += 1; }" })
+
+    metrics = build_test_metrics(:group)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_find_and_modify
+    updated = @tribble.dup
+    updated['name'] = 'codemonkey'
+    @collection.find_and_modify(:query => @tribble, :update => updated)
+
+    metrics = build_test_metrics(:findAndModify)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_find_and_remove
+    @collection.find_and_modify(:query => @tribble, :remove =>true)
+
+    metrics = build_test_metrics(:findAndRemove)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_create_index
+    @collection.create_index([[unique_field_name, Mongo::ASCENDING]])
+
+    metrics = build_test_metrics(:createIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_ensure_index
+    @collection.ensure_index([[unique_field_name, Mongo::ASCENDING]])
+
+    metrics = build_test_metrics(:ensureIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_ensure_index_with_symbol
+    @collection.ensure_index(unique_field_name.to_sym)
+
+    metrics = build_test_metrics(:ensureIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_ensure_index_with_string
+    @collection.ensure_index(unique_field_name)
+
+    metrics = build_test_metrics(:ensureIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_ensure_index_does_not_record_insert
+    @collection.ensure_index([[unique_field_name, Mongo::ASCENDING]])
+
+    assert_metrics_not_recorded(['Datastore/operation/MongoDB/insert'])
+  end
+
+  def test_ensure_index_does_call_ensure_index
+    options = [[unique_field_name, Mongo::ASCENDING]]
+
+    @collection.expects(:ensure_index_without_new_relic_trace).with(options, any_parameters).once
+    @collection.ensure_index(options)
+  end
+
+  def test_records_metrics_for_drop_index
+    name =  @collection.create_index([[unique_field_name, Mongo::ASCENDING]])
+    NewRelic::Agent.drop_buffered_data
+
+    @collection.drop_index(name)
+
+    metrics = build_test_metrics(:dropIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_drop_indexes
+    @collection.create_index([[unique_field_name, Mongo::ASCENDING]])
+    NewRelic::Agent.drop_buffered_data
+
+    @collection.drop_indexes
+
+    metrics = build_test_metrics(:dropIndexes)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_records_metrics_for_reindex
+    @collection.create_index([[unique_field_name, Mongo::ASCENDING]])
+    NewRelic::Agent.drop_buffered_data
+
+    @database.command({ :reIndex => @collection_name })
+
+    metrics = build_test_metrics(:reIndex)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_rename_collection
+    ensure_collection_exists
+
+    @collection.rename("renamed_#{@collection_name}")
+
+    metrics = build_test_metrics(:renameCollection)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  ensure
+    @collection_name = "renamed_#{@collection_name}"
+  end
+
+  def test_rename_collection_via_db
+    ensure_collection_exists
+
+    @database.rename_collection(@collection_name, "renamed_#{@collection_name}")
+
+    metrics = build_test_metrics(:renameCollection)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  ensure
+    @collection_name = "renamed_#{@collection_name}"
+  end
+
+  def test_drop_collection
+    ensure_collection_exists
+
+    @database.drop_collection(@collection_name)
+
+    metrics = build_test_metrics(:drop)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_collstats
+    @collection.insert(@tribble)
+    NewRelic::Agent.drop_buffered_data
+    @collection.stats
+
+    metrics = build_test_metrics(:collstats)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_notices_nosql
+    segment = nil
+
+    in_transaction do
+      @collection.insert(@tribble)
+      segment = find_last_transaction_segment
+    end
+
+    expected = { :database   => @database_name,
+                 :collection => @collection_name,
+                 :operation  => :insert}
+
+    result = segment.params[:statement]
+
+    assert_equal expected, result, "Expected result (#{result}) to be #{expected}"
+  end
+
+  def test_noticed_nosql_includes_operation
+    segment = nil
+
+    in_transaction do
+      @collection.insert(@tribble)
+      segment = find_last_transaction_segment
+    end
+
+    expected = :insert
+
+    query = segment.params[:statement]
+    result = query[:operation]
+
+    assert_equal expected, result
+  end
+
+  def test_noticed_nosql_includes_save_operation
+    segment = nil
+
+    in_transaction do
+      @collection.save(@tribble)
+      segment = find_last_transaction_segment
+    end
+
+    expected = :save
+
+    query = segment.params[:statement]
+    result = query[:operation]
+
+    assert_equal expected, result
+  end
+
+  def test_noticed_nosql_includes_ensure_index_operation
+    segment = nil
+
+    in_transaction do
+      @collection.ensure_index([[unique_field_name, Mongo::ASCENDING]])
+      segment = find_last_transaction_segment
+    end
+
+    assert_ensure_index_in_transaction_segment(segment)
+  end
+
+  def test_noticed_nosql_includes_ensure_index_operation_with_symbol
+    segment = nil
+
+    in_transaction do
+      @collection.ensure_index(unique_field_name.to_sym)
+      segment = find_last_transaction_segment
+    end
+
+    assert_ensure_index_in_transaction_segment(segment)
+  end
+
+  def test_noticed_nosql_includes_ensure_index_operation_with_string
+    segment = nil
+
+    in_transaction do
+      @collection.ensure_index(unique_field_name)
+      segment = find_last_transaction_segment
+    end
+
+    assert_ensure_index_in_transaction_segment(segment)
+  end
+
+  def assert_ensure_index_in_transaction_segment(segment)
+    query = segment.params[:statement]
+    result = query[:operation]
+
+    assert_equal :ensureIndex, result
+  end
+
+  def test_noticed_nosql_does_not_contain_documents
+    segment = nil
+
+    in_transaction do
+      @collection.insert({'name' => 'soterios johnson'})
+      segment = find_last_transaction_segment
+    end
+
+    statement = segment.params[:statement]
+
+    refute statement.keys.include?(:documents), "Noticed NoSQL should not include documents: #{statement}"
+  end
+
+  def test_noticed_nosql_does_not_contain_selector_values
+    @collection.insert({'password' => '$ecret'})
+    segment = nil
+
+    in_transaction do
+      @collection.remove({'password' => '$ecret'})
+      segment = find_last_transaction_segment
+    end
+
+    statement = segment.params[:statement]
+
+    assert_equal '?', statement[:selector]['password']
+  end
+
+  def test_web_requests_record_all_web_metric
+    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+    @collection.insert(@tribble)
+
+    metrics = build_test_metrics(:insert)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_web_requests_do_not_record_all_other_metric
+    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+    @collection.insert(@tribble)
+
+    assert_metrics_not_recorded(['Datastore/allOther'])
+  end
+
+  def test_other_requests_record_all_other_metric
+    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(false)
+    @collection.insert(@tribble)
+
+    metrics = build_test_metrics(:insert, :other)
+    expected = metrics_with_attributes(metrics)
+
+    assert_metrics_recorded(expected)
+  end
+
+  def test_other_requests_do_not_record_all_web_metric
+    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(false)
+    @collection.insert(@tribble)
+
+    assert_metrics_not_recorded(['Datastore/allWeb'])
+  end
+
+  def test_insert_records_instance_metric
+    @collection.insert(@tribble)
+    assert_metrics_recorded(["Datastore/instance/MongoDB/localhost:#{@client.port}/#{@database_name}"])
+  end
+
+  def test_save_records_instance_metric
+    @collection.save(@tribble)
+    assert_metrics_recorded(["Datastore/instance/MongoDB/localhost:#{@client.port}/#{@database_name}"])
+  end
+
+  def test_ensure_index_records_instance_metric
+    @collection.ensure_index([[unique_field_name, Mongo::ASCENDING]])
+    assert_metrics_recorded(["Datastore/instance/MongoDB/localhost:#{@client.port}/#{@database_name}"])
+  end
+
+  def unique_field_name
+    "field#{SecureRandom.hex(10)}"
+  end
+
+  def ensure_collection_exists
+    @collection.insert(:junk => "data")
+    NewRelic::Agent.drop_buffered_data
+  end
+
+end