newrelic_rpm 3.5.8.72 → 3.6.0.74.beta

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

@@ -1,3 +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 'new_relic/agent/instrumentation/controller_instrumentation'
 
 DependencyDetection.defer do

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

@@ -1,3 +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.
+
 DependencyDetection.defer do
   @name = :sunspot
 

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

@@ -1,3 +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.
+
 DependencyDetection.defer do
   @name = :unicorn
 

data/lib/new_relic/agent/instrumentation.rb

@@ -1,3 +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 'new_relic/agent'
 module NewRelic
   module Agent

data/lib/new_relic/agent/method_tracer.rb

@@ -1,3 +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 'new_relic/control'
 module NewRelic
   module Agent
@@ -70,16 +74,13 @@ module NewRelic
         def trace_execution_unscoped(metric_names, options={})
           return yield unless NewRelic::Agent.is_execution_traced?
           t0 = Time.now
-          stats = Array(metric_names).map do | metric_name |
-            NewRelic::Agent.instance.stats_engine.get_stats_no_scope metric_name
-          end
           begin
             NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force]
             yield
           ensure
             NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
             duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
-            stats.each { |stat| stat.trace_call(duration) }
+            stat_engine.record_metrics(metric_names, duration)
           end
         end
 
@@ -117,7 +118,7 @@ module NewRelic
           def stat_engine
             agent_instance.stats_engine
           end
-          
+
           # returns a scoped metric stat for the specified name
           def get_stats_scoped(first_name, scoped_metric_only)
             stat_engine.get_stats(first_name, true, scoped_metric_only)
@@ -126,25 +127,16 @@ module NewRelic
           def get_stats_unscoped(name)
             stat_engine.get_stats_no_scope(name)
           end
-          
-          # the main statistic we should record in
-          # #trace_execution_scoped - a scoped metric provided by the
-          # first item in the metric array
-          def main_stat(metric, options)
-            get_stats_scoped(metric, options[:scoped_metric_only])
-          end
-          
-          # returns an array containing the first metric, and an array
-          # of other unscoped statistics we should also record along
-          # side it
-          def get_metric_stats(metrics, options)
-            metrics = Array(metrics)
-            first_name = metrics.shift
-            stats = metrics.map do | name |
-              get_stats_unscoped(name)
+
+          def get_metric_specs(first_name, other_names, scope, options)
+            specs = other_names.map { |name| NewRelic::MetricSpec.new(name) }
+            if options[:metric]
+              if scope && scope != first_name
+                specs << NewRelic::MetricSpec.new(first_name, scope)
+              end
+              specs << NewRelic::MetricSpec.new(first_name) unless options[:scoped_metric_only]
             end
-            stats.unshift(main_stat(first_name, options)) if options[:metric]
-            [first_name, stats]
+            specs
           end
           
           # Helper for setting a hash key if the hash key is nil,
@@ -207,7 +199,7 @@ module NewRelic
           # this method fails safely if the header does not manage to
           # push the scope onto the stack - it simply does not trace
           # any metrics.
-          def trace_execution_scoped_footer(t0, first_name, metric_stats, expected_scope, forced, t1=Time.now.to_f)
+          def trace_execution_scoped_footer(t0, first_name, metric_specs, expected_scope, forced, t1=Time.now.to_f)
             log_errors("trace_method_execution footer", first_name) do
               duration = t1 - t0
 
@@ -215,7 +207,9 @@ module NewRelic
               if expected_scope
                 scope = stat_engine.pop_scope(expected_scope, duration, t1)
                 exclusive = duration - scope.children_time
-                metric_stats.each { |stats| stats.trace_call(duration, exclusive) }
+                stat_engine.record_metrics(metric_specs) do |stat|
+                  stat.record_data_point(duration, exclusive)
+                end
               end
             end
           end
@@ -229,17 +223,19 @@ module NewRelic
           # Generally you pass an array of metric names if you want to record the metric under additional
           # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
           # on the server.
-
           def trace_execution_scoped(metric_names, options={})
             return yield if trace_disabled?(options)
             set_if_nil(options, :metric)
             set_if_nil(options, :deduct_call_time_from_parent)
-            first_name, metric_stats = get_metric_stats(metric_names, options)
+            metric_names = Array(metric_names)
+            first_name = metric_names.shift
+            scope = stat_engine.scope_name
             start_time, expected_scope = trace_execution_scoped_header(first_name, options)
-            begin
+            begin 
               yield
             ensure
-              trace_execution_scoped_footer(start_time, first_name, metric_stats, expected_scope, options[:force])
+              metric_specs = get_metric_specs(first_name, metric_names, scope, options)
+              trace_execution_scoped_footer(start_time, first_name, metric_specs, expected_scope, options[:force])
             end
           end
 
@@ -356,14 +352,13 @@ module NewRelic
             "def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
               #{assemble_code_header(method_name, metric_name_code, options)}
               t0 = Time.now
-              stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope \"#{metric_name_code}\"
               begin
                 #{"NewRelic::Agent.instance.push_trace_execution_flag(true)\n" if options[:force]}
                 #{_untraced_method_name(method_name, metric_name_code)}(*args, &block)\n
               ensure
                 #{"NewRelic::Agent.instance.pop_trace_execution_flag\n" if options[:force] }
                 duration = (Time.now - t0).to_f
-                stats.trace_call(duration)
+                NewRelic::Agent.record_metric(\"#{metric_name_code}\", duration)
                 #{options[:code_footer]}
               end
             end"

data/lib/new_relic/agent/new_relic_service.rb

@@ -1,3 +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 'zlib'
 require 'new_relic/agent/audit_logger'
 
@@ -274,12 +278,9 @@ module NewRelic
       end
 
       def record_supportability_metrics(method, now)
-        NewRelic::Agent.instance.stats_engine. \
-          get_stats_no_scope('Supportability/invoke_remote'). \
-          record_data_point((Time.now - now).to_f)
-        NewRelic::Agent.instance.stats_engine. \
-          get_stats_no_scope('Supportability/invoke_remote/' + method.to_s). \
-          record_data_point((Time.now - now).to_f)
+        duration = (Time.now - now).to_f
+        NewRelic::Agent.record_metric('Supportability/invoke_remote', duration)
+        NewRelic::Agent.record_metric('Supportability/invoke_remote/' + method.to_s, duration)
       end
 
       # Raises an UnrecoverableServerException if the post_string is longer

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -1,3 +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 'base64'
 
 module NewRelic
@@ -22,9 +26,27 @@ module NewRelic
         @listener ||= Listener.new
       end
 
+      # Expected initial sequence of events for Pipe usage:
+      #
+      # 1. Pipe is created in parent process (read and write ends open)
+      # 2. Parent process forks
+      # 3. An after_fork hook is invoked in the child
+      # 4. From after_fork hook, child closes read end of pipe, and
+      #    writes a ready marker on the pipe (after_fork_in_child).
+      # 5. The parent receives the ready marker, and closes the write end of the
+      #    pipe in response (after_fork_in_parent).
+      #
+      # After this sequence of steps, an exit (whether clean or not) of the
+      # child will result in the pipe being marked readable again, and giving an
+      # EOF marker (nil) when read. Note that closing of the unused ends of the
+      # pipe in the parent and child processes is essential in order for the EOF
+      # to be correctly triggered. The ready marker mechanism is used because
+      # there's no easy hook for after_fork in the parent process.
       class Pipe
+        READY_MARKER = "READY"
+
         attr_accessor :in, :out
-        attr_reader :last_read
+        attr_reader :last_read, :parent_pid
 
         def initialize
           @out, @in = IO.pipe
@@ -32,6 +54,7 @@ module NewRelic
             @in.set_encoding(::Encoding::ASCII_8BIT)
           end
           @last_read = Time.now
+          @parent_pid = $$
         end
 
         def close
@@ -53,6 +76,15 @@ module NewRelic
           @out.gets("\n\n")
         end
 
+        def after_fork_in_child
+          @out.close unless @out.closed?
+          write(READY_MARKER)
+        end
+
+        def after_fork_in_parent
+          @in.close unless @in.closed?
+        end
+
         def closed?
           @out.closed? && @in.closed?
         end
@@ -68,9 +100,13 @@ module NewRelic
           @select_timeout = 60
         end
 
+        def wakeup
+          wake.in << '.'
+        end
+
         def register_pipe(id)
           @pipes[id] = Pipe.new
-          wake.in << '.'
+          wakeup
         end
 
         def start
@@ -81,9 +117,10 @@ module NewRelic
             loop do
               clean_up_pipes
               pipes_to_listen_to = @pipes.values.map{|pipe| pipe.out} + [wake.out]
-              NewRelic::Agent.instance.stats_engine \
-                .get_stats_no_scope('Supportability/Listeners') \
-                .record_data_point((Time.now - now).to_f) if now
+
+              NewRelic::Agent.record_metric('Supportability/Listeners',
+                (Time.now - now).to_f) if now
+
               if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
                 now = Time.now
                 pipe = ready[0][0]
@@ -94,17 +131,21 @@ module NewRelic
                 end
               end
 
-              break if !should_keep_listening?
+              break unless should_keep_listening?
             end
           end
           sleep 0.001 # give time for the thread to spawn
         end
 
+        def stop_listener_thread
+          @started = false
+          wakeup
+          @thread.join
+        end
+
         def stop
           return unless @started == true
-          @started = false
-          wake.in << '.' unless wake.in.closed?
-          @thread.join # make sure we wait for the thread to exit
+          stop_listener_thread
           close_all_pipes
           @wake.close
           @wake = nil
@@ -129,12 +170,14 @@ module NewRelic
 
         def merge_data_from_pipe(pipe_handle)
           pipe = find_pipe_for_handle(pipe_handle)
-          got = pipe.read
-
-          if got && !got.empty?
-            payload = unmarshal(got)
-            if payload == 'EOF'
-              pipe.close
+          raw_payload = pipe.read
+
+          if raw_payload.nil?
+            pipe.close
+          elsif raw_payload && !raw_payload.empty?
+            payload = unmarshal(raw_payload)
+            if payload == Pipe::READY_MARKER
+              pipe.after_fork_in_parent
             elsif payload
               NewRelic::Agent.agent.merge_data_from([payload[:stats],
                                                      payload[:transaction_traces],

data/lib/new_relic/agent/pipe_service.rb

@@ -1,13 +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.
+
 module NewRelic
   module Agent
     class PipeService
-      attr_reader :channel_id, :buffer
+      attr_reader :channel_id, :buffer, :pipe
       attr_accessor :request_timeout, :agent_id, :collector
 
       def initialize(channel_id)
         @channel_id = channel_id
         @collector = NewRelic::Control::Server.new(:name => 'parent',
                                                    :port => 0)
+        @pipe = NewRelic::Agent::PipeChannelManager.channels[@channel_id]
+        if @pipe && @pipe.parent_pid != $$
+          @pipe.after_fork_in_child
+        else
+          NewRelic::Agent.logger.error("No communication channel to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
+        end
       end
 
       def connect(config)
@@ -36,8 +46,7 @@ module NewRelic
       end
 
       def shutdown(time)
-        write_to_pipe('EOF')
-        NewRelic::Agent::PipeChannelManager.channels[@channel_id].close
+        @pipe.close if @pipe
       end
 
       # Invokes the block it is passed.  This is used to implement HTTP
@@ -54,9 +63,7 @@ module NewRelic
       private
 
       def write_to_pipe(data)
-        NewRelic::Agent::PipeChannelManager.channels[@channel_id].write(data)
-      rescue => e
-        NewRelic::Agent.logger.error("#{e.message}: Unable to send data to parent process, please see https://newrelic.com/docs/ruby/resque-instrumentation for more information.")
+        @pipe.write(data) if @pipe
       end
     end
   end

data/lib/new_relic/agent/rules_engine.rb

@@ -1,3 +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.
+
 module NewRelic
   module Agent
     class RulesEngine

data/lib/new_relic/agent/sampler.rb

@@ -1,3 +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.
+
 # A Sampler is used to capture meaningful metrics in a background thread
 # periodically.  They will either be invoked once a minute just before the
 # data is sent to the agent (default) or every 10 seconds, when #use_harvest_sampler?

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

@@ -1,3 +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 'new_relic/agent/sampler'
 
 module NewRelic
@@ -10,17 +14,20 @@ module NewRelic
           poll
         end
 
-        def user_util_stats
-          stats_engine.get_stats_no_scope("CPU/User/Utilization")
+        def record_user_util(value)
+          NewRelic::Agent.record_metric("CPU/User/Utilization", value)
         end
-        def system_util_stats
-          stats_engine.get_stats_no_scope("CPU/System/Utilization")
+
+        def record_system_util(value)
+          NewRelic::Agent.record_metric("CPU/System/Utilization", value)
         end
-        def usertime_stats
-          stats_engine.get_stats_no_scope("CPU/User Time")
+
+        def record_usertime(value)
+          NewRelic::Agent.record_metric("CPU/User Time", value)
         end
-        def systemtime_stats
-          stats_engine.get_stats_no_scope("CPU/System Time")
+
+        def record_systemtime(value)
+          NewRelic::Agent.record_metric("CPU/System Time", value)
         end
 
         def self.supported_on_this_platform?
@@ -39,13 +46,14 @@ module NewRelic
             usertime = t.utime - @last_utime
             systemtime = t.stime - @last_stime
 
-            systemtime_stats.record_data_point(systemtime) if systemtime >= 0
-            usertime_stats.record_data_point(usertime) if usertime >= 0
+            record_systemtime(systemtime) if systemtime >= 0
+            record_usertime(usertime) if usertime >= 0
 
             # Calculate the true utilization by taking cpu times and dividing by
             # elapsed time X num_processors.
-            user_util_stats.record_data_point usertime / (elapsed * num_processors)
-            system_util_stats.record_data_point systemtime / (elapsed * num_processors)
+
+            record_user_util(usertime / (elapsed * num_processors))
+            record_system_util(systemtime / (elapsed * num_processors))
           end
           @last_utime = t.utime
           @last_stime = t.stime

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

@@ -1,3 +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 'new_relic/agent/sampler'
 require 'new_relic/delayed_job_injection'
 
@@ -18,11 +22,12 @@ module NewRelic
           raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
         end
 
-        def error_stats
-          stats_engine.get_stats("Workers/DelayedJob/failed_jobs", false)
+        def record_failed_jobs(value)
+          NewRelic::Agent.record_metric("Workers/DelayedJob/failed_jobs", value)
         end
-        def locked_job_stats
-          stats_engine.get_stats("Workers/DelayedJob/locked_jobs", false)
+
+        def record_locked_jobs(value)
+          NewRelic::Agent.record_metric("Workers/DelayedJob/locked_jobs", value)
         end
 
         def local_env
@@ -45,8 +50,8 @@ module NewRelic
         end
 
         def poll
-          record error_stats, failed_jobs
-          record locked_job_stats, locked_jobs
+          record_failed_jobs(failed_jobs)
+          record_locked_jobs(locked_jobs)
 
           if @queue
             record_queue_length_across_dimension('queue')
@@ -61,9 +66,11 @@ module NewRelic
           all_count = 0
           Delayed::Job.count(:group => column, :conditions => ['run_at < ? and failed_at is NULL', Time.now]).each do | column_val, count |
             all_count += count
-            record stats_engine.get_stats("Workers/DelayedJob/queue_length/#{column == 'queue' ? 'name' : column}/#{column_val}", false), count
+            metric = "Workers/DelayedJob/queue_length/#{column == 'queue' ? 'name' : column}/#{column_val}"
+            NewRelic::Agent.record_metric(metric, count)
           end
-          record(stats_engine.get_stats("Workers/DelayedJob/queue_length/all", false), all_count)
+          all_metric = "Workers/DelayedJob/queue_length/all"
+          NewRelic::Agent.record_metric(all_metric, all_count)
         end
 
         # Figure out if we get the queues.
@@ -76,10 +83,6 @@ module NewRelic
           end
           @queue ||= false
         end
-
-        def record(stat, size)
-          stat.record_data_point size
-        end
       end
     end
   end