newrelic_rpm 3.9.7.266 → 3.9.8.273

data/lib/new_relic/agent/new_relic_service.rb

@@ -26,6 +26,10 @@ module NewRelic
       # 1754:  v3 (tag 2.3.0)
       # 534:   v2 (shows up in 2.1.0, our first tag)
 
+      # These include Errno connection errors, and all indicate that the
+      # underlying TCP connection may be in a bad state.
+      CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+
       attr_accessor :request_timeout, :agent_id
       attr_reader :collector, :marshaller, :metric_id_cache
 
@@ -162,12 +166,20 @@ module NewRelic
         invoke_remote(:get_xray_metadata, [@agent_id, *xray_ids])
       end
 
-      # Send fine-grained analytic data to the collector.
       def analytic_event_data(data)
         invoke_remote(:analytic_event_data, [@agent_id, data],
           :item_count => data.size)
       end
 
+      def custom_event_data(data)
+        invoke_remote(:custom_event_data, [@agent_id, data],
+          :item_count => data.size)
+      end
+
+      def utilization_data(data)
+        invoke_remote(:utilization_data, data)
+      end
+
       # We do not compress if content is smaller than 64kb.  There are
       # problems with bugs in Ruby in some versions that expose us
       # to a risk of segfaults if we compress aggressively.
@@ -189,15 +201,17 @@ module NewRelic
 
         begin
           t0 = Time.now
+          @in_session = true
           if NewRelic::Agent.config[:aggressive_keepalive]
             session_with_keepalive(&block)
           else
             session_without_keepalive(&block)
           end
-        rescue Timeout::Error
+        rescue *CONNECTION_ERRORS => e
           elapsed = Time.now - t0
-          ::NewRelic::Agent.logger.warn "Timed out opening connection to collector after #{elapsed} seconds. If this problem persists, please see http://status.newrelic.com"
-          raise
+          raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to #{@collector} after #{elapsed} seconds: #{e}"
+        ensure
+          @in_session = false
         end
       end
 
@@ -217,10 +231,7 @@ module NewRelic
 
       def establish_shared_connection
         unless @shared_tcp_connection
-          connection = create_http_connection
-          NewRelic::Agent.logger.debug("Opening shared TCP connection to #{connection.address}:#{connection.port}")
-          NewRelic::TimerLib.timeout(@request_timeout) { connection.start }
-          @shared_tcp_connection = connection
+          @shared_tcp_connection = create_and_start_http_connection
         end
         @shared_tcp_connection
       end
@@ -233,11 +244,54 @@ module NewRelic
         end
       end
 
+      def ssl_cert_store
+        path = cert_file_path
+        if !@ssl_cert_store || path != @cached_cert_store_path
+          ::NewRelic::Agent.logger.debug("Creating SSL certificate store from file at #{path}")
+          @ssl_cert_store = OpenSSL::X509::Store.new
+          @ssl_cert_store.add_file(path)
+          @cached_cert_store_path = path
+        end
+        @ssl_cert_store
+      end
+
       # Return a Net::HTTP connection object to make a call to the collector.
       # We'll reuse the same handle for cases where we're using keep-alive, or
       # otherwise create a new one.
       def http_connection
-        @shared_tcp_connection || create_http_connection
+        if @in_session
+          establish_shared_connection
+        else
+          create_http_connection
+        end
+      end
+
+      def setup_connection_for_ssl(conn)
+        # Jruby 1.6.8 requires a gem for full ssl support and will throw
+        # an error when use_ssl=(true) is called and jruby-openssl isn't
+        # installed
+        conn.use_ssl     = true
+        conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        conn.cert_store  = ssl_cert_store
+      rescue StandardError, LoadError
+        msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
+        msg << "Either disable SSL in the agent configuration, or install SSL support."
+        raise UnrecoverableAgentException.new(msg)
+      end
+
+      def start_connection(conn)
+        NewRelic::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
+        NewRelic::TimerLib.timeout(@request_timeout) { conn.start }
+        conn
+      end
+
+      def setup_connection_timeouts(conn)
+        # We use Timeout explicitly instead of this
+        conn.read_timeout = nil
+
+        if conn.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
+          conn.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
+        end
       end
 
       # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
@@ -247,30 +301,19 @@ module NewRelic
         http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
                                       proxy_server.user, proxy_server.password)
 
-        http = http_class.new((@collector.ip || @collector.name), @collector.port)
-        if Agent.config[:ssl]
-          begin
-            # Jruby 1.6.8 requires a gem for full ssl support and will throw
-            # an error when use_ssl=(true) is called and jruby-openssl isn't
-            # installed
-            http.use_ssl = true
-            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            http.ca_file = cert_file_path
-          rescue StandardError, LoadError
-            msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
-            msg << "Either disable SSL in the agent configuration, or install SSL support."
-            raise UnrecoverableAgentException.new(msg)
-          end
-        end
-
-        if http.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
-          http.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
-        end
+        conn = http_class.new((@collector.ip || @collector.name), @collector.port)
+        setup_connection_for_ssl(conn) if Agent.config[:ssl]
+        setup_connection_timeouts(conn)
 
-        ::NewRelic::Agent.logger.debug("Created net/http handle to #{http.address}:#{http.port}")
-        http
+        ::NewRelic::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
+        conn
       end
 
+      def create_and_start_http_connection
+        conn = create_http_connection
+        start_connection(conn)
+        conn
+      end
 
       # The path to the certificate file used to verify the SSL
       # connection if verify_peer is enabled
@@ -405,13 +448,27 @@ module NewRelic
         request.content_type = "application/octet-stream"
         request.body = opts[:data]
 
-        response = nil
-        http = http_connection
-        http.read_timeout = nil
-        NewRelic::TimerLib.timeout(@request_timeout) do
+        response     = nil
+        attempts     = 0
+        max_attempts = 2
+
+        begin
+          attempts += 1
+          conn = http_connection
           ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
-          response = http.request(request)
+          NewRelic::TimerLib.timeout(@request_timeout) do
+            response = conn.request(request)
+          end
+        rescue *CONNECTION_ERRORS => e
+          close_shared_connection
+          if attempts < max_attempts
+            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+            retry
+          else
+            raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
+          end
         end
+
         case response
         when Net::HTTPSuccess
           true # do nothing
@@ -420,7 +477,7 @@ module NewRelic
         when Net::HTTPServiceUnavailable
           raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
         when Net::HTTPGatewayTimeOut
-          raise Timeout::Error, response.message
+          raise ServerConnectionException, "Gateway timeout (#{response.code}): #{response.message}"
         when Net::HTTPRequestEntityTooLarge
           raise UnrecoverableServerException, '413 Request Entity Too Large'
         when Net::HTTPUnsupportedMediaType
@@ -429,15 +486,8 @@ module NewRelic
           raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
         end
         response
-      rescue Timeout::Error, EOFError, SystemCallError, SocketError => e
-        # These include Errno connection errors, and all signify that the
-        # connection may be in a bad state, so drop it and re-create if needed.
-        close_shared_connection
-        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to #{@collector}: #{e}"
       end
 
-
-
       # Decompresses the response from the server, if it is gzip
       # encoded, otherwise returns it verbatim
       def decompress_response(response)

data/lib/new_relic/agent/pipe_service.rb

@@ -32,6 +32,10 @@ module NewRelic
         write_to_pipe(:analytic_event_data, events) if events
       end
 
+      def custom_event_data(events)
+        write_to_pipe(:custom_event_data, events) if events
+      end
+
       def metric_data(unsent_timeslice_data)
         write_to_pipe(:metric_data, unsent_timeslice_data)
         {}

data/lib/new_relic/agent/synthetics_event_buffer.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/event_buffer'
+require 'new_relic/agent/sized_buffer'
+
+module NewRelic
+  module Agent
+    class SyntheticsEventBuffer < SizedBuffer
+
+      def append_with_reject(x)
+        @seen += 1
+        if full?
+          timestamp = timestamp_for(x)
+          latest_event = @items.max_by do |item|
+            timestamp_for(item)
+          end
+
+          if timestamp < timestamp_for(latest_event)
+            # Make room!
+            @items.delete(latest_event)
+            return [append_event(x), latest_event]
+          else
+            return [nil, x]
+          end
+        else
+          return [append_event(x), nil]
+        end
+      end
+
+      TIMESTAMP = "timestamp".freeze
+
+      def timestamp_for(event)
+        main_event, _ = event
+        main_event[TIMESTAMP]
+      end
+
+    end
+  end
+end
+

data/lib/new_relic/agent/system_info.rb

@@ -24,37 +24,41 @@ module NewRelic
         if @processor_info.nil?
           case ruby_os_identifier
 
-          when /darwin/, /freebsd/
+          when /darwin/
             @processor_info = {
-              :num_physical_packages  => `sysctl -n hw.packages`.to_i,
-              :num_physical_cores     => `sysctl -n hw.physicalcpu_max`.to_i,
-              :num_logical_processors => `sysctl -n hw.logicalcpu_max`.to_i
+              :num_physical_packages  => sysctl_value('hw.packages').to_i,
+              :num_physical_cores     => sysctl_value('hw.physicalcpu_max').to_i,
+              :num_logical_processors => sysctl_value('hw.logicalcpu_max').to_i
             }
             # in case those don't work, try backup values
             if @processor_info[:num_physical_cores] <= 0
-              @processor_info[:num_physical_cores] = `sysctl -n hw.physicalcpu`.to_i
+              @processor_info[:num_physical_cores] = sysctl_value('hw.physicalcpu').to_i
             end
             if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = `sysctl -n hw.logicalcpu`.to_i
+              @processor_info[:num_logical_processors] = sysctl_value('hw.logicalcpu').to_i
             end
             if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = `sysctl -n hw.ncpu`.to_i
-            end
-            if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = `sysctl -n hw.availcpu`.to_i
-            end
-            if @processor_info[:num_logical_processors] <= 0
-              @processor_info[:num_logical_processors] = `sysctl -n hw.activecpu`.to_i
+              @processor_info[:num_logical_processors] = sysctl_value('hw.ncpu').to_i
             end
 
           when /linux/
             cpuinfo = proc_try_read('/proc/cpuinfo')
             @processor_info = cpuinfo ? parse_cpuinfo(cpuinfo) : {}
+
+          when /freebsd/
+            @processor_info = {
+              :num_physical_packages  => nil,
+              :num_physical_cores     => nil,
+              :num_logical_processors => sysctl_value('hw.ncpu').to_i
+            }
           end
 
           # give nils for obviously wrong values
           @processor_info.keys.each do |key|
-            @processor_info[key] = nil if @processor_info[key] <= 0
+            value = @processor_info[key]
+            if value.is_a?(Numeric) && value <= 0
+              @processor_info[key] = nil
+            end
           end
         end
 
@@ -63,6 +67,11 @@ module NewRelic
         {}
       end
 
+      def self.sysctl_value(name)
+        # make sure to redirect stderr so we don't spew if the name is unknown
+        `sysctl -n #{name} 2>/dev/null`
+      end
+
       def self.parse_cpuinfo(cpuinfo)
         # Build a hash of the form
         #   { [phys_id, core_id] => num_logical_processors_on_this_core }
@@ -135,8 +144,22 @@ module NewRelic
 
       def self.parse_docker_container_id(cgroup_info)
         cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
-        return unless cpu_cgroup && cpu_cgroup =~ %r{^/docker/(.*)}
-        return $1
+        return unless cpu_cgroup
+
+        case cpu_cgroup
+        # docker native driver w/out systemd (fs)
+        when %r{^/docker/([0-9a-f]+)$}                      then $1
+        # docker native driver with systemd
+        when %r{^/system\.slice/docker-([0-9a-f]+)\.scope$} then $1
+        # docker lxc driver
+        when %r{^/lxc/([0-9a-f]+)$}                         then $1
+        # not in any cgroup
+        when '/'                                            then nil
+        # in a cgroup, but we don't recognize its format
+        else
+          ::NewRelic::Agent.logger.debug("Ignoring unrecognized cgroup ID format: '#{cpu_cgroup}'")
+          nil
+        end
       end
 
       def self.parse_cgroup_ids(cgroup_info)
@@ -145,8 +168,11 @@ module NewRelic
         cgroup_info.split("\n").each do |line|
           parts = line.split(':')
           next unless parts.size == 3
-          _, type, cgroup_id = parts
-          cgroup_ids[type] = cgroup_id
+          _, subsystems, cgroup_id = parts
+          subsystems = subsystems.split(',')
+          subsystems.each do |subsystem|
+            cgroup_ids[subsystem] = cgroup_id
+          end
         end
 
         cgroup_ids

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -39,7 +39,7 @@ class NewRelic::Agent::TransactionEventAggregator
     @notified_full = false
 
     @samples            = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[:'analytics_events.max_samples_stored'])
-    @synthetics_samples = ::NewRelic::Agent::SizedBuffer.new(NewRelic::Agent.config[:'synthetics.events_limit'])
+    @synthetics_samples = ::NewRelic::Agent::SyntheticsEventBuffer.new(NewRelic::Agent.config[:'synthetics.events_limit'])
 
     event_listener.subscribe( :transaction_finished, &method(:on_transaction_finished) )
     self.register_config_callbacks
@@ -152,8 +152,15 @@ class NewRelic::Agent::TransactionEventAggregator
 
   def append_event(event)
     main_event, _ = event
+
     if main_event.include?(SYNTHETICS_RESOURCE_ID_KEY)
-      @synthetics_samples.append(event)
+      # Try adding to synthetics buffer. If anything is rejected, give it a
+      # shot in the main transaction events (where it may get sampled)
+      result, rejected = @synthetics_samples.append_with_reject(event)
+
+      if rejected
+        @samples.append(rejected)
+      end
     else
       @samples.append(event)
     end

data/lib/new_relic/agent/utilization_data.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    class UtilizationData
+
+      REMOTE_DATA_VALID_CHARS = /^[0-9a-zA-Z_ .\/-]$/.freeze
+
+      def harvest!
+        [hostname, container_id, cpu_count, instance_type]
+      end
+
+      # No persistent data, so no need for merging or resetting
+      def merge!(*_); end
+      def reset!(*_); end
+
+      def hostname
+        NewRelic::Agent::Hostname.get
+      end
+
+      def container_id
+        ::NewRelic::Agent::SystemInfo.docker_container_id
+      end
+
+      def cpu_count
+        ::NewRelic::Agent::SystemInfo.clear_processor_info
+        ::NewRelic::Agent::SystemInfo.num_logical_processors
+      end
+
+      def instance_type
+        Timeout::timeout(1) do
+          remote_fetch('instance-type')
+        end
+      rescue Timeout::Error
+        NewRelic::Agent.logger.debug("UtilizationData timed out fetching remote keys.")
+        nil
+      rescue StandardError, LoadError => e
+        NewRelic::Agent.logger.debug("UtilizationData encountered error fetching remote keys:\n#{e}")
+        nil
+      end
+
+      INSTANCE_HOST = '169.254.169.254'
+      API_VERSION   = '2008-02-01'
+
+      def remote_fetch(remote_key)
+        uri = URI("http://#{INSTANCE_HOST}/#{API_VERSION}/meta-data/#{remote_key}")
+        request = Net::HTTP::get(uri)
+
+        data = validate_remote_data(request)
+
+        if request && data.nil?
+          NewRelic::Agent.logger.warn("Fetching instance metadata for #{remote_key.inspect} returned invalid data: #{request.inspect}")
+        end
+
+        data
+      end
+
+      def validate_remote_data(data_str)
+        return nil unless data_str.kind_of?(String)
+        return nil unless data_str.size <= 255
+
+        data_str.each_char do |ch|
+          next if ch =~ REMOTE_DATA_VALID_CHARS
+          code_point = ch[0].ord # this works in Ruby 1.8.7 - 2.1.2
+          next if code_point >= 0x80
+
+          return nil # it's in neither set of valid characters
+        end
+
+        data_str
+      end
+
+    end
+  end
+end