newrelic_rpm 6.15.0 → 9.7.1

data/lib/new_relic/traced_thread.rb

@@ -0,0 +1,38 @@
+# 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
+  #
+  # 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.
+  #
+  # 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:
+    #
+    #     NewRelic::TracedThread.new { execute_some_code }
+    #
+    # @api public
+    def initialize(*args, &block)
+      NewRelic::Agent.record_api_supportability_metric(:traced_thread)
+      traced_block = create_traced_block(&block)
+      super(*args, &traced_block)
+    end
+
+    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(
+        segment_name: 'Ruby/TracedThread',
+        &block
+      )
+    end
+  end
+end

data/lib/new_relic/version.rb

@@ -1,25 +1,14 @@
 #!/usr/bin/ruby
-# encoding: utf-8
 # 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 VERSION #:nodoc:
-    def self.build_version_string(*parts)
-      parts.compact.join('.')
-    end
-
-    MAJOR = 6
-    MINOR = 15
-    TINY  = 0
-
-    begin
-      require File.join(File.dirname(__FILE__), 'build')
-    rescue LoadError
-      BUILD = nil
-    end
+  module VERSION # :nodoc:
+    MAJOR = 9
+    MINOR = 7
+    TINY = 1
 
-    STRING = build_version_string(MAJOR, MINOR, TINY, BUILD)
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end
 end

data/lib/newrelic_rpm.rb

@@ -1,53 +1,40 @@
-# encoding: utf-8
 # 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
 
 # == New Relic Initialization
 #
 # When installed as a gem, you can activate the New Relic agent one of the following ways:
 #
-# For Rails, add:
-#    config.gem 'newrelic_rpm'
-# to your initialization sequence.
+# For applications using Bundler, add this to the Gemfile:
+#    gem 'newrelic_rpm'
 #
-# For merb, do
-#    dependency 'newrelic_rpm'
-# in the Merb config/init.rb
+# You will also need to install the newrelic.yml configuration file
 #
-# For Sinatra, do
-#    require 'newrelic_rpm'
-# after requiring 'sinatra'.
-#
-# For other frameworks, or to manage the agent manually, invoke NewRelic::Agent#manual_start
-# directly.
+# For applications not using Bundler, and for other installation information, visit:
+# https://docs.newrelic.com/docs/agents/ruby-agent/installation/install-new-relic-ruby-agent/
 #
 
 require 'new_relic/control'
-if defined?(Merb) && defined?(Merb::BootLoader)
+
+if defined?(Rails::VERSION)
   module NewRelic
-    class MerbBootLoader < Merb::BootLoader
-      after Merb::BootLoader::ChooseAdapter
-      def self.run
-        NewRelic::Control.instance.init_plugin
-      end
-    end
-  end
-elsif defined?(Rails::VERSION)
-  if Rails::VERSION::MAJOR.to_i >= 3
-    module NewRelic
-      class Railtie < Rails::Railtie
+    class Railtie < Rails::Railtie
+      if ENV['NEW_RELIC_DEFER_RAILS_INITIALIZATION']
+        initializer 'newrelic_rpm.include_method_tracers', before: :load_config_initializers do |app|
+          Module.send(:include, NewRelic::Agent::MethodTracer::ClassMethods)
+          Module.send(:include, NewRelic::Agent::MethodTracer)
+        end
 
-        initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
-          NewRelic::Control.instance.init_plugin(:config => app.config)
+        initializer 'newrelic_rpm.start_plugin', after: :load_config_initializers do |app|
+          NewRelic::Control.instance.init_plugin(config: app.config)
+        end
+      else
+        initializer 'newrelic_rpm.start_plugin', before: :load_config_initializers do |app|
+          NewRelic::Control.instance.init_plugin(config: app.config)
         end
       end
     end
-  else
-    # After version 2.0 of Rails we can access the configuration directly.
-    # We need it to add dev mode routes after initialization finished.
-    config = nil
-    config = Rails.configuration if Rails.respond_to?(:configuration)
-    NewRelic::Control.instance.init_plugin :config => config
   end
 else
   NewRelic::Control.instance.init_plugin

data/lib/sequel/extensions/{newrelic_instrumentation.rb → new_relic_instrumentation.rb}

@@ -1,15 +1,14 @@
 # -*- ruby -*-
-# encoding: utf-8
 # 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 'sequel' unless defined?( Sequel )
-require 'newrelic_rpm' unless defined?( NewRelic )
+require 'sequel' unless defined?(Sequel)
+require 'newrelic_rpm' unless defined?(NewRelic)
 require 'new_relic/agent/instrumentation/sequel_helper'
 require 'new_relic/agent/datastores/metric_helper'
 
 module Sequel
-
   # New Relic's Sequel instrumentation is implemented via a plugin for
   # Sequel::Models, and an extension for Sequel::Databases. Every database
   # handle that Sequel knows about when New Relic is loaded will automatically
@@ -18,7 +17,7 @@ module Sequel
   # instrumentation is loaded:
   #
   #     db = Sequel.connect( ... )
-  #     db.extension :newrelic_instrumentation
+  #     db.extension :new_relic_instrumentation
   #
   # Versions 3.47.0 and later use `Database.extension` to automatically
   # install the extension for new connections.
@@ -28,13 +27,12 @@ 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
       def self.query_method_name
-        if Sequel::VERSION >= "4.35.0"
+        if Sequel::VERSION >= '4.35.0'
           :log_connection_yield
         else
           :log_yield
@@ -42,7 +40,7 @@ module Sequel
       end
     end
 
-    define_method Naming.query_method_name do |*args, &blk| #THREAD_LOCAL_ACCESS
+    define_method Naming.query_method_name do |*args, &blk| # THREAD_LOCAL_ACCESS
       sql = args.first
 
       product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(self.class.adapter_scheme)
@@ -56,7 +54,7 @@ module Sequel
         super(*args, &blk)
       ensure
         notice_sql(sql)
-        segment.finish if segment
+        ::NewRelic::Agent::Transaction::Segment.finish(segment)
       end
     end
 
@@ -64,18 +62,18 @@ module Sequel
     # block in the sequel Plugin instrumentation. A simple ORM operation from the Plugin
     # instrumentation may trigger a number of calls to this method. We want to append
     # the statements that come from the disable_all_tracing block into this node's
-    # statement, otherwise we would end up ovewriting the sql statement with the
+    # statement, otherwise we would end up overwriting the sql statement with the
     # last one executed.
-    def notice_sql sql
+    def notice_sql(sql)
       return unless txn = NewRelic::Agent::Tracer.current_transaction
 
       current_segment = txn.current_segment
       return unless current_segment.is_a?(NewRelic::Agent::Transaction::DatastoreSegment)
 
       if current_segment.sql_statement
-        current_segment.sql_statement.append_sql sql
+        current_segment.sql_statement.append_sql(sql)
       else
-        current_segment._notice_sql sql, self.opts, explainer_for(sql)
+        current_segment._notice_sql(sql, self.opts, explainer_for(sql))
       end
     end
 
@@ -83,19 +81,18 @@ module Sequel
       (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool)
     ].freeze
 
-    def explainer_for sql
-      Proc.new do |*|
+    def explainer_for(sql)
+      proc do |*|
         if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
-          self[ sql ].explain
+          self[sql].explain
         else
-          NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, "Not running SQL explains because Sequel is not in recognized multi-threaded mode")
+          NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, 'Not running SQL explains because Sequel is not in recognized multi-threaded mode')
           nil
         end
       end
     end
   end # module NewRelicInstrumentation
 
-  NewRelic::Agent.logger.debug "Registering the :newrelic_instrumentation extension."
-  Database.register_extension(:newrelic_instrumentation, NewRelicInstrumentation)
-
+  NewRelic::Agent.logger.debug('Registering the :new_relic_instrumentation extension.')
+  Database.register_extension(:new_relic_instrumentation, NewRelicInstrumentation)
 end # module Sequel

data/lib/sequel/plugins/{newrelic_instrumentation.rb → new_relic_instrumentation.rb}

@@ -1,25 +1,23 @@
 # -*- ruby -*-
-# encoding: utf-8
 # 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 'sequel' unless defined?( Sequel )
-require 'newrelic_rpm' unless defined?( NewRelic )
+require 'sequel' unless defined?(Sequel)
+require 'newrelic_rpm' unless defined?(NewRelic)
 require 'new_relic/agent/instrumentation/sequel_helper'
 require 'new_relic/agent/datastores/metric_helper'
 
 module Sequel
   module Plugins
-
     # Sequel::Model instrumentation for the New Relic agent.
-    module NewrelicInstrumentation
-
+    module NewRelicInstrumentation
       # Meta-programming for creating method tracers for the Sequel::Model plugin.
       module MethodWrapping
         # Install a method named +method_name+ that will trace execution
         # with a metric name derived from +operation_name+ (or +method_name+ if +operation_name+
         # isn't specified).
-        def wrap_sequel_method(method_name, operation_name=method_name)
+        def wrap_sequel_method(method_name, operation_name = method_name)
           define_method(method_name) do |*args, &block|
             klass = self.is_a?(Class) ? self : self.class
             product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(db.adapter_scheme)
@@ -32,16 +30,15 @@ module Sequel
             begin
               NewRelic::Agent.disable_all_tracing { super(*args, &block) }
             ensure
-              segment.finish if segment
+              ::NewRelic::Agent::Transaction::Segment.finish(segment)
             end
           end
         end
-
       end # module MethodTracer
 
       # Methods to be added to Sequel::Model instances.
       module InstanceMethods
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
+        extend Sequel::Plugins::NewRelicInstrumentation::MethodWrapping
 
         wrap_sequel_method :delete
         wrap_sequel_method :destroy
@@ -51,20 +48,17 @@ module Sequel
         wrap_sequel_method :update_fields
         wrap_sequel_method :update_only
         wrap_sequel_method :save
-
       end # module InstanceMethods
 
-
       # Methods to be added to Sequel::Model classes.
       module ClassMethods
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
+        extend Sequel::Plugins::NewRelicInstrumentation::MethodWrapping
 
-        wrap_sequel_method :[], "get"
+        wrap_sequel_method :[], 'get'
         wrap_sequel_method :all
         wrap_sequel_method :first
         wrap_sequel_method :create
       end # module ClassMethods
-
     end # module NewRelicInstrumentation
   end # module Plugins
 end # module Sequel

data/lib/tasks/all.rb

@@ -1,8 +1,8 @@
-# encoding: utf-8
 # 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
 
-# This is required to load in task definitions from merb
-Dir.glob(File.join(File.dirname(__FILE__),'*.rake')) do |file|
+# This is required to load in task definitions
+Dir.glob(File.join(File.dirname(__FILE__), '*.rake')) do |file|
   load file
 end

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/config.rake

@@ -1,133 +1,39 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require_relative 'helpers/format'
+include Format
+
 namespace :newrelic do
   namespace :config do
-    desc "Describe available New Relic configuration settings."
+    GENERAL = 'general'
+    DISABLING = 'disabling'
+    ATTRIBUTES = 'attributes'
 
-    GENERAL    = "general"
-    DISABLING  = "disabling"
-    ATTRIBUTES = "attributes"
+    # these configuration options are not able to be set using environment variables
+    NON_ENV_CONFIGS = ['error_collector.ignore_classes', 'error_collector.ignore_messages', 'error_collector.expected_classes', 'error_collector.expected_messages']
 
     SECTION_DESCRIPTIONS = {
-      GENERAL              => 'These settings are available for agent configuration. Some settings depend on your New Relic subscription level.',
-      DISABLING            => 'Use these settings to toggle instrumentation types during agent startup.',
-      ATTRIBUTES           => '<a href="https://docs.newrelic.com/docs/features/agent-attributes">Attributes</a> are key-value pairs containing information that determines the properties of an event or transaction. These key-value pairs can be viewed within transaction traces in New Relic APM, traced errors in New Relic APM, transaction events in Insights, and page views in Insights. You can customize exactly which attributes will be sent to each of these destinations.',
-      "transaction_tracer" => 'The <a href="/docs/apm/traces/transaction-traces/transaction-traces">transaction traces</a> feature collects detailed information from a selection of transactions, including a summary of the calling sequence, a breakdown of time spent, and a list of SQL queries and their query plans (on mysql and postgresql). Available features depend on your New Relic subscription level.',
-      "error_collector"    => 'The agent collects and reports all uncaught exceptions by default. These configuration options allow you to customize the error collection.',
-      "browser_monitoring" => 'New Relic Browser\'s <a href="/docs/browser/new-relic-browser/page-load-timing/page-load-timing-process">page load timing</a> feature (sometimes referred to as real user monitoring or RUM) gives you insight into the performance real users are experiencing with your website. This is accomplished by measuring the time it takes for your users\' browsers to download and render your web pages by injecting a small amount of JavaScript code into the header and footer of each page.',
-      "analytics_events"   => '<a href="/docs/insights/new-relic-insights/understanding-insights/new-relic-insights">New Relic Insights</a> is a software analytics resource to gather and visualize data about your software and what it says about your business. With it you can quickly and easily create real-time dashboards to get immediate answers about end-user experiences, clickstreams, mobile activities, and server transactions.'
+      GENERAL => 'These settings are available for agent configuration. Some settings depend on your New Relic subscription level.',
+      DISABLING => 'Use these settings to toggle instrumentation types during agent startup.',
+      ATTRIBUTES => '[Attributes](/docs/features/agent-attributes) are key-value pairs containing information that determines the properties of an event or transaction. These key-value pairs can be viewed within transaction traces in APM, traced errors in APM, transaction events in dashboards, and page views in dashboards. You can customize exactly which attributes will be sent to each of these destinations',
+      'transaction_tracer' => 'The [transaction traces](/docs/apm/traces/transaction-traces/transaction-traces) feature collects detailed information from a selection of transactions, including a summary of the calling sequence, a breakdown of time spent, and a list of SQL queries and their query plans (on mysql and postgresql). Available features depend on your New Relic subscription level.',
+      'error_collector' => "The agent collects and reports all uncaught exceptions by default. These configuration options allow you to customize the error collection.\n\nFor information on ignored and expected errors, [see this page on Error Analytics in APM](/docs/agents/manage-apm-agents/agent-data/manage-errors-apm-collect-ignore-or-mark-expected/). To set expected errors via the `NewRelic::Agent.notice_error` Ruby method, [consult the Ruby agent API](/docs/agents/ruby-agent/api-guides/sending-handled-errors-new-relic/).",
+      'browser_monitoring' => "The browser monitoring [page load timing](/docs/browser/new-relic-browser/page-load-timing/page-load-timing-process) feature (sometimes referred to as real user monitoring or RUM) gives you insight into the performance real users are experiencing with your website. This is accomplished by measuring the time it takes for your users' browsers to download and render your web pages by injecting a small amount of JavaScript code into the header and footer of each page.",
+      'application_logging' => "The Ruby agent supports [APM logs in context](/docs/apm/new-relic-apm/getting-started/get-started-logs-context). For some tips on configuring logs for the Ruby agent, see [Configure Ruby logs in context](/docs/logs/logs-context/configure-logs-context-ruby).\n\nAvailable logging-related config options include:",
+      'analytics_events' => '[New Relic dashboards](/docs/query-your-data/explore-query-data/dashboards/introduction-new-relic-one-dashboards) is a resource to gather and visualize data about your software and what it says about your business. With it you can quickly and easily create real-time dashboards to get immediate answers about end-user experiences, clickstreams, mobile activities, and server transactions.'
     }
 
     NAME_OVERRIDES = {
-      "slow_sql"     => "Slow SQL"
+      'slow_sql' => 'Slow SQL [#slow-sql]',
+      'custom_insights_events' => 'Custom Events [#custom-events]'
     }
 
-    def output(format)
-      config_hash = build_config_hash
-      sections = flatten_config_hash(config_hash)
-
-      puts build_erb(format).result(binding)
-      sections # silences unused warning to return this
-    end
-
-    def build_config_hash
-      sections = Hash.new {|hash, key| hash[key] = []}
-      NewRelic::Agent::Configuration::DEFAULTS.each do |key, value|
-        next unless value[:public]
-
-        section_key = GENERAL
-        key = key.to_s
-        components = key.split(".")
-
-        if key.match(/^disable_/)           # "disable_httpclient"
-          section_key = DISABLING
-        elsif components.length == 2        # "analytics_events.enabled"
-          section_key = components.first
-        elsif components[1] == "attributes" # "transaction_tracer.attributes.enabled"
-          section_key = ATTRIBUTES
-        end
-
-        sections[section_key] << {
-          :key         => key,
-          :type        => format_type(value[:type]),
-          :description => format_description(value),
-          :default     => format_default_value(value),
-          :env_var     => format_env_var(key)
-        }
-      end
-      sections
-    end
-
-    def flatten_config_hash(config_hash)
-      sections = []
-      sections << pluck(GENERAL, config_hash)
-      sections << pluck("transaction_tracer", config_hash)
-      sections << pluck("error_collector",    config_hash)
-      sections << pluck("browser_monitoring", config_hash)
-      sections << pluck("analytics_events",   config_hash)
-      sections.concat(config_hash.to_a.sort_by { |a| a.first})
-
-      add_data_to_sections(sections)
-
-      sections
-    end
-
-    def add_data_to_sections(sections)
-      sections.each do |section|
-        section_key = section[0]
-        section.insert(1, format_name(section_key))
-        section.insert(2, SECTION_DESCRIPTIONS[section_key])
-      end
-    end
-
-    def format_name(key)
-      name = NAME_OVERRIDES[key]
-      return name if name
-
-      key.split("_").
-          each { |fragment| fragment[0] = fragment[0].upcase }.
-          join(" ")
-    end
-
-    def format_type(type)
-      if type == NewRelic::Agent::Configuration::Boolean
-        "Boolean"
-      else
-        type
-      end
-    end
-
-    def format_description(value)
-      description = value[:description]
-      description = "<b>DEPRECATED</b> #{description}" if value[:deprecated]
-      description
-    end
-
-    def format_default_value(spec)
-      if spec[:default].is_a?(Proc)
-        '(Dynamic)'
-      else
-        "<code>#{spec[:default].inspect}</code>"
-      end
-    end
-
-    def format_env_var(key)
-      "NEW_RELIC_#{key.gsub(".", "_").upcase}"
-    end
-
-    def pluck(key, config_hash)
-      value = config_hash.delete(key)
-      [key, value]
-    end
-
-    def build_erb(format)
-      require 'erb'
-      path = File.join(File.dirname(__FILE__), "config.#{format}.erb")
-      template = File.read(File.expand_path(path))
-      ERB.new(template)
-    end
-
+    desc 'Describe available New Relic configuration settings'
     task :docs, [:format] => [] do |t, args|
-      require File.expand_path(File.join(File.dirname(__FILE__), "..", "new_relic", "agent", "configuration", "default_source.rb"))
-      format = args[:format] || "text"
+      require File.expand_path(File.join(File.dirname(__FILE__), '..', 'new_relic', 'agent', 'configuration', 'default_source.rb'))
+      format = args[:format] || 'text'
       output(format)
     end
   end

data/lib/tasks/coverage_report.rake

@@ -0,0 +1,28 @@
+# 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
+
+if ENV['CI']
+  namespace :coverage do
+    desc 'Collates all result sets generated by the different test runners'
+    task :report do
+      require 'simplecov'
+      require 'fileutils'
+
+      SimpleCov.coverage_dir('coverage_results')
+
+      SimpleCov.collate(Dir['*/coverage_*/.resultset.json']) do
+        formatter SimpleCov::Formatter::HTMLFormatter
+        refuse_coverage_drop
+      end
+
+      Dir['lib/coverage_{[!r][!e][!s][!u][!l][!t][!s]}*'].each { |dir| FileUtils.rm_rf(dir) }
+    end
+
+    desc 'Removes all coverage_* directories'
+    task :clear do
+      require 'fileutils'
+      Dir['lib/coverage_*'].each { |dir| FileUtils.rm_rf(dir) }
+    end
+  end
+end