newrelic_rpm 2.8.0

data/lib/new_relic/agent/worker_loop.rb

@@ -0,0 +1,128 @@
+
+# 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.  
+module NewRelic::Agent
+  
+  class WorkerLoop
+    include(Synchronize)
+    
+    attr_reader :log
+    attr_reader :pid
+    
+    def initialize(log = Logger.new(STDERR))
+      @tasks = []
+      @log = log
+      @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
+    def run
+      while keep_running do
+        run_next_task
+      end
+    end
+    
+    
+    def keep_running
+      @should_run && (@pid == $$)
+    end
+    
+    
+    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)
+      if call_period < MIN_CALL_PERIOD
+        raise ArgumentError, "Invalid Call Period (must be > #{MIN_CALL_PERIOD}): #{call_period}" 
+      end
+      
+      synchronize do 
+        @tasks << LoopTask.new(call_period, &task_proc)
+      end
+    end
+      
+    private 
+      def get_next_task
+        synchronize do
+          return @tasks.inject do |soonest, task|
+            (task.next_invocation_time < soonest.next_invocation_time) ? task : soonest
+          end
+        end
+      end
+    
+      def run_next_task
+        if @tasks.empty?
+          sleep 1.0
+          return
+        end
+        
+        # get the next task to be executed, which is the task with the lowest (ie, soonest)
+        # next invocation time.
+        task = get_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
+      end
+      
+      class LoopTask
+      
+        def initialize(call_period, &task_proc)
+          @call_period = call_period
+          @last_invocation_time = Time.now
+          @task = task_proc
+        end
+      
+        def next_invocation_time
+          @last_invocation_time + @call_period
+        end
+      
+        def execute
+          @last_invocation_time = Time.now
+          @task.call
+        end
+      end
+  end
+end

data/lib/new_relic/api/deployments.rb

@@ -0,0 +1,92 @@
+# This is a class for executing commands related to deployment 
+# events
+
+require 'optparse'
+
+module NewRelic::API
+  
+  class Deployments
+    
+    def self.command; "deployments"; end 
+      
+    # Initialize the deployment uploader with command line args.
+    # Use -h to see options.  Will possibly exit the VM 
+    def initialize command_line_args
+      @application_id = NewRelic::Config.instance.app_name || RAILS_ENV
+      @user = ENV['USER']
+      @description = options.parse(command_line_args).join " "
+    end
+    
+    # Run the Deployment upload in RPM via Active Resource.
+    # Will possibly print errors and exit the VM
+    def run
+      begin
+        @description = nil if @description.blank?
+        create_params = {
+          :application_id => @application_id, 
+          :host => Socket.gethostname, 
+          :description => @description,
+          :user => @user,
+          :revision => @revision,
+          :changelog => @changelog
+        }
+        d = NewRelicApi::Deployment.create(create_params)
+      rescue Exception => e
+        err "Attempting to connect to #{NewRelicApi::BaseResource.site_url}\nUnable to upload deployment (#{e.message})"
+        info e.backtrace.join("\n")
+        just_exit 1
+      end
+      if d.nil?
+        err "No value returned from create!"
+        just_exit 1
+      elsif d.valid?
+        puts "Recorded deployment to NewRelic RPM (#{d.description})"
+      else
+        err "Could not record deployment to NewRelic RPM:"
+        err d.errors.full_messages.join("\n")
+        just_exit 1
+      end
+    end
+    
+    private
+    
+    def options
+      OptionParser.new "Usage: #{self.class.command} [OPTIONS] [description] ", 40 do |o|
+        o.separator "OPTIONS:"
+        o.on("-a", "--appname=DIR", String,
+             "Specify an application name.",
+             "Default: #{@application_id}") { |@application_id| }
+        o.on("-u", "--user=USER", String,
+             "Specify the user deploying.",
+             "Default: #{ENV['USER']}") { |@user| }
+        o.on("-r", "--revision=REV", String,
+             "Specify the revision being deployed") { |@revision | }
+        o.on("-c", "--changes", 
+             "Read in a change log from the standard input") { @changelog = STDIN.read }
+        o.on("-?", "Print this help") { info o.help; just_exit }
+        o.separator ""
+        o.separator 'description = "short text"'
+      end
+    end
+    
+    def help(message)
+      if message
+        err message
+        info options.help
+        just_exit 1
+      else
+        info options
+        just_exit 0
+      end
+    end
+    def info message
+      STDOUT.puts message
+    end
+    def err message
+      STDERR.puts message
+    end  
+    def just_exit status=0
+      exit status
+    end
+  end
+end

data/lib/new_relic/config.rb

@@ -0,0 +1,194 @@
+require 'yaml'
+#require 'new_relic/version'
+require 'singleton'
+require 'new_relic/agent'
+require 'erb'
+
+# Configuration supports the behavior of the agent which is dependent
+# on what environment is being monitored: rails, merb, ruby, etc
+# It is an abstract factory with concrete implementations under
+# the config folder.
+module NewRelic
+  class Config
+    
+    def self.instance
+      @instance ||= new_instance
+    end
+    
+    attr_reader :settings
+    
+    
+    @settings = nil
+    
+    # Initialize the agent: install instrumentation and start the agent if
+    # appropriate.  Subclasses may have different arguments for this when
+    # they are being called from different locations.
+    def start_plugin(*args)
+      if tracers_enabled?
+        start_agent
+      else
+        require 'new_relic/shim_agent'
+      end
+    end
+    
+    # Get the app config info.  It should already have been collected but
+    # if not we will memoize it to be safe.
+    def app_config_info
+      @app_config_info ||= gather_info
+    end
+    
+    def [](key)
+      fetch(key)
+    end
+    
+    def fetch(key, default=nil)
+      @settings[key].nil? ? default : @settings[key]
+    end
+    
+    ###################################
+    # Agent config conveniences
+    
+    def newrelic_root
+      File.expand_path(File.join(__FILE__, "..","..",".."))
+    end
+    def connect_to_server?
+      fetch('enabled', nil)
+    end
+    def developer_mode?
+      fetch('developer', nil)
+    end
+    def tracers_enabled?
+      !(ENV['NEWRELIC_ENABLE'].to_s =~ /false|off|no/i) &&
+       (developer_mode? || connect_to_server?)
+    end
+    def app_name
+      fetch('app_name', nil)
+    end
+    
+    def to_s
+      puts self.inspect
+      "Config[#{self.app}]"
+    end
+    def log
+      # If we try to get a log before one has been set up, return a stdout log
+      unless @log
+        @log = Logger.new(STDOUT)
+        @log.level = Logger::WARN
+      end
+      @log
+    end
+    
+    def setup_log(identifier)
+      log_file = "#{log_path}/#{log_file_name(identifier)}"
+      @log = Logger.new log_file
+      
+      # change the format just for our logger
+      
+      def @log.format_message(severity, timestamp, progname, msg)
+        "[#{timestamp.strftime("%m/%d/%y %H:%M:%S")} (#{$$})] #{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
+      else @log.level = Logger::INFO
+      end
+      log! "New Relic RPM Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
+      log! "Agent Log is found in #{log_file}"
+      @log
+    end
+    
+    def local_env
+      @env ||= NewRelic::LocalEnvironment.new
+    end
+    
+    # send the given message to STDERR so that it shows
+    # up in the console.  This should be used for important informational messages at boot.
+    # The to_stderr may be implemented differently by different config subclasses.
+    # This will NOT print anything if the environment is unknown because this is
+    # probably not an environment the agent will be running in.
+    def log!(msg, level=:info)
+      return if @settings && !tracers_enabled?
+      to_stderr msg
+      log.send level, msg if log
+    end
+    
+    protected
+    # Collect miscellaneous interesting info about the environment
+    # Called when the agent is started
+    def gather_info
+      [[:app, app]]
+    end
+    
+    def to_stderr(msg)
+      STDERR.puts "** [NewRelic] " + msg 
+    end
+    
+    def start_agent
+      NewRelic::Agent::Agent.instance.start(local_env.environment, local_env.identifier)
+    end
+    
+    def config_file
+      File.expand_path(File.join(root,"config","newrelic.yml"))
+    end
+    
+    def log_path
+      path = File.join(root,'log')
+      unless File.directory? path
+        path = '.'
+      end
+      File.expand_path(path)
+    end
+    
+    def log_file_name(identifier="")
+      "newrelic_agent.#{identifier.gsub(/[^-\w.]/, '_')}.log"
+    end
+    
+    # Create the concrete class for environment specific behavior:
+    def self.new_instance
+      case
+        when defined? NewRelic::TEST
+        require 'config/test_config'
+        NewRelic::Config::Test.new
+        when defined? Merb::Plugins then
+        require 'new_relic/config/merb'
+        NewRelic::Config::Merb.new
+        when defined? Rails then
+        require 'new_relic/config/rails'
+        NewRelic::Config::Rails.new
+      else
+        require 'new_relic/config/ruby'
+        NewRelic::Config::Ruby.new
+      end
+    end
+    
+    # Return a hash of settings you want to override in the newrelic.yml
+    # file.  Maybe just for testing.
+    
+    def initialize
+      newrelic_file = config_file
+      # Next two are for populating the newrelic.yml via erb binding, necessary
+      # when using the default newrelic.yml file
+      generated_for_user = ''
+      license_key=''
+      if !File.exists?(config_file)
+        yml_file = File.expand_path(File.join(__FILE__,"..","..","..","newrelic.yml"))
+        yaml = ::ERB.new(File.read(yml_file)).result(binding)
+        log! "Cannot find newrelic.yml file at #{config_file}."
+        log! "Using #{yml_file} file."
+        log! "Signup at rpm.newrelic.com to get a newrelic.yml file configured for a free Lite account."
+      else
+        yaml = ERB.new(File.read(config_file)).result(binding)
+      end
+      @settings = YAML.load(yaml)[env] || {}
+    rescue ScriptError, StandardError => e
+      puts e
+      puts e.backtrace.join("\n")
+      raise "Error reading newrelic.yml file: #{e}"
+    end
+  end
+end

data/lib/new_relic/config/merb.rb

@@ -0,0 +1,35 @@
+class NewRelic::Config::Merb < NewRelic::Config
+  
+  def app; :merb; end
+  
+  def env
+    ::Merb.env
+  end
+  def root 
+    ::Merb.root
+  end
+  
+  def to_stderr(msg)
+    STDERR.puts "NewRelic ~ " + msg 
+  end
+  
+  def start_plugin
+    ::Merb::Plugins.add_rakefiles File.join(newrelic_root,"lib/tasks/all.rb")
+    
+    # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+    ::Merb::Plugins.config[:newrelic] = {
+      :config => self
+    }
+    
+    ::Merb::BootLoader.before_app_loads do
+      # require code that must be loaded before the application
+    end
+    
+    if tracers_enabled?
+      ::Merb::BootLoader.after_app_loads do
+        start_agent
+      end
+    end
+    
+  end
+end