newrelic_rpm 2.12.3 → 2.13.0.beta3

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

@@ -22,21 +22,32 @@ module NewRelic
       #     include NewRelic::Agent::Instrumentation::Rack
       #   end
       #
-      # == Instrumenting Metal
+      # == Instrumenting Metal and Cascading Middlewares
       #
-      # If you are using Metal, be sure and extend the your Metal class with the
-      # Rack instrumentation:
+      # Metal apps and apps belonging to Rack::Cascade middleware
+      # follow a convention of returning a 404 for all requests except
+      # the ones they are set up to handle.  This means that New Relic
+      # needs to ignore these calls when they return a 404.
       #
-      #   require 'newrelic_rpm'
-      #   require 'new_relic/agent/instrumentation/rack'
+      # In these cases, you should not include or extend the Rack
+      # module but instead include
+      # NewRelic::Agent::Instrumentation::ControllerInstrumentation.
+      # Here's how that might look for a Metal app:
+      #
+      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
       #   class MetalApp
+      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
       #     def self.call(env)
-      #       ...
+      #       if should_do_my_thing?
+      #         perform_action_with_newrelic_trace(:category => :rack) do
+      #           return my_response(env)
+      #         end
+      #       else
+      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+      #       end
       #     end
-      #     # Do the include after the call method is defined:
-      #     extend NewRelic::Agent::Instrumentation::Rack
       #   end
-      #
+      #      
       # == Overriding the metric name
       #
       # By default the middleware is identified only by its class, but if you want to 
@@ -53,31 +64,6 @@ module NewRelic
       #     add_transaction_tracer :call, :category => :rack, :name => 'my app'
       #   end
       #
-      # == Cascading or chained calls
-      #
-      # Calls which return a 404 will not have transactions recorded, but 
-      # any calls to instrumented frameworks like ActiveRecord will still be
-      # captured even if the result is a 404.  To avoid this you need to
-      # instrument only when you are the endpoint.
-      #
-      # In these cases, you should not include or extend the Rack module but instead
-      # include NewRelic::Agent::Instrumentation::ControllerInstrumentation.
-      # Here's how that might look:
-      #
-      #   require 'new_relic/agent/instrumentation/controller_instrumentation'
-      #   class MetalApp
-      #     extend NewRelic::Agent::Instrumentation::ControllerInstrumentation
-      #     def self.call(env)
-      #       if should_do_my_thing?
-      #         perform_action_with_newrelic_trace(:category => :rack) do
-      #           return my_response(env)
-      #         end
-      #       else
-      #         return [404, {"Content-Type" => "text/html"}, ["Not Found"]]
-      #       end
-      #     end
-      #   end
-      #      
       module Rack
         def newrelic_request_headers
           @newrelic_request.env

data/lib/new_relic/agent/method_tracer.rb

@@ -67,7 +67,7 @@ module Agent
       #
       def trace_execution_unscoped(metric_names, options={})
         return yield unless NewRelic::Agent.is_execution_traced?
-        t0 = Time.now.to_f
+        t0 = Time.now
         stats = Array(metric_names).map do | metric_name |
           NewRelic::Agent.instance.stats_engine.get_stats_no_scope metric_name
         end
@@ -76,7 +76,7 @@ module Agent
           yield
         ensure
           NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
-          duration = Time.now.to_f - t0              # for some reason this is 3 usec faster than Time - Time
+          duration = (Time.now - t0).to_f              # for some reason this is 3 usec faster than Time - Time
           stats.each { |stat| stat.trace_call(duration) }
         end
       end
@@ -110,7 +110,7 @@ module Agent
         produce_metric               = options[:metric] != false
         deduct_call_time_from_parent = options[:deduct_call_time_from_parent] != false
         scoped_metric_only           = produce_metric && options[:scoped_metric_only]
-        t0 = Time.now.to_f
+        t0 = Time.now
         if metric_names.instance_of? Array
           first_name = metric_names.first
           metric_stats = []
@@ -131,7 +131,7 @@ module Agent
           # Keep a reference to the scope we are pushing so we can do a sanity check making
           # sure when we pop we get the one we 'expected'
           NewRelic::Agent.instance.push_trace_execution_flag(true) if options[:force] 
-          expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(first_name, t0, deduct_call_time_from_parent)
+          expected_scope = NewRelic::Agent.instance.stats_engine.push_scope(first_name, t0.to_f, deduct_call_time_from_parent)
         rescue => e
           NewRelic::Control.instance.log.error("Caught exception in trace_method_execution header. Metric name = #{first_name}, exception = #{e}")
           NewRelic::Control.instance.log.error(e.backtrace.join("\n"))
@@ -140,13 +140,13 @@ module Agent
         begin
           yield
         ensure
-          t1 = Time.now.to_f
-          duration = t1 - t0
+          t1 = Time.now
+          duration = (t1 - t0).to_f
           
           begin
             NewRelic::Agent.instance.pop_trace_execution_flag if options[:force]
             if expected_scope
-              scope = NewRelic::Agent.instance.stats_engine.pop_scope expected_scope, duration, t1
+              scope = NewRelic::Agent.instance.stats_engine.pop_scope expected_scope, duration, t1.to_f
               exclusive = duration - scope.children_time
               metric_stats.each { |stats| stats.trace_call(duration, exclusive) }
             end
@@ -280,14 +280,14 @@ module Agent
           code = <<-CODE
         def #{_traced_method_name(method_name, metric_name_code)}(*args, &block)
           #{header}
-          t0 = Time.now.to_f
+          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.to_f - t0
+            duration = (Time.now - t0).to_f
             stats.trace_call(duration)
             #{options[:code_footer]}
           end

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

@@ -1,37 +1,37 @@
 module NewRelic
   module Agent
     module Samplers
-  class DelayedJobLockSampler < NewRelic::Agent::Sampler
-    def initialize
-      super :delayed_job_lock
-      raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj'] 
-      raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
-    end
-    
-    def stats
-      stats_engine.get_stats("Custom/DJ Locked Jobs", false)
-    end
-    
-    def local_env
-      NewRelic::Control.instance.local_env
-    end
-    
-    def worker_name
-      local_env.dispatcher_instance_id
-    end
-    
-    def locked_jobs
-      Delayed::Job.count(:conditions => {:locked_by => NewRelic::DelayedJobInjection.worker_name})
-    end
-    
-    def self.supported_on_this_platform?
-      defined?(Delayed::Job)
-    end
-    
-    def poll
-      stats.record_data_point locked_jobs
+      class DelayedJobLockSampler < NewRelic::Agent::Sampler
+        def initialize
+          super :delayed_job_lock
+          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj'] 
+          raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
+        end
+        
+        def stats
+          stats_engine.get_stats("Custom/DJ Locked Jobs", false)
+        end
+        
+        def local_env
+          NewRelic::Control.instance.local_env
+        end
+        
+        def worker_name
+          local_env.dispatcher_instance_id
+        end
+        
+        def locked_jobs
+          Delayed::Job.count(:conditions => {:locked_by => NewRelic::DelayedJobInjection.worker_name})
+        end
+        
+        def self.supported_on_this_platform?
+          defined?(Delayed::Job)
+        end
+        
+        def poll
+          stats.record_data_point locked_jobs
+        end
+      end
     end
   end
 end
-end
-end

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

@@ -24,15 +24,15 @@ module Agent
       
       # If use_scope is true, two chained metrics are created, one with scope and one without
       # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
-      def get_stats(metric_name, use_scope = true, scoped_metric_only = false)
-        
+      def get_stats(metric_name, use_scope = true, scoped_metric_only = false, scope = nil)
+        scope ||= scope_name if use_scope
         if scoped_metric_only
-          spec = NewRelic::MetricSpec.new metric_name, scope_name
+          spec = NewRelic::MetricSpec.new metric_name, scope
           stats = stats_hash[spec] ||= NewRelic::MethodTraceStats.new 
         else  
           stats = stats_hash[metric_name] ||= NewRelic::MethodTraceStats.new 
-          if use_scope && scope_name && scope_name != metric_name 
-            spec = NewRelic::MetricSpec.new metric_name, scope_name
+          if scope && scope != metric_name 
+            spec = NewRelic::MetricSpec.new metric_name, scope
             scoped_stats = stats_hash[spec] ||= NewRelic::ScopedMethodTraceStats.new(stats) 
             stats = scoped_stats
           end

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

@@ -45,6 +45,9 @@ module Agent
       
       # Add a sampler to be invoked just before each harvest.
       def add_harvest_sampler sampler
+        harvest_samplers.each do |s|
+          raise "Sampler #{sampler.id} is already registered.  Don't call add_sampler directly anymore." if s.id == sampler.id
+        end
         harvest_samplers << sampler
         sampler.stats_engine = self
         log.debug "Adding harvest time sampler: #{sampler.id.to_s}"

data/lib/new_relic/agent/transaction_sampler.rb

@@ -33,6 +33,11 @@ module Agent
       b and b.sample_id
     end
 
+    def enable
+      @disabled = false
+      NewRelic::Agent.instance.stats_engine.transaction_sampler = self
+    end
+
     def disable
       @disabled = true
       NewRelic::Agent.instance.stats_engine.remove_transaction_sampler self
@@ -44,7 +49,7 @@ module Agent
     end
     
     def notice_first_scope_push(time)
-      start_builder(time) unless disabled
+      start_builder(time.to_f) unless disabled
     end
     
     def notice_push_scope(scope, time=Time.now.to_f)
@@ -124,30 +129,41 @@ module Agent
       builder.set_transaction_cpu_time(cpu_time) if builder
     end
     
+    MAX_DATA_LENGTH = 16384
+    # duration is seconds, float value.
+    def notice_extra_data(message, duration, key, config=nil, config_key=nil)
+      return unless builder
+      segment = builder.current_segment
+      if segment
+        current_message = segment[key]
+        message = current_message + ";\n" + message if current_message
+        if message.length > (MAX_DATA_LENGTH - 4)
+          message = message[0..MAX_DATA_LENGTH - 4] + '...'
+        end
+
+        segment[key] = message
+        segment[config_key] = config if config_key
+        segment[:backtrace] = caller.join("\n") if duration >= @stack_trace_threshold
+      end
+    end
+
+    private :notice_extra_data
         
     # some statements (particularly INSERTS with large BLOBS
     # may be very large; we should trim them to a maximum usable length
     # config is the driver configuration for the connection
+    # duration is seconds, float value.
     MAX_SQL_LENGTH = 16384
     def notice_sql(sql, config, duration)
-      return unless builder
       if Thread::current[:record_sql] != false
-        segment = builder.current_segment
-        if segment
-          current_sql = segment[:sql]
-          sql = current_sql + ";\n" + sql if current_sql
-
-          if sql.length > (MAX_SQL_LENGTH - 4)
-            sql = sql[0..MAX_SQL_LENGTH-4] + '...'
-          end
-          
-          segment[:sql] = sql
-          segment[:connection_config] = config
-          segment[:backtrace] = caller.join("\n") if duration >= @stack_trace_threshold 
-        end
+        notice_extra_data(sql, duration, :sql, config, :connection_config)
       end
     end
 
+    # duration is seconds, float value.
+    def notice_nosql(key, duration)
+      notice_extra_data(key, duration, :key)
+    end
     
     # get the set of collected samples, merging into previous samples,
     # and clear the collected sample list. 

data/lib/new_relic/agent/worker_loop.rb

@@ -9,6 +9,8 @@ module NewRelic
       def initialize
         @log = log
         @should_run = true
+        @next_invocation_time = Time.now 
+        @period = 60.0
       end
       
       def lock
@@ -20,10 +22,10 @@ module NewRelic
       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
-      def run(period, &block)
-        @period = period
-        @next_invocation_time = Time.now + @period
+      # that runs this worker loop.  This will run the task immediately.
+      def run(period=nil, &block)
+        @period = period if period
+        @next_invocation_time = Time.now
         @task = block
         while keep_running do
           now = Time.now
@@ -46,32 +48,31 @@ module NewRelic
       end
       
       def run_task
-        lock.synchronize do
-          @task.call 
-        end
-      rescue ServerError => e
-        log.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.  Check and see if the agent listener is in the
-        # stack trace and log it quietly if it is.
-        message = "Error running task in worker loop, likely a server error (#{e})"
-        if e.backtrace.grep(/agent_listener/).empty?
-          log.error message
-        else
-          log.debug message
+        begin
+          lock.synchronize do
+            @task.call 
+          end
+        rescue ServerError => e
+          log.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")
+        rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
+          # Want to ignore these because they are handled already
+        rescue SystemExit, NoMemoryError, SignalException
+          raise
+        rescue Exception => 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")
         end
-      rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
-        # Want to ignore these because they are handled already
-      rescue ScriptError, StandardError => e 
-        log.error "Error running task in Agent Worker Loop '#{e}': #{e.backtrace.first}" 
-        log.debug e.backtrace.join("\n")
-      ensure
-        while @next_invocation_time < Time.now
+        now = Time.now
+        while @next_invocation_time <= now && @period > 0
           @next_invocation_time += @period
         end        
       end

data/lib/new_relic/collection_helper.rb

@@ -1,5 +1,7 @@
 module NewRelic
   module CollectionHelper
+  DEFAULT_TRUNCATION_SIZE=256
+  DEFAULT_ARRAY_TRUNCATION_SIZE=1024
   # Transform parameter hash into a hash whose values are strictly
   # strings
   def normalize_params(params)
@@ -17,7 +19,7 @@ module NewRelic
         end
         new_params
       when Array
-        params.first(20).map{|item| normalize_params(item)}
+        params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
     else
       truncate(flatten(params))
     end
@@ -50,7 +52,7 @@ module NewRelic
       else "#<#{object.class.to_s}>"
     end
   end
-  def truncate(string, len=256)
+  def truncate(string, len=DEFAULT_TRUNCATION_SIZE)
     case string
     when Symbol then string
     when nil then ""

data/lib/new_relic/command.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+
+# Run the command given by the first argument.  Right
+# now all we have is deployments. We hope to have other
+# kinds of events here later.
+$LOAD_PATH << "#{File.dirname(__FILE__)}/.."
+module NewRelic
+  class Command
+    attr_accessor :leftover
+    # Capture a failure to execute the command.
+    class CommandFailure < StandardError
+      attr_reader :options
+      def initialize message, opt_parser=nil
+        super message
+        @options = opt_parser
+      end
+    end
+    
+    def info(message)
+      STDOUT.puts message
+    end
+    
+    def err(message)
+      STDERR.puts message
+    end    
+    
+    def initialize(command_line_args)
+      if Hash === command_line_args
+        # command line args is an options hash
+        command_line_args.each do | key, value |
+          instance_variable_set "@#{key}", value.to_s if value
+        end
+      else
+        # parse command line args.  Throw an exception on a bad arg.
+        @options = options do | opts |
+          opts.on("-h", "Show this help") {  raise CommandFailure, opts.to_s }
+        end
+        @leftover = @options.parse(command_line_args)
+      end
+    rescue OptionParser::ParseError => e 
+      raise CommandFailure.new e.message, @options
+    end
+    
+    @commands = []
+    def self.inherited(subclass)
+      @commands << subclass
+    end
+    
+    cmds = File.expand_path(File.join(File.dirname(__FILE__), 'commands', '*.rb'))
+    Dir[cmds].each{|command| require command }
+    
+    def self.run
+      
+      @command_names = @commands.map(&:command)
+      
+      extra = []
+      options = ARGV.options do |opts|
+        script_name = File.basename($0)
+        if script_name =~ /newrelic_cmd$/
+          $stdout.puts "warning: the 'newrelic_cmd' script has been renamed 'newrelic'"
+          script_name = 'newrelic'
+        end
+        opts.banner = "Usage: #{script_name} [ #{ @command_names.join(" | ")} ] [options]"
+        opts.separator "use '#{script_name} <command> -h' to see detailed command options"
+        opts
+      end
+      extra = options.order!
+      command = extra.shift
+      # just make it a little easier on them
+      command = 'deployments' if command =~ /deploy/
+      if command.nil?
+        STDERR.puts options
+      elsif !@command_names.include?(command)
+        STDERR.puts "Unrecognized command: #{command}"
+        STDERR.puts options
+      else
+        command_class = @commands.find{ |c| c.command == command} 
+        command_class.new(extra).run
+      end
+    rescue OptionParser::InvalidOption => e
+      raise NewRelic::Command::CommandFailure, e.message
+    end
+  end
+  
+end