newrelic_rpm 9.9.0 → 9.21.0

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

@@ -0,0 +1,66 @@
+# 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
+          class TracePropagator
+            # The carrier is the object carrying the headers
+            # The context argument is a no-op, as the OpenTelemetry context is not used
+            # The setter argument is a no-op, added for consistency with the OpenTelemetry API
+            def inject(carrier, context: ::OpenTelemetry::Context.current, setter: nil)
+              # TODO: determine if we need to update this method to take Context into account
+              NewRelic::Agent::DistributedTracing.insert_distributed_trace_headers(carrier)
+            end
+
+            # The return value for this method should be an instance of the
+            # OpenTelemetry Context class. The return value of
+            # #accept_distributed_trace_headers is a transaction, so we cannot
+            # use it to extract the context.
+            def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
+              carrier_format = determine_format(getter)
+              trace_context = NewRelic::Agent::DistributedTracing::TraceContext.parse(
+                carrier: carrier,
+                format: carrier_format,
+                trace_state_entry_key: Transaction::TraceContext::AccountHelpers.trace_state_entry_key
+              )
+              tp = trace_context.trace_parent
+              span_context = ::OpenTelemetry::Trace::SpanContext.new(
+                trace_id: tp['trace_id'],
+                span_id: tp['parent_id'],
+                trace_flags: tp['trace_flags'],
+                tracestate: trace_context.trace_state_payload,
+                remote: true
+              )
+              span = ::OpenTelemetry::Trace.non_recording_span(span_context)
+
+              ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)
+            rescue StandardError => e
+              NewRelic::Agent.logger.error("Unable to extract context: #{e.message}")
+              context
+            end
+
+            private
+
+            # The getter is the way OpenTelemetry handles Rack vs. non-Rack
+            # formats. Rather than using their parser, get the class info we
+            # need to do things the New Relic way
+            def determine_format(getter)
+              case getter
+              when ::OpenTelemetry::Context::Propagation::RackEnvGetter
+                FORMAT_RACK
+              when defined?(::OpenTelemetry::Common) && ::OpenTelemetry::Common::Propagation::RackEnvGetter
+                FORMAT_RACK
+              else
+                FORMAT_NON_RACK
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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/{tasks/instrumentation_generator/templates/Envfile.tt → new_relic/agent/opentelemetry/context.rb}

@@ -2,8 +2,12 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-instrumentation_methods :chain, :prepend
-
-gemfile <<~RB
-  gem '<%= @name.downcase %>'
-RB
+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

@@ -0,0 +1,31 @@
+# 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 Trace
+        class Span < ::OpenTelemetry::Trace::Span
+          attr_accessor :finishable
+
+          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
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# 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 Trace
+        class Tracer < ::OpenTelemetry::Trace::Tracer
+          def initialize(name = nil, version = nil)
+            @name = name || ''
+            @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)
+            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.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
+  end
+end

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

@@ -0,0 +1,18 @@
+# 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 Trace
+        class TracerProvider < ::OpenTelemetry::Trace::TracerProvider
+          # TODO: Add a registration mechanism for tracers like exists in the SDK
+          def tracer(name = nil, version = nil)
+            @tracer ||= Tracer.new(name, version)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/trace.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 Trace
+        require_relative 'trace/tracer_provider'
+        require_relative 'trace/tracer'
+        require_relative 'trace/span'
+      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

@@ -0,0 +1,32 @@
+# 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
+    class OpenTelemetryBridge
+      def initialize
+        # no-op without OpenTelemetry API & config
+        return unless defined?(OpenTelemetry) &&
+          NewRelic::Agent.config[:'opentelemetry_bridge.enabled']
+
+        OpenTelemetryBridge.install
+      end
+
+      private
+
+      def self.install
+        require 'opentelemetry' # requires the opentelemetry-api gem
+        require_relative 'opentelemetry/trace'
+        require_relative 'opentelemetry/transaction_patch'
+        require_relative 'opentelemetry/context'
+
+        # 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
+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