newrelic_rpm 3.1.0 → 3.1.1.beta1

data/lib/new_relic/control/frameworks/rails.rb

@@ -1,10 +1,10 @@
-# Control subclass instantiated when Rails is detected.  Contains
-# Rails specific configuration, instrumentation, environment values,
-# etc.
 require 'new_relic/control/frameworks/ruby'
 module NewRelic
   class Control
     module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails specific configuration, instrumentation, environment values,
+      # etc.
       class Rails < NewRelic::Control::Frameworks::Ruby
 
         def env
@@ -139,8 +139,8 @@ module NewRelic
 
         def _install_instrumentation
           super
-          if defined?(Rails) && Rails.respond_to?(:configuration) && Rails.configuration.respond_to?(:after_initialize)
-            Rails.configuration.after_initialize do
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration) && ::Rails.configuration.respond_to?(:after_initialize)
+            ::Rails.configuration.after_initialize do
               DependencyDetection.detect!
             end
           end

data/lib/new_relic/control/frameworks/rails3.rb

@@ -1,10 +1,12 @@
-# Control subclass instantiated when Rails is detected.  Contains
-# Rails specific configuration, instrumentation, environment values,
-# etc.
 require 'new_relic/control/frameworks/rails'
 module NewRelic
   class Control
     module Frameworks
+      # Control subclass instantiated when Rails is detected.  Contains
+      # Rails 3.0+  specific configuration, instrumentation, environment values,
+      # etc. Many methods are inherited from the
+      # NewRelic::Control::Frameworks::Rails class, where the two do
+      # not differ
       class Rails3 < NewRelic::Control::Frameworks::Rails
 
         def env

data/lib/new_relic/control/frameworks/ruby.rb

@@ -1,11 +1,11 @@
-# A control used when no framework is detected.
-# Looks for a newrelic.yml file in several locations
-# including ./, ./config, $HOME/.newrelic and $HOME/.
-# It loads the settings from the newrelic.yml section
-# based on the value of RUBY_ENV or RAILS_ENV.
 module NewRelic
   class Control
     module Frameworks
+      # A control used when no framework is detected - the default.
+      # Looks for a newrelic.yml file in several locations including
+      # ./, ./config, $HOME/.newrelic and $HOME/.  It loads the
+      # settings from the newrelic.yml section based on the value of
+      # RUBY_ENV or RAILS_ENV.
       class Ruby < NewRelic::Control
 
         def env

data/lib/new_relic/control/frameworks/sinatra.rb

@@ -3,16 +3,13 @@ require 'new_relic/control/frameworks/ruby'
 module NewRelic
   class Control
     module Frameworks
+      # Contains basic control logic for Sinatra
       class Sinatra < NewRelic::Control::Frameworks::Ruby
 
         def env
           @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
         end
 
-        # This is the control used when starting up in the context of
-        # The New Relic Infrastructure Agent.  We want to call this
-        # out specifically because in this context we are not monitoring
-        # the running process, but actually external things.
         def init_config(options={})
           super
         end

data/lib/new_relic/control/instance_methods.rb

@@ -1,11 +1,18 @@
 module NewRelic
   class Control
+    # Contains methods that relate to the runtime usage of the control
+    # object. Note that these are subject to override in the
+    # NewRelic::Control::Framework classes that are actually instantiated
     module InstanceMethods
       # 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
 
+      # The local environment contains all the information we report
+      # to the server about what kind of application this is, what
+      # gems and plugins it uses, and many other kinds of
+      # machine-dependent information useful in debugging
       attr_reader :local_env
 
 
@@ -90,13 +97,14 @@ module NewRelic
         # dispatcher running
         return true if @local_env.dispatcher != nil
       end
-
+      
+      # Asks the LocalEnvironment instance which framework should be loaded
       def app
         @local_env.framework
       end
       alias framework app
-
-      def to_s
+      
+      def to_s #:nodoc:
         "Control[#{self.app}]"
       end
 
@@ -105,7 +113,9 @@ module NewRelic
       # Append framework specific environment information for uploading to
       # the server for change detection.  Override in subclasses
       def append_environment_info; end
-
+      
+      # Asks bundler to tell us which gemspecs are loaded in the
+      # current process
       def bundler_gem_list
         if defined?(Bundler) && Bundler.instance_eval do @load end
           Bundler.load.specs.map do | spec |
@@ -116,11 +126,15 @@ module NewRelic
           []
         end
       end
-
+      
+      # path to the config file, defaults to the "#{root}/config/newrelic.yml"
       def config_file
         File.expand_path(File.join(root,"config","newrelic.yml"))
       end
-
+      
+      # initializes the control instance with a local environment and
+      # an optional config file override. Checks for the config file
+      # and loads it.
       def initialize local_env, config_file_override=nil
         @local_env = local_env
         @instrumentation_files = []
@@ -140,11 +154,13 @@ module NewRelic
         puts e.backtrace.join("\n")
         raise "Error reading newrelic.yml file: #{e}"
       end
-
+      
       def root
         '.'
       end
 
+      # Delegates to the class method newrelic_root, implemented by
+      # each subclass
       def newrelic_root
         self.class.newrelic_root
       end

data/lib/new_relic/control/instrumentation.rb

@@ -1,6 +1,17 @@
 module NewRelic
   class Control
+    # Contains methods that relate to adding and executing files that
+    # contain instrumentation for the Ruby Agent
     module Instrumentation
+
+      # Adds a list of files in Dir.glob format
+      # (e.g. '/app/foo/**/*_instrumentation.rb')
+      # This requires the files within a rescue block, so that any
+      # errors within instrumentation files do not affect the overall
+      # agent or application in which it runs.
+      #
+      # Logs at debug level for each file loaded, and logs errors in
+      # file loading at error level
       def load_instrumentation_files pattern
         Dir.glob(pattern) do |file|
           begin
@@ -23,8 +34,11 @@ module NewRelic
 
       # 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.
+      # instrumentation, otherwise instrumentation files specified
+      # here will be deferred until all instrumentation is run
       #
+      # This happens after the agent has loaded and all dependencies
+      # are ready to be instrumented
       def add_instrumentation pattern
         if @instrumented
           load_instrumentation_files pattern
@@ -32,11 +46,16 @@ module NewRelic
           @instrumentation_files << pattern
         end
       end
-
+      
+      # Signals the agent that it's time to actually load the
+      # instrumentation files. May be overridden by subclasses
       def install_instrumentation
         _install_instrumentation
       end
-
+      
+      # adds samplers to the stats engine so that they run every
+      # minute. This is dynamically recognized by any class that
+      # subclasses NewRelic::Agent::Sampler
       def load_samplers
         agent = NewRelic::Agent.instance
         NewRelic::Agent::Sampler.sampler_classes.each do | subclass |

data/lib/new_relic/control/logging_methods.rb

@@ -1,12 +1,16 @@
 
 module NewRelic
   class Control
+    # Contains methods that relate to locating, creating, and writing
+    # to the log file and/or standard out
     module LoggingMethods
 
       attr_accessor :log_file
-
+      
+      # returns either the log set up with setup_log or else a new
+      # logger pointing to standard out, if we're trying to log before
+      # a log exists
       def log
-        # If we try to get a log before one has been set up, return a stdout log
         unless @log
           l = Logger.new(STDOUT)
           l.level = Logger::INFO
@@ -24,12 +28,18 @@ module NewRelic
         return unless should_log?
         log.send level, msg if @log
       end
-
+      
+      # true if the agent has settings, and the agent is enabled,
+      # otherwise false
       def should_log?
         @settings && agent_enabled?
       end
 
       # set the log level as specified in the config file
+      #
+      # Possible values are from the Logger class: debug, info, warn,
+      #error, and fatal
+      # Defaults to info
       def set_log_level!(logger)
         case fetch("log_level","info").downcase
           when "debug" then logger.level = Logger::DEBUG
@@ -42,7 +52,7 @@ module NewRelic
         logger
       end
 
-      # change the format just for our logger
+      # patches the logger's format_message method to change the format just for our logger
       def set_log_format!(logger)
         def logger.format_message(severity, timestamp, progname, msg)
           "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
@@ -65,11 +75,17 @@ module NewRelic
         # above
         log
       end
-
+      
+      # simply puts a message to standard out, prepended with the
+      # '** [NewRelic]' sigil to make sure people know where the message
+      # comes from. This should be used sparingly
       def to_stdout(msg)
         STDOUT.puts "** [NewRelic] " + msg
       end
-
+      
+      # sets up and caches the log path, attempting to create it if it
+      #does not exist. this comes from the configuration variable
+      #'log_file_path' in the configuration file.
       def log_path
         return @log_path if @log_path
         @log_path = File.expand_path(fetch('log_file_path', 'log/'))
@@ -78,7 +94,9 @@ module NewRelic
         end
         @log_path
       end
-
+      
+      # Retrieves the log file's name from the config file option
+      #'log_file_name', defaulting to 'newrelic_agent.log'
       def log_file_name
         fetch('log_file_name', 'newrelic_agent.log')
       end

data/lib/new_relic/control/server_methods.rb

@@ -7,13 +7,16 @@ module NewRelic
     end
 
     ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
-
+    
+    # Contains methods that deal with connecting to the server
     module ServerMethods
-
+      
       def server
         @remote_server ||= server_from_host(nil)
       end
-
+      
+      # the server we should contact for api requests, like uploading
+      # deployments and the like
       def api_server
         api_host = self['api_host'] || 'rpm.newrelic.com'
         @api_server ||=
@@ -22,12 +25,17 @@ module NewRelic
         (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
         nil
       end
-
+      
+      # a new instances of the proxy server - this passes through if
+      # there is no proxy, otherwise it has proxy configuration
+      # information pulled from the config file
       def proxy_server
         @proxy_server ||=
           NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
       end
-
+      
+      # turns a hostname into an ip address and returns a
+      # NewRelic::Control::Server that contains the configuration info
       def server_from_host(hostname=nil)
         host = hostname || self['host'] || 'collector.newrelic.com'
 
@@ -66,7 +74,9 @@ module NewRelic
           nil
         end
       end
-
+      
+      # The path to the certificate file used to verify the SSL
+      # connection if verify_peer is enabled
       def cert_file_path
         File.expand_path(File.join(newrelic_root, 'cert', 'cacert.pem'))
       end

data/lib/new_relic/data_serialization.rb

@@ -1,26 +1,68 @@
 require 'fileutils'
 module NewRelic
+  # Handles serialization of data to disk, to save on contacting the
+  # server. Lowers both server and client overhead, if the disk is not overloaded
   class DataSerialization
     module ClassMethods
+      # Check whether the store is too large, too old, or the
+      # semaphore file is too old. If so, we should send the data
+      # right away. If not, we presumably store it for later sending
+      # (handled elsewhere)
       def should_send_data?
-        NewRelic::Control.instance.disable_serialization? || (File.size(file_path) >= max_size)
-      rescue Exception => e
+       NewRelic::Control.instance.disable_serialization? || store_too_large? || store_too_old? || semaphore_too_old?
+      rescue (ENV['CATCH_EXCEPTION'] ? Exception : Class.new) => e
         # This is not what we really should do here, but the fail-safe
         # behavior is to do what the older agent did: send data every
         # time we think we might want to send data.
         true
       end
-      
+
+      # A combined locked read/write from the store file - reduces
+      # contention by not acquiring the lock and file handle twice
       def read_and_write_to_file
         with_locked_store do |f|
           result = (yield get_data_from_file(f))
           f.rewind
-          f.write(dump(result)) if result
+          f.truncate(0)
+          write_contents_nonblockingly(f, dump(result)) if result
         end
       end
-
+      
+      # touches the age file that determines whether we should send
+      # data now or not
+      def update_last_sent!
+        FileUtils.touch(semaphore_path)
+      end
+      
       private
 
+      def store_too_large?
+        size = File.size(file_path) > max_size
+        NewRelic::Control.instance.log.debug("Store was oversize, sending data") if size
+        size
+      rescue Errno::ENOENT
+        FileUtils.touch(file_path)
+        retry
+      end
+
+      def store_too_old?
+        age = (Time.now.to_i - File.mtime(file_path).to_i)
+        NewRelic::Control.instance.log.debug("Store was #{age} seconds old, sending data") if age > 60
+        age > 50
+      rescue Errno::ENOENT
+        FileUtils.touch(file_path)
+        retry
+      end
+
+      def semaphore_too_old?
+        age = (Time.now.to_i - File.mtime(semaphore_path).to_i)
+        NewRelic::Control.instance.log.debug("Pid was #{age} seconds old, sending data") if age > 60
+        age > 60
+      rescue Errno::ENOENT
+        FileUtils.touch(semaphore_path)
+        retry
+      end
+        
       def open_arguments
         if defined?(Encoding)
           [file_path, File::RDWR | File::CREAT, {:internal_encoding => nil}]
@@ -44,38 +86,65 @@ module NewRelic
       end
 
       def get_data_from_file(f)
-        data = f.read
+        data = read_until_eof_error(f)
         result = load(data)
         f.truncate(0)
         result
       end
+
+      def write_contents_nonblockingly(f, string)
+        result = 0
+        while(result < string.length)
+          result += f.write_nonblock(string)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select(nil, [f])
+        retry
+      end
+
+      def read_until_eof_error(f)
+        accumulator = ""
+        while(true)
+          accumulator << f.read_nonblock(10_000)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select([f])
+        retry
+      rescue EOFError
+        accumulator
+      end
       
       def max_size
         10_000
       end
 
-      def create_file_if_needed
-        FileUtils.touch(file_path) unless File.exists?(file_path)
-      end
-
       def dump(object)
         Marshal.dump(object)
       end
 
       def load(dump)
+        if dump.size == 0
+          NewRelic::Control.instance.log.debug("Spool file empty.")
+          return nil
+        end
         Marshal.load(dump)
-      rescue ArgumentError => e
+      rescue ArgumentError, TypeError => e
+        NewRelic::Control.instance.log.error("Error loading data from newrelic_agent_store.db: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.inspect)
         nil
       end
 
       def truncate_file
-        create_file_if_needed
+        FileUtils.touch(file_path)
         File.truncate(file_path, 0)
       end
 
       def file_path
-        # TODO get configuration from main control
-        './log/newrelic_agent_store.db'
+        "#{NewRelic::Control.instance.log_file_path}/newrelic_agent_store.db"
+      end
+
+      def semaphore_path
+        "#{NewRelic::Control.instance.log_file_path}/newrelic_agent_store.age"
       end
     end
     extend ClassMethods