newrelic_rpm 3.16.0.318 → 3.16.1.320

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65e448cfa30a9ec08c2cafdeef4b85d91a4ab36b
-  data.tar.gz: 6ce77fbb0850fdd68d403672df4544c81c1c1937
+  metadata.gz: ec626b83799ad14fe3e3534083621d692bfbd138
+  data.tar.gz: 0593104dbbfb3f5faa967043e7025e42991ce168
 SHA512:
-  metadata.gz: e5b765cb31305ef2f4e1faffe2f715a8a89c39320d21baa7d375f8c4c88d7fabd8d104b8933727ca4750fd51080d92d9c0ee361486fe40ba5e3900602137efc4
-  data.tar.gz: 6722c3012daab68738f96f5237bdbb72a18f972ba799b5e8046179d9a42f9dfbfed8e67c8382cf22e4a923748cc547de15134bef2f1c93984ad7c2569fef081c
+  metadata.gz: 3caec728f33c30b9149c5c01e27d9c573562268f19cc69a06416af69634e622c25e11cb2a9267082615b063b8f3963cb62de03ab97b9d6ddfb6aa721b18d7d66
+  data.tar.gz: 688803e2468ece921d1c4b18dd3f81bb3d7c5ddc41d6ecf0ebb24fef10db0fcfe8ca85d8f329f71a8126769e7bd6c036a9fe2234bee373eed29852dfbf71245f

data/.travis.yml

@@ -45,7 +45,8 @@ rvm:
   # Run slowest builds first to try and optimize overall cycle time.
   - jruby-1.7.23
   - jruby-9.0.4.0
-  - 2.2.4
+  - 2.3.1
+  - 2.2.5
   - 2.1.8
   - 2.0.0-p648
   - 1.9.3
@@ -97,12 +98,20 @@ matrix:
       env: TYPE=FUNCTIONAL GROUP=agent
 
     # Unsupported Rails/Ruby combinations
+    # 2.3
+    - rvm: 2.3.1
+      env: TYPE=UNIT ENVIRONMENT=rails21
+    - rvm: 2.3.1
+      env: TYPE=UNIT ENVIRONMENT=rails22
+    - rvm: 2.3.1
+      env: TYPE=UNIT ENVIRONMENT=rails23
+
     # 2.2
-    - rvm: 2.2.4
+    - rvm: 2.2.5
       env: TYPE=UNIT ENVIRONMENT=rails21
-    - rvm: 2.2.4
+    - rvm: 2.2.5
       env: TYPE=UNIT ENVIRONMENT=rails22
-    - rvm: 2.2.4
+    - rvm: 2.2.5
       env: TYPE=UNIT ENVIRONMENT=rails23
 
     # 2.1

data/CHANGELOG

@@ -1,11 +1,50 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.16.1
+
+  * Internal datastore instrumentation rewrites
+
+  The agent's internal tracing of datastore segments has been rewritten, and
+  instrumentation updated to utilize the new classes.
+
+  * Fix Grape endpoint versions in transaction names
+
+  Grape 0.16 changed Route#version (formerly #route_version) to possibly return
+  an Array of versions for the current endpoint. The agent has been updated to
+  use rack.env['api.version'] set by Grape, and fall back to joining the version
+  Array with '|' before inclusion in the transaction name when api.version is
+  not available. Thanks Geoff Massanek for the contribution!
+
+  * Fix deprecation warnings from various Rails error subclasses
+
+  Rails 5 deprecates #original_exception on a few internal subclasses of
+  StandardError in favor of Exception#cause from Ruby stdlib. The agent has
+  been updated to try Exception#cause first, thus avoiding deprecation
+  warnings. Thanks Alexander Stuart-Kregor for the contribution!
+
+  * Fix instrumentation for Sequel 4.35.0
+
+  The latest version of Sequel changes the name and signature of the method
+  that the Ruby Agent wraps for instrumentation. The agent has been updated
+  to handle these changes. Users using Sequel 4.35.0 or newer should upgrade
+  their agent.
+
+  * Fix DataMapper instrumentation for additional versions
+
+  Different versions of DataMapper have different methods for retrieving the
+  adapter name, and Postmodern expanded our coverage. Thanks for the
+  contribution!
+
 ## v3.16.0
 
-  * Experimental Action Cable instrumentation
+  * Official Rails 5.0 support
+
+  This version of the agent has been verified against the Rails 5.0.0 release.
+
+  * Early access Action Cable instrumentation
 
   The Ruby agent instruments Action Cable channel actions and calls to
-  ActionCable::Channel#Transmit in Rails 5 RC1. Feedback is welcome!
+  ActionCable::Channel#Transmit in Rails 5. Feedback is welcome!
 
   * Obfuscate queries from `oracle_enhanced` adapter correctly
 

data/lib/new_relic/agent/database.rb

@@ -27,8 +27,17 @@ module NewRelic
 
       extend self
 
+      # Properly encode, truncate, and dup the incoming query.
+      # Take care not to the dup the query more than once as
+      # correctly encoded may also dup the query.
       def capture_query(query)
-        Helper.correctly_encoded(truncate_query(query))
+        id = query.object_id
+        query = Helper.correctly_encoded(truncate_query(query))
+        if query.object_id == id
+          query.dup
+        else
+          query
+        end
       end
 
       def truncate_query(query)
@@ -176,7 +185,7 @@ module NewRelic
 
         DEFAULT_QUERY_NAME = "SQL".freeze
 
-        def initialize(sql, config={}, explainer=nil, binds=[], name=DEFAULT_QUERY_NAME)
+        def initialize(sql, config={}, explainer=nil, binds=nil, name=DEFAULT_QUERY_NAME)
           @sql = Database.capture_query(sql)
           @config = config
           @explainer = explainer
@@ -232,15 +241,17 @@ module NewRelic
           end
         end
 
+        ELLIPSIS = "...".freeze
+
         def explainable?
           return false unless @explainer && is_select?(@sql)
 
-          if @sql[-3,3] == '...'
+          if @sql.end_with?(ELLIPSIS)
             NewRelic::Agent.logger.debug('Unable to collect explain plan for truncated query.')
             return false
           end
 
-          if parameterized?(@sql) && @binds.empty?
+          if parameterized?(@sql) && (!@binds || @binds.empty?)
             NewRelic::Agent.logger.debug('Unable to collect explain plan for parameter-less parameterized query.')
             return false
           end

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

@@ -11,9 +11,10 @@ module NewRelic
       module ExplainPlanHelpers
 
         SUPPORTED_ADAPTERS_FOR_EXPLAIN = [:postgres, :mysql2, :mysql, :sqlite]
+        SELECT = 'select'.freeze
 
         def is_select?(sql)
-          NewRelic::Agent::Database.parse_operation_from_query(sql) == 'select'
+          NewRelic::Agent::Database.parse_operation_from_query(sql) == SELECT
         end
 
         def parameterized?(sql)

data/lib/new_relic/agent/datastores.rb

@@ -45,9 +45,11 @@ module NewRelic
             alias_method method_name_without_newrelic, method_name
 
             define_method(method_name) do |*args, &blk|
-              metrics = MetricHelper.metrics_for(product, operation)
-              NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
+              segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation)
+              begin
                 send(method_name_without_newrelic, *args, &blk)
+              ensure
+                segment.finish
               end
             end
 
@@ -103,18 +105,16 @@ module NewRelic
       def self.wrap(product, operation, collection = nil, callback = nil)
         return yield unless operation
 
-        metrics = MetricHelper.metrics_for(product, operation, collection)
-        scoped_metric = metrics.first
-        NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-          t0 = Time.now if callback
-          begin
-            result = yield
-          ensure
-            if callback
-              elapsed_time = (Time.now - t0).to_f
-              callback.call(result, scoped_metric, elapsed_time)
-            end
+        segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation, collection)
+
+        begin
+          result = yield
+        ensure
+          if callback
+            elapsed_time = (Time.now - segment.start_time).to_f
+            callback.call(result, segment.name, elapsed_time)
           end
+          segment.finish
         end
       end
 

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

@@ -44,14 +44,41 @@ module NewRelic
           end
         end
 
-        def self.metrics_for(product, operation, collection = nil, generic_product = nil)
+        def self.scoped_metric_for product, operation, collection=nil
+          if collection
+            statement_metric_for product, collection, operation
+          else
+            operation_metric_for product, operation
+          end
+        end
+
+        def self.unscoped_metrics_for product, operation, collection=nil
+          suffix = all_suffix
+
+          metrics = [
+            product_suffixed_rollup(product, suffix),
+            product_rollup(product),
+            suffixed_rollup(suffix),
+            ROLLUP_METRIC
+          ]
+
+          metrics.unshift operation_metric_for(product, operation) if collection
+
+          metrics
+        end
+
+        def self.product_operation_collection_for product, operation, collection=nil, generic_product = nil
           if overrides = overridden_operation_and_collection
             if should_override?(overrides, product, generic_product)
               operation  = overrides[0] || operation
               collection = overrides[1] || collection
             end
           end
+          [product, operation, collection]
+        end
 
+        def self.metrics_for(product, operation, collection = nil, generic_product = nil)
+          product, operation, collection = product_operation_collection_for(product, operation, collection, generic_product)
           suffix = all_suffix
 
           # Order of these metrics matters--the first metric in the list will
@@ -70,10 +97,14 @@ module NewRelic
         end
 
         def self.metrics_from_sql(product, sql)
-          operation = NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
+          operation = operation_from_sql(sql)
           metrics_for(product, operation)
         end
 
+        def self.operation_from_sql(sql)
+          NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
+        end
+
         # Allow Transaction#with_database_metric_name to override our
         # collection and operation
         def self.overridden_operation_and_collection #THREAD_LOCAL_ACCESS

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

@@ -10,7 +10,7 @@ module NewRelic
     module Datastores
       module Mongo
         module MetricTranslator
-          def self.metrics_for(name, payload)
+          def self.operation_and_collection_for(name, payload)
             payload ||= {}
 
             if collection_in_selector?(payload)
@@ -51,20 +51,14 @@ module NewRelic
               collection = collection_name_from_rename_selector(payload)
             end
 
-            build_metrics(name, collection)
+            [name.to_s, collection]
           rescue => e
             NewRelic::Agent.logger.debug("Failure during Mongo metric generation", e)
-            []
+            nil
           end
 
           MONGO_PRODUCT_NAME = "MongoDB".freeze
 
-          def self.build_metrics(name, collection)
-            NewRelic::Agent::Datastores::MetricHelper.metrics_for(MONGO_PRODUCT_NAME,
-                                                                  name,
-                                                                  collection)
-          end
-
           def self.collection_in_selector?(payload)
             payload[:collection] == '$cmd' && payload[:selector]
           end

data/lib/new_relic/agent/error_collector.rb

@@ -185,8 +185,8 @@ module NewRelic
 
       # extracts a stack trace from the exception for debugging purposes
       def extract_stack_trace(exception)
-        actual_exception = sense_method(exception, 'original_exception') || exception
-        sense_method(actual_exception, 'backtrace') || '<no stack trace>'
+        actual_exception = sense_method(exception, :cause) || sense_method(exception, :original_exception) || exception
+        sense_method(actual_exception, :backtrace) || '<no stack trace>'
       end
 
       # See NewRelic::Agent.notice_error for options and commentary

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

@@ -44,29 +44,19 @@ module NewRelic
           end
 
           sql, name, _ = args
-          metrics = ActiveRecordHelper.metrics_for(
+
+          product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
             NewRelic::Helper.correctly_encoded(name),
             NewRelic::Helper.correctly_encoded(sql),
             @config && @config[:adapter])
 
-          # It is critical that we grab this name before trace_execution_scoped
-          # because that method mutates the metrics list passed in.
-          scoped_metric = metrics.first
-
-          NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-            t0 = Time.now
-            begin
-              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,
-                                                    state, EXPLAINER)
-              NewRelic::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
-                                                    @config, elapsed_time,
-                                                    state, EXPLAINER)
-            end
+          segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation, collection)
+          segment._notice_sql(sql, @config, EXPLAINER)
+
+          begin
+            log_without_newrelic_instrumentation(*args, &block)
+          ensure
+            segment.finish
           end
         end
       end

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

@@ -86,16 +86,12 @@ module NewRelic
         ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
         OTHER         = "other".freeze unless defined?(OTHER)
 
-        def metrics_for(name, sql, adapter_name)
+        def product_operation_collection_for name, sql, adapter_name
           product   = map_product(adapter_name)
           splits    = split_name(name)
           model     = model_from_splits(splits)
           operation = operation_from_splits(splits, sql)
-
-          NewRelic::Agent::Datastores::MetricHelper.metrics_for(product,
-                                                                operation,
-                                                                model,
-                                                                ACTIVE_RECORD)
+          NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for product, operation, model, ACTIVE_RECORD
         end
 
         # @deprecated

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

@@ -23,7 +23,9 @@ module NewRelic
         def start(name, id, payload) #THREAD_LOCAL_ACCESS
           return if payload[:name] == CACHED_QUERY_NAME
           return unless NewRelic::Agent.tl_is_execution_traced?
-          super
+          config = active_record_config(payload)
+          event = ActiveRecordEvent.new(name, Time.now, nil, id, payload, @explainer, config)
+          push_event(event)
         rescue => e
           log_notification_error(e, name, 'start')
         end
@@ -32,10 +34,8 @@ module NewRelic
           return if payload[:name] == CACHED_QUERY_NAME
           state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
-          event  = pop_event(id)
-          config = active_record_config_for_event(event)
-          base_metric = record_metrics(event, config)
-          notice_sql(state, event, config, base_metric)
+          event = pop_event(id)
+          event.finish
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -52,43 +52,11 @@ module NewRelic
           end
         end
 
-        def notice_sql(state, event, config, metric)
-          stack  = state.traced_method_stack
-
-          # enter transaction trace node
-          frame = stack.push_frame(state, :active_record, event.time)
-
-          NewRelic::Agent.instance.transaction_sampler \
-            .notice_sql(event.payload[:sql], config,
-                        Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer, event.payload[:binds], event.payload[:name])
-
-          NewRelic::Agent.instance.sql_sampler \
-            .notice_sql(event.payload[:sql], metric, config,
-                        Helper.milliseconds_to_seconds(event.duration),
-                        state, @explainer, event.payload[:binds], event.payload[:name])
-
-          # exit transaction trace node
-          stack.pop_frame(state, frame, metric, event.end)
-        end
-
-        def record_metrics(event, config) #THREAD_LOCAL_ACCESS
-          base, *other_metrics = ActiveRecordHelper.metrics_for(event.payload[:name],
-                                                               NewRelic::Helper.correctly_encoded(event.payload[:sql]),
-                                                               config && config[:adapter])
-
-          NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
-            base, other_metrics,
-            Helper.milliseconds_to_seconds(event.duration))
-
-          base
-        end
-
-        def active_record_config_for_event(event)
-          return unless event.payload[:connection_id]
+        def active_record_config(payload)
+          return unless payload[:connection_id]
 
           connection = nil
-          connection_id = event.payload[:connection_id]
+          connection_id = payload[:connection_id]
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
             connection = handler.connections.detect do |conn|
@@ -100,6 +68,47 @@ module NewRelic
 
           connection.instance_variable_get(:@config) if connection
         end
+
+        class ActiveRecordEvent < Event
+          def initialize(name, start, ending, transaction_id, payload, explainer, config)
+            super(name, start, ending, transaction_id, payload)
+            @explainer = explainer
+            @config = config
+            @segment = start_segment
+          end
+
+          # Events do not always finish in the order they are started for this subscriber.
+          # The traced_method_stack expects that frames are popped off in the order that they
+          # are pushed, otherwise it will continue to pop up the stack until it finds the frame
+          # it expects. This will be fixed when we replace the tracer internals, but for now
+          # we need to work around this limitation.
+          def start_segment
+            product, operation, collection = ActiveRecordHelper.product_operation_collection_for(payload[:name],
+                                              sql, @config && @config[:adapter])
+            segment = NewRelic::Agent::Transaction::DatastoreSegment.new product, operation, collection
+            if txn = state.current_transaction
+              segment.transaction = txn
+            end
+            segment._notice_sql sql, @config, @explainer, payload[:binds], payload[:name]
+            segment.start
+            segment
+          end
+
+          # See comment for start_segment as we continue to work around limitations of the
+          # current tracer in this method.
+          def finish
+            state.traced_method_stack.push_segment state, @segment
+            @segment.finish
+          end
+
+          def state
+            @state ||= NewRelic::Agent::TransactionState.tl_get
+          end
+
+          def sql
+            @sql ||= Helper.correctly_encoded payload[:sql]
+          end
+        end
       end
     end
   end