newrelic_rpm 3.5.4.35.beta → 3.5.5.38

data/CHANGELOG

@@ -1,6 +1,48 @@
 
 # New Relic Ruby Agent Release Notes #
 
+## v3.5.5 ##
+
+  * Add thread profiling support
+
+    Thread profiling performs statistical sampling of backtraces of all threads
+    within your Ruby processes. This feature requires MRI >= 1.9.2, and is
+    controlled via the New Relic web UI. JRuby support (in 1.9.x compat mode) is
+    considered experimental, due to issues with JRuby's Thread#backtrace.
+
+  * Add audit logging capability
+
+    The agent can now log all of the data it sends to the New Relic servers to
+    a special log file for human inspection. This feature is off by default, and
+    can be enabled by setting the audit_log.enabled configuration key to true.
+    You may also control the location of the audit log with the audit_log.path key. 
+
+  * Use config system for dispatcher, framework, and config file detection
+
+    Several aspects of the agent's configuration were not being handled by the
+    configuration system.  Detection/configuration of the dispatcher (e.g. passenger,
+    unicorn, resque), framework (e.g. rails3, sinatra), and newrelic.yml
+    location are now handled via the Agent environment, manual, and default
+    configuration sources.
+
+  * Updates to logging across the agent
+
+    We've carefully reviewed the logging messages that the agent outputs, adding
+    details in some cases, and removing unnecessary clutter. We've also altered
+    the startup sequence to ensure that we don't spam STDOUT with messages
+    during initialization.
+
+  * Fix passing environment to manual_start()
+
+    Thanks to Justin Hannus.  The :env key, when passed to Agent.manual_start,
+    can again be used to specify which section of newrelic.yml is loaded.
+
+  * Rails 4 support
+
+    This release includes preliminary support for Rails 4 as of 4.0.0.beta.
+    Rails 4 is still in development, but the agent should work as expected for
+    people who are experimenting with the beta.
+
 ## v3.5.4 ##
 
   * Add queue time support for sinatra apps

data/GUIDELINES_FOR_CONTRIBUTING.md

@@ -64,6 +64,9 @@ These tests can be run by invoking:
     bundle
     bundle exec rake test:multiverse
 
+More details are available in
+[test/multiverse/README.md](https://github.com/newrelic/rpm/blob/master/test/multiverse/README.md).
+
 ### And Finally...
 
 You are welcome to send pull requests to us - however, by doing so you agree

data/Rakefile

@@ -23,6 +23,14 @@ namespace :test do
     end
   end
 
+  desc "Test the multiverse testing framework by executing tests in test/multiverse/test. Get meta with it."
+  task 'multiverse:self', [:suite, :mode] => [:gemspec] do |t, args|
+    args.with_defaults(:suite => "", :mode => "")
+    puts ("Testing the multiverse testing framework...")
+    test_files = FileList['test/multiverse/test/*_test.rb']
+    ruby test_files.join(" ")
+  end
+
   Rake::TestTask.new(:intentional_fail) do |t|
     t.libs << "#{agent_home}/test"
     t.libs << "#{agent_home}/lib"

data/bin/mongrel_rpm

@@ -28,6 +28,6 @@ builder = Rack::Builder.new { eval rackup_code, binding, ru_file }
 
 options = { :Host => '127.0.0.1', :Port => port }
 Rack::Handler::Mongrel.run(builder.to_app, options) do | server |
-  NewRelic::Control.instance.log! "Started Mongrel listening for '#{NewRelic::Control.instance.app_names.join(" and ")}' data at #{server.host}:#{server.port}" 
+  NewRelic::Agent.logger.info "Started Mongrel listening for '#{NewRelic::Control.instance.app_names.join(" and ")}' data at #{server.host}:#{server.port}" 
 end
 

data/init.rb

@@ -27,12 +27,5 @@ begin
   NewRelic::Control.instance.init_plugin :config => current_config
 
 rescue => e
-  NewRelic::Control.instance.log! "Error initializing New Relic plugin (#{e})", :error
-  NewRelic::Control.instance.log!  e.backtrace.join("\n"), :error
-  NewRelic::Control.instance.log! "Agent is disabled."
+  ::NewRelic::Agent.logger.error "Error initializing New Relic plugin. Agent is disabled.", e
 end
-
-#ClassLoadingWatcher.flag_const_missing = nil
-#
-# ::RAILS_DEFAULT_LOGGER.warn "New Relic detected environment: #{NewRelic::Control.instance.local_env.to_s}, RAILS_ENV: #{RAILS_ENV}"
-# ::RAILS_DEFAULT_LOGGER.warn "Enabled? #{NewRelic::Control.instance.agent_enabled?}"

data/lib/new_relic/agent.rb

@@ -77,6 +77,7 @@ module NewRelic
     require 'new_relic/agent'
     require 'new_relic/agent/chained_call'
     require 'new_relic/agent/browser_monitoring'
+    require 'new_relic/agent/cross_process_monitoring'
     require 'new_relic/agent/agent'
     require 'new_relic/agent/shim_agent'
     require 'new_relic/agent/method_tracer'
@@ -140,6 +141,16 @@ module NewRelic
 
     alias instance agent #:nodoc:
 
+    # Primary interface to logging is fronted by this accessor
+    # Access via ::NewRelic::Agent.logger
+    def logger
+      @logger || StartupLogger.instance
+    end
+
+    def logger=(log)
+      @logger = log
+    end
+
     # Get or create a statistics gatherer that will aggregate numerical data
     # under a metric name.
     #
@@ -154,19 +165,6 @@ module NewRelic
 
     alias get_stats_no_scope get_stats
 
-    # Get the logger for the agent.  Available after the agent has initialized.
-    # This sends output to the agent log file.  If the agent has not initialized
-    # a standard output logger is returned.
-    def logger
-      control = NewRelic::Control.instance(false)
-      if control && control.log
-        control.log
-      else
-        require 'logger'
-        @stdoutlog ||= Logger.new $stdout
-      end
-    end
-
     # Call this to manually start the Agent in situations where the Agent does
     # not auto-start.
     #

data/lib/new_relic/agent/agent.rb

@@ -89,8 +89,13 @@ module NewRelic
         # handles things like static setup of the header for inclusion
         # into pages
         attr_reader :beacon_configuration
+        # cross process id's and encoding
+        attr_reader :cross_process_id
+        attr_reader :cross_process_encoding_bytes
+        # service for communicating with collector
         attr_accessor :service
 
+
         # Returns the length of the unsent errors array, if it exists,
         # otherwise nil
         def unsent_errors_size
@@ -180,13 +185,12 @@ module NewRelic
             @metric_ids = {}
           end
 
-          # log.debug "Agent received after_fork notice in #$$: [#{control.agent_enabled?}; monitor=#{control.monitor_mode?}; connected: #{@connected.inspect}; thread=#{@worker_thread.inspect}]"
           return if !Agent.config[:agent_enabled] ||
             !Agent.config[:monitor_mode] ||
             @connected == false ||
             @worker_thread && @worker_thread.alive?
 
-          log.info "Starting the worker thread in #{$$} after forking."
+          ::NewRelic::Agent.logger.debug "Starting the worker thread in #{$$} after forking."
 
           # Clear out stats that are left over from parent process
           reset_stats
@@ -226,7 +230,7 @@ module NewRelic
             @worker_loop.stop
           end
 
-          log.debug "Starting Agent shutdown"
+          ::NewRelic::Agent.logger.info "Starting Agent shutdown"
 
           # if litespeed, then ignore all future SIGUSR1 - it's
           # litespeed trying to shut us down
@@ -241,14 +245,14 @@ module NewRelic
               graceful_disconnect
             end
           rescue => e
-            log.error e
-            log.error e.backtrace.join("\n")
+            ::NewRelic::Agent.logger.error e
           end
           NewRelic::Agent.config.remove_config do |config|
             config.class == NewRelic::Agent::Configuration::ManualSource ||
               config.class == NewRelic::Agent::Configuration::ServerSource
           end
           @started = nil
+          Control.reset
         end
 
         # Tells the statistics engine we are starting a new transaction
@@ -298,18 +302,13 @@ module NewRelic
           Thread.current[:newrelic_untraced].pop if Thread.current[:newrelic_untraced]
         end
 
-        # Shorthand to the NewRelic::Agent.logger method
-        def log
-          NewRelic::Agent.logger
-        end
-
         # Herein lies the corpse of the former 'start' method. May
         # its unmatched flog score rest in pieces.
         module Start
           # Check whether we have already started, which is an error condition
           def already_started?
             if started?
-              control.log!("Agent Started Already!", :error)
+              ::NewRelic::Agent.logger.error("Agent Started Already!")
               true
             end
           end
@@ -321,22 +320,35 @@ module NewRelic
             !Agent.config[:agent_enabled]
           end
 
+          # Log startup information that we almost always want to know
+          def log_startup
+            log_environment
+            log_dispatcher
+            log_app_names
+          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
-            return if log_if(dispatcher_name.empty?, :info, "No dispatcher detected.")
-            log.info "Dispatcher: #{dispatcher_name}"
+            return if log_if(dispatcher_name.empty?, :warn, "No dispatcher detected.")
+            ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
           end
 
           # Logs the configured application names
           def log_app_names
             names = Agent.config.app_names
             if names.respond_to?(:any?) && names.any?
-              log.info "Application: #{names.join(", ")}"
+              ::NewRelic::Agent.logger.info "Application: #{names.join(", ")}"
             else
-              log.error 'Unable to determine application name. Please set the application name in your newrelic.yml or in a NEW_RELIC_APP_NAME environment variable.'
+              ::NewRelic::Agent.logger.error 'Unable to determine application name. Please set the application name in your newrelic.yml or in a NEW_RELIC_APP_NAME environment variable.'
             end
           end
 
@@ -384,28 +396,18 @@ module NewRelic
             end
           end
 
-          # Tells us in the log file where the log file is
-          # located. This seems redundant, but can come in handy when
-          # we have some log file path set by the user which parses
-          # incorrectly, sending the log file to who-knows-where
-          def notify_log_file_location
-            log_file = NewRelic::Control.instance.log_file
-            log_if(File.exists?(log_file.to_s), :info,
-                   "Agent Log at #{log_file}")
-          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
-            log.info "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
+            ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
           end
 
           # A helper method that logs a condition if that condition is
           # true. Mentally cleaner than having every method set a
           # local and log if it is true
           def log_if(boolean, level, message)
-            self.log.send(level, message) if boolean
+            ::NewRelic::Agent.logger.send(level, message) if boolean
             boolean
           end
 
@@ -413,7 +415,7 @@ module NewRelic
           # condition is true. Mentally cleaner than having every
           # method set a local and log unless it is true
           def log_unless(boolean, level, message)
-            self.log.send(level, message) unless boolean
+            ::NewRelic::Agent.logger.send(level, message) unless boolean
             boolean
           end
 
@@ -428,7 +430,8 @@ module NewRelic
           # fix it by adding it to the file
           def has_license_key?
             log_unless(Agent.config[:license_key], :warn,
-                       "No license key found in newrelic.yml config.")
+                       "No license key found in newrelic.yml config. " +
+                       "This often means your newrelic.yml is missing a section for the running environment '#{NewRelic::Control.instance.env}'")
           end
 
           # A correct license key exists and is of the proper length
@@ -470,11 +473,9 @@ module NewRelic
           return if already_started? || disabled?
           @started = true
           @local_host = determine_host
-          log_dispatcher
-          log_app_names
+          log_startup
           check_config_and_start_agent
           log_version_and_pid
-          notify_log_file_location
         end
 
         # Clear out the metric data, errors, and transaction traces,
@@ -497,8 +498,8 @@ module NewRelic
           # logs info about the worker loop so users can see when the
           # agent actually begins running in the background
           def log_worker_loop_start
-            log.info "Reporting performance data every #{Agent.config[:data_report_period]} seconds."
-            log.debug "Running worker loop"
+            ::NewRelic::Agent.logger.debug "Reporting performance data every #{Agent.config[:data_report_period]} seconds."
+            ::NewRelic::Agent.logger.debug "Running worker loop"
           end
 
           # Creates the worker loop and loads it with the instructions
@@ -514,7 +515,7 @@ module NewRelic
           # this clears the data, clears connection attempts, and
           # waits a while to reconnect.
           def handle_force_restart(error)
-            log.info error.message
+            ::NewRelic::Agent.logger.debug error.message
             reset_stats
             @metric_ids = {}
             @connected = nil
@@ -525,15 +526,14 @@ module NewRelic
           # is the worker thread that gathers data and talks to the
           # server.
           def handle_force_disconnect(error)
-            log.error "New Relic forced this agent to disconnect (#{error.message})"
+            ::NewRelic::Agent.logger.warn "New Relic forced this agent to disconnect (#{error.message})"
             disconnect
           end
 
           # there is a problem with connecting to the server, so we
           # stop trying to connect and shut down the agent
           def handle_server_connection_problem(error)
-            log.error "Unable to establish connection with the server.  Run with log level set to debug for more information."
-            log.debug("#{error.class.name}: #{error.message}\n#{error.backtrace.first}")
+            ::NewRelic::Agent.logger.error "Unable to establish connection with the server.", error
             disconnect
           end
 
@@ -541,7 +541,7 @@ module NewRelic
           # it and disconnecting the agent, since we are now in an
           # unknown state
           def handle_other_error(error)
-            log.error "Terminating worker loop: #{error.class.name}: #{error.message}\n  #{error.backtrace.join("\n  ")}"
+            ::NewRelic::Agent.logger.error "Terminating worker loop.", error
             disconnect
           end
 
@@ -583,7 +583,7 @@ module NewRelic
                   # never reaches here unless there is a problem or
                   # the agent is exiting
                 else
-                  log.debug "No connection.  Worker thread ending."
+                  ::NewRelic::Agent.logger.debug "No connection.  Worker thread ending."
                 end
               end
             end
@@ -595,7 +595,7 @@ module NewRelic
         #
         # See #connect for a description of connection_options.
         def start_worker_thread(connection_options = {})
-          log.debug "Creating Ruby Agent worker thread."
+          ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
           @worker_thread = NewRelic::Agent::AgentThread.new('Worker Loop') do
             deferred_work!(connection_options)
           end
@@ -658,7 +658,7 @@ module NewRelic
             if @keep_retrying
               self.connect_attempts=(connect_attempts + 1)
               increment_retry_period!
-              log.info "Will re-attempt in #{connect_retry_period} seconds"
+              ::NewRelic::Agent.logger.warn "Will re-attempt in #{connect_retry_period} seconds"
               true
             else
               disconnect
@@ -670,8 +670,7 @@ module NewRelic
           # to tell the user what happened, since this is not an error
           # we can handle gracefully.
           def log_error(error)
-            log.error "Error establishing connection with New Relic Service at #{control.server}: #{error.message}"
-            log.debug error.backtrace.join("\n")
+            ::NewRelic::Agent.logger.error "Error establishing connection with New Relic Service at #{control.server}:", error
           end
 
           # When the server sends us an error with the license key, we
@@ -682,37 +681,18 @@ module NewRelic
           # no longer try to connect to the server, saving the
           # application and the server load
           def handle_license_error(error)
-            log.error error.message
-            log.info "Visit NewRelic.com to obtain a valid license key, or to upgrade your account."
+            ::NewRelic::Agent.logger.error( \
+              error.message, \
+              "Visit NewRelic.com to obtain a valid license key, or to upgrade your account.")
             disconnect
           end
 
-          # If we are using a seed and token to validate the agent, we
-          # should debug log that fact so that debug logs include a
-          # clue that token authentication is what will be used
-          def log_seed_token
-            if Agent.config[:validate_seed]
-              log.debug "Connecting with validation seed/token: #{Agent.config[:validate_seed]}/#{Agent.config[:validate_token]}"
-            end
-          end
-
           # Checks whether we should send environment info, and if so,
           # returns the snapshot from the local environment
           def environment_for_connect
             Agent.config[:send_environment_info] ? Control.instance.local_env.snapshot : []
           end
 
-          # These validation settings are used for cases where a
-          # dynamic server is spun up for clients - partners can
-          # include a seed and token to indicate that the host is
-          # allowed to connect, rather than setting a unique hostname
-          def validate_settings
-            {
-              :seed => Agent.config[:validate_seed],
-              :token => Agent.config[:validate_token]
-            }
-          end
-
           # Initializes the hash of settings that we send to the
           # server. Returns a literal hash containing the options
           def connect_settings
@@ -723,16 +703,12 @@ module NewRelic
               :language => 'ruby',
               :agent_version => NewRelic::VERSION::STRING,
               :environment => environment_for_connect,
-              :settings => Agent.config.flattened_config,
-              :validate => validate_settings
+              :settings => Agent.config.to_collector_hash,
             }
           end
 
-          # Does some simple logging to make sure that our seed and
-          # token for verification are correct, then returns the
-          # connect data passed back from the server
+          # Returns connect data passed back from the server
           def connect_to_server
-            log_seed_token
             @service.connect(connect_settings)
           end
 
@@ -760,23 +736,38 @@ module NewRelic
             @service.agent_id = config_data['agent_run_id'] if @service
 
             if config_data['agent_config']
-              log.info "Using config from server"
+              ::NewRelic::Agent.logger.debug "Using config from server"
             end
 
-            log.debug "Server provided config: #{config_data.inspect}"
+            ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
             server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data)
             Agent.config.apply_config(server_config, 1)
             log_connection!(config_data) if @service
 
+            @cross_process_id = Agent.config[:cross_process_id]
+            @cross_process_encoding_key = Agent.config[:encoding_key]
+            @cross_process_encoding_bytes = get_bytes(@cross_process_encoding_key) unless @cross_process_encoding_key.nil?
+
             @beacon_configuration = BeaconConfiguration.new
           end
 
+          # Ruby 1.8.6 doesn't support the bytes method on strings.
+          def get_bytes(value)
+            return [] if value.nil?
+
+            bytes = []
+            value.each_byte do |b|
+              bytes << b
+            end
+            bytes
+          end
+
           # Logs when we connect to the server, for debugging purposes
           # - makes sure we know if an agent has not connected
           def log_connection!(config_data)
-            log.info "Connected to NewRelic Service at #{@service.collector.name}"
-            log.debug "Agent Run       = #{@service.agent_id}."
-            log.debug "Connection data = #{config_data.inspect}"
+            ::NewRelic::Agent.logger.debug "Connected to NewRelic Service at #{@service.collector.name}"
+            ::NewRelic::Agent.logger.debug "Agent Run       = #{@service.agent_id}."
+            ::NewRelic::Agent.logger.debug "Connection data = #{config_data.inspect}"
             if config_data['messages'] && config_data['messages'].any?
               log_collector_messages(config_data['messages'])
             end
@@ -784,7 +775,7 @@ module NewRelic
 
           def log_collector_messages(messages)
             messages.each do |message|
-              log.send(message['level'].downcase.to_sym, message['message'])
+              ::NewRelic::Agent.logger.send(message['level'].downcase, message['message'])
             end
           end
         end
@@ -859,7 +850,7 @@ module NewRelic
           @connect_retry_period = should_keep_retrying?(options) ? 10 : 0
 
           sleep connect_retry_period
-          log.debug "Connecting Process to New Relic: #$0"
+          ::NewRelic::Agent.logger.debug "Connecting Process to New Relic: #$0"
           query_server_for_configuration
           @connected_pid = $$
           @connected = true
@@ -930,11 +921,11 @@ module NewRelic
                                                 now.to_f,
                                                 @unsent_timeslice_data.values)
           rescue UnrecoverableServerException => e
-            log.debug e.message
+            ::NewRelic::Agent.logger.debug e.message
           end
           fill_metric_id_cache(metric_specs_and_ids)
 
-          log.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@service.agent_id}) in #{Time.now - now} seconds"
+          ::NewRelic::Agent.logger.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@service.agent_id}) in #{Time.now - now} seconds"
 
           # if we successfully invoked this web service, then clear the unsent message cache.
           @unsent_timeslice_data = {}
@@ -953,13 +944,13 @@ module NewRelic
           # FIXME add the code to try to resend if our connection is down
           sql_traces = @sql_sampler.harvest
           unless sql_traces.empty?
-            log.debug "Sending (#{sql_traces.size}) sql traces"
+            ::NewRelic::Agent.logger.debug "Sending (#{sql_traces.size}) sql traces"
             begin
               @service.sql_trace_data(sql_traces)
             rescue UnrecoverableServerException => e
-              log.debug e.message
+              ::NewRelic::Agent.logger.debug e.message
             rescue => e
-              log.debug "Remerging SQL traces after #{e.class.name}: #{e.message}"
+              ::NewRelic::Agent.logger.debug "Remerging SQL traces after #{e.class.name}: #{e.message}"
               @sql_sampler.merge sql_traces
             end
           end
@@ -975,7 +966,7 @@ module NewRelic
           harvest_transaction_traces
           unless @traces.empty?
             now = Time.now
-            log.debug "Sending (#{@traces.length}) transaction traces"
+            ::NewRelic::Agent.logger.debug "Sending (#{@traces.length}) transaction traces"
 
             begin
               options = { :keep_backtraces => true }
@@ -987,9 +978,9 @@ module NewRelic
               end
               traces = @traces.map {|trace| trace.prepare_to_send(options) }
               @service.transaction_sample_data(traces)
-              log.debug "Sent slowest sample (#{@service.agent_id}) in #{Time.now - now} seconds"
+              ::NewRelic::Agent.logger.debug "Sent slowest sample (#{@service.agent_id}) in #{Time.now - now} seconds"
             rescue UnrecoverableServerException => e
-              log.debug e.message
+              ::NewRelic::Agent.logger.debug e.message
             end
           end
 
@@ -1005,7 +996,7 @@ module NewRelic
           if @thread_profiler.finished?
             profile = @thread_profiler.harvest
 
-            log.debug "Sending thread profile #{profile.profile_id}"
+            ::NewRelic::Agent.logger.debug "Sending thread profile #{profile.profile_id}"
             @service.profile_data(profile)
           end
         end
@@ -1025,11 +1016,11 @@ module NewRelic
         def harvest_and_send_errors
           harvest_errors
           if @unsent_errors && @unsent_errors.length > 0
-            log.debug "Sending #{@unsent_errors.length} errors"
+            ::NewRelic::Agent.logger.debug "Sending #{@unsent_errors.length} errors"
             begin
               @service.error_data(@unsent_errors)
             rescue UnrecoverableServerException => e
-              log.debug e.message
+              ::NewRelic::Agent.logger.debug e.message
             end
             # if the remote invocation fails, then we never clear
             # @unsent_errors, and therefore we can re-attempt to send on
@@ -1039,21 +1030,9 @@ module NewRelic
           end
         end
 
-        # Only JSON marshalling appears to work with collector on
-        # get_agent_commands and agent_command_results. We only support
-        # these features on Ruby versions that can hack JSON out of the box
-        def agent_commands_supported?
-          RUBY_VERSION >= "1.9.2"
-        end
-
         def check_for_agent_commands
-          if !agent_commands_supported?
-            log.debug("Skipping agent commands, as they aren't supported on this environment")
-            return
-          end
-
           commands = @service.get_agent_commands
-          log.debug "Received get_agent_commands = #{commands}"
+          ::NewRelic::Agent.logger.debug "Received get_agent_commands = #{commands.inspect}"
 
           @thread_profiler.respond_to_commands(commands) do |command_id, error|
             @service.agent_command_results(command_id, error)
@@ -1062,7 +1041,7 @@ module NewRelic
 
         def transmit_data(disconnecting=false)
           now = Time.now
-          log.debug "Sending data to New Relic Service"
+          ::NewRelic::Agent.logger.debug "Sending data to New Relic Service"
           harvest_and_send_errors
           harvest_and_send_slowest_sample
           harvest_and_send_slowest_sql
@@ -1074,7 +1053,7 @@ module NewRelic
           retry_count ||= 0
           retry_count += 1
           if retry_count <= 1
-            log.debug "retrying transmit_data after #{e}"
+            ::NewRelic::Agent.logger.debug "retrying transmit_data after #{e}"
             retry
           end
           raise e
@@ -1098,17 +1077,17 @@ module NewRelic
               transmit_data(true)
 
               if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
-                log.debug "Sending New Relic service agent run shutdown message"
+                ::NewRelic::Agent.logger.debug "Sending New Relic service agent run shutdown message"
                 @service.shutdown(Time.now.to_f)
               else
-                log.debug "This agent connected from parent process #{@connected_pid}--not sending shutdown"
+                ::NewRelic::Agent.logger.debug "This agent connected from parent process #{@connected_pid}--not sending shutdown"
               end
-              log.debug "Graceful disconnect complete"
+              ::NewRelic::Agent.logger.debug "Graceful disconnect complete"
             rescue Timeout::Error, StandardError => e
-              log.debug "Error when disconnecting #{e.class.name}: #{e.message}"
+              ::NewRelic::Agent.logger.debug "Error when disconnecting #{e.class.name}: #{e.message}"
             end
           else
-            log.debug "Bypassing graceful disconnect - agent not connected"
+            ::NewRelic::Agent.logger.debug "Bypassing graceful disconnect - agent not connected"
           end
         end
       end