newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -1,9 +1,9 @@
-# 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 'new_relic/agent/datastores/metric_helper'
-require 'new_relic/agent/deprecator'
+require 'new_relic/constants'
 
 module NewRelic
   module Agent
@@ -11,51 +11,123 @@ module NewRelic
       module ActiveRecordHelper
         module_function
 
-        ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
-        OTHER         = "other".freeze unless defined?(OTHER)
+        # Used by both the AR 3.x and 4.x instrumentation
+        def instrument_additional_methods
+          instrument_save_methods
+          instrument_relation_methods
+        end
 
-        def metrics_for(name, sql, adapter_name)
-          product   = map_product(adapter_name)
-          splits    = split_name(name)
-          model     = model_from_splits(splits)
-          operation = operation_from_splits(splits, sql)
+        def instrument_save_methods
+          ::ActiveRecord::Base.class_eval do
+            alias_method(:save_without_newrelic, :save)
+
+            def save(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic(*args, &blk)
+              end
+            end
 
-          NewRelic::Agent::Datastores::MetricHelper.metrics_for(product,
-                                                                operation,
-                                                                model)
+            alias_method(:save_without_newrelic!, :save!)
+
+            def save!(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                save_without_newrelic!(*args, &blk)
+              end
+            end
+          end
         end
 
-        # @deprecated
-        def rollup_metrics_for(*_)
-          NewRelic::Agent::Deprecator.deprecate("ActiveRecordHelper.rollup_metrics_for",
-                                                "NewRelic::Agent::Datastores::MetricHelper.metrics_for")
+        def instrument_relation_methods
+          ::ActiveRecord::Relation.class_eval do
+            alias_method(:update_all_without_newrelic, :update_all)
 
-          rollup_metric = if NewRelic::Agent::Transaction.recording_web_transaction?
-            NewRelic::Agent::Datastores::MetricHelper::WEB_ROLLUP_METRIC
-          else
-            NewRelic::Agent::Datastores::MetricHelper::OTHER_ROLLUP_METRIC
+            def update_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                update_all_without_newrelic(*args, &blk)
+              end
+            end
+
+            alias_method(:delete_all_without_newrelic, :delete_all)
+
+            if RUBY_VERSION < '2.7.0'
+              def delete_all(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  delete_all_without_newrelic(*args, &blk)
+                end
+              end
+            else
+              def delete_all(*args, **kwargs, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  delete_all_without_newrelic(*args, **kwargs, &blk)
+                end
+              end
+            end
+
+            alias_method(:destroy_all_without_newrelic, :destroy_all)
+
+            def destroy_all(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                destroy_all_without_newrelic(*args, &blk)
+              end
+            end
+
+            alias_method(:calculate_without_newrelic, :calculate)
+
+            def calculate(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                calculate_without_newrelic(*args, &blk)
+              end
+            end
+
+            if method_defined?(:pluck)
+              alias_method(:pluck_without_newrelic, :pluck)
+
+              def pluck(*args, &blk)
+                ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+                  pluck_without_newrelic(*args, &blk)
+                end
+              end
+
+            end
           end
+        end
+
+        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&.end_with?(MAKARA_SUFFIX)
 
-          [rollup_metric,
-           NewRelic::Agent::Datastores::MetricHelper::ROLLUP_METRIC]
+          adapter_name
         end
 
-        SPACE = ' '.freeze unless defined?(SPACE)
-        EMPTY = [].freeze unless defined?(EMPTY)
+        def product_operation_collection_for(name, sql, 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)
+          NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for(product, operation, model, ACTIVE_RECORD)
+        end
+
+        SPACE = ' '.freeze
 
         def split_name(name)
-          if name && name.respond_to?(:split)
+          if name&.respond_to?(:split)
             name.split(SPACE)
           else
-            EMPTY
+            NewRelic::EMPTY_ARRAY
           end
         end
 
         def model_from_splits(splits)
           if splits.length == 2
             splits.first
-          else
-            nil
           end
         end
 
@@ -71,17 +143,17 @@ module NewRelic
         # known operations coming in. Anything not matching the list is fine,
         # it just needs to get downcased directly for use.
         OPERATION_NAMES = {
-          'Find'    => 'find',
-          'Load'    => 'find',
-          'Count'   => 'find',
-          'Exists'  => 'find',
-          'Create'  => 'create',
+          'Find' => 'find',
+          'Load' => 'find',
+          'Count' => 'find',
+          'Exists' => 'find',
+          'Create' => 'create',
           'Columns' => 'columns',
           'Indexes' => 'indexes',
           'Destroy' => 'destroy',
-          'Update'  => 'update',
-          'Save'    => 'save'
-        }.freeze unless defined?(OPERATION_NAMES)
+          'Update' => 'update',
+          'Save' => 'save'
+        }.freeze
 
         def map_operation(raw_operation)
           direct_op = OPERATION_NAMES[raw_operation]
@@ -91,50 +163,139 @@ module NewRelic
         end
 
         PRODUCT_NAMES = {
-          "mysql"      => "MySQL",
-          "mysql2"     => "MySQL",
+          'mysql' => 'MySQL',
+          'mysql2' => 'MySQL',
 
-          "postgresql" => "Postgres",
+          'postgresql' => 'Postgres',
 
-          "sqlite3"    => "SQLite",
+          'sqlite3' => 'SQLite',
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
-          "jdbcmysql"  => "MySQL",
+          'jdbcmysql' => 'MySQL',
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
-          "jdbcpostgresql" => "Postgres",
+          'jdbcpostgresql' => 'Postgres',
+
+          # https://rubygems.org/gems/activerecord-postgis-adapter
+          'postgis' => 'Postgres',
 
           # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
-          "jdbcsqlite3"    => "SQLite",
+          'jdbcsqlite3' => 'SQLite',
 
           # https://rubygems.org/gems/activerecord-jdbcderby-adapter
-          "derby"      => "Derby",
-          "jdbcderby"  => "Derby",
+          'derby' => 'Derby',
+          'jdbcderby' => 'Derby',
 
           # https://rubygems.org/gems/activerecord-jdbc-adapter
-          "jdbc"       => "JDBC",
+          'jdbc' => 'JDBC',
 
           # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
-          "jdbcmssql"  => "MSSQL",
-          "mssql"      => "MSSQL",
+          'jdbcmssql' => 'MSSQL',
+          'mssql' => 'MSSQL',
 
           # https://rubygems.org/gems/activerecord-sqlserver-adapter
-          "sqlserver"  => "MSSQL",
+          'sqlserver' => 'MSSQL',
 
           # https://rubygems.org/gems/activerecord-odbc-adapter
-          "odbc"       => "ODBC",
+          'odbc' => 'ODBC',
 
           # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
-          "oracle_enhanced" => "Oracle"
-        }.freeze unless defined?(PRODUCT_NAMES)
+          'oracle_enhanced' => 'Oracle',
 
-        ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+          # https://rubygems.org/gems/activerecord-amazon-timestream-adapter
+          'amazon_timestream' => 'Timestream'
+        }.freeze
+
+        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
+          extend self
+
+          PRODUCT_SYMBOLS = {
+            'mysql' => :mysql,
+            'mysql2' => :mysql,
+            'jdbcmysql' => :mysql,
+
+            'postgresql' => :postgres,
+            'jdbcpostgresql' => :postgres,
+            'postgis' => :postgres
+          }.freeze
+
+          DATASTORE_DEFAULT_PORTS = {
+            :mysql => '3306',
+            :postgres => '5432'
+          }.freeze
+
+          DEFAULT = 'default'.freeze
+          UNKNOWN = 'unknown'.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 = adapter_from_config(config)
+            if configured_value.nil? ||
+                postgres_unix_domain_socket_case?(configured_value, adapter)
+
+              LOCALHOST
+            elsif configured_value.empty?
+              UNKNOWN
+            else
+              configured_value
+            end
+          rescue => e
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord host: #{e}")
+            UNKNOWN
+          end
+
+          def port_path_or_id(config)
+            return UNKNOWN unless config
+
+            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)
+              DEFAULT
+            elsif config[:port].nil?
+              DATASTORE_DEFAULT_PORTS[adapter] || DEFAULT
+            elsif config[:port].is_a?(Integer) || config[:port].to_i != 0
+              config[:port].to_s
+            else
+              UNKNOWN
+            end
+          rescue => e
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord port_path_or_id: #{e}")
+            UNKNOWN
+          end
+
+          SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze
+
+          def supported_adapter?(config)
+            config && SUPPORTED_ADAPTERS.include?(adapter_from_config(config))
+          end
+
+          private
+
+          def postgres_unix_domain_socket_case?(host, adapter)
+            adapter == :postgres && host && host.start_with?(NewRelic::SLASH)
+          end
+
+          def mysql_default_case?(config, adapter)
+            (adapter == :mysql2 || adapter == :mysql) &&
+              Hostname.local?(config[:host]) &&
+              !config[:port]
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,156 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/instrumentation/active_record_subscriber'
+require 'new_relic/agent/instrumentation/active_record_prepend'
+
+# Provides a way to send :connection through ActiveSupport notifications to avoid
+# looping through connection handlers to locate a connection by connection_id
+# This is not needed in Rails 6+: https://github.com/rails/rails/pull/34602
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordNotifications
+        SQL_ACTIVE_RECORD = 'sql.active_record'.freeze
+
+        module BaseExtensions4x
+          # https://github.com/rails/rails/blob/4-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L371
+          def log(sql, name = 'SQL', binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              :sql => sql,
+              :name => name,
+              :connection_id => object_id,
+              :connection => self,
+              :statement_name => statement_name,
+              :binds => binds
+            ) { yield }
+          rescue => e
+            # The translate_exception_class method got introduced in 4.1
+            if ::ActiveRecord::VERSION::MINOR == 0
+              raise translate_exception(e, sql)
+            else
+              raise translate_exception_class(e, sql)
+            end
+          end
+        end
+
+        module BaseExtensions50
+          # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L582
+          def log(sql, name = 'SQL', binds = [], type_casted_binds = [], statement_name = nil)
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              sql: sql,
+              name: name,
+              binds: binds,
+              type_casted_binds: type_casted_binds,
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) { yield }
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+
+        module BaseExtensions51
+          # https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L603
+          def log(sql, name = 'SQL', binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+            @instrumenter.instrument(
+              SQL_ACTIVE_RECORD,
+              sql: sql,
+              name: name,
+              binds: binds,
+              type_casted_binds: type_casted_binds,
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) do
+              @lock.synchronize do
+                yield
+              end
+            end
+          rescue => e
+            raise translate_exception_class(e, sql)
+          end
+        end
+      end
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :active_record_notifications
+
+  depends_on do
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      defined?(ActiveRecord::VERSION) &&
+      ActiveRecord::VERSION::MAJOR.to_i >= 4
+  end
+
+  depends_on do
+    !NewRelic::Agent.config[:disable_active_record_instrumentation] &&
+      !NewRelic::Agent.config[:disable_active_record_notifications] &&
+      !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
+  end
+
+  executes do
+    NewRelic::Agent.logger.info('Installing notifications based Active Record instrumentation')
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe('sql.active_record',
+      NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.new)
+  end
+
+  executes do
+    ActiveSupport.on_load(:active_record) do
+      NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ActiveRecord::Base,
+        ActiveRecord::Relation
+      )
+
+      # Default to .prepending, unless the ActiveRecord version is <=4
+      # **AND** the :prepend_active_record_instrumentation config is false
+      if ActiveRecord::VERSION::MAJOR > 4 \
+          || NewRelic::Agent.config[:prepend_active_record_instrumentation]
+
+        ActiveRecord::Base.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ActiveRecord::Relation.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+      else
+        NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+      end
+    end
+  end
+
+  executes do
+    if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
+      major_version = ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ActiveRecord::VERSION::MINOR.to_i
+
+      activerecord_extension = if major_version == 4
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+      elsif major_version == 5 && minor_version == 0
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+      elsif major_version == 5 && minor_version == 1
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+      end
+
+      unless activerecord_extension.nil?
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+      end
+    end
+  end
+
+  executes do
+    if ActiveRecord::VERSION::MAJOR == 5 \
+        && ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ActiveRecord::VERSION::TINY.to_i >= 6
+
+      ActiveRecord::Base.prepend(NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/prepend_supportability'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordPrepend
+        ACTIVE_RECORD = 'ActiveRecord'.freeze
+
+        module BaseExtensions
+          if RUBY_VERSION < '2.7.0'
+            def save(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+
+            def save!(*args, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+
+          else
+            def save(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+
+            def save!(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+
+          end
+        end
+
+        module BaseExtensions516
+          # In ActiveRecord v5.0.0 through v5.1.5, touch() will call
+          # update_all() and cause us to record a transaction.
+          # Starting in v5.1.6, this call no longer happens. We'll
+          # have to set the database metrics explicitly now.
+          #
+          if RUBY_VERSION < '2.7.0'
+            def touch(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+          else
+            def touch(*args, **kwargs, &blk)
+              ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
+                super
+              end
+            end
+          end
+        end
+
+        module RelationExtensions
+          def update_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+
+          def delete_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+
+          def destroy_all(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+
+          def calculate(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+
+          def pluck(*args, &blk)
+            ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end