newrelic_rpm 3.13.0.299 → 3.13.1.300

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a66f2339d582713549cd887c6c249a1e167060a
-  data.tar.gz: 340be0c604f5a041c013c02118bc1f83bfae2fd1
+  metadata.gz: 0b291cf3e5902d8fa8dbf9c03754ba1358d6a4ba
+  data.tar.gz: 12fd3b54abcbe8f42dfa4a15f3f5415633e0cfa5
 SHA512:
-  metadata.gz: f09c1d8499f23aa1659c2a7622f7655b94644493cca9401f9ba663c69c8ff6394c06ef9238b7bb0fc8a62f10be9dd099d27a45e80403810d801ab55ade84d5f0
-  data.tar.gz: 6c325a570205de1ce13fe012203255fbd413684f9f387149f3a967d959064965f1284e4c50820f5499d37f29ab8cae39018f3ff60aab0580256283569923f037
+  metadata.gz: a23de732cf89b9ca75ba7ada9a154eff9416aed114550c89c8422d5f1189fd0c5fd8f0851da9cebe2f120daa3d3354e13bc8afc1a47b5088c275b4bfd1b56c2e
+  data.tar.gz: 034cd20ec28754fd2df81ac73a84458dd1bb96a08c9a2b8253583dc9ff6e910e6cd89db1efe41dbe6d1f0f4148be550d8691183096c5896e4433b709d96d4544

data/.travis.yml

@@ -9,4 +9,9 @@ rvm:
   - 2.2
   - jruby-19mode
   - jruby-18mode
+  - rbx-2.5.8
 
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+      

data/CHANGELOG

@@ -1,10 +1,45 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.13.1 ##
+
+  * Don't use a pager when running `git log` command
+
+  This would cause Capistrano deploys to hang when a large number of commits were being deployed.
+  Thanks to John Naegle for reporting and fixing this issue!
+
+  * Official support for JRuby 9.0.0.0
+
+  The Ruby agent is now officially fully tested and supported on JRuby 9.0.0.0.
+
+  * Instrumentation for MongoDB 2.1.x
+
+  Visibility in your MongoDB queries returns when using version 2.1.0 of
+  the Mongo driver or newer.  Thanks to Durran Jordan of MongoDB for contributing
+  the Mongo Monitoring instrumentation!
+
+  * Fix for ArgumentError "invalid byte sequence in UTF-8"
+
+  This would come up when trying to parse out the operation from a database query
+  containing characters that would trigger a invalid byte sequence in UTF-8 error.
+  Thanks to Mario Izquierdo for reporting this issue!
+
+  * Improved database metric names for ActiveRecord::Calculations queries
+
+  Aggregate metrics recorded for queries made via the ActiveRecord::Calculations
+  module (#count, #sum, #max, etc.) will now be associated with the correct
+  model name, rather than being counted as generic 'select' operations.
+
+  * Allow at_exit handlers to be installed for Rubinius
+
+  Rubinius can support the at_exit block used by install_exit_handler.
+  Thanks to Aidan Coyle for reporting and fixing this issue!
+
 ## v3.13.0 ##
 
   * Bugfix for uninitialized constant NewRelic::Agent::ParameterFiltering
 
-  Users in some environments encountered a NameError: uninitialized constant NewRelic::Agent::ParameterFiltering from the Rails instrumentation while
+  Users in some environments encountered a NameError: uninitialized constant
+  NewRelic::Agent::ParameterFiltering from the Rails instrumentation while
   running v3.12.x of the Ruby agent. This issue has been fixed.
 
   * Rake task instrumentation

data/lib/new_relic/agent/agent.rb

@@ -370,7 +370,6 @@ module NewRelic
           def should_install_exit_handler?
             (
               Agent.config[:send_data_on_exit]                  &&
-              !NewRelic::LanguageSupport.using_engine?('rbx')   &&
               !NewRelic::LanguageSupport.using_engine?('jruby') &&
               !sinatra_classic_app?
             )

data/lib/new_relic/agent/database.rb

@@ -266,7 +266,7 @@ module NewRelic
       EMPTY_STRING      = ''.freeze
 
       def parse_operation_from_query(sql)
-        sql = sql.gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
+        sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, EMPTY_STRING)
         if sql =~ /(\w+)/
           op = $1.downcase
           return op if KNOWN_OPERATIONS.include?(op)

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

@@ -8,15 +8,16 @@ module NewRelic
       module Mongo
         def self.is_supported_version?
           # No version constant in < 2.0 versions of Mongo :(
-          defined?(::Mongo) &&
-            defined?(::Mongo::MongoClient) &&
-            !is_version2?
+          defined?(::Mongo) && (defined?(::Mongo::MongoClient) || is_monitoring_enabled?)
         end
 
-        # At present we explicitly don't support version 2.x of the driver yet
-        def self.is_version2?
-          defined?(::Mongo::VERSION) &&
-            NewRelic::VersionNumber.new(::Mongo::VERSION) > NewRelic::VersionNumber.new("2.0.0")
+        def self.is_monitoring_enabled?
+          defined?(::Mongo::Monitoring)
+        end
+
+        def self.is_unsupported_2x?
+          defined?(::Mongo::VERSION) && VersionNumber.new(::Mongo::VERSION).major_version == 2 &&
+            !self.is_monitoring_enabled?
         end
 
         def self.is_version_1_10_or_later?

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

@@ -0,0 +1,49 @@
+# 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/obfuscator'
+
+module NewRelic
+  module Agent
+    module Datastores
+      module Mongo
+        module EventFormatter
+
+          # Keys that will get their values replaced with '?'.
+          OBFUSCATE_KEYS = [ 'filter', 'query' ].freeze
+
+          # Keys that will get completely removed from the statement.
+          BLACKLISTED_KEYS = [ 'deletes', 'documents', 'updates' ].freeze
+
+          def self.format(command_name, database_name, command)
+            return nil unless NewRelic::Agent.config[:'mongo.capture_queries']
+
+            result = {
+              :operation => command_name,
+              :database => database_name,
+              :collection => command.values.first
+            }
+
+            command.each do |key, value|
+              next if BLACKLISTED_KEYS.include?(key)
+              if OBFUSCATE_KEYS.include?(key)
+                obfuscated = obfuscate(value)
+                result[key] = obfuscated if obfuscated
+              else
+                result[key] = value
+              end
+            end
+            result
+          end
+
+          def self.obfuscate(statement)
+            if NewRelic::Agent.config[:'mongo.obfuscate_queries']
+              statement = Obfuscator.obfuscate_statement(statement)
+            end
+            statement
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module NewRelic
 
           WHITELIST = [:operation].freeze
 
-          def self.obfuscate_statement(source, whitelist=WHITELIST)
+          def self.obfuscate_statement(source, whitelist = WHITELIST)
             obfuscated = {}
             source.each do |key, value|
               if whitelist.include?(key)
@@ -23,7 +23,7 @@ module NewRelic
             obfuscated
           end
 
-          def self.obfuscate_value(value, whitelist)
+          def self.obfuscate_value(value, whitelist = WHITELIST)
             if value.is_a?(Hash)
               obfuscate_statement(value, whitelist)
             elsif value.is_a?(Array)

data/lib/new_relic/agent/error_collector.rb

@@ -1,6 +1,7 @@
 # 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/error_trace_aggregator'
 
 module NewRelic
   module Agent
@@ -15,17 +16,15 @@ module NewRelic
       MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
       EXCEPTION_TAG_IVAR = :'@__nr_seen_exception' unless defined? EXCEPTION_TAG_IVAR
 
-      attr_accessor :errors
-
       # Returns a new error collector
       def initialize
-        @errors = []
+        @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
+
 
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
 
         initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
-        @lock = Mutex.new
 
         Agent.config.register_callback(:'error_collector.enabled') do |config_enabled|
           ::NewRelic::Agent.logger.debug "Errors will #{config_enabled ? '' : 'not '}be sent to the New Relic service."
@@ -35,6 +34,10 @@ module NewRelic
         end
       end
 
+      def errors
+        @error_trace_aggregator.errors
+      end
+
       def initialize_ignored_errors(ignore_errors)
         @ignore.clear
         ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
@@ -189,25 +192,6 @@ module NewRelic
         sense_method(actual_exception, 'backtrace') || '<no stack trace>'
       end
 
-      # checks the size of the error queue to make sure we are under
-      # the maximum limit, and logs a warning if we are over the limit.
-      def over_queue_limit?(message)
-        over_limit = (@errors.reject{|err| err.is_internal}.length >= MAX_ERROR_QUEUE_LENGTH)
-        ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
-        over_limit
-      end
-
-      # Synchronizes adding an error to the error queue, and checks if
-      # the error queue is too long - if so, we drop the error on the
-      # floor after logging a warning.
-      def add_to_error_queue(noticed_error)
-        @lock.synchronize do
-          if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
-            @errors << noticed_error
-          end
-        end
-      end
-
       # See NewRelic::Agent.notice_error for options and commentary
       def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
         return if skip_notice_error?(exception)
@@ -216,7 +200,7 @@ module NewRelic
 
         state = ::NewRelic::Agent::TransactionState.tl_get
         increment_error_count!(state, exception, options)
-        add_to_error_queue(create_noticed_error(exception, options))
+        @error_trace_aggregator.add_to_error_queue(create_noticed_error(exception, options))
 
         exception
       rescue => e
@@ -272,44 +256,21 @@ module NewRelic
       # class per harvest, disregarding (and not impacting) the app error queue
       # limit.
       def notice_agent_error(exception)
-        return unless exception.class < NewRelic::Agent::InternalAgentError
-
-        # Log 'em all!
-        NewRelic::Agent.logger.info(exception)
-
-        @lock.synchronize do
-          # Already seen this class once? Bail!
-          return if @errors.any? { |err| err.exception_class_name == exception.class.name }
-
-          trace = exception.backtrace || caller.dup
-          noticed_error = NewRelic::NoticedError.new("NewRelic/AgentError", exception)
-          noticed_error.stack_trace = trace
-          @errors << noticed_error
-        end
-      rescue => e
-        NewRelic::Agent.logger.info("Unable to capture internal agent error due to an exception:", e)
+        @error_trace_aggregator.notice_agent_error(exception)
       end
 
       def merge!(errors)
-        errors.each do |error|
-          add_to_error_queue(error)
-        end
+        @error_trace_aggregator.merge!(errors)
       end
 
       # Get the errors currently queued up.  Unsent errors are left
       # over from a previous unsuccessful attempt to send them to the server.
       def harvest!
-        @lock.synchronize do
-          errors = @errors
-          @errors = []
-          errors
-        end
+        @error_trace_aggregator.harvest!
       end
 
       def reset!
-        @lock.synchronize do
-          @errors = []
-        end
+        @error_trace_aggregator.reset!
       end
     end
   end

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -0,0 +1,89 @@
+# -*- 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.
+
+module NewRelic
+  module Agent
+    class ErrorTraceAggregator
+      def initialize(capacity)
+        @capacity = capacity
+        @lock = Mutex.new
+        @errors = []
+      end
+
+      def merge!(errors)
+        errors.each do |error|
+          add_to_error_queue(error)
+        end
+      end
+
+      # Get the errors currently queued up.  Unsent errors are left
+      # over from a previous unsuccessful attempt to send them to the server.
+      def harvest!
+        @lock.synchronize do
+          errors = @errors
+          @errors = []
+          errors
+        end
+      end
+
+      def reset!
+        @lock.synchronize do
+          @errors = []
+        end
+      end
+
+      # Synchronizes adding an error to the error queue, and checks if
+      # the error queue is too long - if so, we drop the error on the
+      # floor after logging a warning.
+      def add_to_error_queue(noticed_error)
+        @lock.synchronize do
+          if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
+            @errors << noticed_error
+          end
+        end
+      end
+
+      # checks the size of the error queue to make sure we are under
+      # the maximum limit, and logs a warning if we are over the limit.
+      def over_queue_limit?(message)
+        over_limit = (@errors.reject{|err| err.is_internal}.length >= @capacity)
+        ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{@capacity}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
+        over_limit
+      end
+
+      def errors
+        @lock.synchronize{ @errors }
+      end
+
+      # *Use sparingly for difficult to track bugs.*
+      #
+      # Track internal agent errors for communication back to New Relic.
+      # To use, make a specific subclass of NewRelic::Agent::InternalAgentError,
+      # then pass an instance of it to this method when your problem occurs.
+      #
+      # Limits are treated differently for these errors. We only gather one per
+      # class per harvest, disregarding (and not impacting) the app error queue
+      # limit.
+      def notice_agent_error(exception)
+        return unless exception.class < NewRelic::Agent::InternalAgentError
+
+        # Log 'em all!
+        NewRelic::Agent.logger.info(exception)
+
+        @lock.synchronize do
+          # Already seen this class once? Bail!
+          return if @errors.any? { |err| err.exception_class_name == exception.class.name }
+
+          trace = exception.backtrace || caller.dup
+          noticed_error = NewRelic::NoticedError.new("NewRelic/AgentError", exception)
+          noticed_error.stack_trace = trace
+          @errors << noticed_error
+        end
+      rescue => e
+        NewRelic::Agent.logger.info("Unable to capture internal agent error due to an exception:", e)
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module NewRelic
 
         def self.insert_instrumentation
           if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
-            ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_writer_methods
+            ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
           end
 
           ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do

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

@@ -24,6 +24,6 @@ DependencyDetection.defer do
   executes do
     ActiveSupport::Notifications.subscribe('sql.active_record',
       NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
-    ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_writer_methods
+    ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
   end
 end

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

@@ -12,7 +12,12 @@ module NewRelic
         module_function
 
         # Used by both the AR 3.x and 4.x instrumentation
-        def instrument_writer_methods
+        def instrument_additional_methods
+          instrument_save_methods
+          instrument_relation_methods
+        end
+
+        def instrument_save_methods
           ::ActiveRecord::Base.class_eval do
             alias_method :save_without_newrelic, :save
 
@@ -30,7 +35,9 @@ module NewRelic
               end
             end
           end
+        end
 
+        def instrument_relation_methods
           ::ActiveRecord::Relation.class_eval do
             alias_method :update_all_without_newrelic, :update_all
 
@@ -55,6 +62,24 @@ module NewRelic
                 destroy_all_without_newrelic(*args, &blk)
               end
             end
+
+            alias_method :calculate_without_newrelic, :calculate
+
+            def calculate(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                calculate_without_newrelic(*args, &blk)
+              end
+            end
+
+            if method_defined?(:pluck)
+              alias_method :pluck_without_newrelic, :pluck
+
+              def pluck(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  pluck_without_newrelic(*args, &blk)
+                end
+              end
+            end
           end
         end