newrelic_rpm 9.1.0 → 9.21.0

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -19,7 +19,7 @@ module NewRelic
         def warn_for_yajl
           if defined?(::Yajl)
             require 'yajl/version'
-            if Gem::Version.new(::Yajl::VERSION) < OK_YAJL_VERSION
+            if NewRelic::Helper.version_satisfied?(::Yajl::VERSION, '<', OK_YAJL_VERSION)
               ::NewRelic::Agent.logger.warn("Detected yajl-ruby version #{::Yajl::VERSION} which can cause segfaults with newrelic_rpm's thread profiling features. We strongly recommend you upgrade to the latest yajl-ruby version available.")
             end
           end
@@ -42,7 +42,7 @@ module NewRelic
             return nil
           end
 
-          return_value(::JSON.load(data))
+          return_value(::JSON.parse(data))
         rescue => e
           ::NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} encountered loading collector response: #{data}")
           raise

data/lib/new_relic/agent/new_relic_service.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'zlib'
-require 'timeout'
 require 'new_relic/agent/audit_logger'
 require 'new_relic/agent/new_relic_service/encoders'
 require 'new_relic/agent/new_relic_service/marshaller'
@@ -19,7 +18,13 @@ module NewRelic
 
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
-      CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
+      CONNECTION_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, EOFError, SystemCallError, SocketError]
+      # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until Ruby 2.6.
+      #       Once support for Ruby 2.5 is dropped, we should simply include
+      #       Net::WriteTimeout in the connection errors array directly instead
+      #       of with a conditional
+      CONNECTION_ERRORS << Net::WriteTimeout if defined?(Net::WriteTimeout)
+      CONNECTION_ERRORS.freeze
 
       # The maximum number of times to attempt an HTTP request
       MAX_ATTEMPTS = 2
@@ -138,6 +143,9 @@ module NewRelic
       end
 
       def metric_data(stats_hash)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.metric_data(stats_hash) if NewRelic::Agent.agent.serverless?
+
         timeslice_start = stats_hash.started_at
         timeslice_end = stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)
         metric_data_array = build_metric_data_array(stats_hash)
@@ -149,6 +157,9 @@ module NewRelic
       end
 
       def error_data(unsent_errors)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.error_data(unsent_errors) if NewRelic::Agent.agent.serverless?
+
         invoke_remote(:error_data, [@agent_id, unsent_errors],
           :item_count => unsent_errors.size)
       end
@@ -319,13 +330,15 @@ module NewRelic
 
       def start_connection(conn)
         NewRelic::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
-        Timeout.timeout(@request_timeout) { conn.start }
-        conn
+        conn.start
       end
 
       def setup_connection_timeouts(conn)
-        # We use Timeout explicitly instead of this
-        conn.read_timeout = nil
+        conn.open_timeout = @request_timeout
+        conn.read_timeout = @request_timeout
+        # TODO: MAJOR VERSION - #write_timeout= requires Ruby 2.6+, so remove
+        #       the conditional check once support for Ruby 2.5 is dropped
+        conn.write_timeout = @request_timeout if conn.respond_to?(:write_timeout=)
 
         if conn.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
           conn.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
@@ -362,8 +375,8 @@ module NewRelic
         conn = create_http_connection
         start_connection(conn)
         conn
-      rescue Timeout::Error
-        ::NewRelic::Agent.logger.info('Timeout while attempting to connect. You may need to install system-level CA Certificates, as the ruby agent no longer includes these.')
+      rescue Net::OpenTimeout
+        ::NewRelic::Agent.logger.info('Timed out while attempting to connect. For SSL issues, you may need to install system-level CA Certificates to be used by Net::HTTP.')
         raise
       end
 
@@ -407,7 +420,7 @@ module NewRelic
         else
           request = Net::HTTP::Post.new(opts[:uri], headers)
         end
-        @audit_logger.log_request_headers(opts[:uri], headers)
+        @audit_logger.log_request_headers(filtered_uri(opts[:uri]), headers)
         request['user-agent'] = user_agent
         request.content_type = 'application/octet-stream'
         request.body = opts[:data]
@@ -424,7 +437,7 @@ module NewRelic
         rescue *CONNECTION_ERRORS => e
           close_shared_connection
           if attempts < MAX_ATTEMPTS
-            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
+            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{filtered_uri(opts[:uri])} after #{e}")
             retry
           else
             raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
@@ -436,21 +449,21 @@ module NewRelic
       end
 
       def attempt_request(request, opts)
-        response = nil
         conn = http_connection
-        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{opts[:uri]} with #{request.method}")
-        Timeout.timeout(@request_timeout) do
-          response = conn.request(request)
-        end
-        response
+        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{filtered_uri(opts[:uri])} with #{request.method}")
+        conn.request(request)
       end
 
       def handle_error_response(response, endpoint)
+        NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HTTP_ERROR, [response.code, endpoint])
+
         case response
         when Net::HTTPRequestTimeOut,
              Net::HTTPTooManyRequests,
              Net::HTTPInternalServerError,
-             Net::HTTPServiceUnavailable
+             Net::HTTPServiceUnavailable,
+             Net::OpenTimeout,
+             Net::ReadTimeout
           handle_server_connection_exception(response, endpoint)
         when Net::HTTPBadRequest,
              Net::HTTPForbidden,
@@ -462,7 +475,6 @@ module NewRelic
              Net::HTTPRequestURITooLong,
              Net::HTTPUnsupportedMediaType,
              Net::HTTPExpectationFailed,
-             Net::HTTPUnsupportedMediaType,
              Net::HTTPRequestHeaderFieldsTooLarge
           handle_unrecoverable_server_exception(response, endpoint)
         when Net::HTTPConflict,
@@ -472,9 +484,20 @@ module NewRelic
         when Net::HTTPGone
           handle_gone_response(response, endpoint)
         else
-          record_endpoint_attempts_supportability_metrics(endpoint)
-          record_error_response_supportability_metrics(response.code)
-          raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until
+          #       Ruby 2.6, so it can't be included in the case statement
+          #       as a constant and instead needs to be found here. Once
+          #       support for Ruby 2.5 is dropped, we should have
+          #       Net::WriteTimeout sit in the 'when' clause above alongside
+          #       Net::OpenTimeout and Net::ReadTimeout and this entire if/else
+          #       conditional can be removed.
+          if response.respond_to?(:name) && response.name == 'Net::WriteTimeout'
+            handle_server_connection_exception(response, endpoint)
+          else
+            record_endpoint_attempts_supportability_metrics(endpoint)
+            record_error_response_supportability_metrics(response.code)
+            raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          end
         end
         response
       end
@@ -539,6 +562,8 @@ module NewRelic
       # enough to be worth compressing, and handles any errors the
       # server may return
       def invoke_remote(method, payload = [], options = {})
+        return NewRelic::Agent.agent.serverless_handler.store_payload(method, payload) if NewRelic::Agent.agent.serverless?
+
         start_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         request_send_ts, response_check_ts = nil
         data, encoding, size, serialize_finish_ts = marshal_payload(method, payload, options)
@@ -546,8 +571,10 @@ module NewRelic
         response, request_send_ts, response_check_ts = invoke_remote_send_request(method, payload, data, encoding)
         @marshaller.load(decompress_response(response))
       ensure
-        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
-        record_size_supportability_metrics(method, size, options[:item_count]) if size
+        unless NewRelic::Agent.agent.serverless?
+          record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
+          record_size_supportability_metrics(method, size, options[:item_count]) if size
+        end
       end
 
       def handle_serialization_error(method, e)
@@ -612,9 +639,13 @@ module NewRelic
       def send_request(opts)
         request = prep_request(opts)
         response = relay_request(request, opts)
-        return response if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
 
-        handle_error_response(response, opts[:endpoint])
+        if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+          NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HEALTHY)
+          response
+        else
+          handle_error_response(response, opts[:endpoint])
+        end
       end
 
       def log_response(response)
@@ -674,9 +705,7 @@ module NewRelic
 
       def invoke_remote_send_request(method, payload, data, encoding)
         uri = remote_method_uri(method)
-        full_uri = "#{@collector}#{uri}"
-
-        @audit_logger.log_request(full_uri, payload, @marshaller)
+        @audit_logger.log_request("#{@collector}#{filtered_uri(uri)}", payload, @marshaller)
         request_send_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         response = send_request(:data => data,
           :uri       => uri,
@@ -685,6 +714,10 @@ module NewRelic
           :endpoint  => method)
         [response, request_send_ts, Process.clock_gettime(Process::CLOCK_MONOTONIC)]
       end
+
+      def filtered_uri(uri)
+        uri.gsub(license_key, ASTERISK * license_key.size)
+      end
     end
   end
 end

data/lib/new_relic/agent/obfuscator.rb

@@ -2,8 +2,6 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-# require 'base64'
-
 module NewRelic
   module Agent
     class Obfuscator

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/pipe_channel_manager.rb

@@ -2,7 +2,7 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require 'base64'
+require 'new_relic/base64'
 
 module NewRelic
   module Agent
@@ -257,7 +257,7 @@ module NewRelic
           Marshal.load(data)
         rescue StandardError => e
           ::NewRelic::Agent.logger.error('Failure unmarshalling message from Resque child process', e)
-          ::NewRelic::Agent.logger.debug(Base64.encode64(data))
+          ::NewRelic::Agent.logger.debug(NewRelic::Base64.encode64(data))
           nil
         end