newrelic_rpm 3.16.3.323 → 3.17.0.325

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8454965d0e8d1a99e35caacd91984db198aa5d7
-  data.tar.gz: 830bcd499e25cf38ee804c656788b29201510b6e
+  metadata.gz: 7d92e44197eda26fe761484451437f731e71bbb1
+  data.tar.gz: f1c0e0554ed45e78c7d42b6617a1c98dbb7a3d3f
 SHA512:
-  metadata.gz: 4c62be289b6de4579c011a88fce9777cbd97f1fb3a4c14a0d6accfc9ef377d58520fd8fb3b256298f3d3615e19cc361f92af7e3d730d3b9de30938ffa019dc5f
-  data.tar.gz: 989d62082b606f370a55e9a898ae4b28ae1ddec04ad1c75ecff2a2ab77afde56da330523c5f2be566ae080a7eb5e7c091a41b26f881b95dadd99e72bee51cb41
+  metadata.gz: 92827c74e5109b6d2fd3ba456af3af0d410328b8ff5224a9ee4858e8139fa328cb5128d2fc43c316bca415b5366dca59f691473222c28c620e000c08bd17a79d
+  data.tar.gz: be6bd6121731993cd243c607d21a0eabab546c74c106bcf4a7a37da66a471d68311e5b67df6ca4301a07a0e7253cf20c6aeb4fb32859c34889224e77f26a088b

data/CHANGELOG

@@ -1,5 +1,13 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.17.0 ##
+
+  * Datastore instance reporting for ActiveRecord
+
+  The agent now collects database instance information for ActiveRecord operations,
+  when using the MySQL and Postgres adapters.  This information (database server
+  and database name) is displayed in transaction traces and slow query traces.
+
 ## v3.16.3 ##
 
   * Add `:trace_only` option to `notice_error` API

data/README.md

@@ -78,9 +78,11 @@ edit `environment.rb` and add to the initalizer block:
 
 #### Sinatra Installation
 
-To use the Ruby Agent with a Sinatra app, add
+To use the Ruby Agent with a Sinatra app, add:
 
-    require 'newrelic_rpm'
+```ruby
+require 'newrelic_rpm'
+```
 
 in your Sinatra app, below the Sinatra require directive.
 
@@ -93,13 +95,17 @@ the middleware stack.  See the `config.ru` sample below.
 
 #### Other Environments
 
-You can use the Ruby Agent to monitor any Ruby application.  Add
+You can use the Ruby Agent to monitor any Ruby application. Add:
 
-    require 'newrelic_rpm'
+```ruby
+require 'newrelic_rpm'
+```
 
-to your startup sequence and then manually start the agent using
+to your startup sequence and then manually start the agent using:
 
-    NewRelic::Agent.manual_start
+```ruby
+NewRelic::Agent.manual_start
+```
 
 For information about instrumenting pure Rack applications, see our
 [Rack middlewares documentation](http://docs.newrelic.com/docs/ruby/rack-middlewares).

data/lib/new_relic/agent/audit_logger.rb

@@ -40,7 +40,7 @@ module NewRelic
       rescue StandardError, SystemStackError, SystemCallError => e
         ::NewRelic::Agent.logger.warn("Failed writing to audit log", e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interupt.", e)
+        ::NewRelic::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interrupt.", e)
         raise
       end
 

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

@@ -356,7 +356,7 @@ module NewRelic
           :public => true,
           :type => Boolean,
           :allowed_from_server => false,
-          :description => 'When <code>true</code>, the agent captures HTTP request parameters and attaches them to transaction traces and traced errors.'
+          :description => 'When <code>true</code>, the agent captures HTTP request parameters and attaches them to transaction traces, traced errors, and <a href="https://docs.newrelic.com/docs/insights/new-relic-insights/decorating-events/error-event-default-attributes-insights">TransactionError events</a>.'
         },
         :config_path => {
           :default => DefaultSource.config_path,
@@ -1602,6 +1602,20 @@ module NewRelic
           :type        => Fixnum,
           :allowed_from_server => false,
           :description => 'This value represents the total amount of memory available to the host (not the process), in mebibytes (1024 squared or 1,048,576 bytes).'
+        },
+        :'datastore_tracer.instance_reporting.enabled' => {
+          :default     => true,
+          :public      => true,
+          :type        => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>false</code>, the agent will not report datastore instance metrics, nor add <code>host</code> or <code>port_path_or_id</code> parameters to transaction or slow sql traces.'
+        },
+        :'datastore_tracer.database_name_reporting.enabled' => {
+          :default     => true,
+          :public      => true,
+          :type        => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>false</code>, the agent will not add <code>database_name</code> parameter to transaction or slow sql traces.'
         }
       }.freeze
     end

data/lib/new_relic/agent/database.rb

@@ -181,16 +181,19 @@ module NewRelic
       class Statement
         include ExplainPlanHelpers
 
-        attr_accessor :sql, :config, :explainer, :binds, :name
+        attr_accessor :sql, :config, :explainer, :binds, :name, :host, :port_path_or_id, :database_name
 
         DEFAULT_QUERY_NAME = "SQL".freeze
 
-        def initialize(sql, config={}, explainer=nil, binds=nil, name=DEFAULT_QUERY_NAME)
+        def initialize(sql, config={}, explainer=nil, binds=nil, name=DEFAULT_QUERY_NAME, host=nil, port_path_or_id=nil, database_name=nil)
           @sql = Database.capture_query(sql)
           @config = config
           @explainer = explainer
           @binds = binds
           @name = name
+          @host = host
+          @port_path_or_id = port_path_or_id
+          @database_name = database_name
         end
 
         # This takes a connection config hash from ActiveRecord or Sequel and

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

@@ -24,6 +24,10 @@ module NewRelic
           "Datastore/operation/#{product}/#{operation}"
         end
 
+        def self.instance_metric_for(product, host, port_path_or_id)
+          "Datastore/instance/#{product}/#{host}/#{port_path_or_id}"
+        end
+
         def self.product_suffixed_rollup(product, suffix)
           "Datastore/#{product}/#{suffix}"
         end
@@ -52,7 +56,7 @@ module NewRelic
           end
         end
 
-        def self.unscoped_metrics_for product, operation, collection=nil
+        def self.unscoped_metrics_for product, operation, collection=nil, host=nil, port_path_or_id=nil
           suffix = all_suffix
 
           metrics = [
@@ -62,6 +66,9 @@ module NewRelic
             ROLLUP_METRIC
           ]
 
+          if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled'] && host && port_path_or_id
+            metrics.unshift instance_metric_for(product, host, port_path_or_id)
+          end
           metrics.unshift operation_metric_for(product, operation) if collection
 
           metrics

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

@@ -50,7 +50,21 @@ module NewRelic
             NewRelic::Helper.correctly_encoded(sql),
             @config && @config[:adapter])
 
-          segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation, collection)
+          host = nil
+          port_path_or_id = nil
+          database = nil
+
+          if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
+            if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
+              host = ActiveRecordHelper::InstanceIdentification.host(@config)
+              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
+            end
+            if NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
+              database = @config && @config[:database]
+            end
+          end
+
+          segment = NewRelic::Agent::Transaction.start_datastore_segment(product, operation, collection, host, port_path_or_id, database)
           segment._notice_sql(sql, @config, EXPLAINER)
 
           begin

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

@@ -204,6 +204,89 @@ module NewRelic
                               ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
         end
 
+        module InstanceIdentification
+          extend self
+
+          LOCALHOST = %w[
+            localhost
+            0.0.0.0
+            127.0.0.1
+            0:0:0:0:0:0:0:1
+            0:0:0:0:0:0:0:0
+            ::1
+            ::
+          ].freeze unless defined?(LOCALHOST)
+
+          PRODUCT_SYMBOLS = {
+            "mysql"      => :mysql,
+            "mysql2"     => :mysql,
+            "jdbcmysql"  => :mysql,
+
+            "postgresql"     => :postgres,
+            "jdbcpostgresql" => :postgres
+          }.freeze unless defined?(PRODUCT_SYMBOLS)
+
+          DATASTORE_DEFAULT_PORTS = {
+            :mysql    => "3306",
+            :postgres => "5432"
+          }.freeze unless defined?(DATASTORE_DEFAULT_PORTS)
+
+          DEFAULT = "default".freeze unless defined?(DEFAULT)
+          UNKNOWN = "unknown".freeze unless defined?(UNKNOWN)
+          SLASH = "/".freeze unless defined?(SLASH)
+
+          def host(config)
+            return UNKNOWN unless config
+
+            configured_value  = config[:host]
+            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            if configured_value.nil? ||
+              LOCALHOST.include?(configured_value) ||
+              postgres_unix_domain_socket_case?(configured_value, adapter)
+
+              Hostname.get
+            elsif configured_value.empty?
+              UNKNOWN
+            else
+              configured_value
+            end
+          end
+
+          def port_path_or_id(config)
+            return UNKNOWN unless config
+
+            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            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?(Fixnum) || config[:port].to_i != 0
+              config[:port].to_s
+            else
+              UNKNOWN
+            end
+          end
+
+          SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze unless defined?(SUPPORTED_ADAPTERS)
+
+          def supported_adapter? config
+            config && SUPPORTED_ADAPTERS.include?(PRODUCT_SYMBOLS[config[:adapter]])
+          end
+
+          private
+
+          def postgres_unix_domain_socket_case?(host, adapter)
+            adapter == :postgres && host && host.start_with?(SLASH)
+          end
+
+          def mysql_default_case?(config, adapter)
+            (adapter == :mysql2 || adapter == :mysql) &&
+              LOCALHOST.include?(config[:host]) &&
+              !config[:port]
+          end
+        end
       end
     end
   end

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

@@ -85,7 +85,22 @@ module NewRelic
           def start_segment
             product, operation, collection = ActiveRecordHelper.product_operation_collection_for(payload[:name],
                                               sql, @config && @config[:adapter])
-            segment = NewRelic::Agent::Transaction::DatastoreSegment.new product, operation, collection
+
+            host = nil
+            port_path_or_id = nil
+            database = nil
+
+            if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
+              if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
+                host = ActiveRecordHelper::InstanceIdentification.host(@config)
+                port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
+              end
+              if NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
+                database = @config && @config[:database]
+              end
+            end
+
+            segment = NewRelic::Agent::Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database
             if txn = state.current_transaction
               segment.transaction = txn
             end

data/lib/new_relic/agent/sql_sampler.rb

@@ -236,6 +236,20 @@ module NewRelic
         statement.sql
       end
 
+      def base_params
+        params = {}
+
+        if NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
+          params[:host] = statement.host if statement.host
+          params[:port_path_or_id] = statement.port_path_or_id if statement.port_path_or_id
+        end
+        if NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled'] && statement.database_name
+          params[:database_name] = statement.database_name
+        end
+
+        params
+      end
+
       def obfuscate
         NewRelic::Agent::Database.obfuscate_sql(statement)
       end
@@ -268,7 +282,7 @@ module NewRelic
 
       def initialize(normalized_query, slow_sql, path, uri)
         super()
-        @params = {}
+        @params = slow_sql.base_params
         @sql_id = consistent_hash(normalized_query)
         set_primary slow_sql, path, uri
         record_data_point(float(slow_sql.duration))

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -15,7 +15,7 @@ module NewRelic
             rescue => e
               ::NewRelic::Agent.logger.error("Thread #{label} exited with error", e)
             rescue Exception => e
-              ::NewRelic::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interupt.", e)
+              ::NewRelic::Agent.logger.error("Thread #{label} exited with exception. Re-raising in case of interrupt.", e)
               raise
             ensure
               ::NewRelic::Agent.logger.debug("Exiting New Relic thread: #{label}")

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

@@ -10,15 +10,18 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-        attr_reader :product, :operation, :collection, :sql_statement
+        attr_reader :product, :operation, :collection, :sql_statement, :host, :port_path_or_id, :database_name
 
-        def initialize product, operation, collection = nil
+        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name=nil
           @product = product
           @operation = operation
           @collection = collection
           @sql_statement = nil
+          @host = host
+          @port_path_or_id = port_path_or_id
+          @database_name = database_name
           super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
-                Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection)
+                Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
         end
 
         def notice_sql sql
@@ -28,14 +31,38 @@ module NewRelic
         # @api private
         def _notice_sql sql, config=nil, explainer=nil, binds=nil, name=nil
           return unless record_sql?
-          @sql_statement = Database::Statement.new sql, config, explainer, binds, name
+          @sql_statement = Database::Statement.new sql, config, explainer, binds, name, host, port_path_or_id, database_name
         end
 
         private
 
         def segment_complete
-          return unless sql_statement
+          add_segment_parameters
+          notice_sql_statement if sql_statement
+        end
+
+        def add_segment_parameters
+          instance_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
+          db_name_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
+          return unless instance_reporting_enabled || db_name_reporting_enabled
+
+          params = {}
+          add_instance_parameters params if instance_reporting_enabled
+          add_database_name_parameter params if db_name_reporting_enabled
+
+          NewRelic::Agent.instance.transaction_sampler.add_node_parameters params
+        end
+
+        def add_instance_parameters params
+          params[:host] = host if host
+          params[:port_path_or_id] = port_path_or_id if port_path_or_id
+        end
+
+        def add_database_name_parameter(params)
+          params[:database_name] = database_name if database_name
+        end
 
+        def notice_sql_statement
           NewRelic::Agent.instance.transaction_sampler.notice_sql_statement(sql_statement, duration)
           NewRelic::Agent.instance.sql_sampler.notice_sql_statement(sql_statement.dup, name, duration)
         end

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

@@ -17,8 +17,8 @@ module NewRelic
             segment
           end
 
-          def start_datastore_segment product, operation, collection=nil
-            segment = DatastoreSegment.new product, operation, collection
+          def start_datastore_segment product, operation, collection=nil, host=nil, port_path_or_id=nil, database_name=nil
+            segment = DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
             segment.start
             add_segment segment
             segment

data/lib/new_relic/version.rb

@@ -11,8 +11,8 @@ module NewRelic
     end
 
     MAJOR = 3
-    MINOR = 16
-    TINY  = 3
+    MINOR = 17
+    TINY  = 0
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/test/environments/rails40/Gemfile

@@ -22,7 +22,7 @@ end
 # us from inadvertently loading minitest 5.3.0 on rbx (we'll require
 # minitest/unit instead via a different path).
 gem 'minitest', '~>4.7.5', :require => false
-gem 'mocha', :require => false
+gem 'mocha', '1.1', :require => false
 gem 'rack', '< 2.0.0'
 gem 'rack-test'
 

data/test/environments/rails41/Gemfile

@@ -14,7 +14,7 @@ elsif RUBY_VERSION < '2'
 end
 
 gem 'minitest', '5.2.3'
-gem 'mocha', :require => false
+gem 'mocha', '1.1', :require => false
 gem 'rack', '< 2.0.0'
 gem 'rack-test'
 

data/test/environments/rails42/Gemfile

@@ -14,7 +14,7 @@ elsif RUBY_VERSION < '2'
 end
 
 gem 'minitest', '5.2.3'
-gem 'mocha', :require => false
+gem 'mocha', '1.1', :require => false
 gem 'rack', '< 2.0.0'
 gem 'rack-test'
 

data/test/environments/rails50/Gemfile

@@ -5,7 +5,7 @@ gem 'rake', '< 11'
 gem 'rails', '5.0.0'
 
 gem 'minitest', '5.2.3'
-gem 'mocha', :require => false
+gem 'mocha', '1.1', :require => false
 gem 'rack'
 gem 'rack-test'
 

data/test/fixtures/cross_agent_tests/datastores/README.md

@@ -0,0 +1,16 @@
+## Datastore instance tests
+
+The datastore instance tests provide attributes similar to what an agent could expect to find regarding a database configuration and specifies the expected [datastore instance metric](https://source.datanerd.us/agents/agent-specs/blob/master/Datastore-Metrics-PORTED.md#datastore-metric-namespace) that should be generated. The table below lists types attributes and whether will will always be included or optionally included in each test case.
+
+| Name | Present | Description |
+|---|---|---|
+| system_hostname | always | the hostname of the machine |
+| db_hostname | sometimes | the hostname reported by the database adapter |
+| product | always | the database product for this configuration
+| port | sometimes | the port reported by the database adapter |
+| unix_socket | sometimes |the path to a unix domain socket reported by a database adapter |
+| db_path | sometimes |the path to a filesystem database |
+| expected\_instance\_metric | always | the instance metric expected to be generated from the given attributes |
+
+## Implementing the test cases
+The idea behind these test cases are that you are able to determine a set of configuration properties from a database connection, and based on those properties you should generate the `expected_instance_metric`. Sometimes the properties available are minimal and will mean that you will need to fall back to defaults to obtain some of the information. When there is missing information from a database adapter the guiding principle is to fill in the defaults when they can be inferred, but do not make guesses that could be incorrect or misleading. Some agents may have access to better data and may not need to make inferences. If this applies to your agent then many of these tests will not be applicable.

data/test/fixtures/cross_agent_tests/datastores/datastore_instances.json

@@ -0,0 +1,120 @@
+[
+  {
+    "name": "instance metric uses system hostname when db reports localhost",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "localhost",
+    "product": "Postgres",
+    "port": 5432,
+    "expected_instance_metric": "Datastore/instance/Postgres/datanerd-01/5432"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports host as loopback adapter IPv4",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "127.0.0.1",
+    "product": "Postgres",
+    "port": 5252,
+    "expected_instance_metric": "Datastore/instance/Postgres/datanerd-01/5252"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports host as loopback adapter IPv6",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "0:0:0:0:0:0:0:1",
+    "product": "Postgres",
+    "port": 5252,
+    "expected_instance_metric": "Datastore/instance/Postgres/datanerd-01/5252"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports host as loopback adapter IPv6 shorthand",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "::1",
+    "product": "Postgres",
+    "port": 5252,
+    "expected_instance_metric": "Datastore/instance/Postgres/datanerd-01/5252"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports default host IPv4",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "0.0.0.0",
+    "product": "MySQL",
+    "port": 3600,
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/3600"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports default host IPv6",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "0:0:0:0:0:0:0:0",
+    "product": "MySQL",
+    "port": 5757,
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/5757"
+  },
+  {
+    "name": "instance metric uses system hostname when db reports default host IPv6 shorthand",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "::",
+    "product": "MySQL",
+    "port": 5757,
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/5757"
+  },
+  {
+    "name": "instance metric uses db host when not local",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "accounts-db",
+    "product": "MySQL",
+    "port": 8420,
+    "expected_instance_metric": "Datastore/instance/MySQL/accounts-db/8420"
+  },
+  {
+    "name": "detects default UDS case",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "localhost",
+    "product": "MySQL",
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/default"
+  },
+  {
+    "name": "instance metric uses unix socket path if provided",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "localhost",
+    "product": "MySQL",
+    "unix_socket": "/var/mysql/mysql.sock",
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01//var/mysql/mysql.sock"
+  },
+  {
+    "name": "instance metric reports unknown if host empty",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "",
+    "product": "MySQL",
+    "port": 3600,
+    "expected_instance_metric": "Datastore/instance/MySQL/unknown/3600"
+  },
+  {
+    "name": "instance metric reports unknown if port empty",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "localhost",
+    "product": "MySQL",
+    "port": "",
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/unknown"
+  },
+  {
+    "name": "instance metric reports unknown if unix_socket empty",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "localhost",
+    "product": "MySQL",
+    "unix_socket": "",
+    "expected_instance_metric": "Datastore/instance/MySQL/datanerd-01/unknown"
+  },
+  {
+    "name": "instance metric with ip v6 host",
+    "system_hostname": "datanerd-01",
+    "db_hostname": "2001:0DB8:AC10:FE01:0000:0000:0000:0000",
+    "product": "Postgres",
+    "port": 5432,
+    "expected_instance_metric": "Datastore/instance/Postgres/2001:0DB8:AC10:FE01:0000:0000:0000:0000/5432"
+  },
+  {
+    "name": "instance metric for filesystem database",
+    "system_hostname": "datanerd-01",
+    "product": "SQLite",
+    "database_path": "/db/all.sqlite3",
+    "expected_instance_metric": "Datastore/instance/SQLite/datanerd-01//db/all.sqlite3"
+  }
+]

data/test/new_relic/agent/datastores/metric_helper_test.rb

@@ -26,6 +26,15 @@ module NewRelic
         assert_equal expected, result
       end
 
+      def test_instance_metric_for
+        instance_id = "localhost/1337807"
+        host = "localhost"
+        port = "1337807"
+        expected = "Datastore/instance/JonanDB/#{host}/#{port}"
+        result = Datastores::MetricHelper.instance_metric_for(@product, host, port)
+        assert_equal expected, result
+      end
+
       def test_metrics_for_in_web_context
         Transaction.stubs(:recording_web_transaction?).returns(true)
         expected = [
@@ -109,6 +118,35 @@ module NewRelic
         assert_equal expected, result
       end
 
+      def test_unscoped_metrics_for_with_instance_identifier
+        Transaction.stubs(:recording_web_transaction?).returns(false)
+        expected = [
+          "Datastore/instance/JonanDB/localhost/1337807",
+          "Datastore/JonanDB/allOther",
+          "Datastore/JonanDB/all",
+          "Datastore/allOther",
+          "Datastore/all"
+        ]
+
+        result = Datastores::MetricHelper.unscoped_metrics_for(@product, @operation, nil, "localhost", "1337807")
+        assert_equal expected, result
+      end
+
+      def test_unscoped_metrics_for_with_instance_identifier_and_instance_reporting_disabled
+        with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
+          Transaction.stubs(:recording_web_transaction?).returns(false)
+          expected = [
+            "Datastore/JonanDB/allOther",
+            "Datastore/JonanDB/all",
+            "Datastore/allOther",
+            "Datastore/all"
+          ]
+
+          result = Datastores::MetricHelper.unscoped_metrics_for(@product, @operation, nil, "localhost/1337807")
+          assert_equal expected, result
+        end
+      end
+
       def test_product_operation_collection_for_obeys_collection_and_operation_overrides
         in_transaction do
           NewRelic::Agent.with_database_metric_name("Model", "new_method") do

data/test/new_relic/agent/instrumentation/active_record_subscriber_test.rb

@@ -52,6 +52,46 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
     )
   end
 
+  def test_records_datastore_instance_metric_for_supported_adapter
+    config = { :adapter => "mysql", :host => "jonan.gummy_planet", :port => 3306 }
+    @subscriber.stubs(:active_record_config).returns(config)
+
+    simulate_query(2)
+
+    assert_metrics_recorded('Datastore/instance/MySQL/jonan.gummy_planet/3306')
+  end
+
+  def test_does_not_record_datastore_instance_metric_for_unsupported_adapter
+    config = { :adapter => "JonanDB", :host => "jonan.gummy_planet" }
+    @subscriber.stubs(:active_record_config).returns(config)
+
+    simulate_query(2)
+
+    assert_metrics_not_recorded('Datastore/instance/JonanDB/jonan.gummy_planet/default')
+  end
+
+  def test_does_not_record_datastore_instance_metric_if_disabled
+    with_config('datastore_tracer.instance_reporting.enabled' => false) do
+      config = { :host => "jonan.gummy_planet" }
+      @subscriber.stubs(:active_record_config).returns(config)
+
+      simulate_query(2)
+
+      assert_metrics_not_recorded('Datastore/instance/ActiveRecord/jonan.gummy_planet/default')
+    end
+  end
+
+  def test_does_not_record_database_name_if_disabled
+    config = { :host => "jonan.gummy_planet", :database => "pizza_cube" }
+    @subscriber.stubs(:active_record_config).returns(config)
+    with_config('datastore_tracer.database_name_reporting.enabled' => false) do
+      in_transaction { simulate_query(2) }
+    end
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    node = find_node_with_name_matching sample, /Datastore\//
+    refute node.params.key?(:database_name)
+  end
+
   def test_records_nothing_if_tracing_disabled
     freeze_time
 

data/test/new_relic/agent/instrumentation/instance_identification_test.rb

@@ -0,0 +1,186 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/instrumentation/active_record_helper'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      module ActiveRecordHelper
+        class InstanceIdentificationTest < Minitest::Test
+
+          def test_for_constructs_id_with_configured_host_and_port
+            config = {
+              :host => "jonan.local",
+              :port => 42
+            }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.local", host
+            assert_equal "42", ppid
+          end
+
+          def test_for_constructs_id_with_unspecified_configuration
+            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+            config = {}
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.pizza_cube", host
+            assert_equal "default", ppid
+          end
+
+          def test_for_constructs_id_with_weird_configs
+            config = {
+              :host => "",
+              :port => ""
+            }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "unknown", host
+            assert_equal "unknown", ppid
+          end
+
+          def test_for_constructs_id_with_configured_host_without_port
+            config = { :host => "jonan.gummy_planet" }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.gummy_planet", host
+            assert_equal "default", ppid
+          end
+
+          def test_for_constructs_id_with_port_without_host
+            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+            config = { :port => 1337 }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.pizza_cube", host
+            assert_equal "1337", ppid
+          end
+
+          def test_for_constructs_id_with_detected_localhost
+            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+
+            %w[localhost 0.0.0.0 127.0.0.1 0:0:0:0:0:0:0:1 0:0:0:0:0:0:0:0 ::1 ::].each do |host|
+              config = { :host => host }
+
+              host = InstanceIdentification.host(config)
+              ppid = InstanceIdentification.port_path_or_id(config)
+
+              assert_equal "jonan.pizza_cube", host
+              assert_equal "default", ppid
+            end
+          end
+
+          def test_for_constructs_id_with_default_port
+            config = {
+              :adapter => "mysql",
+              :host => "jonan.gummy_planet"
+            }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.gummy_planet", host
+            assert_equal "3306", ppid
+          end
+
+          def test_for_constructs_id_with_postgres_directory
+            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+            config = {
+              :adapter => "postgresql",
+              :host => "/tmp"
+            }
+
+            host = InstanceIdentification.host(config)
+            ppid = InstanceIdentification.port_path_or_id(config)
+
+            assert_equal "jonan.pizza_cube", host
+            assert_equal "default", ppid
+          end
+
+          def test_for_constructs_id_with_mysql_socket
+            NewRelic::Agent::Hostname.stubs(:get).returns("jonan.pizza_cube")
+            %w[ mysql mysql2 jdbcmysql ].each do |adapter|
+              config = {
+                :adapter => adapter,
+                :socket => "/var/run/mysqld.sock"
+              }
+
+              host = InstanceIdentification.host(config)
+              ppid = InstanceIdentification.port_path_or_id(config)
+
+              assert_equal "jonan.pizza_cube", host
+              assert_equal "/var/run/mysqld.sock", ppid
+            end
+          end
+
+          def test_supports_supported_adapters
+            %w(mysql mysql2 postgresql).each do |adapter|
+              assert InstanceIdentification.supported_adapter?({:adapter => adapter })
+            end
+          end
+
+          SUPPORTED_PRODUCTS = ["Postgres", "MySQL"]
+
+          load_cross_agent_test('datastores/datastore_instances').each do |test|
+            next unless SUPPORTED_PRODUCTS.include?(test['product'])
+
+            define_method :"test_#{test['name'].tr(' ', '_')}" do
+              NewRelic::Agent.drop_buffered_data
+              NewRelic::Agent::Hostname.stubs(:get).returns(test['system_hostname'])
+
+              config = convert_test_case_to_config test
+
+              product, operation, collection = ActiveRecordHelper.product_operation_collection_for "Blog Find", nil , config[:adapter]
+              host = ActiveRecordHelper::InstanceIdentification.host(config)
+              port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(config)
+
+              segment = NewRelic::Agent::Transaction.start_datastore_segment product, operation, collection, host, port_path_or_id
+              segment.finish
+
+              assert_metrics_recorded test['expected_instance_metric']
+            end
+          end
+
+          CONFIG_NAMES = {
+            "db_hostname" => :host,
+            "unix_socket" => :socket,
+            "port" => :port,
+            "product" => :adapter
+          }
+
+          def convert_test_case_to_config test_case
+            config = test_case.inject({}) do |memo, (k,v)|
+              if config_key = CONFIG_NAMES[k]
+                memo[config_key] = v
+              end
+              memo
+            end
+            convert_product_to_adapter config
+            config
+          end
+
+          PRODUCT_TO_ADAPTER_NAMES = {
+            "Postgres" => "postgresql",
+            "MySQL" => "mysql",
+            "SQLite" => "sqlite3"
+          }
+
+          def convert_product_to_adapter config
+            config[:adapter] = PRODUCT_TO_ADAPTER_NAMES[config[:adapter]]
+          end
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -370,6 +370,49 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     assert_equal expected, trace.to_collector_array(marshaller.default_encoder)
   end
 
+  def test_to_collector_array_with_database_instance_params
+    statement = NewRelic::Agent::Database::Statement.new("query", nil, nil, nil, nil, "jonan.gummy_planet", "1337", "pizza_cube")
+    slow = NewRelic::Agent::SlowSql.new(statement, "transaction", 1.0)
+    trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
+    encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+
+    params = trace.to_collector_array(encoder).last
+
+    assert_equal "jonan.gummy_planet", params[:host]
+    assert_equal "1337", params[:port_path_or_id]
+    assert_equal "pizza_cube", params[:database_name]
+  end
+
+  def test_to_collector_array_with_instance_reporting_disabled
+    with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
+      statement = NewRelic::Agent::Database::Statement.new("query", nil, nil, nil, nil, "jonan.gummy_planet", "1337", "pizza_cube")
+      slow = NewRelic::Agent::SlowSql.new(statement, "transaction", 1.0)
+      trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
+      encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+
+      params = trace.to_collector_array(encoder).last
+
+      refute params.key? :host
+      refute params.key? :port_path_or_id
+      assert_equal "pizza_cube", params[:database_name]
+    end
+  end
+
+  def test_to_collector_array_with_database_name_reporting_disabled
+    with_config(:'datastore_tracer.database_name_reporting.enabled' => false) do
+      statement = NewRelic::Agent::Database::Statement.new("query", nil, nil, nil, nil, "jonan.gummy_planet", "1337", "pizza_cube")
+      slow = NewRelic::Agent::SlowSql.new(statement, "transaction", 1.0)
+      trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
+      encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+
+      params = trace.to_collector_array(encoder).last
+
+      assert_equal "jonan.gummy_planet", params[:host]
+      assert_equal "1337", params[:port_path_or_id]
+      refute params.key? :database_name
+    end
+  end
+
   def test_merge_without_existing_trace
     query = "select * from test"
     statement = NewRelic::Agent::Database::Statement.new(query, {})

data/test/new_relic/agent/transaction/datastore_segment_test.rb

@@ -63,6 +63,103 @@ module NewRelic
           ]
         end
 
+        def test_segment_records_expected_metrics_with_instance_identifier
+          Transaction.stubs(:recording_web_transaction?).returns(true)
+
+          segment = DatastoreSegment.new "SQLite", "select", nil, "localhost", "1337807"
+          segment.start
+          advance_time 1
+          segment.finish
+
+          assert_metrics_recorded [
+            "Datastore/instance/SQLite/localhost/1337807",
+            "Datastore/operation/SQLite/select",
+            "Datastore/SQLite/allWeb",
+            "Datastore/SQLite/all",
+            "Datastore/allWeb",
+            "Datastore/all"
+          ]
+        end
+
+        def test_segment_does_not_record_instance_id_metrics_when_disabled
+          with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
+            Transaction.stubs(:recording_web_transaction?).returns(true)
+
+            segment = DatastoreSegment.new "SQLite", "select", nil, "localhost/1337807"
+            segment.start
+            advance_time 1
+            segment.finish
+
+            assert_metrics_not_recorded "Datastore/instance/SQLite/localhost/1337807"
+          end
+        end
+
+        def test_add_instance_identifier_segment_parameter
+          segment = nil
+
+          in_transaction do
+            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "localhost", "1337807"
+            advance_time 1
+            segment.finish
+          end
+
+          sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+          node = find_node_with_name(sample, segment.name)
+
+          assert_equal "localhost", node.params[:host]
+          assert_equal "1337807", node.params[:port_path_or_id]
+        end
+
+        def test_does_not_add_instance_identifier_segment_parameter_when_disabled
+          with_config(:'datastore_tracer.instance_reporting.enabled' => false) do
+            segment = nil
+
+            in_transaction do
+              segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "localhost", "1337807"
+              advance_time 1
+              segment.finish
+            end
+
+            sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+            node = find_node_with_name(sample, segment.name)
+
+            refute node.params.key? :host
+            refute node.params.key? :port_path_or_id
+          end
+        end
+
+        def test_add_database_name_segment_parameter
+          segment = nil
+
+          in_transaction do
+            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
+            advance_time 1
+            segment.finish
+          end
+
+          sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+          node = find_node_with_name(sample, segment.name)
+
+          assert_equal node.params[:database_name], "pizza_cube"
+        end
+
+        def test_does_not_add_database_name_segment_parameter_when_disabled
+          with_config(:'datastore_tracer.database_name_reporting.enabled' => false) do
+            segment = nil
+
+            in_transaction do
+              segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
+              advance_time 1
+              segment.finish
+            end
+
+            sample = NewRelic::Agent.agent.transaction_sampler.last_sample
+            node = find_node_with_name(sample, segment.name)
+
+            refute node.params.key? :database_name
+          end
+        end
+
         def test_notice_sql
           in_transaction do
             segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select"
@@ -78,6 +175,27 @@ module NewRelic
           end
         end
 
+        def test_notice_sql_creates_database_statement_with_identifier
+          in_transaction do
+            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, "jonan.gummy_planet", "1337"
+            segment.notice_sql "select * from blogs"
+            segment.finish
+
+            assert_equal "jonan.gummy_planet", segment.sql_statement.host
+            assert_equal "1337", segment.sql_statement.port_path_or_id
+          end
+        end
+
+        def test_notice_sql_creates_database_statement_with_database_name
+          in_transaction do
+            segment = NewRelic::Agent::Transaction.start_datastore_segment "SQLite", "select", nil, nil, nil, "pizza_cube"
+            segment.notice_sql "select * from blogs"
+            segment.finish
+
+            assert_equal "pizza_cube", segment.sql_statement.database_name
+          end
+        end
+
         def test_internal_notice_sql
           explainer = stub(:explainer)
           in_transaction do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 3.16.3.323
+  version: 3.17.0.325
 platform: ruby
 authors:
 - Tim Krajcar
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -548,6 +548,8 @@ files:
 - test/fixtures/cross_agent_tests/cat_map.json
 - test/fixtures/cross_agent_tests/data_transport/data_transport.json
 - test/fixtures/cross_agent_tests/data_transport/data_transport.md
+- test/fixtures/cross_agent_tests/datastores/README.md
+- test/fixtures/cross_agent_tests/datastores/datastore_instances.json
 - test/fixtures/cross_agent_tests/docker_container_id/README.md
 - test/fixtures/cross_agent_tests/docker_container_id/cases.json
 - test/fixtures/cross_agent_tests/docker_container_id/docker-0.9.1.txt
@@ -1033,6 +1035,7 @@ files:
 - test/new_relic/agent/instrumentation/active_record_subscriber_test.rb
 - test/new_relic/agent/instrumentation/controller_instrumentation_test.rb
 - test/new_relic/agent/instrumentation/delayed_job_instrumentation_test.rb
+- test/new_relic/agent/instrumentation/instance_identification_test.rb
 - test/new_relic/agent/instrumentation/instrumentation_test.rb
 - test/new_relic/agent/instrumentation/metric_frame_test.rb
 - test/new_relic/agent/instrumentation/middleware_proxy_test.rb