ghazel-newrelic_rpm 3.1.0.1

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

@@ -0,0 +1,42 @@
+# A control used when no framework is detected.
+# Looks for a newrelic.yml file in several locations
+# including ./, ./config, $HOME/.newrelic and $HOME/.
+# It loads the settings from the newrelic.yml section
+# based on the value of RUBY_ENV or RAILS_ENV.
+module NewRelic
+  class Control
+    module Frameworks
+      class Ruby < NewRelic::Control
+
+        def env
+          @env ||= ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+        end
+        def root
+          @root ||= ENV['APP_ROOT'] || Dir['.']
+        end
+        # Check a sequence of file locations for newrelic.yml
+        def config_file
+          files = []
+          files << File.join(root,"config","newrelic.yml")
+          files << File.join(root,"newrelic.yml")
+          if ENV["HOME"]
+            files << File.join(ENV["HOME"], ".newrelic", "newrelic.yml")
+            files << File.join(ENV["HOME"], "newrelic.yml")
+          end
+          files << File.expand_path(ENV["NRCONFIG"]) if ENV["NRCONFIG"]
+          files.each do | file |
+            return File.expand_path(file) if File.exists? file
+          end
+          return File.expand_path(files.first)
+        end
+        def to_stdout(msg)
+          STDOUT.puts msg
+        end
+
+        def init_config(options={})
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      class Sinatra < NewRelic::Control::Frameworks::Ruby
+
+        def env
+          @env ||= ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+        end
+
+        # 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.
+        def init_config(options={})
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/control/instance_methods.rb

@@ -0,0 +1,154 @@
+module NewRelic
+  class Control
+    module InstanceMethods
+      # 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
+
+
+      # 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']
+
+        # 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 bundler_gem_list
+        if defined?(Bundler) && Bundler.instance_eval do @load end
+          Bundler.load.specs.map do | spec |
+            version = (spec.respond_to?(:version) && spec.version)
+            spec.name + (version ? "(#{version})" : "")
+          end
+        else
+          []
+        end
+      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)
+          puts "Cannot find or 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 root
+        '.'
+      end
+
+      def newrelic_root
+        self.class.newrelic_root
+      end
+    end
+    include InstanceMethods
+  end
+end

data/lib/new_relic/control/instrumentation.rb

@@ -0,0 +1,81 @@
+module NewRelic
+  class Control
+    module Instrumentation
+      def load_instrumentation_files pattern
+        Dir.glob(pattern) do |file|
+          begin
+            log.debug "Processing instrumentation file '#{file}'"
+            require file.to_s
+          rescue Exception => e
+            log.error "Error loading instrumentation file '#{file}': #{e}"
+            log.debug e.backtrace.join("\n")
+          end
+        end
+      end
+
+      # Install stubs to the proper location so the app code will not fail
+      # if the agent is not running.
+      def install_shim
+        # Once we install instrumentation, you can't undo that by installing the shim.
+        raise "Cannot install the Agent shim after instrumentation has already been installed!" if @instrumented
+        NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
+      end
+
+      # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.
+      # This will load the file synchronously if we've already loaded the default
+      # instrumentation.
+      #
+      def add_instrumentation pattern
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+
+      def install_instrumentation
+        _install_instrumentation
+      end
+
+      def load_samplers
+        agent = NewRelic::Agent.instance
+        NewRelic::Agent::Sampler.sampler_classes.each do | subclass |
+          begin
+            log.debug "#{subclass.name} not supported on this platform." and next if not subclass.supported_on_this_platform?
+            sampler = subclass.new
+            if subclass.use_harvest_sampler?
+              agent.stats_engine.add_harvest_sampler sampler
+              log.debug "Registered #{subclass.name} for harvest time sampling"
+            else
+              agent.stats_engine.add_sampler sampler
+              log.debug "Registered #{subclass.name} for periodic sampling"
+            end
+          rescue NewRelic::Agent::Sampler::Unsupported => e
+            log.info "#{subclass} sampler not available: #{e}"
+          rescue => e
+            log.error "Error registering sampler: #{e}, #{e.backtrace.join("\n")}"
+          end
+        end
+      end
+
+      private
+
+      def _install_instrumentation
+        return if @instrumented
+
+        @instrumented = true
+
+        # Instrumentation for the key code points inside rails for monitoring by NewRelic.
+        # note this file is loaded only if the newrelic agent is enabled (through config/newrelic.yml)
+        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'agent','instrumentation'))
+        @instrumentation_files <<
+        File.join(instrumentation_path, '*.rb') <<
+        File.join(instrumentation_path, app.to_s, '*.rb')
+        @instrumentation_files.each { | pattern |  load_instrumentation_files pattern }
+        DependencyDetection.detect!
+        log.debug "Finished instrumentation"
+      end
+    end
+    include Instrumentation
+  end
+end

data/lib/new_relic/control/logging_methods.rb

@@ -0,0 +1,88 @@
+
+module NewRelic
+  class Control
+    module LoggingMethods
+
+      attr_accessor :log_file
+
+      def log
+        # If we try to get a log before one has been set up, return a stdout log
+        unless @log
+          l = Logger.new(STDOUT)
+          l.level = Logger::INFO
+          return l
+        end
+        @log
+      end
+
+      # send the given message to STDOUT so that it shows
+      # up in the console.  This should be used for important informational messages at boot.
+      # The to_stdout may be implemented differently by different config subclasses.
+      # This will NOT print anything if tracers are not enabled
+      def log!(msg, level=:info)
+        to_stdout msg
+        return unless should_log?
+        log.send level, msg if @log
+      end
+
+      def should_log?
+        @settings && agent_enabled?
+      end
+
+      # set the log level as specified in the config file
+      def set_log_level!(logger)
+        case fetch("log_level","info").downcase
+          when "debug" then logger.level = Logger::DEBUG
+          when "info" then logger.level = Logger::INFO
+          when "warn" then logger.level = Logger::WARN
+          when "error" then logger.level = Logger::ERROR
+          when "fatal" then logger.level = Logger::FATAL
+          else logger.level = Logger::INFO
+        end
+        logger
+      end
+
+      # change the format just for our logger
+      def set_log_format!(logger)
+        def logger.format_message(severity, timestamp, progname, msg)
+          "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
+        end
+        logger
+      end
+
+      # Create the logger using the configuration variables
+      #
+      # Control subclasses may override this, but it can be called multiple times.
+      def setup_log
+        @log_file = "#{log_path}/#{log_file_name}"
+        @log = Logger.new(@log_file) rescue nil
+        if @log
+          set_log_format!(@log)
+          set_log_level!(@log)
+        end
+        # note this is not the variable from above - it is the `log`
+        # method, which returns a default logger if none is setup
+        # above
+        log
+      end
+
+      def to_stdout(msg)
+        STDOUT.puts "** [NewRelic] " + msg
+      end
+
+      def log_path
+        return @log_path if @log_path
+        @log_path = File.expand_path(fetch('log_file_path', 'log/'))
+        if !File.directory?(@log_path) && ! (Dir.mkdir(@log_path) rescue nil)
+          log!("Error creating New Relic log directory '#{@log_path}'", :error)
+        end
+        @log_path
+      end
+
+      def log_file_name
+        fetch('log_file_name', 'newrelic_agent.log')
+      end
+    end
+    include LoggingMethods
+  end
+end

data/lib/new_relic/control/profiling.rb

@@ -0,0 +1,25 @@
+module NewRelic
+  class Control
+    module Profiling
+
+      # A flag used in dev mode to indicate if profiling is available
+      def profiling?
+        @profiling
+      end
+
+      def profiling_available?
+        @profiling_available ||=
+          begin
+            require 'ruby-prof'
+            true
+          rescue LoadError; end
+      end
+      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
+      # loaded a true value is ignored.
+      def profiling=(val)
+        @profiling = profiling_available? && val && defined?(RubyProf)
+      end
+    end
+    include Profiling
+  end
+end

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,104 @@
+module NewRelic
+  class Control
+
+    # Structs holding info for the remote server and proxy server
+    class Server < Struct.new :name, :port, :ip #:nodoc:
+      def to_s; "#{name}:#{port}"; end
+    end
+
+    ProxyServer = Struct.new :name, :port, :user, :password #:nodoc:
+
+    module ServerMethods
+
+      def server
+        @remote_server ||= server_from_host(nil)
+      end
+
+      def api_server
+        api_host = self['api_host'] || 'rpm.newrelic.com'
+        @api_server ||=
+          NewRelic::Control::Server.new \
+        api_host,
+        (self['api_port'] || self['port'] || (use_ssl? ? 443 : 80)).to_i,
+        nil
+      end
+
+      def proxy_server
+        @proxy_server ||=
+          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+      end
+
+      def server_from_host(hostname=nil)
+        host = hostname || self['host'] || 'collector.newrelic.com'
+
+        # if the host is not an IP address, turn it into one
+        NewRelic::Control::Server.new host, (self['port'] || (use_ssl? ? 443 : 80)).to_i, convert_to_ip_address(host)
+      end
+
+      # Check to see if we need to look up the IP address
+      # If it's an IP address already, we pass it through.
+      # If it's nil, or localhost, we don't bother.
+      # Otherwise, use `resolve_ip_address` to find one
+      def convert_to_ip_address(host)
+        # here we leave it as a host name since the cert verification
+        # needs it in host form
+        return host if verify_certificate?
+        return nil if host.nil? || host.downcase == "localhost"
+        ip = resolve_ip_address(host)
+        log.info "Resolved #{host} to #{ip}"
+        ip
+      end
+
+      # Look up the ip address of the host using the pure ruby lookup
+      # to prevent blocking.  If that fails, fall back to the regular
+      # IPSocket library.  Return nil if we can't find the host ip
+      # address and don't have a good default.
+      def resolve_ip_address(host)
+        Resolv.getaddress(host)
+      rescue Exception => e
+        log.warn("DNS Error caching IP address: #{e}")
+        log.debug(e.backtrace.join("\n   "))
+        begin
+          log.info("Trying native DNS lookup since Resolv failed")
+          IPSocket.getaddress(host)
+        rescue Exception => e
+          log.error("Could not look up server address: #{e}")
+          nil
+        end
+      end
+
+      def cert_file_path
+        File.expand_path(File.join(newrelic_root, 'cert', 'cacert.pem'))
+      end
+
+      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
+      # Default is the collector but for api calls you need to pass api_server
+      #
+      # Experimental support for SSL verification:
+      # swap 'VERIFY_NONE' for 'VERIFY_PEER' line to try it out
+      # If verification fails, uncomment the 'http.ca_file' line
+      # and it will use the included certificate.
+      def http_connection(host = nil)
+        host ||= server
+        # Proxy returns regular HTTP if @proxy_host is nil (the default)
+        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
+                                      proxy_server.user, proxy_server.password)
+        http = http_class.new(host.ip || host.name, host.port)
+        log.debug("Http Connection opened to #{host.ip||host.name}:#{host.port}")
+        if use_ssl?
+          http.use_ssl = true
+          if verify_certificate?
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = cert_file_path
+          else
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+        end
+        http
+      end
+    end
+
+    include ServerMethods
+  end
+end
+