newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/samplers/vm_sampler.rb

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/sampler'
 require 'new_relic/agent/vm'
@@ -9,15 +9,16 @@ module NewRelic
   module Agent
     module Samplers
       class VMSampler < Sampler
-        GC_RUNS_METRIC                = 'RubyVM/GC/runs'.freeze
-        HEAP_LIVE_METRIC              = 'RubyVM/GC/heap_live'.freeze
-        HEAP_FREE_METRIC              = 'RubyVM/GC/heap_free'.freeze
-        THREAD_COUNT_METRIC           = 'RubyVM/Threads/all'.freeze
-        OBJECT_ALLOCATIONS_METRIC     = 'RubyVM/GC/total_allocated_object'.freeze
-        MAJOR_GC_METRIC               = 'RubyVM/GC/major_gc_count'.freeze
-        MINOR_GC_METRIC               = 'RubyVM/GC/minor_gc_count'.freeze
-        METHOD_INVALIDATIONS_METRIC   = 'RubyVM/CacheInvalidations/method'.freeze
+        GC_RUNS_METRIC = 'RubyVM/GC/runs'.freeze
+        HEAP_LIVE_METRIC = 'RubyVM/GC/heap_live'.freeze
+        HEAP_FREE_METRIC = 'RubyVM/GC/heap_free'.freeze
+        THREAD_COUNT_METRIC = 'RubyVM/Threads/all'.freeze
+        OBJECT_ALLOCATIONS_METRIC = 'RubyVM/GC/total_allocated_object'.freeze
+        MAJOR_GC_METRIC = 'RubyVM/GC/major_gc_count'.freeze
+        MINOR_GC_METRIC = 'RubyVM/GC/minor_gc_count'.freeze
+        METHOD_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/method'.freeze
         CONSTANT_INVALIDATIONS_METRIC = 'RubyVM/CacheInvalidations/constant'.freeze
+        CONSTANT_MISSES_METRIC = 'RubyVM/CacheMisses/constant'.freeze
 
         attr_reader :transaction_count
 
@@ -49,7 +50,7 @@ module NewRelic
           end
         end
 
-        def record_gc_runs_metric(snapshot, txn_count) #THREAD_LOCAL_ACCESS
+        def record_gc_runs_metric(snapshot, txn_count) # THREAD_LOCAL_ACCESS
           if snapshot.gc_total_time || snapshot.gc_runs
             if snapshot.gc_total_time
               gc_time = snapshot.gc_total_time - @last_snapshot.gc_total_time.to_f
@@ -59,30 +60,30 @@ module NewRelic
             end
             wall_clock_time = snapshot.taken_at - @last_snapshot.taken_at
             NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(GC_RUNS_METRIC) do |stats|
-              stats.call_count           += txn_count
-              stats.total_call_time      += gc_runs if gc_runs
+              stats.call_count += txn_count
+              stats.total_call_time += gc_runs if gc_runs
               stats.total_exclusive_time += gc_time if gc_time
-              stats.max_call_time         = (gc_time.nil? ? 0 : 1)
-              stats.sum_of_squares       += wall_clock_time
+              stats.max_call_time = (gc_time.nil? ? 0 : 1)
+              stats.sum_of_squares += wall_clock_time
             end
           end
         end
 
-        def record_delta(snapshot, key, metric, txn_count) #THREAD_LOCAL_ACCESS
+        def record_delta(snapshot, key, metric, txn_count) # THREAD_LOCAL_ACCESS
           value = snapshot.send(key)
           if value
             delta = value - @last_snapshot.send(key)
             NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric) do |stats|
-              stats.call_count      += txn_count
+              stats.call_count += txn_count
               stats.total_call_time += delta
             end
           end
         end
 
-        def record_gauge_metric(metric_name, value) #THREAD_LOCAL_ACCESS
+        def record_gauge_metric(metric_name, value) # THREAD_LOCAL_ACCESS
           NewRelic::Agent.agent.stats_engine.tl_record_unscoped_metrics(metric_name) do |stats|
-            stats.call_count      = value
-            stats.sum_of_squares  = 1
+            stats.call_count = value
+            stats.sum_of_squares = 1
           end
         end
 
@@ -114,6 +115,7 @@ module NewRelic
           record_delta(snap, :minor_gc_count, MINOR_GC_METRIC, tcount)
           record_delta(snap, :method_cache_invalidations, METHOD_INVALIDATIONS_METRIC, tcount)
           record_delta(snap, :constant_cache_invalidations, CONSTANT_INVALIDATIONS_METRIC, tcount)
+          record_delta(snap, :constant_cache_misses, CONSTANT_MISSES_METRIC, tcount)
           record_heap_live_metric(snap)
           record_heap_free_metric(snap)
           record_thread_count_metric(snap)

data/lib/new_relic/agent/serverless_handler.rb

@@ -0,0 +1,171 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'json'
+require 'new_relic/base64'
+
+module NewRelic
+  module Agent
+    class ServerlessHandler
+      ATTRIBUTE_ARN = 'aws.lambda.arn'
+      ATTRIBUTE_COLD_START = 'aws.lambda.coldStart'
+      ATTRIBUTE_REQUEST_ID = 'aws.requestId'
+      AGENT_ATTRIBUTE_DESTINATIONS = NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER |
+        NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS
+      EXECUTION_ENVIRONMENT = "AWS_Lambda_ruby#{RUBY_VERSION.rpartition('.').first}".freeze
+      LAMBDA_MARKER = 'NR_LAMBDA_MONITORING'
+      LAMBDA_ENVIRONMENT_VARIABLE = 'AWS_LAMBDA_FUNCTION_NAME'
+      METHOD_BLOCKLIST = %i[agent_command_results connect get_agent_commands preconnect profile_data
+        shutdown].freeze
+      NAMED_PIPE = '/tmp/newrelic-telemetry'
+      SUPPORTABILITY_METRIC = 'Supportability/AWSLambda/HandlerInvocation'
+      FUNCTION_NAME = 'lambda_function'
+      PAYLOAD_VERSION = ENV.fetch('NEW_RELIC_SERVERLESS_PAYLOAD_VERSION', 2)
+
+      def self.env_var_set?
+        ENV.key?(LAMBDA_ENVIRONMENT_VARIABLE)
+      end
+
+      def initialize
+        @context = nil
+        @payloads = {}
+      end
+
+      def invoke_lambda_function_with_new_relic(event:, context:, method_name:, namespace: nil)
+        NewRelic::Agent.increment_metric(SUPPORTABILITY_METRIC)
+
+        @context = context
+
+        NewRelic::Agent::Tracer.in_transaction(category: :other, name: function_name) do
+          add_agent_attributes
+
+          NewRelic::LanguageSupport.constantize(namespace).send(method_name, event: event, context: context)
+        end
+      ensure
+        harvest!
+        write_output
+        reset!
+      end
+
+      def store_payload(method, payload)
+        return if METHOD_BLOCKLIST.include?(method)
+
+        @payloads[method] = payload
+      end
+
+      def metric_data(stats_hash)
+        payload = [nil,
+          stats_hash.started_at,
+          (stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)),
+          []]
+        stats_hash.each do |metric_spec, stats|
+          next if stats.is_reset?
+
+          hash = {name: metric_spec.name}
+          hash[:scope] = metric_spec.scope unless metric_spec.scope.empty?
+
+          payload.last.push([hash, [
+            stats.call_count,
+            stats.total_call_time,
+            stats.total_exclusive_time,
+            stats.min_call_time,
+            stats.max_call_time,
+            stats.sum_of_squares
+          ]])
+        end
+
+        return if payload.last.empty?
+
+        store_payload(:metric_data, payload)
+      end
+
+      def error_data(errors)
+        store_payload(:error_data, [nil, errors.map(&:to_collector_array)])
+      end
+
+      private
+
+      def harvest!
+        NewRelic::Agent.instance.harvest_and_send_analytic_event_data
+        NewRelic::Agent.instance.harvest_and_send_custom_event_data
+        NewRelic::Agent.instance.harvest_and_send_data_types
+      end
+
+      def metadata
+        m = {arn: @context.invoked_function_arn,
+             protocol_version: NewRelic::Agent::NewRelicService::PROTOCOL_VERSION,
+             function_version: @context.function_version,
+             execution_environment: EXECUTION_ENVIRONMENT,
+             agent_version: NewRelic::VERSION::STRING}
+        if PAYLOAD_VERSION >= 2
+          m[:metadata_version] = PAYLOAD_VERSION
+          m[:agent_language] = NewRelic::LANGUAGE
+        end
+        m
+      end
+
+      def function_name
+        ENV.fetch(LAMBDA_ENVIRONMENT_VARIABLE, FUNCTION_NAME)
+      end
+
+      def write_output
+        string = PAYLOAD_VERSION == 1 ? payload_v1 : payload_v2
+
+        return puts string unless use_named_pipe?
+
+        File.write(NAMED_PIPE, string)
+
+        NewRelic::Agent.logger.debug "Wrote serverless payload to #{NAMED_PIPE}\n" \
+          "BEGIN PAYLOAD>>>\n#{string}\n<<<END PAYLOAD"
+      end
+
+      def payload_v1
+        payload_hash = {'metadata' => metadata, 'data' => @payloads}
+        json = NewRelic::Agent.agent.service.marshaller.dump(payload_hash)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def payload_v2
+        json = NewRelic::Agent.agent.service.marshaller.dump(@payloads)
+        gzipped = NewRelic::Agent::NewRelicService::Encoders::Compressed::Gzip.encode(json)
+        base64_encoded = NewRelic::Base64.strict_encode64(gzipped)
+        array = [PAYLOAD_VERSION, LAMBDA_MARKER, metadata, base64_encoded]
+        ::JSON.dump(array)
+      end
+
+      def use_named_pipe?
+        return @use_named_pipe if defined?(@use_named_pipe)
+
+        @use_named_pipe = File.exist?(NAMED_PIPE) && File.writable?(NAMED_PIPE)
+      end
+
+      def add_agent_attributes
+        return unless NewRelic::Agent::Tracer.current_transaction
+
+        add_agent_attribute(ATTRIBUTE_COLD_START, true) if cold?
+        add_agent_attribute(ATTRIBUTE_ARN, @context.invoked_function_arn)
+        add_agent_attribute(ATTRIBUTE_REQUEST_ID, @context.aws_request_id)
+      end
+
+      def add_agent_attribute(attribute, value)
+        NewRelic::Agent::Tracer.current_transaction.add_agent_attribute(attribute, value, AGENT_ATTRIBUTE_DESTINATIONS)
+      end
+
+      def cold?
+        return @cold if defined?(@cold)
+
+        @cold = false
+        true
+      end
+
+      def reset!
+        @context = nil
+        @payloads.replace({})
+      end
+    end
+  end
+end

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -0,0 +1,49 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'newrelic_rpm' unless defined?(NewRelic)
+require 'new_relic/agent' unless defined?(NewRelic::Agent)
+require 'new_relic/agent/event_aggregator'
+require 'new_relic/agent/priority_sampled_buffer'
+
+module NewRelic
+  module Agent
+    class SpanEventAggregator < EventAggregator
+      named :SpanEventAggregator
+      capacity_key :'span_events.max_samples_stored'
+
+      enabled_keys :'span_events.enabled',
+        :'distributed_tracing.enabled'
+
+      def record(priority: nil, event: nil, &blk)
+        unless event || priority && blk
+          raise ArgumentError, 'Expected priority and block, or event'
+        end
+
+        return unless enabled?
+
+        @lock.synchronize do
+          @buffer.append(priority: priority, event: event, &blk)
+          notify_if_full
+        end
+      end
+
+      SUPPORTABILITY_TOTAL_SEEN = 'Supportability/SpanEvent/TotalEventsSeen'.freeze
+      SUPPORTABILITY_TOTAL_SENT = 'Supportability/SpanEvent/TotalEventsSent'.freeze
+      SUPPORTABILITY_DISCARDED = 'Supportability/SpanEvent/Discarded'.freeze
+
+      def after_harvest(metadata)
+        seen = metadata[:seen]
+        sent = metadata[:captured]
+        discarded = seen - sent
+
+        ::NewRelic::Agent.record_metric(SUPPORTABILITY_TOTAL_SEEN, count: seen)
+        ::NewRelic::Agent.record_metric(SUPPORTABILITY_TOTAL_SENT, count: sent)
+        ::NewRelic::Agent.record_metric(SUPPORTABILITY_DISCARDED, count: discarded)
+
+        super
+      end
+    end
+  end
+end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -0,0 +1,222 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+# This module builds the data structures necessary to create a Span
+# event for a segment.
+
+require 'new_relic/agent/payload_metric_mapping'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
+
+module NewRelic
+  module Agent
+    module SpanEventPrimitive
+      include NewRelic::Coerce
+      extend self
+
+      # Strings for static keys of the event structure
+      ELLIPSIS = '...'
+      TYPE_KEY = 'type'
+      TRACE_ID_KEY = 'traceId'
+      GUID_KEY = 'guid'
+      PARENT_ID_KEY = 'parentId'
+      TRANSACTION_ID_KEY = 'transactionId'
+      SAMPLED_KEY = 'sampled'
+      PRIORITY_KEY = 'priority'
+      TIMESTAMP_KEY = 'timestamp'
+      DURATION_KEY = 'duration'
+      NAME_KEY = 'name'
+      CATEGORY_KEY = 'category'
+      HTTP_URL_KEY = 'http.url'
+      HTTP_METHOD_KEY = 'http.method'
+      HTTP_REQUEST_METHOD_KEY = 'http.request.method'
+      HTTP_STATUS_CODE_KEY = 'http.statusCode'
+      COMPONENT_KEY = 'component'
+      DB_INSTANCE_KEY = 'db.instance'
+      DB_STATEMENT_KEY = 'db.statement'
+      DB_SYSTEM_KEY = 'db.system'
+      PEER_ADDRESS_KEY = 'peer.address'
+      PEER_HOSTNAME_KEY = 'peer.hostname'
+      SERVER_ADDRESS_KEY = 'server.address'
+      SERVER_PORT_KEY = 'server.port'
+      SPAN_KIND_KEY = 'span.kind'
+      ENTRY_POINT_KEY = 'nr.entryPoint'
+      TRUSTED_PARENT_KEY = 'trustedParentId'
+      TRACING_VENDORS_KEY = 'tracingVendors'
+      TRANSACTION_NAME_KEY = 'transaction.name'
+
+      # Strings for static values of the event structure
+      EVENT_TYPE = 'Span'
+      GENERIC_CATEGORY = 'generic'
+      HTTP_CATEGORY = 'http'
+      DATASTORE_CATEGORY = 'datastore'
+      CLIENT = 'client'
+
+      # Builds a Hash of error attributes as well as the Span ID when
+      # an error is present.  Otherwise, returns nil when no error present.
+      def error_attributes(segment)
+        return if Agent.config[:high_security] || !segment.noticed_error
+
+        segment.noticed_error.build_error_attributes
+        segment.noticed_error_attributes
+      end
+
+      def for_segment(segment)
+        intrinsics = intrinsics_for(segment)
+        intrinsics[CATEGORY_KEY] = GENERIC_CATEGORY
+
+        [intrinsics, custom_attributes(segment), agent_attributes(segment)]
+      end
+
+      def for_external_request_segment(segment)
+        intrinsics = intrinsics_for(segment)
+
+        intrinsics[COMPONENT_KEY] = segment.library
+        intrinsics[HTTP_METHOD_KEY] = segment.procedure
+        intrinsics[HTTP_REQUEST_METHOD_KEY] = segment.procedure
+        intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
+        intrinsics[CATEGORY_KEY] = HTTP_CATEGORY
+        intrinsics[SPAN_KIND_KEY] = CLIENT
+        intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host
+        intrinsics[SERVER_PORT_KEY] = segment.uri.port
+        agent_attributes = {}
+
+        if allowed?(HTTP_URL_KEY)
+          agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
+        end
+
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
+      end
+
+      def for_datastore_segment(segment) # rubocop:disable Metrics/AbcSize
+        intrinsics = intrinsics_for(segment)
+
+        intrinsics[COMPONENT_KEY] = segment.product
+        intrinsics[SPAN_KIND_KEY] = CLIENT
+        intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
+
+        agent_attributes = {}
+
+        if segment.database_name && allowed?(DB_INSTANCE_KEY)
+          agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
+        end
+        if segment.host && segment.port_path_or_id && allowed?(PEER_ADDRESS_KEY)
+          agent_attributes[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
+        end
+        if segment.host
+          [PEER_HOSTNAME_KEY, SERVER_ADDRESS_KEY].each do |key|
+            agent_attributes[key] = truncate(segment.host) if allowed?(key)
+          end
+        end
+        if segment.port_path_or_id&.match?(/^\d+$/) && allowed?(SERVER_PORT_KEY)
+          agent_attributes[SERVER_PORT_KEY] = segment.port_path_or_id
+        end
+        agent_attributes[DB_SYSTEM_KEY] = segment.product if allowed?(DB_SYSTEM_KEY)
+
+        if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+        elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+        end
+
+        [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
+      end
+
+      private
+
+      def intrinsics_for(segment)
+        intrinsics = {
+          TYPE_KEY => EVENT_TYPE,
+          TRACE_ID_KEY => segment.transaction.trace_id,
+          GUID_KEY => segment.guid,
+          TRANSACTION_ID_KEY => segment.transaction.guid,
+          PRIORITY_KEY => segment.transaction.priority,
+          TIMESTAMP_KEY => milliseconds_since_epoch(segment),
+          DURATION_KEY => segment.duration,
+          NAME_KEY => segment.name
+        }
+
+        # with infinite-tracing, transactions may or may not be sampled!
+        if segment.transaction.sampled?
+          intrinsics[SAMPLED_KEY] = true
+        end
+
+        if segment.parent.nil?
+          intrinsics[ENTRY_POINT_KEY] = true
+          if txn = segment.transaction
+            if header_data = txn.distributed_tracer.trace_context_header_data
+              if trace_state_vendors = header_data.trace_state_vendors
+                intrinsics[TRACING_VENDORS_KEY] = trace_state_vendors unless trace_state_vendors == NewRelic::EMPTY_STR
+              end
+            end
+            if trace_state_payload = txn.distributed_tracer.trace_state_payload
+              intrinsics[TRUSTED_PARENT_KEY] = trace_state_payload.id if trace_state_payload.id
+            end
+          end
+        end
+
+        if parent_id = parent_guid(segment)
+          intrinsics[PARENT_ID_KEY] = parent_id
+        end
+
+        if segment.transaction_name
+          intrinsics[TRANSACTION_NAME_KEY] = segment.transaction_name
+        end
+
+        intrinsics
+      end
+
+      def custom_attributes(segment)
+        attributes = segment.attributes
+        if attributes
+          result = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+          result.freeze
+        else
+          NewRelic::EMPTY_HASH
+        end
+      end
+
+      def merge_hashes(hash1, hash2)
+        return hash1 if hash2.nil? || hash2.empty?
+        return hash2 if hash1.nil? || hash1.empty?
+
+        hash1.merge!(hash2)
+      end
+
+      def agent_attributes(segment)
+        agent_attributes = segment.attributes
+          .agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
+        error_attributes = error_attributes(segment)
+        code_attributes = segment.code_attributes
+        agent_attributes = merge_hashes(agent_attributes, error_attributes)
+        agent_attributes = merge_hashes(agent_attributes, code_attributes)
+        agent_attributes.freeze
+      end
+
+      def parent_guid(segment)
+        if segment.parent
+          segment.parent.guid
+        elsif txn = segment.transaction
+          txn.distributed_tracer.parent_guid
+        end
+      end
+
+      def milliseconds_since_epoch(segment)
+        Integer(segment.start_time.to_f * 1000.0)
+      end
+
+      def truncate(value, max_size = 255)
+        value = value.to_s
+        if value.bytesize > max_size
+          value.byteslice(0, max_size - 2).chop! << ELLIPSIS
+        else
+          value
+        end
+      end
+
+      def allowed?(key)
+        NewRelic::Agent.instance.attribute_filter.allows_key?(key, AttributeFilter::DST_SPAN_EVENTS)
+      end
+    end
+  end
+end