newrelic_rpm 3.6.1.88 → 3.6.2.90.beta

data/CHANGELOG

@@ -1,6 +1,26 @@
 
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.2 ##
+
+  * Sequel support
+
+  The Ruby agent now supports Sequel, a database toolkit for Ruby. This
+  includes capturing SQL calls and model operations in transaction traces, and
+  recording slow SQL calls. See https://newrelic.com/docs/ruby/sequel-instrumentation
+  for full details.
+
+  * Fix for over-counted Net::HTTP calls
+
+  Under some circumstances, calls into Net::HTTP were being counted twice in
+  metrics and transaction traces. This has been fixed.
+
+  * Missing traced errors for Resque applications
+
+  Traced errors weren't displaying for some Resque workers, although the errors
+  were factored into the overall count graphs. This has been fixed, and traced
+  errors should be available again after upgrading the agent.
+
 ## v3.6.1 ##
 
   * Full URIs for HTTP requests are recorded in transaction traces

data/Gemfile

@@ -12,4 +12,5 @@ group :development do
   gem 'sqlite3', :platform => 'mri'
   gem 'activerecord-jdbcsqlite3-adapter', :platform => 'jruby'
   gem 'jruby-openssl', :platform => 'jruby'
+  gem 'sequel', '~> 3.46.0'
 end

data/lib/new_relic/agent/autostart.rb

@@ -19,9 +19,10 @@ module NewRelic
       extend self
 
 
-      # The constants and execuatables (i.e. $0) used can be configured with
-      # via the config keys 'autostart.blacklisted_constants' and
-      # 'autostart.blacklisted_executables'
+      # The constants, execuatables (i.e. $0) and rake tasks used can be
+      # configured with the config keys 'autostart.blacklisted_constants',
+      # 'autostart.blacklisted_executables' and
+      # 'autostart.blacklisted_rake_tasks'
       def agent_should_start?
           !::NewRelic::Agent.config['autostart.blacklisted_constants'] \
             .split(/\s*,\s*/).any?{ |name| constant_is_defined?(name) } &&

data/lib/new_relic/agent/database.rb

@@ -46,8 +46,8 @@ module NewRelic
         end
       end
 
-      def get_connection(config)
-        ConnectionManager.instance.get_connection(config)
+      def get_connection(config, &connector)
+        ConnectionManager.instance.get_connection(config, &connector)
       end
 
       def close_connections
@@ -63,14 +63,14 @@ module NewRelic
       # exceeds a threshold (e.g. 500ms) and only within the slowest
       # transaction in a report period, selected for shipment to New
       # Relic
-      def explain_sql(sql, connection_config)
+      def explain_sql(sql, connection_config, &explainer)
         return nil unless sql && connection_config
         statement = sql.split(";\n")[0] # only explain the first
-        explain_plan = explain_statement(statement, connection_config)
+        explain_plan = explain_statement(statement, connection_config, &explainer)
         return explain_plan || []
       end
 
-      def explain_statement(statement, config)
+      def explain_statement(statement, config, &explainer)
         return unless is_select?(statement)
 
         if statement[-3,3] == '...'
@@ -84,14 +84,10 @@ module NewRelic
         end
 
         handle_exception_in_explain do
-          connection = get_connection(config)
-          plan = nil
-          if connection
-            start = Time.now
-            plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
-            ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
-          end
-          return plan
+          start = Time.now
+          plan = explainer.call(config, statement)
+          ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
+          return process_resultset(plan) if plan
         end
       end
 
@@ -130,8 +126,10 @@ module NewRelic
         begin
           # guarantees no throw from explain_sql
           ::NewRelic::Agent.logger.error("Error getting query plan:", e)
+          nil
         rescue
           # double exception. throw up your hands
+          nil
         end
       end
 
@@ -153,7 +151,7 @@ module NewRelic
         # configuration - these are stored or reopened as needed, and if
         # we cannot get one, we ignore it and move on without explaining
         # the sql
-        def get_connection(config)
+        def get_connection(config, &connector)
           @connections ||= {}
 
           connection = @connections[config]
@@ -161,8 +159,7 @@ module NewRelic
           return connection if connection
 
           begin
-            connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
-            @connections[config] = connection
+            @connections[config] = connector.call(config)
           rescue => e
             ::NewRelic::Agent.logger.error("Caught exception trying to get connection to DB for explain. Control: #{config}", e)
             nil
@@ -253,7 +250,7 @@ module NewRelic
       end
 
       class Statement < String
-        attr_accessor :adapter
+        attr_accessor :adapter, :config, :explainer
       end
     end
   end

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

@@ -6,6 +6,16 @@ module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecord
+        EXPLAINER = lambda do |config, query|
+          connection = NewRelic::Agent::Database.get_connection(config) do
+            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
+                                      config)
+          end
+          if connection && connection.respond_to?(:execute)
+            return connection.execute("EXPLAIN #{query}")
+          end
+        end
+
         def self.included(instrumented_class)
           instrumented_class.class_eval do
             unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
@@ -36,10 +46,13 @@ module NewRelic
                 log_without_newrelic_instrumentation(*args, &block)
               ensure
                 elapsed_time = (Time.now - t0).to_f
+
                 NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
-                                                         @config, elapsed_time)
+                                                      @config, elapsed_time,
+                                                                  &EXPLAINER)
                 NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
-                                                         @config, elapsed_time)
+                                                      @config, elapsed_time,
+                                                                  &EXPLAINER)
               end
             end
           end

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

@@ -63,7 +63,7 @@ module NewRelic
         # Host defaults to "localhost".
         def remote_service_metric(adapter, host)
           host ||= 'localhost'
-          type = adapter.sub(/\d*/, '')
+          type = adapter.to_s.sub(/\d*/, '')
           "RemoteService/sql/#{type}/#{host}"
         end
       end

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

@@ -27,6 +27,16 @@ module NewRelic
           notice_sql(event)
         end
 
+        def get_explain_plan( config, query )
+          connection = NewRelic::Agent::Database.get_connection(config) do
+            ::ActiveRecord::Base.send("#{config[:adapter]}_connection",
+                                      config)
+          end
+          if connection && connection.respond_to?(:execute)
+            return connection.execute("EXPLAIN #{query}")
+          end
+        end
+
         def notice_sql(event)
           config = active_record_config_for_event(event)
           metric = base_metric(event)
@@ -36,11 +46,13 @@ module NewRelic
 
           NewRelic::Agent.instance.transaction_sampler \
             .notice_sql(event.payload[:sql], config,
-                        Helper.milliseconds_to_seconds(event.duration))
+                        Helper.milliseconds_to_seconds(event.duration),
+                        &method(:get_explain_plan))
 
           NewRelic::Agent.instance.sql_sampler \
             .notice_sql(event.payload[:sql], metric, config,
-                        Helper.milliseconds_to_seconds(event.duration))
+                        Helper.milliseconds_to_seconds(event.duration),
+                        &method(:get_explain_plan))
 
           # exit transaction trace segment
           NewRelic::Agent.instance.stats_engine.pop_scope(scope, metric, event.end)

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

@@ -2,7 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-
 DependencyDetection.defer do
   @name = :net
 
@@ -17,11 +16,18 @@ DependencyDetection.defer do
 
   executes do
     class Net::HTTP
-
-      # Instrument outgoing HTTP requests and fire associated events back
-      # into the Agent.
+      # Instrument outgoing HTTP requests
+      #
+      # If request is called when not the connection isn't started, request
+      # will call back into itself (via a start block).
+      #
+      # Don't tracing until the inner call then to avoid double-counting.
       def request_with_newrelic_trace(request, *args, &block)
-        NewRelic::Agent::CrossAppTracing.trace_http_request( self, request ) do
+        if started?
+          NewRelic::Agent::CrossAppTracing.trace_http_request( self, request ) do
+            request_without_newrelic_trace( request, *args, &block )
+          end
+        else
           request_without_newrelic_trace( request, *args, &block )
         end
       end

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

@@ -66,8 +66,7 @@ DependencyDetection.defer do
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,
                                      :sync_startup => true,
-                                     :start_channel_listener => true,
-                                     :report_instance_busy => false)
+                                     :start_channel_listener => true)
       end
 
       ::Resque.before_fork do |job|
@@ -75,7 +74,10 @@ DependencyDetection.defer do
       end
 
       ::Resque.after_fork do |job|
-        NewRelic::Agent.after_fork(:report_to_channel => job.object_id)
+        # Only suppress reporting Instance/Busy for forked children
+        # Traced errors UI relies on having the parent process report that metric
+        NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
+                                   :report_instance_busy => false)
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# -*- 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 'newrelic_rpm'
+
+DependencyDetection.defer do
+  @name = :sequel
+
+  depends_on do
+    defined?(::Sequel)
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+    !NewRelic::Agent.config[:disable_database_instrumentation]
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing Sequel instrumentation'
+
+    if Sequel::Database.respond_to?( :extension )
+      Sequel::Database.extension :newrelic_instrumentation
+    else
+      NewRelic::Agent.logger.info "Detected Sequel version %s." % [ Sequel::VERSION ]
+      NewRelic::Agent.logger.info "Please see additional documentation: " +
+        "https://newrelic.com/docs/ruby/sequel-instrumentation"
+    end
+
+    Sequel.synchronize{Sequel::DATABASES.dup}.each do |db|
+      db.extension :newrelic_instrumentation
+    end
+
+    Sequel::Model.plugin :newrelic_instrumentation
+
+  end
+
+end
+

data/lib/new_relic/agent/sql_sampler.rb

@@ -99,14 +99,14 @@ module NewRelic
 
       end
 
-      def notice_sql(sql, metric_name, config, duration)
+      def notice_sql(sql, metric_name, config, duration, &explainer)
         return unless transaction_data
         if NewRelic::Agent.is_sql_recorded?
           if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
             transaction_data.sql_data << SlowSql.new(TransactionSampler.truncate_message(sql),
                                                      metric_name, config,
-                                                     duration, backtrace)
+                                                     duration, backtrace, &explainer)
           end
         end
       end
@@ -163,12 +163,14 @@ module NewRelic
       attr_reader :duration
       attr_reader :backtrace
 
-      def initialize(sql, metric_name, config, duration, backtrace = nil)
+      def initialize(sql, metric_name, config, duration, backtrace=nil,
+                     &explainer)
         @sql = sql
         @metric_name = metric_name
         @config = config
         @duration = duration
         @backtrace = backtrace
+        @explainer = explainer
       end
 
       def obfuscate
@@ -181,7 +183,14 @@ module NewRelic
       end
 
       def explain
-        NewRelic::Agent::Database.explain_sql(@sql, @config)
+        if @config && @explainer
+          NewRelic::Agent::Database.explain_sql(@sql, @config, &@explainer)
+        end
+      end
+
+      # We can't serialize the explainer, so clear it before we transmit
+      def prepare_to_send
+        @explainer = nil
       end
     end
 
@@ -222,6 +231,7 @@ module NewRelic
       def prepare_to_send
         params[:explain_plan] = @slow_sql.explain if need_to_explain?
         @sql = @slow_sql.obfuscate if need_to_obfuscate?
+        @slow_sql.prepare_to_send
       end
 
       def need_to_obfuscate?

data/lib/new_relic/agent/transaction_sampler.rb

@@ -261,19 +261,16 @@ module NewRelic
       # active segment like a sql query, memcache key, or Net::HTTP uri
       #
       # duration is seconds, float value.
-      def notice_extra_data(message, duration, key, config=nil, config_key=nil)
+      def notice_extra_data(message, duration, key)
         return unless builder
         segment = builder.current_segment
         if segment
-          new_message = self.class.truncate_message(append_new_message(segment[key],
-                                                            message))
-          if key == :sql && config.respond_to?(:has_key?) && config.has_key?(:adapter)
-            segment[key] = Database::Statement.new(new_message)
-            segment[key].adapter = config[:adapter]
+          if key != :sql
+            segment[key] = self.class.truncate_message(append_new_message(segment[key],
+                                                                          message))
           else
-            segment[key] = new_message
+            segment[key] = message
           end
-          segment[config_key] = config if config_key
           append_backtrace(segment, duration)
         end
       end
@@ -314,9 +311,15 @@ module NewRelic
       # may be very large; we should trim them to a maximum usable length
       # config is the driver configuration for the connection
       # duration is seconds, float value.
-      def notice_sql(sql, config, duration)
+      def notice_sql(sql, config, duration, &explainer)
         if NewRelic::Agent.is_sql_recorded?
-          notice_extra_data(sql, duration, :sql, config, :connection_config)
+          statement = Database::Statement.new(self.class.truncate_message(sql))
+          if config
+            statement.adapter = config[:adapter]
+            statement.config = config
+          end
+          statement.explainer = explainer
+          notice_extra_data(statement, duration, :sql)
         end
       end
 

data/lib/new_relic/build.rb

@@ -1,2 +1,2 @@
-# GITSHA: a83461a282a21153235345f8ea3fbfc579b87126
-module NewRelic; module VERSION; BUILD='88'; end; end
+# GITSHA: cf4fddf24f885c2d7a4cbdaf9c3b762e482354e8
+module NewRelic; module VERSION; BUILD='90.beta'; end; end

data/lib/new_relic/transaction_sample/segment.rb

@@ -182,16 +182,23 @@ module NewRelic
         end
         nil
       end
-      
+
       def explain_sql
-        NewRelic::Agent::Database.explain_sql(params[:sql],
-                                              params[:connection_config])
+        return params[:explain_plan] if params.key?(:explain_plan)
+
+        statement = params[:sql]
+        return nil unless statement.respond_to?(:config) &&
+                          statement.respond_to?(:explainer)
+
+        NewRelic::Agent::Database.explain_sql(statement,
+                                              statement.config,
+                                              &statement.explainer)
       end
-      
+
       def obfuscated_sql
         NewRelic::Agent::Database.obfuscate_sql(params[:sql])
       end
-      
+
       def params=(p)
         @params = p
       end

data/lib/new_relic/version.rb

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