newrelic_rpm 3.16.0.318 → 3.16.1.320

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

@@ -133,30 +133,36 @@ module NewRelic
               name = self.class.name
             end
 
-            metrics = NewRelic::Agent::Datastores::MetricHelper.metrics_for(
-              DATA_MAPPER,
-              metric_operation,
-              name)
-
-            NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-              begin
-                self.send("#{method_name}_without_newrelic", *args, &blk)
-              rescue ::DataObjects::SQLError => e
-                e.uri.gsub!(PASSWORD_REGEX, AMPERSAND) if e.uri.include?(PASSWORD_PARAM)
-
-                strategy = NewRelic::Agent::Database.record_sql_method(:slow_sql)
-                case strategy
-                when :obfuscated
-                  adapter_name = self.respond_to?(:options) ? self.options[:adapter] : self.repository.adapter.uri.scheme
-                  statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
-                  obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
-                  e.instance_variable_set(:@query, obfuscated_sql)
-                when :off
-                  e.instance_variable_set(:@query, nil)
-                end
-
-                raise
+            segment = NewRelic::Agent::Transaction.start_datastore_segment DATA_MAPPER, metric_operation, name
+
+            begin
+              self.send("#{method_name}_without_newrelic", *args, &blk)
+            rescue ::DataObjects::SQLError => e
+              e.uri.gsub!(PASSWORD_REGEX, AMPERSAND) if e.uri.include?(PASSWORD_PARAM)
+
+              strategy = NewRelic::Agent::Database.record_sql_method(:slow_sql)
+              case strategy
+              when :obfuscated
+                adapter_name = if self.respond_to?(:options)
+                    self.options[:adapter]
+                  else
+                    if self.repository.adapter.respond_to?(:options)
+                      self.repository.adapter.options[:adapter]
+                    else
+                      # DataMapper < 0.10.0
+                      self.repository.adapter.uri.scheme
+                    end
+                  end
+                statement = NewRelic::Agent::Database::Statement.new(e.query, :adapter => adapter_name)
+                obfuscated_sql = NewRelic::Agent::Database.obfuscate_sql(statement)
+                e.instance_variable_set(:@query, obfuscated_sql)
+              when :off
+                e.instance_variable_set(:@query, nil)
               end
+
+              raise
+            ensure
+              segment.finish
             end
           end
         end

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

@@ -11,43 +11,51 @@ module NewRelic
         extend self
 
         API_ENDPOINT   = 'api.endpoint'.freeze
+        API_VERSION    = 'api.version'.freeze
         FORMAT_REGEX   = /\(\/?\.[\:\w]*\)/.freeze # either :format (< 0.12.0) or .ext (>= 0.12.0)
         VERSION_REGEX  = /:version(\/|$)/.freeze
         EMPTY_STRING   = ''.freeze
         MIN_VERSION    = VersionNumber.new("0.2.0")
+        PIPE_STRING    = '|'.freeze
 
-        def handle_transaction(endpoint, class_name)
+        def handle_transaction(endpoint, class_name, version)
           return unless endpoint && route = endpoint.route
-          name_transaction(route, class_name)
+          name_transaction(route, class_name, version)
           capture_params(endpoint)
         end
 
-        def name_transaction(route, class_name)
-          txn_name = name_for_transaction(route, class_name)
+        def name_transaction(route, class_name, version)
+          txn_name = name_for_transaction(route, class_name, version)
           node_name = "Middleware/Grape/#{class_name}/call"
           Transaction.set_default_transaction_name(txn_name, :grape, node_name)
         end
 
         if defined?(Grape::VERSION) && VersionNumber.new(::Grape::VERSION) >= VersionNumber.new("0.16.0")
-          def name_for_transaction(route, class_name)
+          def name_for_transaction(route, class_name, version)
             action_name = route.path.sub(FORMAT_REGEX, EMPTY_STRING)
             method_name = route.request_method
+            version ||= route.version
 
-            if route.version
+            # defaulting does not set rack.env['api.version'] and route.version may return Array
+            #
+            version = version.join(PIPE_STRING) if Array === version
+
+            if version
               action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
-              "#{class_name}-#{route.version}#{action_name} (#{method_name})"
+              "#{class_name}-#{version}#{action_name} (#{method_name})"
             else
               "#{class_name}#{action_name} (#{method_name})"
             end
           end
         else
-          def name_for_transaction(route, class_name)
+          def name_for_transaction(route, class_name, version)
             action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
             method_name = route.route_method
+            version ||= route.route_version
 
-            if route.route_version
+            if version
               action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
-              "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
+              "#{class_name}-#{version}#{action_name} (#{method_name})"
             else
               "#{class_name}#{action_name} (#{method_name})"
             end
@@ -108,7 +116,8 @@ DependencyDetection.defer do
         ensure
           begin
             endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
-            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, self.class.name)
+            version = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_VERSION]
+            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, self.class.name, version)
           rescue => e
             ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
           end

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

@@ -40,17 +40,15 @@ module NewRelic
               alias_method method_name_without, method_name
 
               define_method method_name do |*args, &block|
-                metrics = Datastores::MetricHelper.metrics_for("Memcached", method_name)
-
-                NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-                  t0 = Time.now
-                  begin
-                    send method_name_without, *args, &block
-                  ensure
-                    if NewRelic::Agent.config[:capture_memcache_keys]
-                      NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect, (Time.now - t0).to_f) rescue nil
-                    end
+                segment = NewRelic::Agent::Transaction.start_datastore_segment "Memcached", method_name
+                begin
+                  send method_name_without, *args, &block
+                ensure
+                  if NewRelic::Agent.config[:capture_memcache_keys]
+                    NewRelic::Agent.instance.transaction_sampler.notice_nosql(args.first.inspect,
+                                                                              (Time.now - segment.start_time).to_f) rescue nil
                   end
+                  segment.finish
                 end
               end
 

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

@@ -65,23 +65,30 @@ DependencyDetection.defer do
         NewRelic::Agent.logger.debug("Exception during Mongo statement gathering", e)
       end
 
-      def new_relic_generate_metrics(operation, payload = nil)
-        payload ||= { :collection => self.name, :database => self.db.name }
-        NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(operation, payload)
+      def new_relic_default_payload
+        { :collection => self.name, :database => self.db.name }
       end
 
-      def instrument_with_new_relic_trace(name, payload = {}, &block)
-        metrics = new_relic_generate_metrics(name, payload)
+      def new_relic_start_segment name, payload
+        product = NewRelic::Agent::Datastores::Mongo::MetricTranslator::MONGO_PRODUCT_NAME
+        op_and_col = NewRelic::Agent::Datastores::Mongo::MetricTranslator.operation_and_collection_for name, payload
+        if op_and_col
+          NewRelic::Agent::Transaction.start_datastore_segment product, *op_and_col
+        end
+      end
 
-        trace_execution_scoped(metrics) do
-          t0 = Time.now
+      def instrument_with_new_relic_trace(name, payload = {}, &block)
+        segment = new_relic_start_segment name, payload
 
+        begin
           result = NewRelic::Agent.disable_all_tracing do
             instrument_without_new_relic_trace(name, payload, &block)
           end
 
-          new_relic_notice_statement(t0, payload, name)
+          new_relic_notice_statement(segment.start_time, payload, name) if segment
           result
+        ensure
+          segment.finish if segment
         end
       end
 
@@ -93,16 +100,17 @@ DependencyDetection.defer do
   def instrument_save
     ::Mongo::Collection.class_eval do
       def save_with_new_relic_trace(doc, opts = {}, &block)
-        metrics = new_relic_generate_metrics(:save)
-        trace_execution_scoped(metrics) do
-          t0 = Time.now
+        segment = new_relic_start_segment :save, new_relic_default_payload
 
+        begin
           result = NewRelic::Agent.disable_all_tracing do
             save_without_new_relic_trace(doc, opts, &block)
           end
 
-          new_relic_notice_statement(t0, doc, :save)
+          new_relic_notice_statement(segment.start_time, doc, :save) if segment
           result
+        ensure
+          segment.finish if segment
         end
       end
 
@@ -114,10 +122,9 @@ DependencyDetection.defer do
   def instrument_ensure_index
     ::Mongo::Collection.class_eval do
       def ensure_index_with_new_relic_trace(spec, opts = {}, &block)
-        metrics = new_relic_generate_metrics(:ensureIndex)
-        trace_execution_scoped(metrics) do
-          t0 = Time.now
+        segment = new_relic_start_segment :ensureIndex, new_relic_default_payload
 
+        begin
           result = NewRelic::Agent.disable_all_tracing do
             ensure_index_without_new_relic_trace(spec, opts, &block)
           end
@@ -131,8 +138,10 @@ DependencyDetection.defer do
                    spec.dup
                  end
 
-          new_relic_notice_statement(t0, spec, :ensureIndex)
+          new_relic_notice_statement(segment.start_time, spec, :ensureIndex) if segment
           result
+        ensure
+          segment.finish if segment
         end
       end
 

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

@@ -7,13 +7,13 @@ module NewRelic
   module Agent
     module Instrumentation
       class MongodbCommandSubscriber
-
         MONGODB = 'MongoDB'.freeze
         COLLECTION = "collection".freeze
 
         def started(event)
           begin
             return unless NewRelic::Agent.tl_is_execution_traced?
+            segments[event.operation_id] = start_segment event
             operations[event.operation_id] = event
           rescue Exception => e
             log_notification_error('started', e)
@@ -25,14 +25,9 @@ module NewRelic
             state = NewRelic::Agent::TransactionState.tl_get
             return unless state.is_execution_traced?
             started_event = operations.delete(event.operation_id)
-
-            base, *other_metrics = metrics(started_event)
-
-            NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
-              base, other_metrics, event.duration
-            )
-
-            notice_nosql_statement(state, started_event, base, event.duration)
+            segment = segments.delete(event.operation_id)
+            notice_nosql_statement(state, started_event, segment.name, event.duration)
+            segment.finish
           rescue Exception => e
             log_notification_error('completed', e)
           end
@@ -43,6 +38,12 @@ module NewRelic
 
         private
 
+        def start_segment event
+          NewRelic::Agent::Transaction.start_datastore_segment(
+            MONGODB, event.command_name, collection(event)
+          )
+        end
+
         def collection(event)
           event.command[COLLECTION] || event.command[:collection] || event.command.values.first
         end
@@ -60,6 +61,10 @@ module NewRelic
           @operations ||= {}
         end
 
+        def segments
+          @segments ||= {}
+        end
+
         def generate_statement(event)
           NewRelic::Agent::Datastores::Mongo::EventFormatter.format(
             event.command_name,
@@ -69,19 +74,9 @@ module NewRelic
         end
 
         def notice_nosql_statement(state, event, metric, duration)
-          end_time = Time.now.to_f
-
-          stack  = state.traced_method_stack
-
-          # enter transaction trace node
-          frame = stack.push_frame(state, :mongo_db, end_time - duration)
-
           NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(
               generate_statement(event), duration
             )
-
-          # exit transaction trace node
-          stack.pop_frame(state, frame, metric, end_time)
         end
       end
     end

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -74,19 +74,15 @@ module NewRelic
         first_name   = metric_names.shift
         return yield unless first_name
 
-        additional_metrics_callback = options[:additional_metrics_callback]
-        start_time = Time.now.to_f
-        expected_scope = trace_execution_scoped_header(state, start_time)
+        segment = NewRelic::Agent::Transaction.start_segment first_name, metric_names
+        segment.record_metrics = options.fetch(:metric, true)
 
         begin
-          result = yield
-          metric_names += Array(additional_metrics_callback.call) if additional_metrics_callback
-          result
+          yield
         ensure
-          trace_execution_scoped_footer(state, start_time, first_name, metric_names, expected_scope, options)
+          segment.finish
         end
       end
-
     end
   end
 end

data/lib/new_relic/agent/sql_sampler.rb

@@ -140,7 +140,7 @@ module NewRelic
       # @api public
       # @deprecated Use {Datastores.notice_sql} instead.
       #
-      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil, binds=[], name="SQL") #THREAD_LOCAL_ACCESS sometimes
+      def notice_sql(sql, metric_name, config, duration, state=nil, explainer=nil, binds=nil, name=nil) #THREAD_LOCAL_ACCESS sometimes
         state ||= TransactionState.tl_get
         data = state.sql_sampler_transaction_data
         return unless data
@@ -154,6 +154,19 @@ module NewRelic
         end
       end
 
+      def notice_sql_statement(statement, metric_name, duration)
+        state ||= TransactionState.tl_get
+        data = state.sql_sampler_transaction_data
+        return unless data
+
+        if state.is_sql_recorded?
+          if duration > Agent.config[:'slow_sql.explain_threshold']
+            backtrace = caller.join("\n")
+            data.sql_data << SlowSql.new(statement, metric_name, duration, backtrace)
+          end
+        end
+      end
+
       def merge!(sql_traces)
         @samples_lock.synchronize do
           sql_traces.each do |trace|

data/lib/new_relic/agent/stats_engine/metric_stats.rb

@@ -66,6 +66,15 @@ module NewRelic
           end
         end
 
+        # This aliasing was introduced for T2 so that MetricsStats and
+        # TransactionStates have the same interface for recording
+        # unscoped metrics. The tl_ version should be used outside of the
+        # segment api.
+        #
+        # @api private
+        #
+        alias_method :record_unscoped, :tl_record_unscoped_metrics
+
         # Like tl_record_unscoped_metrics, but records a scoped metric as well.
         #
         # This is an internal method, subject to change at any time. Client apps
@@ -108,6 +117,15 @@ module NewRelic
           end
         end
 
+        # This aliasing was introduced for T2 so that MetricsStats and
+        # TransactionStates have the same interface for recording
+        # scoped metrics. The tl_ version should be used outside of the
+        # segment api.
+        #
+        # @api private
+        #
+        alias_method :record_scoped_and_unscoped, :tl_record_scoped_and_unscoped_metrics
+
         # This method is deprecated and not thread safe, and should not be used
         # by any new client code.
         #

data/lib/new_relic/agent/supported_versions.rb

@@ -11,7 +11,7 @@ module NewRelic
       {
         :type        => :ruby,
         :name        => "MRI",
-        :supported   => ["1.8.7", "1.9.2", "1.9.3", "2.0.0", "~> 2.1.0", "~> 2.2.0" ],
+        :supported   => ["1.8.7", "1.9.2", "1.9.3", "2.0.0", "~> 2.1.0", "~> 2.2.0", "~> 2.3.0"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",
         :notes       => [
@@ -85,8 +85,7 @@ module NewRelic
       :rails =>
       {
         :type        => :web,
-        :supported   => ["~>2.1.0", "~>2.2.0", "~>2.3.0", "~3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0"],
-        :experimental=> ["5.0.0.rc1"],
+        :supported   => ["~>2.1.0", "~>2.2.0", "~>2.3.0", "~3.0.0", "~>3.1.0", "~>3.2.0", "~>4.0.0", "~>4.1.0", "~>4.2.0", "~> 5.0.0"],
         :deprecated  => ["~>2.0.0"],
         :url         => "https://rubygems.org/gems/rails",
         :feed        => "https://rubygems.org/gems/rails/versions.atom",

data/lib/new_relic/agent/traced_method_stack.rb

@@ -37,6 +37,12 @@ module NewRelic
         frame
       end
 
+      def push_segment state, segment
+        transaction_sampler.notice_push_frame(state, segment.start_time) if sampler_enabled?
+        @stack.push segment
+        segment
+      end
+
       # Pops a frame off the transaction stack - this updates the transaction
       # sampler that we've finished execution of a traced method.
       #
@@ -50,7 +56,7 @@ module NewRelic
         note_children_time(frame, time, deduct_call_time_from_parent)
 
         transaction_sampler.notice_pop_frame(state, name, time) if sampler_enabled?
-        frame.name = name
+        frame.name = name if frame.is_a? TracedMethodFrame
         frame
       end
 

data/lib/new_relic/agent/transaction.rb

@@ -8,6 +8,7 @@ require 'new_relic/agent/transaction_metrics'
 require 'new_relic/agent/method_tracer_helpers'
 require 'new_relic/agent/transaction/attributes'
 require 'new_relic/agent/transaction/request_attributes'
+require 'new_relic/agent/transaction/tracing'
 
 module NewRelic
   module Agent
@@ -16,6 +17,7 @@ module NewRelic
     #
     # @api public
     class Transaction
+      include Tracing
 
       # for nested transactions
       SUBTRANSACTION_PREFIX        = 'Nested/'.freeze
@@ -41,6 +43,9 @@ module NewRelic
       TRACE_OPTIONS_SCOPED         = { :metric => true, :scoped_metric => true }.freeze
       TRACE_OPTIONS_UNSCOPED       = { :metric => true, :scoped_metric => false }.freeze
 
+      # reference to the transaction state managing this transaction
+      attr_accessor :state
+
       # A Time instance for the start time, never nil
       attr_accessor :start_time
 
@@ -128,6 +133,7 @@ module NewRelic
       def self.start_new_transaction(state, category, options)
         txn = Transaction.new(category, options)
         state.reset(txn)
+        txn.state = state
         txn.start(state)
         txn
       end