newrelic_rpm 6.3.0.355 → 6.8.0.360

data/lib/new_relic/agent/instrumentation/rails_notifications/action_cable.rb

@@ -28,9 +28,8 @@ DependencyDetection.defer do
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
     ActiveSupport.on_load(:action_cable) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-        ::ActionCable::Engine,
-        ::ActionCable::RemoteConnections)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::Engine) if defined?(::ActionCable::Engine)
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::RemoteConnections) if defined?(::ActionCable::RemoteConnections)
     end
   end
 end

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -14,7 +14,7 @@ module NewRelic
       RUM_KEY_LENGTH = 13
 
       def initialize(event_listener)
-        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+        event_listener.subscribe(:initial_configuration_complete, &method(:log_configuration))
       end
 
       def log_configuration

data/lib/new_relic/agent/logging.rb

@@ -0,0 +1,129 @@
+# 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 'json'
+require 'new_relic/agent/hostname'
+
+module NewRelic
+  module Agent
+    module Logging
+
+      # This class can be used as the formatter for an existing logger.  It
+      # decorates log messages with trace and entity metadata, and formats each
+      # log messages as a JSON object.
+      #
+      # It can be added to a Rails application like this:
+      #
+      #   require 'newrelic_rpm'
+      #
+      #   Rails.application.configure do
+      #     config.log_formatter = ::NewRelic::Agent::Logging::DecoratingFormatter.new
+      #   end
+      #
+      # @api public
+      class DecoratingFormatter < ::Logger::Formatter
+        TIMESTAMP_KEY = 'timestamp'.freeze
+        MESSAGE_KEY = 'message'.freeze
+        LOG_LEVEL_KEY = 'log.level'.freeze
+        LOG_NAME_KEY = 'logger.name'.freeze
+        NEWLINE = "\n".freeze
+
+        QUOTE = '"'.freeze
+        COLON = ':'.freeze
+        COMMA = ','.freeze
+        CLOSING_BRACE = '}'.freeze
+
+        def initialize
+          Agent.config.register_callback :app_name do
+            @app_name = nil
+          end
+        end
+
+        def call severity, time, progname, msg
+          message = '{'
+          if app_name
+            add_key_value message, ENTITY_NAME_KEY, app_name
+            message << COMMA
+          end
+          add_key_value message, ENTITY_TYPE_KEY, ENTITY_TYPE
+          message << COMMA
+          add_key_value message, HOSTNAME_KEY, Hostname.get
+
+          if entity_guid = Agent.config[:entity_guid]
+            message << COMMA
+            add_key_value message, ENTITY_GUID_KEY, entity_guid
+          end
+
+          if trace_id = Tracer.trace_id
+            message << COMMA
+            add_key_value message, TRACE_ID_KEY, trace_id
+          end
+          if span_id = Tracer.span_id
+            message << COMMA
+            add_key_value message, SPAN_ID_KEY, span_id
+          end
+
+          message << COMMA
+          message << QUOTE << MESSAGE_KEY << QUOTE << COLON << escape(msg)
+          message << COMMA
+          add_key_value message, LOG_LEVEL_KEY, severity
+          if progname
+            message << COMMA
+            add_key_value message, LOG_NAME_KEY, progname
+          end
+
+          message << COMMA
+          message << QUOTE << TIMESTAMP_KEY << QUOTE << COLON << time.to_f.to_s
+          message << CLOSING_BRACE << NEWLINE
+        end
+
+        def app_name
+          @app_name ||= Agent.config[:app_name][0]
+        end
+
+        def add_key_value message, key, value
+          message << QUOTE << key << QUOTE << COLON << QUOTE << value << QUOTE
+        end
+
+        def escape message
+          if String === message
+            message.to_json
+          else
+            message.inspect.to_json
+          end
+        end
+
+        def clear_tags!
+          # No-op; just avoiding issues with act-fluent-logger-rails
+        end
+      end
+
+
+      # This logger decorates logs with trace and entity metadata, and emits log
+      # messages formatted as JSON objects.  It extends the Logger class from
+      # the Ruby standard library, and accepts the same constructor parameters.
+      #
+      # It aliases the `:info` message to overwrite the `:write` method, so it
+      # can be used in Rack applications that expect the logger to be a file-like
+      # object.
+      #
+      # It can be added to an application like this:
+      #
+      #   require 'newrelic_rpm'
+      #
+      #   config.logger = NewRelic::Agent::Logging::DecoratingLogger.new "log/application.log"
+      #
+      # @api public
+      class DecoratingLogger < (defined?(::ActiveSupport) && defined?(::ActiveSupport::Logger) ? ::ActiveSupport::Logger : ::Logger)
+
+        alias :write :info
+
+        def initialize *args
+          super
+          self.formatter = DecoratingFormatter.new
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -92,14 +92,16 @@ module NewRelic
         token = Agent.config[:security_policies_token]
 
         if token && !token.empty?
-          response = invoke_remote(:preconnect, [{'security_policies_token' => token}])
+          response = invoke_remote(:preconnect, [{'security_policies_token' => token, 'high_security' => false}])
 
           validator = SecurityPolicySettings::Validator.new(response)
           validator.validate_matching_agent_config!
 
           response
+        elsif Agent.config[:high_security]
+          invoke_remote(:preconnect, [{'high_security' => true}])
         else
-          invoke_remote(:preconnect, [])
+          invoke_remote(:preconnect, [{'high_security' => false}])
         end
       end
 
@@ -163,10 +165,6 @@ module NewRelic
         invoke_remote(:agent_command_results, [@agent_id, results])
       end
 
-      def get_xray_metadata(xray_ids)
-        invoke_remote(:get_xray_metadata, [@agent_id, *xray_ids])
-      end
-
       def analytic_event_data(data)
         _, items = data
         invoke_remote(:analytic_event_data, [@agent_id, *data],
@@ -200,10 +198,10 @@ module NewRelic
         encoding = 'identity'
         if data.size > 64 * 1024
           encoding = Agent.config[:compressed_content_encoding]
-          data = if encoding == 'gzip'
-            Encoders::Compressed::Gzip.encode(data)
-          else
+          data = if encoding == 'deflate'
             Encoders::Compressed::Deflate.encode(data)
+          else
+            Encoders::Compressed::Gzip.encode(data)
           end
         end
         check_post_size(data, endpoint)

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -22,6 +22,8 @@ module NewRelic
       def append(priority: nil, event: nil, &blk)
         increment_seen
 
+        return if @capacity == 0
+
         if @seen == @capacity
           @items = Heap.new(@items) { |x| priority_for(x) }
         end

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -13,10 +13,8 @@ module NewRelic
       named :SpanEventAggregator
       capacity_key :'span_events.max_samples_stored'
 
-      enabled_fn -> {
-        NewRelic::Agent.config[:'span_events.enabled'] &&
-        NewRelic::Agent.config[:'distributed_tracing.enabled']
-      }
+      enabled_keys :'span_events.enabled',
+                   :'distributed_tracing.enabled'
 
       def record priority: nil, event:nil, &blk
         unless(event || priority && blk)

data/lib/new_relic/agent/span_event_primitive.rb

@@ -36,6 +36,8 @@ module NewRelic
       PEER_HOSTNAME_KEY    = 'peer.hostname'.freeze
       SPAN_KIND_KEY        = 'span.kind'.freeze
       ENTRY_POINT_KEY      = 'nr.entryPoint'.freeze
+      TRUSTED_PARENT_KEY   = "trustedParentId".freeze
+      TRACING_VENDORS_KEY  = "tracingVendors".freeze
 
       # Strings for static values of the event structure
       EVENT_TYPE         = 'Span'.freeze
@@ -51,7 +53,7 @@ module NewRelic
         intrinsics = intrinsics_for(segment)
         intrinsics[CATEGORY_KEY] = GENERIC_CATEGORY
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        [intrinsics, custom_attributes(segment.attributes), EMPTY_HASH]
       end
 
       def for_external_request_segment(segment)
@@ -68,7 +70,7 @@ module NewRelic
           agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        [intrinsics, custom_attributes(segment.attributes), agent_attributes]
       end
 
       def for_datastore_segment(segment)
@@ -96,7 +98,7 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, EMPTY_HASH, agent_attributes]
+        [intrinsics, custom_attributes(segment.attributes), agent_attributes]
       end
 
       private
@@ -115,19 +117,39 @@ module NewRelic
           NAME_KEY           => segment.name
         }
 
+        if segment.parent.nil?
+          intrinsics[ENTRY_POINT_KEY] = true
+          if segment.transaction
+            if segment.transaction.trace_context_header_data
+              intrinsics[TRACING_VENDORS_KEY] = segment.transaction.trace_context_header_data.trace_state_vendors
+            end
+            if segment.transaction.trace_state_payload
+              intrinsics[TRUSTED_PARENT_KEY] = segment.transaction.trace_state_payload.id
+            end
+          end
+        end
+
         parent_id = parent_guid(segment)
         intrinsics[PARENT_ID_KEY] = parent_id if parent_id
-
-        intrinsics[ENTRY_POINT_KEY] = true unless segment.parent
-
         intrinsics
       end
 
+      def custom_attributes attributes
+        if attributes
+          result = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+          result.freeze
+        else
+          EMPTY_HASH
+        end
+      end
+
       def parent_guid(segment)
         if segment.parent
           segment.parent.guid
-        elsif segment.transaction && segment.transaction.distributed_trace?
+        elsif segment.transaction && segment.transaction.distributed_trace_payload
           segment.transaction.distributed_trace_payload.id
+        elsif segment.transaction && segment.transaction.trace_context_header_data
+          segment.transaction.trace_context_header_data.parent_id
         end
       end
 

data/lib/new_relic/agent/sql_sampler.rb

@@ -162,7 +162,7 @@ module NewRelic
         if transaction && transaction.distributed_trace_payload
           params = {}
           payload = transaction.distributed_trace_payload
-          payload.assign_intrinsics transaction, params
+          DistributedTraceIntrinsics.copy_from_transaction transaction, payload, params
           params[PRIORITY] = transaction.priority
         end
         params

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -36,8 +36,8 @@ module NewRelic
           @worker_loop = NewRelic::Agent::WorkerLoop.new
 
           # Memoize overhead % to avoid getting stale OR looked up every poll
-          @overhead_percent_threshold = NewRelic::Agent.config[:'xray_session.max_profile_overhead']
-          NewRelic::Agent.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
+          @overhead_percent_threshold = NewRelic::Agent.config[:'thread_profiler.max_profile_overhead']
+          NewRelic::Agent.config.register_callback(:'thread_profiler.max_profile_overhead') do |new_value|
             @overhead_percent_threshold = new_value
           end
 
@@ -213,7 +213,7 @@ module NewRelic
             if @buffer[thread].length < MAX_BUFFER_LENGTH
               @buffer[thread] << [timestamp, backtrace]
             else
-              NewRelic::Agent.increment_metric('Supportability/XraySessions/DroppedBacktraces')
+              NewRelic::Agent.increment_metric('Supportability/ThreadProfiler/DroppedBacktraces')
             end
           end
         end

data/lib/new_relic/agent/threading/thread_profile.rb

@@ -16,7 +16,7 @@ module NewRelic
 
         attr_reader :profile_id, :traces, :sample_period,
           :duration, :poll_count, :backtrace_count, :failure_count,
-          :created_at, :xray_id, :command_arguments, :profile_agent_code
+          :created_at, :command_arguments, :profile_agent_code
         attr_accessor :finished_at
 
         def initialize(command_arguments={})
@@ -25,7 +25,6 @@ module NewRelic
           @duration           = command_arguments.fetch('duration', 120)
           @sample_period      = command_arguments.fetch('sample_period', 0.1)
           @profile_agent_code = command_arguments.fetch('profile_agent_code', false)
-          @xray_id            = command_arguments.fetch('x_ray_id', nil)
           @finished = false
 
           @traces = {
@@ -51,14 +50,6 @@ module NewRelic
           @poll_count += 1
         end
 
-        def sample_count
-          xray? ? @backtrace_count : @poll_count
-        end
-
-        def xray?
-          !!@xray_id
-        end
-
         def empty?
           @backtrace_count == 0
         end
@@ -121,26 +112,21 @@ module NewRelic
         def to_collector_array(encoder)
           encoded_trace_tree = encoder.encode(generate_traces, :skip_normalization => true)
           result = [
-            int(self.profile_id),
-            float(self.created_at),
-            float(self.finished_at),
-            int(self.sample_count),
+            int(profile_id),
+            float(created_at),
+            float(finished_at),
+            int(poll_count),
             encoded_trace_tree,
-            int(self.unique_thread_count),
+            int(unique_thread_count),
             0 # runnable thread count, which we don't track
           ]
-          result << int(@xray_id) if xray?
           result
         end
 
         def to_log_description
-          id = if xray?
-                 "@xray_id: #{xray_id}"
-               else
-                 "@profile_id: #{profile_id}"
-               end
-
-          "#<ThreadProfile:#{object_id} #{id} @command_arguments=#{@command_arguments.inspect}>"
+          "#<ThreadProfile:#{object_id} "\
+            "@profile_id: #{profile_id} "\
+            "@command_arguments=#{@command_arguments.inspect}>"
         end
 
       end

data/lib/new_relic/agent/trace_context.rb

@@ -0,0 +1,244 @@
+# 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/trace_context_payload'
+
+module NewRelic
+  module Agent
+    class TraceContext
+      VERSION = 0x0
+      TRACE_PARENT = 'traceparent'.freeze
+      TRACE_STATE  = 'tracestate'.freeze
+
+      TRACE_PARENT_RACK = 'HTTP_TRACEPARENT'.freeze
+      TRACE_STATE_RACK  = 'HTTP_TRACESTATE'.freeze
+
+      FORMAT_HTTP = 0
+      FORMAT_RACK = 1
+
+      TRACE_PARENT_REGEX = /\A(?<version>[a-f\d]{2})-(?<trace_id>[a-f\d]{32})-(?<parent_id>[a-f\d]{16})-(?<trace_flags>\d{2})(?<undefined_fields>-[a-zA-Z\d-]*)?\z/.freeze
+
+      COMMA = ','.freeze
+      EMPTY_STRING = ''.freeze
+      EQUALS = '='.freeze
+      TRACE_ID_KEY = 'trace_id'.freeze
+      PARENT_ID_KEY = 'parent_id'.freeze
+      VERSION_KEY = 'version'.freeze
+      UNDEFINED_FIELDS_KEY = 'undefined_fields'.freeze
+      INVALID_TRACE_ID = ('0' * 32).freeze
+      INVALID_PARENT_ID = ('0' * 16).freeze
+      INVALID_VERSION = 'ff'.freeze
+
+      MAX_TRACE_STATE_SIZE = 512 # bytes
+      MAX_TRACE_STATE_ENTRY_SIZE = 128 # bytes
+
+      SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION = "Supportability/TraceContext/TraceParent/Parse/Exception".freeze
+      SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION  = "Supportability/TraceContext/TraceState/Parse/Exception".freeze
+
+      class << self
+        def insert format: FORMAT_HTTP,
+                   carrier: nil,
+                   parent_id: nil,
+                   trace_id: nil,
+                   trace_flags: nil,
+                   trace_state: nil
+
+          trace_parent_header = trace_parent_header_for_format format
+          carrier[trace_parent_header] = format_trace_parent \
+            trace_id: trace_id,
+            parent_id: parent_id,
+            trace_flags: trace_flags
+
+          trace_state_header = trace_state_header_for_format format
+          carrier[trace_state_header] = trace_state if trace_state && !trace_state.empty?
+        end
+
+        def parse format: FORMAT_HTTP,
+                  carrier: nil,
+                  trace_state_entry_key: nil
+          trace_parent = extract_traceparent(format, carrier)
+          unless trace_parent_valid? trace_parent
+            NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION
+            return
+          end
+
+          begin
+            if header_data = extract_tracestate(format, carrier, trace_state_entry_key)
+              header_data.trace_parent = trace_parent
+              header_data
+            end
+          rescue Exception
+            NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION
+          end
+        end
+
+        def create_trace_state_entry entry_key, payload
+          "#{entry_key}=#{payload}"
+        end
+
+        private
+
+        TRACE_PARENT_FORMAT_STRING = "%02x-%s-%s-%02x".freeze
+
+        def format_trace_parent trace_id: nil,
+                                parent_id: nil,
+                                trace_flags: nil
+          sprintf TRACE_PARENT_FORMAT_STRING,
+                  VERSION,
+                  trace_id,
+                  parent_id,
+                  trace_flags
+        end
+
+        def extract_traceparent format, carrier
+          header_name = trace_parent_header_for_format format
+          return unless header = carrier[header_name]
+          if matchdata = header.match(TRACE_PARENT_REGEX)
+            TRACE_PARENT_REGEX.named_captures.inject({}) do |hash, (name, (index))|
+              hash[name] = matchdata[index]
+              hash
+            end
+          end
+        end
+
+        def trace_parent_valid? trace_parent
+          return false if trace_parent.nil?
+          return false if trace_parent[TRACE_ID_KEY] == INVALID_TRACE_ID
+          return false if trace_parent[PARENT_ID_KEY] == INVALID_PARENT_ID
+          return false if trace_parent[VERSION_KEY] == INVALID_VERSION
+          return false if trace_parent[VERSION_KEY].to_i(16) == VERSION && !trace_parent[UNDEFINED_FIELDS_KEY].nil?
+
+          true
+        end
+
+        def trace_parent_header_for_format format
+          if format == FORMAT_RACK
+            TRACE_PARENT_RACK
+          else
+            TRACE_PARENT
+          end
+        end
+
+        def trace_state_header_for_format format
+          if format == FORMAT_RACK
+            TRACE_STATE_RACK
+          else
+            TRACE_STATE
+          end
+        end
+
+        def extract_tracestate format, carrier, trace_state_entry_key
+          header_name = trace_state_header_for_format format
+          header = carrier[header_name]
+          return HeaderData.create if header.nil? || header.empty?
+
+          payload = nil
+          trace_state_size = 0
+          trace_state_vendors = ''
+          trace_state = header.split(COMMA).map(&:strip)
+          trace_state.reject! do |entry|
+            vendor_id = entry.slice 0, entry.index(EQUALS)
+            if vendor_id == trace_state_entry_key
+              payload = entry.slice! trace_state_entry_key.size + 1, entry.size
+              true
+            else
+              trace_state_size += entry.size
+              trace_state_vendors << vendor_id << COMMA
+              false
+            end
+          end
+
+          trace_state_vendors.chomp! COMMA unless trace_state_vendors.empty?
+
+          HeaderData.create trace_state_payload: payload ? decode_payload(payload) : nil,
+                      trace_state_entries: trace_state,
+                      trace_state_size: trace_state_size,
+                      trace_state_vendors: trace_state_vendors
+        end
+
+        def decode_payload payload
+          TraceContextPayload.from_s payload
+        end
+      end
+
+      class HeaderData
+        class << self
+          def create trace_parent: nil,
+                     trace_state_payload: nil,
+                     trace_state_entries: nil,
+                     trace_state_size: 0,
+                     trace_state_vendors: nil
+            new trace_parent, \
+                trace_state_payload, \
+                trace_state_entries, \
+                trace_state_size, \
+                trace_state_vendors
+          end
+        end
+
+        def initialize trace_parent, trace_state_payload, trace_state_entries, trace_state_size, trace_state_vendors
+          @trace_parent = trace_parent
+          @trace_state_entries = trace_state_entries
+          @trace_state_payload = trace_state_payload
+          @trace_state_size = trace_state_size
+          @trace_state_vendors = trace_state_vendors
+        end
+
+        attr_accessor :trace_parent, :trace_state_payload, :trace_state_vendors
+
+        def trace_state trace_state_entry
+          @trace_state ||= join_trace_state trace_state_entry.size
+          @trace_state_entries = nil
+
+          trace_state_entry << @trace_state
+        end
+
+        def trace_id
+          @trace_parent[TRACE_ID_KEY]
+        end
+
+        def parent_id
+          @trace_parent[PARENT_ID_KEY]
+        end
+
+        private
+
+        def join_trace_state trace_state_entry_size
+          return @trace_state || EMPTY_STRING if @trace_state_entries.nil? || @trace_state_entries.empty?
+
+          max_size = MAX_TRACE_STATE_SIZE - trace_state_entry_size
+          return @trace_state_entries.join(COMMA).prepend(COMMA) if @trace_state_size < max_size
+
+          joined_trace_state = ''
+
+          used_size = 0
+
+          @trace_state_entries.each do |entry|
+            entry_size = entry.size + 1
+            break if used_size + entry_size > max_size
+            next if entry_size > MAX_TRACE_STATE_ENTRY_SIZE
+
+            joined_trace_state << COMMA << entry
+            used_size += entry_size
+          end
+
+          joined_trace_state
+        end
+
+      end
+
+      module AccountHelpers
+        extend self
+
+        def trace_state_entry_key
+          @trace_state_entry_key ||= if Agent.config[:trusted_account_key]
+            "#{Agent.config[:trusted_account_key]}@nr".freeze
+          elsif Agent.config[:account_id]
+            "#{Agent.config[:account_id]}@nr".freeze
+          end
+        end
+      end
+    end
+  end
+end