sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/agent/worker_loop.rb

@@ -0,0 +1,96 @@
+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
+
+      # Optional argument :duration (in seconds) for how long the worker loop runs
+      # or :limit (integer) for max number of iterations
+      def initialize(opts={})
+        @should_run = true
+        @next_invocation_time = Time.now
+        @period = 60.0
+        @duration = opts[:duration] if opts[:duration]
+        @limit = opts[:limit] if opts[:limit]
+        @iterations = 0
+      end
+
+      # returns a class-level memoized mutex to make sure we don't run overlapping
+      def lock
+        @@lock ||= Mutex.new
+      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)
+        @deadline = Time.now + @duration if @duration
+        @period = period if period
+        @next_invocation_time = (Time.now + @period)
+        @task = block
+        while keep_running? do
+          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?
+          @iterations += 1 if !@limit.nil?
+        end
+      end
+
+      # a simple accessor for @should_run
+      def keep_running?
+        @now = Time.now
+        @should_run && under_duration? && under_limit?
+      end
+
+      def under_duration?
+        !@deadline || @now < @deadline
+      end
+
+      def under_limit?
+        !@limit || @iterations < @limit
+      end
+
+      # Sets @should_run to false. Returns false
+      def stop
+        @should_run = false
+      end
+
+      # Executes the block given to the worker loop, and handles many
+      # possible errors. Also updates the execution time so that the
+      # next run occurs on schedule, even if we execute at some odd time
+      def run_task
+        begin
+          lock.synchronize do
+            @task.call
+          end
+        rescue ServerError => e
+          ::NewRelic::Agent.logger.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.
+          ::NewRelic::Agent.logger.error "Error running task in worker loop, likely a server error:", e
+        rescue Timeout::Error, NewRelic::Agent::ServerConnectionException
+          # Want to ignore these because they are handled already
+        rescue SystemExit, NoMemoryError, SignalException
+          raise
+        rescue => e
+          # Don't blow out the stack for anything that hasn't already propagated
+          ::NewRelic::Agent.logger.error "Error running task in Agent Worker Loop:", e
+        end
+        now = Time.now
+        while @next_invocation_time <= now && @period > 0
+          @next_invocation_time += @period
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/coerce.rb

@@ -0,0 +1,37 @@
+module NewRelic
+  # We really don't want to send bad values to the collector, and it doesn't
+  # accept types like Rational that have occasionally slipped into our data.
+  #
+  # These methods are intended to safely coerce things into the form we want,
+  # to provide documentation of expected types on to_collector_array methods,
+  # and to log failures if totally invalid data gets into outgoing data
+  module Coerce
+    def int(value, context=nil)
+      Integer(value)
+    rescue => error
+      log_failure(value, Integer, context, error)
+      0
+    end
+
+    def float(value, context=nil)
+      Float(value)
+    rescue => error
+      log_failure(value, Float, context, error)
+      0.0
+    end
+
+    def string(value, context=nil)
+      return value if value.nil?
+      String(value)
+    rescue => error
+      log_failure(value.class, String, context, error)
+      ""
+    end
+
+    def log_failure(value, type, context, error)
+      msg = "Unable to convert '#{value}' to #{type}"
+      msg += " in context '#{context}'" if context
+      NewRelic::Agent.logger.warn(msg, error)
+    end
+  end
+end

data/lib/new_relic/collection_helper.rb

@@ -0,0 +1,77 @@
+require 'new_relic/control'
+
+module NewRelic
+  module CollectionHelper
+  DEFAULT_TRUNCATION_SIZE=16 * 1024
+  DEFAULT_ARRAY_TRUNCATION_SIZE=128
+  # Transform parameter hash into a hash whose values are strictly
+  # strings
+  def normalize_params(params)
+    case params
+      when Hash
+        # optimize for empty hash since that is often what this is called with.
+        return params if params.empty?
+        new_params = {}
+        params.each do | key, value |
+          new_params[truncate(normalize_params(key),64)] = normalize_params(value)
+        end
+        new_params
+      when Symbol, FalseClass, TrueClass, nil
+        params
+      when Numeric
+        truncate(params.to_s)
+      when String
+        truncate(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 && !Agent.config[:disable_backtrace_cleanup]
+      # this is for 1.9.1, where strings no longer have Enumerable
+      backtrace = backtrace.split("\n") if String === backtrace
+      backtrace = backtrace.map &:to_s
+      backtrace = backtrace.reject do |line|
+        line.include?(NewRelic::Control.newrelic_root) or
+        line =~ /^newrelic_rpm\s/
+      end
+      # rename methods back to their original state
+      backtrace = backtrace.collect {|line| line.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,114 @@
+# 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 :control
+  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 string values for
+  # :user, :description, :appname, :revision, :environment,
+  # and :changes.
+  #
+  # Will throw CommandFailed exception if there's any error.
+  #
+  def initialize command_line_args
+    @control = NewRelic::Control.instance
+    super(command_line_args)
+    @description ||= @leftover && @leftover.join(" ")
+    @user ||= ENV['USER']
+    control.env = @environment if @environment
+    load_yaml_from_env(control.env)
+    @appname ||= NewRelic::Agent.config.app_names[0] || control.env || 'development'
+  end
+
+  def load_yaml_from_env(env)
+    yaml = NewRelic::Agent::Configuration::YamlSource.new(NewRelic::Agent.config[:config_path], env)
+    NewRelic::Agent.config.replace_or_add_config(yaml, 1)
+  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 = ::NewRelic::Agent::NewRelicService.new(nil, control.api_server).http_connection
+
+      uri = "/deployments.xml"
+
+      if NewRelic::Agent.config[:license_key].nil? ||
+          NewRelic::Agent.config[:license_key].empty?
+        raise "license_key was not set in newrelic.yml for #{control.env}"
+      end
+      request = Net::HTTP::Post.new(uri, {'x-license-key' => NewRelic::Agent.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 #{control.api_server} (#{e})"
+      raise NewRelic::Command::CommandFailure.new(err_string)
+    rescue NewRelic::Command::CommandFailure
+      raise
+    rescue => e
+      err "Unexpected error attempting to connect to #{control.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: #{control.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,80 @@
+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
+    
+  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