newrelic_rpm 3.13.0.299 → 3.13.1.300

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

@@ -11,12 +11,27 @@ DependencyDetection.defer do
 
   depends_on do
     require 'new_relic/agent/datastores/mongo'
+    if NewRelic::Agent::Datastores::Mongo.is_unsupported_2x?
+      NewRelic::Agent.logger.log_once(:info, :mongo2, 'Detected unsupported Mongo 2, upgrade your Mongo Driver to 2.1 or newer for instrumentation')
+    end
     NewRelic::Agent::Datastores::Mongo.is_supported_version?
   end
 
   executes do
     NewRelic::Agent.logger.info 'Installing Mongo instrumentation'
-    install_mongo_instrumentation
+    if NewRelic::Agent::Datastores::Mongo.is_monitoring_enabled?
+      install_mongo_command_subscriber
+    else
+      install_mongo_instrumentation
+    end
+  end
+
+  def install_mongo_command_subscriber
+    require 'new_relic/agent/instrumentation/mongodb_command_subscriber'
+    Mongo::Monitoring::Global.subscribe(
+      Mongo::Monitoring::COMMAND,
+      NewRelic::Agent::Instrumentation::MongodbCommandSubscriber.new
+    )
   end
 
   def install_mongo_instrumentation

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

@@ -0,0 +1,74 @@
+# 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 'new_relic/agent/datastores/mongo/event_formatter'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class MongodbCommandSubscriber
+
+        MONGODB = 'MongoDB'.freeze
+
+        def started(event)
+          begin
+            return unless NewRelic::Agent.tl_is_execution_traced?
+            operations[event.operation_id] = event
+          rescue Exception => e
+            log_notification_error('started', e)
+          end
+        end
+
+        def completed(event)
+          begin
+            state = NewRelic::Agent::TransactionState.tl_get
+            return unless state.is_execution_traced?
+            started_event = operations.delete(event.operation_id)
+
+            base, *other_metrics = metrics(started_event)
+
+            NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
+              base, other_metrics, event.duration
+            )
+
+            NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(
+              generate_statement(started_event), event.duration
+            )
+          rescue Exception => e
+            log_notification_error('completed', e)
+          end
+        end
+
+        alias :succeeded :completed
+        alias :failed :completed
+
+        private
+
+        def collection(event)
+          event.command.values.first
+        end
+
+        def metrics(event)
+          NewRelic::Agent::Datastores::MetricHelper.metrics_for(MONGODB, event.command_name, collection(event))
+        end
+
+        def log_notification_error(event_type, error)
+          NewRelic::Agent.logger.error("Error during MongoDB #{event_type} event:")
+          NewRelic::Agent.logger.log_exception(:error, error)
+        end
+
+        def operations
+          @operations ||= {}
+        end
+
+        def generate_statement(event)
+          NewRelic::Agent::Datastores::Mongo::EventFormatter.format(
+            event.command_name,
+            event.database_name,
+            event.command
+          )
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/supported_versions.rb

@@ -148,12 +148,26 @@ module NewRelic
       :mongo =>
       {
         :type        => :database,
-        :supported   => [">= 1.8.0", "< 2.0.0"],
+        :supported   => ["~>1.8", "~>2.1"],
         :url         => "https://rubygems.org/gems/mongo",
         :feed        => "https://rubygems.org/gems/mongo/versions.atom"
       },
+      :redis =>
+      {
+        :type        => :database,
+        :supported   => ["~> 3.0"],
+        :url         => "https://rubygems.org/gems/redis",
+        :feed        => "https://rubygems.org/gems/redis/versions.atom"
+      },
 
       # Background Jobs
+      :rake =>
+      {
+        :type        => :background,
+        :supported   => ["~> 10.0"],
+        :url         => "https://rubygems.org/gems/rake",
+        :feed        => "https://rubygems.org/gems/rake/versions.atom"
+      },
       :resque =>
       {
         :type        => :background,

data/lib/new_relic/agent/system_info.rb

@@ -113,6 +113,11 @@ module NewRelic
         if num_physical_cores == 0
           num_logical_processors = total_processors
 
+          if total_processors == 0
+            # Likely a malformed file.
+            num_logical_processors = nil
+          end
+
           if total_processors == 1
             # Some older, single-core processors might not list ids,
             # so we'll just mark them all 1.

data/lib/new_relic/recipes/capistrano3.rb

@@ -58,7 +58,7 @@ namespace :newrelic do
     current_revision = fetch(:current_revision)
 
     if scm == :git
-      log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
+      log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
                     "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
       `#{log_command}`
     end

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -58,7 +58,7 @@ make_notify_task = Proc.new do
         from_revision = source.next_revision(current_revision)
 
         if scm == :git
-          log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
+          log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
             "--abbrev-commit --no-merges #{previous_revision}..#{real_revision}"
         else
           log_command = "#{source.log(from_revision)}"

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 13
-    TINY  = 0
+    TINY  = 1
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/newrelic_rpm.gemspec

@@ -61,7 +61,7 @@ EOS
 
   if RUBY_PLATFORM == 'java'
     s.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
-    s.add_development_dependency 'jruby-openssl'
+    s.add_development_dependency 'jruby-openssl', '~> 0.9.10' unless JRUBY_VERSION > '1.7'
   else
     s.add_development_dependency 'sqlite3'
   end

data/test/environments/lib/environments/runner.rb

@@ -18,6 +18,7 @@ module Environments
       "ree"         => ["rails40", "rails41", "rails42"],
       "jruby-1.6"   => ["rails40", "rails41", "rails42"],
       "jruby-1.7"   => ["rails21", "rails22", "rails23"],
+      "jruby-9.0"   => ["rails21", "rails22", "rails23", "rails30", "rails31", "rails32"],
       "rbx-2.0"     => ["rails21", "rails22", "rails23", "rails30", "rails31", "rails32"],
     }
 

data/test/fixtures/cross_agent_tests/proc_cpuinfo/README.md

@@ -22,3 +22,7 @@ should produce the following expected values:
 If any of `A`, `B`, or `C` are the character `X` instead of an integer, then
 processing code should not return a value (return `null`, return `nil`,
 raise an exception... whatever makes most sense for your agent).
+
+There is a malformed.txt file which is a random file that does not adhere to
+any /proc/cpuinfo format. The expected result is `null` for packages, cores and
+processors.

data/test/fixtures/cross_agent_tests/proc_cpuinfo/malformed_file.txt

@@ -0,0 +1,3 @@
+This is a random text file that does NOT adhere to the /proc/cpuinfo format.
+xxxYYYZZz
+

data/test/multiverse/lib/multiverse/suite.rb

@@ -172,7 +172,7 @@ module Multiverse
         f.puts '  source "https://rubygems.org"' unless local
         f.print gemfile_text
         f.puts newrelic_gemfile_line unless gemfile_text =~ /^\s*gem .newrelic_rpm./
-        f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./
+        f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./ || (defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7')
         f.puts minitest_line unless gemfile_text =~ /^\s*gem .minitest[^_]./
 
         rbx_gemfile_lines(f, gemfile_text)
@@ -184,8 +184,8 @@ module Multiverse
 
           # Pry 0.10.0 breaks compatibility with Ruby 1.8.7 :(
           f.puts "  gem 'pry', '~> #{pry_version}'"
-          f.puts "  gem 'pry-byebug'" if RUBY_VERSION >= "2.0.0"
-          f.puts "  gem 'pry-stack_explorer'"
+          f.puts "  gem 'pry-byebug'" if RUBY_VERSION >= "2.0.0" && RUBY_ENGINE == "ruby"
+          f.puts "  gem 'pry-stack_explorer'" if RUBY_ENGINE == "ruby"
         end
       end
       puts yellow("Gemfile.#{env_index} set to:") if verbose?
@@ -212,7 +212,7 @@ module Multiverse
     end
 
     def jruby_openssl_line
-      "gem 'jruby-openssl', :require => false, :platforms => [:jruby]"
+      "gem 'jruby-openssl', '~> 0.9.10', :require => false, :platforms => [:jruby]"
     end
 
     def minitest_line

data/test/multiverse/suites/active_record/active_record_test.rb

@@ -9,11 +9,76 @@ class ActiveRecordInstrumentationTest < Minitest::Test
   include MultiverseHelpers
   setup_and_teardown_agent
 
+  module VersionHelpers
+    def active_record_major_version
+      if defined?(::ActiveRecord::VERSION::MAJOR)
+        ::ActiveRecord::VERSION::MAJOR.to_i
+      else
+        2
+      end
+    end
+
+    def active_record_minor_version
+      if defined?(::ActiveRecord::VERSION::MINOR)
+        ::ActiveRecord::VERSION::MINOR.to_i
+      else
+        1
+      end
+    end
+
+    def active_record_version
+      if defined?(::ActiveRecord::VERSION::MINOR)
+        NewRelic::VersionNumber.new(::ActiveRecord::VERSION::STRING)
+      else
+        NewRelic::VersionNumber.new("2.1.0")  # Can't tell between 2.1 and 2.2. Meh.
+      end
+    end
+  end
+
+  include VersionHelpers
+  extend VersionHelpers
+
   def after_setup
     super
     NewRelic::Agent.drop_buffered_data
   end
 
+  def test_metrics_for_calculation_methods
+    in_web_transaction do
+      Order.count
+      Order.average(:id)
+      Order.minimum(:id)
+      Order.maximum(:id)
+      Order.sum(:id)
+    end
+
+    if active_record_major_version >= 3
+      assert_activerecord_metrics(Order, 'select', :call_count => 5)
+    else
+      assert_generic_rollup_metrics('select')
+    end
+  end
+
+  if active_record_version >= NewRelic::VersionNumber.new('3.2.0')
+    def test_metrics_for_pluck
+      in_web_transaction do
+        Order.pluck(:id)
+      end
+
+      assert_activerecord_metrics(Order, 'select')
+    end
+  end
+
+  if active_record_version >= NewRelic::VersionNumber.new('4.0.0')
+    def test_metrics_for_ids
+      in_web_transaction do
+        Order.ids
+      end
+
+      assert_activerecord_metrics(Order, 'select')
+    end
+  end
+
   def test_metrics_for_create
     in_web_transaction do
       Order.create(:name => 'bob')
@@ -157,7 +222,7 @@ class ActiveRecordInstrumentationTest < Minitest::Test
   end
 
   # delete and touch did not exist in AR 2.2
-  if defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::MAJOR >= 3
+  if active_record_version >= NewRelic::VersionNumber.new('3.0.0')
     def test_metrics_for_delete
       in_web_transaction do
         order = Order.create("name" => "burt")
@@ -256,7 +321,7 @@ class ActiveRecordInstrumentationTest < Minitest::Test
   end
 
   # update & update! didn't become public until 4.0
-  if defined?(::ActiveRecord::VERSION) && ::ActiveRecord::VERSION::MAJOR >= 4
+  if active_record_version >= NewRelic::VersionNumber.new('4.0.0')
     def test_metrics_for_update
       in_web_transaction do
         order = Order.create(:name => "wendy")
@@ -525,30 +590,6 @@ class ActiveRecordInstrumentationTest < Minitest::Test
     NewRelic::Agent::Instrumentation::ActiveRecordHelper::PRODUCT_NAMES[adapter.to_s]
   end
 
-  def active_record_major_version
-    if defined?(::ActiveRecord::VERSION::MAJOR)
-      ::ActiveRecord::VERSION::MAJOR.to_i
-    else
-      2
-    end
-  end
-
-  def active_record_minor_version
-    if defined?(::ActiveRecord::VERSION::MINOR)
-      ::ActiveRecord::VERSION::MINOR.to_i
-    else
-      1
-    end
-  end
-
-  def active_record_version
-    if defined?(::ActiveRecord::VERSION::MINOR)
-      NewRelic::VersionNumber.new(::ActiveRecord::VERSION::STRING)
-    else
-      NewRelic::VersionNumber.new("2.1.0")  # Can't tell between 2.1 and 2.2. Meh.
-    end
-  end
-
   def assert_activerecord_metrics(model, operation, stats={})
     assert_metrics_recorded({
       "Datastore/statement/#{current_product}/#{model}/#{operation}" => stats,

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

@@ -7,6 +7,10 @@ require 'open3'
 
 class StartUpTest < Minitest::Test
   GIT_NOISE = "fatal: Not a git repository (or any of the parent directories): .git\n"
+  JRUBY_9000_NOISE = [
+    /uri\:classloader\:\/jruby\/kernel\/kernel\.rb\:\d*\: warning: unsupported exec option: close_others/, # https://github.com/jruby/jruby/issues/1913
+    /.*\/lib\/ruby\/stdlib\/jar_dependencies.rb:\d*: warning: shadowing outer local variable - (group_id|artifact_id)/, #https://github.com/mkristian/jar-dependencies/commit/65c71261b1522f7b10fcb95de42ea4799de3a83a
+  ]
 
   include MultiverseHelpers
 
@@ -25,7 +29,9 @@ class StartUpTest < Minitest::Test
       GIT_NOISE,
       /Exception\: java\.lang.*\n/]
 
-    expected_noise.each {|noise| output.gsub!(noise, "")}
+    expected_noise << JRUBY_9000_NOISE if jruby_9000
+
+    expected_noise.flatten.each {|noise| output.gsub!(noise, "")}
 
     assert_equal '', output.chomp
   end
@@ -64,8 +70,12 @@ class StartUpTest < Minitest::Test
                        'NEW_RELIC_PORT' => $collector.port.to_s) do
 
         output = `bundle exec ruby -w script/warnings.rb 2>&1`
-        output.gsub!(GIT_NOISE, "")
-        output.chomp!
+        expected_noise = [GIT_NOISE]
+
+        expected_noise << JRUBY_9000_NOISE if jruby_9000
+
+        expected_noise.flatten.each {|noise| output.gsub!(noise, "")}
+        output.strip!
 
         assert_equal NewRelic::VERSION::STRING, output
       end
@@ -79,4 +89,8 @@ class StartUpTest < Minitest::Test
     problems = output.scan(/ERROR : .*/)
     assert_empty problems
   end
+
+  def jruby_9000
+    defined?(JRUBY_VERSION) && NewRelic::VersionNumber.new(JRUBY_VERSION) >= "9.0.0"
+  end
 end

data/test/multiverse/suites/config_file_loading/Envfile

@@ -6,7 +6,7 @@ gemfile <<-RB
   gem 'fakefs', :require => 'fakefs/safe'
 
   # Because we delay the agent, order of jruby-openssl matters
-  gem 'jruby-openssl', :platforms => [:jruby]
+  gem 'jruby-openssl', '~> 0.9.10', :platforms => [:jruby]
 
   # don't start the agent
   gem 'newrelic_rpm', :require => false, :path => File.expand_path('../../../../')

data/test/multiverse/suites/mongo/Envfile

@@ -1,7 +1,9 @@
 if RUBY_VERSION >= '1.9.3'
+  gemfile <<-RB
+    gem 'mongo', '~>2.1.0'
+  RB
   gemfile <<-RB
     gem 'mongo', '~>2.0.1'
-    gem 'bson_ext', :platforms => :ruby
   RB
 end
 

data/test/multiverse/suites/mongo/mongo2_instrumentation_test.rb

@@ -0,0 +1,344 @@
+# 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 'mongo'
+require 'newrelic_rpm'
+require 'new_relic/agent/datastores/mongo'
+require 'helpers/mongo_metric_builder'
+
+if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
+    NewRelic::Agent::Datastores::Mongo.is_monitoring_enabled?
+  module NewRelic
+    module Agent
+      module Instrumentation
+        class Mongo2InstrumentationTest < Minitest::Test
+          include Mongo
+          include TestHelpers::MongoMetricBuilder
+
+          def setup
+            @database_name = "multiverse"
+            @client = Mongo::Client.new(["#{$mongo.host}:#{$mongo.port}"], :database => @database_name)
+            @database = @client.database
+
+            @collection_name = "tribbles-#{SecureRandom.hex(16)}"
+            @collection = @database.collection(@collection_name)
+
+            @tribbles = [{'name' => 'soterios johnson'}, {'name' => 'wes mantooth'}]
+
+            NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+            NewRelic::Agent.drop_buffered_data
+          end
+
+          def teardown
+            NewRelic::Agent.drop_buffered_data
+            @collection.drop
+          end
+
+          def test_records_metrics_for_insert_one
+            @collection.insert_one(@tribbles.first)
+
+            metrics = build_test_metrics(:insert)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_insert_many
+            @collection.insert_many(@tribbles)
+
+            metrics = build_test_metrics(:insert)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_delete_one
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.delete_one(@tribbles.first)
+
+            metrics = build_test_metrics(:delete)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_delete_many
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.delete_many(@tribbles.first)
+
+            metrics = build_test_metrics(:delete)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_replace_one
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.replace_one(@tribbles[0], @tribbles[1])
+
+            metrics = build_test_metrics(:update)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_update_one
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.update_one(@tribbles[0], "$set" => @tribbles[1])
+
+            metrics = build_test_metrics(:update)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_update_many
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.update_many(@tribbles[0], "$set" => @tribbles[1])
+
+            metrics = build_test_metrics(:update)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_find
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.find(@tribbles.first).to_a
+
+            metrics = build_test_metrics(:find)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_find_one_and_delete
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.find_one_and_delete(@tribbles.first)
+
+            metrics = build_test_metrics(:findandmodify)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_find_one_and_replace
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.find_one_and_replace(@tribbles[0], @tribbles[1])
+
+            metrics = build_test_metrics(:findandmodify)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_records_metrics_for_find_one_and_update
+            @collection.insert_one(@tribbles.first)
+            NewRelic::Agent.drop_buffered_data
+
+            @collection.find_one_and_update(@tribbles[0], "$set" => @tribbles[1])
+
+            metrics = build_test_metrics(:findandmodify)
+            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_drop_collection
+            @collection.drop
+
+            metrics = build_test_metrics(:drop)
+            expected = metrics_with_attributes(metrics)
+
+            assert_metrics_recorded(expected)
+          end
+
+          def test_web_scoped_metrics
+            in_web_transaction("webby") do
+              @collection.insert_one(@tribbles.first)
+            end
+
+            metric = statement_metric(:insert)
+            assert_metrics_recorded([[metric, "webby"]])
+          end
+
+          def statement_metric(action)
+            metrics = build_test_metrics(action)
+            metrics.select { |m| m.start_with?("Datastore/statement") }.first
+          end
+
+          def test_background_scoped_metrics
+            in_background_transaction("backed-up") do
+              @collection.insert_one(@tribbles.first)
+            end
+
+            metric = statement_metric(:insert)
+            assert_metrics_recorded([[metric, "backed-up"]])
+          end
+
+          def test_notices_nosql
+            node = nil
+
+            in_transaction do
+              @collection.insert_one(@tribbles.first)
+
+              node = find_last_transaction_node
+            end
+
+            expected = {
+              :database   => @database_name,
+              :collection => @collection_name,
+              'insert' => @collection_name,
+              :operation  => :insert,
+              'writeConcern' => { :w => 1 },
+              'ordered' => true
+            }
+
+            result = node.params[:statement]
+
+            assert_equal expected, result
+          end
+
+          def test_noticed_nosql_includes_operation
+            node = nil
+
+            in_transaction do
+              @collection.insert_one(@tribbles.first)
+              node = find_last_transaction_node
+            end
+
+            query = node.params[:statement]
+
+            assert_equal :insert, query[:operation]
+          end
+
+          def test_noticed_nosql_includes_update_one_operation
+            node = nil
+
+            in_transaction do
+              @collection.update_one(@tribbles[0], @tribbles[1])
+
+              node = find_last_transaction_node
+            end
+
+            query = node.params[:statement]
+
+            assert_equal :update, query[:operation]
+          end
+
+          def test_noticed_nosql_includes_find_operation
+            node = nil
+
+            in_transaction do
+              @collection.insert_one(@tribbles.first)
+              @collection.find(@tribbles.first).to_a
+              node = find_last_transaction_node
+            end
+
+            query = node.params[:statement]
+
+            assert_equal 'find', query[:operation]
+          end
+
+          def test_noticed_nosql_does_not_contain_documents
+            node = nil
+
+            in_transaction do
+              @collection.insert_one(@tribbles.first)
+              node = find_last_transaction_node
+            end
+
+            statement = node.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_one({'password' => '$ecret'})
+            node = nil
+
+            in_transaction do
+              @collection.find({'password' => '$ecret'}).to_a
+              node = find_last_transaction_node
+            end
+
+            statement = node.params[:statement]
+
+            refute statement.inspect.include?('$secret')
+
+            assert_equal '?', statement['filter']['password']
+          end
+
+          def test_web_requests_record_all_web_metric
+            NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
+            @collection.insert_one(@tribbles.first)
+
+            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_one(@tribbles.first)
+
+            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_one(@tribbles.first)
+
+            metrics = build_test_metrics(:insert)
+            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_one(@tribbles.first)
+
+            assert_metrics_not_recorded(['Datastore/allWeb'])
+          end
+        end
+      end
+    end
+  end
+end