newrelic_rpm 5.5.0.348 → 6.2.0.354

data/lib/new_relic/agent/external.rb

@@ -34,13 +34,16 @@ module NewRelic
       #
       # @api public
       def start_segment(library: nil, uri: nil, procedure: nil)
+        Deprecator.deprecate 'External.start_segment',
+                             'Tracer#start_external_request_segment'
+
         raise ArgumentError, 'Argument `library` is required' if library.nil?
         raise ArgumentError, 'Argument `uri` is required' if uri.nil?
         raise ArgumentError, 'Argument `procedure` is required' if procedure.nil?
 
         ::NewRelic::Agent.record_api_supportability_metric(:start_segment)
 
-        ::NewRelic::Agent::Transaction.start_external_request_segment(
+        ::NewRelic::Agent::Tracer.start_external_request_segment(
           library: library,
           uri: uri,
           procedure: procedure
@@ -64,7 +67,7 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        state = NewRelic::Agent::TransactionState.tl_get
+        state = NewRelic::Agent::Tracer.state
         if transaction = state.current_transaction
           rmd = ::JSON.parse obfuscator.deobfuscate(request_metadata)
 
@@ -109,8 +112,7 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        state = NewRelic::Agent::TransactionState.tl_get
-        return unless (transaction = state.current_transaction)
+        return unless (transaction = Tracer.current_transaction)
         return unless (cross_app_payload = transaction.cross_app_payload)
 
         # must freeze the name since we're responding with it

data/lib/new_relic/agent/hostname.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 'socket'
 
 module NewRelic
   module Agent
@@ -16,6 +17,13 @@ module NewRelic
         end
       end
 
+      def self.get_fqdn
+        %x[hostname -f].chomp!
+      rescue => e
+        NewRelic::Agent.logger.debug "Unable to determine fqdn #{e}"
+        nil
+      end
+
       def self.heroku_dyno_name_prefix(dyno_name)
         get_dyno_prefixes.find do |dyno_prefix|
           dyno_name.start_with?(dyno_prefix + ".")

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

@@ -27,7 +27,7 @@ module NewRelic
           event = super
           notice_error payload if payload.key? :exception
           if event.name == PERFORM_ACTION
-            finish_transaction
+            finish_transaction event
           else
             stop_recording_metrics event
           end
@@ -38,15 +38,18 @@ module NewRelic
         private
 
         def start_transaction event
-          Transaction.start(state, :action_cable, :transaction_name => transaction_name_from_event(event))
+          event.payload[:finishable] = Tracer.start_transaction_or_segment(
+            name:     transaction_name_from_event(event),
+            category: :action_cable
+          )
         end
 
-        def finish_transaction
-          Transaction.stop(state)
+        def finish_transaction event
+          (finishable = event.payload[:finishable]) && finishable.finish
         end
 
         def start_recording_metrics event
-          event.payload[:segment] = Transaction.start_segment name: metric_name_from_event(event)
+          event.payload[:segment] = Tracer.start_segment name: metric_name_from_event(event)
         end
 
         def stop_recording_metrics event

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

@@ -43,17 +43,21 @@ module NewRelic
         end
 
         def start_transaction(event)
-          Transaction.start(state, :controller,
-                            :request          => event.request,
-                            :filtered_params  => filter(event.payload[:params]),
-                            :apdex_start_time => event.queue_start,
-                            :transaction_name => event.metric_name,
-                            :ignore_apdex     => event.apdex_ignored?,
-                            :ignore_enduser   => event.enduser_ignored?)
+          event.payload[:finishable] = Tracer.start_transaction_or_segment(
+            name:             event.metric_name,
+            category:         :controller,
+            options: {
+              request:          event.request,
+              filtered_params:  filter(event.payload[:params]),
+              apdex_start_time: event.queue_start,
+              ignore_apdex:     event.apdex_ignored?,
+              ignore_enduser:   event.enduser_ignored?
+            }
+          )
         end
 
         def stop_transaction(event)
-          Transaction.stop(state)
+          (finishable = event.payload[:finishable]) && finishable.finish
         end
 
         def filter(params)

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

@@ -14,7 +14,7 @@ module NewRelic
           event = RenderEvent.new(name, Time.now, nil, id, payload)
           push_event(event)
           if state.is_execution_traced? && event.recordable?
-            event.segment = NewRelic::Agent::Transaction.start_segment name: event.metric_name
+            event.segment = NewRelic::Agent::Tracer.start_segment name: event.metric_name
           end
         rescue => e
           log_notification_error(e, name, 'start')

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

@@ -39,7 +39,7 @@ module NewRelic
         end
 
         def self.perform(job, block)
-          state = ::NewRelic::Agent::TransactionState.tl_get
+          state = ::NewRelic::Agent::Tracer.state
           txn = state.current_transaction
 
           # Don't nest transactions if we're already in a web transaction.
@@ -52,7 +52,7 @@ module NewRelic
               transaction_category)
             block.call
           else
-            run_in_transaction(state, job, block)
+            run_in_transaction(job, block)
           end
         end
 
@@ -62,11 +62,10 @@ module NewRelic
           end
         end
 
-        def self.run_in_transaction(state, job, block)
-          ::NewRelic::Agent::Transaction.wrap(state,
-                                              transaction_name_for_job(job),
-                                              :other,
-                                              &block)
+        def self.run_in_transaction(job, block)
+          ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
+                                                   category: :other,
+                                                   &block)
         end
 
         def self.transaction_category

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

@@ -44,7 +44,7 @@ module NewRelic
         end
 
         def log_with_newrelic_instrumentation(*args, &block) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
 
           if !state.is_execution_traced?
             return log_without_newrelic_instrumentation(*args, &block)
@@ -67,7 +67,7 @@ module NewRelic
             database = @config && @config[:database]
           end
 
-          segment = NewRelic::Agent::Transaction.start_datastore_segment(
+          segment = NewRelic::Agent::Tracer.start_datastore_segment(
             product: product,
             operation: operation,
             collection: collection,

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

@@ -31,7 +31,7 @@ module NewRelic
           # we don't expect this to be called more than once, but we're being
           # defensive.
           return if defined?(cached?)
-          if ::ActiveRecord::VERSION::STRING >= "5.1.0"
+          if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::STRING >= "5.1.0"
             def cached?(payload)
               payload.fetch(:cached, false)
             end
@@ -114,7 +114,7 @@ module NewRelic
               database = @config && @config[:database]
             end
 
-            segment = Transaction.start_datastore_segment product: product,
+            segment = Tracer.start_datastore_segment product: product,
                                                           operation: operation,
                                                           collection: collection,
                                                           host: host,
@@ -130,7 +130,7 @@ module NewRelic
           end
 
           def state
-            @state ||= NewRelic::Agent::TransactionState.tl_get
+            @state ||= NewRelic::Agent::Tracer.state
           end
 
           def sql

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

@@ -0,0 +1,23 @@
+# 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/instrumentation/active_storage_subscriber'
+
+DependencyDetection.defer do
+  named :active_storage
+
+  depends_on do
+    defined?(::ActiveStorage) &&
+      !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing ActiveStorage 5 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\.active_storage$/,
+      NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.new)
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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/instrumentation/evented_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveStorageSubscriber < EventedSubscriber
+        def start name, id, payload
+          return unless state.is_execution_traced?
+          start_segment name, id, payload
+        rescue => e
+          log_notification_error e, name, 'start'
+        end
+
+        def finish name, id, payload
+          return unless state.is_execution_traced?
+          finish_segment id
+        rescue => e
+          log_notification_error e, name, 'finish'
+        end
+
+        def start_segment name, id, payload
+          segment = Tracer.start_segment name: metric_name(name, payload)
+          segment.params[:key] = payload[:key]
+          segment.params[:exist] = payload[:exist] if payload.key? :exist
+          event_stack[id].push segment
+        end
+
+        def finish_segment id
+          segment = event_stack[id].pop
+          segment.finish if segment
+        end
+
+        def metric_name name, payload
+          service = payload[:service]
+          method = method_from_name name
+          "Ruby/ActiveStorage/#{service}Service/#{method}"
+        end
+
+        PATTERN = /\Aservice_([^\.]*)\.active_storage\z/
+        UNKNOWN = "unknown".freeze
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = UNKNOWN
+          end
+        end
+
+        def method_from_name name
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module NewRelic
             begin
               parse_query_without_newrelic(*args)
             ensure
-              return unless txn = ::NewRelic::Agent::TransactionState.tl_get.current_transaction
+              return unless txn = ::NewRelic::Agent::Tracer.current_transaction
               txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
             end
           end

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

@@ -57,19 +57,23 @@ DependencyDetection.defer do
         def pop(opts = {:manual_ack => false}, &block)
           t0 = Time.now
           msg = pop_without_new_relic opts, &block
+          delivery_info, message_properties, _payload = msg
 
           begin
-            exchange_name = NewRelic::Agent::Instrumentation::Bunny.exchange_name(msg.first.exchange)
-
-            segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: exchange_name,
-              delivery_info: msg[0],
-              message_properties: msg[1],
-              exchange_type: channel.exchanges[msg.first.exchange].type,
-              queue_name: name,
-              start_time: t0
-            )
+            if delivery_info
+              exchange_name = NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange)
+              exchange_type = NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel)
+
+              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+                destination_name: exchange_name,
+                delivery_info: delivery_info,
+                message_properties: message_properties,
+                exchange_type: exchange_type,
+                queue_name: name,
+                start_time: t0
+              )
+            end
 
           rescue => e
             NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#pop", e
@@ -85,7 +89,7 @@ DependencyDetection.defer do
         def purge *args
           begin
             type = server_named? ? :temporary_queue : :queue
-            segment = NewRelic::Agent::Transaction.start_message_broker_segment(
+            segment = NewRelic::Agent::Tracer.start_message_broker_segment(
               action: :purge,
               library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
               destination_type: type,

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

@@ -233,7 +233,9 @@ module NewRelic
             category ||= (txn && txn.category)
             case category
             when :controller    then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :web           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :task          then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :background    then ::NewRelic::Agent::Transaction::TASK_PREFIX
             when :rack          then ::NewRelic::Agent::Transaction::RACK_PREFIX
             when :uri           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :sinatra       then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
@@ -344,7 +346,7 @@ module NewRelic
         #
         def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
           NewRelic::Agent.record_api_supportability_metric(:perform_action_with_newrelic_trace)
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
           request = newrelic_request(args)
           queue_start_time = detect_queue_start_time(request)
 
@@ -364,7 +366,11 @@ module NewRelic
           txn_options   = create_transaction_options(trace_options, category, state, queue_start_time)
 
           begin
-            Transaction.start(state, category, txn_options)
+            finishable = Tracer.start_transaction_or_segment(
+              name: txn_options[:transaction_name],
+              category: category,
+              options: txn_options
+            )
 
             begin
               yield
@@ -374,7 +380,7 @@ module NewRelic
             end
 
           ensure
-            Transaction.stop(state)
+            finishable.finish if finishable
           end
         end
 

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

@@ -112,13 +112,9 @@ DependencyDetection.defer do
       alias_method :add_without_newrelic, :add
       alias_method :add, :add_with_newrelic
 
-
       # Trace as an External/Multiple call if the first request isn't serial.
       def perform_with_newrelic(&blk)
-        return perform_without_newrelic if
-          self.requests.first &&
-          self.requests.first.respond_to?(:_nr_serial) &&
-          self.requests.first._nr_serial
+        return perform_without_newrelic if first_request_is_serial?
 
         trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
           perform_without_newrelic(&blk)
@@ -198,6 +194,23 @@ DependencyDetection.defer do
         request._nr_instrumented = false
       end
 
+      private
+
+      def first_request_is_serial?
+        return false unless (first = self.requests.first)
+
+        # Before curb 0.9.8, requests was an array of Curl::Easy
+        # instances.  Starting with 0.9.8, it's a Hash where the
+        # values are Curl::Easy instances.
+        #
+        # So, requests.first will either be an_obj or [a_key, an_obj].
+        # We need to handle either case.
+        #
+        first = first[-1] if first.is_a?(Array)
+
+        first.respond_to?(:_nr_serial) && first._nr_serial
+      end
+
     end # class Curl::Multi
 
   end

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

@@ -185,7 +185,7 @@ module NewRelic
         # hooked with tracers, ensuring that notice_sql attaches this SQL to
         # the proper call scope.
         def log(msg) #THREAD_LOCAL_ACCESS
-          state = NewRelic::Agent::TransactionState.tl_get
+          state = NewRelic::Agent::Tracer.state
           return unless state.is_execution_traced?
 
           txn = state.current_transaction

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

@@ -60,7 +60,7 @@ module NewRelic
         end
 
         def state
-          NewRelic::Agent::TransactionState.tl_get
+          NewRelic::Agent::Tracer.state
         end
       end