honkster-newrelic_rpm 2.13.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
+        @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,71 @@
+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
+      # strip newrelic from the trace
+      backtrace = backtrace.reject {|line| line =~ /new_relic\/agent\// }
+      # rename methods back to their original state
+      # GJV - 4/6/10 - adding .to_s call since we were seeing line as a Fixnum in some cases
+      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 RPM 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,81 @@
+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

data/lib/new_relic/control.rb

@@ -0,0 +1,203 @@
+require 'yaml'
+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'
+
+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
+
+    include Profiling
+    include LoggingMethods
+    include Configuration
+    include ServerMethods
+    include Instrumentation
+
+    # 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
+
+    module ClassMethods
+      # Access the Control singleton, lazy initialized
+      def instance
+        @instance ||= new_instance
+      end
+
+      # Create the concrete class for environment specific behavior:
+      def new_instance
+        @local_env = NewRelic::LocalEnvironment.new
+        if @local_env.framework == :test
+          # You can set this env var if you want to run the tests
+          # without Rails.
+          config = File.expand_path("../../../test/config/newrelic.yml", __FILE__)
+          if ENV['SKIP_RAILS']
+            require "new_relic/control/frameworks/ruby.rb"
+            NewRelic::Control::Frameworks::Ruby.new @local_env, config
+          else
+            require "config/test_control"
+            NewRelic::Control::Frameworks::Test.new @local_env, config
+          end
+        else
+          begin
+            require "new_relic/control/frameworks/#{@local_env.framework}.rb"
+          rescue LoadError
+          end
+          NewRelic::Control::Frameworks.const_get(@local_env.framework.to_s.capitalize).new @local_env
+        end
+      end
+
+      # The root directory for the plugin or gem
+      def newrelic_root
+        File.expand_path("../../..", __FILE__)
+      end
+    end
+    extend ClassMethods
+
+    # Initialize the plugin/gem and start the agent.  This does the necessary configuration based on the
+    # framework environment and determines whether or not to start the agent.  If the
+    # agent is not going to be started then it loads the agent shim which has stubs
+    # for all the external api.
+    #
+    # This may be invoked multiple times, as long as you don't attempt to uninstall
+    # the agent after it has been started.
+    #
+    # If the plugin is initialized and it determines that the agent is not enabled, it
+    # will skip starting it and install the shim.  But if you later call this with
+    # <tt>:agent_enabled => true</tt>, then it will install the real agent and start it.
+    #
+    # What determines whether the agent is launched is the result of calling agent_enabled?
+    # This will indicate whether the instrumentation should/will be installed.  If we're
+    # in a mode where tracers are not installed then we should not start the agent.
+    #
+    # Subclasses are not allowed to override, but must implement init_config({}) which
+    # is called one or more times.
+    #
+    def init_plugin(options={})
+      options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
+
+      require 'new_relic/agent'
+
+      # Load the DJ injection now.  If you do it sooner, DJ might not be loaded and
+      # you'll miss it.
+      require 'new_relic/delayed_job_injection'
+
+      # Merge the stringified options into the config as overrides:
+      logger_override = options.delete(:log)
+      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
+      @settings = nil
+      settings
+      merge_options(options)
+      if logger_override
+        @log = logger_override
+        # 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)
+      NewRelic::Agent.agent = NewRelic::Agent::Agent.instance
+      if agent_enabled? && !NewRelic::Agent.instance.started?
+        setup_log unless logger_override
+        start_agent
+        install_instrumentation
+        load_samplers unless self['disable_samplers']
+        local_env.gather_environment_info
+        append_environment_info
+      elsif !agent_enabled?
+        install_shim
+      end
+    end
+
+    # Install the real agent into the Agent module, and issue the start command.
+    def start_agent
+      NewRelic::Agent.agent.start
+    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
+    # by NEWRELIC_ENABLE env variable, monitor_daemons config option when true, or
+    # 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'].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
+      # When in 'auto' mode the agent is enabled if there is a known
+      # dispatcher running
+      return true if @local_env.dispatcher != nil
+    end
+
+    def app
+      @local_env.framework
+    end
+    alias framework app
+
+    def to_s
+      "Control[#{self.app}]"
+    end
+
+    protected
+
+    # Append framework specific environment information for uploading to
+    # the server for change detection.  Override in subclasses
+    def append_environment_info; end
+
+    def config_file
+      File.expand_path(File.join(root,"config","newrelic.yml"))
+    end
+
+    def initialize local_env, config_file_override=nil
+      @local_env = local_env
+      @instrumentation_files = []
+      newrelic_file = config_file_override || 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?(newrelic_file)
+        log! "Cannot find read #{newrelic_file}."
+        @yaml = {}
+      else
+        @yaml = YAML.load(ERB.new(File.read(newrelic_file)).result(binding))
+      end
+    rescue ScriptError, StandardError => e
+      puts e
+      puts e.backtrace.join("\n")
+      raise "Error reading newrelic.yml file: #{e}"
+    end
+
+    def newrelic_root
+      self.class.newrelic_root
+    end
+
+  end
+end