newrelic_rpm 10.5.0 → 10.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53ece09719003e8bd215b6b809a5ea7089546577e0107b323b64055601e06171
-  data.tar.gz: 3e7d00ad842bf03e8612657e8e78669b332be80eaac406713c5ab462eaa4e54e
+  metadata.gz: 04f3daab2bb3609b38de8f2a1eb9c16bbbee814b6a7f8536abc4db1f09bc8634
+  data.tar.gz: 8c32e76b543d25220865b18f2247489df611bce74c1b755a97fcd79c7ddeb9d3
 SHA512:
-  metadata.gz: c12d4ed6d3520e1657917d7ffd21e7db8f4026060cea521e8a33de2f7d98af0bc7e7b2e1049eb74655dea6ab6e558cd16e7410a691f2fe271cff0e9fb6aebf87
-  data.tar.gz: b67bbe080e6bb3ddf2a3c26f2b2b2ada57780cf9a49fab21c7d8421d3e9748c4250c7e61eae4a1ec1f2a9430df42151ff6cdee97e9e11059578f6c0dabf57b73
+  metadata.gz: 369084a1fd6fc7313177f80da8701e51e431062fc5d3d6fc602491a58c4e91afe997262f74ff15a66a451812dbcb40c68634bf580cdbdc0c8053d4bf2c3a12b4
+  data.tar.gz: ef014f91db60cd980859de6eda2177dac2f42c49b16d590d69aec2aa4365a160045d2c181badf990944519e824e3fb54f0a52dd5cfef3fe8d836d132d69ce340

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # New Relic Ruby Agent Release Notes
 
+## v10.6.0
+
+- **Feature: SpanLink events are now supported for the Hybrid Agent**
+
+Spans created by an OpenTelemetry API can now have [Span Links](https://opentelemetry.io/docs/concepts/signals/traces/#span-links) associated with them. Links can be added on a span's start, by passing them to the `links` argument, or by calling the `OpenTelemetry::Trace::Span#add_link` API. [PR#3586](https://github.com/newrelic/newrelic-ruby-agent/pull/3586)
+
+- **Feature: SpanEvent events are now supported for the Hybrid Agent**
+
+Spans created by an OpenTelemetry API can now have [SpanEvent events](https://opentelemetry.io/docs/concepts/signals/traces/#span-events) associated with them via the `OpenTelemetry::Trace::Span#add_event` API. SpanEvent events capture timestamped annotations on a span and are sent to New Relic alongside the parent span. [PR#3587](https://github.com/newrelic/newrelic-ruby-agent/pull/3587)
+
+- **Feature: Set Span Kind on all Hybrid Agent spans**
+
+  Previously, only OpenTelemetry spans translated into external request segments or datastore segments added span kind as an attribute. Now, the agent adds span kind to all OpenTelemetry spans where the value is available. [PR#3589](https://github.com/newrelic/newrelic-ruby-agent/pull/3589)
+
+- **Feature: Add support for OpenTelemetry::Tracer#start_root_span**
+
+  The `OpenTelemetry::Tracer#start_root_span` API can now be used to force a transaction to start for a given span, provided it has a `:server` or `:consumer` span kind. For any other span kinds, it will no-op. This method is most commonly used in background job instrumentation. [PR#3588](https://github.com/newrelic/newrelic-ruby-agent/pull/3588)
+
+- **Bugfix: Fix `instrumentation.rails_event_logger: false` not disabling the instrumentation**
+
+  Setting `instrumentation.rails_event_logger` to `false` was not disabling the Rails.event instrumentation as expected. The instrumentation would still be installed during Rails boot. This has been fixed. [PR#3564](https://github.com/newrelic/newrelic-ruby-agent/pull/3564)
+
+- **Bugfix: Normalize boolean-like values to `disabled` for instrumentation config keys**
+
+  Setting any `instrumentation.*` config key to `false`, `no`, or `off` instead of `disabled` will now resolve to `disabled` and prevent the instrumentation from being installed. [PR#3579](https://github.com/newrelic/newrelic-ruby-agent/pull/3579)
+
+- **Bugfix: Per-library logging supportability metrics now reflect each library's instrumentation state**
+
+  The `Supportability/Logging/Ruby/{library}/{enabled|disabled}` metrics previously echoed `application_logging.enabled` for every library, so disabling a single logging instrumentation or running without one of its gems still reported `enabled`. Each library now reports based on its own instrumentation state. [PR#3571](https://github.com/newrelic/newrelic-ruby-agent/pull/3571)
+
 ## v10.5.0
 
 - **Feature: Add Dalli 5.0 support and fix meta protocol instrumentation**

data/lib/new_relic/agent/configuration/default_source.rb

@@ -1792,12 +1792,12 @@ module NewRelic
           :description => 'Controls auto-instrumentation of the LogStasher library at start-up. May be one of: `auto`, `prepend`, `chain`, `disabled`.'
         },
         :'instrumentation.rails_event_logger' => {
-          :default => value_of(:'application_logging.enabled'),
-          :documentation_default => 'true',
+          :default => instrumentation_value_from_boolean(:'application_logging.enabled'),
+          :documentation_default => 'enabled',
           :public => true,
-          :type => Boolean,
+          :type => String,
           :allowed_from_server => false,
-          :description => 'Controls instrumentation of Rails.event as structured logs'
+          :description => 'Controls instrumentation of Rails.event as structured logs. May be one of: `enabled`, `disabled`.'
         },
         :'instrumentation.rails_event_logger.event_names' => {
           :default => [],

data/lib/new_relic/agent/configuration/manager.rb

@@ -26,6 +26,7 @@ module NewRelic
         }.freeze
 
         INSTRUMENTATION_VALUES = %w[chain prepend unsatisfied]
+        INSTRUMENTATION_DISABLED_VALUES = %w[false no off].freeze
         NUMERIC_TYPES = [Integer, Float]
         STRINGLIKE_TYPES = [String, Symbol]
 
@@ -178,6 +179,11 @@ module NewRelic
           false
         end
 
+        def instrumentation_key?(key)
+          key.to_s.match?(/\Ainstrumentation\.[^.]+\z/) &&
+            DEFAULTS.dig(key, :type) == String
+        end
+
         def handle_nil_type(key, value, category)
           return value if %i[manual test].include?(category)
 
@@ -205,6 +211,7 @@ module NewRelic
 
           type = DEFAULTS.dig(key, :type)
           return handle_nil_type(key, value, category) unless type
+          return 'disabled' if instrumentation_key?(key) && INSTRUMENTATION_DISABLED_VALUES.include?(value.to_s.downcase)
           return value if value.is_a?(type) || boolean?(type, value) || instrumentation?(type, value)
           return numeric_conversion(value) if NUMERIC_TYPES.include?(type) && NUMERIC_TYPES.include?(value.class)
           return string_conversion(value) if STRINGLIKE_TYPES.include?(type) && STRINGLIKE_TYPES.include?(value.class)

data/lib/new_relic/agent/database/explain_plan_helpers.rb

@@ -80,7 +80,7 @@ module NewRelic
           unless NewRelic::Agent::Database.record_sql_method == :raw
             query_plan_string = NewRelic::Agent::Database::PostgresExplainObfuscator.obfuscate(query_plan_string)
           end
-          values = query_plan_string.split("\n").map { |line| [line] }
+          values = query_plan_string.split("\n").zip
 
           [[QUERY_PLAN], values]
         end

data/lib/new_relic/agent/error_collector.rb

@@ -286,13 +286,13 @@ module NewRelic
           trace[-keep_frames..-1].unshift("<truncated #{truncate_frames} additional frames>")
         when 'end'
           # Remove the end, keep the beginning
-          trace[0...keep_frames].concat(["<truncated #{truncate_frames} additional frames>"])
+          trace[0...keep_frames].push("<truncated #{truncate_frames} additional frames>")
         else # 'middle' or default (original behavior)
           # Remove the middle, keep beginning and end
           # If keep_frames is odd, we will split things up favoring the top of the trace
           keep_top = (keep_frames / 2.0).ceil
           keep_bottom = (keep_frames / 2.0).floor
-          trace[0...keep_top].concat(["<truncated #{truncate_frames} additional frames>"]).concat(trace[-keep_bottom..-1])
+          trace[0...keep_top].push("<truncated #{truncate_frames} additional frames>").concat(trace[-keep_bottom..-1])
         end
       end
 

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -24,7 +24,13 @@ module NewRelic
       FORWARDING_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Forwarding/Ruby/%s'.freeze
       DECORATING_SUPPORTABILITY_FORMAT = 'Supportability/Logging/LocalDecorating/Ruby/%s'.freeze
       LABELS_SUPPORTABILITY_FORMAT = 'Supportability/Logging/Labels/Ruby/%s'.freeze
-      SUPPORTED_LOGGING_LIBRARIES = %w[Logger LogStasher Logging SemanticLogger RailsEventLogger].freeze
+      SUPPORTED_LOGGING_LIBRARIES = {
+        'Logger' => :'instrumentation.logger',
+        'LogStasher' => :'instrumentation.logstasher',
+        'Logging' => :'instrumentation.logging',
+        'SemanticLogger' => :'instrumentation.semantic_logger',
+        'RailsEventLogger' => :'instrumentation.rails_event_logger'
+      }.freeze
       MAX_BYTES = 32768 # 32 * 1024 bytes (32 kibibytes)
       SKIP_SEMANTIC_LOGGER_VARS = %w[@level @level_index @message @time @payload].freeze
       SKIP_RAILS_EVENT_KEYS = %w[message level].freeze
@@ -479,8 +485,8 @@ module NewRelic
           record_configuration_metric(FORWARDING_SUPPORTABILITY_FORMAT, FORWARDING_ENABLED_KEY)
           record_configuration_metric(DECORATING_SUPPORTABILITY_FORMAT, DECORATING_ENABLED_KEY)
           record_configuration_metric(LABELS_SUPPORTABILITY_FORMAT, LABELS_ENABLED_KEY)
-          SUPPORTED_LOGGING_LIBRARIES.each do |library|
-            record_logs_supportability_metric(library, OVERALL_ENABLED_KEY)
+          SUPPORTED_LOGGING_LIBRARIES.each do |library, instrumentation_key|
+            record_logs_supportability_metric(library, instrumentation_key)
           end
 
           add_custom_attributes(NewRelic::Agent.config[CUSTOM_ATTRIBUTES_KEY])
@@ -492,8 +498,10 @@ module NewRelic
         NewRelic::Agent.increment_metric(format % label)
       end
 
-      def record_logs_supportability_metric(library, key)
-        label = supportability_label_for(key)
+      def record_logs_supportability_metric(library, instrumentation_key)
+        value = NewRelic::Agent.config[instrumentation_key]
+        installed = @enabled && value != 'disabled' && value != :unsatisfied
+        label = installed ? 'enabled' : 'disabled'
         NewRelic::Agent.increment_metric("Supportability/Logging/Ruby/#{library}/#{label}")
       end
 

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

@@ -6,6 +6,53 @@ module NewRelic
   module Agent
     module OpenTelemetry
       module AbstractSegmentPatch
+        MAX_SPAN_LINKS = 100
+        SPAN_LINKS_DROPPED_METRIC = 'Supportability/Ruby/SpanEvent/Links/Dropped'
+        MAX_SPAN_EVENTS = 100
+        SPAN_EVENTS_DROPPED_METRIC = 'Supportability/Ruby/SpanEvent/Events/Dropped'
+
+        def add_span_link(link)
+          @span_links ||= []
+          if @span_links.size >= MAX_SPAN_LINKS
+            NewRelic::Agent.record_metric(SPAN_LINKS_DROPPED_METRIC, 1)
+            return
+          end
+          @span_links << link
+        end
+
+        def span_links
+          instance_variable_defined?(:@span_links) ? @span_links : NewRelic::EMPTY_ARRAY
+        end
+
+        # This method adds SpanEvent events to a Span event/Segment.
+        # A SpanEvent is used to denote a meaningful, singular point in a
+        # Span's duration.
+        def add_span_event_event(name, attributes: nil, timestamp: nil)
+          @span_events ||= []
+
+          if @span_events.size >= MAX_SPAN_EVENTS
+            NewRelic::Agent.record_metric(SPAN_EVENTS_DROPPED_METRIC, 1)
+            return
+          end
+
+          # Normalize to Float seconds at storage time.
+          # OTel may pass Integer nanoseconds; New Relic uses Float seconds.
+          ts = if timestamp.nil?
+            Process.clock_gettime(Process::CLOCK_REALTIME)
+          elsif timestamp.is_a?(Integer)
+            timestamp / 1_000_000_000.0
+          else
+            timestamp
+          end
+
+          @span_events << {name: name, attributes: attributes, timestamp: ts}
+        end
+
+        # Used to reference SpanEvent events associated with a Span/Segment
+        def span_events
+          instance_variable_defined?(:@span_events) ? @span_events : NewRelic::EMPTY_ARRAY
+        end
+
         def force_finish
           if instance_variable_defined?(:@otel_span)
             otel_span = instance_variable_get(:@otel_span)

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

@@ -3,9 +3,12 @@
 # frozen_string_literal: true
 
 require_relative 'translators/datastore_translator'
+require_relative 'translators/redis_datastore_translator'
 require_relative 'translators/http_client_translator'
 require_relative 'translators/http_server_translator'
 require_relative 'translators/generic_translator'
+require_relative 'translators/rpc_translator'
+require_relative 'translators/messaging_translator'
 
 module NewRelic
   module Agent
@@ -19,19 +22,19 @@ module NewRelic
             # pg instrumentation doesn't have db.system assigned when connect
             # spans start, so they would be incorrectly assigned
             # the HttpClientTranslator
-            'opentelemetry-instrumentation-pg' => DatastoreTranslator
-            # 'opentelemetry-instrumentation-redis' => RedisDatastoreTranslator,
+            'opentelemetry-instrumentation-pg' => DatastoreTranslator,
+            'opentelemetry-instrumentation-redis' => RedisDatastoreTranslator
           },
           discriminating_attribute: {
             'db.system' => DatastoreTranslator,
-            'db.system.name' => DatastoreTranslator
-            # 'rpc.system' => RpcTranslator,
+            'db.system.name' => DatastoreTranslator,
+            'rpc.system' => RpcTranslator
           },
           span_kind: {
             client: HttpClientTranslator,
             server: HttpServerTranslator,
-            # consumer: MessagingConsumerTranslator,
-            # producer: MessagingProducerTranslator,
+            consumer: MessagingTranslator,
+            producer: MessagingTranslator,
             internal: GenericTranslator
           }
         }.freeze
@@ -64,7 +67,7 @@ module NewRelic
               GenericTranslator
             end
 
-          translator.translate(attributes: attributes, name: name, instrumentation_scope: instrumentation_scope)
+          translator.translate(attributes: attributes, name: name, instrumentation_scope: instrumentation_scope, kind: span_kind)
         end
       end
     end

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

@@ -0,0 +1,39 @@
+# 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 MessagingPatch
+        # A producer span with a remote parent MUST start a new
+        # transaction. Naming for that case is handled by MessagingPatch
+        # since NR's transaction_name only knows about :consume
+        PRODUCE = 'Produce/'
+
+        def transaction_name(library, destination_type, destination_name, action = nil)
+          return super unless action == :produce
+
+          name = Transaction::MESSAGE_PREFIX + library
+          name << NewRelic::SLASH
+          name << Transaction::MessageBrokerSegment::TYPES[destination_type]
+          name << NewRelic::SLASH
+          name << PRODUCE
+
+          case destination_type
+          when :queue, :topic, :exchange
+            name << Transaction::MessageBrokerSegment::NAMED
+            name << destination_name.to_s
+          when :temporary_queue, :temporary_topic
+            name << Transaction::MessageBrokerSegment::TEMP
+          else # handles :stream or :unknown
+            name << Transaction::MessageBrokerSegment::NAMED
+            name << destination_name.to_s
+          end
+
+          name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# 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_relative '../attributes'
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      module SpanEventPrimitivePatch
+        SPAN_LINK_TYPE = 'SpanLink'
+        SPAN_EVENT_TYPE = 'SpanEvent'
+        ID_KEY = 'id'
+        LINKED_SPAN_ID_KEY = 'linkedSpanId'
+        LINKED_TRACE_ID_KEY = 'linkedTraceId'
+        TRACE_DOT_ID_KEY = 'trace.id'
+        SPAN_DOT_ID_KEY = 'span.id'
+
+        def for_segment(segment)
+          span_data = super
+          update_spans_for_otel(span_data, segment)
+        end
+
+        def for_external_request_segment(segment)
+          span_data = super
+          update_spans_for_otel(span_data, segment)
+        end
+
+        def for_datastore_segment(segment)
+          span_data = super
+          update_spans_for_otel(span_data, segment)
+        end
+
+        private
+
+        def update_spans_for_otel(span_data, segment)
+          span_data = attach_span_kind(span_data, segment)
+          span_data = attach_span_links(span_data, segment)
+          attach_span_event_events(span_data, segment)
+        end
+
+        def attach_span_kind(span_data, segment)
+          if segment.instance_variable_defined?(:@otel_span)
+            otel_span = segment.instance_variable_get(:@otel_span)
+            kind = otel_span.kind&.to_s
+            span_data[0][SpanEventPrimitive::SPAN_KIND_KEY] = kind if kind
+
+            span_data
+          end
+        end
+
+        def attach_span_links(span_data, segment)
+          links = for_span_links(segment)
+          links.empty? ? span_data : span_data << links
+        end
+
+        def for_span_links(segment)
+          return [] if segment.span_links.empty?
+
+          segment.span_links.map do |link|
+            ctx = link.span_context
+            intrinsics = {
+              SpanEventPrimitive::TYPE_KEY => SPAN_LINK_TYPE,
+              SpanEventPrimitive::TIMESTAMP_KEY => milliseconds_since_epoch(segment),
+              ID_KEY => segment.guid,
+              TRACE_DOT_ID_KEY => segment.transaction.trace_id,
+              LINKED_SPAN_ID_KEY => ctx.hex_span_id,
+              LINKED_TRACE_ID_KEY => ctx.hex_trace_id
+            }
+            [intrinsics, sanitize_event_attributes(link.attributes), {}]
+          end
+        end
+
+        def attach_span_event_events(span_data, segment)
+          span_events = for_span_event_events(segment)
+          return span_data if span_events.empty?
+
+          if span_data.length > 3
+            span_data[3].concat(span_events)
+          else
+            span_data << span_events
+          end
+
+          span_data
+        end
+
+        def for_span_event_events(segment)
+          return [] if segment.span_events.empty?
+
+          segment.span_events.map do |evt|
+            intrinsics = {
+              SpanEventPrimitive::TYPE_KEY => SPAN_EVENT_TYPE,
+              # This is the same formula as milliseconds_since_epoch, but without
+              # the segment.start_time value
+              SpanEventPrimitive::TIMESTAMP_KEY => Integer(evt[:timestamp].to_f * 1000.0),
+              SPAN_DOT_ID_KEY => segment.guid,
+              TRACE_DOT_ID_KEY => segment.transaction.trace_id,
+              SpanEventPrimitive::NAME_KEY => evt[:name]
+            }
+            [intrinsics, sanitize_event_attributes(evt[:attributes]), {}]
+          end
+        end
+
+        def sanitize_event_attributes(attrs)
+          return NewRelic::EMPTY_HASH if attrs.nil? || attrs.empty?
+
+          filter = NewRelic::Agent.instance.attribute_filter
+          attr_obj = Attributes.new(filter)
+          attr_obj.merge_custom_attributes(attrs)
+          attr_obj.custom_attributes_for(AttributeFilter::DST_SPAN_EVENTS)
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,7 @@ module NewRelic
       module Trace
         class Span < ::OpenTelemetry::Trace::Span
           attr_accessor :finishable
+          attr_accessor :kind
           attr_writer :translator
           attr_reader :status
 
@@ -23,7 +24,7 @@ module NewRelic
             return if attributes.nil? || attributes.empty?
 
             if @translator
-              translated = @translator.translate(attributes: attributes)
+              translated = @translator.translate(attributes: attributes, kind: @kind)
               apply_translated_attributes(translated)
             else
               # fallback to adding all attributes to the span as custom
@@ -31,6 +32,27 @@ module NewRelic
             end
           end
 
+          def add_link(link)
+            return self unless recording?
+
+            # add_span_link lives in OpenTelemetry::AbstractSegmentPatch
+            # and in OpenTelemetry::TransactionPatch
+            finishable&.add_span_link(link)
+            self
+          end
+
+          def add_event(name, attributes: nil, timestamp: nil)
+            # This method adds SpanEvent events to a Span event.
+            # A SpanEvent is used to denote a meaningful, singular point in a
+            # Span's duration.
+            return self unless recording?
+
+            # add_span_event_event lives in OpenTelemetry::AbstractSegmentPatch
+            # and in OpenTelemetry::TransactionPatch
+            finishable&.add_span_event_event(name, attributes: attributes, timestamp: timestamp)
+            self
+          end
+
           def apply_translated_attributes(translated)
             translated[:instance_variable].each do |key, value|
               sym_key = "@#{key}".to_sym

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

@@ -35,10 +35,12 @@ module NewRelic
 
             otel_span.finishable = finishable
             otel_span.status = ::OpenTelemetry::Trace::Status.unset
+            otel_span.kind = kind
             otel_span.translator = translated[:translator]
             add_remote_context_to_otel_span(otel_span, parent_otel_context)
             otel_span.add_instrumentation_scope(@name, @version)
             otel_span.apply_translated_attributes(translated)
+            links&.each { |link| otel_span.add_link(link) }
 
             otel_span
           end
@@ -56,6 +58,10 @@ module NewRelic
             span&.finish
           end
 
+          def start_root_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
+            start_span(name, with_parent: ::OpenTelemetry::Context.empty, attributes: attributes, links: links, start_timestamp: start_timestamp, kind: kind)
+          end
+
           private
 
           def start_segment_from_otel(name:, translated: nil, start_timestamp: nil, kind: nil)
@@ -63,9 +69,9 @@ module NewRelic
 
             case kind
             when :client
-              if segment_api_params[:uri] # HTTP Client
+              if segment_api_params[:uri] # HTTP Client and gRPC Client
                 NewRelic::Agent::Tracer.start_external_request_segment(
-                  library: @name,
+                  library: segment_api_params[:library] || @name,
                   uri: segment_api_params[:uri],
                   procedure: segment_api_params[:procedure],
                   start_time: start_timestamp
@@ -81,12 +87,29 @@ module NewRelic
                   start_time: start_timestamp
                 )
 
-                segment&._notice_sql(segment_api_params[:sql])
+                if segment_api_params[:sql]
+                  segment&._notice_sql(segment_api_params[:sql])
+                elsif segment_api_params[:nosql_statement]
+                  segment&.notice_nosql_statement(segment_api_params[:nosql_statement])
+                end
 
                 segment
               else
                 NewRelic::Agent::Tracer.start_segment(name: name)
               end
+            when :producer, :consumer
+              if segment_api_params[:library] # Messaging
+                NewRelic::Agent::Tracer.start_message_broker_segment(
+                  action: segment_api_params[:action],
+                  library: segment_api_params[:library],
+                  destination_type: segment_api_params[:destination_type],
+                  destination_name: segment_api_params[:destination_name],
+                  parameters: messaging_segment_parameters(segment_api_params),
+                  start_time: start_timestamp
+                )
+              else
+                NewRelic::Agent::Tracer.start_segment(name: name)
+              end
             else
               NewRelic::Agent::Tracer.start_segment(name: name)
             end
@@ -97,14 +120,16 @@ module NewRelic
             segment_api_params = translated[:for_segment_api]
 
             case kind
-            when :server
+            when :server # HTTP or gRPC server calls
               nr_item = NewRelic::Agent::Tracer.start_transaction_or_segment(
                 name: segment_api_params[:name] || name,
                 category: :web
               )
             when :client
               nr_item = NewRelic::Agent::Tracer.start_transaction_or_segment(name: name, category: :web)
-            when :consumer, :producer, :internal, nil
+            when :consumer, :producer
+              nr_item = start_messaging_transaction(name, segment_api_params)
+            when :internal, nil
               nr_item = NewRelic::Agent::Tracer.start_transaction_or_segment(name: name, category: :task)
             end
 
@@ -113,6 +138,21 @@ module NewRelic
             nr_item
           end
 
+          def messaging_segment_parameters(segment_api_params)
+            return nil unless NewRelic::Agent.config[:'message_tracer.segment_parameters.enabled']
+
+            segment_api_params[:parameters]
+          end
+
+          def start_messaging_transaction(name, segment_api_params)
+            return NewRelic::Agent::Tracer.start_transaction_or_segment(name: name, category: :task) unless segment_api_params[:name]
+
+            NewRelic::Agent::Tracer.start_transaction_or_segment(
+              name: segment_api_params[:name],
+              category: :message
+            )
+          end
+
           def get_otel_span_from_finishable(finishable)
             case finishable
             when NewRelic::Agent::Transaction

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

@@ -31,6 +31,26 @@ module NewRelic
           super
         end
 
+        def add_span_link(link)
+          initial_segment&.add_span_link(link)
+        end
+
+        def span_links
+          initial_segment&.span_links || NewRelic::EMPTY_ARRAY
+        end
+
+        # This method adds a SpanEvent event to the Transaction's initial segment.
+        # A SpanEvent is used to denote a meaningful, singular point in a
+        # Span's duration.
+        def add_span_event_event(name, attributes: nil, timestamp: nil)
+          initial_segment&.add_span_event_event(name, attributes: attributes, timestamp: timestamp)
+        end
+
+        # Used to reference SpanEvent events associated with the initial segment.
+        def span_events
+          initial_segment&.span_events || NewRelic::EMPTY_ARRAY
+        end
+
         private
 
         def find_or_create_span(segment)

data/lib/new_relic/agent/opentelemetry/translators/attribute_mappings.rb

@@ -97,6 +97,33 @@ module NewRelic
           }
         }.freeze
 
+        REDIS_MAPPINGS = { # v1.25, v1.17
+          'product' => {
+            otel_keys: ['db.system.name', 'db.system'],
+            segment_field: :product
+          },
+          'database_name' => {
+            otel_keys: ['db.namespace', 'db.name'],
+            segment_field: :database_name
+          },
+          'host' => {
+            otel_keys: ['server.address', 'net.peer.name'],
+            segment_field: :host
+          },
+          'port_path_or_id' => {
+            otel_keys: ['server.port', 'net.peer.port'],
+            segment_field: :port_path_or_id
+          },
+          'operation' => {
+            otel_keys: ['db.operation.name', 'db.operation'],
+            segment_field: :operation
+          },
+          'nosql_statement' => {
+            otel_keys: ['db.statement', 'db.query.text'],
+            segment_field: :nosql_statement
+          }
+        }.freeze
+
         HTTP_SERVER_MAPPINGS = { # v1.23, v1.20
           'http_response_code' => {
             otel_keys: ['http.response.status_code', 'http.status_code'],
@@ -123,6 +150,106 @@ module NewRelic
             destinations: DEFAULT_DESTINATIONS
           }
         }.freeze
+
+        RPC_SERVER_MAPPINGS = { # v1.20
+          'response_status' => {
+            otel_keys: ['rpc.grpc.status_code'],
+            category: :instance_variable
+          },
+          'request.headers.host' => {
+            otel_keys: ['net.sock.peer.addr', 'server.address', 'net.peer.name'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          },
+          'request.method' => {
+            otel_keys: ['rpc.method'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          }
+        }.freeze
+
+        RPC_CLIENT_MAPPINGS = { # v1.17
+          'grpc_status_code' => {
+            otel_keys: ['rpc.grpc.status_code'],
+            category: :instance_variable
+          },
+          # the value closest to library in intention is rpc.system. however,
+          # to get the correct segment name, we need to set this to rpc.service
+          'library' => {
+            otel_keys: ['rpc.service'],
+            segment_field: :library
+          },
+          'procedure' => {
+            otel_keys: ['rpc.method'],
+            segment_field: :procedure
+          },
+          'host' => {
+            # traditional host keys aren't sent by otel grpc instrumentation
+            # so we use net.sock.peer.address to fill the host field
+            otel_keys: ['net.sock.peer.addr', 'server.address', 'net.peer.name'],
+            segment_field: :host
+          },
+          # not sent by gRPC OTel instrumentation, but can sometimes be gleaned
+          # by net.sock.peer.addr
+          'port' => {
+            otel_keys: ['server.port', 'net.peer.port'],
+            segment_field: :port
+          }
+        }.freeze
+
+        MESSAGING_CONSUMER_MAPPINGS = { # v1.30/v1.24, v1.17
+          'messaging.system' => {
+            otel_keys: ['messaging.system'],
+            category: :agent,
+            destinations: AttributeFilter::DST_TRANSACTION_TRACER
+          },
+          'message.queueName' => {
+            otel_keys: ['messaging.destination.name', 'messaging.destination'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS,
+            segment_field: :destination_name
+          },
+          'port' => {
+            otel_keys: ['server.port', 'net.peer.port'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          },
+          'host' => {
+            otel_keys: ['server.address', 'net.peer.name'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          },
+          'message.routingKey' => {
+            otel_keys: [
+              'messaging.kafka.message.key',
+              'messaging.rabbitmq.destination.routing_key'
+            ],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          }
+        }.freeze
+
+        MESSAGING_PRODUCER_MAPPINGS = { # v1.30/v1.24, v1.17
+          'messaging.system' => {
+            otel_keys: ['messaging.system'],
+            category: :agent,
+            destinations: AttributeFilter::DST_TRANSACTION_TRACER
+          },
+          'destination_name' => {
+            otel_keys: ['messaging.destination.name', 'messaging.destination'],
+            segment_field: :destination_name
+          },
+          'port' => {
+            otel_keys: ['server.port', 'net.peer.port'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          },
+          'host' => {
+            otel_keys: ['server.address', 'net.peer.name'],
+            category: :agent,
+            destinations: DEFAULT_DESTINATIONS
+          }
+        }.freeze
       end
     end
   end

data/lib/new_relic/agent/opentelemetry/translators/base_translator.rb

@@ -14,7 +14,7 @@ module NewRelic
           # This method should be redefined in child classes.
           # The body of the method should be the mappings constant defined in the
           #  AttributesMappings module for the attribute type being translated
-          def mappings_hash
+          def mappings_hash(kind)
             # no-op
             NewRelic::EMPTY_HASH
           end
@@ -28,11 +28,11 @@ module NewRelic
           #
           # @return [Hash] A hash with attributes divided into various categories for assignment on a New Relic
           # transaction or segment.
-          def translate(attributes: {}, name: nil, instrumentation_scope: nil)
+          def translate(attributes: {}, name: nil, instrumentation_scope: nil, kind: nil)
             working_attrs = attributes.dup # shallow copy
             result = {intrinsic: {}, agent: {}, custom: {}, for_segment_api: {}, instance_variable: {}, translator: self}
 
-            mappings_hash.each do |nr_key, mapping|
+            mappings_hash(kind).each do |nr_key, mapping|
               value = extract_first_present(working_attrs, mapping[:otel_keys])
               next unless value
 
@@ -54,7 +54,7 @@ module NewRelic
             # specialized attributes.
             # This method will augment the working result hash, so it does not
             # need to be merged.
-            add_specialized_attributes(result: result, name: name, attributes: attributes, instrumentation_scope: instrumentation_scope)
+            add_specialized_attributes(result: result, name: name, attributes: attributes, instrumentation_scope: instrumentation_scope, kind: kind)
 
             # Assign any remaining attributes as custom attributes
             result[:custom] = working_attrs
@@ -71,7 +71,7 @@ module NewRelic
           # @param [optional, String] instrumentation_scope The instrumentation scope provided to the translate method
           #
           # @return [Hash] The augmented result hash
-          def add_specialized_attributes(result: {}, name: nil, attributes: {}, instrumentation_scope: nil)
+          def add_specialized_attributes(result: {}, name: nil, attributes: {}, instrumentation_scope: nil, kind: nil)
             # no-op
             {}
           end

data/lib/new_relic/agent/opentelemetry/translators/datastore_translator.rb

@@ -9,11 +9,11 @@ module NewRelic
     module OpenTelemetry
       class DatastoreTranslator < BaseTranslator
         class << self
-          def mappings_hash
+          def mappings_hash(_kind)
             AttributeMappings::DATASTORE_MAPPINGS
           end
 
-          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil)
+          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil, kind: nil)
             operation = parse_operation(name, attributes)
             result[:for_segment_api][:operation] = operation if operation
 

data/lib/new_relic/agent/opentelemetry/translators/generic_translator.rb

@@ -11,7 +11,7 @@ module NewRelic
       # because there are no known New Relic attributes to translate
       class GenericTranslator < BaseTranslator
         class << self
-          def mappings_hash
+          def mappings_hash(_kind)
             NewRelic::EMPTY_HASH
           end
         end

data/lib/new_relic/agent/opentelemetry/translators/http_client_translator.rb

@@ -9,11 +9,11 @@ module NewRelic
     module OpenTelemetry
       class HttpClientTranslator < BaseTranslator
         class << self
-          def mappings_hash
+          def mappings_hash(_kind)
             AttributeMappings::HTTP_CLIENT_MAPPINGS
           end
 
-          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil)
+          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil, kind: nil)
             uri = build_uri(attributes)
             result[:for_segment_api][:uri] = uri if uri
 

data/lib/new_relic/agent/opentelemetry/translators/http_server_translator.rb

@@ -9,11 +9,11 @@ module NewRelic
     module OpenTelemetry
       class HttpServerTranslator < BaseTranslator
         class << self
-          def mappings_hash
+          def mappings_hash(_kind)
             AttributeMappings::HTTP_SERVER_MAPPINGS
           end
 
-          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil)
+          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil, kind: nil)
             result[:for_segment_api][:name] = create_server_transaction_name(name, instrumentation_scope, attributes)
 
             result

data/lib/new_relic/agent/opentelemetry/translators/messaging_translator.rb

@@ -0,0 +1,128 @@
+# 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_relative 'base_translator'
+require_relative '../../messaging'
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      class MessagingTranslator < BaseTranslator
+        # OTel seems to be inconsistent with dot or underscore,
+        # so we handle both just in case.
+        DESTINATION_TYPES_MAP = {
+          consumer: {
+            'kafka' => :topic,
+            'rabbitmq' => :queue,
+            'aws.sqs' => :queue,
+            'aws_sqs' => :queue,
+            'aws.sns' => :topic,
+            'aws_sns' => :topic,
+            'aws.kinesis' => :stream,
+            'aws_kinesis' => :stream
+          },
+          producer: {
+            'kafka' => :topic,
+            'rabbitmq' => :exchange,
+            'aws.sqs' => :queue,
+            'aws_sqs' => :queue,
+            'aws.sns' => :topic,
+            'aws_sns' => :topic,
+            'aws.kinesis' => :stream,
+            'aws_kinesis' => :stream
+          }
+        }.freeze
+
+        # `messaging.destination_kind` is a v1.17 attribute that we
+        # should honor when present.
+        DESTINATION_KIND_MAP = {
+          'queue' => :queue,
+          'topic' => :topic
+        }.freeze
+
+        TEMP_MAP = {
+          queue: :temporary_queue,
+          topic: :temporary_topic
+        }.freeze
+
+        ACTION_MAP = {
+          consumer: :consume,
+          producer: :produce
+        }.freeze
+
+        # Capitalize the OTel `messaging.system` value to match the casing used
+        # by NR messaging instrumentation.
+        LIBRARY_MAP = {
+          'kafka' => 'Kafka',
+          'rabbitmq' => 'RabbitMQ',
+          'aws.sqs' => 'SQS',
+          'aws_sqs' => 'SQS',
+          'aws.sns' => 'SNS',
+          'aws_sns' => 'SNS',
+          'aws.kinesis' => 'Kinesis',
+          'aws_kinesis' => 'Kinesis'
+        }.freeze
+
+        ROUTING_KEY_OTEL_KEYS = [
+          'messaging.kafka.message.key',
+          'messaging.rabbitmq.destination.routing_key'
+        ].freeze
+        CORRELATION_ID_OTEL_KEY = 'messaging.message.conversation_id'
+
+        class << self
+          def mappings_hash(kind)
+            kind == :consumer ? AttributeMappings::MESSAGING_CONSUMER_MAPPINGS : AttributeMappings::MESSAGING_PRODUCER_MAPPINGS
+          end
+
+          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil, kind: nil)
+            result[:for_segment_api][:action] = ACTION_MAP[kind]
+            result[:for_segment_api][:destination_type] = determine_destination_type(attributes, kind)
+            if (system = attributes['messaging.system'])
+              result[:for_segment_api][:library] = LIBRARY_MAP[system] || system
+            end
+
+            result[:for_segment_api][:name] = build_transaction_name(result[:for_segment_api])
+
+            add_producer_segment_params(result, attributes) if kind == :producer
+
+            result
+          end
+
+          def build_transaction_name(segment_api_params)
+            return nil unless segment_api_params[:library] && segment_api_params[:destination_name]
+
+            NewRelic::Agent::Messaging.transaction_name(
+              segment_api_params[:library],
+              segment_api_params[:destination_type],
+              segment_api_params[:destination_name],
+              segment_api_params[:action]
+            )
+          end
+
+          def add_producer_segment_params(result, attributes)
+            params = {
+              routing_key: ROUTING_KEY_OTEL_KEYS.map { |k| attributes[k] }.compact.first,
+              correlation_id: attributes[CORRELATION_ID_OTEL_KEY]
+            }.compact
+
+            result[:for_segment_api][:parameters] = params unless params.empty?
+          end
+
+          def determine_destination_type(attributes, kind)
+            type = explicit_destination_kind(attributes) ||
+              DESTINATION_TYPES_MAP[kind][attributes['messaging.system']] ||
+              :unknown
+            return type unless attributes['messaging.destination.temporary'] == true
+
+            TEMP_MAP[type] || type
+          end
+
+          def explicit_destination_kind(attributes)
+            DESTINATION_KIND_MAP[attributes['messaging.destination_kind']]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/translators/redis_datastore_translator.rb

@@ -0,0 +1,19 @@
+# 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_relative 'datastore_translator'
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      class RedisDatastoreTranslator < DatastoreTranslator
+        class << self
+          def mappings_hash(_kind)
+            AttributeMappings::REDIS_MAPPINGS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry/translators/rpc_translator.rb

@@ -0,0 +1,63 @@
+# 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_relative 'base_translator'
+
+module NewRelic
+  module Agent
+    module OpenTelemetry
+      class RpcTranslator < BaseTranslator
+        class << self
+          def mappings_hash(kind)
+            kind == :client ? AttributeMappings::RPC_CLIENT_MAPPINGS : AttributeMappings::RPC_SERVER_MAPPINGS
+          end
+
+          def add_specialized_attributes(result: {}, name: nil, attributes: nil, instrumentation_scope: nil, kind: nil)
+            case kind
+            when :client
+              uri = build_uri(attributes)
+              result[:for_segment_api][:uri] = uri if uri
+            when :server
+              server_name = create_server_transaction_name(name: name, attributes: attributes, instrumentation_scope: instrumentation_scope) if name
+              result[:for_segment_api][:name] = server_name if server_name
+
+              uri = build_uri(attributes)
+              if uri
+                result[:agent]['request.uri'] = {value: uri, destinations: AttributeMappings::DEFAULT_DESTINATIONS}
+              end
+            end
+
+            result
+          end
+
+          def create_server_transaction_name(name: nil, attributes: nil, instrumentation_scope: nil)
+            txn_name = name&.delete_prefix(NewRelic::SLASH)
+            Instrumentation::ControllerInstrumentation::TransactionNamer.name_for(nil, nil, :web, {class_name: instrumentation_scope, name: txn_name})
+          end
+
+          def build_uri(attributes)
+            host = attributes['server.address'] || attributes['net.peer.name'] || attributes['net.sock.peer.addr']
+            service = attributes['rpc.service']
+            method = attributes['rpc.method']
+
+            # return early if this method is called with an attributes
+            # hash that doesn't have the required values
+            return unless host || service || method
+
+            # strip scheme prefix (e.g. dns:///, xds:///) used by gRPC name resolvers
+            host = host&.sub(%r{\A\w+:///}, '')
+
+            if host && service && method
+              "grpc://#{host}/#{service}/#{method}"
+            elsif host && method
+              "grpc://#{host}/#{method}"
+            elsif service && method
+              "grpc://#{service}/#{method}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/opentelemetry_bridge.rb

@@ -70,12 +70,16 @@ module NewRelic
         require_relative 'opentelemetry/context'
         require_relative 'opentelemetry/trace_patch'
         require_relative 'opentelemetry/abstract_segment_patch'
+        require_relative 'opentelemetry/messaging_patch'
+        require_relative 'opentelemetry/span_event_primitive_patch'
 
         NewRelic::Agent.logger.warn('OpenTelemetry SDK gem is installed. This may interfere with New Relic instrumentation.') if defined?(OpenTelemetry::SDK)
 
-        ::OpenTelemetry::Trace.singleton_class.prepend(NewRelic::Agent::OpenTelemetry::TracePatch)
+        ::OpenTelemetry::Trace.singleton_class.prepend(OpenTelemetry::TracePatch)
         Transaction.prepend(OpenTelemetry::TransactionPatch)
         Transaction::AbstractSegment.prepend(OpenTelemetry::AbstractSegmentPatch)
+        Messaging.singleton_class.prepend(OpenTelemetry::MessagingPatch)
+        SpanEventPrimitive.prepend(OpenTelemetry::SpanEventPrimitivePatch)
 
         ::OpenTelemetry.tracer_provider = OpenTelemetry::Trace::TracerProvider.new
         ::OpenTelemetry.propagation = OpenTelemetry::Context::Propagation::TracePropagator.new

data/lib/new_relic/agent/span_event_aggregator.rb

@@ -33,6 +33,25 @@ module NewRelic
       SUPPORTABILITY_TOTAL_SENT = 'Supportability/SpanEvent/TotalEventsSent'.freeze
       SUPPORTABILITY_DISCARDED = 'Supportability/SpanEvent/Discarded'.freeze
 
+      def harvest!
+        metadata, events = super
+        # extra_events is for SpanLink and SpanEvent data related to a Span
+        # SpanLink and SpanEvent events are both created by OpenTelemetry APIs
+        extra_events = []
+        events.each do |event|
+          # Spans are normally: [intrinsics, custom_attrs, agent_attrs].
+          # When a span has links, a 4th element is appended:
+          # [intrinsics, custom_attrs, agent_attrs, extra_events]
+          #
+          # SpanLinks and SpanEvents must be sent to the backend at the top
+          # level of the main payload, not nested inside an individual Span.
+          # This pulls them out to be flattened into the final array:
+          # [Span, SpanLink, Span, SpanEvent, Span]
+          extra_events.concat(event.slice!(3)) if event.length > 3
+        end
+        [metadata, events.concat(extra_events)]
+      end
+
       def after_harvest(metadata)
         seen = metadata[:seen]
         sent = metadata[:captured]

data/lib/new_relic/agent/span_event_primitive.rb

@@ -27,6 +27,7 @@ module NewRelic
       DURATION_KEY = 'duration'
       NAME_KEY = 'name'
       CATEGORY_KEY = 'category'
+      GRPC_STATUS_CODE_KEY = 'grpc.statusCode'
       HTTP_URL_KEY = 'http.url'
       HTTP_METHOD_KEY = 'http.method'
       HTTP_REQUEST_METHOD_KEY = 'http.request.method'
@@ -79,6 +80,7 @@ module NewRelic
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
         intrinsics[HTTP_REQUEST_METHOD_KEY] = segment.procedure
         intrinsics[HTTP_STATUS_CODE_KEY] = segment.http_status_code if segment.http_status_code
+        intrinsics[GRPC_STATUS_CODE_KEY] = segment.instance_variable_get(:@grpc_status_code) if segment.instance_variable_defined?(:@grpc_status_code)
         intrinsics[CATEGORY_KEY] = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY] = CLIENT
         intrinsics[SERVER_ADDRESS_KEY] = segment.uri.host

data/lib/new_relic/agent/transaction.rb

@@ -68,6 +68,7 @@ module NewRelic
         :jruby_cpu_start,
         :process_cpu_start,
         :http_response_code,
+        :response_status,
         :response_content_length,
         :response_content_type,
         :parent_span_id
@@ -633,6 +634,10 @@ module NewRelic
           add_agent_attribute(:'http.statusCode', http_response_code, default_destinations)
         end
 
+        if response_status
+          add_agent_attribute(:'response.status', response_status, default_destinations)
+        end
+
         if response_content_length
           add_agent_attribute(:'response.headers.contentLength', response_content_length.to_i, default_destinations)
         end

data/lib/new_relic/dependency_detection.rb

@@ -70,7 +70,8 @@ module DependencyDetection
       #       https://github.com/newrelic/newrelic-ruby-agent/issues/2912
       return if name == :padrino
 
-      NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
+      cache = NewRelic::Agent.config.instance_variable_get(:@cache)
+      cache[config_key] = config_key && cache[config_key] == false ? :disabled : :unsatisfied
     end
 
     def source_location_for(klass, method_name)

data/lib/new_relic/version.rb

@@ -6,7 +6,7 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 10
-    MINOR = 5
+    MINOR = 6
     TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"

data/newrelic.yml

@@ -657,8 +657,9 @@ common: &default_settings
   # auto, prepend, chain, disabled.
   # instrumentation.rack_urlmap: auto
 
-  # Controls instrumentation of Rails.event as structured logs
-  # instrumentation.rails_event_logger: true
+  # Controls instrumentation of Rails.event as structured logs. May be one of:
+  # enabled, disabled.
+  # instrumentation.rails_event_logger: enabled
 
   # An array of Rails.event names to capture as structured log events. For
   # example,

data/newrelic_rpm.gemspec

@@ -54,6 +54,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'feedjira', '3.2.1' unless ENV['CI']
   s.add_development_dependency 'httparty' unless ENV['CI'] # for perf tests and Gabby
+  # TODO: MAJOR VERSION - Remove support for Minitest 4.7.5 and all calls to
+  # skip_unless_minitest5_or_above when we drop support for Ruby 2.7
   s.add_development_dependency 'minitest', "#{RUBY_VERSION >= '2.7.0' ? '5.3.3' : '4.7.5'}"
   s.add_development_dependency 'minitest-stub-const', '0.6'
   s.add_development_dependency 'mocha', '~> 1.16'

data/test/agent_helper.rb

@@ -30,8 +30,8 @@ def fake_guid(length = 16)
   NewRelic::Agent::GuidGenerator.generate_guid(length)
 end
 
-def assert_between(floor, ceiling, value, message = "expected #{floor} <= #{value} <= #{ceiling}")
-  assert((floor <= value && value <= ceiling), message)
+def assert_between(floor, ceiling, value, message = "expected #{value} to be between #{floor} and #{ceiling}")
+  assert((value.between?(floor, ceiling)), message)
 end
 
 def assert_in_delta(expected, actual, delta)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 10.5.0
+  version: 10.6.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -639,6 +639,8 @@ files:
 - lib/new_relic/agent/opentelemetry/context.rb
 - lib/new_relic/agent/opentelemetry/context/propagation.rb
 - lib/new_relic/agent/opentelemetry/context/propagation/trace_propagator.rb
+- lib/new_relic/agent/opentelemetry/messaging_patch.rb
+- lib/new_relic/agent/opentelemetry/span_event_primitive_patch.rb
 - lib/new_relic/agent/opentelemetry/trace.rb
 - lib/new_relic/agent/opentelemetry/trace/span.rb
 - lib/new_relic/agent/opentelemetry/trace/tracer.rb
@@ -652,6 +654,9 @@ files:
 - lib/new_relic/agent/opentelemetry/translators/generic_translator.rb
 - lib/new_relic/agent/opentelemetry/translators/http_client_translator.rb
 - lib/new_relic/agent/opentelemetry/translators/http_server_translator.rb
+- lib/new_relic/agent/opentelemetry/translators/messaging_translator.rb
+- lib/new_relic/agent/opentelemetry/translators/redis_datastore_translator.rb
+- lib/new_relic/agent/opentelemetry/translators/rpc_translator.rb
 - lib/new_relic/agent/opentelemetry_bridge.rb
 - lib/new_relic/agent/parameter_filtering.rb
 - lib/new_relic/agent/payload_metric_mapping.rb