newrelic_rpm 3.6.1.88 → 3.6.2.90.beta

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -0,0 +1,103 @@
+# -*- 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 'sequel' unless defined?( Sequel )
+require 'newrelic_rpm' unless defined?( NewRelic )
+require 'new_relic/agent/instrumentation/active_record_helper'
+
+module Sequel
+
+  # New Relic's Sequel instrumentation is implemented via a plugin for
+  # Sequel::Models, and an extension for Sequel::Databases. Every database
+  # handle that Sequel knows about when New Relic is loaded will automatically
+  # be instrumented, but if you're using a version of Sequel before 3.47.0,
+  # you'll need to add the extension yourself if you create any after the
+  # instrumentation is loaded:
+  # 
+  #     db = Sequel.connect( ... )
+  #     db.extension :newrelic_instrumentation
+  # 
+  # Versions 3.47.0 and later use `Database.extension` to automatically
+  # install the extension for new connections.
+  # 
+  # == Disabling
+  # 
+  # If you don't want your models or database connections to be instrumented,
+  # you can disable them by setting `disable_database_instrumentation` in
+  # your `newrelic.yml` to `true`. It will also honor the 
+  # `disable_activerecord_instrumentation` setting.
+  # 
+  module NewRelicInstrumentation
+    include NewRelic::Agent::MethodTracer,
+            NewRelic::Agent::Instrumentation::ActiveRecordHelper
+
+
+    # Instrument all queries that go through #execute_query.
+    def log_yield( sql, args=nil )
+      return super unless NewRelic::Agent.is_execution_traced?
+
+      t0 = Time.now
+      rval = super
+      t1 = Time.now
+
+      begin
+        duration = t1 - t0
+        record_metrics( sql, args, duration )
+        notice_sql( sql, args, t0, t1 )
+      rescue => err
+        NewRelic::Agent.logger.debug "while recording metrics for Sequel", err
+      end
+
+      return rval
+    end
+
+    # Record metrics for the specified +sql+ and +args+ using the specified
+    # +duration+.
+    def record_metrics( sql, args, duration)
+      primary_metric = primary_metric_for( sql, args )
+      engine         = NewRelic::Agent.instance.stats_engine
+
+      engine.record_metrics( primary_metric, duration, :scoped => true )
+
+      metrics = rollup_metrics_for( primary_metric )
+      metrics << remote_service_metric( *self.opts.values_at(:adapter, :host) ) if self.opts.key?(:adapter)
+
+      engine.record_metrics( metrics, duration, :scoped => false )
+    end
+
+
+    # Record the given +sql+ within a new scope, using the given +start+ and
+    # +finish+ times.
+    def notice_sql( sql, args, start, finish )
+      metric   = primary_metric_for( sql, args )
+      agent    = NewRelic::Agent.instance
+      duration = finish - start
+
+      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
+        end
+      ensure
+        agent.stats_engine.pop_scope( scope, metric, finish )
+      end
+    end
+
+
+    # Derive a primary database metric for the specified +sql+.
+    def primary_metric_for( sql, _ )
+      return metric_for_sql(NewRelic::Helper.correctly_encoded(sql))
+    end
+
+  end # module NewRelicInstrumentation
+
+  NewRelic::Agent.logger.debug "Registering the :newrelic_instrumentation extension."
+  Database.register_extension( :newrelic_instrumentation, NewRelicInstrumentation )
+
+end # module Sequel
+

data/lib/sequel/plugins/newrelic_instrumentation.rb

@@ -0,0 +1,83 @@
+# -*- 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 'sequel' unless defined?( Sequel )
+require 'newrelic_rpm' unless defined?( NewRelic )
+
+module Sequel
+  module Plugins
+
+    # Sequel::Model instrumentation for the New Relic agent.
+    module NewrelicInstrumentation
+
+      # Meta-programming for creating method tracers for the Sequel::Model plugin.
+      module MethodTracer
+
+        # Make a lambda for the method body of the traced method
+        def make_tracer_method( opname, options )
+          body = Proc.new do |*args, &block|
+            classname = self.is_a?( Class ) ? self.name : self.class.name
+            metric = "ActiveRecord/%s/%s" % [ classname, opname ]
+            trace_execution_scoped( metric, options ) do
+              super( *args, &block )
+            end
+          end
+
+          return body
+        end
+
+        # Install a method named +method_name+ that will trace execution
+        # with a metric name derived from +metric+ (or +method_name+ if +metric+
+        # isn't specified). The +options+ hash is passed as-is though to
+        # NewRelic::Agent::MethodTracer#trace_execution_scoped; see the
+        # docs for that method for valid settings.
+        def add_method_tracer( method_name, metric=nil, options={} )
+          # Shift options hash if metric is omitted
+          if metric.is_a?( Hash )
+            options = metric
+            metric = nil
+          end
+
+          metric ||= method_name.to_s
+
+          body = make_tracer_method( metric, options )
+          define_method( method_name, &body )
+        end
+
+      end # module MethodTracer
+
+
+      # Methods to be added to Sequel::Model instances.
+      module InstanceMethods
+        include NewRelic::Agent::MethodTracer
+        extend Sequel::Plugins::NewrelicInstrumentation::MethodTracer
+
+        add_method_tracer :delete
+        add_method_tracer :destroy
+        add_method_tracer :update
+        add_method_tracer :update_all
+        add_method_tracer :update_except
+        add_method_tracer :update_fields
+        add_method_tracer :update_only
+        add_method_tracer :save
+
+      end # module InstanceMethods
+
+
+      # Methods to be added to Sequel::Model classes.
+      module ClassMethods
+        include NewRelic::Agent::MethodTracer
+        extend Sequel::Plugins::NewrelicInstrumentation::MethodTracer
+
+        add_method_tracer :[], :get
+        add_method_tracer :all
+        add_method_tracer :first
+        add_method_tracer :create
+      end # module ClassMethods
+
+    end # module NewRelicInstrumentation
+  end # module Plugins
+end # module Sequel
+

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

@@ -83,7 +83,7 @@ class ThreadProfilingTest < Test::Unit::TestCase
 
 
   def let_it_finish
-    Timeout.timeout(2) do
+    Timeout.timeout(5) do
       until @thread_profiler.finished?
         sleep(0.1)
       end

data/test/multiverse/suites/resque/instrumentation_test.rb

@@ -135,6 +135,7 @@ class ResqueTest < Test::Unit::TestCase
 
   def test_agent_posts_correct_metric_data
     run_worker
+    assert_metric_and_call_count('Instance/Busy', 1)
     assert_metric_and_call_count('OtherTransaction/ResqueJob/all', JOB_COUNT)
   end
 
@@ -146,6 +147,7 @@ class ResqueTest < Test::Unit::TestCase
 
     def test_agent_posts_correct_metric_data_background
       run_worker(:background => true)
+      assert_metric_and_call_count('Instance/Busy', 1)
       assert_metric_and_call_count('OtherTransaction/ResqueJob/all', JOB_COUNT)
     end
   end

data/test/new_relic/agent/database_test.rb

@@ -6,6 +6,10 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',
                                    'test_helper'))
 require 'new_relic/agent/database'
 class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
+  def setup
+    @explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
+  end
+
   def teardown
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
@@ -20,7 +24,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     config = {:adapter => 'mysql'}
     config.default('val')
     sql = 'SELECT foo'
-    connection = mock('connection')
+    connection = mock('mysql connection')
     plan = {
       "select_type"=>"SIMPLE", "key_len"=>nil, "table"=>"blogs", "id"=>"1",
       "possible_keys"=>nil, "type"=>"ALL", "Extra"=>"", "rows"=>"2",
@@ -30,9 +34,8 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     result.expects(:each_hash).yields(plan)
     # two rows, two columns
     connection.expects(:execute).with('EXPLAIN SELECT foo').returns(result)
-    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
-
-    result = NewRelic::Agent::Database.explain_sql(sql, config)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    result = NewRelic::Agent::Database.explain_sql(sql, config, &@explainer)
     assert_equal(plan.keys.sort, result[0].sort)
     assert_equal(plan.values.compact.sort, result[1][0].compact.sort)
   end
@@ -41,23 +44,23 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     config = {:adapter => 'postgresql'}
     config.default('val')
     sql = 'select count(id) from blogs limit 1'
-    connection = mock('connection')
+    connection = stub('pg connection', :disconnect! => true)
     plan = [{"QUERY PLAN"=>"Limit  (cost=11.75..11.76 rows=1 width=4)"},
             {"QUERY PLAN"=>"  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"},
             {"QUERY PLAN"=>"        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"}]
     connection.expects(:execute).returns(plan)
-    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
     assert_equal([['QUERY PLAN'],
                   [["Limit  (cost=11.75..11.76 rows=1 width=4)"],
                    ["  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"],
                    ["        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"]]],
-                 NewRelic::Agent::Database.explain_sql(sql, config))
+                 NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
   end
 
   def test_dont_collect_explain_for_parameterized_query
     config = {:adapter => 'postgresql'}
     config.default('val')
-    connection = mock('connection')
+    connection = mock('param connection')
     connection.expects(:execute).never
     NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
     expects_logging(:debug, 'Unable to collect explain plan for parameterized query.')
@@ -69,20 +72,20 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
   def test_do_collect_explain_for_parameter_looking_literal
     config = {:adapter => 'postgresql'}
     config.default('val')
-    connection = mock('connection')
+    connection = mock('literal connection')
     plan = [{"QUERY PLAN"=>"Some Jazz"}]
     connection.stubs(:execute).returns(plan)
     NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
 
     sql = "SELECT * FROM table WHERE id = 'noise $11'"
     assert_equal([['QUERY PLAN'], [["Some Jazz"]]],
-                 NewRelic::Agent::Database.explain_sql(sql, config))
+                 NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
   end
 
   def test_dont_collect_explain_for_truncated_query
     config = {:adapter => 'postgresql'}
     config.default('val')
-    connection = mock('connection')
+    connection = mock('truncated connection')
     connection.expects(:execute).never
     NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
     expects_logging(:debug, 'Unable to collect explain plan for truncated query.')
@@ -112,7 +115,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     # errors to percolate up.
     config = mock('config')
     config.stubs(:[]).returns(nil)
-    assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
+    assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config, &@explainer))
   end
 
   def test_obfuscation_mysql_basic

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

@@ -62,9 +62,6 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::Tes
     @response = CANNED_RESPONSE.clone
     @socket = fixture_tcp_socket( @response )
 
-    # $stderr.puts '', '---', ''
-    # NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new( {:log_level => 'debug'}, '', Logger.new($stderr) )
-
     @engine = NewRelic::Agent.instance.stats_engine
     @engine.clear_stats
 
@@ -175,6 +172,18 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::Tes
     ])
   end
 
+
+  # https://newrelic.atlassian.net/browse/RUBY-835
+  def test_direct_get_request_doesnt_double_count
+    uri = URI.parse("http://www.google.com/index.html")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.request(Net::HTTP::Get.new(uri.request_uri))
+
+    assert_metrics_recorded([
+      'External/www.google.com/Net::HTTP/GET'
+    ])
+  end
+
   def test_ignore
     in_transaction do
       NewRelic::Agent.disable_all_tracing do
@@ -429,4 +438,5 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Test::Unit::Tes
       assert_equal filtered_uri, last_segment.params[:uri]
     end
   end
+
 end

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

@@ -0,0 +1,285 @@
+# 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.
+
+if RUBY_VERSION >= "1.8.7"
+
+require 'sequel'
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < Test::Unit::TestCase
+  require 'active_record_fixtures'
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation,
+          TransactionSampleTestHelper
+
+  def self.jruby?
+    NewRelic::LanguageSupport.using_engine?('jruby')
+  end
+
+  def jruby?
+    self.class.jruby?
+  end
+
+  # Use an in-memory SQLite database
+  if (jruby?)
+    DB = Sequel.connect('jdbc:sqlite::memory:')
+  else
+    DB = Sequel.sqlite
+  end
+  DB.extension :newrelic_instrumentation
+
+  # Create tables and model classes for testing
+  DB.create_table( :authors ) do
+    primary_key :id
+    string :name
+    string :login
+  end
+  class Author < Sequel::Model; end
+
+  DB.create_table( :posts ) do
+    primary_key :id
+    string :title
+    string :content
+    time :created_at
+  end
+  class Post < Sequel::Model; end
+
+
+
+  #
+  # Setup/teardown
+  #
+
+  def setup
+    super
+
+    NewRelic::Agent.manual_start
+
+    @agent = NewRelic::Agent.instance
+    @agent.transaction_sampler.reset!
+
+    @engine = @agent.stats_engine
+    @engine.clear_stats
+    @engine.start_transaction
+
+    @sampler = NewRelic::Agent.instance.transaction_sampler
+  end
+
+  def teardown
+    super
+    @engine.end_transaction
+    NewRelic::Agent::TransactionInfo.reset
+    Thread::current[:newrelic_scope_name] = nil
+    NewRelic::Agent.shutdown
+  end
+
+
+  #
+  # Tests
+  #
+
+  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
+    Post.all
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/select"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/all"
+  end
+
+  def test_model_index_operator_generates_metrics
+    Post[11]
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/select"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/get"
+  end
+
+  def test_model_create_method_generates_metrics
+    post = Post.create( :title => 'The Thing', :content => 'A wicked short story.' )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/insert"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/create"
+  end
+
+  def test_model_update_method_generates_metrics
+    post = Post.create( :title => 'All The Things', :content => 'A story about beans.' )
+    post.update( :title => 'A Lot of the Things' )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/update"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/update"
+  end
+
+  def test_model_update_all_method_generates_metrics
+    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' )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/update"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/update_all"
+  end
+
+  def test_model_update_except_method_generates_metrics
+    post = Post.create( :title => 'All The Things', :content => 'A story.' )
+    post.update_except( {:title => 'A Bit More of the Things'}, :created_at )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/update"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/update_except"
+  end
+
+  def test_model_update_fields_method_generates_metrics
+    post = Post.create( :title => 'All The Things', :content => 'A venal short story.' )
+    post.update_fields( {:title => 'A Plethora of Things'}, [:title] )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/update"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/update_fields"
+  end
+
+  def test_model_update_only_method_generates_metrics
+    post = Post.create( :title => 'All The Things', :content => 'A meandering short story.' )
+    post.update_only( {:title => 'A Lot of the Things'}, :title )
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/update"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/update_only"
+  end
+
+  def test_model_save_method_generates_metrics
+    post = Post.new( :title => 'An Endless Lot Full of Things',
+                     :content => 'A lingering long story.' )
+    post.save
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/insert"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/save"
+  end
+
+  def test_model_delete_method_generates_metrics
+    post = Post.create( :title => 'All The Things', :content => 'A nice short story.' )
+    post.delete
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/delete"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/delete"
+  end
+
+  def test_model_destroy_method_generates_metrics
+    post = Post.create( :title => 'Most of the Things', :content => 'Another short story.' )
+    post.destroy
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/delete"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Post.name}/destroy"
+  end
+
+  def test_model_destroy_uses_the_class_name_for_the_metric
+    author = Author.create( :name => 'Marlon Forswytthe', :login => 'mfors' )
+    author.destroy
+
+    assert_remote_service_metrics
+    assert_includes @engine.metrics, "Database/SQL/delete"
+    assert_includes @engine.metrics, "ActiveRecord/all"
+    assert_includes @engine.metrics, "ActiveRecord/#{Author.name}/destroy"
+  end
+
+  def test_slow_queries_get_an_explain_plan
+    with_config( :'transaction_tracer.explain_threshold' => 0.0 ) do
+      segment = last_segment_for(:record_sql => :raw) 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_queries_can_get_explain_plan_with_obfuscated_sql
+    with_config( :'transaction_tracer.explain_threshold' => 0.0 ) 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 = build_message( msg, "Expected ? to have an explain plan", segment )
+    assert_block( msg ) { segment.params[:explain_plan].join =~ SQLITE_EXPLAIN_PLAN_COLUMNS_RE }
+  end
+
+  def assert_remote_service_metrics
+    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 with_controller_scope
+    @sampler.notice_first_scope_push Time.now.to_f
+    @sampler.notice_transaction('/', {})
+    @sampler.notice_push_scope "Controller/sandwiches/index"
+
+    yield if block_given?
+
+    @sampler.notice_pop_scope "Controller/sandwiches/index"
+    @sampler.notice_scope_empty(stub('txn', :name => '/', :custom_parameters => {}))
+    @sampler.samples
+  end
+
+  def last_segment_for(options={})
+      transaction_samples = with_controller_scope do
+        yield
+      end
+
+      sample = transaction_samples.first.prepare_to_send(
+        :explain_sql=>options[:explain_sql] || -0.01,    # Force to take explain, even if duration's reported as 0.0
+        :record_sql=>options[:record_sql])
+      segment = 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
+
+end