newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/recipes/capistrano_legacy.rb

@@ -1,60 +1,57 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-make_notify_task = Proc.new do
-
-  namespace :newrelic do
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
+make_notify_task = proc do
+  namespace(:newrelic) do
     # on all deployments, notify New Relic
-    desc "Record a deployment in New Relic (newrelic.com)"
-    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
+    desc("Record a deployment in New Relic (newrelic.com)")
+    task(:notice_deployment, :roles => :app, :except => {:no_release => true}) do
       rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
 
       require 'new_relic/cli/command'
 
       begin
         # allow overrides to be defined for revision, description, changelog, appname, and user
-        rev         = fetch(:newrelic_revision)    if exists?(:newrelic_revision)
-        description = fetch(:newrelic_desc)        if exists?(:newrelic_desc)
-        changelog   = fetch(:newrelic_changelog)   if exists?(:newrelic_changelog)
-        appname     = fetch(:newrelic_appname)     if exists?(:newrelic_appname)
-        user        = fetch(:newrelic_user)        if exists?(:newrelic_user)
+        rev = fetch(:newrelic_revision) if exists?(:newrelic_revision)
+        description = fetch(:newrelic_desc) if exists?(:newrelic_desc)
+        changelog = fetch(:newrelic_changelog) if exists?(:newrelic_changelog)
+        appname = fetch(:newrelic_appname) if exists?(:newrelic_appname)
+        user = fetch(:newrelic_user) if exists?(:newrelic_user)
         license_key = fetch(:newrelic_license_key) if exists?(:newrelic_license_key)
 
         unless scm == :none
           changelog = lookup_changelog(changelog)
-          rev       = lookup_rev(rev)
+          rev = lookup_rev(rev)
         end
 
         new_revision = rev
         deploy_options = {
           :environment => rails_env,
-          :revision    => new_revision,
-          :changelog   => changelog,
+          :revision => new_revision,
+          :changelog => changelog,
           :description => description,
-          :appname     => appname,
-          :user        => user,
+          :appname => appname,
+          :user => user,
           :license_key => license_key
         }
 
-        logger.debug "Uploading deployment to New Relic"
-        deployment = NewRelic::Cli::Deployments.new deploy_options
+        logger.debug("Uploading deployment to New Relic")
+        deployment = NewRelic::Cli::Deployments.new(deploy_options)
         deployment.run
-        logger.info "Uploaded deployment information to New Relic"
-
+        logger.info("Uploaded deployment information to New Relic")
       rescue NewRelic::Cli::Command::CommandFailure => e
-        logger.info e.message
+        logger.info(e.message)
       rescue Capistrano::CommandError
-        logger.info "Unable to notify New Relic of the deployment... skipping"
+        logger.info("Unable to notify New Relic of the deployment... skipping")
       rescue => e
-        logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
+        logger.info("Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}")
       end
     end
 
     def lookup_changelog(changelog)
       if !changelog
-        logger.debug "Getting log of changes for New Relic Deployment details"
+        logger.debug("Getting log of changes for New Relic Deployment details")
         from_revision = source.next_revision(current_revision)
 
         if scm == :git
@@ -72,7 +69,7 @@ make_notify_task = Proc.new do
     def lookup_rev(rev)
       if rev.nil?
         rev = source.query_revision(source.head()) do |cmd|
-          logger.debug "executing locally: '#{cmd}'"
+          logger.debug("executing locally: '#{cmd}'")
           `#{cmd}`
         end
 

data/lib/new_relic/recipes/helpers/send_deployment.rb

@@ -0,0 +1,69 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module SendDeployment
+  def send_deployment_notification_to_newrelic
+    require 'new_relic/cli/command'
+    debug("Uploading deployment to New Relic")
+    NewRelic::Cli::Deployments.new(deploy_options).run
+    info("Uploaded deployment information to New Relic")
+  rescue NewRelic::Cli::Command::CommandFailure => e
+    info(e.message)
+  rescue => e
+    info("Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}")
+  end
+
+  private
+
+  def deploy_options
+    {
+      :environment => fetch_environment,
+      :revision => fetch_rev,
+      :changelog => fetch_changelog,
+      :description => fetch(:newrelic_desc),
+      :appname => fetch(:newrelic_appname),
+      :user => fetch(:newrelic_user),
+      :license_key => fetch(:newrelic_license_key)
+    }
+  end
+
+  def fetch_changelog
+    has_scm? ? fetch(:newrelic_changelog) : lookup_changelog
+  end
+
+  def fetch_environment
+    fetch(:newrelic_rails_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage, "production"))))
+  end
+
+  def fetch_rev
+    newrelic_rev = fetch(:newrelic_revision)
+    has_scm? && !newrelic_rev ? fetch(:current_revision) : newrelic_rev
+  end
+
+  def has_scm?
+    has_scm_from_plugin? || has_scm_from_config?
+  end
+
+  def has_scm_from_config?
+    defined?(scm) && !scm.nil? && scm != :none
+  end
+
+  def has_scm_from_plugin?
+    respond_to?(:scm_plugin_installed?) && scm_plugin_installed?
+  end
+
+  def lookup_changelog
+    previous_revision = fetch(:previous_revision)
+    current_revision = fetch(:current_revision)
+    return unless current_revision && previous_revision
+
+    debug("Retrieving changelog for New Relic Deployment details")
+
+    if Rake::Task.task_defined?("git:check")
+      log_command = "git --no-pager log --no-color --pretty=format:'  * %an: %s' " +
+        "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
+      `#{log_command}`
+    end
+  end
+end

data/lib/new_relic/recipes.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # When installed as a plugin, this is loaded automatically.
 #

data/lib/new_relic/supportability_helper.rb

@@ -1,17 +1,19 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module SupportabilityHelper
-
     API_SUPPORTABILITY_PREFIX = 'Supportability/API/'.freeze
 
     # pre-instantiate these strings as they may be used multiple times per
     # transaction, just to eke out a bit less performance hit
     #
     API_SUPPORTABILITY_METRICS = [
+      :insert_distributed_trace_headers,
+      :accept_distributed_trace_headers,
       :add_custom_attributes,
+      :add_custom_span_attributes,
       :add_instrumentation,
       :add_method_tracer,
       :add_transaction_tracer,
@@ -48,10 +50,11 @@ module NewRelic
       :shutdown,
       :start_segment,
       :trace,
+      :traced_thread,
       :trace_execution_scoped,
       :trace_execution_unscoped,
       :wrap
-    ].reduce({}) do |h,o|
+    ].reduce({}) do |h, o|
       h[o] = API_SUPPORTABILITY_PREFIX + o.to_s
       h
     end
@@ -59,10 +62,22 @@ module NewRelic
     def record_api_supportability_metric(method_name)
       agent = NewRelic::Agent.agent or return
       if metric = API_SUPPORTABILITY_METRICS[method_name]
-        agent.stats_engine.tl_record_unscoped_metrics metric, &:increment_count
+        agent.stats_engine.tl_record_unscoped_metrics(metric, &:increment_count)
       else
-        NewRelic::Agent.logger.debug "API supportability metric not found for :#{method_name}"
+        NewRelic::Agent.logger.debug("API supportability metric not found for :#{method_name}")
       end
     end
+
+    def valid_api_argument_class?(arg, name, klass)
+      return true if arg.is_a?(klass)
+
+      caller_location = caller_locations(1..1).first.label
+
+      message = "Bad argument passed to ##{caller_location}. " \
+        "Expected #{klass} for `#{name}` but got #{arg.class}"
+
+      NewRelic::Agent.logger.warn(message)
+      nil
+    end
   end
 end

data/lib/new_relic/traced_thread.rb

@@ -0,0 +1,35 @@
+# 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(*args, &block)
+      super(*args, &traced_block)
+    end
+
+    def create_traced_block(*args, &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, &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/rpm/blob/master/LICENSE for complete details.
-
+# 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 = 8
-    TINY  = 0
-
-    begin
-      require File.join(File.dirname(__FILE__), 'build')
-    rescue LoadError
-      BUILD = nil
-    end
+  module VERSION # :nodoc:
+    MAJOR = 8
+    MINOR = 13
+    TINY = 1
 
-    STRING = build_version_string(MAJOR, MINOR, TINY, BUILD)
+    STRING = "#{MAJOR}.#{MINOR}.#{TINY}"
   end
 end

data/lib/newrelic_rpm.rb

@@ -1,53 +1,29 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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)
-  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
 
-        initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
-          NewRelic::Control.instance.init_plugin(:config => app.config)
-        end
+if defined?(Rails::VERSION)
+  module NewRelic
+    class Railtie < Rails::Railtie
+      initializer "newrelic_rpm.start_plugin", before: :load_config_initializers do |app|
+        NewRelic::Control.instance.init_plugin(config: app.config)
       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

@@ -1,15 +1,14 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# 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
@@ -31,7 +30,6 @@ module Sequel
   # `disable_activerecord_instrumentation` setting.
   #
   module NewRelicInstrumentation
-
     module Naming
       def self.query_method_name
         if Sequel::VERSION >= "4.35.0"
@@ -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)
@@ -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,10 +81,10 @@ 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")
           nil
@@ -95,7 +93,6 @@ module Sequel
     end
   end # module NewRelicInstrumentation
 
-  NewRelic::Agent.logger.debug "Registering the :newrelic_instrumentation extension."
+  NewRelic::Agent.logger.debug("Registering the :newrelic_instrumentation extension.")
   Database.register_extension(:newrelic_instrumentation, NewRelicInstrumentation)
-
 end # module Sequel

data/lib/sequel/plugins/newrelic_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/rpm/blob/master/LICENSE for complete details.
+# 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
-
       # 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)
@@ -36,7 +34,6 @@ module Sequel
             end
           end
         end
-
       end # module MethodTracer
 
       # Methods to be added to Sequel::Model instances.
@@ -51,10 +48,8 @@ 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
@@ -64,7 +59,6 @@ module Sequel
         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/rpm/blob/master/LICENSE for complete details.
+# 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