newrelic_rpm 4.0.0.332 → 6.13.1

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # NOTE there are multiple implementations of the MemCache client in Ruby,
 # each with slightly different API's and semantics.
@@ -41,14 +41,19 @@ module NewRelic
               alias_method method_name_without, method_name
 
               define_method method_name do |*args, &block|
-                segment = NewRelic::Agent::Transaction.start_datastore_segment "Memcached", method_name
+                segment = NewRelic::Agent::Tracer.start_datastore_segment(
+                  product: "Memcached",
+                  operation: method_name
+                )
                 begin
-                  send method_name_without, *args, &block
+                  NewRelic::Agent::Tracer.capture_segment_error segment do
+                    send method_name_without, *args, &block
+                  end
                 ensure
                   if NewRelic::Agent.config[:capture_memcache_keys]
                     segment.notice_nosql_statement "#{method_name} #{args.first.inspect}"
                   end
-                  segment.finish
+                  segment.finish if segment
                 end
               end
 

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent
@@ -40,7 +40,7 @@ module NewRelic
               def server_for_key key
                 server = server_for_key_without_newrelic_trace key
                 begin
-                  if txn = ::NewRelic::Agent::Transaction.tl_current
+                  if txn = ::NewRelic::Agent::Tracer.current_transaction
                     segment = txn.current_segment
                     if ::NewRelic::Agent::Transaction::DatastoreSegment === segment
                       ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, server)
@@ -59,16 +59,21 @@ module NewRelic
               alias_method :send_multiget_without_newrelic_trace, :send_multiget
 
               def send_multiget(keys)
-                segment = ::NewRelic::Agent::Transaction.start_datastore_segment(MEMCACHED, SEND_MULTIGET_METRIC_NAME)
+                segment = ::NewRelic::Agent::Tracer.start_datastore_segment(
+                  product: MEMCACHED,
+                  operation: SEND_MULTIGET_METRIC_NAME
+                )
                 ::NewRelic::Agent::Instrumentation::Memcache::Dalli.assign_instance_to(segment, self)
 
                 begin
-                  send_multiget_without_newrelic_trace(keys)
+                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
+                    send_multiget_without_newrelic_trace(keys)
+                  end
                 ensure
                   if ::NewRelic::Agent.config[:capture_memcache_keys]
                     segment.notice_nosql_statement "#{SEND_MULTIGET_METRIC_NAME} #{keys.inspect}"
                   end
-                  segment.finish
+                  segment.finish if segment
                 end
               end
             end
@@ -82,11 +87,13 @@ module NewRelic
               alias_method method_name_without, method_name
 
               define_method method_name do |*args, &block|
-                segment = NewRelic::Agent::Transaction.start_segment "Ruby/Memcached/Dalli/#{method_name}"
+                segment = NewRelic::Agent::Tracer.start_segment name: "Ruby/Memcached/Dalli/#{method_name}"
                 begin
-                  __send__ method_name_without, *args, &block
+                  NewRelic::Agent::Tracer.capture_segment_error segment do                  
+                    __send__ method_name_without, *args, &block
+                  end
                 ensure
-                  segment.finish
+                  segment.finish if segment
                 end
               end
 

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'set'
 

data/lib/new_relic/agent/instrumentation/merb/errors.rb

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   @name = :merb_error

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

@@ -1,10 +1,10 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/agent/method_tracer'
 require 'new_relic/agent/transaction'
-require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/tracer'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 require 'new_relic/agent/instrumentation/middleware_tracing'
@@ -27,10 +27,18 @@ module NewRelic
             @middleware_class = middleware_class
           end
 
-          def new(*args, &blk)
-            middleware_instance = @middleware_class.new(*args, &blk)
-            MiddlewareProxy.wrap(middleware_instance)
+          if RUBY_VERSION < "2.7.0"
+            def new(*args, &blk)
+              middleware_instance = @middleware_class.new(*args, &blk)
+              MiddlewareProxy.wrap(middleware_instance)
+            end
+          else
+            def new(*args, **kwargs, &blk)
+              middleware_instance = @middleware_class.new(*args, **kwargs, &blk)
+              MiddlewareProxy.wrap(middleware_instance)
+            end
           end
+
         end
 
         def self.is_sinatra_app?(target)

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

@@ -1,10 +1,11 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/method_tracer'
 require 'new_relic/agent/transaction'
-require 'new_relic/agent/transaction_state'
+require 'new_relic/agent/tracer'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -26,7 +27,10 @@ module NewRelic
   module Agent
     module Instrumentation
       module MiddlewareTracing
-        TXN_STARTED_KEY = 'newrelic.transaction_started'.freeze
+
+        TXN_STARTED_KEY = 'newrelic.transaction_started'
+        CONTENT_TYPE    = 'Content-Type'
+        CONTENT_LENGTH  = 'Content-Length'
 
         def _nr_has_middleware_tracing
           true
@@ -56,8 +60,6 @@ module NewRelic
           end
         end
 
-        CONTENT_TYPE = 'Content-Type'.freeze
-
         def capture_response_content_type(state, result)
           if result.is_a?(Array) && state.current_transaction
             _, headers, _ = result
@@ -65,12 +67,12 @@ module NewRelic
           end
         end
 
-        CONTENT_LENGTH = 'Content-Length'.freeze
-
         def capture_response_content_length(state, result)
           if result.is_a?(Array) && state.current_transaction
             _, headers, _ = result
-            state.current_transaction.response_content_length = headers[CONTENT_LENGTH]
+            length = headers[CONTENT_LENGTH]
+            length = length.reduce(0){|sum, h| sum + h.to_i} if length.is_a?(Array)
+            state.current_transaction.response_content_length = length
           end
         end
 
@@ -83,10 +85,17 @@ module NewRelic
         def call(env)
           first_middleware = note_transaction_started(env)
 
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
 
           begin
-            Transaction.start(state, category, build_transaction_options(env, first_middleware))
+            options = build_transaction_options(env, first_middleware)
+
+            finishable = Tracer.start_transaction_or_segment(
+              name: options[:transaction_name],
+              category: category,
+              options: options
+            )
+
             events.notify(:before_call, env) if first_middleware
 
             result = (target == self) ? traced_call(env) : target.call(env)
@@ -101,7 +110,7 @@ module NewRelic
             NewRelic::Agent.notice_error(e)
             raise e
           ensure
-            Transaction.stop(state)
+            finishable.finish if finishable
           end
         end
 

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   named :mongo
@@ -56,10 +56,10 @@ DependencyDetection.defer do
 
       # It's key that this method eats all exceptions, as it rests between the
       # Mongo operation the user called and us returning them the data. Be safe!
-      def new_relic_notice_statement(t0, payload, name)
+      def new_relic_notice_statement(segment, payload, name)
         statement = NewRelic::Agent::Datastores::Mongo::StatementFormatter.format(payload, name)
         if statement
-          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(statement, (Time.now - t0).to_f)
+          segment.notice_nosql_statement statement
         end
       rescue => e
         NewRelic::Agent.logger.debug("Exception during Mongo statement gathering", e)
@@ -73,7 +73,12 @@ DependencyDetection.defer do
         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
+          operation, collection = op_and_col
+          NewRelic::Agent::Tracer.start_datastore_segment(
+            product: product,
+            operation: operation,
+            collection: collection
+          )
         end
       end
 
@@ -82,10 +87,12 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            instrument_without_new_relic_trace(name, payload, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              instrument_without_new_relic_trace(name, payload, &block)
+            end
           end
 
-          new_relic_notice_statement(segment.start_time, payload, name) if segment
+          new_relic_notice_statement(segment, payload, name) if segment
           result
         ensure
           segment.finish if segment
@@ -104,10 +111,12 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            save_without_new_relic_trace(doc, opts, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              save_without_new_relic_trace(doc, opts, &block)
+            end
           end
 
-          new_relic_notice_statement(segment.start_time, doc, :save) if segment
+          new_relic_notice_statement(segment, doc, :save) if segment
           result
         ensure
           segment.finish if segment
@@ -126,7 +135,9 @@ DependencyDetection.defer do
 
         begin
           result = NewRelic::Agent.disable_all_tracing do
-            ensure_index_without_new_relic_trace(spec, opts, &block)
+            NewRelic::Agent::Tracer.capture_segment_error segment do
+              ensure_index_without_new_relic_trace(spec, opts, &block)
+            end
           end
 
           spec = case spec
@@ -138,7 +149,7 @@ DependencyDetection.defer do
                    spec.dup
                  end
 
-          new_relic_notice_statement(segment.start_time, spec, :ensureIndex) if segment
+          new_relic_notice_statement(segment, spec, :ensureIndex) if segment
           result
         ensure
           segment.finish if segment

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 require 'new_relic/agent/datastores/mongo/event_formatter'
 
 module NewRelic
@@ -12,18 +12,41 @@ module NewRelic
 
         def started(event)
           begin
-            return unless NewRelic::Agent.tl_is_execution_traced?
+            return unless NewRelic::Agent::Tracer.tracing_enabled?
             segments[event.operation_id] = start_segment event
           rescue Exception => e
             log_notification_error('started', e)
           end
         end
 
+        ERROR_KEYS = %w{ writeErrors writeConcernError writeConcernErrors }.freeze
+
+        def error_key_present?(event)
+          if reply = event.reply
+            ERROR_KEYS.detect{ |key| reply[key] }
+          end
+        rescue
+          false
+        end
+
         def completed(event)
           begin
-            state = NewRelic::Agent::TransactionState.tl_get
-            return unless state.is_execution_traced?
+            return unless NewRelic::Agent::Tracer.tracing_enabled?
             segment = segments.delete(event.operation_id)
+            return unless segment
+
+            # operations that succeed but have errors return CommandSucceeded 
+            # with an error_key that is populated with error specfics
+            if error_key = error_key_present?(event)
+              # taking the last error as there can potentially be many
+              attributes = event.reply[error_key][-1]
+              segment.notice_error Mongo::Error.new("%s (%s)" % [attributes["errmsg"], attributes["code"]])
+
+            # failing commands return a CommandFailed event with an error message
+            # in the form of "% (%s)" for the message and code
+            elsif event.is_a? Mongo::Monitoring::Event::CommandFailed
+              segment.notice_error Mongo::Error.new(event.message)
+            end
             segment.finish
           rescue Exception => e
             log_notification_error('completed', e)
@@ -38,13 +61,27 @@ module NewRelic
         def start_segment event
           host = host_from_address event.address
           port_path_or_id = port_path_or_id_from_address event.address
-          segment = NewRelic::Agent::Transaction.start_datastore_segment(
-            MONGODB, event.command_name, collection(event), host, port_path_or_id, event.database_name
+          segment = NewRelic::Agent::Tracer.start_datastore_segment(
+            product: MONGODB,
+            operation: operation(event.command_name),
+            collection: collection(event),
+            host: host,
+            port_path_or_id: port_path_or_id,
+            database_name: event.database_name
           )
           segment.notice_nosql_statement(generate_statement(event))
           segment
         end
 
+        def operation(command_name)
+          # from 2.0 to 2.5, :findandmodify was the command_name
+          if command_name == :findandmodify
+            :findAndModify 
+          else
+            command_name
+          end
+        end
+
         def collection(event)
           event.command[COLLECTION] || event.command[:collection] || event.command.values.first
         end

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

@@ -1,6 +1,6 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 DependencyDetection.defer do
   named :net_http
@@ -11,35 +11,75 @@ DependencyDetection.defer do
 
   executes do
     ::NewRelic::Agent.logger.info 'Installing Net instrumentation'
-    require 'new_relic/agent/cross_app_tracing'
+    require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
   executes do
     class Net::HTTP
-      def request_with_newrelic_trace(request, *args, &block)
-        wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
 
-        segment = NewRelic::Agent::Transaction.start_external_request_segment(
-          wrapped_request.type, wrapped_request.uri, wrapped_request.method)
-
-        begin
-          response = nil
-          segment.add_request_headers wrapped_request
-
-          # RUBY-1244 Disable further tracing in request to avoid double
-          # counting if connection wasn't started (which calls request again).
-          NewRelic::Agent.disable_all_tracing do
-            response = request_without_newrelic_trace( request, *args, &block )
+      if RUBY_VERSION < "2.7.0"
+        def request_with_newrelic_trace(request, *args, &block)
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+  
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method
+          )
+  
+          begin
+            response = nil
+            segment.add_request_headers wrapped_request
+  
+            # RUBY-1244 Disable further tracing in request to avoid double
+            # counting if connection wasn't started (which calls request again).
+            NewRelic::Agent.disable_all_tracing do
+              response = NewRelic::Agent::Tracer.capture_segment_error segment do
+                request_without_newrelic_trace(request, *args, &block)
+              end
+            end
+  
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
+            segment.process_response_headers wrapped_response
+            response
+          ensure
+            segment.finish
+          end
+        end  
+      else
+        def request_with_newrelic_trace(request, *args, **kwargs, &block)
+          wrapped_request = NewRelic::Agent::HTTPClients::NetHTTPRequest.new(self, request)
+  
+          segment = NewRelic::Agent::Tracer.start_external_request_segment(
+            library: wrapped_request.type,
+            uri: wrapped_request.uri,
+            procedure: wrapped_request.method
+          )
+  
+          begin
+            response = nil
+            segment.add_request_headers wrapped_request
+  
+            # RUBY-1244 Disable further tracing in request to avoid double
+            # counting if connection wasn't started (which calls request again).
+            NewRelic::Agent.disable_all_tracing do
+              response = NewRelic::Agent::Tracer.capture_segment_error segment do
+                request_without_newrelic_trace(request, *args, **kwargs, &block)
+              end
+            end
+  
+            wrapped_response = NewRelic::Agent::HTTPClients::NetHTTPResponse.new response
+            segment.process_response_headers wrapped_response
+            response
+          ensure
+            segment.finish
           end
-
-          segment.read_response_headers response
-          response
-        ensure
-          segment.finish
         end
+    
       end
 
+
       alias request_without_newrelic_trace request
       alias request request_with_newrelic_trace
     end