newrelic_rpm 3.10.0.279 → 3.11.0.283

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

@@ -0,0 +1,85 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Datastores
+      module MetricHelper
+        ROLLUP_METRIC        = "Datastore/all".freeze
+        WEB_ROLLUP_METRIC    = "Datastore/allWeb".freeze
+        OTHER_ROLLUP_METRIC  = "Datastore/allOther".freeze
+        DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
+        OTHER = "Other".freeze
+
+        ALL = "all".freeze
+        ALL_WEB = "allWeb".freeze
+        ALL_OTHER = "allOther".freeze
+
+        def self.statement_metric_for(product, collection, operation)
+          "Datastore/statement/#{product}/#{collection}/#{operation}"
+        end
+
+        def self.operation_metric_for(product, operation)
+          "Datastore/operation/#{product}/#{operation}"
+        end
+
+        def self.product_suffixed_rollup(product, suffix)
+          "Datastore/#{product}/#{suffix}"
+        end
+
+        def self.product_rollup(product)
+          "Datastore/#{product}/all"
+        end
+
+        def self.suffixed_rollup(suffix)
+          "Datastore/#{suffix}"
+        end
+
+        def self.all_suffix
+          if NewRelic::Agent::Transaction.recording_web_transaction?
+            ALL_WEB
+          else
+            ALL_OTHER
+          end
+        end
+
+        def self.metrics_for(product, operation, collection = nil)
+          if overrides = overridden_operation_and_collection
+            operation, collection = overrides
+          end
+
+          suffix = all_suffix
+
+          # Order of these metrics matters--the first metric in the list will
+          # be treated as the scoped metric in a bunch of different cases.
+          metrics = [
+            operation_metric_for(product, operation),
+            product_suffixed_rollup(product, suffix),
+            product_rollup(product),
+            suffixed_rollup(suffix),
+            ROLLUP_METRIC
+          ]
+
+          metrics.unshift statement_metric_for(product, collection, operation) if collection
+
+          metrics
+        end
+
+        def self.metrics_from_sql(product, sql)
+          operation = NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
+          metrics_for(product, operation)
+        end
+
+        # Allow Transaction#with_database_metric_name to override our
+        # collection and operation
+        def self.overridden_operation_and_collection #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+          txn   = state.current_transaction
+          txn ? txn.instrumentation_state[:datastore_override] : nil
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/datastores/mongo/metric_translator.rb

@@ -3,13 +3,14 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/agent/datastores/mongo/obfuscator'
+require 'new_relic/agent/datastores/metric_helper'
 
 module NewRelic
   module Agent
     module Datastores
       module Mongo
         module MetricTranslator
-          def self.metrics_for(name, payload, request_type = :web)
+          def self.metrics_for(name, payload)
             payload ||= {}
 
             if collection_in_selector?(payload)
@@ -50,28 +51,18 @@ module NewRelic
               collection = collection_name_from_rename_selector(payload)
             end
 
-            build_metrics(name, collection, request_type)
+            build_metrics(name, collection)
+          rescue => e
+            NewRelic::Agent.logger.debug("Failure during Mongo metric generation", e)
+            []
           end
 
-          def self.build_metrics(name, collection, request_type = :web)
-            default_metrics = [
-              "Datastore/statement/MongoDB/#{collection}/#{name}",
-              "Datastore/operation/MongoDB/#{name}",
-              "Datastore/all"
-            ]
+          MONGO_PRODUCT_NAME = "MongoDB".freeze
 
-            if request_type == :web
-              default_metrics << 'ActiveRecord/all'
-              default_metrics << 'Datastore/allWeb'
-            else
-              default_metrics << 'Datastore/allOther'
-            end
-
-            default_metrics
-          end
-
-          def self.instance_metric(host, port, database)
-            "Datastore/instance/MongoDB/#{host}:#{port}/#{database}"
+          def self.build_metrics(name, collection)
+            NewRelic::Agent::Datastores::MetricHelper.metrics_for(MONGO_PRODUCT_NAME,
+                                                                  name,
+                                                                  collection)
           end
 
           def self.collection_in_selector?(payload)

data/lib/new_relic/agent/deprecator.rb

@@ -0,0 +1,18 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module Deprecator
+      def self.deprecate(method_name, new_method_name = nil, version = nil)
+        msgs = ["The method #{method_name} is deprecated."]
+        msgs << "It will be removed in version #{version}." if version
+        msgs << "Please use #{new_method_name} instead." if new_method_name
+
+        NewRelic::Agent.logger.log_once(:warn, "deprecated_#{method_name}".to_sym, msgs)
+        NewRelic::Agent.record_metric("Supportability/Deprecated/#{method_name}", 1)
+      end
+    end
+  end
+end

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

@@ -20,15 +20,6 @@ module NewRelic
           ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
             include ::NewRelic::Agent::Instrumentation::ActiveRecord
           end
-
-          ::ActiveRecord::Base.class_eval do
-            class << self
-              add_method_tracer(:find_by_sql, 'ActiveRecord/#{self.name}/find_by_sql',
-                                :metric => false)
-              add_method_tracer(:transaction, 'ActiveRecord/#{self.name}/transaction',
-                                :metric => false)
-            end
-          end
         end
 
         def self.included(instrumented_class)
@@ -49,35 +40,29 @@ module NewRelic
           end
 
           sql, name, _ = args
-          metric = ActiveRecordHelper.metric_for_name(NewRelic::Helper.correctly_encoded(name)) ||
-            ActiveRecordHelper.metric_for_sql(NewRelic::Helper.correctly_encoded(sql))
+          metrics = ActiveRecordHelper.metrics_for(
+            NewRelic::Helper.correctly_encoded(name),
+            NewRelic::Helper.correctly_encoded(sql),
+            @config && @config[:adapter])
 
-          if !metric
-            log_without_newrelic_instrumentation(*args, &block)
-          else
-            metrics = [metric, remote_service_metric].compact
-            metrics += ActiveRecordHelper.rollup_metrics_for(metric)
-            self.class.trace_execution_scoped(metrics) do
-              t0 = Time.now
-              begin
-                log_without_newrelic_instrumentation(*args, &block)
-              ensure
-                elapsed_time = (Time.now - t0).to_f
+          # It is critical that we grab this name before trace_execution_scoped
+          # because that method mutates the metrics list passed in.
+          scoped_metric = metrics.first
 
-                NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
-                                                      @config, elapsed_time,
-                                                      state, &EXPLAINER)
-                NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric,
-                                                      @config, elapsed_time,
-                                                      state, &EXPLAINER)
-              end
-            end
-          end
-        end
+          NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
+            t0 = Time.now
+            begin
+              log_without_newrelic_instrumentation(*args, &block)
+            ensure
+              elapsed_time = (Time.now - t0).to_f
 
-        def remote_service_metric
-          if @config && @config[:adapter]
-            ActiveRecordHelper.remote_service_metric(@config[:adapter], @config[:host])
+              NewRelic::Agent.instance.transaction_sampler.notice_sql(sql,
+                                                    @config, elapsed_time,
+                                                    state, &EXPLAINER)
+              NewRelic::Agent.instance.sql_sampler.notice_sql(sql, scoped_metric,
+                                                    @config, elapsed_time,
+                                                    state, &EXPLAINER)
+            end
           end
         end
       end

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

@@ -1,81 +1,140 @@
 # 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.
+
+require 'new_relic/agent/datastores/metric_helper'
+require 'new_relic/agent/deprecator'
+
 module NewRelic
   module Agent
     module Instrumentation
       module ActiveRecordHelper
         module_function
 
-        def metric_for_name(name)
-          return unless name && name.respond_to?(:split)
-          parts = name.split(' ')
-          if parts.size == 2
-            model = parts.first
-            operation = parts.last.downcase
-            case operation
-            when 'load', 'count', 'exists'
-              op_name = 'find'
-            when 'indexes', 'columns'
-              op_name = nil # fall back to DirectSQL
-            when 'destroy', 'find', 'save', 'create'
-              op_name = operation
-            when 'update'
-              op_name = 'save'
-            else
-              if model == 'Join'
-                op_name = operation
-              end
-            end
-            "ActiveRecord/#{model}/#{op_name}" if op_name
+        ACTIVE_RECORD = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD)
+        OTHER         = "other".freeze unless defined?(OTHER)
+
+        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)
+
+          NewRelic::Agent::Datastores::MetricHelper.metrics_for(product,
+                                                                operation,
+                                                                model)
+        end
+
+        # @deprecated
+        def rollup_metrics_for(*_)
+          NewRelic::Agent::Deprecator.deprecate("#{self.class}.rollup_metrics_for",
+                                                "NewRelic::Agent::Datastores::MetricHelper.metrics_for")
+
+          rollup_metric = if NewRelic::Agent::Transaction.recording_web_transaction?
+            NewRelic::Agent::Datastores::MetricHelper::WEB_ROLLUP_METRIC
+          else
+            NewRelic::Agent::Datastores::MetricHelper::OTHER_ROLLUP_METRIC
+          end
+
+          [rollup_metric,
+           NewRelic::Agent::Datastores::MetricHelper::ROLLUP_METRIC]
+        end
+
+        SPACE = ' '.freeze unless defined?(SPACE)
+        EMPTY = [].freeze unless defined?(EMPTY)
+
+        def split_name(name)
+          if name && name.respond_to?(:split)
+            name.split(SPACE)
+          else
+            EMPTY
           end
         end
 
-        def metric_for_sql(sql) #THREAD_LOCAL_ACCESS
-          txn = NewRelic::Agent::Transaction.tl_current
-          metric = txn && txn.database_metric_name
-          if metric.nil?
-            operation = NewRelic::Agent::Database.parse_operation_from_query(sql)
-            if operation
-              # Could not determine the model/operation so use a fallback metric
-              metric = "Database/SQL/#{operation}"
-            else
-              metric = "Database/SQL/other"
-            end
+        def model_from_splits(splits)
+          if splits.length == 2
+            splits.first
+          else
+            nil
           end
-          metric
         end
 
-        # Given a metric name such as "ActiveRecord/model/action" this
-        # returns an array of rollup metrics:
-        # [ "Datastore/all", "ActiveRecord/all", "ActiveRecord/action" ]
-        # If the metric name is in the form of "ActiveRecord/action"
-        # this returns merely: [ "Datastore/all", "ActiveRecord/all" ]
-        def rollup_metrics_for(metric)
-          metrics = ["Datastore/all"]
-
-          # If we're outside of a web transaction, don't record any rollup
-          # database metrics. This is to prevent metrics from background tasks
-          # from polluting the metrics used to drive overview graphs.
-          if NewRelic::Agent::Transaction.recording_web_transaction?
-            metrics << "ActiveRecord/all"
+        def operation_from_splits(splits, sql)
+          if splits.length == 2
+            map_operation(splits[1])
           else
-            metrics << "Datastore/allOther"
+            NewRelic::Agent::Database.parse_operation_from_query(sql) || OTHER
           end
-          metrics << "ActiveRecord/#{$1}" if metric =~ /ActiveRecord\/[\w|\:]+\/(\w+)/
+        end
 
-          metrics
+        # These are used primarily to optimize and avoid allocation on well
+        # 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',
+          'Columns' => 'columns',
+          'Indexes' => 'indexes',
+          'Destroy' => 'destroy',
+          'Update'  => 'update',
+          'Save'    => 'save'
+        }.freeze unless defined?(OPERATION_NAMES)
+
+        def map_operation(raw_operation)
+          direct_op = OPERATION_NAMES[raw_operation]
+          return direct_op if direct_op
+
+          raw_operation.downcase
         end
 
-        # Given a database adapter name and a database server host
-        # this returns a metric name in the form:
-        # "RemoteService/sql/adapter/host"
-        # Host defaults to "localhost".
-        def remote_service_metric(adapter, host)
-          host ||= 'localhost'
-          type = adapter.to_s.sub(/\d*/, '')
-          "RemoteService/sql/#{type}/#{host}"
+        PRODUCT_NAMES = {
+          "mysql"      => "MySQL",
+          "mysql2"     => "MySQL",
+
+          "postgresql" => "Postgres",
+
+          "sqlite3"    => "SQLite",
+
+          # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+          "jdbcmysql"  => "MySQL",
+
+          # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+          "jdbcpostgresql" => "Postgres",
+
+          # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
+          "jdbcsqlite3"    => "SQLite",
+
+          # https://rubygems.org/gems/activerecord-jdbcderby-adapter
+          "derby"      => "Derby",
+          "jdbcderby"  => "Derby",
+
+          # https://rubygems.org/gems/activerecord-jdbc-adapter
+          "jdbc"       => "JDBC",
+
+          # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
+          "jdbcmssql"  => "MSSQL",
+          "mssql"      => "MSSQL",
+
+          # https://rubygems.org/gems/activerecord-sqlserver-adapter
+          "sqlserver"  => "MSSQL",
+
+          # https://rubygems.org/gems/activerecord-odbc-adapter
+          "odbc"       => "ODBC",
+
+          # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
+          "oracle_enhanced" => "Oracle"
+        }.freeze unless defined?(PRODUCT_NAMES)
+
+        ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze unless defined?(ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+
+        def map_product(adapter_name)
+          PRODUCT_NAMES.fetch(adapter_name,
+                              ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
         end
+
       end
     end
   end

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

@@ -25,9 +25,10 @@ module NewRelic
           return if payload[:name] == CACHED_QUERY_NAME
           state = NewRelic::Agent::TransactionState.tl_get
           return unless state.is_execution_traced?
-          event = pop_event(id)
-          record_metrics(event)
-          notice_sql(state, event)
+          event  = pop_event(id)
+          config = active_record_config_for_event(event)
+          base_metric = record_metrics(event, config)
+          notice_sql(state, event, config, base_metric)
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -42,10 +43,8 @@ module NewRelic
           end
         end
 
-        def notice_sql(state, event)
+        def notice_sql(state, event, config, metric)
           stack  = state.traced_method_stack
-          config = active_record_config_for_event(event)
-          metric = base_metric(event)
 
           # enter transaction trace segment
           frame = stack.push_frame(state, :active_record, event.time)
@@ -64,24 +63,16 @@ module NewRelic
           stack.pop_frame(state, frame, metric, event.end)
         end
 
-        def record_metrics(event) #THREAD_LOCAL_ACCESS
-          base = base_metric(event)
-
-          other_metrics = ActiveRecordHelper.rollup_metrics_for(base)
-          if config = active_record_config_for_event(event)
-            other_metrics << ActiveRecordHelper.remote_service_metric(config[:adapter], config[:host])
-          end
-          other_metrics.compact!
+        def record_metrics(event, config) #THREAD_LOCAL_ACCESS
+          base, *other_metrics = ActiveRecordHelper.metrics_for(event.payload[:name],
+                                                               NewRelic::Helper.correctly_encoded(event.payload[:sql]),
+                                                               config && config[:adapter])
 
           NewRelic::Agent.instance.stats_engine.tl_record_scoped_and_unscoped_metrics(
             base, other_metrics,
-            Helper.milliseconds_to_seconds(event.duration)
-          )
-        end
+            Helper.milliseconds_to_seconds(event.duration))
 
-        def base_metric(event)
-          ActiveRecordHelper.metric_for_name(event.payload[:name]) ||
-            ActiveRecordHelper.metric_for_sql(NewRelic::Helper.correctly_encoded(event.payload[:sql]))
+          base
         end
 
         def active_record_config_for_event(event)