newrelic_rpm 8.7.0 → 8.11.0

data/lib/new_relic/agent/transaction/abstract_segment.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/range_extensions'
 require 'new_relic/agent/guid_generator'
@@ -9,9 +9,9 @@ module NewRelic
   module Agent
     class Transaction
       class AbstractSegment
-        # This class is the base class for all segments. It is reponsible for
+        # This class is the base class for all segments. It is responsible for
         # timing, naming, and defining lifecycle callbacks. One of the more
-        # complex responsibilites of this class is computing exclusive duration.
+        # complex responsibilities of this class is computing exclusive duration.
         # One of the reasons for this complexity is that exclusive time will be
         # computed using time ranges or by recording an aggregate value for
         # a segments children time. The reason for this is that computing
@@ -25,7 +25,7 @@ module NewRelic
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
-        def initialize name = nil, start_time = nil
+        def initialize(name = nil, start_time = nil)
           @name = name
           @starting_thread_id = ::Thread.current.object_id
           @transaction_name = nil
@@ -37,8 +37,8 @@ module NewRelic
           @end_time = nil
           @duration = 0.0
           @exclusive_duration = 0.0
+          @children_timings = []
           @children_time = 0.0
-          @children_time_ranges = nil
           @active_children = 0
           @range_recorded = false
           @concurrent_children = false
@@ -46,22 +46,27 @@ module NewRelic
           @record_scoped_metric = true
           @record_on_finish = false
           @noticed_error = nil
+          @code_filepath = nil
+          @code_function = nil
+          @code_lineno = nil
+          @code_namespace = nil
         end
 
         def start
           @start_time ||= Process.clock_gettime(Process::CLOCK_REALTIME)
           return unless transaction
-          parent.child_start self if parent
+          parent.child_start(self) if parent
         end
 
         def finish
           @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           @duration = end_time - start_time
+
           return unless transaction
           run_complete_callbacks
           finalize if record_on_finish?
         rescue => e
-          NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
+          NewRelic::Agent.logger.error("Exception finishing segment: #{name}", e)
         end
 
         def finished?
@@ -98,18 +103,68 @@ module NewRelic
           @start_time.to_f..@end_time.to_f
         end
 
+        def timings_overlap?(timing1, timing2)
+          (timing1.first >= timing2.first && timing1.first <= timing2.last) ||
+            (timing2.first >= timing1.first && timing2.first <= timing1.last)
+        end
+
+        def merge_timings(timing1, timing2)
+          [(timing1.first < timing2.first ? timing1.first : timing2.first),
+            (timing1.last > timing2.last ? timing1.last : timing2.last)]
+        end
+
+        # @children_timings is an array of array, with each inner array
+        # holding exactly 2 values, a child segment's start time and finish
+        # time (in that order). When it's time to record, these timings are
+        # converted into an array of range objects (using the same start and
+        # end values as the original array). Any two range objects that
+        # intersect and merged into a larger range. This checking for a
+        # intersections and merging of ranges is expensive, so the operation
+        # is only done at recording time.
         def children_time_ranges
-          @children_time_ranges ||= []
+          @children_time_ranges ||= begin
+            overlapped = @children_timings.each_with_object([]) do |timing, timings|
+              i = timings.index { |t| timings_overlap?(t, timing) }
+              if i
+                timings[i] = merge_timings(timing, timings[i])
+              else
+                timings << timing
+              end
+            end
+            overlapped.map { |t| Range.new(t.first, t.last) }
+          end
         end
 
         def children_time_ranges?
-          !!@children_time_ranges
+          !@children_timings.empty?
         end
 
         def concurrent_children?
           @concurrent_children
         end
 
+        def code_information=(info = {})
+          return unless info[:filepath]
+
+          @code_filepath = info[:filepath]
+          @code_function = info[:function]
+          @code_lineno = info[:lineno]
+          @code_namespace = info[:namespace]
+        end
+
+        def all_code_information_present?
+          @code_filepath && @code_function && @code_lineno && @code_namespace
+        end
+
+        def code_attributes
+          return ::NewRelic::EMPTY_HASH unless all_code_information_present?
+
+          @code_attributes ||= {'code.filepath' => @code_filepath,
+                                'code.function' => @code_function,
+                                'code.lineno' => @code_lineno,
+                                'code.namespace' => @code_namespace}
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect
@@ -123,22 +178,24 @@ module NewRelic
         def transaction_assigned
         end
 
-        def set_noticed_error noticed_error
+        def set_noticed_error(noticed_error)
           if @noticed_error
-            NewRelic::Agent.logger.debug \
+            NewRelic::Agent.logger.debug( \
               "Segment: #{name} overwriting previously noticed " \
               "error: #{@noticed_error.inspect} with: #{noticed_error.inspect}"
+            )
           end
           @noticed_error = noticed_error
         end
 
-        def notice_error exception, options = {}
+        def notice_error(exception, options = {})
           if Agent.config[:high_security]
-            NewRelic::Agent.logger.debug \
+            NewRelic::Agent.logger.debug( \
               "Segment: #{name} ignores notice_error for " \
               "error: #{exception.inspect} because :high_security is enabled"
+            )
           else
-            NewRelic::Agent.instance.error_collector.notice_segment_error self, exception, options
+            NewRelic::Agent.instance.error_collector.notice_segment_error(self, exception, options)
           end
         end
 
@@ -155,16 +212,16 @@ module NewRelic
           @range_recorded
         end
 
-        def child_start segment
+        def child_start(segment)
           @active_children += 1
           @concurrent_children ||= @active_children > 1
 
           transaction.async = true if @concurrent_children
         end
 
-        def child_complete segment
+        def child_complete(segment)
           @active_children -= 1
-          record_child_time segment
+          record_child_time(segment)
 
           if finished?
             transaction.async = true
@@ -178,36 +235,39 @@ module NewRelic
         # an ancestor whose end time is greater than or equal to the descendant's
         # we can stop the propagation. We pass along the direct child so we can
         # make any corrections needed for exclusive time calculation.
+        def descendant_complete(child, descendant)
+          add_child_timing(descendant)
 
-        def descendant_complete child, descendant
-          RangeExtensions.merge_or_append descendant.time_range,
-            children_time_ranges
           # If this child's time was previously added to this segment's
           # aggregate children time, we need to re-record it using a time range
           # for proper exclusive time calculation
           unless child.range_recorded?
             self.children_time -= child.duration
-            record_child_time_as_range child
+            record_child_time_as_range(child)
           end
 
           if parent && finished? && descendant.end_time >= end_time
-            parent.descendant_complete self, descendant
+            parent.descendant_complete(self, descendant)
           end
         end
 
         private
 
+        def add_child_timing(segment)
+          @children_timings << [segment.start_time, segment.end_time]
+        end
+
         def force_finish
           finish
-          NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
+          NewRelic::Agent.logger.warn("Segment: #{name} was unfinished at " \
             "the end of transaction. Timing information for this segment's" \
-            "parent #{parent.name} in #{transaction.best_name} may be inaccurate."
+            "parent #{parent.name} in #{transaction.best_name} may be inaccurate.")
         end
 
         def run_complete_callbacks
           segment_complete
-          parent.child_complete self if parent
-          transaction.segment_complete self
+          parent.child_complete(self) if parent
+          transaction.segment_complete(self)
         end
 
         def record_metrics
@@ -218,27 +278,26 @@ module NewRelic
         def segment_complete
         end
 
-        def record_child_time child
+        def record_child_time(child)
           if concurrent_children? || finished? && end_time < child.end_time
-            record_child_time_as_range child
+            record_child_time_as_range(child)
           else
-            record_child_time_as_number child
+            record_child_time_as_number(child)
           end
         end
 
-        def record_child_time_as_range child
-          RangeExtensions.merge_or_append child.time_range,
-            children_time_ranges
+        def record_child_time_as_range(child)
+          add_child_timing(child)
           child.range_recorded = true
         end
 
-        def record_child_time_as_number child
+        def record_child_time_as_number(child)
           self.children_time += child.duration
         end
 
         def record_exclusive_duration
           overlapping_duration = if children_time_ranges?
-            RangeExtensions.compute_overlap time_range, children_time_ranges
+            RangeExtensions.compute_overlap(time_range, children_time_ranges)
           else
             0.0
           end

data/lib/new_relic/agent/transaction/datastore_segment.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # 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 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/datastores/metric_helper'
@@ -16,26 +16,26 @@ module NewRelic
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name, :record_sql
 
-        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil, start_time = nil
+        def initialize(product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil, start_time = nil)
           @product = product
           @operation = operation
           @collection = collection
           @sql_statement = nil
           @nosql_statement = nil
           @record_sql = true
-          set_instance_info host, port_path_or_id
+          set_instance_info(host, port_path_or_id)
           @database_name = database_name ? database_name.to_s : nil
-          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
+          super(Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
                 nil,
-                start_time
+                start_time)
         end
 
-        def set_instance_info host = nil, port_path_or_id = nil
+        def set_instance_info(host = nil, port_path_or_id = nil)
           port_path_or_id = port_path_or_id.to_s if port_path_or_id
           host_present = host && !host.empty?
           ppi_present = port_path_or_id && !port_path_or_id.empty?
 
-          host = NewRelic::Agent::Hostname.get_external host if host_present
+          host = NewRelic::Agent::Hostname.get_external(host) if host_present
 
           case
           when host_present && ppi_present
@@ -55,15 +55,15 @@ module NewRelic
           end
         end
 
-        def notice_sql sql
-          _notice_sql sql
+        def notice_sql(sql)
+          _notice_sql(sql)
           nil
         end
 
         # @api private
-        def _notice_sql sql, config = nil, explainer = nil, binds = nil, name = nil
+        def _notice_sql(sql, config = nil, explainer = nil, binds = nil, name = nil)
           return unless record_sql?
-          @sql_statement = Database::Statement.new sql, config, explainer, binds, name, host, port_path_or_id, database_name
+          @sql_statement = Database::Statement.new(sql, config, explainer, binds, name, host, port_path_or_id, database_name)
         end
 
         # Method for simplifying attaching non-SQL data statements to a
@@ -83,7 +83,7 @@ module NewRelic
         #   please ensure all data passed to this method is safe to transmit to
         #   New Relic.
 
-        def notice_nosql_statement nosql_statement
+        def notice_nosql_statement(nosql_statement)
           return unless record_sql?
           @nosql_statement = Database.truncate_query(nosql_statement)
           nil

data/lib/new_relic/agent/transaction/distributed_tracer.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # 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
@@ -26,12 +25,12 @@ module NewRelic
           end
         end
 
-        def accept_incoming_request request, transport_type = nil
-          accept_incoming_transport_type request, transport_type
-          if trace_parent_header_present? request
-            accept_trace_context_incoming_request request
+        def accept_incoming_request(request, transport_type = nil)
+          accept_incoming_transport_type(request, transport_type)
+          if trace_parent_header_present?(request)
+            accept_trace_context_incoming_request(request)
           else
-            accept_distributed_tracing_incoming_request request
+            accept_distributed_tracing_incoming_request(request)
           end
         end
 
@@ -39,84 +38,89 @@ module NewRelic
           @caller_transport_type ||= "Unknown"
         end
 
-        def accept_transport_type_from_api value
-          @caller_transport_type = DistributedTraceTransportType.from value
+        def accept_transport_type_from_api(value)
+          @caller_transport_type = DistributedTraceTransportType.from(value)
         end
 
-        def accept_incoming_transport_type request, transport_type
+        def accept_incoming_transport_type(request, transport_type)
           if transport_type.to_s == NewRelic::EMPTY_STR
-            @caller_transport_type = DistributedTraceTransportType.for_rack_request request
+            @caller_transport_type = DistributedTraceTransportType.for_rack_request(request)
           else
-            @caller_transport_type = DistributedTraceTransportType.from transport_type
+            @caller_transport_type = DistributedTraceTransportType.from(transport_type)
           end
         end
 
-        def initialize transaction
+        def initialize(transaction)
           @transaction = transaction
         end
 
         def record_metrics
           record_cross_app_metrics
-          DistributedTraceMetrics.record_metrics_for_transaction transaction
+          DistributedTraceMetrics.record_metrics_for_transaction(transaction)
         end
 
-        def append_payload payload
-          append_cat_info payload
-          DistributedTraceAttributes.copy_from_transaction \
+        def append_payload(payload)
+          append_cat_info(payload)
+          DistributedTraceAttributes.copy_from_transaction( \
             transaction,
             trace_state_payload || distributed_trace_payload,
             payload
+          )
         end
 
-        def log_request_headers headers, direction = "OUTGOING"
-          NewRelic::Agent.logger.debug "#{direction} REQUEST HEADERS: #{headers}"
+        def log_request_headers(headers, direction = "OUTGOING")
+          NewRelic::Agent.logger.debug("#{direction} REQUEST HEADERS: #{headers}")
         end
 
-        def insert_headers headers
+        def insert_headers(headers)
           return unless NewRelic::Agent.agent.connected?
-          insert_trace_context_header headers
-          insert_distributed_trace_header headers
-          insert_cross_app_header headers
-          log_request_headers headers
+          insert_trace_context_header(headers)
+          insert_distributed_trace_header(headers)
+          insert_cross_app_header(headers)
+          log_request_headers(headers)
         end
 
-        def consume_message_headers headers, tracer_state, transport_type
-          log_request_headers headers, "INCOMING"
-          consume_message_distributed_tracing_headers headers, transport_type
-          consume_message_cross_app_tracing_headers headers, tracer_state
-          consume_message_synthetics_headers headers
+        def consume_message_headers(headers, tracer_state, transport_type)
+          log_request_headers(headers, "INCOMING")
+          consume_message_distributed_tracing_headers(headers, transport_type)
+          consume_message_cross_app_tracing_headers(headers, tracer_state)
+          consume_message_synthetics_headers(headers)
         rescue => e
-          NewRelic::Agent.logger.error "Error in consume_message_headers", e
+          NewRelic::Agent.logger.error("Error in consume_message_headers", e)
         end
 
         def assign_intrinsics
-          if Agent.config[:'distributed_tracing.enabled']
-            DistributedTraceAttributes.copy_to_attributes transaction.payload, transaction.attributes
+          if dt_enabled?
+            DistributedTraceAttributes.copy_to_attributes(transaction.payload, transaction.attributes)
           elsif is_cross_app?
             assign_cross_app_intrinsics
           end
         end
 
-        def insert_distributed_trace_header headers
-          return unless Agent.config[:'distributed_tracing.enabled']
+        def insert_distributed_trace_header(headers)
+          return unless dt_enabled?
           return if Agent.config[:'exclude_newrelic_header']
           payload = create_distributed_trace_payload
           headers[NewRelic::NEWRELIC_KEY] = payload.http_safe if payload
         end
 
-        def insert_cat_headers headers
+        def insert_cat_headers(headers)
           return unless CrossAppTracing.cross_app_enabled?
           @is_cross_app_caller = true
-          insert_message_headers headers,
+          insert_message_headers(headers,
             transaction.guid,
             cat_trip_id,
             cat_path_hash,
-            transaction.raw_synthetics_header
+            transaction.raw_synthetics_header)
         end
 
         private
 
-        def consume_message_synthetics_headers headers
+        def dt_enabled?
+          Agent.config[:'distributed_tracing.enabled']
+        end
+
+        def consume_message_synthetics_headers(headers)
           synthetics_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER]
           if synthetics_header and
               incoming_payload = ::JSON.load(deobfuscate(synthetics_header)) and
@@ -128,31 +132,31 @@ module NewRelic
             transaction.synthetics_payload = incoming_payload
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error in consume_message_synthetics_header", e
+          NewRelic::Agent.logger.error("Error in consume_message_synthetics_header", e)
         end
 
-        def consume_message_distributed_tracing_headers headers, transport_type
-          return unless Agent.config[:'distributed_tracing.enabled']
+        def consume_message_distributed_tracing_headers(headers, transport_type)
+          return unless dt_enabled?
 
-          accept_incoming_transport_type headers, transport_type
+          accept_incoming_transport_type(headers, transport_type)
 
           newrelic_trace_key = NewRelic::CANDIDATE_NEWRELIC_KEYS.detect do |key|
             headers.has_key?(key)
           end
           return unless newrelic_trace_key && (payload = headers[newrelic_trace_key])
 
-          accept_distributed_trace_payload payload
+          accept_distributed_trace_payload(payload)
         end
 
-        def consume_message_cross_app_tracing_headers headers, tracer_state
+        def consume_message_cross_app_tracing_headers(headers, tracer_state)
           return unless CrossAppTracing.cross_app_enabled?
           return unless CrossAppTracing.message_has_crossapp_request_header?(headers)
 
-          accept_cross_app_payload headers, tracer_state
-          CrossAppTracing.assign_intrinsic_transaction_attributes tracer_state
+          accept_cross_app_payload(headers, tracer_state)
+          CrossAppTracing.assign_intrinsic_transaction_attributes(tracer_state)
         end
 
-        def accept_cross_app_payload headers, tracer_state
+        def accept_cross_app_payload(headers, tracer_state)
           encoded_id = headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER]
           decoded_id = encoded_id.nil? ? EMPTY_STRING : deobfuscate(encoded_id)
 
@@ -167,8 +171,8 @@ module NewRelic
           nil
         end
 
-        def deobfuscate message
-          CrossAppTracing.obfuscator.deobfuscate message
+        def deobfuscate(message)
+          CrossAppTracing.obfuscator.deobfuscate(message)
         end
       end
     end

data/lib/new_relic/agent/transaction/distributed_tracing.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # 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
@@ -36,11 +35,11 @@ module NewRelic
 
         NEWRELIC_TRACE_KEY = "HTTP_NEWRELIC"
 
-        def accept_distributed_tracing_incoming_request request
+        def accept_distributed_tracing_incoming_request(request)
           return unless Agent.config[:'distributed_tracing.enabled']
           return unless payload = request[NEWRELIC_TRACE_KEY]
 
-          accept_distributed_trace_payload payload
+          accept_distributed_trace_payload(payload)
         end
 
         def distributed_trace_payload_created?
@@ -51,16 +50,16 @@ module NewRelic
           return unless Agent.config[:'distributed_tracing.enabled']
 
           @distributed_trace_payload_created = true
-          payload = DistributedTracePayload.for_transaction transaction
-          NewRelic::Agent.increment_metric CREATE_SUCCESS_METRIC
+          payload = DistributedTracePayload.for_transaction(transaction)
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
           payload
         rescue => e
-          NewRelic::Agent.increment_metric CREATE_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to create distributed trace payload", e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to create distributed trace payload", e)
           nil
         end
 
-        def accept_distributed_trace_payload payload
+        def accept_distributed_trace_payload(payload)
           return unless Agent.config[:'distributed_tracing.enabled']
 
           return false if check_payload_ignored(payload)
@@ -72,11 +71,11 @@ module NewRelic
 
           assign_payload_and_sampling_params(payload)
 
-          NewRelic::Agent.increment_metric ACCEPT_SUCCESS_METRIC
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
-          NewRelic::Agent.increment_metric ACCEPT_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Failed to accept distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to accept distributed trace payload", e)
           false
         end
 
@@ -84,10 +83,10 @@ module NewRelic
 
         def check_payload_ignored(payload)
           if distributed_trace_payload
-            NewRelic::Agent.increment_metric IGNORE_MULTIPLE_ACCEPT_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
             return true
           elsif distributed_trace_payload_created?
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_AFTER_CREATE_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
             return true
           end
           false
@@ -96,7 +95,7 @@ module NewRelic
         def check_payload_present(payload)
           # We might be passed a Ruby `nil` object _or_ the JSON "null"
           if payload.nil? || payload == NULL_PAYLOAD
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_NULL_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_NULL_METRIC)
             return nil
           end
 
@@ -104,18 +103,18 @@ module NewRelic
         end
 
         def decode_payload(payload)
-          decoded = if payload.start_with? LBRACE
-            DistributedTracePayload.from_json payload
+          decoded = if payload.start_with?(LBRACE)
+            DistributedTracePayload.from_json(payload)
           else
-            DistributedTracePayload.from_http_safe payload
+            DistributedTracePayload.from_http_safe(payload)
           end
 
           return nil unless check_payload_present(decoded)
 
           decoded
         rescue => e
-          NewRelic::Agent.increment_metric ACCEPT_PARSE_EXCEPTION_METRIC
-          NewRelic::Agent.logger.warn "Error parsing distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Error parsing distributed trace payload", e)
           nil
         end
 
@@ -131,7 +130,7 @@ module NewRelic
 
             true
           else
-            NewRelic::Agent.increment_metric ACCEPT_PARSE_EXCEPTION_METRIC
+            NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
             false
           end
         end
@@ -140,7 +139,7 @@ module NewRelic
           if DistributedTracePayload.major_version_matches?(payload)
             true
           else
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_MAJOR_VERSION_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_MAJOR_VERSION_METRIC)
             false
           end
         end
@@ -148,7 +147,7 @@ module NewRelic
         def check_trusted_account(payload)
           compare_key = payload.trusted_account_key || payload.parent_account_id
           unless compare_key == NewRelic::Agent.config[:trusted_account_key]
-            NewRelic::Agent.increment_metric IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC)
             return false
           end
           true