newrelic_rpm 4.0.0.332 → 4.4.0.336

data/test/new_relic/agent/instrumentation/instance_identification_test.rb

@@ -1,169 +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/instrumentation/active_record_helper'
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module ActiveRecordHelper
-        class InstanceIdentificationTest < Minitest::Test
-
-          def test_for_constructs_id_with_configured_host_and_port
-            config = {
-              :host => "jonan.local",
-              :port => 42
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.local", host
-            assert_equal "42", ppid
-          end
-
-          def test_for_constructs_id_with_unspecified_configuration
-            config = {}
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_weird_configs
-            config = {
-              :host => "",
-              :port => ""
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "unknown", host
-            assert_equal "unknown", ppid
-          end
-
-          def test_for_constructs_id_with_configured_host_without_port
-            config = { :host => "jonan.gummy_planet" }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.gummy_planet", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_port_without_host
-            config = { :port => 1337 }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "1337", ppid
-          end
-
-          def test_for_constructs_id_with_default_port
-            config = {
-              :adapter => "mysql",
-              :host => "jonan.gummy_planet"
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "jonan.gummy_planet", host
-            assert_equal "3306", ppid
-          end
-
-          def test_for_constructs_id_with_postgres_directory
-            config = {
-              :adapter => "postgresql",
-              :host => "/tmp"
-            }
-
-            host = InstanceIdentification.host(config)
-            ppid = InstanceIdentification.port_path_or_id(config)
-
-            assert_equal "localhost", host
-            assert_equal "default", ppid
-          end
-
-          def test_for_constructs_id_with_mysql_socket
-            %w[ mysql mysql2 jdbcmysql ].each do |adapter|
-              config = {
-                :adapter => adapter,
-                :socket => "/var/run/mysqld.sock"
-              }
-
-              host = InstanceIdentification.host(config)
-              ppid = InstanceIdentification.port_path_or_id(config)
-
-              assert_equal "localhost", host
-              assert_equal "/var/run/mysqld.sock", ppid
-            end
-          end
-
-          def test_supports_supported_adapters
-            %w(mysql mysql2 postgresql).each do |adapter|
-              assert InstanceIdentification.supported_adapter?({:adapter => adapter })
-            end
-          end
-
-          SUPPORTED_PRODUCTS = ["Postgres", "MySQL"]
-
-          load_cross_agent_test('datastores/datastore_instances').each do |test|
-            next unless SUPPORTED_PRODUCTS.include?(test['product'])
-
-            define_method :"test_#{test['name'].tr(' ', '_')}" do
-              NewRelic::Agent.drop_buffered_data
-              NewRelic::Agent::Hostname.stubs(:get).returns(test['system_hostname'])
-
-              in_transaction do
-                config = convert_test_case_to_config test
-                product, operation, collection = ActiveRecordHelper.product_operation_collection_for "Blog Find", nil , config[:adapter]
-                host = ActiveRecordHelper::InstanceIdentification.host(config)
-                port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
-
-                segment = NewRelic::Agent::Transaction.start_datastore_segment product, operation, collection, host, port_path_or_id
-                segment.finish
-              end
-
-              assert_metrics_recorded test['expected_instance_metric']
-            end
-          end
-
-          CONFIG_NAMES = {
-            "db_hostname" => :host,
-            "unix_socket" => :socket,
-            "port" => :port,
-            "product" => :adapter
-          }
-
-          def convert_test_case_to_config test_case
-            config = test_case.inject({}) do |memo, (k,v)|
-              if config_key = CONFIG_NAMES[k]
-                memo[config_key] = v
-              end
-              memo
-            end
-            convert_product_to_adapter config
-            config
-          end
-
-          PRODUCT_TO_ADAPTER_NAMES = {
-            "Postgres" => "postgresql",
-            "MySQL" => "mysql",
-            "SQLite" => "sqlite3"
-          }
-
-          def convert_product_to_adapter config
-            config[:adapter] = PRODUCT_TO_ADAPTER_NAMES[config[:adapter]]
-          end
-        end
-      end
-    end
-  end
-end

data/test/new_relic/agent/instrumentation/instrumentation_test.rb

@@ -1,14 +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'))
-class NewRelic::Agent::Instrumentation::InstrumentationTest < Minitest::Test
-  def test_load_all_instrumentation_files
-    # just checking for syntax errors and unguarded code
-    Dir.glob('new_relic/agent/instrumentation/**/*.rb') do |f|
-      require f
-    end
-    require 'new_relic/delayed_job_injection'
-  end
-end

data/test/new_relic/agent/instrumentation/middleware_proxy_test.rb

@@ -1,256 +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'))
-
-class NewRelic::Agent::Instrumentation::MiddlewareProxyTest < Minitest::Test
-
-  def setup
-    NewRelic::Agent.drop_buffered_data
-  end
-
-  def test_generator_creates_wrapped_instances
-    middleware_class = Class.new
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-    wrapped_instance  = generator.new
-
-    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped_instance)
-    assert_kind_of(middleware_class, wrapped_instance.target)
-  end
-
-  def test_generator_passes_through_initialize_args
-    middleware_class = Class.new do
-      attr_reader :initialize_args
-
-      def initialize(*args)
-        @initialize_args = args
-      end
-    end
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-    wrapped_instance = generator.new('abc', 123)
-
-    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
-  end
-
-  def test_generator_passes_through_block_to_initialize
-    middleware_class = Class.new do
-      attr_reader :initialize_args
-
-      def initialize(*args, &blk)
-        @initialize_args = args
-        blk.call
-      end
-    end
-
-    generator = NewRelic::Agent::Instrumentation::MiddlewareProxy.for_class(middleware_class)
-
-    block_called = false
-    wrapped_instance = generator.new('abc', 123) do
-      block_called = true
-    end
-
-    assert block_called
-    assert_equal(['abc', 123], wrapped_instance.target.initialize_args)
-  end
-
-  def test_anonymous_class_naming
-    middleware_class = Class.new
-    wrapped_instance = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
-
-    name = wrapped_instance.transaction_options[:transaction_name]
-    assert_equal("Middleware/Rack/AnonymousClass/call", name)
-  end
-
-  class BaseForAnonymous
-  end
-
-  def test_anonymous_derived_class_naming
-    middleware_class = Class.new(BaseForAnonymous)
-    wrapped_instance = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware_class.new)
-
-    name = wrapped_instance.transaction_options[:transaction_name]
-    assert_equal("Middleware/Rack/#{BaseForAnonymous.name}/call", name)
-  end
-
-  def test_does_not_wrap_sinatra_apps
-    sinatra_dummy_module = Module.new
-    sinatra_dummy_class  = Class.new(Object)
-    app_class            = Class.new(sinatra_dummy_class)
-
-    with_constant_defined(:'::Sinatra', sinatra_dummy_module) do
-      with_constant_defined(:'::Sinatra::Base', sinatra_dummy_class) do
-        app = app_class.new
-
-        wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-        assert_same(app, wrapped)
-      end
-    end
-  end
-
-  def test_does_not_wrap_instrumented_middlewares
-    app_class = Class.new do
-      def _nr_has_middleware_tracing
-        true
-      end
-    end
-
-    app = app_class.new
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    assert_same(app, wrapped)
-  end
-
-  def test_should_wrap_non_instrumented_middlewares
-    app_class = Class.new do
-      def call(env)
-        :yay
-      end
-    end
-
-    app = app_class.new
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    assert_kind_of(NewRelic::Agent::Instrumentation::MiddlewareProxy, wrapped)
-  end
-
-  def test_call_should_proxy_to_target_when_in_transaction
-    call_was_called = false
-    call_received   = nil
-
-    app = lambda do |env|
-      call_was_called = true
-      call_received   = env
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-    env = {}
-
-    ret = nil
-    in_transaction do
-      ret = wrapped.call(env)
-    end
-
-    assert(call_was_called)
-    assert_equal(:super_duper, ret)
-    assert_same(env, call_received)
-  end
-
-  def test_call_should_proxy_to_target_when_not_in_transaction
-    call_was_called = false
-    call_received   = nil
-
-    app = lambda do |env|
-      call_was_called = true
-      call_received   = env
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-    env = {}
-    ret = wrapped.call(env)
-
-    assert(call_was_called)
-    assert_equal(:super_duper, ret)
-    assert_same(env, call_received)
-  end
-
-  def test_should_start_transaction_if_none_is_running
-    app = lambda do |env|
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app)
-
-    wrapped.call({})
-
-    assert_metrics_recorded("HttpDispatcher")
-  end
-
-  def test_should_respect_force_transaction_flag
-    app = lambda do |env|
-      :super_duper
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    in_transaction('Controller/foo', :category => :controller) do
-      wrapped.call({})
-    end
-
-    assert_metrics_recorded('Controller/Rack/Proc/call')
-  end
-
-  def test_should_get_the_right_name_when_target_is_a_class
-    target_class = Class.new do
-      def self.name
-        "GreatClass"
-      end
-
-      def self.call(env)
-        :super_duper
-      end
-    end
-
-    wrapped = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(target_class, true)
-
-    wrapped.call({})
-
-    assert_metrics_recorded('Controller/Rack/GreatClass/call')
-  end
-
-  def test_should_emit_events_once
-    app = Proc.new { |env| [200, {}, ["nothing"]]}
-    middleware = Proc.new { |env| app.call(env) }
-    wrapped_middleware = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(middleware, true)
-
-    before_call_count = 0
-    after_call_count = 0
-
-    NewRelic::Agent.instance.events.subscribe(:before_call) { before_call_count += 1 }
-    NewRelic::Agent.instance.events.subscribe(:after_call) { after_call_count += 1 }
-
-    wrapped_middleware.call({})
-    assert_equal 1, before_call_count
-    assert_equal 1, after_call_count
-  end
-
-  def test_before_call_should_receive_rack_env_hash
-    app = Proc.new { |env| [200, {}, ["nothing"]]}
-    wrapped_app = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    original_env = {}
-    env_from_before_call = nil
-
-    NewRelic::Agent.instance.events.subscribe(:before_call) { |env| env_from_before_call = env }
-
-    wrapped_app.call(original_env)
-    assert_same original_env, env_from_before_call
-  end
-
-  def test_after_call_should_receive_rack_env_hash
-    app = Proc.new { |env| [200, {}, ["nothing"]] }
-    wrapped_app = NewRelic::Agent::Instrumentation::MiddlewareProxy.wrap(app, true)
-
-    original_env = {}
-    env_from_after_call = nil
-    result_from_after_call = nil
-
-    NewRelic::Agent.instance.events.subscribe(:after_call) do |env, result|
-      env_from_after_call = env
-      result_from_after_call = result
-    end
-
-    result = wrapped_app.call(original_env)
-
-    assert_same original_env, env_from_after_call
-    assert_same result, result_from_after_call
-  end
-end
-

data/test/new_relic/agent/instrumentation/middleware_tracing_test.rb

@@ -1,49 +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/instrumentation/middleware_tracing'
-
-class NewRelic::Agent::Instrumentation::MiddlewareTracingTest < Minitest::Test
-  class UserError < StandardError
-  end
-
-  class HostClass
-    include NewRelic::Agent::Instrumentation::MiddlewareTracing
-
-    attr_reader :category
-
-    def initialize(&blk)
-      @action = blk
-    end
-
-    def target
-      self
-    end
-
-    def transaction_options
-      {}
-    end
-
-    def traced_call(env)
-      @action.call
-    end
-  end
-
-  def test_dont_block_errors_during_malfunctioning_transaction
-    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
-
-    middleware = HostClass.new { raise UserError }
-    assert_raises(UserError) do
-      middleware.call({})
-    end
-  end
-
-  def test_dont_raise_when_transaction_start_fails
-    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
-
-    middleware = HostClass.new { [200, {}, ['hi!']] }
-    middleware.call({})
-  end
-end

data/test/new_relic/agent/instrumentation/mongodb_command_subscriber_test.rb

@@ -1,112 +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/instrumentation/mongodb_command_subscriber'
-
-class NewRelic::Agent::Instrumentation::MongodbCommandSubscriberTest < Minitest::Test
-
-  def setup
-    freeze_time
-    @started_event = mock('started event')
-    @started_event.stubs(:operation_id).returns(1)
-    @started_event.stubs(:command_name).returns('find')
-    @started_event.stubs(:database_name).returns('mongodb-test')
-    @started_event.stubs(:command).returns({ 'find' => 'users', 'filter' => { 'name' => 'test' }})
-    address = stub('address', :host => "127.0.0.1", :port => 27017)
-    @started_event.stubs(:address).returns(address)
-
-    @succeeded_event = mock('succeeded event')
-    @succeeded_event.stubs(:operation_id).returns(1)
-    @succeeded_event.stubs(:duration).returns(2)
-
-    @subscriber = NewRelic::Agent::Instrumentation::MongodbCommandSubscriber.new
-
-    NewRelic::Agent::Hostname.stubs(:get).returns("nerd-server")
-    @stats_engine = NewRelic::Agent.instance.stats_engine
-    @stats_engine.clear_stats
-  end
-
-  def test_records_metrics_for_simple_find
-    in_transaction { simulate_query }
-
-    metric_name = 'Datastore/statement/MongoDB/users/find'
-    assert_metrics_recorded(
-      metric_name => { :call_count => 1, :total_call_time => 2.0 }
-    )
-  end
-
-  def test_records_scoped_metrics
-    in_transaction('test_txn') { simulate_query }
-
-    metric_name = 'Datastore/statement/MongoDB/users/find'
-    assert_metrics_recorded(
-      [ metric_name, 'test_txn' ] => { :call_count => 1, :total_call_time => 2 }
-    )
-  end
-
-  def test_records_nothing_if_tracing_disabled
-    NewRelic::Agent.disable_all_tracing { simulate_query }
-    metric_name = 'Datastore/statement/MongoDB/users/find'
-    assert_metrics_not_recorded([ metric_name ])
-  end
-
-  def test_records_rollup_metrics
-    in_web_transaction { simulate_query }
-
-    assert_metrics_recorded(
-      'Datastore/operation/MongoDB/find' => { :call_count => 1, :total_call_time => 2 },
-      'Datastore/allWeb' => { :call_count => 1, :total_call_time => 2 },
-      'Datastore/all' => { :call_count => 1, :total_call_time => 2 }
-    )
-  end
-
-  def test_should_not_raise_due_to_an_exception_during_instrumentation_callback
-    @subscriber.stubs(:metrics).raises(StandardError)
-    in_transaction { simulate_query }
-  end
-
-  def test_records_instance_metrics_for_tcp_connection
-    in_transaction { simulate_query }
-    assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server/27017')
-  end
-
-  def test_records_instance_metrics_for_unix_domain_socket
-    address = stub('address', :host => "/tmp/mongodb-27017.sock", :port => nil)
-    @started_event.stubs(:address).returns(address)
-    in_transaction { simulate_query }
-    assert_metrics_recorded('Datastore/instance/MongoDB/nerd-server//tmp/mongodb-27017.sock')
-  end
-
-  def test_records_unknown_unknown_metric_when_error_gathering_instance_data
-    @started_event.stubs(:address).returns(nil)
-    in_transaction { simulate_query }
-    assert_metrics_recorded('Datastore/instance/MongoDB/unknown/unknown')
-  end
-
-  def test_records_tt_segment_parameters_for_datastore_instance
-    in_transaction { simulate_query }
-
-    tt = last_transaction_trace
-
-    node = find_node_with_name_matching tt, /^Datastore\//
-
-    assert_equal(NewRelic::Agent::Hostname.get, node[:host])
-    assert_equal('27017', node[:port_path_or_id])
-    assert_equal('mongodb-test', node[:database_name])
-  end
-
-  def test_does_not_record_unknown_unknown_metric_when_data_empty
-    address = stub('address', :host => "", :port => "")
-    @started_event.stubs(:address).returns(address)
-    in_transaction { simulate_query }
-    assert_metrics_not_recorded('Datastore/instance/MongoDB/unknown/unknown')
-  end
-
-  def simulate_query
-    @subscriber.started(@started_event)
-    advance_time @succeeded_event.duration
-    @subscriber.succeeded(@succeeded_event)
-  end
-end

data/test/new_relic/agent/instrumentation/net_instrumentation_test.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-# 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 'net/http'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/cross_app_tracing'
-
-class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Minitest::Test
-  def setup
-    NewRelic::Agent.manual_start(
-      :"cross_application_tracer.enabled" => false,
-      :"transaction_tracer.enabled"       => true,
-      :cross_process_id                   => '269975#22824',
-      :encoding_key                       => 'gringletoes'
-    )
-
-    @response ||= nil
-
-    @socket = fixture_tcp_socket( @response )
-
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  end
-
-  def teardown
-    NewRelic::Agent.shutdown
-  end
-
-  def test_scope_stack_integrity_maintained_on_request_failure
-    @socket.stubs(:write).raises('fake network error')
-    with_config(:"cross_application_tracer.enabled" => true) do
-      state    = NewRelic::Agent::TransactionState.tl_get
-      stack    = state.traced_method_stack
-      expected = stack.push_frame(state, 'dummy')
-      Net::HTTP.get(URI.parse('http://www.google.com/index.html')) rescue nil
-      stack.pop_frame(state, expected, 42, Time.now.to_f)
-    end
-  end
-
-end