newrelic_rpm 4.1.0.333 → 4.2.0.334

data/test/new_relic/agent/datastores/mongo/obfuscator_test.rb

@@ -1,99 +0,0 @@
-# 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/obfuscator'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        class ObfuscatorTest < Minitest::Test
-          def test_obfuscator_removes_values_from_statement
-            selector = {
-              'name'     => 'soterios johnson',
-              :operation => :find,
-              :_id       => "BSON::ObjectId('?')"
-            }
-
-            expected = {
-              'name'     => '?',
-              :operation => :find,
-              :_id       => '?'
-            }
-
-            obfuscated = Obfuscator.obfuscate_statement(selector)
-            assert_equal expected, obfuscated
-          end
-
-          def test_obfuscate_selector_values_skips_whitelisted_keys
-            selector   = {
-              :benign    => 'bland data',
-              :operation => :find,
-              :_id       => "BSON::ObjectId('?')"
-            }
-
-            expected   = {
-              :benign    => 'bland data',
-              :operation => :find,
-              :_id       => '?'
-            }
-
-            obfuscated = Obfuscator.obfuscate_statement(selector, [:benign, :operation])
-            assert_equal expected, obfuscated
-          end
-
-          def test_obfuscate_nested_hashes
-            selector = {
-              "group" => {
-                "ns"      => "tribbles",
-                "$reduce" => stub("BSON::Code"),
-                "cond"    => {},
-                "initial" => { :count => 0 },
-                "key"     => { "name" => 1 }
-              }
-            }
-
-            expected = {
-              "group" => {
-                "ns"      => "?",
-                "$reduce" => "?",
-                "cond"    => {},
-                "initial" => { :count => "?" },
-                "key"     => { "name" => "?" }
-              }
-            }
-
-            obfuscated = Obfuscator.obfuscate_statement(selector)
-            assert_equal expected, obfuscated
-          end
-
-          def test_obfuscates_array_statement
-            statement = [{"$group"=>{:_id=>"$says", :total=>{"$sum"=>1}}}]
-            expected = [{"$group"=>{:_id=>"?", :total=>{"$sum"=>"?"}}}]
-
-            obfuscated = Obfuscator.obfuscate_statement(statement)
-            assert_equal expected, obfuscated
-          end
-
-          def test_obfuscate_nested_arrays
-            selector = {
-              "aggregate" => "mongeese",
-              "pipeline"  => [{"$group"=>{:_id=>"$says", :total=>{"$sum"=>1}}}]
-            }
-
-            expected = {
-              "aggregate" => "?",
-              "pipeline"  => [{"$group"=>{:_id=>"?", :total=>{"$sum"=>"?"}}}]
-            }
-
-            obfuscated = Obfuscator.obfuscate_statement(selector)
-            assert_equal expected, obfuscated
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/datastores/mongo/statement_formatter_test.rb

@@ -1,72 +0,0 @@
-# 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 'new_relic/agent/datastores/mongo/statement_formatter'
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        class StatementFormatterTest < Minitest::Test
-          DOC_STATEMENT = { :database   => "multiverse",
-                            :collection => "tribbles",
-                            :operation  => :insert,
-                            :fields     => ["field_name"],
-                            :skip       => 1,
-                            :limit      => -1,
-                            :order      => :ascending,
-
-                            :ignored    => "we're whitelisted!",
-                            :documents  => [ { "name" => "soterios johnson",
-                                               :_id   => "BSON::ObjectId()" } ] }.freeze
-
-
-          SELECTOR_STATEMENT = { :database   => 'multiverse',
-                                 :collection => 'tribbles',
-                                 :selector   => { 'name'     => 'soterios johnson',
-                                                  :operation => :find,
-                                                  :_id       => "BSON::ObjectId('?')" } }.freeze
-
-          def test_doesnt_modify_incoming_statement
-            formatted = StatementFormatter.format(DOC_STATEMENT, :find)
-            refute_same DOC_STATEMENT, formatted
-          end
-
-          def test_statement_formatter_removes_unwhitelisted_keys
-            formatted = StatementFormatter.format(DOC_STATEMENT, :find)
-            assert_equal_unordered(formatted.keys, StatementFormatter::PLAINTEXT_KEYS)
-          end
-
-          def test_can_disable_statement_capturing_queries
-            with_config(:'mongo.capture_queries' => false) do
-              formatted = StatementFormatter.format(DOC_STATEMENT, :find)
-              assert_nil formatted
-            end
-          end
-
-          def test_statement_formatter_obfuscates_by_default
-            expected = { :database   => 'multiverse',
-                         :collection => 'tribbles',
-                         :operation  => :find,
-                         :selector   => { 'name'     => '?',
-                                          :operation => :find,
-                                          :_id       => '?' } }
-
-            result = StatementFormatter.format(SELECTOR_STATEMENT, :find)
-            assert_equal expected, result
-          end
-
-          def test_statement_formatter_raw_selectors
-            with_config(:'mongo.obfuscate_queries' => false) do
-              result = StatementFormatter.format(SELECTOR_STATEMENT, :find)
-              assert_equal SELECTOR_STATEMENT.merge(:operation => :find), result
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/datastores/redis_test.rb

@@ -1,126 +0,0 @@
-# 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/redis'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-
-class NewRelic::Agent::Datastores::RedisTest < Minitest::Test
-  def test_format_command
-    expected = "set \"foo\" \"bar\""
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
-      assert_equal expected, result
-    end
-  end
-
-  def test_format_command_truncates_long_arguments
-    key = "namespace.other_namespace.different_namespace.why.would.you.do.this.key"
-    expected_key = "namespace.other_namespace.dif...ace.why.would.you.do.this.key"
-
-    expected = "set \"#{expected_key}\" \"redoctober\""
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, key, 'redoctober'])
-      assert_equal expected, result
-    end
-  end
-
-  def test_format_command_truncates_long_commands
-    key = "key"
-    command = [:set] + Array.new(NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH, key)
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command(command)
-      assert result.length <= NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH
-    end
-  end
-
-  def test_format_command_with_record_arguments_false
-    with_config(:'transaction_tracer.record_redis_arguments' => false) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
-      assert_equal nil, result
-    end
-  end
-
-  def test_format_command_in_pipeline
-    expected = "set \"foo\" \"bar\""
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
-      assert_equal expected, result
-    end
-  end
-
-  def test_append_command_in_pipeline_with_record_arguments_false
-    expected = "set ?"
-
-    with_config(:'transaction_tracer.record_redis_arguments' => false) do
-      result = ""
-      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:set, 'foo', 'bar'])
-      assert_equal expected, result
-    end
-  end
-
-  def test_append_command_in_pipeline_with_record_arguments_and_no_args
-    expected = "multi"
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = ""
-      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:multi])
-      assert_equal expected, result
-    end
-  end
-
-  def test_append_command_in_pipeline_with_record_arguments_false_and_no_args
-    expected = "multi"
-
-    with_config(:'transaction_tracer.record_redis_arguments' => false) do
-      result = ""
-      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:multi])
-      assert_equal expected, result
-    end
-  end
-
-  def test_format_pipeline_commands_truncates_long_commands
-    pipeline = NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH.times.map do
-      [:set, "0123456789"]
-    end
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
-      assert NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH, result.length
-      assert result.end_with?("012345...")
-    end
-  end
-
-  def test_format_command_with_non_string_argument
-    expected = "set \"key\" true"
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', true])
-      assert_equal expected, result
-    end
-  end
-
-  def test_format_command_handles_binary_strings
-    binary_string = (0..255).to_a.pack("c*")
-    expected = 'set "key" <binary data>'
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
-      assert_equal expected, result
-    end
-  end
-
-  def test_format_command_in_pipeline_handles_binary_strings
-    binary_string = (0..255).to_a.pack("c*")
-    expected = 'set "key" <binary data>'
-
-    with_config(:'transaction_tracer.record_redis_arguments' => true) do
-      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
-      assert_equal expected, result
-    end
-  end
-end

data/test/new_relic/agent/datastores_test.rb

@@ -1,202 +0,0 @@
-# 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'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-
-class NewRelic::Agent::DatastoresTest < Minitest::Test
-  class MyFirstDatabase
-    THE_OBJECT = Object.new
-
-    def find
-      THE_OBJECT
-    end
-
-    def save
-    end
-
-    def internal
-    end
-
-    private :internal
-
-    NewRelic::Agent::Datastores.trace self, :find,     "MyFirstDatabase"
-    NewRelic::Agent::Datastores.trace self, :save,     "MyFirstDatabase", "create"
-    NewRelic::Agent::Datastores.trace self, :internal, "MyFirstDatabase"
-
-    def boom
-      raise "haha"
-    end
-
-    NewRelic::Agent::Datastores.trace self, :boom, "MyFirstDatabase", "boom"
-  end
-
-  def setup
-    NewRelic::Agent.drop_buffered_data
-  end
-
-  def test_still_calls_through
-    assert_equal MyFirstDatabase::THE_OBJECT, MyFirstDatabase.new.find
-  end
-
-  def test_in_web_transaction
-    in_web_transaction("txn") do
-      MyFirstDatabase.new.find
-    end
-
-    assert_metrics("find", "Web")
-  end
-
-  def test_in_other_transaction
-    in_background_transaction("txn") do
-      MyFirstDatabase.new.find
-    end
-
-    assert_metrics("find", "Other")
-  end
-
-  def test_separate_operation_name
-    in_background_transaction("txn") do
-      MyFirstDatabase.new.save
-    end
-
-    assert_metrics("create", "Other")
-  end
-
-  def test_safe_to_reinstrument
-    MyFirstDatabase.class_eval do
-      NewRelic::Agent::Datastores.trace self, :find, "MyFirstDatabase", "find"
-    end
-
-    assert_equal MyFirstDatabase::THE_OBJECT, MyFirstDatabase.new.find
-  end
-
-  def test_method_retains_visbility
-    private_methods = MyFirstDatabase.private_instance_methods.map(&:to_sym)
-    assert_includes private_methods, :internal
-  end
-
-  def test_wrap_doesnt_interfere
-    result = NewRelic::Agent::Datastores.wrap("MyFirstDatabase", "op") do
-      "yo"
-    end
-
-    assert_equal "yo", result
-  end
-
-  def test_wrap
-    in_background_transaction("txn") do
-      NewRelic::Agent::Datastores.wrap("MyFirstDatabase", "op", "coll") do
-      end
-    end
-
-    assert_statement_metrics("op", "coll", "Other")
-  end
-
-  def test_wrap_with_only_operation
-    in_background_transaction("txn") do
-      NewRelic::Agent::Datastores.wrap("MyFirstDatabase", "op") do
-      end
-    end
-
-    assert_metrics("op", "Other")
-  end
-
-  def test_wrap_with_no_operation
-    in_background_transaction("txn") do
-      NewRelic::Agent::Datastores.wrap("MyFirstDatabase", nil) do
-      end
-    end
-
-    refute_metrics_recorded([
-                            "Datastore/operation/MyFirstDatabase/",
-                            "Datastore/MyFirstDatabase/allOther",
-                            "Datastore/MyFirstDatabase/all",
-                            "Datastore/allOther",
-                            "Datastore/all"])
-  end
-
-  def test_wrap_calls_notice
-    noticed = nil
-    notice = Proc.new do |*args|
-      noticed = args
-    end
-
-    NewRelic::Agent::Datastores.wrap("MyFirstDatabase", "op", "coll", notice) do
-      "yo"
-    end
-
-    result, scoped_metric, elapsed = noticed
-
-    assert_equal "yo", result
-    assert_equal "Datastore/statement/MyFirstDatabase/coll/op", scoped_metric
-    assert_instance_of Float, elapsed
-  end
-
-  def test_notice_sql
-    query   = "SELECT * FROM SomeThings"
-    metric  = "Datastore/statement/MyFirstDatabase/SomeThing/find"
-    elapsed = 1.0
-
-    agent = NewRelic::Agent.instance
-    agent.transaction_sampler.expects(:notice_sql).with(query, nil, elapsed)
-    agent.sql_sampler.expects(:notice_sql).with(query, metric, nil, elapsed)
-
-    NewRelic::Agent::Datastores.notice_sql(query, metric, elapsed)
-  end
-
-  def test_notice_statement
-    query   = "key"
-    elapsed = 1.0
-
-    agent = NewRelic::Agent.instance
-    agent.transaction_sampler.expects(:notice_nosql_statement).with(query, elapsed)
-
-    NewRelic::Agent::Datastores.notice_statement(query, elapsed)
-  end
-
-  def test_dont_notice_statement_based_on_record_sql_setting
-    query   = "key"
-    elapsed = 1.0
-
-    agent = NewRelic::Agent.instance
-    agent.transaction_sampler.expects(:notice_nosql_statement).never
-
-    with_config(:'transaction_tracer.record_sql' => 'none') do
-      NewRelic::Agent::Datastores.notice_statement(query, elapsed)
-    end
-  end
-
-  def test_node_created_when_exception_occurs
-    db = MyFirstDatabase.new
-    in_transaction do
-      db.find
-      db.boom
-    end
-  rescue
-    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    refute_nil find_node_with_name(sample, "Datastore/operation/MyFirstDatabase/boom")
-  end
-
-  def assert_statement_metrics(operation, collection, type)
-    assert_metrics_recorded([
-                            "Datastore/statement/MyFirstDatabase/#{collection}/#{operation}",
-                            ["Datastore/statement/MyFirstDatabase/#{collection}/#{operation}", "txn"],
-                            "Datastore/operation/MyFirstDatabase/#{operation}",
-                            "Datastore/MyFirstDatabase/all#{type}",
-                            "Datastore/MyFirstDatabase/all",
-                            "Datastore/all#{type}",
-                            "Datastore/all"])
-  end
-
-  def assert_metrics(operation, type)
-    assert_metrics_recorded([
-                            "Datastore/operation/MyFirstDatabase/#{operation}",
-                            ["Datastore/operation/MyFirstDatabase/#{operation}", "txn"],
-                            "Datastore/MyFirstDatabase/all#{type}",
-                            "Datastore/MyFirstDatabase/all",
-                            "Datastore/all#{type}",
-                            "Datastore/all"])
-  end
-end