newrelic_rpm 3.5.4.35.beta → 3.5.5.38

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -149,7 +149,7 @@ module NewRelic
           end
         rescue StandardError => e
           msg = "#{e.class.name} '#{e.message}' trying to load #{Base64.encode64(data)}"
-          NewRelic::Control.instance.log.debug(msg)
+          ::NewRelic::Agent.logger.debug(msg)
           nil
         end
 

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -15,10 +15,10 @@ module NewRelic
           elsif platform =~ /linux/
             @sampler = ProcStatus.new
             if !@sampler.can_run?
-              NewRelic::Agent.instance.warn.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
+              ::NewRelic::Agent.logger.debug "Error attempting to use /proc/#{$$}/status file for reading memory. Using ps command instead."
               @sampler = ShellPS.new("ps -o rsz")
             else
-              NewRelic::Agent.instance.log.debug "Using /proc/#{$$}/status for reading process memory."
+              ::NewRelic::Agent.logger.debug "Using /proc/#{$$}/status for reading process memory."
             end
           elsif platform =~ /darwin9/ # 10.5
             @sampler = ShellPS.new("ps -o rsz")
@@ -68,14 +68,12 @@ module NewRelic
             begin
               m = get_memory
               if m.nil?
-                NewRelic::Agent.instance.log.error "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
+                ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}.  Disabling memory sampler."
                 @broken = true
               end
               return m
             rescue => e
-              NewRelic::Agent.instance.log.error "Unable to get the resident memory for process #{$$}. (#{e})"
-              NewRelic::Agent.instance.log.debug e.backtrace.join("\n  ")
-              NewRelic::Agent.instance.log.error "Disabling memory sampler."
+              ::NewRelic::Agent.logger.warn "Unable to get the resident memory for process #{$$}. Disabling memory sampler.", e
               @broken = true
               return nil
             end

data/lib/new_relic/agent/sql_sampler.rb

@@ -71,7 +71,7 @@ module NewRelic
 
         if data.sql_data.size > 0
           @samples_lock.synchronize do
-            NewRelic::Agent.instance.log.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
+            ::NewRelic::Agent.logger.debug "Harvesting #{data.sql_data.size} slow transaction sql statement(s)"
             #FIXME get tx name and uri
             harvest_slow_sql data
           end
@@ -223,31 +223,16 @@ module NewRelic
         Agent.config[:'slow_sql.explain_enabled']
       end
 
-      def to_collector_array(marshaller)
-        params = if marshaller.respond_to?(:encode_compress)
-          marshaller.encode_compress(@params)
-        else
-          @params
-        end
-
+      def to_collector_array(encoder)
         [ @path, @url, @sql_id, @sql, @database_metric_name, @call_count,
           Helper.time_to_millis(@total_call_time),
           Helper.time_to_millis(@min_call_time),
           Helper.time_to_millis(@max_call_time),
-          params ]
+          encoder.encode(@params) ]
       end
 
       private
 
-      def compress(data)
-        if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
-          require 'json'
-          Base64.encode64(Zlib::Deflate.deflate(JSON.dump(data), Zlib::DEFAULT_COMPRESSION))
-        else
-          data
-        end
-      end
-
       def consistent_hash(string)
         # need to hash the same way in every process
         Digest::MD5.hexdigest(string).hex \

data/lib/new_relic/agent/stats_engine.rb

@@ -16,11 +16,6 @@ module NewRelic
         Thread::current[:newrelic_scope_stack] = nil
         start_sampler_thread
       end
-
-      def log
-        NewRelic::Control.instance.log
-      end
-
     end
   end
 end

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

@@ -51,7 +51,7 @@ module NewRelic
 
           def log_error(e)
             backtraces = Thread.list.map { |t| log_thread(t) }.join("\n\n")
-            NewRelic::Control.instance.log.warn(
+            ::NewRelic::Agent.logger.warn(
               "SynchronizedHash failure: #{e.class.name}: #{e.message}\n#{backtraces}")
           end
 
@@ -71,9 +71,9 @@ module NewRelic
             # exceptions without referencing their classes (since they don't
             # exist in MRI).  It also prevents us from swallowing signals or
             # other nasty things that can happen when you rescue Exception.
-            NewRelic::Control.instance.log.warn(
+            ::NewRelic::Agent.logger.warn(
               "Error collecting thread backtraces: #{e.class.name}: #{e.message}")
-            NewRelic::Control.instance.log.debug( e.backtrace.join("\n") )
+            ::NewRelic::Agent.logger.debug( e.backtrace.join("\n") )
 
             raise e if e.class.ancestors.include? Exception
           end

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

@@ -51,7 +51,7 @@ module Agent
       end
 
       def log_added_sampler(type, sampler)
-        log.debug "Adding #{type} sampler: #{sampler.id}"
+        ::NewRelic::Agent.logger.debug "Adding #{type} sampler: #{sampler.id}"
       end
 
       public
@@ -79,9 +79,7 @@ module Agent
             sampled_item.poll
             false # it's okay.  don't delete it.
           rescue => e
-            log.error "Removing #{sampled_item} from list"
-            log.error e
-            log.debug e.backtrace.to_s
+            ::NewRelic::Agent.logger.warn "Removing #{sampled_item} from list", e
             true # remove the sampler
           end
         end

data/lib/new_relic/agent/thread.rb

@@ -3,7 +3,7 @@ module NewRelic
 
     class AgentThread < ::Thread
       def initialize(label)
-        NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
+        ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
         self[:newrelic_label] = label
         super
       end
@@ -19,8 +19,13 @@ module NewRelic
       end
 
       def self.scrub_backtrace(thread, profile_agent_code)
-        return thread.backtrace if profile_agent_code
-        thread.backtrace.select {|t| t !~ /\/newrelic_rpm-\d/ }
+        begin
+          bt = thread.backtrace
+        rescue Exception => e
+          ::NewRelic::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
+        end
+        return nil unless bt
+        profile_agent_code ? bt : bt.select { |t| t !~ /\/newrelic_rpm-\d/ }
       end
     end
   end

data/lib/new_relic/agent/thread_profiler.rb

@@ -14,10 +14,10 @@ module NewRelic
 
       def start(profile_id, duration, interval, profile_agent_code)
         if !ThreadProfiler.is_supported?
-          log.debug("Not starting thread profile as it isn't supported on this environment")
+          ::NewRelic::Agent.logger.debug("Not starting thread profile as it isn't supported on this environment")
           @profile = nil
         else
-          log.debug("Starting thread profile. profile_id=#{profile_id}, duration=#{duration}")
+          ::NewRelic::Agent.logger.debug("Starting thread profile. profile_id=#{profile_id}, duration=#{duration}")
           @profile = ThreadProfile.new(profile_id, duration, interval, profile_agent_code)
           @profile.run
         end
@@ -45,12 +45,25 @@ module NewRelic
         name = command["name"]
         arguments = command["arguments"]
 
-        case name
-          when "start_profiler"
-            start_unless_running_and_notify(command_id, arguments, &notify_results)
+        if (ThreadProfiler.is_supported?)
+          case name
+            when "start_profiler"
+              start_unless_running_and_notify(command_id, arguments, &notify_results)
 
-          when "stop_profiler"
-            stop_and_notify(command_id, arguments, &notify_results)
+            when "stop_profiler"
+              stop_and_notify(command_id, arguments, &notify_results)
+          end
+        else
+          msg = <<-EOF
+Thread profiling is only supported on 1.9.2 and greater versions of Ruby.
+We detected running agents capable of profiling, but the profile started with
+an agent running Ruby #{RUBY_VERSION}.
+
+Profiling again might select an appropriate agent, but we recommend running a
+consistent version of Ruby across your application for better results.
+EOF
+          ::NewRelic::Agent.logger.debug(msg)
+          notify_results.call(command_id, msg) if !notify_results.nil?
         end
       end
 
@@ -72,7 +85,7 @@ module NewRelic
 
         if running?
           msg = "Profile already in progress. Ignoring agent command to start another."
-          log.debug(msg)
+          ::NewRelic::Agent.logger.debug(msg)
           yield(command_id, msg) if block_given?
         else
           start(profile_id, duration, interval, profile_agent_code)
@@ -86,9 +99,6 @@ module NewRelic
         yield(command_id) if block_given?
       end
 
-      def log
-        NewRelic::Agent.logger
-      end
     end
 
     class ThreadProfile
@@ -117,6 +127,7 @@ module NewRelic
 
         @poll_count = 0
         @sample_count = 0
+        @failure_count = 0
       end
 
       def run
@@ -129,24 +140,31 @@ module NewRelic
 
               @poll_count += 1
               AgentThread.list.each do |t|
-                @sample_count += 1
-
                 bucket = AgentThread.bucket_thread(t, @profile_agent_code)
-                backtrace = AgentThread.scrub_backtrace(t, @profile_agent_code)
-                aggregate(backtrace, @traces[bucket]) unless bucket == :ignore
+                if bucket != :ignore
+                  backtrace = AgentThread.scrub_backtrace(t, @profile_agent_code)
+                  if backtrace.nil?
+                    @failure_count += 1
+                  else
+                    @sample_count += 1
+                    aggregate(backtrace, @traces[bucket])
+                  end
+                end
               end
             end
           end
 
           mark_done
-          log.debug("Finished thread profile. Will send with next harvest.")
+          ::NewRelic::Agent.logger.debug("Finished thread profile. #{@sample_count} backtraces, #{@failure_count} failures. Will send with next harvest.")
+          NewRelic::Agent.instance.stats_engine.
+            record_supportability_metrics_count(@failure_count, "ThreadProfiler/BacktraceFailures")
         end
       end
 
       def stop
         @worker_loop.stop
         mark_done
-        log.debug("Stopping thread profile.")
+        ::NewRelic::Agent.logger.debug("Stopping thread profile.")
       end
 
       def aggregate(trace, trees=@traces[:request], parent=nil)
@@ -184,7 +202,7 @@ module NewRelic
 
       THREAD_PROFILER_NODES = 20_000
 
-      def to_compressed_array
+      def to_collector_array(encoder)
         prune!(THREAD_PROFILER_NODES)
 
         traces = {
@@ -196,8 +214,8 @@ module NewRelic
 
         [[@profile_id,
           @start_time.to_f, @stop_time.to_f,
-          @poll_count, 
-          ThreadProfile.compress(JSON.dump(traces)),
+          @poll_count,
+          encoder.encode(traces),
           @sample_count, 0]]
       end
 
@@ -223,10 +241,6 @@ module NewRelic
         nodes.map { |n| [n, flattened_nodes(n.children)] }.flatten
       end
 
-      def self.compress(json)
-        compressed = Base64.encode64(Zlib::Deflate.deflate(json, Zlib::DEFAULT_COMPRESSION))
-      end
-
       def self.parse_backtrace(trace)
         trace.map do |line|
           line =~ /(.*)\:(\d+)\:in `(.*)'/
@@ -287,9 +301,6 @@ module NewRelic
         end
       end
 
-      def log
-        NewRelic::Agent.logger
-      end
     end
   end
 end

data/lib/new_relic/agent/transaction_info.rb

@@ -33,7 +33,7 @@ module NewRelic
       def duration
         Time.now - start_time
       end
-      
+
       def ignore_end_user?
         @ignore_end_user
       end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -37,7 +37,7 @@ module NewRelic
           @current_segment.add_called_segment(segment)
           @current_segment = segment
           if @sample.count_segments == segment_limit
-            NewRelic::Control.instance.log.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
+            ::NewRelic::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
           end
           @current_segment
         end
@@ -56,8 +56,7 @@ module NewRelic
         # This should never get called twice, but in a rare case that we can't reproduce in house it does.
         # log forensics and return gracefully
         if @sample.frozen?
-          log = NewRelic::Control.instance.log
-          log.error "Unexpected double-freeze of Transaction Trace Object: \n#{@sample.to_s}"
+          ::NewRelic::Agent.logger.error "Unexpected double-freeze of Transaction Trace Object: \n#{@sample.to_s}"
           return
         end
         @sample.root_segment.end_trace(time.to_f - @sample_start)

data/lib/new_relic/agent/transaction_sampler.rb

@@ -45,23 +45,19 @@ module NewRelic
         Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
           if enabled
             threshold = Agent.config[:'transaction_tracer.transaction_threshold']
-            log.debug "Transaction tracing threshold is #{threshold} seconds."
+            ::NewRelic::Agent.logger.debug "Transaction tracing threshold is #{threshold} seconds."
           else
-            log.debug "Transaction traces will not be sent to the New Relic service."
+            ::NewRelic::Agent.logger.debug "Transaction traces will not be sent to the New Relic service."
           end
         end
 
         Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
           if config == 'raw'
-            log.warn("Agent is configured to send raw SQL to the service")
+            ::NewRelic::Agent.logger.warn("Agent is configured to send raw SQL to the service")
           end
         end
       end
 
-      def log
-        NewRelic::Control.instance.log
-      end
-
       # Returns the current sample id, delegated from `builder`
       def current_sample_id
         b=builder

data/lib/new_relic/agent/worker_loop.rb

@@ -9,7 +9,6 @@ module NewRelic
       # Optional argument :duration (in seconds) for how long the worker loop runs
       # or :limit (integer) for max number of iterations
       def initialize(opts={})
-        @log = log
         @should_run = true
         @next_invocation_time = Time.now
         @period = 60.0
@@ -23,11 +22,6 @@ module NewRelic
         @@lock ||= Mutex.new
       end
 
-      # a helper to access the NewRelic::Control.instance.log
-      def log
-        NewRelic::Control.instance.log
-      end
-
       # Run infinitely, calling the registered tasks at their specified
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
@@ -75,23 +69,21 @@ module NewRelic
             @task.call
           end
         rescue ServerError => e
-          log.debug "Server Error: #{e}"
+          ::NewRelic::Agent.logger.debug "Server Error:", e
         rescue NewRelic::Agent::ForceRestartException, NewRelic::Agent::ForceDisconnectException
           # blow out the loop
           raise
         rescue RuntimeError => e
           # This is probably a server error which has been logged in the server along
           # with your account name.
-          log.error "Error running task in worker loop, likely a server error (#{e})"
-          log.debug e.backtrace.join("\n")
+          ::NewRelic::Agent.logger.error "Error running task in worker loop, likely a server error:", e
         rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
           # Want to ignore these because they are handled already
         rescue SystemExit, NoMemoryError, SignalException
           raise
         rescue => e
           # Don't blow out the stack for anything that hasn't already propagated
-          log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}"
-          log.debug e.backtrace.join("\n")
+          ::NewRelic::Agent.logger.error "Error running task in Agent Worker Loop:", e
         end
         now = Time.now
         while @next_invocation_time <= now && @period > 0

data/lib/new_relic/control.rb

@@ -11,7 +11,6 @@ require 'net/https'
 require 'logger'
 require 'new_relic/control/frameworks'
 require 'new_relic/control/profiling'
-require 'new_relic/control/logging_methods'
 require 'new_relic/control/server_methods'
 require 'new_relic/control/instrumentation'
 require 'new_relic/control/class_methods'
@@ -35,7 +34,6 @@ module NewRelic
     # extend ClassMethods
     # include InstanceMethods
     # include Profiling
-    # include LoggingMethods
     # include Configuration
     # include ServerMethods
     # include Instrumentation

data/lib/new_relic/control/class_methods.rb

@@ -9,6 +9,12 @@ module NewRelic
         @instance ||= create && new_instance
       end
 
+      # clear out memoized Control and LocalEnv instances
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+
       # Access the LocalEnvironment singleton, lazy initialized
       def local_env
         @local_env ||= NewRelic::LocalEnvironment.new
@@ -16,10 +22,10 @@ module NewRelic
 
       # Create the concrete class for environment specific behavior
       def new_instance
-        if local_env.framework == :test
+        if Agent.config[:framework] == :test
           load_test_framework
         else
-          load_framework_class(local_env.framework).new(local_env)
+          load_framework_class(Agent.config[:framework]).new(local_env)
         end
       end