newrelic_rpm 9.2.2 → 9.3.0

data/lib/new_relic/agent/instrumentation/thread/chain.rb

@@ -14,7 +14,7 @@ module NewRelic::Agent::Instrumentation
           alias_method(:initialize_without_new_relic, :initialize)
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { initialize_without_new_relic(*args, &traced_block) }
           end
         end

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

@@ -17,7 +17,6 @@ module NewRelic
           return block if !NewRelic::Agent::Tracer.thread_tracing_enabled?
 
           NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-            *args,
             segment_name: 'Ruby/Thread',
             &block
           )

data/lib/new_relic/agent/instrumentation/thread/prepend.rb

@@ -12,7 +12,7 @@ module NewRelic
           include NewRelic::Agent::Instrumentation::MonitoredThread
 
           def initialize(*args, &block)
-            traced_block = add_thread_tracing(*args, &block)
+            traced_block = add_thread_tracing(&block)
             initialize_with_newrelic_tracing { super(*args, &traced_block) }
           end
         end

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/log_priority'
+require 'new_relic/agent/log_event_attributes'
 
 module NewRelic
   module Agent
@@ -36,6 +37,10 @@ module NewRelic
       METRICS_ENABLED_KEY = :'application_logging.metrics.enabled'
       FORWARDING_ENABLED_KEY = :'application_logging.forwarding.enabled'
       DECORATING_ENABLED_KEY = :'application_logging.local_decorating.enabled'
+      LOG_LEVEL_KEY = :'application_logging.forwarding.log_level'
+      CUSTOM_ATTRIBUTES_KEY = :'application_logging.forwarding.custom_attributes'
+
+      attr_reader :attributes
 
       def initialize(events)
         super(events)
@@ -44,6 +49,7 @@ module NewRelic
         @seen_by_severity = Hash.new(0)
         @high_security = NewRelic::Agent.config[:high_security]
         @instrumentation_logger_enabled = NewRelic::Agent::Instrumentation::Logger.enabled?
+        @attributes = NewRelic::Agent::LogEventAttributes.new
         register_for_done_configuring(events)
       end
 
@@ -63,8 +69,9 @@ module NewRelic
           end
         end
 
+        return if severity_too_low?(severity)
         return if formatted_message.nil? || formatted_message.empty?
-        return unless NewRelic::Agent.config[:'application_logging.forwarding.enabled']
+        return unless NewRelic::Agent.config[FORWARDING_ENABLED_KEY]
         return if @high_security
 
         txn = NewRelic::Agent::Transaction.tl_current
@@ -114,6 +121,10 @@ module NewRelic
         ]
       end
 
+      def add_custom_attributes(custom_attributes)
+        attributes.add_custom_attributes(custom_attributes)
+      end
+
       # Because our transmission format (MELT) is different than historical
       # agent payloads, extract the munging here to keep the service focused
       # on the general harvest + transmit instead of the format.
@@ -130,6 +141,8 @@ module NewRelic
         # sent by classic logs-in-context
         common_attributes.delete(ENTITY_TYPE_KEY)
 
+        common_attributes.merge!(NewRelic::Agent.agent.log_event_aggregator.attributes.custom_attributes)
+
         _, items = data
         payload = [{
           common: {attributes: common_attributes},
@@ -149,6 +162,7 @@ module NewRelic
           @seen = 0
           @seen_by_severity.clear
         end
+
         super
       end
 
@@ -168,6 +182,8 @@ module NewRelic
           record_configuration_metric(METRICS_SUPPORTABILITY_FORMAT, METRICS_ENABLED_KEY)
           record_configuration_metric(FORWARDING_SUPPORTABILITY_FORMAT, FORWARDING_ENABLED_KEY)
           record_configuration_metric(DECORATING_SUPPORTABILITY_FORMAT, DECORATING_ENABLED_KEY)
+
+          add_custom_attributes(NewRelic::Agent.config[CUSTOM_ATTRIBUTES_KEY])
         end
       end
 
@@ -191,7 +207,7 @@ module NewRelic
       # these until harvest before recording them
       def record_customer_metrics
         return unless enabled?
-        return unless NewRelic::Agent.config[:'application_logging.metrics.enabled']
+        return unless NewRelic::Agent.config[METRICS_ENABLED_KEY]
 
         @counter_lock.synchronize do
           return unless @seen > 0
@@ -230,6 +246,37 @@ module NewRelic
 
         message.byteslice(0...MAX_BYTES)
       end
+
+      def minimum_log_level
+        if Logger::Severity.constants.include?(configured_log_level_constant)
+          configured_log_level_constant
+        else
+          NewRelic::Agent.logger.log_once(
+            :error,
+            'Invalid application_logging.forwarding.log_level ' \
+            "'#{NewRelic::Agent.config[LOG_LEVEL_KEY]}' specified! " \
+            "Must be one of #{Logger::Severity.constants.join('|')}. " \
+            "Using default level of 'debug'"
+          )
+          :DEBUG
+        end
+      end
+
+      def configured_log_level_constant
+        format_log_level_constant(NewRelic::Agent.config[LOG_LEVEL_KEY])
+      end
+
+      def format_log_level_constant(log_level)
+        log_level.upcase.to_sym
+      end
+
+      def severity_too_low?(severity)
+        severity_constant = format_log_level_constant(severity)
+        # always record custom log levels
+        return false unless Logger::Severity.constants.include?(severity_constant)
+
+        Logger::Severity.const_get(severity_constant) < Logger::Severity.const_get(minimum_log_level)
+      end
     end
   end
 end

data/lib/new_relic/agent/log_event_attributes.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
+
+module NewRelic
+  module Agent
+    class LogEventAttributes
+      MAX_ATTRIBUTE_COUNT = 240 # limit is 255, assume we send 15
+      ATTRIBUTE_KEY_CHARACTER_LIMIT = 255
+      ATTRIBUTE_VALUE_CHARACTER_LIMIT = 4094
+
+      def add_custom_attributes(attributes)
+        return if @custom_attribute_limit_reached
+
+        attributes.each do |key, value|
+          next if absent?(key) || absent?(value)
+
+          add_custom_attribute(key, value)
+        end
+      end
+
+      def custom_attributes
+        @custom_attributes ||= {}
+      end
+
+      private
+
+      class TruncationError < StandardError
+        attr_reader :attribute, :limit
+
+        def initialize(attribute, limit, msg = "Can't truncate")
+          @attribute = attribute
+          @limit = limit
+          super(msg)
+        end
+      end
+
+      class InvalidTypeError < StandardError
+        attr_reader :attribute
+
+        def initialize(attribute, msg = 'Invalid attribute type')
+          @attribute = attribute
+          super(msg)
+        end
+      end
+
+      def absent?(value)
+        value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      def add_custom_attribute(key, value)
+        if custom_attributes.size >= MAX_ATTRIBUTE_COUNT
+          NewRelic::Agent.logger.warn(
+            'Too many custom log attributes defined. ' \
+            "Only taking the first #{MAX_ATTRIBUTE_COUNT}."
+          )
+          @custom_attribute_limit_reached = true
+          return
+        end
+
+        @custom_attributes.merge!(truncate_attributes(key_to_string(key), value))
+      end
+
+      def key_to_string(key)
+        key.is_a?(String) ? key : key.to_s
+      end
+
+      def truncate_attribute(attribute, limit)
+        case attribute
+        when Integer
+          if attribute.digits.length > limit
+            raise TruncationError.new(attribute, limit)
+          end
+        when Float
+          if attribute.to_s.length > limit
+            raise TruncationError.new(attribute, limit)
+          end
+        when String, Symbol
+          if attribute.length > limit
+            attribute = attribute.slice(0..(limit - 1))
+          end
+        when TrueClass, FalseClass
+          attribute
+        else
+          raise InvalidTypeError.new(attribute)
+        end
+
+        attribute
+      end
+
+      def truncate_attributes(key, value)
+        key = truncate_attribute(key, ATTRIBUTE_KEY_CHARACTER_LIMIT)
+        value = truncate_attribute(value, ATTRIBUTE_VALUE_CHARACTER_LIMIT)
+
+        {key => value}
+      rescue TruncationError => e
+        NewRelic::Agent.logger.warn(
+          "Dropping custom log attribute #{key} => #{value} \n" \
+          "Length exceeds character limit of #{e.limit}. " \
+          "Can't truncate: #{e.attribute}"
+        )
+
+        {}
+      rescue InvalidTypeError => e
+        NewRelic::Agent.logger.warn(
+          "Dropping custom log attribute #{key} => #{value} \n" \
+          "Invalid type of #{e.attribute.class} given. " \
+          "Can't send #{e.attribute}."
+        )
+
+        {}
+      end
+    end
+  end
+end

data/lib/new_relic/agent/logging.rb

@@ -62,6 +62,10 @@ module NewRelic
           message << CLOSING_BRACE << NEWLINE
         end
 
+        def clear_tags!
+          # No-op; just avoiding issues with act-fluent-logger-rails
+        end
+
         private
 
         def add_app_name(message)
@@ -138,10 +142,6 @@ module NewRelic
           end
           message.to_json
         end
-
-        def clear_tags!
-          # No-op; just avoiding issues with act-fluent-logger-rails
-        end
       end
 
       # This logger decorates logs with trace and entity metadata, and emits log

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -46,13 +46,15 @@ module NewRelic
         cache_key = "#{object.object_id}#{method_name}".freeze
         return @code_information[cache_key] if @code_information.key?(cache_key)
 
-        namespace, location, is_class_method = namespace_and_location(object, method_name.to_sym)
+        info = namespace_and_location(object, method_name.to_sym)
+        return ::NewRelic::EMPTY_HASH if info.empty?
 
+        namespace, location, is_class_method = info
         @code_information[cache_key] = {filepath: location.first,
                                         lineno: location.last,
                                         function: "#{'self.' if is_class_method}#{method_name}",
                                         namespace: namespace}.freeze
-      rescue => e
+      rescue StandardError => e
         ::NewRelic::Agent.logger.warn("Unable to determine source code info for '#{object}', " \
                                         "method '#{method_name}' - #{e.class}: #{e.message}")
         ::NewRelic::Agent.increment_metric(SOURCE_CODE_INFORMATION_FAILURE_METRIC, 1)
@@ -66,10 +68,10 @@ module NewRelic
       end
 
       # The string representation of a singleton class looks like
-      # '#<Class:MyModule::MyClass>'. Return the 'MyModule::MyClass' part of
-      # that string
+      # '#<Class:MyModule::MyClass>', or '#<Class:MyModule::MyClass(id: integer, attribute: string)>'
+      # Return the 'MyModule::MyClass' part of that string
       def klass_name(object)
-        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:(.*)>$/
+        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:([\w:]+).*>$/
         return name if name
 
         raise "Unable to glean a class name from string '#{object}'"
@@ -101,6 +103,9 @@ module NewRelic
         klass = object.singleton_class? ? klassify_singleton(object) : object
         name = klass.name || '(Anonymous)'
         is_class_method = false
+
+        return controller_info(klass, name, is_class_method) if controller_without_method?(klass, method_name)
+
         method = if (klass.instance_methods + klass.private_instance_methods).include?(method_name)
           klass.instance_method(method_name)
         else
@@ -109,6 +114,22 @@ module NewRelic
         end
         [name, method.source_location, is_class_method]
       end
+
+      # Rails controllers can be a special case because by default, controllers in Rails
+      # automatically render views with names that correspond to valid routes. This means
+      # that a controller method may not have a corresponding method in the controller class.
+      def controller_without_method?(klass, method_name)
+        defined?(Rails) &&
+          defined?(ApplicationController) &&
+          klass < ApplicationController &&
+          !klass.method_defined?(method_name)
+      end
+
+      def controller_info(klass, name, is_class_method)
+        path = Rails.root.join("app/controllers/#{klass.name.underscore}.rb")
+
+        File.exist?(path) ? [name, [path.to_s, 1], is_class_method] : []
+      end
     end
   end
 end

data/lib/new_relic/agent/tracer.rb

@@ -419,10 +419,10 @@ module NewRelic
           NewRelic::Agent.config[:'instrumentation.thread.tracing']
         end
 
-        def thread_block_with_current_transaction(*args, segment_name:, parent: nil, &block)
+        def thread_block_with_current_transaction(segment_name:, parent: nil, &block)
           parent ||= current_segment
           current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
-          proc do
+          proc do |*args|
             begin
               if current_txn && !current_txn.finished?
                 NewRelic::Agent::Tracer.state.current_transaction = current_txn

data/lib/new_relic/agent.rb

@@ -649,6 +649,43 @@ module NewRelic
       end
     end
 
+    # Add custom attributes to log events for the current agent instance.
+    #
+    # @param [Hash] params    A Hash of attributes to attach to log
+    #                         events. The agent accepts up to 240 custom
+    #                         log event attributes.
+    #
+    #                         Keys will be coerced into Strings and must
+    #                         be less than 256 characters. Keys longer
+    #                         than 255 characters will be truncated.
+    #
+    #                         Values may be Strings, Symbols, numeric
+    #                         values or Booleans and must be less than
+    #                         4095 characters. If the value is a String
+    #                         or a Symbol, values longer than 4094
+    #                         characters will be truncated. If the value
+    #                         exceeds 4094 characters and is of a
+    #                         different class, the attribute pair will
+    #                         be dropped.
+    #
+    #                         This API can be called multiple times.
+    #                         If the same key is passed more than once,
+    #                         the value associated with the last call
+    #                         will be preserved.
+    #
+    #                         Attribute pairs with empty or nil contents
+    #                         will be dropped.
+    # @api public
+    def add_custom_log_attributes(params)
+      record_api_supportability_metric(:add_custom_log_attributes)
+
+      if params.is_a?(Hash)
+        NewRelic::Agent.agent.log_event_aggregator.add_custom_attributes(params)
+      else
+        NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_log_attributes. Expected Hash but got #{params.class}.")
+      end
+    end
+
     # Set the user id for the current transaction. When present, this value will be included in the agent attributes for transaction and error events as 'enduser.id'.
     #
     # @param [String] user_id    The user id to add to the current transaction attributes

data/lib/new_relic/dependency_detection.rb

@@ -27,6 +27,8 @@ module DependencyDetection
     @items.each do |item|
       if item.dependencies_satisfied?
         item.execute
+      else
+        item.configure_as_unsatisfied unless item.disabled_configured?
       end
     end
   end
@@ -62,6 +64,10 @@ module DependencyDetection
       !executed and check_dependencies
     end
 
+    def configure_as_unsatisfied
+      NewRelic::Agent.config.instance_variable_get(:@cache)[config_key] = :unsatisfied
+    end
+
     def source_location_for(klass, method_name)
       Object.instance_method(:method).bind(klass.allocate).call(method_name).source_location.to_s
     end

data/lib/new_relic/latest_changes.rb

@@ -8,7 +8,7 @@ module NewRelic
       File.join(File.dirname(__FILE__), '..', '..', 'CHANGELOG.md')
     end
 
-    FOOTER = <<'EOS'
+    FOOTER = <<EOS
     See https://github.com/newrelic/newrelic-ruby-agent/blob/main/CHANGELOG.md for a full list of
     changes.
 EOS

data/lib/new_relic/supportability_helper.rb

@@ -13,6 +13,7 @@ module NewRelic
       :insert_distributed_trace_headers,
       :accept_distributed_trace_headers,
       :add_custom_attributes,
+      :add_custom_log_attributes,
       :add_custom_span_attributes,
       :add_instrumentation,
       :add_method_tracer,

data/lib/new_relic/traced_thread.rb

@@ -22,15 +22,14 @@ module NewRelic
     # @api public
     def initialize(*args, &block)
       NewRelic::Agent.record_api_supportability_metric(:traced_thread)
-      traced_block = create_traced_block(*args, &block)
+      traced_block = create_traced_block(&block)
       super(*args, &traced_block)
     end
 
-    def create_traced_block(*args, &block)
+    def create_traced_block(&block)
       return block if NewRelic::Agent.config[:'instrumentation.thread.tracing'] # if this is on, don't double trace
 
       NewRelic::Agent::Tracer.thread_block_with_current_transaction(
-        *args,
         segment_name: 'Ruby/TracedThread',
         &block
       )

data/lib/new_relic/version.rb

@@ -6,8 +6,8 @@
 module NewRelic
   module VERSION # :nodoc:
     MAJOR = 9
-    MINOR = 2
-    TINY = 2
+    MINOR = 3
+    TINY = 0
 
     STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end

data/lib/sequel/extensions/new_relic_instrumentation.rb

@@ -27,7 +27,7 @@ module Sequel
   # If you don't want your models or database connections to be instrumented,
   # you can disable them by setting `disable_database_instrumentation` in
   # your `newrelic.yml` to `true`. It will also honor the
-  # `disable_activerecord_instrumentation` setting.
+  # `disable_active_record_instrumentation` setting.
   #
   module NewRelicInstrumentation
     module Naming

data/lib/tasks/bump_version.rake

@@ -0,0 +1,21 @@
+# 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 './helpers/version_bump'
+
+namespace :newrelic do
+  namespace :version do
+    desc 'Returns the current version'
+    task :current do
+      puts "#{NewRelic::VERSION::STRING}"
+    end
+
+    desc 'Update version file and changelog to next version'
+    task :bump, [:format] => [] do |t, args|
+      new_version = VersionBump.update_version
+      VersionBump.update_changelog(new_version)
+      puts "New version: #{new_version}"
+    end
+  end
+end

data/lib/tasks/helpers/newrelicyml.rb

@@ -0,0 +1,144 @@
+# 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 '../../new_relic/agent/configuration/default_source'
+
+module NewRelicYML
+  CRITICAL = [:'agent_enabled', :'app_name', :'license_key', :'log_level']
+  DEFAULTS = NewRelic::Agent::Configuration::DEFAULTS
+  # Skip because not configurable via yml
+  SKIP = [:'defer_rails_initialization']
+  # Don't evaluate Procs, instead use set values
+  PROCS = {:'config_path' => 'newrelic.yml',
+           :'process_host.display_name' => 'default hostname',
+           :'transaction_tracer.transaction_threshold' => 1.0}
+
+  HEADER = <<~HEADER
+    #
+    # This file configures the New Relic Agent.  New Relic monitors Ruby, Java,
+    # .NET, PHP, Python, Node, and Go applications with deep visibility and low
+    # overhead.  For more information, visit www.newrelic.com.
+
+    # Generated <%= Time.now.strftime('%B %d, %Y') %><%= ", for version \#{@agent_version}" if @agent_version %>
+    #<%= "\\n# \#{generated_for_user}\\n#" if generated_for_user %>
+    # For full documentation of agent configuration options, please refer to
+    # https://docs.newrelic.com/docs/agents/ruby-agent/installation-configuration/ruby-agent-configuration
+
+    common: &default_settings
+      # Required license key associated with your New Relic account.
+      license_key: <%= license_key %>
+
+      # Your application name. Renaming here affects where data displays in New
+      # Relic. For more details, see https://docs.newrelic.com/docs/apm/new-relic-apm/maintenance/renaming-applications
+      app_name: <%= app_name %>
+
+      # To disable the agent regardless of other settings, uncomment the following:
+      # agent_enabled: false
+
+      # Logging level for log/newrelic_agent.log; options are error, warn, info, or
+      # debug.
+      log_level: info
+
+      # All of the following configuration options are optional. Review them, and
+      # uncomment or edit them if they appear relevant to your application needs.
+
+  HEADER
+
+  FOOTER = <<~FOOTER
+    # Environment-specific settings are in this section.
+    # RAILS_ENV or RACK_ENV (as appropriate) is used to determine the environment.
+    # If your application has other named environments, configure them here.
+    development:
+      <<: *default_settings
+      app_name: <%= app_name %> (Development)
+
+    test:
+      <<: *default_settings
+      # It doesn't make sense to report to New Relic from automated test runs.
+      monitor_mode: false
+
+    staging:
+      <<: *default_settings
+      app_name: <%= app_name %> (Staging)
+
+    production:
+      <<: *default_settings
+  FOOTER
+
+  def self.get_configs(defaults)
+    defaults.sort.each_with_object({}) do |(key, value), final_configs|
+      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}
+    end
+  end
+
+  def self.public_config?(value)
+    value[:public] == true
+  end
+
+  def self.deprecated?(value)
+    value[:deprecated] == true
+  end
+
+  def self.sanitize_description(description)
+    # remove callouts
+    description = description.split("\n").reject { |line| line.match?('</?Callout') }.join("\n")
+    # remove InlinePopover, keep the text inside type
+    description.gsub!(/<InlinePopover type="(.*)" \/>/, '\1')
+    # remove hyperlinks
+    description.gsub!(/\[([^\]]+)\]\([^\)]+\)/, '\1')
+    # remove single pairs of backticks
+    description.gsub!(/`([^`]+)`/, '\1')
+    # removed href links
+    description.gsub!(/<a href="(.*)">(.*)<\/a>/, '\2')
+
+    description
+  end
+
+  def self.format_description(description)
+    # remove leading and trailing whitespace
+    description.strip!
+    # wrap text after 80 characters
+    description.gsub!(/(.{1,80})(\s+|\Z)/, "\\1\n")
+    # add hashtags to lines
+    description = description.split("\n").map { |line| "  # #{line}" }.join("\n")
+
+    description
+  end
+
+  def self.default_value(key, config_hash)
+    if PROCS.include?(key)
+      PROCS[key]
+    else
+      default = config_hash[:documentation_default].nil? ? config_hash[:default] : config_hash[:documentation_default]
+      default = 'nil' if default.nil?
+      default = '""' if default == ''
+
+      default
+    end
+  end
+
+  def self.build_string(defaults)
+    configs = get_configs(defaults)
+    yml_string = ''
+
+    configs.each do |key, value|
+      yml_string += "#{value[:description]}\n  # #{key}: #{value[:default]}\n\n"
+    end
+
+    yml_string
+  end
+
+  # :nocov:
+  def self.write_file(defaults = DEFAULTS)
+    File.write('newrelic.yml', HEADER + build_string(defaults) + FOOTER)
+  end
+  # :nocov:
+end