newrelic_rpm 2.9.9 → 2.10.3

data/lib/new_relic/agent/worker_loop.rb

@@ -1,4 +1,5 @@
-module NewRelic::Agent
+module NewRelic
+module Agent
   
   # A worker loop executes a set of registered tasks on a single thread.  
   # A task is a proc or block with a specified call period in seconds.  
@@ -13,7 +14,7 @@ module NewRelic::Agent
       @should_run = true
       @pid = $$
     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
@@ -30,89 +31,89 @@ module NewRelic::Agent
     def stop
       @should_run = false
     end
-
+    
     MIN_CALL_PERIOD = 0.1
     
     # add a task to the worker loop.  The task will be called approximately once
     # every call_period seconds.  The task is passed as a block
-    def add_task(call_period, &task_proc)
+    def add_task(call_period, desc="", &task_proc)
       if call_period < MIN_CALL_PERIOD
         raise ArgumentError, "Invalid Call Period (must be > #{MIN_CALL_PERIOD}): #{call_period}" 
       end
-      @tasks << LoopTask.new(call_period, &task_proc)
+      @tasks << LoopTask.new(call_period, desc, &task_proc)
     end
-      
+    
     private 
-      def next_task
-        @tasks.inject do |soonest, task|
-            (task.next_invocation_time < soonest.next_invocation_time) ? task : soonest
-        end
+    def next_task
+      @tasks.inject do |soonest, task|
+       (task.next_invocation_time < soonest.next_invocation_time) ? task : soonest
       end
+    end
     
-      def run_next_task
-        if @tasks.empty?
-          sleep 5.0
-          return
-        end
-        
-        # get the next task to be executed, which is the task with the lowest (ie, soonest)
-        # next invocation time.
-        task = next_task
-        
-        # sleep in chunks no longer than 1 second
-        while Time.now < task.next_invocation_time
-          
-          # sleep until this next task's scheduled invocation time
-          sleep_time = [task.next_invocation_time - Time.now, 0.000001].max
-          sleep_time = (sleep_time > 1) ? 1 : sleep_time
-
-          sleep sleep_time
-            
-          return if !keep_running
-        end
-        
-        begin
-          # wrap task execution in a block that won't collect a TT
-          NewRelic::Agent.disable_transaction_tracing do
-            task.execute
-          end
-        rescue ServerError => e
-          log.debug "Server Error: #{e}"
-        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
-            log.debug e.backtrace.join("\n")
-          end
-        rescue Timeout::Error, NewRelic::Agent::IgnoreSilentlyException
-          # Want to ignore these because they are handled already
-        rescue ScriptError, StandardError => e 
-          log.error "Error running task in Agent Worker Loop (#{e.class}): #{e} " 
-          log.debug e.backtrace.join("\n")
-        end
+    def run_next_task
+      if @tasks.empty?
+        sleep 5.0
+        return
       end
       
-      class LoopTask
+      # get the next task to be executed, which is the task with the lowest (ie, soonest)
+      # next invocation time.
+      task = next_task
       
-        def initialize(call_period, &task_proc)
-          @call_period = call_period
-          @last_invocation_time = Time.now
-          @task = task_proc
-        end
+      while Time.now < task.next_invocation_time
+        
+        # sleep until this next task's scheduled invocation time
+        sleep_time = task.next_invocation_time - Time.now
+        sleep sleep_time if sleep_time > 0
+        return if !keep_running
+      end
       
-        def next_invocation_time
-          @last_invocation_time + @call_period
+      begin
+        task.execute if keep_running
+      rescue ServerError => e
+        log.debug "Server Error: #{e}"
+      rescue NewRelic::Agent::ForceRestartException => e
+        # 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
+          log.debug e.backtrace.join("\n")
         end
+      rescue Timeout::Error, NewRelic::Agent::IgnoreSilentlyException
+        # 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")
+      end
+    end
+    
+    class LoopTask
       
-        def execute
-          @last_invocation_time = Time.now
-          @task.call
-        end
+      def initialize(call_period, desc="", &task_proc) 
+        @call_period = call_period
+        @last_invocation_time = Time.now
+        @task = task_proc
+        @desc = desc
       end
+      def to_s
+        "Task[#{@desc}]"
+      end
+      def next_invocation_time
+        @last_invocation_time + @call_period
+      end
+      
+      def execute
+        @last_invocation_time = Time.now
+        @task.call
+      end
+    end
   end
 end
+end

data/lib/new_relic/commands/deployments.rb

@@ -87,7 +87,7 @@ module NewRelic
           response = http.request(request)
           
           if response.is_a? Net::HTTPSuccess
-            info "Recorded deployment to NewRelic RPM (#{@description || Time.now })"
+            info "Recorded deployment to '#{@appname}' (#{@description || Time.now })"
           else
             err_string = [ "Unexpected response from server: #{response.code}: #{response.message}" ]
             begin
@@ -107,7 +107,7 @@ module NewRelic
           raise
         rescue Exception => e
           err "Unexpected error attempting to connect to #{config.api_server}"
-          info e.backtrace.join("\n")
+          info "#{e}: #{e.backtrace.join("\n   ")}"
           raise CommandFailure.new(e.to_s, -1)
         end
       end
@@ -115,9 +115,9 @@ module NewRelic
       private
       
       def options
-        OptionParser.new "Usage: #{self.class.command} [OPTIONS] [description] ", 40 do |o|
+        OptionParser.new %Q{Usage: #{$0} [OPTIONS] ["description"] }, 40 do |o|
           o.separator "OPTIONS:"
-          o.on("-a", "--appname=DIR", String,
+          o.on("-a", "--appname=NAME", String,
              "Set the application name.",
              "Default is app_name setting in newrelic.yml") { | e | @appname = e }
           o.on("-e", "--environment=name", String,
@@ -131,8 +131,6 @@ module NewRelic
           o.on("-c", "--changes", 
              "Read in a change log from the standard input") { @changelog = STDIN.read }
           o.on("-h", "--help", "Print this help") { raise CommandFailure.new(o.help, 0) }
-          o.separator ""
-          o.separator 'description = "short text"'
         end
       end
       

data/lib/new_relic/control.rb

@@ -6,7 +6,6 @@ require 'socket'
 require 'net/https'
 require 'logger'
 
-
 module NewRelic 
   
   # The Control is a singleton responsible for the startup and
@@ -18,20 +17,38 @@ module NewRelic
   # 
   class Control
     
+    # A flag used in dev mode to indicate if profiling is available
+    def profiling?
+      @profiling
+    end
+    
+    def profiling_available?
+      @profiling_available ||= 
+      begin
+        require 'ruby-prof'
+        true
+      rescue LoadError; end
+    end
+    # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+    # loaded a true value is ignored.
+    def profiling=(val)
+      @profiling = profiling_available? && val && defined?(RubyProf)
+    end
+    
     attr_accessor :log_file
     # The env is the setting used to identify which section of the newrelic.yml
     # to load.  This defaults to a framework specific value, such as ENV['RAILS_ENV']
     # but can be overridden as long as you set it before calling #init_plugin
     attr_writer :env
     attr_reader :local_env
-
-    # Structs holding info for the remote server and proxy server 
+    
+    # Structs holding info for the remote server and proxy server
     class Server < Struct.new :name, :port, :ip #:nodoc:
       def to_s; "#{name}:#{port}"; end
     end
     
     ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
-
+    
     # Access the Control singleton, lazy initialized
     def self.instance
       @instance ||= new_instance
@@ -57,11 +74,15 @@ module NewRelic
     # is called at most once.
     #
     def init_plugin(options={})
+      options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
+ 
       require 'new_relic/agent'
       # Merge the stringified options into the config as overrides:
       logger_override = options.delete(:log)
-      environment_name = options.delete(:env)
-      self.env = environment_name if environment_name
+      environment_name = options.delete(:env) and self.env = environment_name
+      dispatcher = options.delete(:dispatcher) and @local_env.dispatcher = dispatcher 
+      dispatcher_instance_id = options.delete(:dispatcher_instance_id) and @local_env.dispatcher_instance_id = dispatcher_instance_id
+
       # Clear out the settings, if they've already been loaded.  It may be that
       # between calling init_plugin the first time and the second time, the env
       # has been overridden
@@ -73,6 +94,10 @@ module NewRelic
         # Try to grab the log filename
         @log_file = @log.instance_eval { @logdev.filename rescue nil }
       end
+      # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
+      # methods in the module methods.
+      Module.send :include, NewRelic::Agent::MethodTracer::ClassMethods
+      Module.send :include, NewRelic::Agent::MethodTracer::InstanceMethods
       init_config(options)
       if agent_enabled? && !@started
         setup_log unless logger_override
@@ -102,7 +127,14 @@ module NewRelic
         @settings = (@yaml && merge_defaults(@yaml[env])) || {}
         # At the time we bind the settings, we also need to run this little piece
         # of magic which allows someone to augment the id with the app name, necessary
-        @local_env.dispatcher_instance_id << ":#{app_names.first}" if self['multi_homed'] && app_names.size > 0
+        if self['multi_homed'] && app_names.size > 0
+          if @local_env.dispatcher_instance_id
+            @local_env.dispatcher_instance_id << ":#{app_names.first}"
+          else
+            @local_env.dispatcher_instance_id = app_names.first
+          end
+        end
+        
       end
       @settings
     end
@@ -124,6 +156,10 @@ module NewRelic
     ###################################
     # Agent config conveniences
     
+    def apdex_t
+      # Always initialized with a default
+      fetch('apdex_t').to_f
+    end
     def license_key
       fetch('license_key')
     end
@@ -132,11 +168,22 @@ module NewRelic
     end
     # True if we are sending data to the server, monitoring production
     def monitor_mode?
-      fetch('enabled', nil)
+      fetch('monitor_mode', fetch('enabled'))
     end
     # True if we are capturing data and displaying in /newrelic
     def developer_mode?
-      fetch('developer', nil)
+      fetch('developer_mode', fetch('developer'))
+    end
+    # True if the app runs in multi-threaded mode
+    def multi_threaded?
+      fetch('multi_threaded')
+    end
+    # True if we should view files in textmate
+    def use_textmate?
+      fetch('textmate')
+    end
+    def post_size_limit
+      fetch('post_size_limit', 2 * 1024 * 1024)
     end
     # True if dev mode or monitor mode are enabled, and we are running
     # inside a valid dispatcher like mongrel or passenger.  Can be overridden
@@ -144,7 +191,7 @@ module NewRelic
     # agent_enabled config option when true or false.
     def agent_enabled?
       return false if !developer_mode? && !monitor_mode?
-      return self['agent_enabled'].to_s =~ /true|on|yes/i if self['agent_enabled'] && self['agent_enabled'] != 'auto'
+      return self['agent_enabled'].to_s =~ /true|on|yes/i if !self['agent_enabled'].nil? && self['agent_enabled'] != 'auto'
       return false if ENV['NEWRELIC_ENABLE'].to_s =~ /false|off|no/i 
       return true if self['monitor_daemons'].to_s =~ /true|on|yes/i
       return true if ENV['NEWRELIC_ENABLE'].to_s =~ /true|on|yes/i
@@ -184,15 +231,15 @@ module NewRelic
     def api_server
       api_host = self['api_host'] || 'rpm.newrelic.com' 
       @api_server ||= 
-        NewRelic::Control::Server.new \
-          api_host, 
-          (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i, 
-          nil
+      NewRelic::Control::Server.new \
+      api_host, 
+       (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i, 
+      nil
     end
     
     def proxy_server
       @proxy_server ||=
-         NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass'] 
+      NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass'] 
     end
     
     def server_from_host(hostname=nil)
@@ -215,6 +262,7 @@ module NewRelic
       http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port, 
                                     proxy_server.user, proxy_server.password)
       http = http_class.new(host.ip || host.name, host.port)
+      log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
       if use_ssl?
         http.use_ssl = true
         if verify_certificate?
@@ -256,50 +304,57 @@ module NewRelic
       # Once we install instrumentation, you can't undo that by installing the shim.
       raise "Cannot install the Agent shim after instrumentation has already been installed!" if @instrumented
       NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
-      Module.send :include, NewRelic::Agent::MethodTracerShim
     end
     
+    # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
+    # This will load the file synchronously if we've already loaded the default
+    # instrumentation.
+    #
+    def add_instrumentation pattern
+      if @instrumented
+        load_instrumentation_files pattern
+      else
+        @instrumentation_files << pattern
+      end
+    end
     def install_instrumentation
       return if @instrumented
       
       @instrumented = true
       
-      Module.send :include, NewRelic::Agent::MethodTracer
-      
       # Instrumentation for the key code points inside rails for monitoring by NewRelic.
       # note this file is loaded only if the newrelic agent is enabled (through config/newrelic.yml)
       instrumentation_path = File.join(File.dirname(__FILE__), 'agent','instrumentation')
-      instrumentation_files = [ ] <<
+      @instrumentation_files <<
       File.join(instrumentation_path, '*.rb') <<
       File.join(instrumentation_path, app.to_s, '*.rb')
-      instrumentation_files.each do | pattern |
-        Dir.glob(pattern) do |file|
-          begin
-            log.debug "Processing instrumentation file '#{file}'"
-            require file
-          rescue => e
-            log.error "Error loading instrumentation file '#{file}': #{e}"
-            log.debug e.backtrace.join("\n")
-          end
-        end
-      end
-      
+      @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
       log.debug "Finished instrumentation"
     end
-
+    
     def load_samplers
       agent = NewRelic::Agent.instance
-      agent.stats_engine.add_sampler NewRelic::Agent::Samplers::MongrelSampler.new if local_env.mongrel
-      agent.stats_engine.add_harvest_sampler NewRelic::Agent::Samplers::CpuSampler.new unless defined? Java
-      begin
-        agent.stats_engine.add_sampler NewRelic::Agent::Samplers::MemorySampler.new
-      rescue RuntimeError => e
-        log.error "Cannot add memory sampling: #{e}"
+      NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
+        begin
+          log.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+          sampler = subclass.new
+          if subclass.use_harvest_sampler?
+            agent.stats_engine.add_harvest_sampler sampler
+            log.debug "Registered #{subclass.name} for harvest time sampling"
+          else            
+            agent.stats_engine.add_sampler sampler
+            log.debug "Registered #{subclass.name} for periodic sampling"
+          end
+        rescue NewRelic::Agent::Sampler::Unsupported => e
+          log.info "#{subclass} sampler not available: #{e}"
+        rescue => e
+          log.error "Error registering sampler: #{e}, #{e.backtrace.join("\n")}"
+        end
       end
     end
-     
+    
     protected
-
+    
     # Append framework specific environment information for uploading to
     # the server for change detection.  Override in subclasses
     def append_environment_info; end
@@ -325,7 +380,7 @@ module NewRelic
       end
       ip_address
     end
-
+    
     def merge_defaults(settings_hash)
       s = {
         'host' => 'collector.newrelic.com',
@@ -338,6 +393,7 @@ module NewRelic
       s['agent_enabled'] = s.delete('monitor_daemons') if s['agent_enabled'].nil? && s.include?('monitor_daemons')
       s
     end
+    
     # Control subclasses may override this, but it can be called multiple times.
     def setup_log
       @log_file = "#{log_path}/newrelic_agent.log"
@@ -348,14 +404,14 @@ module NewRelic
       def @log.format_message(severity, timestamp, progname, msg)
         "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n" 
       end
-    
+      
       # set the log level as specified in the config file
       case fetch("log_level","info").downcase
-        when "debug"; @log.level = Logger::DEBUG
-        when "info"; @log.level = Logger::INFO
-        when "warn"; @log.level = Logger::WARN
-        when "error"; @log.level = Logger::ERROR
-        when "fatal"; @log.level = Logger::FATAL
+      when "debug" then @log.level = Logger::DEBUG
+      when "info" then @log.level = Logger::INFO
+      when "warn" then @log.level = Logger::WARN
+      when "error" then @log.level = Logger::ERROR
+      when "fatal" then @log.level = Logger::FATAL
       else @log.level = Logger::INFO
       end
       @log
@@ -380,26 +436,18 @@ module NewRelic
     # Create the concrete class for environment specific behavior:
     def self.new_instance
       @local_env = NewRelic::LocalEnvironment.new
-      case @local_env.framework
-        when :test
+      if @local_env.framework == :test
         require File.join(newrelic_root, "test", "config", "test_control.rb")
         NewRelic::Control::Test.new @local_env
-        when :merb
-        require 'new_relic/control/merb'
-        NewRelic::Control::Merb.new @local_env
-        when :rails
-        require 'new_relic/control/rails'
-        NewRelic::Control::Rails.new @local_env
-        when :ruby
-        require 'new_relic/control/ruby'
-        NewRelic::Control::Ruby.new @local_env
-      else 
-        raise "Unknown framework: #{@local_env.framework}"
+      else
+        require "new_relic/control/#{@local_env.framework}.rb"
+        NewRelic::Control.const_get(@local_env.framework.to_s.capitalize).new @local_env
       end
     end
     
     def initialize local_env
       @local_env = local_env
+      @instrumentation_files = []
       newrelic_file = config_file
       # Next two are for populating the newrelic.yml via erb binding, necessary
       # when using the default newrelic.yml file
@@ -424,5 +472,18 @@ module NewRelic
     def newrelic_root
       self.class.newrelic_root
     end
+    
+    def load_instrumentation_files pattern
+      Dir.glob(pattern) do |file|
+        begin
+          log.debug "Processing instrumentation file '#{file}'"
+          require file
+        rescue => e
+          log.error "Error loading instrumentation file '#{file}': #{e}"
+          log.debug e.backtrace.join("\n")
+        end
+      end
+    end
+    
   end
 end