newrelic_rpm 8.13.0 → 8.14.0

data/lib/new_relic/agent/agent_helpers/startup.rb

@@ -0,0 +1,202 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module AgentHelpers
+      module Startup
+        # True if we have initialized and completed 'start'
+        def started?
+          @started
+        end
+
+        # Check whether we have already started, which is an error condition
+        def already_started?
+          if started?
+            ::NewRelic::Agent.logger.error("Agent Started Already!")
+            true
+          end
+        end
+
+        # Logs a bunch of data and starts the agent, if needed
+        def start
+          return unless agent_should_start?
+
+          log_startup
+          check_config_and_start_agent
+          log_version_and_pid
+
+          events.subscribe(:initial_configuration_complete) do
+            log_ignore_url_regexes
+          end
+        end
+
+        # Sanity-check the agent configuration and start the agent,
+        # setting up the worker thread and the exit handler to shut
+        # down the agent
+        def check_config_and_start_agent
+          return unless monitoring? && has_correct_license_key?
+          return if using_forking_dispatcher?
+
+          setup_and_start_agent
+        end
+
+        # This is the shared method between the main agent startup and the
+        # after_fork call restarting the thread in deferred dispatchers.
+        #
+        # Treatment of @started and env report is important to get right.
+        def setup_and_start_agent(options = {})
+          @started = true
+          @harvester.mark_started
+
+          unless in_resque_child_process?
+            install_exit_handler
+            environment_for_connect
+            @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
+          end
+
+          connect_in_foreground if Agent.config[:sync_startup]
+          start_worker_thread(options)
+        end
+
+        # Log startup information that we almost always want to know
+        def log_startup
+          log_environment
+          log_dispatcher
+          log_app_name
+        end
+
+        # Log the environment the app thinks it's running in.
+        # Useful in debugging, as this is the key for config YAML lookups.
+        def log_environment
+          ::NewRelic::Agent.logger.info("Environment: #{NewRelic::Control.instance.env}")
+        end
+
+        # Logs the dispatcher to the log file to assist with
+        # debugging. When no debugger is present, logs this fact to
+        # assist with proper dispatcher detection
+        def log_dispatcher
+          dispatcher_name = Agent.config[:dispatcher].to_s
+
+          if dispatcher_name.empty?
+            ::NewRelic::Agent.logger.info('No known dispatcher detected.')
+          else
+            ::NewRelic::Agent.logger.info("Dispatcher: #{dispatcher_name}")
+          end
+        end
+
+        def log_app_name
+          ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(", ")}")
+        end
+
+        def log_ignore_url_regexes
+          regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
+
+          unless regexes.empty?
+            ::NewRelic::Agent.logger.info("Ignoring URLs that match the following regexes: " \
+              "#{regexes.map(&:inspect).join(", ")}.")
+          end
+        end
+
+        # Classy logging of the agent version and the current pid,
+        # so we can disambiguate processes in the log file and make
+        # sure they're running a reasonable version
+        def log_version_and_pid
+          ::NewRelic::Agent.logger.debug("New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}")
+        end
+
+        # Logs the configured application names
+        def app_name_configured?
+          names = Agent.config[:app_name]
+          return names.respond_to?(:any?) && names.any?
+        end
+
+        # Connecting in the foreground blocks further startup of the
+        # agent until we have a connection - useful in cases where
+        # you're trying to log a very-short-running process and want
+        # to get statistics from before a server connection
+        # (typically 20 seconds) exists
+        def connect_in_foreground
+          NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
+        end
+
+        # Warn the user if they have configured their agent not to
+        # send data, that way we can see this clearly in the log file
+        def monitoring?
+          if Agent.config[:monitor_mode]
+            true
+          else
+            ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
+            false
+          end
+        end
+
+        # Tell the user when the license key is missing so they can
+        # fix it by adding it to the file
+        def has_license_key?
+          if Agent.config[:license_key] && Agent.config[:license_key].length > 0
+            true
+          else
+            ::NewRelic::Agent.logger.warn("No license key found. " +
+              "This often means your newrelic.yml file was not found, or it lacks a section for the running " \
+              "environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml " \
+              "to ensure it is valid YML.")
+            false
+          end
+        end
+
+        # A correct license key exists and is of the proper length
+        def has_correct_license_key?
+          has_license_key? && correct_license_length
+        end
+
+        # A license key is an arbitrary 40 character string,
+        # usually looks something like a SHA1 hash
+        def correct_license_length
+          key = Agent.config[:license_key]
+
+          if key.length == 40
+            true
+          else
+            ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
+            false
+          end
+        end
+
+        # Check to see if the agent should start, returning +true+ if it should.
+        def agent_should_start?
+          return false if already_started? || disabled?
+
+          if defer_for_delayed_job?
+            ::NewRelic::Agent.logger.debug("Deferring startup for DelayedJob")
+            return false
+          end
+
+          if defer_for_resque?
+            ::NewRelic::Agent.logger.debug("Deferring startup for Resque in case it daemonizes")
+            return false
+          end
+
+          unless app_name_configured?
+            NewRelic::Agent.logger.error("No application name configured.",
+              "The Agent cannot start without at least one. Please check your ",
+              "newrelic.yml and ensure that it is valid and has at least one ",
+              "value set for app_name in the #{NewRelic::Control.instance.env} ",
+              "environment.")
+            return false
+          end
+
+          return true
+        end
+
+        # The agent is disabled when it is not force enabled by the
+        # 'agent_enabled' option (e.g. in a manual start), or
+        # enabled normally through the configuration file
+        def disabled?
+          !Agent.config[:agent_enabled]
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent_helpers/transmit.rb

@@ -0,0 +1,76 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module AgentHelpers
+      module Transmit
+        TRANSACTION_EVENT = "TransactionEvent".freeze
+        def transmit_analytic_event_data
+          transmit_single_data_type(:harvest_and_send_analytic_event_data, TRANSACTION_EVENT)
+        end
+
+        CUSTOM_EVENT = "CustomEvent".freeze
+        def transmit_custom_event_data
+          transmit_single_data_type(:harvest_and_send_custom_event_data, CUSTOM_EVENT)
+        end
+
+        ERROR_EVENT = "ErrorEvent".freeze
+        def transmit_error_event_data
+          transmit_single_data_type(:harvest_and_send_error_event_data, ERROR_EVENT)
+        end
+
+        SPAN_EVENT = "SpanEvent".freeze
+        def transmit_span_event_data
+          transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
+        end
+
+        LOG_EVENT = "LogEvent".freeze
+        def transmit_log_event_data
+          transmit_single_data_type(:harvest_and_send_log_event_data, LOG_EVENT)
+        end
+
+        def transmit_single_data_type(harvest_method, supportability_name)
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          msg = "Sending #{supportability_name} data to New Relic Service"
+          ::NewRelic::Agent.logger.debug(msg)
+
+          @service.session do # use http keep-alive
+            self.send(harvest_method)
+          end
+        ensure
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
+          NewRelic::Agent.record_metric("Supportability/#{supportability_name}Harvest", duration)
+        end
+
+        def transmit_data
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          ::NewRelic::Agent.logger.debug("Sending data to New Relic Service")
+
+          @events.notify(:before_harvest)
+          @service.session do # use http keep-alive
+            harvest_and_send_data_types
+
+            check_for_and_handle_agent_commands
+            harvest_and_send_for_agent_commands
+          end
+        ensure
+          NewRelic::Agent::Database.close_connections
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
+          NewRelic::Agent.record_metric('Supportability/Harvest', duration)
+        end
+
+        def transmit_data_types
+          transmit_data
+          transmit_analytic_event_data
+          transmit_custom_event_data
+          transmit_error_event_data
+          transmit_span_event_data
+          transmit_log_event_data
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/default_source.rb

@@ -358,6 +358,19 @@ module NewRelic
           :description => 'Sets the level of detail of log messages. Possible log levels, in increasing verbosity, are: `error`, `warn`, `info` or `debug`.'
         },
         # General
+        :active_support_custom_events_names => {
+          :default => [],
+          :public => true,
+          :type => Array,
+          :allowed_from_server => false,
+          :description => <<-DESCRIPTION
+An array of ActiveSupport custom events names to subscribe to and provide
+instrumentation for. For example,
+  - my.custom.event
+  - another.event
+  - a.third.event
+          DESCRIPTION
+        },
         :apdex_t => {
           :default => 0.5,
           :public => true,
@@ -1837,6 +1850,15 @@ If `true`, disables agent middleware for Sinatra. This middleware is responsible
           :allowed_from_server => false,
           :description => 'Specify a custom host name for [display in the New Relic UI](/docs/apm/new-relic-apm/maintenance/add-rename-remove-hosts#display_name).'
         },
+        # Rails
+        :'defer_rails_initialization' => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :allowed_from_server => false,
+          :description => 'If `true`, when the agent is in an application using Ruby on Rails, it will start after ' \
+            'config/initializers are run.'
+        },
         # Rake
         :'rake.tasks' => {
           :default => [],

data/lib/new_relic/agent/datastores.rb

@@ -53,7 +53,7 @@ module NewRelic
               begin
                 send(method_name_without_newrelic, *args, &blk)
               ensure
-                segment.finish if segment
+                ::NewRelic::Agent::Transaction::Segment.finish(segment)
               end
             end
 
@@ -126,7 +126,7 @@ module NewRelic
               callback.call(result, segment.name, elapsed_time)
             end
           ensure
-            segment.finish if segment
+            ::NewRelic::Agent::Transaction::Segment.finish(segment)
           end
         end
       end

data/lib/new_relic/agent/guid_generator.rb

@@ -7,14 +7,23 @@ module NewRelic
     module GuidGenerator
       module_function
 
+      MAX_RAND_16 = 16**16
+      MAX_RAND_32 = 16**32
       # This method intentionally does not use SecureRandom, because it relies
       # on urandom, which raises an exception in MRI when the interpreter runs
       # out of allocated file descriptors.
       # The guids generated by this method may not be _secure_, but they are
       # random enough for our purposes.
       def generate_guid(length = 16)
-        guid = rand(16**length).to_s(16)
-        guid.length < length ? guid.rjust(length, "0") : guid
+        guid = case length
+               when 16
+                 rand(MAX_RAND_16)
+               when 32
+                 rand(MAX_RAND_32)
+               else
+                 rand(16**length)
+        end.to_s(16)
+        guid.length < length ? guid.rjust(length, '0') : guid
       end
     end
   end

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

@@ -8,22 +8,22 @@ DependencyDetection.defer do
   named :activejob
 
   depends_on do
-    defined?(::ActiveJob::Base)
+    defined?(ActiveJob::Base)
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActiveJob instrumentation')
+    NewRelic::Agent.logger.info('Installing ActiveJob instrumentation')
 
     ActiveSupport.on_load(:active_job) do
-      ::ActiveJob::Base.around_enqueue do |job, block|
-        ::NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
+      ActiveJob::Base.around_enqueue do |job, block|
+        NewRelic::Agent::Instrumentation::ActiveJobHelper.enqueue(job, block)
       end
 
-      ::ActiveJob::Base.around_perform do |job, block|
-        ::NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
+      ActiveJob::Base.around_perform do |job, block|
+        NewRelic::Agent::Instrumentation::ActiveJobHelper.perform(job, block)
       end
 
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActiveJob::Base)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(ActiveJob::Base)
     end
   end
 end

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

@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActiveMerchant instrumentation')
+    NewRelic::Agent.logger.info('Installing ActiveMerchant instrumentation')
   end
 
   executes do
@@ -42,7 +42,7 @@ DependencyDetection.defer do
     deprecation_msg = 'The Ruby Agent is dropping support for ActiveMerchant versions below 1.65.0 ' \
       'in version 9.0.0. Please upgrade your ActiveMerchant version to continue receiving full support. ' \
 
-    ::NewRelic::Agent.logger.log_once(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_active_merchant_version,
       deprecation_msg

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

@@ -84,7 +84,7 @@ module NewRelic
                 log_without_newrelic_instrumentation(*args, &block)
               end
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         else
@@ -128,7 +128,7 @@ module NewRelic
                 log_without_newrelic_instrumentation(*args, **kwargs, &block)
               end
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end
@@ -141,9 +141,9 @@ DependencyDetection.defer do
   @name = :active_record
 
   depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      (!defined?(::ActiveRecord::VERSION) ||
-        ::ActiveRecord::VERSION::MAJOR.to_i <= 3)
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      (!defined?(ActiveRecord::VERSION) ||
+        ActiveRecord::VERSION::MAJOR.to_i <= 3)
   end
 
   depends_on do
@@ -151,18 +151,18 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActiveRecord instrumentation')
+    NewRelic::Agent.logger.info('Installing ActiveRecord instrumentation')
   end
 
   executes do
     require 'new_relic/agent/instrumentation/active_record_helper'
 
-    if defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR.to_i == 3
+    if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR.to_i == 3
       ActiveSupport.on_load(:active_record) do
-        ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+        NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
       end
     else
-      ::NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
+      NewRelic::Agent::Instrumentation::ActiveRecord.insert_instrumentation
     end
   end
 end

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

@@ -84,9 +84,9 @@ DependencyDetection.defer do
   named :active_record_notifications
 
   depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      defined?(ActiveRecord::VERSION) &&
+      ActiveRecord::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
@@ -95,7 +95,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing notifications based Active Record instrumentation')
+    NewRelic::Agent.logger.info('Installing notifications based Active Record instrumentation')
   end
 
   executes do
@@ -105,51 +105,51 @@ DependencyDetection.defer do
 
   executes do
     ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-        ::ActiveRecord::Base,
-        ::ActiveRecord::Relation
+      NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ActiveRecord::Base,
+        ActiveRecord::Relation
       )
 
       # Default to .prepending, unless the ActiveRecord version is <=4
       # **AND** the :prepend_active_record_instrumentation config is false
-      if ::ActiveRecord::VERSION::MAJOR > 4 \
-          || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+      if ActiveRecord::VERSION::MAJOR > 4 \
+          || NewRelic::Agent.config[:prepend_active_record_instrumentation]
 
-        ::ActiveRecord::Base.send(:prepend,
-          ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
-        ::ActiveRecord::Relation.send(:prepend,
-          ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+        ActiveRecord::Base.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ActiveRecord::Relation.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
       else
-        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+        NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
       end
     end
   end
 
   executes do
     if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
-      major_version = ::ActiveRecord::VERSION::MAJOR.to_i
-      minor_version = ::ActiveRecord::VERSION::MINOR.to_i
+      major_version = ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ActiveRecord::VERSION::MINOR.to_i
 
       activerecord_extension = if major_version == 4
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
       elsif major_version == 5 && minor_version == 0
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
       elsif major_version == 5 && minor_version == 1
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
       end
 
       unless activerecord_extension.nil?
-        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
       end
     end
   end
 
   executes do
-    if ::ActiveRecord::VERSION::MAJOR == 5 \
-        && ::ActiveRecord::VERSION::MINOR.to_i == 1 \
-        && ::ActiveRecord::VERSION::TINY.to_i >= 6
+    if ActiveRecord::VERSION::MAJOR == 5 \
+        && ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ActiveRecord::VERSION::TINY.to_i >= 6
 
-      ::ActiveRecord::Base.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
+      ActiveRecord::Base.prepend(NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
     end
   end
 end

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

@@ -8,12 +8,12 @@ DependencyDetection.defer do
   named :active_storage
 
   depends_on do
-    defined?(::ActiveStorage) &&
+    defined?(ActiveStorage) &&
       !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActiveStorage instrumentation')
+    NewRelic::Agent.logger.info('Installing ActiveStorage instrumentation')
   end
 
   executes do

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

@@ -0,0 +1,12 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# This is a helper file that will allow apps using ActiveSupport without Rails
+# to still leverage all ActiveSupport based instrumentation functionality
+# offered by the agent that would otherwise be gated by the detection of Rails.
+
+# ActiveSupport notifications custom events
+if !defined?(Rails) && defined?(ActiveSupport::Notifications) && defined?(ActiveSupport::IsolatedExecutionState)
+  require_relative 'rails_notifications/custom_events'
+end

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

@@ -9,14 +9,14 @@ require_relative 'active_support_logger/prepend'
 DependencyDetection.defer do
   named :active_support_logger
 
-  depends_on { defined?(::ActiveSupport::Logger) }
+  depends_on { defined?(ActiveSupport::Logger) }
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')
+    NewRelic::Agent.logger.info('Installing ActiveSupport::Logger instrumentation')
 
     if use_prepend?
       # the only method currently instrumented is a class method
-      prepend_instrument ::ActiveSupport::Logger.singleton_class, NewRelic::Agent::Instrumentation::ActiveSupportLogger::Prepend
+      prepend_instrument ActiveSupport::Logger.singleton_class, NewRelic::Agent::Instrumentation::ActiveSupportLogger::Prepend
     else
       chain_instrument NewRelic::Agent::Instrumentation::ActiveSupportLogger::Chain
     end

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

@@ -44,11 +44,11 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing ActsAsSolr instrumentation')
+    NewRelic::Agent.logger.info('Installing ActsAsSolr instrumentation')
     deprecation_msg = 'The instrumentation for ActsAsSolr is deprecated. ' \
       'It will be removed in version 9.0.0.' \
 
-    ::NewRelic::Agent.logger.log_once(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_acts_as_solr,
       deprecation_msg

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

@@ -12,11 +12,11 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing Authlogic instrumentation')
+    NewRelic::Agent.logger.info('Installing Authlogic instrumentation')
     deprecation_msg = 'The instrumentation for Authlogic is deprecated. ' \
       'It will be removed in version 9.0.0.' \
 
-    ::NewRelic::Agent.logger.log_once(
+    NewRelic::Agent.logger.log_once(
       :warn,
       :deprecated_authlogic,
       deprecation_msg

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

@@ -53,7 +53,7 @@ module NewRelic
                 yield
               end
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end
@@ -97,7 +97,7 @@ module NewRelic
                 raise bunny_error
               end
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
 
             msg
@@ -120,7 +120,7 @@ module NewRelic
                 yield
               end
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end