dolores_rpm 3.2.0.2

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 string 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,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

data/lib/new_relic/control/class_methods.rb

@@ -0,0 +1,53 @@
+module NewRelic
+  class Control
+    # class-level methods for lazy creation of NewRelic::Control and
+    # NewRelic::LocalEnvironment instances.
+    module ClassMethods
+      # Access the Control singleton, lazy initialized.  Default will instantiate a new
+      # instance or pass false to defer
+      def instance(create=true)
+        @instance ||= create && new_instance
+      end
+      
+      # Access the LocalEnvironment singleton, lazy initialized
+      def local_env
+        @local_env ||= NewRelic::LocalEnvironment.new
+      end
+
+      # Create the concrete class for environment specific behavior
+      def new_instance
+        if local_env.framework == :test
+          load_test_framework
+        else
+          load_framework_class(local_env.framework).new(local_env)
+        end
+      end
+
+      # nb this does not 'load test' the framework, it loads the 'test framework'
+      def load_test_framework
+        config = File.expand_path(File.join('..','..','..','..', "test","config","newrelic.yml"), __FILE__)
+        require "config/test_control"
+        NewRelic::Control::Frameworks::Test.new(local_env, config)
+      end
+      
+      # Loads the specified framework class from the
+      # NewRelic::Control::Frameworks module
+      def load_framework_class(framework)
+        begin
+          require "new_relic/control/frameworks/#{framework}"
+        rescue LoadError
+          # maybe it is already loaded by some external system
+          # i.e. rpm_contrib or user extensions?
+        end
+        NewRelic::Control::Frameworks.const_get(framework.to_s.capitalize)
+      end
+
+      # The root directory for the plugin or gem
+      def newrelic_root
+        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
+      end
+    end
+    extend ClassMethods
+  end
+end
+

data/lib/new_relic/control/configuration.rb

@@ -0,0 +1,202 @@
+module NewRelic
+  class Control
+    # used to contain methods to look up settings from the
+    # configuration located in newrelic.yml
+    module Configuration
+      def settings
+        unless @settings
+          @settings = (@yaml && merge_defaults(@yaml[env])) || {}
+          # At the time we bind the settings, we also need to run this little piece
+          # of magic which allows someone to augment the id with the app name, necessary
+          if self['multi_homed'] && app_names.size > 0
+            if @local_env.dispatcher_instance_id
+              @local_env.dispatcher_instance_id << ":#{app_names.first}"
+            else
+              @local_env.dispatcher_instance_id = app_names.first
+            end
+          end
+
+        end
+        @settings
+      end
+
+      def merge_defaults(settings_hash)
+        s = {
+          'host' => 'collector.newrelic.com',
+          'ssl' => false,
+          'log_level' => 'info',
+          'apdex_t' => 0.5
+        }
+        s.merge! settings_hash if settings_hash
+        # monitor_daemons replaced with agent_enabled
+        s['agent_enabled'] = s.delete('monitor_daemons') if s['agent_enabled'].nil? && s.include?('monitor_daemons')
+        s
+      end
+
+      # Merge the given options into the config options.
+      # They might be a nested hash
+      def merge_options(options, hash=self)
+        options.each do |key, val|
+          case
+          when key == :config then next
+          when val.is_a?(Hash)
+            merge_options(val, hash[key.to_s] ||= {})
+          when val.nil?
+            hash.delete(key.to_s)
+          else
+            hash[key.to_s] = val
+          end
+        end
+      end
+
+      def merge_server_side_config(data)
+        remove_server_controlled_configs
+        config = Hash.new
+        data.each_pair do |key, value|
+          if key.include?('.')
+            key = key.split('.')
+            config[key.first] ||= Hash.new
+            config[key.first][key[1]] = value
+          else
+            config[key] = value
+          end
+        end
+        merge_options(config)
+      end
+
+      def remove_server_controlled_configs
+        settings.delete('transaction_tracer')
+        settings.delete('slow_sql')
+        settings.delete('error_collector')
+        settings.delete('capture_params')
+      end
+
+      def [](key)
+        fetch(key)
+      end
+
+      def []=(key, value)
+        settings[key] = value
+      end
+
+      def fetch(key, default=nil)
+        settings.fetch(key, default)
+      end
+
+      def apdex_t
+        # Always initialized with a default
+        fetch('apdex_t').to_f
+      end
+
+      def license_key
+        env_setting = ENV['NEW_RELIC_LICENSE_KEY'] || ENV['NEWRELIC_LICENSE_KEY']
+        fetch('license_key', env_setting)
+      end
+      
+      def capture_params
+        fetch('capture_params')
+      end
+      
+      # True if we are sending data to the server, monitoring production
+      def monitor_mode?
+        fetch('monitor_mode', fetch('enabled'))
+      end
+
+      # True if we are capturing data and displaying in /newrelic
+      def developer_mode?
+        fetch('developer_mode', fetch('developer'))
+      end
+      
+      # whether we should install the
+      # NewRelic::Rack::BrowserMonitoring middleware automatically on
+      # Rails applications
+      def browser_monitoring_auto_instrument?
+        fetch('browser_monitoring', {}).fetch('auto_instrument', true)
+      end
+
+      def multi_threaded?
+        fetch('multi_threaded')
+      end
+
+      def disable_serialization?
+        fetch('disable_serialization', false)
+      end
+      def disable_serialization=(b)
+        self['disable_serialization'] = b
+      end
+      
+      # True if we should view files in textmate
+      def use_textmate?
+        fetch('textmate')
+      end
+      
+      # defaults to 2MiB
+      def post_size_limit
+        fetch('post_size_limit', 2 * 1024 * 1024)
+      end
+
+      # Configuration option of the same name to indicate that we should connect
+      # to New Relic synchronously on startup.  This means when the agent is loaded it
+      # won't return without trying to set up the server connection at least once
+      # which can make startup take longer.  Defaults to false.
+      def sync_startup
+        fetch('sync_startup', false)
+      end
+
+      # Configuration option of the same name to indicate that we should flush
+      # data to the server on exiting.  Defaults to true.
+      def send_data_on_exit
+        fetch('send_data_on_exit', true)
+      end
+
+      def dispatcher_instance_id
+        self['dispatcher_instance_id'] || @local_env.dispatcher_instance_id
+      end
+
+      def dispatcher
+        (self['dispatcher'] && self['dispatcher'].to_sym) || @local_env.dispatcher
+      end
+      def app_names
+        case self['app_name']
+        when Array then self['app_name']
+        when String then self['app_name'].split(';')
+        else [ env ]
+        end
+      end
+      def validate_seed
+        self['validate_seed'] || ENV['NR_VALIDATE_SEED']
+      end
+      def validate_token
+        self['validate_token'] || ENV['NR_VALIDATE_TOKEN']
+      end
+      
+      def use_ssl?
+        @use_ssl = fetch('ssl', false) unless @use_ssl
+        @use_ssl
+      end
+      
+      def log_file_path
+        fetch('log_file_path', 'log/')
+      end
+      
+      # only verify certificates if you're very sure you want this
+      # level of security, it includes possibly app-crashing dns
+      # lookups every connection to the server
+      def verify_certificate?
+        unless @verify_certificate
+          unless use_ssl?
+            @verify_certificate = false
+          else
+            @verify_certificate = fetch('verify_certificate', false)
+          end
+        end
+        @verify_certificate
+      end
+
+      def disable_backtrace_cleanup?
+        fetch('disable_backtrace_cleanup')
+      end
+    end
+    include Configuration
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # 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.
+      class External < NewRelic::Control::Frameworks::Ruby
+        def init_config(options={})
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module NewRelic
+  class Control
+    module Frameworks
+      # Includes limited support for Merb
+      class Merb < NewRelic::Control
+
+        def env
+          @env ||= ::Merb.env
+        end
+        def root
+          ::Merb.root
+        end
+
+        def to_stdout(msg)
+          Merb.logger.info("NewRelic ~ " + msg)
+        rescue Exception => e
+          STDOUT.puts "NewRelic ~ " + msg
+        end
+
+        def init_config options={}
+          ::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
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+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
+          @env ||= RAILS_ENV.dup
+        end
+        def root
+          if defined?(RAILS_ROOT) && RAILS_ROOT.to_s != ''
+            RAILS_ROOT.to_s
+          else
+            super
+          end
+        end
+        def logger
+          ::RAILS_DEFAULT_LOGGER
+        end
+
+        # In versions of Rails prior to 2.0, the rails config was only available to
+        # the init.rb, so it had to be passed on from there.  This is a best effort to 
+        # find a config and use that.
+        def init_config(options={})
+          rails_config = options[:config]
+          if !rails_config && defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            rails_config = ::Rails.configuration
+          end
+          # Install the dependency detection, 
+          if rails_config && ::Rails.configuration.respond_to?(:after_initialize)
+            rails_config.after_initialize do
+              # This will insure we load all the instrumentation as late as possible.  If the agent
+              # is not enabled, it will load a limited amount of instrumentation.  See 
+              # delayed_job_injection.rb
+              DependencyDetection.detect!
+            end
+          end          
+          if !agent_enabled?
+            # Might not be running if it does not think mongrel, thin, passenger, etc
+            # is running, if it things it's a rake task, or if the agent_enabled is false.
+            log! "New Relic Agent not running."
+          else
+            log! "Starting the New Relic Agent."
+            install_developer_mode rails_config if developer_mode?
+            install_browser_monitoring(rails_config)
+          end
+        end
+
+        def install_browser_monitoring(config)
+          return if @browser_monitoring_installed
+          @browser_monitoring_installed = true
+          return if config.nil? || !config.respond_to?(:middleware) || !browser_monitoring_auto_instrument?
+          begin
+            require 'new_relic/rack/browser_monitoring'
+            config.middleware.use NewRelic::Rack::BrowserMonitoring
+            log!("Installed New Relic Browser Monitoring middleware", :info)
+          rescue Exception => e
+            log!("Error installing New Relic Browser Monitoring middleware: #{e.inspect}", :error)
+          end
+        end
+
+        def install_developer_mode(rails_config)
+          return if @installed
+          @installed = true
+          if rails_config && rails_config.respond_to?(:middleware)
+            begin
+              require 'new_relic/rack/developer_mode'
+              rails_config.middleware.use NewRelic::Rack::DeveloperMode
+
+              # inform user that the dev edition is available if we are running inside
+              # a webserver process
+              if @local_env.dispatcher_instance_id
+                port = @local_env.dispatcher_instance_id.to_s =~ /^\d+/ ? ":#{local_env.dispatcher_instance_id}" : ":port"
+                log!("NewRelic Agent Developer Mode enabled.")
+                log!("To view performance information, go to http://localhost#{port}/newrelic")
+              end
+            rescue Exception => e
+              log!("Error installing New Relic Developer Mode: #{e.inspect}", :error)
+            end
+          elsif rails_config
+            log!("Developer mode not available for Rails versions prior to 2.2", :warn)
+          end
+        end
+
+        def log!(msg, level=:info)
+          if should_log?
+            logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
+            logger.send(level, msg)
+          else
+            super
+          end
+        rescue Exception => e
+          super
+        end
+
+        def to_stdout(message)
+          logger = ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
+          logger.info(message)
+        rescue Exception => e
+          super
+        end
+
+        def rails_version
+          @rails_version ||= NewRelic::VersionNumber.new(::Rails::VERSION::STRING)
+        end
+
+        protected
+
+        def rails_vendor_root
+          File.join(root,'vendor','rails')
+        end
+
+        def rails_gem_list
+          ::Rails.configuration.gems.map do | gem |
+            version = (gem.respond_to?(:version) && gem.version) ||
+              (gem.specification.respond_to?(:version) && gem.specification.version)
+            gem.name + (version ? "(#{version})" : "")
+          end
+        end
+
+        # Collect the Rails::Info into an associative array as well as the list of plugins
+        def append_environment_info
+          local_env.append_environment_value('Rails version'){ ::Rails::VERSION::STRING }
+          if rails_version >= NewRelic::VersionNumber.new('2.2.0')
+            local_env.append_environment_value('Rails threadsafe') do
+              ::Rails.configuration.action_controller.allow_concurrency == true
+            end
+          end
+          local_env.append_environment_value('Rails Env') { ENV['RAILS_ENV'] }
+          if rails_version >= NewRelic::VersionNumber.new('2.1.0')
+            local_env.append_gem_list do
+              (bundler_gem_list + rails_gem_list).uniq
+            end
+            # The plugins is configured manually.  If it's nil, it loads everything non-deterministically
+            if ::Rails.configuration.plugins
+              local_env.append_plugin_list { ::Rails.configuration.plugins }
+            else
+              ::Rails.configuration.plugin_paths.each do |path|
+                local_env.append_plugin_list { Dir[File.join(path, '*')].collect{ |p| File.basename p if File.directory? p }.compact }
+              end
+            end
+          else
+            # Rails prior to 2.1, can't get the gems.  Find plugins in the default location
+            local_env.append_plugin_list do
+              Dir[File.join(root, 'vendor', 'plugins', '*')].collect{ |p| File.basename p if File.directory? p }.compact
+            end
+          end
+        end
+
+        def install_shim
+          super
+          require 'new_relic/agent/instrumentation/controller_instrumentation'
+          ::ActionController::Base.class_eval {
+            include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+          }
+        end
+
+      end
+    end
+  end
+end