ghazel-newrelic_rpm 3.1.0.1

data/lib/new_relic/agent/worker_loop.rb

@@ -0,0 +1,81 @@
+require 'thread'
+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.
+    class WorkerLoop
+
+      def initialize
+        @log = log
+        @should_run = true
+        @next_invocation_time = Time.now
+        @period = 60.0
+      end
+
+      def lock
+        @@lock ||= Mutex.new
+      end
+
+      def log
+        NewRelic::Control.instance.log
+      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.  This will run the task immediately.
+      def run(period=nil, &block)
+        @period = period if period
+        @next_invocation_time = (Time.now + @period)
+        @task = block
+        while keep_running do
+          now = Time.now
+          while now < @next_invocation_time
+            # sleep until this next task's scheduled invocation time
+            sleep_time = @next_invocation_time - now
+            sleep sleep_time if sleep_time > 0
+            now = Time.now
+          end
+          run_task if keep_running
+        end
+      end
+
+      def keep_running
+        @should_run
+      end
+
+      def stop
+        @should_run = false
+      end
+
+      def run_task
+        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
+        now = Time.now
+        while @next_invocation_time <= now && @period > 0
+          @next_invocation_time += @period
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/collection_helper.rb

@@ -0,0 +1,69 @@
+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)
+    case params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(params)
+      when Hash
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),32)] = normalize_params(value)
+        end
+        new_params
+      when Array
+        params.first(DEFAULT_ARRAY_TRUNCATION_SIZE).map{|item| normalize_params(item)}
+    else
+      truncate(flatten(params))
+    end
+  end
+
+  # Return an array of strings (backtrace), cleaned up for readability
+  # Return nil if there is no backtrace
+
+  def strip_nr_from_backtrace(backtrace)
+    if backtrace
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      backtrace = backtrace.reject {|line| line =~ /new_?relic/ }
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.to_s.gsub(/_without_(newrelic|trace)/, "")}
+    end
+    backtrace
+  end
+
+  private
+
+  # Convert any kind of object to a short string.
+  def flatten(object)
+    s = case object
+      when nil then ''
+      when object.instance_of?(String) then object
+      when String then String.new(object)  # convert string subclasses to strings
+      else "#<#{object.class.to_s}>"
+    end
+  end
+  def truncate(string, len=DEFAULT_TRUNCATION_SIZE)
+    case string
+    when Symbol then string
+    when nil then ""
+    when String
+      real_string = flatten(string)
+      if real_string.size > len
+        real_string = real_string.slice(0...len)
+        real_string << "..."
+      end
+      real_string
+    else
+      truncate(flatten(string), len)
+    end
+  end
+  end
+end

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{ |c| c.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

data/lib/new_relic/commands/deployments.rb

@@ -0,0 +1,105 @@
+# This is a class for executing commands related to deployment
+# events.  It runs without loading the rails environment
+
+require 'yaml'
+require 'net/http'
+require 'rexml/document'
+
+# We need to use the Control object but we don't want to load
+# the rails/merb environment.  The defined? clause is so that
+# it won't load it twice, something it does when run inside a test
+require 'new_relic/control' unless defined? NewRelic::Control
+
+class NewRelic::Command::Deployments < NewRelic::Command
+  attr_reader :config
+  def self.command; "deployments"; end
+
+  # Initialize the deployment uploader with command line args.
+  # Use -h to see options.
+  # When command_line_args is a hash, we are invoking directly and
+  # it's treated as an options with optional sttring values for
+  # :user, :description, :appname, :revision, :environment,
+  # and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  #
+  def initialize command_line_args
+    @config = NewRelic::Control.instance
+    super(command_line_args)
+    @description ||= @leftover && @leftover.join(" ")
+    @user ||= ENV['USER']
+    config.env = @environment if @environment
+    @appname ||= config.app_names[0] || config.env || 'development'
+  end
+
+  # Run the Deployment upload in New Relic via Active Resource.
+  # Will possibly print errors and exit the VM
+  def run
+    begin
+      @description = nil if @description && @description.strip.empty?
+      create_params = {}
+      {
+            :application_id => @appname,
+            :host => Socket.gethostname,
+            :description => @description,
+            :user => @user,
+            :revision => @revision,
+            :changelog => @changelog
+      }.each do |k, v|
+        create_params["deployment[#{k}]"] = v unless v.nil? || v == ''
+      end
+      http = config.http_connection(config.api_server)
+
+      uri = "/deployments.xml"
+
+      raise "license_key was not set in newrelic.yml for #{config.env}" if config['license_key'].nil?
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => config['license_key']})
+      request.content_type = "application/octet-stream"
+
+      request.set_form_data(create_params)
+
+      response = http.request(request)
+
+      if response.is_a? Net::HTTPSuccess
+        info "Recorded deployment to '#{@appname}' (#{@description || Time.now })"
+      else
+        err_string = REXML::Document.new(response.body).elements['errors/error'].map(&:to_s).join("; ") rescue  response.message
+        raise NewRelic::Command::CommandFailure, "Deployment not recorded: #{err_string}"
+      end
+    rescue SystemCallError, SocketError => e
+      # These include Errno connection errors
+      err_string = "Transient error attempting to connect to #{config.api_server} (#{e})"
+      raise NewRelic::Command::CommandFailure.new(err_string)
+    rescue NewRelic::Command::CommandFailure
+      raise
+    rescue Exception => e
+      err "Unexpected error attempting to connect to #{config.api_server}"
+      info "#{e}: #{e.backtrace.join("\n   ")}"
+      raise NewRelic::Command::CommandFailure.new(e.to_s)
+    end
+  end
+
+  private
+
+  def options
+    OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |o|
+      o.separator "OPTIONS:"
+      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,
+               "Override the (RAILS|MERB|RUBY|RACK)_ENV setting",
+               "currently: #{config.env}") { | e | @environment = e }
+      o.on("-u", "--user=USER", String,
+             "Specify the user deploying, for information only",
+             "Default: #{@user || '<none>'}") { | u | @user = u }
+      o.on("-r", "--revision=REV", String,
+             "Specify the revision being deployed") { | r | @revision = r }
+      o.on("-c", "--changes",
+             "Read in a change log from the standard input") { @changelog = STDIN.read }
+      yield o if block_given?
+    end
+  end
+
+
+end

data/lib/new_relic/commands/install.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+require 'new_relic/version'
+require 'erb'
+
+class NewRelic::Command::Install < NewRelic::Command
+
+  NO_LICENSE_KEY = "<PASTE LICENSE KEY HERE>"
+
+  def self.command; "install"; end
+
+  # Use -h to see options.
+  # When command_line_args is a hash, we are invoking directly and
+  # it's treated as an options with optional string values for
+  # :user, :description, :appname, :revision, :environment,
+  # and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  #
+  attr_reader :dest_dir, :license_key, :generated_for_user, :quiet, :src_file, :app_name
+  def initialize command_line_args={}
+    super command_line_args
+    if !@dest_dir
+      # Install a newrelic.yml file into the local config directory.
+      if File.directory? "config"
+        @dest_dir = "config"
+      else
+        @dest_dir = "."
+      end
+    end
+    @license_key ||= NO_LICENSE_KEY
+    @app_name ||= @leftover
+    raise CommandFailure.new("Application name required.", @options) unless @app_name && @app_name.size > 0
+    @generated_for_user ||= @user_string || ""
+  end
+
+  def run
+    dest_file = File.expand_path(@dest_dir + "/newrelic.yml")
+    if File.exist?(dest_file)
+      raise NewRelic::Command::CommandFailure, "newrelic.yml file already exists.  Move it out of the way."
+    end
+    File.open(dest_file, 'w') { | out | out.puts(content) }
+
+    puts <<-EOF unless quiet
+
+Installed a default configuration file at
+#{dest_file}.
+    EOF
+    puts <<-EOF unless quiet || @license_key != NO_LICENSE_KEY
+
+To monitor your application in production mode, sign up for an account
+at www.newrelic.com, and replace the newrelic.yml file with the one
+you receive upon registration.
+    EOF
+    puts <<-EOF unless quiet
+
+E-mail support@newrelic.com with any problems or questions.
+
+    EOF
+    puts <<-EOF
+
+Installing the plugin from Rubyforge is deprecated. This repository will not be updated after January 2011
+
+Please use one of the following options:
+
+Gems: gem install newrelic_rpm
+
+Github! git clone git://github.com/newrelic/rpm.git vendor/plugins/newrelic_rpm
+
+    EOF
+  end
+
+  def content
+    @src_file ||= File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","newrelic.yml"))
+    template = File.read(@src_file)
+    ERB.new(template).result(binding)
+  end
+
+  private
+
+  def options
+    OptionParser.new "Usage: #{$0} #{self.class.command} [ OPTIONS] 'application name'", 40 do |o|
+      o.on("-l", "--license_key=NAME", String,
+             "Use the given license key") { | e | @license_key = e }
+      o.on("-d", "--destdir=name", String,
+               "Write the newrelic.yml to the given directory, default is '.'") { | e | @dest_dir = e }
+      yield o if block_given?
+    end
+  end
+
+
+end

data/lib/new_relic/control.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+require 'conditional_vendored_metric_parser'
+require 'conditional_vendored_dependency_detection'
+require 'new_relic/local_environment'
+
+require 'singleton'
+require 'erb'
+require 'socket'
+require 'net/https'
+require 'logger'
+require 'new_relic/control/profiling'
+require 'new_relic/control/logging_methods'
+require 'new_relic/control/configuration'
+require 'new_relic/control/server_methods'
+require 'new_relic/control/instrumentation'
+require 'new_relic/control/class_methods'
+require 'new_relic/control/instance_methods'
+
+require 'new_relic/agent'
+require 'new_relic/delayed_job_injection'
+
+
+module NewRelic
+
+  # The Control is a singleton responsible for the startup and
+  # initialization sequence.  The initializer uses a LocalEnvironment to
+  # detect the framework and instantiates the framework specific
+  # subclass.
+  #
+  # The Control also implements some of the public API for the agent.
+  #
+  class Control
+    # used for framework-specific subclasses
+    module Frameworks; end
+
+    # done in a subfile for load order purposes
+    # extend ClassMethods
+    # include InstanceMethods
+    # include Profiling
+    # include LoggingMethods
+    # include Configuration
+    # include ServerMethods
+    # include Instrumentation
+
+
+
+  end
+end