newrelic_rpm 6.0.0.351 → 6.1.0.352

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ab526e3b85c3d323b557163c7213681e1783c0c6ac9f29bf53dad5dd421a92
-  data.tar.gz: ba03925e985ecaf44b0b56375cb0c38532c2473cf87440c2b7f2c4fccea3d744
+  metadata.gz: 73929ba01fea0db2f54b9977a41dfc7b710d51f38b9d07a8f0d96e8525a8574a
+  data.tar.gz: cb28508e22221fe2c0869a247ee9796ea9a07f595ca51679eee9fd5b75027d1a
 SHA512:
-  metadata.gz: 811d5a9f971f18d5e66a2b0826d003603b5771b8378906ee1594ec95834593f31a668e8d8084cbd84db8f0e3d367d93620ed87b86e047c31d20b115cd4c8cfb6
-  data.tar.gz: 115f4a4d0c6186546cdd6d698279e5d60b26a67d7749bd2959c44f0478f594621e78e4785a8b6508d78c986e5a19d6dcb5df145f9891eb323432141336e72845
+  metadata.gz: 0e8c015d61f300f5460a8c2a4e38d8baf74917529d4f17bc8218114e2a71b6b8cb9cdc520b68e301f2a6733b8026f6bf4815709374ba6c7de6fc60ec622d9775
+  data.tar.gz: d61094c98597fe88fb0d947b9ab6ea68f450e89dc592ab29116a000f06ca2acea7958a7d130619eecad1e94b908fd201e811cd6a27e5936db65876dcaaa489cf

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # New Relic Ruby Agent Release Notes #
 
+## v6.1.0
+
+   * Performance monitoring on Kubernetes
+
+     This release adds Transaction event attributes that provide
+     context between your Kubernetes cluster and services. For details
+     on the benefits, see this [blog
+     post](https://blog.newrelic.com/engineering/monitoring-application-performance-in-kubernetes/).
+
+   * Bugfix for Bunny instrumentation when popping empty queues
+
+     When a customer calls `Bunny::Queue#pop` on an empty queue, Bunny
+     returns a `nil` value.  Previous Ruby Agent versions raised a
+     `NoMethodError` when trying to process this result.  Now, the
+     agent correctly skips processing for `nil` values.  Thanks to
+     Matt Campbell for the contribution.
+
 ## v6.0.0
 
    * Tracer API for flexible custom instrumentation

data/lib/new_relic/agent.rb

@@ -76,7 +76,11 @@ module NewRelic
     class ForceDisconnectException < StandardError; end
 
     # An exception that forces an agent to restart.
-    class ForceRestartException < StandardError; end
+    class ForceRestartException < StandardError
+      def message
+        "#{super}, restarting."
+      end
+    end
 
     # Used to blow out of a periodic task without logging a an error, such as for routine
     # failures.

data/lib/new_relic/agent/agent.rb

@@ -624,7 +624,7 @@ module NewRelic
           # is the worker thread that gathers data and talks to the
           # server.
           def handle_force_disconnect(error)
-            ::NewRelic::Agent.logger.warn "New Relic forced this agent to disconnect (#{error.message})"
+            ::NewRelic::Agent.logger.warn "Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})"
             disconnect
           end
 
@@ -632,7 +632,7 @@ module NewRelic
           # it and disconnecting the agent, since we are now in an
           # unknown state.
           def handle_other_error(error)
-            ::NewRelic::Agent.logger.error "Unhandled error in worker thread, disconnecting this agent process:"
+            ::NewRelic::Agent.logger.error "Unhandled error in worker thread, disconnecting."
             # These errors are fatal (that is, they will prevent the agent from
             # reporting entirely), so we really want backtraces when they happen
             ::NewRelic::Agent.logger.log_exception(:error, error)
@@ -1119,6 +1119,8 @@ module NewRelic
             @agent_command_router.check_for_and_handle_agent_commands
           rescue ForceRestartException, ForceDisconnectException
             raise
+          rescue UnrecoverableServerException => e
+            NewRelic::Agent.logger.warn("get_agent_commands message was rejected by remote service, discarding. Error: ", e)
           rescue ServerConnectionException => e
             log_remote_unavailable(:get_agent_commands, e)
           rescue => e

data/lib/new_relic/agent/configuration/default_source.rb

@@ -1694,6 +1694,13 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, the agent automatically detects that it is running in Docker.'
         },
+        :'utilization.detect_kubernetes' => {
+          :default     => true,
+          :public      => true,
+          :type        => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, the agent automatically detects that it is running in Kubernetes.'
+        },
         :'utilization.billing_hostname' => {
           :default     => nil,
           :allow_nil   => true,

data/lib/new_relic/agent/configuration/server_source.rb

@@ -103,7 +103,8 @@ module NewRelic
             'error_collector.enabled'        => 'collect_errors',
             'analytics_events.enabled'       => 'collect_analytics_events',
             'custom_insights_events.enabled' => 'collect_custom_events',
-            'error_collector.capture_events' => 'collect_error_events'
+            'error_collector.capture_events' => 'collect_error_events',
+            'span_events.enabled'            => 'collect_span_events'
           }
           gated_features.each do |config_key, gate_key|
             if connect_reply.has_key?(gate_key)

data/lib/new_relic/agent/distributed_trace_payload.rb

@@ -168,7 +168,12 @@ module NewRelic
         @caller_transport_type = PARENT_TRANSPORT_TYPE_UNKNOWN
       end
 
-      def to_json
+      # Represent this payload as a raw JSON string.
+      #
+      # @return [String] Payload translated to JSON
+      #
+      # @api public
+      def text
         result = {
           VERSION_KEY => version
         }
@@ -198,16 +203,7 @@ module NewRelic
       #
       # @api public
       def http_safe
-        Base64.strict_encode64 to_json
-      end
-
-      # Represent this payload as a raw JSON string.
-      #
-      # @return [String] Payload translated to JSON
-      #
-      # @api public
-      def text
-        to_json
+        Base64.strict_encode64 text
       end
 
       def assign_intrinsics transaction, transaction_payload

data/lib/new_relic/agent/hostname.rb

@@ -1,6 +1,7 @@
 # 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 'socket'
 
 module NewRelic
   module Agent
@@ -16,6 +17,13 @@ module NewRelic
         end
       end
 
+      def self.get_fqdn
+        %x[hostname -f].chomp!
+      rescue => e
+        NewRelic::Agent.logger.debug "Unable to determine fqdn #{e}"
+        nil
+      end
+
       def self.heroku_dyno_name_prefix(dyno_name)
         get_dyno_prefixes.find do |dyno_prefix|
           dyno_name.start_with?(dyno_prefix + ".")

data/lib/new_relic/agent/instrumentation/bunny.rb

@@ -57,19 +57,23 @@ DependencyDetection.defer do
         def pop(opts = {:manual_ack => false}, &block)
           t0 = Time.now
           msg = pop_without_new_relic opts, &block
+          delivery_info, message_properties, _payload = msg
 
           begin
-            exchange_name = NewRelic::Agent::Instrumentation::Bunny.exchange_name(msg.first.exchange)
-
-            segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: exchange_name,
-              delivery_info: msg[0],
-              message_properties: msg[1],
-              exchange_type: channel.exchanges[msg.first.exchange].type,
-              queue_name: name,
-              start_time: t0
-            )
+            if delivery_info
+              exchange_name = NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange)
+              exchange_type = NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel)
+
+              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+                library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
+                destination_name: exchange_name,
+                delivery_info: delivery_info,
+                message_properties: message_properties,
+                exchange_type: exchange_type,
+                queue_name: name,
+                start_time: t0
+              )
+            end
 
           rescue => e
             NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#pop", e

data/lib/new_relic/agent/instrumentation/curb.rb

@@ -112,13 +112,9 @@ DependencyDetection.defer do
       alias_method :add_without_newrelic, :add
       alias_method :add, :add_with_newrelic
 
-
       # Trace as an External/Multiple call if the first request isn't serial.
       def perform_with_newrelic(&blk)
-        return perform_without_newrelic if
-          self.requests.first &&
-          self.requests.first.respond_to?(:_nr_serial) &&
-          self.requests.first._nr_serial
+        return perform_without_newrelic if first_request_is_serial?
 
         trace_execution_scoped("External/Multiple/Curb::Multi/perform") do
           perform_without_newrelic(&blk)
@@ -198,6 +194,23 @@ DependencyDetection.defer do
         request._nr_instrumented = false
       end
 
+      private
+
+      def first_request_is_serial?
+        return false unless (first = self.requests.first)
+
+        # Before curb 0.9.8, requests was an array of Curl::Easy
+        # instances.  Starting with 0.9.8, it's a Hash where the
+        # values are Curl::Easy instances.
+        #
+        # So, requests.first will either be an_obj or [a_key, an_obj].
+        # We need to handle either case.
+        #
+        first = first[-1] if first.is_a?(Array)
+
+        first.respond_to?(:_nr_serial) && first._nr_serial
+      end
+
     end # class Curl::Multi
 
   end

data/lib/new_relic/agent/new_relic_service.rb

@@ -16,7 +16,7 @@ module NewRelic
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
 
-      PROTOCOL_VERSION = 16
+      PROTOCOL_VERSION = 17
 
       # 1f147a42: v10 (tag 3.5.3.17)
       # cf0d1ff1: v9 (tag 3.5.0)
@@ -43,6 +43,7 @@ module NewRelic
         @in_session = nil
         @agent_id = nil
         @shared_tcp_connection = nil
+        @request_headers_map = nil
         reset_remote_method_uris
 
         @audit_logger = ::NewRelic::Agent::AuditLogger.new
@@ -69,6 +70,7 @@ module NewRelic
       end
 
       def connect(settings={})
+        @request_headers_map = nil
         security_policies = nil
         if response = preconnect
           if host = response['redirect_host']
@@ -80,6 +82,7 @@ module NewRelic
           end
         end
         response = invoke_remote(:connect, [settings])
+        @request_headers_map = response['request_headers_map']
         self.agent_id = response['agent_run_id']
         response.merge!(security_policies) if security_policies
         response
@@ -404,7 +407,7 @@ module NewRelic
       def invoke_remote(method, payload = [], options = {})
         start_ts = Time.now
 
-        data, size, serialize_finish_ts = nil
+        data, size, serialize_finish_ts, request_send_ts, response_check_ts = nil
         begin
           data = @marshaller.dump(payload, options)
         rescue StandardError, SystemStackError => e
@@ -419,13 +422,16 @@ module NewRelic
         full_uri = "#{@collector}#{uri}"
 
         @audit_logger.log_request(full_uri, payload, @marshaller)
+        request_send_ts = Time.now
         response = send_request(:data      => data,
                                 :uri       => uri,
                                 :encoding  => encoding,
-                                :collector => @collector)
+                                :collector => @collector,
+                                :endpoint  => method)
+        response_check_ts = Time.now
         @marshaller.load(decompress_response(response))
       ensure
-        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
+        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
         if size
           record_size_supportability_metrics(method, size, options[:item_count])
         end
@@ -440,11 +446,12 @@ module NewRelic
         raise error
       end
 
-      def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
+      def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
         serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
-        duration = (Time.now - start_ts).to_f
-        NewRelic::Agent.record_metric("Supportability/invoke_remote", duration)
-        NewRelic::Agent.record_metric("Supportability/invoke_remote/#{method.to_s}", duration)
+        request_duration = response_check_ts && (response_check_ts - request_send_ts).to_f
+        if request_duration
+          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method.to_s}/Duration", request_duration)
+        end
         if serialize_time
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
           NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
@@ -489,10 +496,16 @@ module NewRelic
       #                    contact
       #  - :data => the data to send as the body of the request
       def send_request(opts)
+        headers = {
+          'Content-Encoding' => opts[:encoding],
+          'Host'             => opts[:collector].name
+        }
+        headers.merge!(@request_headers_map) if @request_headers_map
+
         if Agent.config[:put_for_data_send]
-          request = Net::HTTP::Put.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+          request = Net::HTTP::Put.new(opts[:uri], headers)
         else
-          request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
+          request = Net::HTTP::Post.new(opts[:uri], headers)
         end
         request['user-agent'] = user_agent
         request.content_type = "application/octet-stream"
@@ -501,6 +514,7 @@ module NewRelic
         response     = nil
         attempts     = 0
         max_attempts = 2
+        endpoint     = opts[:endpoint]
 
         begin
           attempts += 1
@@ -522,20 +536,43 @@ module NewRelic
         log_response(response)
 
         case response
-        when Net::HTTPSuccess
+        when Net::HTTPSuccess,
+             Net::HTTPAccepted
           true # do nothing
-        when Net::HTTPUnauthorized
-          raise LicenseException, 'Invalid license key, please visit support.newrelic.com'
-        when Net::HTTPServiceUnavailable
-          raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
-        when Net::HTTPGatewayTimeOut
-          raise ServerConnectionException, "Gateway timeout (#{response.code}): #{response.message}"
-        when Net::HTTPRequestEntityTooLarge
-          raise UnrecoverableServerException, '413 Request Entity Too Large'
-        when Net::HTTPUnsupportedMediaType
-          raise UnrecoverableServerException, '415 Unsupported Media Type'
+        when Net::HTTPRequestTimeOut,
+             Net::HTTPTooManyRequests,
+             Net::HTTPInternalServerError,
+             Net::HTTPServiceUnavailable
+          record_endpoint_attempts_supportability_metrics(endpoint)
+          raise ServerConnectionException, "#{response.code}: #{response.message}"
+        when Net::HTTPBadRequest,
+             Net::HTTPForbidden,
+             Net::HTTPNotFound,
+             Net::HTTPMethodNotAllowed,
+             Net::HTTPProxyAuthenticationRequired,
+             Net::HTTPLengthRequired,
+             Net::HTTPRequestEntityTooLarge,
+             Net::HTTPRequestURITooLong,
+             Net::HTTPUnsupportedMediaType,
+             Net::HTTPExpectationFailed,
+             Net::HTTPUnsupportedMediaType,
+             Net::HTTPRequestHeaderFieldsTooLarge
+          record_endpoint_attempts_supportability_metrics(endpoint)
+          record_error_response_supportability_metrics(response.code)
+          raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+        when Net::HTTPConflict,
+             Net::HTTPUnauthorized
+          record_endpoint_attempts_supportability_metrics(endpoint)
+          record_error_response_supportability_metrics(response.code)
+          raise ForceRestartException, "#{response.code}: #{response.message}"
+        when Net::HTTPGone
+          record_endpoint_attempts_supportability_metrics(endpoint)
+          record_error_response_supportability_metrics(response.code)
+          raise ForceDisconnectException, "#{response.code}: #{response.message}"
         else
-          raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
+          record_endpoint_attempts_supportability_metrics(endpoint)
+          record_error_response_supportability_metrics(response.code)
+          raise UnrecoverableServerException, "#{response.code}: #{response.message}"
         end
         response
       end
@@ -544,6 +581,16 @@ module NewRelic
         ::NewRelic::Agent.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
       end
 
+      # Per protocol 17, this metric should be recorded for all error response codes
+      # that cause data to be discarded.
+      def record_error_response_supportability_metrics(response_code)
+        ::NewRelic::Agent.increment_metric("Supportability/Agent/Collector/HTTPError/#{response_code}")
+      end
+
+      def record_endpoint_attempts_supportability_metrics(endpoint)
+        ::NewRelic::Agent.increment_metric("Supportability/Agent/Collector/#{endpoint}/Attempts")
+      end
+
       # Decompresses the response from the server, if it is gzip
       # encoded, otherwise returns it verbatim
       def decompress_response(response)
@@ -566,9 +613,6 @@ module NewRelic
         zlib_version << "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
         "NewRelic-RubyAgent/#{NewRelic::VERSION::STRING} #{ruby_description}#{zlib_version}"
       end
-
-      # Used to wrap errors reported to agent by the collector
-      class CollectorError < StandardError; end
     end
   end
 end

data/lib/new_relic/agent/new_relic_service/marshaller.rb

@@ -6,24 +6,6 @@ module NewRelic
   module Agent
     class NewRelicService
       class Marshaller
-        def parsed_error(error)
-          error_type    = error['error_type']
-          error_message = error['message']
-
-          exception = case error_type
-          when 'NewRelic::Agent::LicenseException'
-            LicenseException.new(error_message)
-          when 'NewRelic::Agent::ForceRestartException'
-            ForceRestartException.new(error_message)
-          when 'NewRelic::Agent::ForceDisconnectException'
-            ForceDisconnectException.new(error_message)
-          else
-            CollectorError.new("#{error['error_type']}: #{error['message']}")
-          end
-
-          exception
-        end
-
         def prepare(data, options={})
           encoder = options[:encoder] || default_encoder
           if data.respond_to?(:to_collector_array)
@@ -46,15 +28,12 @@ module NewRelic
         protected
 
         def return_value(data)
-          if data.respond_to?(:has_key?)
-            if data.has_key?('exception')
-              raise parsed_error(data['exception'])
-            elsif data.has_key?('return_value')
-              return data['return_value']
-            end
+          if data.respond_to?(:has_key?) && data.has_key?('return_value')
+            data['return_value']
+          else
+            ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
+            nil
           end
-          ::NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
-          nil
         end
       end
     end

data/lib/new_relic/agent/system_info.rb

@@ -8,6 +8,7 @@
 # the requested information is unavailable.
 
 require 'rbconfig'
+require 'socket'
 
 module NewRelic
   module Agent
@@ -30,6 +31,10 @@ module NewRelic
 
       @processor_info = nil
 
+      def self.ip_addresses
+        Socket.ip_address_list.map(&:ip_address)
+      end
+
       def self.clear_processor_info
         @processor_info = nil
       end

data/lib/new_relic/agent/utilization_data.rb

@@ -7,10 +7,11 @@ require 'new_relic/agent/utilization/gcp'
 require 'new_relic/agent/utilization/azure'
 require 'new_relic/agent/utilization/pcf'
 
+
 module NewRelic
   module Agent
     class UtilizationData
-      METADATA_VERSION = 3
+      METADATA_VERSION = 5
 
       VENDORS = {
         Utilization::AWS   => :'utilization.detect_aws',
@@ -23,6 +24,14 @@ module NewRelic
         NewRelic::Agent::Hostname.get
       end
 
+      def fqdn
+        NewRelic::Agent::Hostname.get_fqdn
+      end
+
+      def ip_addresses
+        ::NewRelic::Agent::SystemInfo.ip_addresses
+      end
+
       def container_id
         ::NewRelic::Agent::SystemInfo.docker_container_id
       end
@@ -69,6 +78,9 @@ module NewRelic
         append_docker_info(result)
         append_configured_values(result)
         append_boot_id(result)
+        append_ip_address(result)
+        append_full_hostname(result)
+        append_kubernetes_info(result)
 
         result
       end
@@ -105,6 +117,29 @@ module NewRelic
         end
       end
 
+      def append_ip_address(collector_hash)
+        ips = ip_addresses
+        collector_hash[:ip_address] = ips unless ips.empty?
+      end
+
+      KUBERNETES_SERVICE_HOST = 'KUBERNETES_SERVICE_HOST'.freeze
+
+      def append_kubernetes_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_kubernetes']
+        if host = ENV[KUBERNETES_SERVICE_HOST]
+          collector_hash[:vendors] ||= {}
+          collector_hash[:vendors][:kubernetes] = {
+            kubernetes_service_host: host
+          }
+        end
+      end
+
+      def append_full_hostname(collector_hash)
+        full_hostname = fqdn
+        return if full_hostname.nil? || full_hostname.empty?
+        collector_hash[:full_hostname] = full_hostname
+      end
+
       def config_hash
         config_hash = {}
 

data/lib/new_relic/version.rb

@@ -11,7 +11,7 @@ module NewRelic
     end
 
     MAJOR = 6
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
 
     begin

data/newrelic_rpm.gemspec

@@ -54,6 +54,6 @@ EOS
   if RUBY_PLATFORM == 'java'
     s.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
   else
-    s.add_development_dependency 'sqlite3'
+    s.add_development_dependency 'sqlite3', '~> 1.3.13'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 6.0.0.351
+  version: 6.1.0.352
 platform: ruby
 authors:
 - Matthew Wear
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-23 00:00:00.000000000 Z
+date: 2019-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -143,16 +143,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.13
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.13
 description: |
   New Relic is a performance management system, developed by New Relic,
   Inc (http://www.newrelic.com).  New Relic provides you with deep