newrelic_rpm 9.17.0 → 9.21.0

data/lib/new_relic/agent/instrumentation/typhoeus/instrumentation.rb

@@ -8,11 +8,11 @@ module NewRelic
       module Typhoeus
         HYDRA_SEGMENT_NAME = 'External/Multiple/Typhoeus::Hydra/run'
         NOTICEABLE_ERROR_CLASS = 'Typhoeus::Errors::TyphoeusError'
-        EARLIEST_VERSION = Gem::Version.new('0.5.3')
+        EARLIEST_VERSION = '0.5.3'
         INSTRUMENTATION_NAME = NewRelic::Agent.base_name(name)
 
         def self.is_supported_version?
-          Gem::Version.new(::Typhoeus::VERSION) >= EARLIEST_VERSION
+          NewRelic::Helper.version_satisfied?(::Typhoeus::VERSION, '>=', EARLIEST_VERSION)
         end
 
         def self.request_is_hydra_enabled?(request)

data/lib/new_relic/agent/llm/chat_completion_summary.rb

@@ -32,7 +32,7 @@ module NewRelic
           # TODO: OLD RUBIES < 2.6
           # Hash#merge accepts multiple arguments in 2.6
           # Remove condition once support for Ruby <2.6 is dropped
-          if RUBY_VERSION >= '2.6.0'
+          if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '2.6.0')
             LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
           else
             LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)

data/lib/new_relic/agent/llm/embedding.rb

@@ -25,7 +25,7 @@ module NewRelic
           # TODO: OLD RUBIES < 2.6
           # Hash#merge accepts multiple arguments in 2.6
           # Remove condition once support for Ruby <2.6 is dropped
-          if RUBY_VERSION >= '2.6.0'
+          if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '>=', '2.6.0')
             LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS, ATTRIBUTE_NAME_EXCEPTIONS)
           else
             LlmEvent::ATTRIBUTE_NAME_EXCEPTIONS.merge(ResponseHeaders::ATTRIBUTE_NAME_EXCEPTIONS).merge(ATTRIBUTE_NAME_EXCEPTIONS)

data/lib/new_relic/agent/local_log_decorator.rb

@@ -43,7 +43,7 @@ module NewRelic
         # URI version 1.0+ will ship with Ruby 3.4
         # Once we drop support for Rubies below 3.4, we can use the
         # URI::RFC2396 parser exclusively.
-        if Gem::Version.new(URI::VERSION) >= Gem::Version.new('1.0')
+        if NewRelic::Helper.version_satisfied?(URI::VERSION, '>=', '1.0')
           URI::RFC2396_PARSER.escape(entity_name)
         else
           URI::DEFAULT_PARSER.escape(entity_name)

data/lib/new_relic/agent/logging.rb

@@ -165,7 +165,7 @@ module NewRelic
         # Positional and Keyword arguments are separated beginning with Ruby 2.7
         # Signature of ::Logger constructor changes in Ruby 2.4 to have both positional and keyword args
         # We pivot on Ruby 2.7 for widest supportability with least amount of hassle.
-        if RUBY_VERSION < '2.7.0'
+        if NewRelic::Helper.version_satisfied?(RUBY_VERSION, '<', '2.7.0')
           def initialize(*args)
             super(*args)
             self.formatter = DecoratingFormatter.new

data/lib/new_relic/agent/messaging.rb

@@ -49,6 +49,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_message_broker_segment(action: nil,
@@ -107,6 +108,7 @@ module NewRelic
       # @return return value of given block, which will be the same as the
       #   return value of an un-instrumented subscribed callback
       #
+      # @!scope class
       # @api public
       #
       def wrap_message_broker_consume_transaction(library:,
@@ -180,6 +182,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_amqp_publish_segment(library:,
@@ -240,6 +243,7 @@ module NewRelic
       #
       # @return [NewRelic::Agent::Transaction::MessageBrokerSegment]
       #
+      # @!scope class
       # @api public
       #
       def start_amqp_consume_segment(library:,
@@ -301,6 +305,7 @@ module NewRelic
       # @return return value of given block, which will be the same as the
       #   return value of an un-instrumented subscribed callback
       #
+      # @!scope class
       # @api public
       #
       def wrap_amqp_consume_transaction(library: nil,

data/lib/new_relic/agent/method_tracer.rb

@@ -65,6 +65,7 @@ module NewRelic
       # categories, but generally this *should never ever be done*.  Most of the time you can aggregate
       # on the server.
       #
+      # @!scope class
       # @api public
       #
       def trace_execution_scoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
@@ -81,6 +82,7 @@ module NewRelic
       #
       # * <tt>metric_names</tt> is a single name or an array of names of metrics
       #
+      # @!scope class
       # @api public
       #
       def trace_execution_unscoped(metric_names, options = NewRelic::EMPTY_HASH) # THREAD_LOCAL_ACCESS
@@ -241,6 +243,7 @@ module NewRelic
         #   # Instrument foo in transaction traces only
         #   add_method_tracer :foo, 'Custom/foo', :metric => false
         #
+        # @!scope class
         # @api public
         #
         def add_method_tracer(method_name, metric_name = nil, options = {})

data/lib/new_relic/agent/monitors/inbound_request_monitor.rb

@@ -32,7 +32,7 @@ module NewRelic
 
       def deserialize_header(encoded_header, key)
         decoded_header = obfuscator.deobfuscate(encoded_header)
-        ::JSON.load(decoded_header)
+        ::JSON.parse(decoded_header)
       rescue => err
         # If we have a failure of any type here, just return nil and carry on
         NewRelic::Agent.logger.debug("Failure deserializing encoded header '#{key}' in #{self.class}, #{err.class}, #{err.message}")

data/lib/new_relic/agent/monitors/synthetics_monitor.rb

@@ -35,7 +35,7 @@ module NewRelic
       end
 
       def load_json(header, key)
-        ::JSON.load(header)
+        ::JSON.parse(header)
       rescue => err
         NewRelic::Agent.logger.debug("Failure loading json header '#{key}' in #{self.class}, #{err.class}, #{err.message}")
         nil

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

@@ -455,7 +455,7 @@ module NewRelic
       end
 
       def handle_error_response(response, endpoint)
-        NewRelic::Agent.agent.health_check.update_status(NewRelic::Agent::HealthCheck::HTTP_ERROR, [response.code, endpoint])
+        NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HTTP_ERROR, [response.code, endpoint])
 
         case response
         when Net::HTTPRequestTimeOut,
@@ -641,7 +641,7 @@ module NewRelic
         response = relay_request(request, opts)
 
         if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
-          NewRelic::Agent.agent.health_check.update_status(NewRelic::Agent::HealthCheck::HEALTHY)
+          NewRelic::Agent.agent&.health_check&.update_status(NewRelic::Agent::HealthCheck::HEALTHY)
           response
         else
           handle_error_response(response, opts[:endpoint])

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

data/lib/new_relic/agent/serverless_handler.rb

@@ -40,7 +40,13 @@ module NewRelic
 
         @event, @context = event, context
 
-        NewRelic::Agent::Tracer.in_transaction(category: category, name: function_name) do
+        txn_name = function_name
+        if ENV['NEW_RELIC_APM_LAMBDA_MODE'] == 'true'
+          source = event_source_event_info['name'] if event_source_event_info
+          txn_name = "#{source.upcase} #{txn_name}" if source
+        end
+
+        NewRelic::Agent::Tracer.in_transaction(category: category, name: txn_name) do
           prep_transaction
 
           process_response(NewRelic::LanguageSupport.constantize(namespace)

data/lib/new_relic/agent/span_event_primitive.rb

@@ -40,10 +40,12 @@ module NewRelic
       SERVER_ADDRESS_KEY = 'server.address'
       SERVER_PORT_KEY = 'server.port'
       SPAN_KIND_KEY = 'span.kind'
+      STACKTRACE_KEY = 'code.stacktrace'
       ENTRY_POINT_KEY = 'nr.entryPoint'
       TRUSTED_PARENT_KEY = 'trustedParentId'
       TRACING_VENDORS_KEY = 'tracingVendors'
       TRANSACTION_NAME_KEY = 'transaction.name'
+      THREAD_ID_KEY = 'thread.id'
 
       # Strings for static values of the event structure
       EVENT_TYPE = 'Span'
@@ -121,6 +123,10 @@ module NewRelic
           agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
         end
 
+        if segment.params[:backtrace]
+          agent_attributes[STACKTRACE_KEY] = segment.params[:backtrace]
+        end
+
         [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]
       end
 
@@ -135,7 +141,8 @@ module NewRelic
           PRIORITY_KEY => segment.transaction.priority,
           TIMESTAMP_KEY => milliseconds_since_epoch(segment),
           DURATION_KEY => segment.duration,
-          NAME_KEY => segment.name
+          NAME_KEY => segment.name,
+          THREAD_ID_KEY => segment.thread_id
         }
 
         # with infinite-tracing, transactions may or may not be sampled!