newrelic_rpm 9.12.0 → 9.17.0

data/lib/new_relic/agent/span_event_primitive.rb

@@ -52,6 +52,8 @@ module NewRelic
       DATASTORE_CATEGORY = 'datastore'
       CLIENT = 'client'
 
+      DB_STATEMENT_MAX_BYTES = 4096
+
       # Builds a Hash of error attributes as well as the Span ID when
       # an error is present.  Otherwise, returns nil when no error present.
       def error_attributes(segment)
@@ -114,9 +116,9 @@ module NewRelic
         agent_attributes[DB_SYSTEM_KEY] = segment.product if allowed?(DB_SYSTEM_KEY)
 
         if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, DB_STATEMENT_MAX_BYTES)
         elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
-          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, DB_STATEMENT_MAX_BYTES)
         end
 
         [intrinsics, custom_attributes(segment), agent_attributes.merge(agent_attributes(segment))]

data/lib/new_relic/agent/system_info.rb

@@ -19,6 +19,20 @@ module NewRelic
         RbConfig::CONFIG['target_os']
       end
 
+      def self.os_distribution
+        case
+        when darwin? then :darwin
+        when linux? then :linux
+        when bsd? then :bsd
+        when windows? then :windows
+        else ruby_os_identifier
+        end
+      end
+
+      def self.windows?
+        !!(ruby_os_identifier[/mingw|mswin/i])
+      end
+
       def self.darwin?
         !!(ruby_os_identifier =~ /darwin/i)
       end

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -125,7 +125,16 @@ module NewRelic
 
         # Returns [filename, method, line number]
         def parse_backtrace_frame(frame)
-          frame =~ /([^:]*)(\:(\d+))?\:in `(.*)'/
+          # TODO: OLD RUBIES - Ruby 3.3
+          # The (?:`|') non-capturing group can be removed when the agent
+          # drops support for Ruby 3.3
+          # This group is used to capture the pre-Ruby 3.4.0 backtrace syntax.
+          # Example frame:
+          # Ruby 3.3.0 and below
+          # "irb.rb:69:in `catch'"
+          # Ruby 3.4.0+
+          # "irb.rb:69:in 'Kernel#catch'"
+          frame =~ /([^:]*)(\:(\d+))?\:in (?:`|')(.*)'/
           [$1, $4, $3] # sic
         end
       end

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

@@ -15,6 +15,7 @@ module NewRelic
         PRODUCE = 'Produce'.freeze
         QUEUE = 'Queue'.freeze
         PURGE = 'Purge'.freeze
+        STREAM = 'Stream'.freeze
         TEMP = 'Temp'.freeze
         TOPIC = 'Topic'.freeze
         UNKNOWN = 'Unknown'.freeze
@@ -22,6 +23,7 @@ module NewRelic
         DESTINATION_TYPES = [
           :exchange,
           :queue,
+          :stream,
           :topic,
           :temporary_queue,
           :temporary_topic,
@@ -37,6 +39,7 @@ module NewRelic
         TYPES = {
           exchange: EXCHANGE,
           temporary_queue: QUEUE,
+          stream: STREAM,
           queue: QUEUE,
           temporary_topic: TOPIC,
           topic: TOPIC,

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

@@ -24,7 +24,7 @@ module NewRelic
           @referer = referer_from_request(request)
           @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
           @content_length = content_length_from_request(request)
-          @content_type = attribute_from_request(request, :content_type)
+          @content_type = content_type_attribute_from_request(request)
           @host = attribute_from_request(request, :host)
           @port = port_from_request(request)
           @user_agent = attribute_from_request(request, :user_agent)
@@ -127,6 +127,18 @@ module NewRelic
           end
         end
 
+        def content_type_attribute_from_request(request)
+          # Rails 7.0 changed the behavior of `content_type`. We want just the MIME type, so use `media_type` if available.
+          # https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#actiondispatch-request-content-type-now-returns-content-type-header-as-it-is
+          content_type = if request.respond_to?(:media_type)
+            :media_type
+          elsif request.respond_to?(:content_type)
+            :content_type
+          end
+
+          request.send(content_type) if content_type
+        end
+
         def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]

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

@@ -95,7 +95,7 @@ module NewRelic
 
         def create_trace_state_payload
           unless Agent.config[:'distributed_tracing.enabled']
-            NewRelic::Agent.logger.warn('Not configured to create WC3 trace context payload')
+            NewRelic::Agent.logger.warn('Not configured to create W3C trace context payload')
             return
           end
 

data/lib/new_relic/agent.rb

@@ -85,6 +85,10 @@ module NewRelic
     # An exception that forces an agent to stop reporting until its mongrel is restarted.
     class ForceDisconnectException < StandardError; end
 
+    # Error handling for the automated custom instrumentation tracer logic
+    class AutomaticTracerParseException < StandardError; end
+    class AutomaticTracerTraceException < StandardError; end
+
     # An exception that forces an agent to restart.
     class ForceRestartException < StandardError
       def message
@@ -109,6 +113,9 @@ module NewRelic
     # placeholder name used when we cannot determine a transaction's name
     UNKNOWN_METRIC = '(unknown)'.freeze
     LLM_FEEDBACK_MESSAGE = 'LlmFeedbackMessage'
+    # give the observed app time to load the code that automatic tracers have
+    # been configured for
+    AUTOMATIC_TRACER_MAX_ATTEMPTS = 60 # 60 = try about twice a second for 30 seconds
 
     attr_reader :error_group_callback
     attr_reader :llm_token_count_callback
@@ -125,8 +132,8 @@ module NewRelic
     def agent # :nodoc:
       return @agent if @agent
 
-      NewRelic::Agent.logger.warn("Agent unavailable as it hasn't been started.")
-      NewRelic::Agent.logger.warn(caller.join("\n"))
+      NewRelic::Agent.logger.debug("Agent unavailable as it hasn't been started.")
+      NewRelic::Agent.logger.debug(caller.join("\n"))
       nil
     end
 
@@ -163,6 +170,92 @@ module NewRelic
       end
     end
 
+    # @api private
+    def self.add_automatic_method_tracers(arr)
+      return unless arr
+      return arr if arr.respond_to?(:empty?) && arr.empty?
+
+      arr = arr.split(/\s*,\s*/) if arr.is_a?(String)
+
+      add_tracers_once_methods_are_defined(arr.dup)
+
+      arr
+    end
+
+    # spawn a thread that will attempt to establish a tracer for each of the
+    # configured methods. the thread will continue to keep trying with each
+    # tracer until one of the following happens:
+    #   - the tracer is successfully established
+    #   - the configured method string couldn't be parsed
+    #   - establishing a tracer for a successfully parsed string failed
+    #   - the maximum number of attempts has been reached
+    # the thread will only be spawned once per agent initialization, to account
+    # for configuration reloading scenarios.
+    #
+    # @api private
+    def self.add_tracers_once_methods_are_defined(notations)
+      # this class method can be invoked multiple times at agent startup, so
+      # we return asap here instead of using a traditional memoization of
+      # waiting for the method's body to finish being executed
+      if defined?(@add_tracers_once_methods_are_defined)
+        return
+      else
+        @add_tracers_once_methods_are_defined = true
+      end
+
+      Thread.new do
+        AUTOMATIC_TRACER_MAX_ATTEMPTS.times do
+          notations.delete_if { |notation| prep_tracer_for(notation) }
+
+          break if notations.empty?
+
+          sleep 0.5
+        end
+      end
+    end
+
+    # returns `true` if the notation string has either been successfully
+    # processed or raised an error during processing. returns `false` if the
+    # string seems good but the (customer) code to be traced has not yet been
+    # loaded into the Ruby VM
+    #
+    # @api private
+    def self.prep_tracer_for(fully_qualified_method_notation)
+      delimiters = fully_qualified_method_notation.scan(/\.|#/)
+      raise AutomaticTracerParseException.new("Expected exactly one '.' or '#' delimiter.") unless delimiters.size == 1
+
+      delimiter = delimiters.first
+      namespace, method_name = fully_qualified_method_notation.split(delimiter)
+      unless namespace && !namespace.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the left of the #{delimiter} delimiter.")
+      end
+      unless method_name && !method_name.empty?
+        raise AutomaticTracerParseException.new("Nothing found to the right of the #{delimiter} delimiter.")
+      end
+
+      begin
+        klass = ::NewRelic::LanguageSupport.constantize(namespace)
+        return false unless klass
+
+        klass_to_trace = delimiter.eql?('.') ? klass.singleton_class : klass
+        add_or_defer_method_tracer(klass_to_trace, method_name, nil, {})
+      rescue StandardError => e
+        raise AutomaticTracerTraceException.new("#{e.class} - #{e.message}")
+      end
+
+      true
+    rescue AutomaticTracerParseException => e
+      NewRelic::Agent.logger.error('Unable to parse out a usable method name to trace. Expected a valid, fully ' \
+                                   "qualified method notation. Got: '#{fully_qualified_method_notation}'. " \
+                                   "Error: #{e.message}")
+      true
+    rescue AutomaticTracerTraceException => e
+      NewRelic::Agent.logger.error('Unable to automatically apply a tracer to method ' \
+                                   "'#{fully_qualified_method_notation}'. Error: #{e.message}")
+      true
+    end
+
+    # @api private
     def add_deferred_method_tracers_now
       @tracer_lock.synchronize do
         @tracer_queue.each do |receiver, method_name, metric_name, options|

data/lib/new_relic/control/frameworks/grape.rb

@@ -0,0 +1,14 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/control/frameworks/ruby'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Grape
+      class Grape < NewRelic::Control::Frameworks::Ruby
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/padrino.rb

@@ -0,0 +1,14 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/control/frameworks/sinatra'
+module NewRelic
+  class Control
+    module Frameworks
+      # Contains basic control logic for Padrino
+      class Padrino < NewRelic::Control::Frameworks::Sinatra
+      end
+    end
+  end
+end

data/lib/new_relic/control/frameworks/rails4.rb

@@ -9,9 +9,7 @@ module NewRelic
     module Frameworks
       class Rails4 < NewRelic::Control::Frameworks::Rails3
         def rails_gem_list
-          Bundler.rubygems.all_specs.map do |gem|
-            "#{gem.name} (#{gem.version})"
-          end
+          NewRelic::Helper.rubygems_specs.map { |gem| "#{gem.name} (#{gem.version})" }
         end
 
         def append_plugin_list

data/lib/new_relic/dependency_detection.rb

@@ -25,11 +25,9 @@ module DependencyDetection
 
   def detect!
     @items.each do |item|
-      if item.dependencies_satisfied?
-        item.execute
-      else
-        item.configure_as_unsatisfied unless item.disabled_configured?
-      end
+      next if item.executed || item.disabled_configured?
+
+      item.dependencies_satisfied? ? item.execute : item.configure_as_unsatisfied
     end
   end
 
@@ -65,6 +63,13 @@ module DependencyDetection
     end
 
     def configure_as_unsatisfied
+      # TODO: currently using :unsatisfied for Padrino will clobber the value
+      #       already set for Sinatra, so skip Padrino and circle back with a
+      #       new Padrino specific solution in the future.
+      #
+      #       https://github.com/newrelic/newrelic-ruby-agent/issues/2912
+      return if name == :padrino
+
       NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
     end
 
@@ -139,8 +144,6 @@ module DependencyDetection
       !(disabled_configured? || deprecated_disabled_configured?)
     end
 
-    # TODO: MAJOR VERSION
-    # will only return true if a disabled key is found and is truthy
     def deprecated_disabled_configured?
       return false if self.name.nil?
 
@@ -148,12 +151,7 @@ module DependencyDetection
       return false unless ::NewRelic::Agent.config[key] == true
 
       ::NewRelic::Agent.logger.debug("Not installing #{self.name} instrumentation because of configuration #{key}")
-      ::NewRelic::Agent.logger.debug( \
-        "[DEPRECATED] configuration #{key} for #{self.name} will be removed in the next major release. " \
-        "Use `#{config_key}` with one of `#{VALID_CONFIG_VALUES.map(&:to_s).inspect}`"
-      )
-
-      return true
+      true
     end
 
     def config_key

data/lib/new_relic/environment_report.rb

@@ -44,7 +44,7 @@ module NewRelic
     ####################################
     report_on('Gems') do
       begin
-        Bundler.rubygems.all_specs.map { |gem| "#{gem.name}(#{gem.version})" }
+        NewRelic::Helper.rubygems_specs.map { |gem| "#{gem.name}(#{gem.version})" }
       rescue
         # There are certain rubygem, bundler, rails combinations (e.g. gem
         # 1.6.2, rails 2.3, bundler 1.2.3) where the code above throws an error
@@ -67,7 +67,7 @@ module NewRelic
     report_on('Physical Cores') { ::NewRelic::Agent::SystemInfo.num_physical_cores }
     report_on('Arch') { ::NewRelic::Agent::SystemInfo.processor_arch }
     report_on('OS version') { ::NewRelic::Agent::SystemInfo.os_version }
-    report_on('OS') { ::NewRelic::Agent::SystemInfo.ruby_os_identifier }
+    report_on('OS') { ::NewRelic::Agent::SystemInfo.os_distribution }
     report_on('Database adapter') { ::NewRelic::Agent::DatabaseAdapter.value }
     report_on('Framework') { Agent.config[:framework].to_s }
     report_on('Dispatcher') { Agent.config[:dispatcher].to_s }

data/lib/new_relic/helper.rb

@@ -82,5 +82,20 @@ module NewRelic
         File.exist?(executable_path) && File.file?(executable_path) && File.executable?(executable_path)
       end
     end
+
+    # Bundler version 2.5.12 deprecated all_specs and added installed_specs.
+    # To support newer Bundler versions, try to use installed_specs first,
+    # then fall back to all_specs.
+    # All callers expect this to be an array, so return an array if Bundler isn't defined
+    # @api private
+    def rubygems_specs
+      return [] unless defined?(Bundler)
+
+      if Bundler.rubygems.respond_to?(:installed_specs)
+        Bundler.rubygems.installed_specs
+      else
+        Bundler.rubygems.all_specs
+      end
+    end
   end
 end

data/lib/new_relic/language_support.rb

@@ -88,7 +88,9 @@ module NewRelic
     end
 
     def bundled_gem?(gem_name)
-      defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?(gem_name)
+      return false unless defined?(Bundler)
+
+      NewRelic::Helper.rubygems_specs.map(&:name).include?(gem_name)
     rescue => e
       ::NewRelic::Agent.logger.info("Could not determine if third party #{gem_name} gem is installed", e)
       false

data/lib/new_relic/local_environment.rb

@@ -142,10 +142,7 @@ module NewRelic
     end
 
     def check_for_falcon
-      return unless defined?(::Falcon::Server) &&
-        NewRelic::LanguageSupport.object_space_usable?
-
-      @discovered_dispatcher = :falcon if find_class_in_object_space(::Falcon::Server)
+      @discovered_dispatcher = :falcon if defined?(::Falcon::Server) && File.basename($PROGRAM_NAME) == 'falcon'
     end
 
     def check_for_delayed_job

data/lib/new_relic/version.rb

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

data/lib/sequel/extensions/new_relic_instrumentation.rb

@@ -79,7 +79,7 @@ module Sequel
 
     THREAD_SAFE_CONNECTION_POOL_CLASSES = [
       (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool),
-      (defined?(::Sequel::TimedQueueConnectionPool) && RUBY_VERSION >= '3.4' && ::Sequel::TimedQueueConnectionPool)
+      (defined?(::Sequel::TimedQueueConnectionPool) && RUBY_VERSION >= '3.2' && ::Sequel::TimedQueueConnectionPool)
     ].compact.freeze
 
     def explainer_for(sql)

data/lib/tasks/helpers/newrelicyml.rb

@@ -45,6 +45,34 @@ module NewRelicYML
 
   HEADER
 
+  SECURITY_BEGIN = <<-SECURITY
+  # BEGIN security agent
+  #
+  #   NOTE: At this time, the security agent is intended for use only within
+  #         a dedicated security testing environment with data that can tolerate
+  #         modification or deletion. The security agent is available as a
+  #         separate Ruby gem, newrelic_security. It is recommended that this
+  #         separate gem only be introduced to a security testing environment
+  #         by leveraging Bundler grouping like so:
+  #
+  #         # Gemfile
+  #         gem 'newrelic_rpm'               # New Relic APM observability agent
+  #         gem 'newrelic-infinite_tracing'  # New Relic Infinite Tracing
+  #
+  #         group :security do
+  #           gem 'newrelic_security', require: false # New Relic security agent
+  #         end
+  #
+  #   NOTE: All "security.*" configuration parameters are related only to the
+  #         security agent, and all other configuration parameters that may
+  #         have "security" in the name somewhere are related to the APM agent.
+  
+  SECURITY
+
+  SECURITY_END = <<-SECURITY
+  # END security agent
+  SECURITY
+
   FOOTER = <<~FOOTER
     # Environment-specific settings are in this section.
     # RAILS_ENV or RACK_ENV (as appropriate) is used to determine the environment.
@@ -67,16 +95,35 @@ module NewRelicYML
   FOOTER
 
   def self.get_configs(defaults)
-    defaults.sort.each_with_object({}) do |(key, value), final_configs|
+    agent_configs = {}
+    security_configs = {}
+
+    defaults.sort.each do |key, value|
       next if CRITICAL.include?(key) || SKIP.include?(key)
 
       next unless public_config?(value) && !deprecated?(value)
 
-      sanitized_description = sanitize_description(value[:description])
-      description = format_description(sanitized_description)
-      default = default_value(key, value)
-      final_configs[key] = {description: description, default: default}
+      # TODO: OLD RUBIES < 2.6
+      # Remove `to_s`. `start_with?` doesn't accept symbols in Ruby <2.6
+      if key.to_s.start_with?('security.')
+        description, default = build_config(key, value)
+        security_configs[key] = {description: description, default: default}
+        next
+      end
+
+      description, default = build_config(key, value)
+      agent_configs[key] = {description: description, default: default}
     end
+
+    [agent_configs, security_configs]
+  end
+
+  def self.build_config(key, value)
+    sanitized_description = sanitize_description(value[:description])
+    description = format_description(sanitized_description)
+    default = default_value(key, value)
+
+    [description, default]
   end
 
   def self.public_config?(value)
@@ -126,15 +173,30 @@ module NewRelicYML
     end
   end
 
-  def self.build_string(defaults)
-    configs = get_configs(defaults)
-    yml_string = ''
+  def self.agent_configs_yml(agent_configs)
+    agent_yml = ''
+    agent_configs.each do |key, value|
+      agent_yml += "#{value[:description]}\n  # #{key}: #{value[:default]}\n\n"
+    end
+
+    agent_yml
+  end
 
-    configs.each do |key, value|
-      yml_string += "#{value[:description]}\n  # #{key}: #{value[:default]}\n\n"
+  def self.security_configs_yml(security_configs)
+    security_yml = ''
+    security_configs.each do |key, value|
+      security_yml += "#{value[:description]}\n  # #{key}: #{value[:default]}\n\n"
     end
 
-    yml_string
+    security_yml
+  end
+
+  def self.build_string(defaults)
+    agent_configs, security_configs = get_configs(defaults)
+    agent_string = agent_configs_yml(agent_configs)
+    security_string = security_configs_yml(security_configs)
+
+    agent_string + SECURITY_BEGIN + security_string + SECURITY_END + "\n"
   end
 
   # :nocov:

data/lib/tasks/instrumentation_generator/instrumentation.thor

@@ -103,7 +103,7 @@ class Instrumentation < Thor
     <<-CONFIG
         :'instrumentation.#{snake_name}' => {
           :default => 'auto',
-          :documentation_default => 'auto'
+          :documentation_default => 'auto',
           :public => true,
           :type => String,
           :dynamic_name => true,

data/lib/tasks/instrumentation_generator/templates/dependency_detection.tt

@@ -2,27 +2,30 @@
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
 
-require_relative '<%= @snake_name.downcase %>/instrumentation'
-require_relative '<%= @snake_name.downcase %>/chain'
-require_relative '<%= @snake_name.downcase %>/prepend'
-
 DependencyDetection.defer do
-  named :<%= @name.match?(/\-|\_/) ? "'#{@snake_name}'" : @name.downcase %>
+  named :<%= @snake_name %>
 
   depends_on do
     # The class that needs to be defined to prepend/chain onto. This can be used
     # to determine whether the library is installed.
-    defined?(::<%= @class_name %>)
+    defined?(<%= @class_name %>)
     # Add any additional requirements to verify whether this instrumentation
     # should be installed
   end
 
   executes do
-    ::NewRelic::Agent.logger.info('Installing <%= @name.downcase %> instrumentation')
+    require_relative '<%= @snake_name.downcase %>/instrumentation'
 
+    # prepend_instrument and chain_instrument call extract_supportability_name
+    # to get the library name for supportability metrics and info-level logging.
+    # This is done by spliting on the 2nd to last spot of the instrumented
+    # module. If this isn't how we want the name to appear, pass in the desired
+    # name as a third argument.
     if use_prepend?
-      prepend_instrument ::<%= @class_name %>, NewRelic::Agent::Instrumentation::<%= @class_name %>::Prepend
+      require_relative '<%= @snake_name.downcase %>/prepend'
+      prepend_instrument <%= @class_name %>, NewRelic::Agent::Instrumentation::<%= @class_name %>::Prepend
     else
+      require_relative '<%= @snake_name.downcase %>/chain'
       chain_instrument NewRelic::Agent::Instrumentation::<%= @class_name %>::Chain
     end
   end