newrelic_rpm 3.15.1.316 → 3.15.2.317

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1bc3b5920b3b7ea0c2997962168a45b01127ea75
-  data.tar.gz: e48ce51b1f0bb6847fa09ab23dfa005a3f068311
+  metadata.gz: 3e8eefedf383e69a41a5dfb8f9c607a8c93f3390
+  data.tar.gz: 4aa588cdb66a876439bc666ab40a5dd8bb829a50
 SHA512:
-  metadata.gz: 47057832e75c7c3319433fb03ee49475136c1e8c284fa3b238d5e591d185f6f5222cfb7b8c3f6696b0aa99bcbfae827ea964beb7712a0b15954dea8b72b69033
-  data.tar.gz: 6428ef632749929082e53b93e74df3239c41430bf7688ab6c28822dcf3889cf23b1e17501f1f2eb75ee186327231ca3fbd77f6ca1963f97f8c6041ed7c6aef0e
+  metadata.gz: aa28051c2fe6daef0a6adbbb71cb884da9ecb83ec26835ad6e5de7ddbbfd43180bdd220669ca226dbba226668b7f9e1c56274ecc01e0fe3dd9af7a0db901f9da
+  data.tar.gz: 6e9e0e4b9183378f59fab486acf5ca1eeae547f0850f6657ba50cf3df7122a9a665bfb5ce4207439c345775286516ac7c48baf3958a9182715cbe68c6ff490a4

data/CHANGELOG

@@ -1,6 +1,47 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.15.2 ##
+
+  * Run explain plans on parameterized slow queries in AR4
+
+  In our ActiveRecord 4 instrumentation, we moved to tracing slow queries
+  using the payloads from ActiveSupport::Notifications `sql.active_record`
+  events. As a result, we were unable to run explain plans on parameterized
+  queries. This has now been updated to pass along and use the parameter values,
+  when available, to get the explain plans.
+
+  * Fix getMore metric grouping issue in Mongo 2.2.x instrumentation
+
+  A metric grouping issue had cropped up when using the most recent Mongo gem
+  (2.2.0) with the most recent release of the server (3.2.4). We now have a more
+  future-proof setup for preventing these.
+
+  * Restore older DataMapper support after password obfuscation fix
+
+  Back in 3.14.3, we released a fix to avoid inadvertently sending sensitive
+  information from DataMapper SQLErrors. Our implementation did not account for
+  DataMapper versions below v0.10.0 not implementing the #options accessor.
+  Thanks Bram de Vries for the fix to our fix!
+
+  * Padrino 0.13.1 Support
+
+  Users with Padrino 0.13.x apps were previously seeing the default transaction
+  name "(unknown)" for all of their routes. We now provide the full Padrino
+  route template in transaction names, including any parameter placeholders.
+  Thanks Robert Schulze for the contribution!
+
+  * Update transaction naming for Grape 0.16.x
+
+  In Grape 0.16.x, `route_` methods are no longer prefixed. Thanks to Daniel
+  Doubrovkine for the contribution!
+
+  * Fix name collision on method created for default metric name fix
+
+  We had a name collision with the yard gem, which sets a `class_name` method
+  on Module. We've renamed our internal method to `derived_class_name` instead.
+
 ## v3.15.1 ##
+
   * Rack 2 alpha support
 
   This release includes experimental support for Rack 2 as of 2.0.0.alpha.

data/lib/new_relic/agent/agent.rb

@@ -1033,7 +1033,7 @@ module NewRelic
         #    drop any stored data and reset to a clean state.
         #
         #  #merge!(payload)
-        #    merge the given pyalod back into the internal buffer of the
+        #    merge the given payload back into the internal buffer of the
         #    container, so that it may be harvested again later.
         #
         def harvest_and_send_from_container(container, endpoint)

data/lib/new_relic/agent/autostart.rb

@@ -8,7 +8,7 @@ module NewRelic
     # monitoring.
     #
     # If the agent is in a monitored environment (e.g. production) it will
-    # attempt to avoid starting at "inapproriate" times, for example in an IRB
+    # attempt to avoid starting at "inappropriate" times, for example in an IRB
     # session.  On Heroku, logs typically go to STDOUT so agent logs can spam
     # the console during interactive sessions.
     #

data/lib/new_relic/agent/database.rb

@@ -3,9 +3,8 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'singleton'
-require 'new_relic/agent/database/obfuscation_helpers'
+require 'new_relic/agent/database/explain_plan_helpers'
 require 'new_relic/agent/database/obfuscator'
-require 'new_relic/agent/database/postgres_explain_obfuscator'
 
 module NewRelic
   # columns for a mysql explain plan
@@ -95,157 +94,18 @@ module NewRelic
         ConnectionManager.instance.close_connections
       end
 
-      # This takes a connection config hash from ActiveRecord or Sequel and
-      # returns a string describing the associated database adapter
-      def adapter_from_config(config)
-        if config[:adapter]
-          return config[:adapter].to_s
-        elsif config[:uri] && config[:uri].to_s =~ /^jdbc:([^:]+):/
-          # This case is for Sequel with the jdbc-mysql, jdbc-postgres, or
-          # jdbc-sqlite3 gems.
-          return $1
-        end
-      end
-
       # Perform this in the runtime environment of a managed
       # application, to explain the sql statement executed within a
-      # node of a transaction sample. Returns an array of
-      # explanations (which is an array rows consisting of an array of
-      # strings for each column returned by the the explain query)
-      # Note this happens only for statements whose execution time
-      # 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, explainer=nil)
-        return nil unless sql && explainer && connection_config
-        statement = sql.split(";\n")[0] # only explain the first
-        explain_plan = explain_statement(statement, connection_config, explainer)
-        return explain_plan || []
-      end
-
-      SUPPORTED_ADAPTERS_FOR_EXPLAIN = %w[postgres postgresql mysql2 mysql sqlite].freeze
-
-      def explain_statement(statement, config, explainer)
-        return unless explainer && is_select?(statement)
-
-        if statement[-3,3] == '...'
-          NewRelic::Agent.logger.debug('Unable to collect explain plan for truncated query.')
-          return
-        end
-
-        if parameterized?(statement)
-          NewRelic::Agent.logger.debug('Unable to collect explain plan for parameterized query.')
-          return
-        end
-
-        adapter = adapter_from_config(config)
-        if !SUPPORTED_ADAPTERS_FOR_EXPLAIN.include?(adapter)
-          NewRelic::Agent.logger.debug("Not collecting explain plan because an unknown connection adapter ('#{adapter}') was used.")
-          return
-        end
-
-        handle_exception_in_explain do
-          start = Time.now
-          plan = explainer.call(config, statement)
-          ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
-          return process_resultset(plan, adapter) if plan
-        end
-      end
-
-      def process_resultset(results, adapter)
-        case adapter.to_s
-        when 'postgres', 'postgresql'
-          process_explain_results_postgres(results)
-        when 'mysql2'
-          process_explain_results_mysql2(results)
-        when 'mysql'
-          process_explain_results_mysql(results)
-        when 'sqlite'
-          process_explain_results_sqlite(results)
-        end
-      end
-
-      QUERY_PLAN = 'QUERY PLAN'.freeze
-
-      def process_explain_results_postgres(results)
-        if results.is_a?(String)
-          query_plan_string = results
-        else
-          lines = []
-          results.each { |row| lines << row[QUERY_PLAN] }
-          query_plan_string = lines.join("\n")
-        end
-
-        unless record_sql_method == :raw
-          query_plan_string = NewRelic::Agent::Database::PostgresExplainObfuscator.obfuscate(query_plan_string)
-        end
-        values = query_plan_string.split("\n").map { |line| [line] }
-
-        [[QUERY_PLAN], values]
-      end
-
-      # Sequel returns explain plans as just one big pre-formatted String
-      # In that case, we send a nil headers array, and the single string
-      # wrapped in an array for the values.
-      # Note that we don't use this method for Postgres explain plans, since
-      # they need to be passed through the explain plan obfuscator first.
-      def string_explain_plan_results(results)
-        [nil, [results]]
-      end
-
-      def process_explain_results_mysql(results)
-        return string_explain_plan_results(results) if results.is_a?(String)
-        headers = []
-        values  = []
-        if results.is_a?(Array)
-          # We're probably using the jdbc-mysql gem for JRuby, which will give
-          # us an array of hashes.
-          headers = results.first.keys
-          results.each do |row|
-            values << headers.map { |h| row[h] }
-          end
-        else
-          # We're probably using the native mysql driver gem, which will give us
-          # a Mysql::Result object that responds to each_hash
-          results.each_hash do |row|
-            headers = row.keys
-            values << headers.map { |h| row[h] }
-          end
-        end
-        [headers, values]
-      end
-
-      def process_explain_results_mysql2(results)
-        return string_explain_plan_results(results) if results.is_a?(String)
-        headers = results.fields
-        values  = []
-        results.each { |row| values << row }
-        [headers, values]
-      end
-
-      SQLITE_EXPLAIN_COLUMNS = %w[addr opcode p1 p2 p3 p4 p5 comment]
-
-      def process_explain_results_sqlite(results)
-        return string_explain_plan_results(results) if results.is_a?(String)
-        headers = SQLITE_EXPLAIN_COLUMNS
-        values  = []
-        results.each do |row|
-          values << headers.map { |h| row[h] }
-        end
-        [headers, values]
-      end
-
-      def handle_exception_in_explain
-        yield
-      rescue => e
-        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
+      # node of a transaction sample. Returns an array of two arrays.
+      # The first array contains the headers, while the second consists of
+      # arrays of strings for each column returned by the explain query.
+      # Note this happens only for statements whose execution time 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(statement)
+        return nil unless statement.sql && statement.explainer && statement.config
+        statement.sql = statement.sql.split(";\n")[0] # only explain the first
+        return statement.explain || []
       end
 
       KNOWN_OPERATIONS = [
@@ -273,14 +133,6 @@ module NewRelic
         end
       end
 
-      def is_select?(statement)
-        parse_operation_from_query(statement) == 'select'
-      end
-
-      def parameterized?(statement)
-        Obfuscator.instance.obfuscate_single_quote_literals(statement) =~ /\$\d+/
-      end
-
       class ConnectionManager
         include Singleton
 
@@ -318,33 +170,88 @@ module NewRelic
       end
 
       class Statement
-        attr_accessor :sql, :config, :explainer
+        include ExplainPlanHelpers
+
+        attr_accessor :sql, :config, :explainer, :binds, :name
 
-        def initialize(sql, config={}, explainer=nil)
+        DEFAULT_QUERY_NAME = "SQL".freeze
+
+        def initialize(sql, config={}, explainer=nil, binds=[], name=DEFAULT_QUERY_NAME)
           @sql = Database.capture_query(sql)
           @config = config
           @explainer = explainer
+          @binds = binds
+          @name = name
         end
 
+        # This takes a connection config hash from ActiveRecord or Sequel and
+        # returns a symbol describing the associated database adapter
         def adapter
-          config && config[:adapter] && symbolized_adapter(config[:adapter].to_s.downcase)
+          return unless @config
+
+          @adapter ||= if @config[:adapter]
+            symbolized_adapter(@config[:adapter].to_s.downcase)
+          elsif @config[:uri] && @config[:uri].to_s =~ /^jdbc:([^:]+):/
+            # This case is for Sequel with the jdbc-mysql, jdbc-postgres, or jdbc-sqlite3 gems.
+            symbolized_adapter($1)
+          else
+            nil
+          end
+        end
+
+        def explain
+          return unless explainable?
+          handle_exception_in_explain do
+            start = Time.now
+            plan = @explainer.call(self)
+            ::NewRelic::Agent.record_metric("Supportability/Database/execute_explain_plan", Time.now - start)
+            return process_resultset(plan, adapter) if plan
+          end
         end
 
+        private
+
         POSTGRES_PREFIX = 'postgres'.freeze
-        MYSQL_PREFIX = 'mysql'.freeze
-        SQLITE_PREFIX = 'sqlite'.freeze
+        MYSQL_PREFIX    = 'mysql'.freeze
+        MYSQL2_PREFIX   = 'mysql2'.freeze
+        SQLITE_PREFIX   = 'sqlite'.freeze
 
         def symbolized_adapter(adapter)
           if adapter.start_with? POSTGRES_PREFIX
             :postgres
-          elsif adapter.start_with? MYSQL_PREFIX
+          elsif adapter == MYSQL_PREFIX
             :mysql
+          # For the purpose of fetching explain plans, we need to maintain the distinction
+          # between usage of mysql and mysql2. Obfuscation is the same, though.
+          elsif adapter == MYSQL2_PREFIX
+            :mysql2
           elsif adapter.start_with? SQLITE_PREFIX
             :sqlite
           else
             adapter.to_sym
           end
         end
+
+        def explainable?
+          return false unless @explainer && is_select?(@sql)
+
+          if @sql[-3,3] == '...'
+            NewRelic::Agent.logger.debug('Unable to collect explain plan for truncated query.')
+            return false
+          end
+
+          if parameterized?(@sql) && @binds.empty?
+            NewRelic::Agent.logger.debug('Unable to collect explain plan for parameter-less parameterized query.')
+            return false
+          end
+
+          if !SUPPORTED_ADAPTERS_FOR_EXPLAIN.include?(adapter)
+            NewRelic::Agent.logger.debug("Not collecting explain plan because an unknown connection adapter ('#{adapter}') was used.")
+            return false
+          end
+
+          true
+        end
       end
     end
   end

data/lib/new_relic/agent/database/explain_plan_helpers.rb

@@ -0,0 +1,127 @@
+# 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/database/obfuscator'
+require 'new_relic/agent/database/postgres_explain_obfuscator'
+
+module NewRelic
+  module Agent
+    module Database
+      module ExplainPlanHelpers
+
+        SUPPORTED_ADAPTERS_FOR_EXPLAIN = [:postgres, :mysql2, :mysql, :sqlite]
+
+        def is_select?(sql)
+          NewRelic::Agent::Database.parse_operation_from_query(sql) == 'select'
+        end
+
+        def parameterized?(sql)
+          Obfuscator.instance.obfuscate_single_quote_literals(sql) =~ /\$\d+/
+        end
+
+        def handle_exception_in_explain
+          yield
+        rescue => e
+          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
+
+        def process_resultset(results, adapter)
+          if adapter == :postgres
+            return process_explain_results_postgres(results)
+          elsif defined?(::ActiveRecord::Result) && results.is_a?(::ActiveRecord::Result)
+            # Note if adapter is mysql, will only have headers, not values
+            return [results.columns, results.rows]
+          elsif results.is_a?(String)
+            return string_explain_plan_results(results)
+          end
+
+          case adapter
+          when :mysql2
+            process_explain_results_mysql2(results)
+          when :mysql
+            process_explain_results_mysql(results)
+          when :sqlite
+            process_explain_results_sqlite(results)
+          end
+        end
+
+        QUERY_PLAN = 'QUERY PLAN'.freeze
+
+        def process_explain_results_postgres(results)
+          if defined?(::ActiveRecord::Result) && results.is_a?(::ActiveRecord::Result)
+            query_plan_string = results.rows.join("\n")
+          elsif results.is_a?(String)
+            query_plan_string = results
+          else
+            lines = []
+            results.each { |row| lines << row[QUERY_PLAN] }
+            query_plan_string = lines.join("\n")
+          end
+
+          unless NewRelic::Agent::Database.record_sql_method == :raw
+            query_plan_string = NewRelic::Agent::Database::PostgresExplainObfuscator.obfuscate(query_plan_string)
+          end
+          values = query_plan_string.split("\n").map { |line| [line] }
+
+          [[QUERY_PLAN], values]
+        end
+
+        # Sequel returns explain plans as just one big pre-formatted String
+        # In that case, we send a nil headers array, and the single string
+        # wrapped in an array for the values.
+        # Note that we don't use this method for Postgres explain plans, since
+        # they need to be passed through the explain plan obfuscator first.
+        def string_explain_plan_results(results)
+          [nil, [results]]
+        end
+
+        def process_explain_results_mysql(results)
+          headers = []
+          values  = []
+          if results.is_a?(Array)
+            # We're probably using the jdbc-mysql gem for JRuby, which will give
+            # us an array of hashes.
+            headers = results.first.keys
+            results.each do |row|
+              values << headers.map { |h| row[h] }
+            end
+          else
+            # We're probably using the native mysql driver gem, which will give us
+            # a Mysql::Result object that responds to each_hash
+            results.each_hash do |row|
+              headers = row.keys
+              values << headers.map { |h| row[h] }
+            end
+          end
+          [headers, values]
+        end
+
+        def process_explain_results_mysql2(results)
+          headers = results.fields
+          values  = []
+          results.each { |row| values << row }
+          [headers, values]
+        end
+
+        SQLITE_EXPLAIN_COLUMNS = %w[addr opcode p1 p2 p3 p4 p5 comment]
+
+        def process_explain_results_sqlite(results)
+          headers = SQLITE_EXPLAIN_COLUMNS
+          values  = []
+          results.each do |row|
+            values << headers.map { |h| row[h] }
+          end
+          [headers, values]
+        end
+      end
+    end
+  end
+end