newrelic_rpm 8.7.0 → 8.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5346c26b9d9c2f9200860b562f1dadb5e79e3eb5d8904850d015c3096cc27d5a
-  data.tar.gz: acf374f8f16b88746f6a8451255bb0c6c571fbb0a3875c967648b5a8c5286217
+  metadata.gz: 0eb3871a3ff66d8707dd01f40025d812d34904c02631d3a83af046bdbaeacdeb
+  data.tar.gz: 4e73dfe935bcd268ad0969a2c076e83313e75c3f3f0b711a7cba8c3af1327677
 SHA512:
-  metadata.gz: fb227c6b6d69c8900b5693567b03cc2b4f3d95e4059953e7c45287e51892cbb9ae70e6fb9b9ad6015e5eab1b162281fcc384db07ae4367174617726fca086ad0
-  data.tar.gz: e0bca3ab2559e65d9e2f900ddf69a1882190bc7034948760f87829772cfac441f8b14a4028c441316de2126c85b9dc18bf5acafc7587f10deae7beeb7ba0f386
+  metadata.gz: 07566af3aff20a1fe5951fb36e34086f665e8788ecb7edfd2664213e73877e7a1c58d4447f2dd85efb75beeda0ce2f484c513d4a7a09c01bcbe4c20e8a5cba1a
+  data.tar.gz: 577944d3712cdd9908d4a564346e7f4bd6fd5772fa00069d73acdb3d8a033621042c72346ddd4ca22585910f035116701f0f904dd8f40c8f0b1e9934bd787705

data/.rubocop.yml

@@ -819,9 +819,6 @@ Lint/UselessAccessModifier:
 Lint/UselessAssignment:
   Enabled: false
 
-Lint/UselessElseWithoutRescue:
-  Enabled: true
-
 Lint/UselessMethodDefinition:
   Enabled: false
 
@@ -967,6 +964,9 @@ Performance/CollectionLiteralInLoop:
 Performance/CompareWithBlock:
   Enabled: true
 
+Performance/ConcurrentMonotonicTime:
+  Enabled: true
+
 # Disabling for now
 Performance/ConstantRegexp:
   Enabled: false
@@ -1072,6 +1072,9 @@ Performance/Squeeze:
 Performance/StartWith:
   Enabled: false
 
+Performance/StringIdentifierArgument:
+  Enabled: true
+
 Performance/StringInclude:
   Enabled: false
 

data/.yardopts

@@ -1,6 +1,7 @@
 --non-transitive-tag api
 --api public
 lib/new_relic/agent.rb
+lib/new_relic/traced_thread.rb
 lib/new_relic/agent/method_tracer.rb
 lib/new_relic/agent/distributed_tracing.rb
 lib/new_relic/agent/distributed_trace_payload.rb

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # New Relic Ruby Agent Release Notes #
 
+  ## v8.8.0
+
+  * **Support Makara database adapters with ActiveRecord**
+
+    Thanks to a community submission from @lucasklaassen with [PR #1177](https://github.com/newrelic/newrelic-ruby-agent/pull/1177), the Ruby agent will now correctly work well with the [Makara gem](https://github.com/instacart/makara). Functionality such as SQL obfuscation should now work when Makara database adapters are used with Active Record.
+
+  * **Lowered the minimum payload size to compress**
+
+    Previously the Ruby agent used a particularly large payload size threshold of 64KiB that would need to be met before the agent would compress data en route to New Relic's collector. The original value stems from segfault issues that very old Rubies (< 2.2) used to encounter when compressing smaller payloads. This value has been lowered to 2KiB (2048 bytes), which should provide a more optimal balance between the CPU cycles spent on compression and the bandwidth savings gained from it.
+
+  * **Provide Code Level Metrics for New Relic CodeStream**
+
+    For Ruby on Rails applications and/or those with manually traced methods, the agent is now capable of reporting metrics with Ruby method-level granularity. When the new `code_level_metrics.enabled` configuration parameter is set to a `true` value, the agent will associate source-code-related metadata with the metrics for things such as Rails controller methods. Then, when the corresponding Ruby class file that defines the methods is loaded up in a [New Relic CodeStream](https://www.codestream.com/)-powered IDE, [the four golden signals](https://sre.google/sre-book/monitoring-distributed-systems/) for each method will be presented to the developer directly.
+
+  * **Supportability Metrics will always report uncompressed payload size**
+
+    New Relic's agent specifications call for Supportability Metrics to always reference the uncompressed payload byte size. Previously, the Ruby agent was calculating the byte size after compression. Furthermore, compression is only performed on payloads of a certain size. This means that sometimes the value could have represented a compressed size and sometimes an uncompressed one. Now the uncompressed value is always used, bringing consistency for comparing two instances of the same metric and alignment with the New Relic agent specifications.
+
+
   ## v8.7.0
 
   * **APM logs-in-context log forwarding on by default**

data/CONTRIBUTING.md

@@ -128,7 +128,7 @@ This will run the unit tests in standalone mode. You can run against a specific
 by passing the version name (which should match the name of a subdirectory in test/environments)
 as an argument to the test:env rake task, like this:
 
-bundle exec rake test:env[rails60]
+bundle exec rake 'test:env[rails60]'
 
 These tests are setup to run automatically in
 [GitHub Actions](https://github.com/newrelic/newrelic-ruby-agent/actions) under several

data/Rakefile

@@ -11,15 +11,6 @@ task :test => ['test:newrelic']
 namespace :test do
   desc "Run all tests"
   task :all => %w[newrelic multiverse all_compatible_envs]
-
-  begin
-    require 'test_bisect'
-    TestBisect::BisectTask.new do |t|
-      t.test_task_name = 'test:newrelic'
-    end
-  rescue LoadError
-  end
-
   agent_home = File.expand_path(File.dirname(__FILE__))
 
   desc "Run agent performance tests"
@@ -116,24 +107,38 @@ task :update_ca_bundle do |t|
 end
 
 namespace :cross_agent_tests do
-  cross_agent_tests_upstream_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'cross_agent_tests'))
-  cross_agent_tests_local_path = File.expand_path(File.join(File.dirname(__FILE__), 'test', 'fixtures', 'cross_agent_tests'))
+  CROSS_AGENT_TESTS_UPSTREAM_PATH = File.expand_path(File.join('..', 'cross_agent_tests')).freeze
+  CROSS_AGENT_TESTS_LOCAL_PATH = File.expand_path(File.join('test', 'fixtures', 'cross_agent_tests')).freeze
+
+  def prompt_to_continue(command, destination = 'local')
+    puts "The following rsync command will be executed to update the #{destination} copy of the specs:"
+    puts
+    puts command
+    puts
+    puts "CAUTION: Any unsaved changes that exist within the #{destination} content will be OVERWRITTEN!"
+    if destination.eql?('local')
+      puts 'CAUTION 2: Before continuing, make sure your local repo is on the correct, synced branch!'
+    end
+    puts
+    print "Do you wish to continue? ('y' to continue, return to cancel) [n] "
+    continue = STDIN.gets.chomp
+    if continue.downcase.eql?('y')
+      system(command)
+    else
+      puts 'Cancelled'
+    end
+  end
 
-  # Note: before you pull, make sure your local repo is on the correct, synced branch!
   desc 'Pull latest changes from cross_agent_tests repo'
   task :pull do
-    puts "Updating embedded cross_agent_tests from #{cross_agent_tests_upstream_path}..."
-    cmd = "rsync -avu --exclude .git #{cross_agent_tests_upstream_path}/ #{cross_agent_tests_local_path}/"
-    puts cmd
-    system(cmd)
+    command = "  rsync -av --exclude .git #{CROSS_AGENT_TESTS_UPSTREAM_PATH}/ #{CROSS_AGENT_TESTS_LOCAL_PATH}/"
+    prompt_to_continue(command)
   end
 
   desc 'Copy changes from embedded cross_agent_tests to official repo working copy'
   task :push do
-    puts "Copying changes from embedded cross_agent_tests to #{cross_agent_tests_upstream_path}..."
-    cmd = "rsync -avu #{cross_agent_tests_local_path}/ #{cross_agent_tests_upstream_path}/"
-    puts cmd
-    system(cmd)
+    command = "rsync -av #{CROSS_AGENT_TESTS_LOCAL_PATH}/ #{CROSS_AGENT_TESTS_UPSTREAM_PATH}/"
+    prompt_to_continue(command, 'remote (agent spec repo)')
   end
 end
 

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

@@ -2010,6 +2010,13 @@ A map of error classes to a list of messages. When an error of one of the classe
           :allowed_from_server => false,
           :description => 'If `true`, the agent decorates logs with metadata to link to entities, hosts, traces, and spans.'
         },
+        :'code_level_metrics.enabled' => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :allowed_from_server => true,
+          :description => 'If `true`, the agent will report source code level metrics for traced methods.'
+        },
         :'instrumentation.active_support_logger' => {
           :default => instrumentation_value_from_boolean(:'application_logging.enabled'),
           :documentation_default => 'auto',

data/lib/new_relic/agent/database.rb

@@ -131,15 +131,15 @@ module NewRelic
         'execute',
         'call'
       ]
-
+      OTHER_OPERATION = 'other'.freeze
       SQL_COMMENT_REGEX = Regexp.new('/\*.*?\*/', Regexp::MULTILINE).freeze
 
       def parse_operation_from_query(sql)
         sql = Helper.correctly_encoded(sql).gsub(SQL_COMMENT_REGEX, NewRelic::EMPTY_STR)
-        if sql =~ /(\w+)/
-          op = $1.downcase
-          return op if KNOWN_OPERATIONS.include?(op)
-        end
+        return unless sql =~ /(\w+)/
+
+        op = Regexp.last_match(1).downcase
+        KNOWN_OPERATIONS.include?(op) ? op : OTHER_OPERATION
       end
 
       class ConnectionManager

data/lib/new_relic/agent/datastores/metric_helper.rb

@@ -101,7 +101,9 @@ module NewRelic
         end
 
         def self.operation_from_sql(sql)
-          NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
+          operation = NewRelic::Agent::Database.parse_operation_from_query(sql)
+          operation = OTHER if operation.eql?(NewRelic::Agent::Database::OTHER_OPERATION)
+          operation
         end
 
         # Allow Transaction#with_database_metric_name to override our

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

@@ -50,27 +50,30 @@ module NewRelic
           Tracer.start_transaction_or_segment(
             name: format_metric_name(payload[:action], controller_class),
             category: :controller,
-            options: {
-              request: request,
-              filtered_params: NewRelic::Agent::ParameterFiltering.filter_using_rails(
-                payload[:params],
-                Rails.application.config.filter_parameters
-              ),
-              apdex_start_time: queue_start(request),
-              ignore_apdex: NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-                ControllerInstrumentation::NR_IGNORE_APDEX_KEY,
-                controller_class,
-                payload[:action]
-              ),
-              ignore_enduser: NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
-                ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
-                controller_class,
-                payload[:action]
-              )
-            }
+            options: tracer_options(payload, request, controller_class)
           )
         end
 
+        def tracer_options(payload, request, controller_class)
+          {
+            request: request,
+            filtered_params: filtered_params(payload[:params]),
+            apdex_start_time: queue_start(request),
+            ignore_apdex: ignore?(payload[:action], ControllerInstrumentation::NR_IGNORE_APDEX_KEY, controller_class),
+            ignore_enduser: ignore?(payload[:action],
+              ControllerInstrumentation::NR_IGNORE_ENDUSER_KEY,
+              controller_class)
+          }.merge(NewRelic::Agent::MethodTracerHelpers.code_information(controller_class, payload[:action]))
+        end
+
+        def filtered_params(params)
+          NewRelic::Agent::ParameterFiltering.filter_using_rails(params, Rails.application.config.filter_parameters)
+        end
+
+        def ignore?(action, key, controller_class)
+          NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(key, controller_class, action)
+        end
+
         def format_metric_name(metric_action, controller)
           controller_class = controller.is_a?(Class) ? controller : Object.const_get(controller)
           "Controller/#{controller_class.controller_path}/#{metric_action}"

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

@@ -58,14 +58,21 @@ module NewRelic
         end
 
         def self.run_in_trace(job, block, event)
-          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}",
+            code_information: code_information_for_job(job)) do
             block.call
           end
         end
 
         def self.run_in_transaction(job, block)
+          options = code_information_for_job(job)
+          options = {} if options.frozen? # the hash will be added to later
           ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
-            category: :other, &block)
+            category: :other, options: options, &block)
+        end
+
+        def self.code_information_for_job(job)
+          NewRelic::Agent::MethodTracerHelpers.code_information(job.class, :perform)
         end
 
         def self.transaction_category

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

@@ -93,9 +93,21 @@ module NewRelic
 
         ACTIVE_RECORD = "ActiveRecord".freeze
         OTHER = "other".freeze
+        MAKARA_SUFFIX = "_makara".freeze
+
+        # convert vendor (makara, etc.) wrapper names to their bare names
+        # ex: postgresql_makara -> postgresql
+        def bare_adapter_name(adapter_name)
+          # TODO: OLD RUBIES - RUBY_VERSION < 2.5
+          # With Ruby 2.5+ we could use #delete_suffix instead of #chomp for a
+          # potential speed boost
+          return adapter_name.chomp(MAKARA_SUFFIX) if adapter_name && adapter_name.end_with?(MAKARA_SUFFIX)
+
+          adapter_name
+        end
 
         def product_operation_collection_for name, sql, adapter_name
-          product = map_product(adapter_name)
+          product = map_product(bare_adapter_name(adapter_name))
           splits = split_name(name)
           model = model_from_splits(splits)
           operation = operation_from_splits(splits, sql)
@@ -194,8 +206,7 @@ module NewRelic
         ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
 
         def map_product(adapter_name)
-          PRODUCT_NAMES.fetch(adapter_name,
-            ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+          PRODUCT_NAMES.fetch(adapter_name, ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
         end
 
         module InstanceIdentification
@@ -221,11 +232,16 @@ module NewRelic
           SLASH = "/".freeze
           LOCALHOST = "localhost".freeze
 
+          def adapter_from_config(config)
+            bare_name = NewRelic::Agent::Instrumentation::ActiveRecordHelper.bare_adapter_name(config[:adapter])
+            PRODUCT_SYMBOLS[bare_name]
+          end
+
           def host(config)
             return UNKNOWN unless config
 
             configured_value = config[:host]
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            adapter = adapter_from_config(config)
             if configured_value.nil? ||
                 postgres_unix_domain_socket_case?(configured_value, adapter)
 
@@ -243,7 +259,7 @@ module NewRelic
           def port_path_or_id(config)
             return UNKNOWN unless config
 
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            adapter = adapter_from_config(config)
             if config[:socket]
               config[:socket].empty? ? UNKNOWN : config[:socket]
             elsif postgres_unix_domain_socket_case?(config[:host], adapter) || mysql_default_case?(config, adapter)
@@ -263,7 +279,7 @@ module NewRelic
           SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze
 
           def supported_adapter? config
-            config && SUPPORTED_ADAPTERS.include?(PRODUCT_SYMBOLS[config[:adapter]])
+            config && SUPPORTED_ADAPTERS.include?(adapter_from_config(config))
           end
 
           private

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

@@ -91,17 +91,26 @@ module NewRelic
           end
 
           return unless connection_id = payload[:connection_id]
-          connection = nil
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
-            connection = handler.connections.detect do |conn|
-              conn.object_id == connection_id
-            end
-
-            break if connection
+            connection = handler.connections.detect { |conn| conn.object_id == connection_id }
+            return connection.instance_variable_get(:@config) if connection
+
+            # when using makara, handler.connections will be empty, so use the
+            # spec config instead.
+            # https://github.com/newrelic/newrelic-ruby-agent/issues/507
+            # thank you @lucasklaassen
+            return handler.spec.config if use_spec_config?(handler)
           end
 
-          connection.instance_variable_get(:@config) if connection
+          nil
+        end
+
+        def use_spec_config?(handler)
+          handler.respond_to?(:spec) &&
+            handler.spec &&
+            handler.spec.config &&
+            handler.spec.config[:adapter].end_with?('makara')
         end
 
         def start_segment(config, payload)

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

@@ -165,10 +165,6 @@ module NewRelic
           def add_transaction_tracer(method, options = {})
             NewRelic::Agent.record_api_supportability_metric(:add_transaction_tracer)
 
-            # The metric path:
-            options[:name] ||= method.to_s
-
-            argument_list = generate_argument_list(options)
             traced_method, punctuation = parse_punctuation(method)
             with_method_name, without_method_name = build_method_names(traced_method, punctuation)
 
@@ -177,6 +173,12 @@ module NewRelic
               return
             end
 
+            # The metric path:
+            options[:name] ||= method.to_s
+
+            code_info = NewRelic::Agent::MethodTracerHelpers.code_information(self, method)
+            argument_list = generate_argument_list(options.merge(code_info))
+
             class_eval <<-EOC
               def #{with_method_name}(*args, &block)
                 perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
@@ -441,6 +443,9 @@ module NewRelic
           txn_options[:apdex_start_time] = queue_start_time
           txn_options[:ignore_apdex] = ignore_apdex?
           txn_options[:ignore_enduser] = ignore_enduser?
+          NewRelic::Agent::MethodTracerHelpers::SOURCE_CODE_INFORMATION_PARAMETERS.each do |parameter|
+            txn_options[parameter] = trace_options[parameter]
+          end
           txn_options
         end
 

data/lib/new_relic/agent/log_event_aggregator.rb

@@ -9,7 +9,7 @@ module NewRelic
   module Agent
     class LogEventAggregator < EventAggregator
       # Per-message keys
-      LEVEL_KEY = "log.level".freeze
+      LEVEL_KEY = "level".freeze
       MESSAGE_KEY = "message".freeze
       TIMESTAMP_KEY = "timestamp".freeze
       PRIORITY_KEY = "priority".freeze

data/lib/new_relic/agent/method_tracer.rb

@@ -100,7 +100,7 @@ module NewRelic
       module ClassMethods
         # contains methods refactored out of the #add_method_tracer method
         module AddMethodTracer
-          ALLOWED_KEYS = [:metric, :push_scope, :code_header, :code_footer].freeze
+          ALLOWED_KEYS = [:metric, :push_scope, :code_header, :code_information, :code_footer].freeze
 
           DEFAULT_SETTINGS = {:push_scope => true, :metric => true, :code_header => "", :code_footer => ""}.freeze
 
@@ -274,7 +274,8 @@ module NewRelic
 
           _nr_define_traced_method(method_name, scoped_metric: scoped_metric, unscoped_metrics: unscoped_metrics,
             code_header: options[:code_header], code_footer: options[:code_footer],
-            record_metrics: options[:metric], visibility: visibility)
+            record_metrics: options[:metric], visibility: visibility,
+            code_information: options[:code_information])
 
           prepend(_nr_traced_method_module)
 
@@ -298,7 +299,8 @@ module NewRelic
 
         def _nr_define_traced_method(method_name, scoped_metric: nil, unscoped_metrics: [],
           code_header: nil, code_footer: nil, record_metrics: true,
-          visibility: :public)
+          visibility: :public, code_information: {})
+
           _nr_traced_method_module.module_eval do
             define_method(method_name) do |*args, &block|
               return super(*args, &block) unless NewRelic::Agent.tl_is_execution_traced?
@@ -325,7 +327,10 @@ module NewRelic
               # If tracing multiple metrics on this method, nest one unscoped trace inside the scoped trace.
               begin
                 if scoped_metric_eval
-                  ::NewRelic::Agent::MethodTracer.trace_execution_scoped(scoped_metric_eval, metric: record_metrics, internal: true) do
+                  ::NewRelic::Agent::MethodTracer.trace_execution_scoped(scoped_metric_eval,
+                    metric: record_metrics,
+                    internal: true,
+                    code_information: code_information) do
                     if unscoped_metrics_eval.empty?
                       super(*args, &block)
                     else

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -5,6 +5,13 @@
 module NewRelic
   module Agent
     module MethodTracerHelpers
+      # These are code level metrics (CLM) attributes. For Ruby, they map like so:
+      #   filepath: full path to an .rb file on disk
+      #   lineno: the line number a Ruby method is defined on within a given .rb file
+      #   function: the name of the Ruby method
+      #   namespace: the Ruby class' namespace as a string, ex: 'MyModule::MyClass'
+      SOURCE_CODE_INFORMATION_PARAMETERS = %i[filepath lineno function namespace].freeze
+      SOURCE_CODE_INFORMATION_FAILURE_METRIC = "Supportabiltiy/CodeLevelMetrics/Ruby/Failure".freeze
       MAX_ALLOWED_METRIC_DURATION = 1_000_000_000 # roughly 31 years
 
       extend self
@@ -26,12 +33,85 @@ module NewRelic
           segment.record_metrics = false
         end
 
+        unless !options.key?(:code_information) || options[:code_information].nil? || options[:code_information].empty?
+          segment.code_information = options[:code_information]
+        end
+
         begin
           Tracer.capture_segment_error(segment) { yield }
         ensure
           segment.finish if segment
         end
       end
+
+      def code_information(object, method_name)
+        unless NewRelic::Agent.config[:'code_level_metrics.enabled'] && object && method_name
+          return NewRelic::EMPTY_HASH
+        end
+
+        @code_information ||= {}
+        cache_key = "#{object.object_id}#{method_name}"
+        return @code_information[cache_key] if @code_information.key?(cache_key)
+
+        namespace, location, is_class_method = namespace_and_location(object, method_name.to_sym)
+
+        @code_information[cache_key] = {filepath: location.first,
+                                        lineno: location.last,
+                                        function: "#{'self.' if is_class_method}#{method_name}",
+                                        namespace: namespace}
+      rescue => 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)
+        ::NewRelic::EMPTY_HASH
+      end
+
+      private
+
+      # The string representation of a singleton class looks like
+      # '#<Class:MyModule::MyClass>'. Return the 'MyModule::MyClass' part of
+      # that string
+      def klass_name(object)
+        name = Regexp.last_match(1) if object.to_s =~ /^#<Class:(.*)>$/
+        return name if name
+
+        raise "Unable to glean a class name from string '#{object}'" unless name
+      end
+
+      # get at the underlying class from the singleton class
+      #
+      # note: even with the regex hit from klass_name(), `Object.const_get`
+      # is more performant than iterating through `ObjectSpace`
+      def klassify_singleton(object)
+        Object.const_get(klass_name(object))
+      end
+
+      # determine the namespace (class name including all module names in scope)
+      # and source code location (file path and line number) for the given
+      # object and method name
+      #
+      # traced class methods:
+      #     * object is a singleton class, `#<Class::MyClass>`
+      #     * get at the underlying non-singleton class
+      #
+      # traced instance methods and Rails controller methods:
+      #     * object is a class, `MyClass`
+      #
+      # anonymous class based methods (`c = Class.new { def method; end; }`:
+      #     * `#name` returns `nil`, so use '(Anonymous)' instead
+      #
+      def namespace_and_location(object, method_name)
+        klass = object.singleton_class? ? klassify_singleton(object) : object
+        name = klass.name || '(Anonymous)'
+        is_class_method = false
+        method = if klass.instance_methods.include?(method_name)
+          klass.instance_method(method_name)
+        else
+          is_class_method = true
+          klass.method(method_name)
+        end
+        [name, method.source_location, is_class_method]
+      end
     end
   end
 end

data/lib/new_relic/agent/new_relic_service.rb

@@ -15,23 +15,23 @@ module NewRelic
     class NewRelicService
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
-
       PROTOCOL_VERSION = 17
 
-      # 1f147a42: v10 (tag 3.5.3.17)
-      # cf0d1ff1: v9 (tag 3.5.0)
-      # 14105: v8 (tag 2.10.3)
-      # (no v7)
-      # 10379: v6 (not tagged)
-      # 4078:  v5 (tag 2.5.4)
-      # 2292:  v4 (tag 2.3.6)
-      # 1754:  v3 (tag 2.3.0)
-      # 534:   v2 (shows up in 2.1.0, our first tag)
-
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
       CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
 
+      # Don't perform compression on the payload unless its uncompressed size is
+      # greater than or equal to this number of bytes. In testing with
+      # Ruby 2.2 - 3.1, we determined an absolute minimum value for ASCII to be
+      # 535 bytes to obtain at least a 10% savings in size. It is recommended
+      # that this value be kept above that 535 number. It is also important to
+      # consider the CPU cost involved with performing compression and to find
+      # a balance between CPU cycles spent and bandwidth saved. A good
+      # reasonable default here is 2048 bytes, which is a tried and true Apache
+      # Tomcat default (as of v8.5.78)
+      MIN_BYTE_SIZE_TO_COMPRESS = 2048
+
       attr_accessor :request_timeout
       attr_reader :collector, :marshaller, :agent_id
 
@@ -198,12 +198,9 @@ module NewRelic
         response
       end
 
-      # We do not compress if content is smaller than 64kb.  There are
-      # problems with bugs in Ruby in some versions that expose us
-      # to a risk of segfaults if we compress aggressively.
       def compress_request_if_needed(data, endpoint)
         encoding = 'identity'
-        if data.size > 64 * 1024
+        if data.size >= MIN_BYTE_SIZE_TO_COMPRESS
           encoding = Agent.config[:compressed_content_encoding]
           data = if encoding == 'deflate'
             Encoders::Compressed::Deflate.encode(data)
@@ -429,8 +426,8 @@ module NewRelic
         end
         serialize_finish_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+        size = data.size # only the uncompressed size is reported
         data, encoding = compress_request_if_needed(data, method)
-        size = data.size
 
         # Preconnect needs to always use the configured collector host, not the redirect host
         # We reset it here so we are always using the configured collector during our creation of the new connection

data/lib/new_relic/agent/span_event_primitive.rb

@@ -165,18 +165,21 @@ module NewRelic
         end
       end
 
-      def merge_and_freeze_attributes agent_attributes, error_attributes
-        return agent_attributes.freeze unless error_attributes
-        return error_attributes.freeze if agent_attributes.equal?(NewRelic::EMPTY_HASH)
-        agent_attributes.merge!(error_attributes).freeze
+      def merge_hashes(hash1, hash2)
+        return hash1 if hash2.nil? || hash2.empty?
+        return hash2 if hash1.nil? || hash1.empty?
+
+        hash1.merge!(hash2)
       end
 
       def agent_attributes segment
         agent_attributes = segment.attributes
           .agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_SPAN_EVENTS)
         error_attributes = error_attributes(segment)
-        return NewRelic::EMPTY_HASH unless agent_attributes || error_attributes
-        merge_and_freeze_attributes(agent_attributes, error_attributes)
+        code_attributes = segment.code_attributes
+        agent_attributes = merge_hashes(agent_attributes, error_attributes)
+        agent_attributes = merge_hashes(agent_attributes, code_attributes)
+        agent_attributes.freeze
       end
 
       def parent_guid segment

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

@@ -46,6 +46,10 @@ module NewRelic
           @record_scoped_metric = true
           @record_on_finish = false
           @noticed_error = nil
+          @code_filepath = nil
+          @code_function = nil
+          @code_lineno = nil
+          @code_namespace = nil
         end
 
         def start
@@ -57,6 +61,7 @@ module NewRelic
         def finish
           @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           @duration = end_time - start_time
+
           return unless transaction
           run_complete_callbacks
           finalize if record_on_finish?
@@ -110,6 +115,28 @@ module NewRelic
           @concurrent_children
         end
 
+        def code_information=(info = {})
+          return unless info[:filepath]
+
+          @code_filepath = info[:filepath]
+          @code_function = info[:function]
+          @code_lineno = info[:lineno]
+          @code_namespace = info[:namespace]
+        end
+
+        def all_code_information_present?
+          @code_filepath && @code_function && @code_lineno && @code_namespace
+        end
+
+        def code_attributes
+          return ::NewRelic::EMPTY_HASH unless all_code_information_present?
+
+          @code_attributes ||= {'code.filepath' => @code_filepath,
+                                'code.function' => @code_function,
+                                'code.lineno' => @code_lineno,
+                                'code.namespace' => @code_namespace}
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect

data/lib/new_relic/agent/transaction.rb

@@ -124,7 +124,7 @@ module NewRelic
         txn = Transaction.new(category, options)
         state.reset(txn)
         txn.state = state
-        txn.start
+        txn.start(options)
         txn
       end
 
@@ -414,7 +414,7 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      def start
+      def start(options = {})
         return if !state.is_execution_traced?
 
         sql_sampler.on_start_transaction(state, request_path)
@@ -423,7 +423,7 @@ module NewRelic
 
         ignore! if user_defined_rules_ignore?
 
-        create_initial_segment
+        create_initial_segment(options)
         Segment.merge_untrusted_agent_attributes \
           @filtered_params,
           :'request.parameters',
@@ -434,12 +434,12 @@ module NewRelic
         segments.first
       end
 
-      def create_initial_segment
-        segment = create_segment @default_name
+      def create_initial_segment(options = {})
+        segment = create_segment @default_name, options
         segment.record_scoped_metric = false
       end
 
-      def create_segment(name)
+      def create_segment(name, options = {})
         summary_metrics = nil
 
         if name.start_with?(MIDDLEWARE_PREFIX)
@@ -453,6 +453,10 @@ module NewRelic
           unscoped_metrics: summary_metrics
         )
 
+        # #code_information will glean the code info out of the options hash
+        # if it exists or noop otherwise
+        segment.code_information = options
+
         segment
       end
 
@@ -467,7 +471,8 @@ module NewRelic
 
         nest_initial_segment if segments.length == 1
         nested_name = self.class.nested_transaction_name options[:transaction_name]
-        segment = create_segment nested_name
+
+        segment = create_segment nested_name, options
         set_default_transaction_name(options[:transaction_name], category)
         segment
       end

data/lib/new_relic/agent.rb

@@ -143,6 +143,8 @@ module NewRelic
     #
     def add_or_defer_method_tracer(receiver, method_name, metric_name, options)
       @tracer_lock.synchronize do
+        options[:code_information] = NewRelic::Agent::MethodTracerHelpers.code_information(receiver, method_name)
+
         if @agent
           receiver.send(:_nr_add_method_tracer_now, method_name, metric_name, options)
         else

data/lib/new_relic/traced_thread.rb

@@ -7,19 +7,18 @@ module NewRelic
   #
   # This class allows the current transaction to be passed to a Thread so that nested segments can be created from the operations performed within the Thread's block.
   # To have the New Relic Ruby agent automatically trace all of your applications threads,
-  # enable the `instrumentation.thread.tracing` configuration option in your newrelic.yml.
+  # enable the +instrumentation.thread.tracing+ configuration option in your newrelic.yml.
   #
-  # Note: disabling the configuration option `instrumentation.thread` while using this class can cause incorrectly nested spans.
+  # Note: disabling the configuration option +instrumentation.thread+ while using this class can cause incorrectly nested spans.
   #
   # @api public
   class TracedThread < Thread
     #
     # Creates a new Thread whose work will be traced by New Relic.
     # Use this class as a replacement for the native Thread class.
-    # Example: Instead of using `Thread.new`, use:
-    # ```ruby
-    #   NewRelic::TracedThread.new { execute_some_code }
-    # ```
+    # Example: Instead of using +Thread.new+, use:
+    #
+    #     NewRelic::TracedThread.new { execute_some_code }
     #
     # @api public
     def initialize(*args, &block)

data/lib/new_relic/version.rb

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

data/newrelic.yml

@@ -42,6 +42,9 @@ common: &default_settings
 # If `true`, the agent decorates logs with metadata to link to entities, hosts, traces, and spans.
 # application_logging.local_decorating.enabled: false
 
+# If `true`, the agent will report source code level metrics for traced methods
+# code_level_metrics.enabled: false
+
 # If true, enables transaction event sampling.
 # transaction_events.enabled: true
 

data/newrelic_rpm.gemspec

@@ -47,10 +47,6 @@ https://github.com/newrelic/newrelic-ruby-agent/
   s.require_paths = ["lib"]
   s.rubygems_version = Gem::VERSION
   s.summary = "New Relic Ruby Agent"
-  s.post_install_message = 'Thanks for installing the latest version of newrelic_rpm. '\
-    'This version turns on application log forwarding by default. If you want to turn ' \
-    'off this feature, set `application_logging.forwarding.enabled: false`. ' \
-    'For more information, visit: https://docs.newrelic.com/docs/logs/logs-context/configure-logs-context-ruby'
   s.add_development_dependency 'rake', '12.3.3'
   s.add_development_dependency 'rb-inotify', '0.9.10' # locked to support < Ruby 2.3 (and listen 3.0.8)
   s.add_development_dependency 'listen', '3.0.8' # locked to support < Ruby 2.3
@@ -62,7 +58,6 @@ https://github.com/newrelic/newrelic-ruby-agent/
   s.add_development_dependency 'pry-stack_explorer', '~> 0.4.9'
   s.add_development_dependency 'guard', '~> 2.16.0'
   s.add_development_dependency 'guard-minitest', '~> 2.4.0'
-  s.add_development_dependency 'hometown', '~> 0.2.5'
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'rubocop-performance'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 8.7.0
+  version: 8.8.0
 platform: ruby
 authors:
 - Tanna McClure
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-03 00:00:00.000000000 Z
+date: 2022-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -167,20 +167,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.4.0
-- !ruby/object:Gem::Dependency
-  name: hometown
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.5
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -618,10 +604,7 @@ metadata:
   documentation_uri: https://docs.newrelic.com/docs/agents/ruby-agent
   source_code_uri: https://github.com/newrelic/newrelic-ruby-agent
   homepage_uri: https://newrelic.com/ruby
-post_install_message: 'Thanks for installing the latest version of newrelic_rpm. This
-  version turns on application log forwarding by default. If you want to turn off
-  this feature, set `application_logging.forwarding.enabled: false`. For more information,
-  visit: https://docs.newrelic.com/docs/logs/logs-context/configure-logs-context-ruby'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib