newrelic_rpm 3.10.0.279 → 3.11.0.283

data/gem-public_cert.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMREwDwYDVQQDDAhzZWN1
-cml0eTEYMBYGCgmSJomT8ixkARkWCG5ld3JlbGljMRMwEQYKCZImiZPyLGQBGRYD
-Y29tMB4XDTE0MDIxMjIzMzUzMloXDTE1MDIxMjIzMzUzMlowQjERMA8GA1UEAwwI
-c2VjdXJpdHkxGDAWBgoJkiaJk/IsZAEZFghuZXdyZWxpYzETMBEGCgmSJomT8ixk
-ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxaTfJVp22V
-JCFhQTS0Zuyo66ZknUwwoVbhuSoXJ0mo9PZSifiIwr9aHmM9dpSztUamDvXesLpP
-8HESyhe3sgpK0z7UXbDmtWZZx43qulx3xTObLQauVZcxP8qqGqvRzdovqXnFe8lN
-sRUnXQjm9kArMI8uHhcU7XvlbQeTtPcjP0U/ZSyKABsJXRamQ/SVCPXqAHXv+OWP
-t4yDB/MrAQFVSoNisyYtB7Af/izqw0/cnUCAOXGQL24l4Ir0dwMd0K6oAnaG93DB
-v6yb30VT5elw40BeIhBsjZP731vRgXIlIKYwhVAlkvRkexAy9kH456Vt0fDBBYka
-eE53BhdcguUCAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUPJxv/VCFdHOH
-lINeV2xQGQhFthEwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQDRCiPq
-50B4sJN0Gj2T+9g+uXtC845mJD+0BlsAVjLcc+TchxxD3BYeln9c2ErPSIrzZ92Q
-YlwLvw99ksJ5Qa/tAJCUyE3u9JuldalewRi/FHjoGcdhjUErzIyHtNlnCbTMfScz
-5T+r8iUhvt0tcZ0/dQ1LFN8vMizN4Rm6JMXsmkHHxuosllQ9Q14sCYd2ekk2UF0l
-59Jd6iWx3iVmUHSQNXiAdEihcwcx3e71dBNzl6FiR328PzniUjrhoSKzVLQv+JlR
-1fUxkomKs2EL+FYMwnAb+VmNOhv1S+sJhbjZ30PKgz6vLhT6unieCjLk9wGGmlSK
-YjbnvA9qraLLajSj
------END CERTIFICATE-----

data/lib/new_relic/agent/datastores/mongo/metric_generator.rb

@@ -1,33 +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/metric_translator'
-
-module NewRelic
-  module Agent
-    module Datastores
-      module Mongo
-        module MetricGenerator
-          def self.generate_metrics_for(name, payload)
-            if NewRelic::Agent::Transaction.recording_web_transaction?
-              request_type = :web
-            else
-              request_type = :other
-            end
-
-            NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(name, payload, request_type)
-          rescue => e
-            NewRelic::Agent.logger.debug("Failure during Mongo metric generation", e)
-            []
-          end
-
-          def self.generate_instance_metric_for(host, port, database_name)
-            return unless host && port && database_name
-            NewRelic::Agent::Datastores::Mongo::MetricTranslator.instance_metric(host, port, database_name)
-          end
-        end
-      end
-    end
-  end
-end

data/test/multiverse/suites/sequel/sequel_instrumentation_test.rb

@@ -1,289 +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.join(File.dirname(__FILE__), 'database.rb')
-
-if Sequel.const_defined?( :MAJOR ) &&
-      ( Sequel::MAJOR > 3 ||
-        Sequel::MAJOR == 3 && Sequel::MINOR >= 37 )
-
-require 'newrelic_rpm'
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'agent_helper')
-
-class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < Minitest::Test
-
-  def setup
-    super
-
-    DB.extension :newrelic_instrumentation
-
-    NewRelic::Agent.manual_start
-    NewRelic::Agent.instance.transaction_sampler.reset!
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  end
-
-  def teardown
-    super
-
-    NewRelic::Agent.shutdown
-  end
-
-  def test_sequel_database_instrumentation_is_loaded
-    assert DB.respond_to?( :primary_metric_for )
-  end
-
-  def test_sequel_model_instrumentation_is_loaded
-    assert Post.respond_to?( :trace_execution_scoped )
-  end
-
-  def test_model_enumerator_generates_metrics
-    in_web_transaction { Post.all }
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/select",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/all"
-    ])
-  end
-
-  def test_model_index_operator_generates_metrics
-    in_web_transaction { Post[11] }
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/select",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/get"
-    ])
-  end
-
-  def test_model_create_method_generates_metrics
-    in_web_transaction do
-      Post.create( :title => 'The Thing', :content => 'A wicked short story.' )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      'Database/SQL/insert',
-      'ActiveRecord/all',
-      "ActiveRecord/#{Post.name}/create"
-    ])
-  end
-
-  def test_model_update_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A story about beans.' )
-      post.update( :title => 'A Lot of the Things' )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      'Database/SQL/update',
-      'ActiveRecord/all',
-      "ActiveRecord/#{Post.name}/update"
-    ])
-  end
-
-  def test_model_update_all_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A nicer story than yours.' )
-      post.update_all( :title => 'A Whole Hell of a Lot of the Things' )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/update",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/update_all"
-    ])
-  end
-
-  def test_model_update_except_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A story.' )
-      post.update_except( {:title => 'A Bit More of the Things'} )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/update",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/update_except"
-    ])
-  end
-
-  def test_model_update_fields_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A venal short story.' )
-      post.update_fields( {:title => 'A Plethora of Things'}, [:title] )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/update",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/update_fields"
-    ])
-  end
-
-  def test_model_update_only_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A meandering short story.' )
-      post.update_only( {:title => 'A Lot of the Things'}, :title )
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/update",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/update_only"
-    ])
-  end
-
-  def test_model_save_method_generates_metrics
-    in_web_transaction do
-      post = Post.new( :title => 'An Endless Lot Full of Things',
-                       :content => 'A lingering long story.' )
-      post.save
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/insert",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/save"
-    ])
-  end
-
-  def test_model_delete_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'All The Things', :content => 'A nice short story.' )
-      post.delete
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/delete",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/delete"
-    ])
-  end
-
-  def test_model_destroy_method_generates_metrics
-    in_web_transaction do
-      post = Post.create( :title => 'Most of the Things', :content => 'Another short story.' )
-      post.destroy
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/delete",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Post.name}/destroy"
-    ])
-  end
-
-  def test_model_destroy_uses_the_class_name_for_the_metric
-    in_web_transaction do
-      author = Author.create( :name => 'Marlon Forswytthe', :login => 'mfors' )
-      author.destroy
-    end
-
-    assert_remote_service_metrics
-    assert_metrics_recorded([
-      "Database/SQL/delete",
-      "ActiveRecord/all",
-      "ActiveRecord/#{Author.name}/destroy"
-    ])
-  end
-
-  def test_slow_queries_get_an_explain_plan
-    with_config( :'transaction_tracer.explain_threshold' => -0.01,
-                 :'transaction_tracer.record_sql' => 'raw' ) do
-      segment = last_segment_for do
-        Post[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = 11}i, segment.params[:sql]
-      assert_segment_has_explain_plan( segment )
-    end
-  end
-
-  def test_no_explain_plans_with_single_threaded_connection
-    connect_opts = DB.opts
-    single_threaded_db = Sequel.connect(connect_opts.merge(:single_threaded => true))
-    create_tables(single_threaded_db)
-    model_class = Class.new(Sequel::Model(single_threaded_db[:posts]))
-
-    with_config(:'transaction_tracer.explain_threshold' => -0.01,
-                :'transaction_tracer.record_sql' => 'raw') do
-      segment = last_segment_for do
-        model_class[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = 11}i, segment.params[:sql]
-      assert_equal([], segment.params[:explain_plan], "Should not capture explain plan with single-threaded connection pool")
-    end
-  end
-
-  def test_queries_can_get_explain_plan_with_obfuscated_sql
-    config = {
-      :'transaction_tracer.explain_threshold' => -0.01,
-      :'transaction_tracer.record_sql' => 'obfuscated'
-    }
-    with_config(config) do
-      segment = last_segment_for(:record_sql => :obfuscated) do
-        Post[11]
-      end
-      assert_match %r{select \* from `posts` where `id` = \?}i, segment.params[:sql]
-      assert_segment_has_explain_plan( segment )
-    end
-  end
-
-
-  #
-  # Helpers
-  #
-
-  # Pattern to match the column headers of a Sqlite explain plan
-  SQLITE_EXPLAIN_PLAN_COLUMNS_RE =
-    %r{\|addr\s*\|opcode\s*\|p1\s*\|p2\s*\|p3\s*\|p4\s*\|p5\s*\|comment\s*\|}
-
-  # This is particular to sqlite plans currently. To abstract it up, we'd need to
-  # be able to specify a flavor (e.g., :sqlite, :postgres, :mysql, etc.)
-  def assert_segment_has_explain_plan( segment, msg=nil )
-    msg = "Expected #{segment.inspect} to have an explain plan"
-    assert_block( msg ) { segment.params[:explain_plan].join =~ SQLITE_EXPLAIN_PLAN_COLUMNS_RE }
-  end
-
-  def assert_remote_service_metrics
-    engine = NewRelic::Agent.instance.stats_engine
-    if (jruby?)
-      assert engine.metrics.none? {|s| s.start_with?("RemoteService/")}, "Sqlite on JRuby doesn't report adapter right for this metric. Why's it here?"
-    else
-      assert_includes engine.metrics, "RemoteService/sql/sqlite/localhost"
-    end
-  end
-
-  def last_segment_for(options={})
-      in_transaction('sandwiches/index') do
-        yield
-      end
-      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-      sample.prepare_to_send!
-      last_segment(sample)
-  end
-
-  def last_segment(txn_sample)
-    l_segment = nil
-    txn_sample.root_segment.each_segment do |segment|
-      l_segment = segment
-    end
-    l_segment
-  end
-
-end
-
-else
-  puts "Skipping tests in #{__FILE__} because unsupported Sequel version"
-end

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

@@ -1,69 +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/metric_generator'
-
-class NewRelic::Agent::Datastores::Mongo::MetricGeneratorTest < Minitest::Test
-  include ::NewRelic::TestHelpers::MongoMetricBuilder
-
-  def setup
-    @payload = { :collection => 'tribbles', :database => 'enterprise' }
-  end
-
-  def test_generate_metrics_for_includes_all_web_for_web_requests
-    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
-
-    assert_includes metrics, 'Datastore/allWeb'
-  end
-
-  def test_generate_metrics_for_does_not_include_all_other_for_web_requests
-    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(true)
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
-
-    refute metrics.include? 'Datastore/allOther'
-  end
-
-  def test_generate_metrics_for_includes_all_other_for_other_requests
-    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(false)
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
-
-    assert_includes metrics, 'Datastore/allOther'
-  end
-
-  def test_generate_metrics_for_does_not_include_all_web_for_other_requests
-    NewRelic::Agent::Transaction.stubs(:recording_web_transaction?).returns(false)
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
-
-    refute metrics.include? 'Datastore/allWeb'
-  end
-
-  def test_generate_metrics_for_is_graceful_if_exceptions_are_raised
-    NewRelic::Agent::Datastores::Mongo::MetricTranslator.stubs(:metrics_for).raises("Booom")
-    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
-
-    assert_empty metrics
-  end
-
-  def test_generate_instance_metric_for_returns_instance_metric_for_given_attributes
-    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', 'port', 'database')
-    assert_equal 'Datastore/instance/MongoDB/host:port/database', result
-  end
-
-  def test_generate_metrics_for_does_not_include_instance_metric_without_host
-    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for(nil, 'port', 'database')
-    assert_nil result
-  end
-
-  def test_generate_metrics_for_does_not_include_instance_metric_without_port
-    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', nil, 'database')
-    assert_nil result
-  end
-
-  def test_generate_metrics_for_does_not_include_instance_metric_without_database_name
-    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', 'port', nil)
-    assert_nil result
-  end
-end

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -1,155 +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'))
-
-memcached_ready = false
-classes = {
-#   'memcache' => 'MemCache',
-#   'dalli' => 'Dalli::Client',
-  'memcached' => 'Memcached'
-#   'spymemcached' => 'Spymemcached'
-}
-begin
-  TCPSocket.new('localhost', 11211)
-  classes.each do |req, const|
-    begin
-      require req
-      MEMCACHED_CLASS = const.constantize
-      puts "Testing #{MEMCACHED_CLASS}"
-      memcached_ready = true
-    rescue LoadError
-    rescue NameError
-    end
-  end
-rescue Errno::ECONNREFUSED
-rescue Errno::ETIMEDOUT
-end
-
-if memcached_ready
-  class NewRelic::Agent::MemcacheInstrumentationTest < Minitest::Test
-    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-    def setup
-      NewRelic::Agent.manual_start
-      @engine = NewRelic::Agent.instance.stats_engine
-
-      case MEMCACHED_CLASS.name
-      when 'Memcached'
-        @cache = MEMCACHED_CLASS.new('localhost', :support_cas => true)
-      when 'Spymemcached'
-        @cache = MEMCACHED_CLASS.new('localhost:11211')
-      else
-        @cache = MEMCACHED_CLASS.new('localhost')
-      end
-      @key = 'schluessel'
-      @cache.set('schluessel', 1)
-    end
-
-    def teardown
-      if MEMCACHED_CLASS.name == 'Memcached'
-        @cache.flush
-      elsif MEMCACHED_CLASS.name == 'Spymemcached'
-        @cache.flush
-        @cache.instance_eval{ @client.shutdown }
-      else
-        @cache.flush_all
-      end
-    end
-
-    def _call_test_method_in_web_transaction(method, *args)
-      @engine.clear_stats
-      perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
-        @cache.send(method.to_sym, *[@key, *args])
-      end
-    end
-
-    def _call_test_method_in_background_task(method, *args)
-      @engine.clear_stats
-      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
-        @cache.send(method.to_sym, *[@key, *args])
-      end
-    end
-
-    def test_reads__web
-      commands = ['get']
-      commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-      expected_metrics = commands
-      expected_metrics = ['single_get', 'multi_get'] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
-      commands.zip(expected_metrics) do |method, metric|
-        if @cache.class.method_defined?(method)
-          _call_test_method_in_web_transaction(method)
-          compare_metrics ["Memcache/#{metric}", "Memcache/allWeb", "Memcache/#{metric}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
-          @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-    end
-
-    def test_writes__web
-      %w[delete].each do |method|
-        if @cache.class.method_defined?(method)
-          _call_test_method_in_web_transaction(method)
-          expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
-          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-
-      %w[set add].each do |method|
-        @cache.delete(@key) rescue nil
-        if @cache.class.method_defined?(method)
-          expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
-          _call_test_method_in_web_transaction(method, 'value')
-          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-    end
-
-    def test_reads__background
-      commands = ['get']
-      commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-      expected_metrics = commands
-      expected_metrics = ['single_get', 'multi_get'] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
-      commands.zip(expected_metrics) do |method, metric|
-        if @cache.class.method_defined?(method)
-          _call_test_method_in_background_task(method)
-          compare_metrics ["Memcache/#{metric}", "Memcache/allOther", "Memcache/#{metric}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
-          @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-    end
-
-    def test_writes__background
-      %w[delete].each do |method|
-        expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
-        if @cache.class.method_defined?(method)
-          _call_test_method_in_background_task(method)
-          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-
-      %w[set add].each do |method|
-        @cache.delete(@key) rescue nil
-        expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
-        if @cache.class.method_defined?(method)
-          _call_test_method_in_background_task(method, 'value')
-          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        end
-      end
-    end
-
-    def test_handles_cas
-      expected_metrics = ["cas"]
-      expected_metrics = ["single_get", "single_cas"] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
-      expected_metrics = ["Memcache/allOther"] + expected_metrics.flat_map {|m| ["Memcache/#{m}", "Memcache/#{m}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"] }
-      if @cache.class.method_defined?(:cas)
-        @engine.clear_stats
-        perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
-          @cache.cas(@key) {|val| val += 2 }
-        end
-        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-        assert_equal 3, @cache.get(@key)
-      end
-    end
-  end
-end