newrelic_rpm 9.19.0 → 9.20.0

data/lib/new_relic/agent/opentelemetry/context/propagation.rb

@@ -0,0 +1,15 @@
+# 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
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      module Context
+        module Propagation
+          require_relative 'propagation/trace_propagator'
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/context.rb

@@ -0,0 +1,13 @@
+# 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
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      module Context
+        require_relative 'context/propagation'
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace/span.rb

@@ -7,14 +7,22 @@ module NewRelic
     module OpenTelemetry
       module Trace
         class Span < ::OpenTelemetry::Trace::Span
-          attr_reader :context
+          attr_accessor :finishable
 
-          def initialize(segment:, transaction:)
-            @context = ::OpenTelemetry::Trace::SpanContext.new(
-              trace_id: transaction.trace_id,
-              span_id: segment.guid,
-              trace_flags: 1
-            )
+          def finish(end_timestamp: nil)
+            finishable&.finish
+          end
+
+          def set_attribute(key, value)
+            NewRelic::Agent.add_custom_span_attributes(key => value)
+          end
+
+          def add_attributes(attributes)
+            NewRelic::Agent.add_custom_span_attributes(attributes)
+          end
+
+          def record_exception(exception, attributes: nil)
+            NewRelic::Agent.notice_error(exception, attributes: attributes)
           end
         end
       end

data/lib/new_relic/agent/opentelemetry/trace/tracer.rb

@@ -12,25 +12,116 @@ module NewRelic
             @version = version || ''
           end
 
+          def start_span(name, with_parent: nil, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
+            parent_otel_context = ::OpenTelemetry::Trace.current_span(with_parent).context
+
+            finishable = if can_start_transaction?(parent_otel_context)
+              return if internal_span_kind_with_invalid_parent?(kind, parent_otel_context)
+
+              nr_item = NewRelic::Agent::Tracer.start_transaction_or_segment(name: name, category: :otel)
+              add_remote_context_to_txn(nr_item, parent_otel_context)
+              nr_item
+            else
+              NewRelic::Agent::Tracer.start_segment(name: name)
+            end
+
+            otel_span = get_otel_span_from_finishable(finishable)
+            otel_span.finishable = finishable
+            add_remote_context_to_otel_span(otel_span, parent_otel_context)
+            otel_span.add_attributes(attributes) if attributes
+            otel_span
+          end
+
           def in_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
-            case kind
-            when :internal
-              begin
-                return yield unless NewRelic::Agent::Tracer.current_transaction
-
-                segment = NewRelic::Agent::Tracer.start_segment(name: name)
-                span = Span.new(segment: segment, transaction: segment.transaction)
-
-                ::OpenTelemetry::Trace.with_span(span) do
-                  yield
-                end
-              ensure
-                segment&.finish
-              end
+            span = start_span(name, attributes: attributes, links: links, start_timestamp: start_timestamp, kind: kind)
+            begin
+              yield
+            rescue => e
+              # TODO: Update for segment errors if finishable is a segment
+              NewRelic::Agent.notice_error(e)
+              raise
+            end
+          ensure
+            span&.finish
+          end
+
+          private
+
+          def get_otel_span_from_finishable(finishable)
+            case finishable
+            when NewRelic::Agent::Transaction
+              finishable.segments.first.instance_variable_get(:@otel_span)
+            when NewRelic::Agent::Transaction::Segment
+              finishable.instance_variable_get(:@otel_span)
             else
-              NewRelic::Agent.logger.debug("Span kind: #{kind} is not supported yet")
+              NewRelic::Agent.logger.warn('Tracer#get_otel_span_from_finishable failed to get span from finishable - finishable is not a transaction or segment')
+              nil
             end
           end
+
+          def can_start_transaction?(parent_otel_context)
+            parent_otel_context.remote? || !parent_otel_context.valid?
+          end
+
+          def internal_span_kind_with_invalid_parent?(kind, parent_otel_context)
+            !parent_otel_context.valid? && kind == :internal
+          end
+
+          def transaction_and_remote_parent?(txn, parent_otel_context)
+            txn.is_a?(NewRelic::Agent::Transaction) && parent_otel_context.remote?
+          end
+
+          def add_remote_context_to_txn(txn, parent_otel_context)
+            return unless transaction_and_remote_parent?(txn, parent_otel_context)
+
+            txn.trace_id = parent_otel_context.trace_id
+            txn.parent_span_id = parent_otel_context.span_id
+
+            set_tracestate(txn.distributed_tracer, parent_otel_context)
+          end
+
+          def set_tracestate(distributed_tracer, otel_context)
+            case otel_context.tracestate
+            when ::OpenTelemetry::Trace::Tracestate
+              set_otel_trace_state(distributed_tracer, otel_context)
+            when NewRelic::Agent::TraceContextPayload
+              set_nr_trace_state(distributed_tracer, otel_context)
+            end
+          end
+
+          def set_nr_trace_state(distributed_tracer, otel_context)
+            distributed_tracer.instance_variable_set(:@trace_state_payload, otel_context.tracestate)
+            distributed_tracer.parent_transaction_id = distributed_tracer.trace_state_payload.transaction_id
+            distributed_tracer.determine_sampling_decision(otel_context.tracestate, otel_context.trace_flags)
+          end
+
+          def set_otel_trace_state(distributed_tracer, otel_context)
+            nr_entry = otel_context.tracestate.value(Transaction::TraceContext::AccountHelpers.trace_state_entry_key)
+            return unless nr_entry
+
+            nr_payload = NewRelic::Agent::TraceContextPayload.from_s(nr_entry)
+            distributed_tracer.instance_variable_set(:@trace_state_payload, nr_payload)
+            distributed_tracer.parent_transaction_id = distributed_tracer.trace_state_payload.transaction_id
+            trace_flags = parse_trace_flags(otel_context.trace_flags)
+            distributed_tracer.determine_sampling_decision(nr_payload, trace_flags)
+          end
+
+          def parse_trace_flags(trace_flags)
+            case trace_flags
+            when String
+              trace_flags
+            when Integer
+              trace_flags.to_s
+            when ::OpenTelemetry::Trace::TraceFlags
+              trace_flags.sampled? ? '01' : '00'
+            end
+          end
+
+          def add_remote_context_to_otel_span(otel_span, parent_otel_context)
+            return unless transaction_and_remote_parent?(otel_span.finishable, parent_otel_context)
+
+            otel_span.context.instance_variable_set(:@trace_id, otel_span.finishable.trace_id)
+          end
         end
       end
     end

data/lib/new_relic/agent/opentelemetry/transaction_patch.rb

@@ -0,0 +1,69 @@
+# 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
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      module TransactionPatch
+        attr_accessor :opentelemetry_context
+
+        def initialize(_category, _options)
+          @opentelemetry_context = {}
+          super
+        end
+
+        def set_current_segment(new_segment)
+          @current_segment_lock.synchronize do
+            unless opentelemetry_context.empty?
+              ::OpenTelemetry::Context.detach(opentelemetry_context[otel_current_span_key])
+            end
+
+            span = find_or_create_span(new_segment)
+            ctx = ::OpenTelemetry::Context.current.set_value(otel_current_span_key, span)
+            token = ::OpenTelemetry::Context.attach(ctx)
+
+            opentelemetry_context[otel_current_span_key] = token
+          end
+
+          super
+        end
+
+        def remove_current_segment_by_thread_id(id)
+          # make sure the context is fully detached when the transaction ends
+          @current_segment_lock.synchronize do
+            ::OpenTelemetry::Context.detach(opentelemetry_context[otel_current_span_key])
+            opentelemetry_context.delete(id)
+          end
+
+          super
+        end
+
+        private
+
+        def find_or_create_span(segment)
+          if segment.instance_variable_defined?(:@otel_span)
+            segment.instance_variable_get(:@otel_span)
+          else
+            span = Trace::Span.new(span_context: span_context_from_segment(segment))
+            segment.instance_variable_set(:@otel_span, span)
+            span
+          end
+        end
+
+        def span_context_from_segment(segment)
+          ::OpenTelemetry::Trace::SpanContext.new(
+            trace_id: segment.transaction.trace_id,
+            span_id: segment.guid,
+            remote: false
+          )
+        end
+
+        def otel_current_span_key
+          # CURRENT_SPAN_KEY is a private constant
+          ::OpenTelemetry::Trace.const_get(:CURRENT_SPAN_KEY)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry_bridge.rb

@@ -18,8 +18,14 @@ module NewRelic
       def self.install
         require 'opentelemetry' # requires the opentelemetry-api gem
         require_relative 'opentelemetry/trace'
+        require_relative 'opentelemetry/transaction_patch'
+        require_relative 'opentelemetry/context'
 
-        ::OpenTelemetry.tracer_provider = NewRelic::Agent::OpenTelemetry::Trace::TracerProvider.new
+        # TODO: Add a warning if SDK gem is installed
+
+        ::OpenTelemetry.tracer_provider = OpenTelemetry::Trace::TracerProvider.new
+        Transaction.prepend(OpenTelemetry::TransactionPatch)
+        ::OpenTelemetry.propagation = OpenTelemetry::Context::Propagation::TracePropagator.new
       end
     end
   end

data/lib/new_relic/agent/parameter_filtering.rb

@@ -9,7 +9,7 @@ module NewRelic
 
       ACTION_DISPATCH_PARAMETER_FILTER ||= 'action_dispatch.parameter_filter'.freeze
 
-      if defined?(Rails) && Gem::Version.new(::Rails::VERSION::STRING) >= Gem::Version.new('5.0.0')
+      if defined?(Rails) && NewRelic::Helper.version_satisfied?(::Rails::VERSION::STRING, '>=', '5.0.0')
         Rails.application.config.to_prepare do
           RAILS_FILTER_CLASS ||= if defined?(ActiveSupport::ParameterFilter)
             ActiveSupport::ParameterFilter

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

@@ -42,7 +42,7 @@ module NewRelic
           # Process.times on JRuby < 1.7.0 reports wall clock elapsed time,
           # not actual cpu time used, so this sampler can only be used on JRuby >= 1.7.0.
           if defined?(JRuby)
-            return JRUBY_VERSION >= '1.7.0'
+            return NewRelic::Helper.version_satisfied?(JRUBY_VERSION, '>=', '1.7.0')
           end
 
           true

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

@@ -50,7 +50,7 @@ module NewRelic
             begin
               NewRelic::Helper.run_command('uname -s').downcase
             rescue NewRelic::CommandRunFailedError, NewRelic::CommandExecutableNotFoundError
-              'unknown'
+              NewRelic::UNKNOWN_LOWER
             end
           else
             RUBY_PLATFORM.downcase

data/lib/new_relic/agent/span_event_primitive.rb

@@ -40,6 +40,7 @@ module NewRelic
       SERVER_ADDRESS_KEY = 'server.address'
       SERVER_PORT_KEY = 'server.port'
       SPAN_KIND_KEY = 'span.kind'
+      STACKTRACE_KEY = 'code.stacktrace'
       ENTRY_POINT_KEY = 'nr.entryPoint'
       TRUSTED_PARENT_KEY = 'trustedParentId'
       TRACING_VENDORS_KEY = 'tracingVendors'
@@ -122,6 +123,10 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
         end
 
+        if segment.params[:backtrace]
+          agent_attributes[STACKTRACE_KEY] = segment.params[:backtrace]
+        end
+
         [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 

data/lib/new_relic/agent/tracer.rb

@@ -247,7 +247,7 @@ module NewRelic
           log_error('start_segment', exception)
         end
 
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
         OTHER = 'other'.freeze
 
         # Creates and starts a datastore segment used to time

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

@@ -11,7 +11,7 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-        UNKNOWN = 'unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN_LOWER
 
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name, :record_sql

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

@@ -35,7 +35,7 @@ module NewRelic
         end
 
         def caller_transport_type
-          @caller_transport_type ||= 'Unknown'
+          @caller_transport_type ||= NewRelic::UNKNOWN
         end
 
         def accept_transport_type_from_api(value)
@@ -127,7 +127,7 @@ module NewRelic
         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
+              incoming_payload = ::JSON.parse(deobfuscate(synthetics_header)) and
               SyntheticsMonitor.is_valid_payload?(incoming_payload) and
               SyntheticsMonitor.is_supported_version?(incoming_payload) and
               SyntheticsMonitor.is_trusted?(incoming_payload)
@@ -167,7 +167,7 @@ module NewRelic
           return unless CrossAppTracing.trusted_valid_cross_app_id?(decoded_id)
 
           txn_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER]
-          txn_info = ::JSON.load(deobfuscate(txn_header))
+          txn_info = ::JSON.parse(deobfuscate(txn_header))
           payload = CrossAppPayload.new(decoded_id, transaction, txn_info)
 
           @cross_app_payload = payload

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

@@ -18,7 +18,7 @@ module NewRelic
         STREAM = 'Stream'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
-        UNKNOWN = 'Unknown'.freeze
+        UNKNOWN = NewRelic::UNKNOWN
 
         DESTINATION_TYPES = [
           :exchange,

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

@@ -136,7 +136,7 @@ module NewRelic
 
           transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
 
-          determine_sampling_decision(payload, header_data)
+          determine_sampling_decision(payload, header_data.trace_parent['trace_flags'])
 
           NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
@@ -146,10 +146,10 @@ module NewRelic
           false
         end
 
-        def determine_sampling_decision(payload, header_data)
-          if header_data.trace_parent['trace_flags'] == '01'
+        def determine_sampling_decision(payload, trace_flags)
+          if trace_flags == '01'
             set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_sampled'], payload)
-          elsif header_data.trace_parent['trace_flags'] == '00'
+          elsif trace_flags == '00'
             set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_not_sampled'], payload)
           else
             use_nr_tracestate_sampled(payload)

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -150,7 +150,7 @@ module NewRelic
           # rubocop:disable Style/SafeNavigation
           transaction_name = transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-            'unknown'
+            NewRelic::UNKNOWN_LOWER
           # rubocop:enable Style/SafeNavigation
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end

data/lib/new_relic/agent/utilization/ecs.rb

@@ -0,0 +1,22 @@
+# 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/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class ECS < Vendor
+        vendor_name 'ecs'
+        endpoint ENV['ECS_CONTAINER_METADATA_URI'] || ''
+        headers 'Metadata' => 'true'
+        keys %w[DockerId]
+
+        def transform_key(key)
+          'ecs' + key
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/ecs_v4.rb

@@ -0,0 +1,22 @@
+# 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/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class ECSV4 < Vendor
+        vendor_name 'ecs_v4'
+        endpoint ENV['ECS_CONTAINER_METADATA_URI_V4'] || ''
+        headers 'Metadata' => 'true'
+        keys %w[DockerId]
+
+        def transform_key(key)
+          'ecs' + key
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization_data.rb

@@ -6,6 +6,8 @@ require 'new_relic/agent/utilization/aws'
 require 'new_relic/agent/utilization/gcp'
 require 'new_relic/agent/utilization/azure'
 require 'new_relic/agent/utilization/pcf'
+require 'new_relic/agent/utilization/ecs'
+require 'new_relic/agent/utilization/ecs_v4'
 
 module NewRelic
   module Agent
@@ -84,10 +86,32 @@ module NewRelic
         result
       end
 
+      def append_ecs_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_aws']
+
+        Thread.new do
+          # try v4 first, and only try unversioned endpoint if v4 fails
+          ecs = Utilization::ECSV4.new
+          if ecs.detect
+            collector_hash[:vendors] ||= {}
+            collector_hash[:vendors][:ecs] = ecs.metadata
+          else
+            ecs = Utilization::ECS.new
+            if ecs.detect
+              collector_hash[:vendors] ||= {}
+              collector_hash[:vendors][:ecs] = ecs.metadata
+            end
+          end
+        end
+      end
+
       def append_vendor_info(collector_hash)
         threads = []
         complete = false
 
+        # ecs needs be checked even if AWS check succeeds
+        ecs_thread = append_ecs_info(collector_hash)
+
         VENDORS.each_pair do |klass, config_option|
           next unless Agent.config[config_option]
 
@@ -106,6 +130,7 @@ module NewRelic
         while complete == false && threads.any?(&:alive?)
           sleep 0.01
         end
+        ecs_thread&.join
       end
 
       def append_docker_info(collector_hash)

data/lib/new_relic/agent/vm/c_ruby_vm.rb

@@ -61,7 +61,7 @@ module NewRelic
         end
 
         def gather_constant_cache_invalidations
-          RubyVM.stat[RUBY_VERSION >= '3.2.0' ? :constant_cache_invalidations : :global_constant_state]
+          RubyVM.stat[NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '3.2.0') ? :constant_cache_invalidations : :global_constant_state]
         end
 
         def gather_constant_cache_misses
@@ -86,9 +86,9 @@ module NewRelic
           when :gc_total_time
             NewRelic::LanguageSupport.gc_profiler_enabled?
           when :method_cache_invalidations
-            RUBY_VERSION < '3.0.0'
+            NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '3.0.0')
           when :constant_cache_misses
-            RUBY_VERSION >= '3.2.0'
+            NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '3.2.0')
           else
             false
           end