newrelic_rpm 6.15.0 → 8.13.1

data/lib/new_relic/agent/transaction.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
@@ -24,33 +23,32 @@ module NewRelic
       include Tracing
 
       # for nested transactions
-      NESTED_TRANSACTION_PREFIX    = "Nested/"
-      CONTROLLER_PREFIX            = "Controller/"
-      MIDDLEWARE_PREFIX            = "Middleware/Rack/"
-      OTHER_TRANSACTION_PREFIX     = "OtherTransaction/"
-      TASK_PREFIX                  = "#{OTHER_TRANSACTION_PREFIX}Background/"
-      RAKE_PREFIX                  = "#{OTHER_TRANSACTION_PREFIX}Rake/"
-      MESSAGE_PREFIX               = "#{OTHER_TRANSACTION_PREFIX}Message/"
-      RACK_PREFIX                  = "#{CONTROLLER_PREFIX}Rack/"
-      SINATRA_PREFIX               = "#{CONTROLLER_PREFIX}Sinatra/"
-      GRAPE_PREFIX                 = "#{CONTROLLER_PREFIX}Grape/"
-      ACTION_CABLE_PREFIX          = "#{CONTROLLER_PREFIX}ActionCable/"
-
-      WEB_TRANSACTION_CATEGORIES   = [:web, :controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
-      TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
-
-      MIDDLEWARE_SUMMARY_METRICS   = ["Middleware/all"].freeze
-      WEB_SUMMARY_METRIC           = "HttpDispatcher"
-      OTHER_SUMMARY_METRIC         = "#{OTHER_TRANSACTION_PREFIX}all"
-      QUEUE_TIME_METRIC            = "WebFrontend/QueueTime"
-
-      APDEX_S                       = "S"
-      APDEX_T                       = "T"
-      APDEX_F                       = "F"
-      APDEX_ALL_METRIC              = "ApdexAll"
-      APDEX_METRIC                  = "Apdex"
-      APDEX_OTHER_METRIC            = "ApdexOther"
-      APDEX_TXN_METRIC_PREFIX       = "Apdex/"
+      NESTED_TRANSACTION_PREFIX = "Nested/"
+      CONTROLLER_PREFIX = "Controller/"
+      MIDDLEWARE_PREFIX = "Middleware/Rack/"
+      OTHER_TRANSACTION_PREFIX = "OtherTransaction/"
+      TASK_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Background/"
+      RAKE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Rake/"
+      MESSAGE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Message/"
+      RACK_PREFIX = "#{CONTROLLER_PREFIX}Rack/"
+      SINATRA_PREFIX = "#{CONTROLLER_PREFIX}Sinatra/"
+      GRAPE_PREFIX = "#{CONTROLLER_PREFIX}Grape/"
+      ACTION_CABLE_PREFIX = "#{CONTROLLER_PREFIX}ActionCable/"
+
+      WEB_TRANSACTION_CATEGORIES = [:web, :controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
+
+      MIDDLEWARE_SUMMARY_METRICS = ["Middleware/all"].freeze
+      WEB_SUMMARY_METRIC = "HttpDispatcher"
+      OTHER_SUMMARY_METRIC = "#{OTHER_TRANSACTION_PREFIX}all"
+      QUEUE_TIME_METRIC = "WebFrontend/QueueTime"
+
+      APDEX_S = "S"
+      APDEX_T = "T"
+      APDEX_F = "F"
+      APDEX_ALL_METRIC = "ApdexAll"
+      APDEX_METRIC = "Apdex"
+      APDEX_OTHER_METRIC = "ApdexOther"
+      APDEX_TXN_METRIC_PREFIX = "Apdex/"
       APDEX_OTHER_TXN_METRIC_PREFIX = "ApdexOther/Transaction/"
 
       JRUBY_CPU_TIME_ERROR = "Error calculating JRuby CPU Time"
@@ -67,27 +65,28 @@ module NewRelic
       attr_accessor :apdex_start
 
       attr_accessor :exceptions,
-                    :filtered_params,
-                    :jruby_cpu_start,
-                    :process_cpu_start,
-                    :http_response_code,
-                    :response_content_length,
-                    :response_content_type,
-                    :parent_span_id
+        :filtered_params,
+        :jruby_cpu_start,
+        :process_cpu_start,
+        :http_response_code,
+        :response_content_length,
+        :response_content_type,
+        :parent_span_id
 
       attr_reader :guid,
-                  :metrics,
-                  :gc_start_snapshot,
-                  :category,
-                  :attributes,
-                  :payload,
-                  :nesting_max_depth,
-                  :segments,
-                  :end_time,
-                  :duration
+        :metrics,
+        :logs,
+        :gc_start_snapshot,
+        :category,
+        :attributes,
+        :payload,
+        :nesting_max_depth,
+        :segments,
+        :end_time,
+        :duration
 
       attr_writer :sampled,
-                  :priority
+        :priority
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
@@ -100,13 +99,13 @@ module NewRelic
         Tracer.current_transaction
       end
 
-      def self.set_default_transaction_name(partial_name, category = nil) #THREAD_LOCAL_ACCESS
-        txn  = tl_current
+      def self.set_default_transaction_name(partial_name, category = nil) # THREAD_LOCAL_ACCESS
+        txn = tl_current
         name = name_from_partial(partial_name, category || txn.category)
         txn.set_default_transaction_name(name, category)
       end
 
-      def self.set_overriding_transaction_name(partial_name, category = nil) #THREAD_LOCAL_ACCESS
+      def self.set_overriding_transaction_name(partial_name, category = nil) # THREAD_LOCAL_ACCESS
         txn = tl_current
         return unless txn
 
@@ -119,38 +118,16 @@ module NewRelic
         "#{namer.prefix_for_category(self, category)}#{partial_name}"
       end
 
-      def self.wrap(state, name, category, options = {})
-        Deprecator.deprecate 'Transaction.wrap',
-                             'Tracer#in_transaction'
-
-        finishable = Tracer.start_transaction_or_segment(
-              name: name,
-              category: category,
-              options: options
-            )
-
-        begin
-          # We shouldn't raise from Transaction.start, but only wrap the yield
-          # to be absolutely sure we don't report agent problems as app errors
-          yield
-        rescue => e
-          Transaction.notice_error(e)
-          raise e
-        ensure
-          finishable.finish if finishable
-        end
-      end
-
       def self.start_new_transaction(state, category, options)
         txn = Transaction.new(category, options)
         state.reset(txn)
         txn.state = state
-        txn.start
+        txn.start(options)
         txn
       end
 
       def self.nested_transaction_name(name)
-        if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(OTHER_TRANSACTION_PREFIX)
+        if name.start_with?(CONTROLLER_PREFIX, OTHER_TRANSACTION_PREFIX)
           "#{NESTED_TRANSACTION_PREFIX}#{name}"
         else
           name
@@ -165,7 +142,7 @@ module NewRelic
       end
 
       # See NewRelic::Agent.notice_error for options and commentary
-      def self.notice_error(e, options={})
+      def self.notice_error(e, options = {})
         if txn = Tracer.current_transaction
           txn.notice_error(e, options)
         elsif NewRelic::Agent.instance
@@ -178,7 +155,7 @@ module NewRelic
       #
       # @api public
       #
-      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
+      def self.recording_web_transaction? # THREAD_LOCAL_ACCESS
         NewRelic::Agent.record_api_supportability_metric(:recording_web_transaction?)
 
         txn = tl_current
@@ -202,7 +179,7 @@ module NewRelic
         if txn = tl_current
           txn.add_agent_attribute(key, value, default_destinations)
         else
-          NewRelic::Agent.logger.debug "Attempted to add agent attribute: #{key} without transaction"
+          NewRelic::Agent.logger.debug("Attempted to add agent attribute: #{key} without transaction")
         end
       end
 
@@ -215,7 +192,7 @@ module NewRelic
         if txn = tl_current
           txn.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
         else
-          NewRelic::Agent.logger.debug "Attempted to merge untrusted attributes without transaction"
+          NewRelic::Agent.logger.debug("Attempted to merge untrusted attributes without transaction")
         end
       end
 
@@ -229,8 +206,8 @@ module NewRelic
       if defined? JRuby
         begin
           require 'java'
-          java_import 'java.lang.management.ManagementFactory'
-          java_import 'com.sun.management.OperatingSystemMXBean'
+          java_import('java.lang.management.ManagementFactory')
+          java_import('com.sun.management.OperatingSystemMXBean')
           @@java_classes_loaded = true
         rescue
         end
@@ -238,17 +215,19 @@ module NewRelic
 
       def initialize(category, options)
         @nesting_max_depth = 0
-        @current_segment = nil
+        @current_segment_by_thread = {}
+        @current_segment_lock = Mutex.new
         @segments = []
 
         self.default_name = options[:transaction_name]
-        @overridden_name    = nil
-        @frozen_name      = nil
+        @overridden_name = nil
+        @frozen_name = nil
 
         @category = category
-        @start_time = Time.now
+        @start_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @end_time = nil
         @duration = nil
+
         @apdex_start = options[:apdex_start_time] || @start_time
         @jruby_cpu_start = jruby_cpu_time
         @process_cpu_start = process_cpu
@@ -257,6 +236,7 @@ module NewRelic
 
         @exceptions = {}
         @metrics = TransactionMetrics.new
+        @logs = PrioritySampledBuffer.new(NewRelic::Agent.instance.log_event_aggregator.capacity)
         @guid = NewRelic::Agent::GuidGenerator.generate_guid
 
         @ignore_this_transaction = false
@@ -274,18 +254,39 @@ module NewRelic
         merge_request_parameters(@filtered_params)
 
         if request = options[:request]
-          @request_attributes = RequestAttributes.new request
+          @request_attributes = RequestAttributes.new(request)
         else
           @request_attributes = nil
         end
       end
 
+      def parent_thread_id
+        ::Thread.current.nr_parent_thread_id if ::Thread.current.respond_to?(:nr_parent_thread_id)
+      end
+
+      def current_segment
+        current_thread_id = ::Thread.current.object_id
+        return current_segment_by_thread[current_thread_id] if current_segment_by_thread[current_thread_id]
+        return current_segment_by_thread[parent_thread_id] if current_segment_by_thread[parent_thread_id]
+
+        current_segment_by_thread[@starting_thread_id]
+      end
+
+      def set_current_segment(new_segment)
+        @current_segment_lock.synchronize { current_segment_by_thread[::Thread.current.object_id] = new_segment }
+      end
+
+      def remove_current_segment_by_thread_id(id)
+        @current_segment_lock.synchronize { current_segment_by_thread.delete(id) }
+      end
+
       def distributed_tracer
         @distributed_tracer ||= DistributedTracer.new(self)
       end
 
       def sampled?
         return unless Agent.config[:'distributed_tracing.enabled']
+
         if @sampled.nil?
           @sampled = NewRelic::Agent.instance.adaptive_sampler.sampled?
         end
@@ -293,7 +294,7 @@ module NewRelic
       end
 
       def trace_id
-        @trace_id ||= NewRelic::Agent::GuidGenerator.generate_guid 32
+        @trace_id ||= NewRelic::Agent::GuidGenerator.generate_guid(32)
       end
 
       def trace_id=(value)
@@ -316,7 +317,7 @@ module NewRelic
         @request_attributes && @request_attributes.port
       end
 
-      # This transaction-local hash may be used as temprory storage by
+      # This transaction-local hash may be used as temporary storage by
       # instrumentation that needs to pass data from one instrumentation point
       # to another.
       #
@@ -348,6 +349,7 @@ module NewRelic
 
       def set_default_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
+
         if influences_transaction_name?(category)
           self.default_name = name
           @category = category if category
@@ -356,6 +358,7 @@ module NewRelic
 
       def set_overriding_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
+
         if influences_transaction_name?(category)
           self.overridden_name = name
           @category = category if category
@@ -373,9 +376,9 @@ module NewRelic
 
       def best_name
         @frozen_name ||
-        @overridden_name ||
-        @default_name ||
-        NewRelic::Agent::UNKNOWN_METRIC
+          @overridden_name ||
+          @default_name ||
+          NewRelic::Agent::UNKNOWN_METRIC
       end
 
       # For common interface with Trace
@@ -413,32 +416,33 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      def start
+      def start(options = {})
         return if !state.is_execution_traced?
 
-        sql_sampler.on_start_transaction(state, start_time, request_path)
+        sql_sampler.on_start_transaction(state, request_path)
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::TransactionTimeAggregator.transaction_start(start_time)
 
         ignore! if user_defined_rules_ignore?
 
-        create_initial_segment
-        Segment.merge_untrusted_agent_attributes \
+        create_initial_segment(options)
+        Segment.merge_untrusted_agent_attributes( \
           @filtered_params,
           :'request.parameters',
           AttributeFilter::DST_SPAN_EVENTS
+        )
       end
 
       def initial_segment
         segments.first
       end
 
-      def create_initial_segment
-        segment = create_segment @default_name
+      def create_initial_segment(options = {})
+        segment = create_segment(@default_name, options)
         segment.record_scoped_metric = false
       end
 
-      def create_segment(name)
+      def create_segment(name, options = {})
         summary_metrics = nil
 
         if name.start_with?(MIDDLEWARE_PREFIX)
@@ -452,6 +456,10 @@ module NewRelic
           unscoped_metrics: summary_metrics
         )
 
+        # #code_information will glean the code info out of the options hash
+        # if it exists or noop otherwise
+        segment.code_information = options
+
         segment
       end
 
@@ -461,18 +469,19 @@ module NewRelic
           merge_request_parameters(options[:filtered_params])
         end
 
-        @ignore_apdex = options[:ignore_apdex] if options.key? :ignore_apdex
-        @ignore_enduser = options[:ignore_enduser] if options.key? :ignore_enduser
+        @ignore_apdex = options[:ignore_apdex] if options.key?(:ignore_apdex)
+        @ignore_enduser = options[:ignore_enduser] if options.key?(:ignore_enduser)
 
-        nest_initial_segment if nesting_max_depth == 1
-        nested_name = self.class.nested_transaction_name options[:transaction_name]
-        segment = create_segment nested_name
+        nest_initial_segment if segments.length == 1
+        nested_name = self.class.nested_transaction_name(options[:transaction_name])
+
+        segment = create_segment(nested_name, options)
         set_default_transaction_name(options[:transaction_name], category)
         segment
       end
 
       def nest_initial_segment
-        self.initial_segment.name = self.class.nested_transaction_name initial_segment.name
+        self.initial_segment.name = self.class.nested_transaction_name(initial_segment.name)
         initial_segment.record_scoped_metric = true
       end
 
@@ -505,8 +514,9 @@ module NewRelic
 
       def finish
         return unless state.is_execution_traced?
-        @end_time = Time.now
-        @duration = @end_time.to_f - @start_time.to_f
+
+        @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+        @duration = @end_time - @start_time
         freeze_name_and_execute_if_not_ignored
 
         if nesting_max_depth == 1
@@ -554,6 +564,7 @@ module NewRelic
 
         record_exceptions
         record_transaction_event
+        record_log_events
         merge_metrics
         send_transaction_finished_event
       end
@@ -561,19 +572,16 @@ module NewRelic
       def assign_segment_dt_attributes
         dt_payload = distributed_tracer.trace_state_payload || distributed_tracer.distributed_trace_payload
         parent_attributes = {}
-        DistributedTraceAttributes.copy_parent_attributes self, dt_payload, parent_attributes
-        parent_attributes.each { |k, v| initial_segment.add_agent_attribute k, v }
+        DistributedTraceAttributes.copy_parent_attributes(self, dt_payload, parent_attributes)
+        parent_attributes.each { |k, v| initial_segment.add_agent_attribute(k, v) }
       end
 
       def assign_agent_attributes
         default_destinations = AttributeFilter::DST_TRANSACTION_TRACER |
-                               AttributeFilter::DST_TRANSACTION_EVENTS |
-                               AttributeFilter::DST_ERROR_COLLECTOR
+          AttributeFilter::DST_TRANSACTION_EVENTS |
+          AttributeFilter::DST_ERROR_COLLECTOR
 
         if http_response_code
-          add_agent_attribute(:httpResponseCode, http_response_code.to_s, default_destinations)
-          # Sending status code as an int with http.statusCode key is correct
-          # The above attribute is deprecated and should be removed in agent version 7.0.0
           add_agent_attribute(:'http.statusCode', http_response_code, default_destinations)
         end
 
@@ -586,7 +594,7 @@ module NewRelic
         end
 
         if @request_attributes
-          @request_attributes.assign_agent_attributes self
+          @request_attributes.assign_agent_attributes(self)
         end
 
         display_host = Agent.config[:'process_host.display_name']
@@ -623,10 +631,10 @@ module NewRelic
       # This method returns transport_duration in seconds. Transport duration
       # is stored in milliseconds on the payload, but it's needed in seconds
       # for metrics and intrinsics.
-      def calculate_transport_duration distributed_trace_payload
+      def calculate_transport_duration(distributed_trace_payload)
         return unless distributed_trace_payload
 
-        duration = (start_time.to_f * 1000 - distributed_trace_payload.timestamp) / 1000
+        duration = start_time - (distributed_trace_payload.timestamp / 1000.0)
         duration < 0 ? 0 : duration
       end
 
@@ -646,14 +654,14 @@ module NewRelic
 
       def generate_payload
         @payload = {
-          :name                 => @frozen_name,
-          :bucket               => recording_web_transaction? ? :request : :background,
-          :start_timestamp      => start_time.to_f,
-          :duration             => duration,
-          :metrics              => @metrics,
-          :attributes           => @attributes,
-          :error                => false,
-          :priority             => priority
+          :name => @frozen_name,
+          :bucket => recording_web_transaction? ? :request : :background,
+          :start_timestamp => start_time,
+          :duration => duration,
+          :metrics => @metrics,
+          :attributes => @attributes,
+          :error => false,
+          :priority => priority
         }
 
         distributed_tracer.append_payload(@payload)
@@ -666,7 +674,7 @@ module NewRelic
       end
 
       def is_synthetics_request?
-        synthetics_payload != nil && raw_synthetics_header != nil
+        !synthetics_payload.nil? && !raw_synthetics_header.nil?
       end
 
       def synthetics_version
@@ -707,7 +715,6 @@ module NewRelic
         when :apdex_s then APDEX_S
         when :apdex_t then APDEX_T
         when :apdex_f then APDEX_F
-        else nil
         end
         payload[:apdex_perf_zone] = bucket_str if bucket_str
       end
@@ -716,8 +723,8 @@ module NewRelic
         return unless is_synthetics_request?
 
         payload[:synthetics_resource_id] = synthetics_resource_id
-        payload[:synthetics_job_id]      = synthetics_job_id
-        payload[:synthetics_monitor_id]  = synthetics_monitor_id
+        payload[:synthetics_job_id] = synthetics_job_id
+        payload[:synthetics_monitor_id] = synthetics_monitor_id
       end
 
       def merge_metrics
@@ -727,35 +734,38 @@ module NewRelic
       def record_exceptions
         error_recorded = false
         @exceptions.each do |exception, options|
-          options[:uri]      ||= request_path if request_path
-          options[:port]       = request_port if request_port
-          options[:metric]     = best_name
+          options[:uri] ||= request_path if request_path
+          options[:port] = request_port if request_port
+          options[:metric] = best_name
           options[:attributes] = @attributes
 
-          span_id = options.delete :span_id
+          span_id = options.delete(:span_id)
           error_recorded = !!agent.error_collector.notice_error(exception, options, span_id) || error_recorded
         end
         payload[:error] = error_recorded if payload
       end
 
       # Do not call this.  Invoke the class method instead.
-      def notice_error(error, options={}) # :nodoc:
-
+      def notice_error(error, options = {}) # :nodoc:
         # Only the last error is kept
-        if @current_segment
-          @current_segment.notice_error error, expected: options[:expected]
-          options[:span_id] = @current_segment.guid
+        if current_segment
+          current_segment.notice_error(error, expected: options[:expected])
+          options[:span_id] = current_segment.guid
         end
 
         if @exceptions[error]
-          @exceptions[error].merge! options
+          @exceptions[error].merge!(options)
         else
           @exceptions[error] = options
         end
       end
 
       def record_transaction_event
-        agent.transaction_event_recorder.record payload
+        agent.transaction_event_recorder.record(payload)
+      end
+
+      def record_log_events
+        agent.log_event_aggregator.record_batch(self, @logs.to_a)
       end
 
       def queue_time
@@ -795,8 +805,8 @@ module NewRelic
             record_apdex_metrics(APDEX_METRIC, APDEX_TXN_METRIC_PREFIX, apdex_t)
           else
             record_apdex_metrics(APDEX_OTHER_METRIC,
-                                 APDEX_OTHER_TXN_METRIC_PREFIX,
-                                 transaction_specific_apdex_t)
+              APDEX_OTHER_TXN_METRIC_PREFIX,
+              transaction_specific_apdex_t)
           end
         end
       end
@@ -804,9 +814,9 @@ module NewRelic
       def record_apdex_metrics(rollup_metric, transaction_prefix, current_apdex_t)
         return unless current_apdex_t
 
-        total_duration      = end_time - apdex_start
+        total_duration = end_time - apdex_start
         apdex_bucket_global = apdex_bucket(total_duration, current_apdex_t)
-        apdex_bucket_txn    = apdex_bucket(duration, current_apdex_t)
+        apdex_bucket_txn = apdex_bucket(duration, current_apdex_t)
 
         @metrics.record_unscoped(rollup_metric, apdex_bucket_global, current_apdex_t)
         @metrics.record_unscoped(APDEX_ALL_METRIC, apdex_bucket_global, current_apdex_t)
@@ -824,7 +834,7 @@ module NewRelic
       end
 
       def threshold
-         source_class = Agent.config.source(:'transaction_tracer.transaction_threshold').class
+        source_class = Agent.config.source(:'transaction_tracer.transaction_threshold').class
         if source_class == Configuration::DefaultSource
           apdex_t * 4
         else
@@ -832,7 +842,7 @@ module NewRelic
         end
       end
 
-      def with_database_metric_name(model, method, product=nil)
+      def with_database_metric_name(model, method, product = nil)
         previous = self.instrumentation_state[:datastore_override]
         model_name = case model
                      when Class
@@ -841,7 +851,7 @@ module NewRelic
                        model
                      else
                        model.to_s
-                     end
+        end
         self.instrumentation_state[:datastore_override] = [method, model_name, product]
         yield
       ensure
@@ -852,6 +862,10 @@ module NewRelic
         attributes.merge_custom_attributes(p)
       end
 
+      def add_log_event(event)
+        logs.append(event: event)
+      end
+
       def recording_web_transaction?
         web_category?(@category)
       end
@@ -870,11 +884,13 @@ module NewRelic
 
       def normal_cpu_burn
         return unless @process_cpu_start
+
         process_cpu - @process_cpu_start
       end
 
       def jruby_cpu_burn
         return unless @jruby_cpu_start
+
         jruby_cpu_time - @jruby_cpu_start
       end
 
@@ -910,18 +926,21 @@ module NewRelic
 
       def process_cpu
         return nil if defined? JRuby
+
         p = Process.times
         p.stime + p.utime
       end
 
       def jruby_cpu_time
         return nil unless @@java_classes_loaded
+
         threadMBean = Java::JavaLangManagement::ManagementFactory.getThreadMXBean()
 
         return nil unless threadMBean.isCurrentThreadCpuTimeSupported
-        java_utime = threadMBean.getCurrentThreadUserTime()  # ns
 
-        -1 == java_utime ? 0.0 : java_utime/1e9
+        java_utime = threadMBean.getCurrentThreadUserTime() # ns
+
+        -1 == java_utime ? 0.0 : java_utime / 1e9
       rescue => e
         ::NewRelic::Agent.logger.log_once(:warn, :jruby_cpu_time, JRUBY_CPU_TIME_ERROR, e)
         ::NewRelic::Agent.logger.debug(JRUBY_CPU_TIME_ERROR, e)