dolores_rpm 3.2.0.2

data/lib/new_relic/control/server_methods.rb

@@ -0,0 +1,114 @@
+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:
+    
+    # Contains methods that deal with connecting to the server
+    module ServerMethods
+      
+      def server
+        @remote_server ||= server_from_host(nil)
+      end
+      
+      # the server we should contact for api requests, like uploading
+      # deployments and the like
+      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
+      
+      # a new instances of the proxy server - this passes through if
+      # there is no proxy, otherwise it has proxy configuration
+      # information pulled from the config file
+      def proxy_server
+        @proxy_server ||=
+          NewRelic::Control::ProxyServer.new self['proxy_host'], self['proxy_port'], self['proxy_user'], self['proxy_pass']
+      end
+      
+      # turns a hostname into an ip address and returns a
+      # NewRelic::Control::Server that contains the configuration info
+      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
+      
+      # The path to the certificate file used to verify the SSL
+      # connection if verify_peer is enabled
+      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
+

data/lib/new_relic/control.rb

@@ -0,0 +1,46 @@
+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/frameworks'
+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
+    # done in a subfile for load order purposes
+    # extend ClassMethods
+    # include InstanceMethods
+    # include Profiling
+    # include LoggingMethods
+    # include Configuration
+    # include ServerMethods
+    # include Instrumentation
+
+
+
+  end
+end

data/lib/new_relic/data_serialization.rb

@@ -0,0 +1,157 @@
+require 'fileutils'
+require 'new_relic/language_support'
+
+module NewRelic
+  # Handles serialization of data to disk, to save on contacting the
+  # server. Lowers both server and client overhead, if the disk is not overloaded
+  class DataSerialization
+    include NewRelic::LanguageSupport::DataSerialization
+    
+    module ClassMethods
+      # Check whether the store is too large, too old, or the
+      # pid file is too old. If so, we should send the data
+      # right away. If not, we presumably store it for later sending
+      # (handled elsewhere)
+      def should_send_data?
+        NewRelic::Control.instance.disable_serialization? || store_too_large? ||
+          store_too_old? || pid_too_old?
+      rescue Exception => e
+        NewRelic::Control.instance.disable_serialization = true
+        NewRelic::Control.instance.log.warn("Disabling serialization: #{e.message}")
+        true
+      end
+
+      # A combined locked read/write from the store file - reduces
+      # contention by not acquiring the lock and file handle twice
+      def read_and_write_to_file
+        with_locked_store do |f|
+          result = (yield get_data_from_file(f))
+          f.rewind
+          f.truncate(0)
+          write_contents_nonblockingly(f, dump(result)) if result
+        end
+      rescue Errno::ENOENT => e
+        NewRelic::Control.instance.log.warn(e.message)
+      end
+      
+      # touches the age file that determines whether we should send
+      # data now or not
+      def update_last_sent!
+        FileUtils.touch(pid_file_path)
+      end
+      
+      def pid_too_old?
+        create_pid_file unless File.exists?(pid_file_path)
+        age = (Time.now.to_i - File.mtime(pid_file_path).to_i)
+        NewRelic::Control.instance.log.debug("Pid was #{age} seconds old, sending data") if age > 60
+        age > 60
+      end
+      
+      def store_too_old?
+        FileUtils.touch(file_path) unless File.exists?(file_path)
+        age = (Time.now.to_i - File.mtime(file_path).to_i)
+        NewRelic::Control.instance.log.debug("Store was #{age} seconds old, sending data") if age > 60
+        age > 50
+      end      
+    
+      def store_too_large?
+        FileUtils.touch(file_path) unless File.exists?(file_path)
+        size = File.size(file_path) > max_size
+        NewRelic::Control.instance.log.debug("Store was oversize, sending data") if size
+        size
+      end
+      
+      private
+      
+      def open_arguments
+        if defined?(Encoding)
+          [file_path, File::RDWR | File::CREAT, {:internal_encoding => nil}]
+        else
+          [file_path, File::RDWR | File::CREAT]
+        end
+      end
+      
+      def with_locked_store
+        File.open(*open_arguments) do |f|
+          f.flock(File::LOCK_EX)
+          begin
+            yield(f)
+          ensure
+            f.flock(File::LOCK_UN)
+          end
+        end
+      rescue Exception => e
+        NewRelic::Control.instance.log.error("Error serializing data to disk: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.split("\n"))
+      end
+
+      def get_data_from_file(f)
+        data = read_until_eof_error(f)
+        result = load(data)
+        f.truncate(0)
+        result
+      end
+
+      def write_contents_nonblockingly(f, string)
+        result = 0
+        while (result < string.length)
+          result += f.write_nonblock(string)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select(nil, [f])
+        retry
+      end
+
+      def read_until_eof_error(f)
+        accumulator = ""
+        while(true)
+          accumulator << f.read_nonblock(10_000)
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+        IO.select([f])
+        retry
+      rescue EOFError
+        accumulator
+      end
+      
+      def max_size
+        10_000
+      end
+
+      def dump(object)
+        Marshal.dump(object.clone)
+      end
+      
+      def load(dump)
+        if dump.respond_to?(:size) && dump.size == 0
+          NewRelic::Control.instance.log.debug("Spool file empty.")
+          return nil
+        end
+        Marshal.load(dump)
+      rescue ArgumentError, TypeError => e
+        NewRelic::Control.instance.log.error("Error loading data from newrelic_agent_store.db: #{e.inspect}")
+        NewRelic::Control.instance.log.debug(e.backtrace.inspect)
+        nil
+      end
+
+      def truncate_file
+        FileUtils.touch(file_path)
+        File.truncate(file_path, 0)
+      end
+      
+      def create_pid_file
+        File.open(pid_file_path, 'w') {|f| f.write $$ }
+      end
+      
+      def file_path
+        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.db"
+      end
+
+      def pid_file_path
+        "#{NewRelic::Control.instance.log_path}/newrelic_agent_store.pid"
+      end
+    end
+    extend ClassMethods
+  end
+end
+

data/lib/new_relic/delayed_job_injection.rb

@@ -0,0 +1,46 @@
+require 'dependency_detection'
+# This installs some code to manually start the agent when a delayed
+# job worker starts.  It's not really instrumentation.  It's more like
+# a hook from DJ to the Ruby Agent so it gets loaded at the time the
+# Ruby Agent initializes, which must be before the DJ worker
+# initializes.  Loaded from control.rb
+module NewRelic
+  module DelayedJobInjection
+    extend self
+    attr_accessor :worker_name
+  end
+end
+
+DependencyDetection.defer do
+  @name = :delayed_job_injection
+  
+  depends_on do
+    defined?(::Delayed) && defined?(::Delayed::Worker) && !NewRelic::Control.instance['disable_dj']
+  end
+  
+  executes do
+    if NewRelic::Agent.respond_to?(:logger)
+      NewRelic::Agent.logger.debug 'Installing DelayedJob instrumentation hooks'
+    end
+  end
+  
+  executes do
+    Delayed::Worker.class_eval do
+      def initialize_with_new_relic(*args)
+        initialize_without_new_relic(*args)
+        worker_name = case
+                      when self.respond_to?(:name) then self.name
+                      when self.class.respond_to?(:default_name) then self.class.default_name
+                      end
+        dispatcher_instance_id = worker_name || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+        say "New Relic Ruby Agent Monitoring DJ worker #{dispatcher_instance_id}"
+        NewRelic::DelayedJobInjection.worker_name = worker_name
+        NewRelic::Control.instance.init_plugin :dispatcher => :delayed_job, :dispatcher_instance_id => dispatcher_instance_id
+      end
+
+      alias initialize_without_new_relic initialize
+      alias initialize initialize_with_new_relic
+    end
+  end
+end
+DependencyDetection.detect!

data/lib/new_relic/language_support.rb

@@ -0,0 +1,69 @@
+module NewRelic::LanguageSupport
+  extend self
+  
+  module DataSerialization
+    def self.included(base)
+      # need to disable GC during marshal load in 1.8.7
+      if NewRelic::LanguageSupport.using_version?('1.8.7') &&
+          !NewRelic::LanguageSupport.using_engine?('jruby') &&
+          !NewRelic::LanguageSupport.using_engine?('rbx')
+        base.class_eval do
+          def self.load(*args)
+            if defined?(::GC) && ::GC.respond_to?(:disable)
+              ::GC.disable
+              val = super
+              ::GC.enable
+              val
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  module Control
+    def self.included(base)
+      # need to use syck rather than psych when possible
+      if defined?(::YAML::ENGINE)
+        base.class_eval do
+          def load_newrelic_yml(*args)
+            yamler = ::YAML::ENGINE.yamler
+            ::YAML::ENGINE.yamler = 'syck'
+            val = super
+            ::YAML::ENGINE.yamler = yamler
+            val
+          end
+        end
+      end
+    end
+  end
+  
+  module SynchronizedHash
+    def self.included(base)
+      # need to lock iteration of stats hash in 1.9.x
+      if NewRelic::LanguageSupport.using_version?('1.9') ||
+          NewRelic::LanguageSupport.using_engine?('jruby')
+        base.class_eval do
+          def each(*args, &block)
+            @lock.synchronize { super }
+          end
+        end
+      end
+    end
+  end
+  
+  def using_engine?(engine)
+    if defined?(::RUBY_ENGINE)
+      ::RUBY_ENGINE == engine
+    else
+      engine == 'ruby'
+    end
+  end
+  
+  def using_version?(version)
+    numbers = version.split('.')
+    numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
+  end
+end