newrelic_rpm 5.5.0.348 → 5.6.0.349

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b17c73d708623383395fecf3a60a063566a12b59a10d2b18d686deef72f31773
-  data.tar.gz: f9b9275cf1f9f980175454d8ed5f06a4fa2d173c4edf52e136580c96b2e05eda
+  metadata.gz: eafe4315178abb8fe388bdae54e2c201fa080b142d093d0aa66678e2dff39596
+  data.tar.gz: 1c7d5d213331e77c5e3c78c1bf58cc956336615aa5d08bc7331a56ca2293a351
 SHA512:
-  metadata.gz: 8cc16f8281e2e00829add33da0ba8053afbfe29e56b9e901c40d40cd44be982df5859492a26041aed7593b687316848113dcc02b646816e2812132bda4a86db5
-  data.tar.gz: 7eecd067c7606152a08e6485c6f0a642f5e73081812b011f89ba8d2b3fdd74df66ee0686e385d078ec4a4286e396a1ee9206bbc9c2585925596b9b7e90101015
+  metadata.gz: e8027ef671be103e04bc674a35fccfed2c292abe47873281d0007738a306b88422493283eb04881cb6794478b9c10307db3a89c342d149456bc21e73cffbcf83
+  data.tar.gz: 8d6006908631d158b0edc1757c80960a80e7d415599faf5516635fa96dafe16e228e20263dbf1961f82e7cc6483f7ebbdd26f4dc8e8602846bc8e1e6a114ab72

data/.travis.yml

@@ -9,7 +9,9 @@ language: ruby
 sudo: required
 
 before_install:
-  - sudo apt-get update && sudo apt-get install --only-upgrade openssl && sudo apt-get install --only-upgrade libssl-dev
+  # RUBY-2072 Prevent Travis setup failure before our test even starts
+  - sudo rm -f /etc/apt/sources.list.d/travis_ci_zeromq3.list
+
   - gem --version
   - gem update --system
   - ./test/script/before_install/gemstash_mirror.sh
@@ -19,7 +21,11 @@ install: bundle install
 
 addons:
   apt:
+    update: true
     packages:
+      - openssl
+      - libssl-dev
+      - build-essential
       - haveged
 
 before_script: ./test/script/before_script/install_mongodb.sh
@@ -40,6 +46,7 @@ notifications:
 rvm:
   # Run slowest builds first to try and optimize overall cycle time.
   - jruby-9.1.13.0
+  - 2.6.0-preview3
   - 2.5.0
   - 2.4.2
   - 2.3.5
@@ -88,6 +95,24 @@ matrix:
   fast_finish: true
   exclude:
     # Unsupported Rails/Ruby combinations
+    # 2.6
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails21
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails22
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails23
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails30
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails31
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails32
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails40
+    - rvm: 2.6.0-preview3
+      env: TYPE=UNIT ENVIRONMENT=rails41
+
     # 2.5
     - rvm: 2.5.0
       env: TYPE=UNIT ENVIRONMENT=rails21

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # New Relic Ruby Agent Release Notes #
 
+## v5.6.0
+
+  * Bugfix for transactions with `ActionController::Live`
+
+    Previously, transactions containing `ActionController::Live` resulted in
+    incorrect calculations of capacity analysis as well as error backtraces
+    appearing in agent logs in agent versions 5.4 and later. The agent now
+    correctly calculates capacity for transactions with `ActionController::Live`.
+
+  * Add ability to exclude attributes from span events and transaction
+    segments
+
+    Agent versions 5.5 and lower could selectively exclude attributes
+    from page views, error traces, transaction traces, and
+    transaction events.  With agent version 5.6 and higher, you can
+    also exclude attributes from span events (via the
+    `span_events.include/exclude` options) and from transaction
+    segments (via the `transaction_segments.include/exclude` options).
+
+    As with other attribute destinations, these new options will
+    inherit values from the top-level `attributes.include/exclude`
+    settings. See the
+    [documentation](https://docs.newrelic.com/docs/agents/ruby-agent/attributes/enabling-disabling-attributes-ruby)
+    for more information.
+
+  * Increasing backoff sequence on failing to connect to New Relic
+
+    If the agent cannot reach New Relic, it will now wait for an
+    increasing amount of time after each failed attempt.  We are also
+    starting with a shorter delay initially, which will help customer
+    apps bounce back more quickly from transient network errors.
+
+  * Truncation of long stack traces
+
+    Previous versions of the agent would truncate long stack traces to
+    50 frames.  To give customers more flexibility, we have added the
+    `error_collector.max_backtrace_frames` configuration option.
+    Thanks to Patrick Tulskie for the contribution!
+
+  * Update link in documentation
+
+    The community forum link in `README.md` now goes to the updated
+    location.  Thanks to Sam Killgallon for the contribution!
+
+  * Active Storage instrumentation
+
+    The agent now provides instrumentation for Active Storage, introduced in
+    Rails 5.2. Customers will see Active Storage operations represented as
+    segments within transaction traces.
+
 ## v5.5.0
 
   * Bugfix for `perform` instrumentation with curb gem

data/README.md

@@ -127,7 +127,7 @@ You can find more detailed documentation [on our website](http://newrelic.com/do
 and specifically in the [Ruby category](http://newrelic.com/docs/ruby).
 
 If you can't find what you're looking for there, reach out to us on our [support
-site](http://support.newrelic.com/) or our [community forum](http://forum.newrelic.com)
+site](http://support.newrelic.com/) or our [community forum](https://discuss.newrelic.com/)
 and we'll be happy to help you.
 
 Find a bug? Contact us via [support.newrelic.com](http://support.newrelic.com/),

data/config.dot

@@ -18,6 +18,7 @@ digraph AgentEnabled {
   "[error_collector.capture_source]"
   "[error_collector.enabled]"
   "[error_collector.ignore_errors]"
+  "[error_collector.max_backtrace_frames]"
   "[browser_monitoring.auto_instrument]"
   "[license_key]"
   "[verify_certificate]"

data/lib/new_relic/agent/agent.rb

@@ -727,12 +727,14 @@ module NewRelic
             force || (!connected? && !disconnected?)
           end
 
-          # Retry period is a minute for each failed attempt that
-          # we've made. This should probably do some sort of sane TCP
-          # backoff to prevent hammering the server, but a minute for
-          # each attempt seems to work reasonably well.
+          # Per the spec at
+          # /agents/agent-specs/Collector-Response-Handling.md, retry
+          # connections after a specific backoff sequence to prevent
+          # hammering the server.
+          CONNECT_RETRY_PERIODS = [15, 15, 30, 60, 120, 300]
+
           def connect_retry_period
-            [600, connect_attempts * 60].min
+            CONNECT_RETRY_PERIODS[connect_attempts] || 300
           end
 
           def note_connect_failure

data/lib/new_relic/agent/attribute_filter.rb

@@ -64,42 +64,55 @@ module NewRelic
     class AttributeFilter
       DST_NONE = 0x0
 
-      DST_TRANSACTION_EVENTS = 1 << 0
-      DST_TRANSACTION_TRACER = 1 << 1
-      DST_ERROR_COLLECTOR    = 1 << 2
-      DST_BROWSER_MONITORING = 1 << 3
+      DST_TRANSACTION_EVENTS   = 1 << 0
+      DST_TRANSACTION_TRACER   = 1 << 1
+      DST_ERROR_COLLECTOR      = 1 << 2
+      DST_BROWSER_MONITORING   = 1 << 3
+      DST_SPAN_EVENTS          = 1 << 4
+      DST_TRANSACTION_SEGMENTS = 1 << 5
 
-      DST_ALL = 0xF
+      DST_ALL                  = 0x3f
 
       attr_reader :rules
 
       def initialize(config)
         @enabled_destinations = DST_NONE
 
-        @enabled_destinations |= DST_TRANSACTION_TRACER if config[:'transaction_tracer.attributes.enabled']
-        @enabled_destinations |= DST_TRANSACTION_EVENTS if config[:'transaction_events.attributes.enabled']
-        @enabled_destinations |= DST_ERROR_COLLECTOR    if config[:'error_collector.attributes.enabled']
-        @enabled_destinations |= DST_BROWSER_MONITORING if config[:'browser_monitoring.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_TRACER   if config[:'transaction_tracer.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_EVENTS   if config[:'transaction_events.attributes.enabled']
+        @enabled_destinations |= DST_ERROR_COLLECTOR      if config[:'error_collector.attributes.enabled']
+        @enabled_destinations |= DST_BROWSER_MONITORING   if config[:'browser_monitoring.attributes.enabled']
+        @enabled_destinations |= DST_SPAN_EVENTS          if config[:'span_events.attributes.enabled']
+        @enabled_destinations |= DST_TRANSACTION_SEGMENTS if config[:'transaction_segments.attributes.enabled']
 
         @enabled_destinations = DST_NONE unless config[:'attributes.enabled']
 
         @rules = []
 
         build_rule(config[:'attributes.exclude'], DST_ALL, false)
-        build_rule(config[:'transaction_tracer.attributes.exclude'], DST_TRANSACTION_TRACER, false)
-        build_rule(config[:'transaction_events.attributes.exclude'], DST_TRANSACTION_EVENTS, false)
-        build_rule(config[:'error_collector.attributes.exclude'],    DST_ERROR_COLLECTOR,    false)
-        build_rule(config[:'browser_monitoring.attributes.exclude'], DST_BROWSER_MONITORING, false)
+        build_rule(config[:'transaction_tracer.attributes.exclude'],   DST_TRANSACTION_TRACER,   false)
+        build_rule(config[:'transaction_events.attributes.exclude'],   DST_TRANSACTION_EVENTS,   false)
+        build_rule(config[:'error_collector.attributes.exclude'],      DST_ERROR_COLLECTOR,      false)
+        build_rule(config[:'browser_monitoring.attributes.exclude'],   DST_BROWSER_MONITORING,   false)
+        build_rule(config[:'span_events.attributes.exclude'],          DST_SPAN_EVENTS,          false)
+        build_rule(config[:'transaction_segments.attributes.exclude'], DST_TRANSACTION_SEGMENTS, false)
 
         build_rule(['request.parameters.*'], include_destinations_for_capture_params(config[:capture_params]), true)
         build_rule(['job.resque.args.*'],    include_destinations_for_capture_params(config[:'resque.capture_params']), true)
         build_rule(['job.sidekiq.args.*'],   include_destinations_for_capture_params(config[:'sidekiq.capture_params']), true)
 
+        build_rule(['host', 'port_path_or_id'], DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.instance_reporting.enabled'])
+        build_rule(['database_name'],           DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.database_name_reporting.enabled'])
+
         build_rule(config[:'attributes.include'], DST_ALL, true)
-        build_rule(config[:'transaction_tracer.attributes.include'], DST_TRANSACTION_TRACER, true)
-        build_rule(config[:'transaction_events.attributes.include'], DST_TRANSACTION_EVENTS, true)
-        build_rule(config[:'error_collector.attributes.include'],    DST_ERROR_COLLECTOR,    true)
-        build_rule(config[:'browser_monitoring.attributes.include'], DST_BROWSER_MONITORING, true)
+        build_rule(config[:'transaction_tracer.attributes.include'],   DST_TRANSACTION_TRACER,   true)
+        build_rule(config[:'transaction_events.attributes.include'],   DST_TRANSACTION_EVENTS,   true)
+        build_rule(config[:'error_collector.attributes.include'],      DST_ERROR_COLLECTOR,      true)
+        build_rule(config[:'browser_monitoring.attributes.include'],   DST_BROWSER_MONITORING,   true)
+        build_rule(config[:'span_events.attributes.include'],          DST_SPAN_EVENTS,          true)
+        build_rule(config[:'transaction_segments.attributes.include'], DST_TRANSACTION_SEGMENTS, true)
+
+        build_uri_rule(config[:'attributes.exclude'])
 
         @rules.sort!
 
@@ -107,9 +120,35 @@ module NewRelic
         # filter is re-generated on any significant config change.
         @high_security = config[:high_security]
 
+        setup_key_cache
         cache_prefix_blacklist
       end
 
+      # Note the key_cache is a global cache, accessible by multiple threads,
+      # but is intentionally left unsynchronized for liveness. Writes will always
+      # involve writing the same boolean value for each key, so there is no
+      # worry of one value clobbering another. For reads, if a value hasn't been
+      # written to the cache yet, the worst that will happen is that it will run
+      # through the filter rules again. Both reads and writes will become
+      # eventually consistent.
+
+      def setup_key_cache
+        destinations = [
+          DST_TRANSACTION_EVENTS,
+          DST_TRANSACTION_TRACER,
+          DST_ERROR_COLLECTOR,
+          DST_BROWSER_MONITORING,
+          DST_SPAN_EVENTS,
+          DST_TRANSACTION_SEGMENTS,
+          DST_ALL
+        ]
+
+        @key_cache = destinations.inject({}) do |memo, destination|
+          memo[destination] = {}
+          memo
+        end
+      end
+
       def include_destinations_for_capture_params(capturing)
         if capturing
           DST_TRANSACTION_TRACER | DST_ERROR_COLLECTOR
@@ -125,6 +164,14 @@ module NewRelic
         end
       end
 
+      def build_uri_rule(excluded_attributes)
+        uri_aliases = %w(uri url request_uri request.uri http.url)
+
+        if (excluded_attributes & uri_aliases).size > 0
+          build_rule(uri_aliases - excluded_attributes, DST_ALL, false)
+        end
+      end
+
       def apply(attribute_name, default_destinations)
         return DST_NONE if @enabled_destinations == DST_NONE
 
@@ -148,6 +195,19 @@ module NewRelic
         allowed_destinations & requested_destination == requested_destination
       end
 
+      def allows_key?(key, destination)
+        return false unless destination & @enabled_destinations == destination
+
+        value = @key_cache[destination][key]
+
+        if value.nil?
+          allowed_destinations = apply(key, destination)
+          @key_cache[destination][key] = allows?(allowed_destinations, destination)
+        else
+          value
+        end
+      end
+
       def high_security?
         @high_security
       end

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

@@ -719,6 +719,14 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, disables Action Cable instrumentation.'
         },
+        :disable_active_storage => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :dynamic_name => true,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, disables ActiveStorage instrumentation.'
+        },
         :disable_memcached => {
           :default => value_of(:disable_memcache_instrumentation),
           :public => true,
@@ -981,6 +989,13 @@ module NewRelic
           :allowed_from_server => true,
           :description => 'Specify a comma-delimited list of error classes that the agent should ignore.'
         },
+        :'error_collector.max_backtrace_frames' => {
+          :default => 50,
+          :public => true,
+          :type => Integer,
+          :allowed_from_server => false,
+          :description => 'Defines the maximum number of frames in an error backtrace. Backtraces over this amount are truncated at the beginning and end.'
+        },
         :'error_collector.capture_events' => {
           :default => value_of(:'error_collector.enabled'),
           :public => true,
@@ -1505,6 +1520,20 @@ module NewRelic
           :allowed_from_server => false,
           :description => 'If <code>true</code>, the agent captures attributes from browser monitoring.'
         },
+        :'span_events.attributes.enabled' => {
+          :default     => true,
+          :public      => true,
+          :type        => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, the agent captures attributes on span events.'
+        },
+        :'transaction_segments.attributes.enabled' => {
+          :default     => true,
+          :public      => true,
+          :type        => Boolean,
+          :allowed_from_server => false,
+          :description => 'If <code>true</code>, the agent captures attributes on transaction segments.'
+        },
         :'attributes.exclude' => {
           :default     => [],
           :public      => true,
@@ -1545,6 +1574,22 @@ module NewRelic
           :transform    => DefaultSource.method(:convert_to_list),
           :description => 'Prefix of attributes to exclude from browser monitoring. Allows <code>*</code> as wildcard at end.'
         },
+        :'span_events.attributes.exclude' => {
+          :default     => [],
+          :public      => true,
+          :type        => Array,
+          :allowed_from_server => false,
+          :transform   => DefaultSource.method(:convert_to_list),
+          :description => 'Prefix of attributes to exclude from span events. Allows <code>*</code> as wildcard at end.'
+        },
+        :'transaction_segments.attributes.exclude' => {
+          :default     => [],
+          :public      => true,
+          :type        => Array,
+          :allowed_from_server => false,
+          :transform   => DefaultSource.method(:convert_to_list),
+          :description => 'Prefix of attributes to exclude from transaction segments. Allows <code>*</code> as wildcard at end.'
+        },
         :'attributes.include' => {
           :default     => [],
           :public      => true,
@@ -1585,6 +1630,22 @@ module NewRelic
           :transform    => DefaultSource.method(:convert_to_list),
           :description => 'Prefix of attributes to include in browser monitoring. Allows <code>*</code> as wildcard at end.'
         },
+        :'span_events.attributes.include' => {
+          :default     => [],
+          :public      => true,
+          :type        => Array,
+          :allowed_from_server => false,
+          :transform    => DefaultSource.method(:convert_to_list),
+          :description => 'Prefix of attributes to include on span events. Allows <code>*</code> as wildcard at end.'
+        },
+        :'transaction_segments.attributes.include' => {
+          :default     => [],
+          :public      => true,
+          :type        => Array,
+          :allowed_from_server => false,
+          :transform    => DefaultSource.method(:convert_to_list),
+          :description => 'Prefix of attributes to include on transaction segments. Allows <code>*</code> as wildcard at end.'
+        },
         :'custom_attributes.enabled' => {
           :default     => true,
           :public      => true,

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

@@ -121,6 +121,20 @@ module NewRelic
               enabled_fn:     method(:not_empty?),
               disabled_value: [],
               permitted_fn:   nil
+            },
+            {
+              option:         :'span_events.attributes.include',
+              supported:      true,
+              enabled_fn:     method(:not_empty?),
+              disabled_value: [],
+              permitted_fn:   nil
+            },
+            {
+              option:         :'transaction_segments.attributes.include',
+              supported:      true,
+              enabled_fn:     method(:not_empty?),
+              disabled_value: [],
+              permitted_fn:   nil
             }
           ],
           "allow_raw_exception_messages" => [

data/lib/new_relic/agent/error_collector.rb

@@ -13,9 +13,6 @@ module NewRelic
       # made configurable in the future. This is a tradeoff between
       # memory and data retention
       MAX_ERROR_QUEUE_LENGTH = 20
-      # Maximum number of frames in backtraces. May be made configurable
-      # in the future.
-      MAX_BACKTRACE_FRAMES = 50
       EXCEPTION_TAG_IVAR = :'@__nr_seen_exception'
 
       attr_reader :error_trace_aggregator, :error_event_aggregator
@@ -216,8 +213,9 @@ module NewRelic
         nil
       end
 
-      def truncate_trace(trace, keep_frames=MAX_BACKTRACE_FRAMES)
-        return trace if trace.length < keep_frames || trace.length == 0
+      def truncate_trace(trace, keep_frames=nil)
+        keep_frames ||= Agent.config[:'error_collector.max_backtrace_frames']
+        return trace if !keep_frames || trace.length < keep_frames || trace.length == 0
 
         # If keep_frames is odd, we will split things up favoring the top of the trace
         keep_top = (keep_frames / 2.0).ceil

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

@@ -0,0 +1,23 @@
+# 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/instrumentation/active_storage_subscriber'
+
+DependencyDetection.defer do
+  named :active_storage
+
+  depends_on do
+    defined?(::ActiveStorage) &&
+      !NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.subscribed?
+  end
+
+  executes do
+    ::NewRelic::Agent.logger.info 'Installing ActiveStorage 5 instrumentation'
+  end
+
+  executes do
+    ActiveSupport::Notifications.subscribe(/\.active_storage$/,
+      NewRelic::Agent::Instrumentation::ActiveStorageSubscriber.new)
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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/instrumentation/evented_subscriber'
+
+module NewRelic
+  module Agent
+    module Instrumentation
+      class ActiveStorageSubscriber < EventedSubscriber
+        def start name, id, payload
+          return unless state.is_execution_traced?
+          start_segment name, id, payload
+        rescue => e
+          log_notification_error e, name, 'start'
+        end
+
+        def finish name, id, payload
+          return unless state.is_execution_traced?
+          finish_segment id
+        rescue => e
+          log_notification_error e, name, 'finish'
+        end
+
+        def start_segment name, id, payload
+          segment = Transaction.start_segment name: metric_name(name, payload)
+          segment.params[:key] = payload[:key]
+          segment.params[:exist] = payload[:exist] if payload.key? :exist
+          event_stack[id].push segment
+        end
+
+        def finish_segment id
+          segment = event_stack[id].pop
+          segment.finish if segment
+        end
+
+        def metric_name name, payload
+          service = payload[:service]
+          method = method_from_name name
+          "Ruby/ActiveStorage/#{service}Service/#{method}"
+        end
+
+        PATTERN = /\Aservice_([^\.]*)\.active_storage\z/
+        UNKNOWN = "unknown".freeze
+
+        METHOD_NAME_MAPPING = Hash.new do |h, k|
+          if PATTERN =~ k
+            h[k] = $1
+          else
+            h[k] = UNKNOWN
+          end
+        end
+
+        def method_from_name name
+          METHOD_NAME_MAPPING[name]
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/span_event_primitive.rb

@@ -57,40 +57,46 @@ module NewRelic
       def for_external_request_segment(segment)
         intrinsics = intrinsics_for(segment)
 
-        intrinsics[HTTP_URL_KEY]    = truncate(segment.uri)
         intrinsics[COMPONENT_KEY]   = segment.library
         intrinsics[HTTP_METHOD_KEY] = segment.procedure
         intrinsics[CATEGORY_KEY]    = HTTP_CATEGORY
         intrinsics[SPAN_KIND_KEY]   = CLIENT
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        agent_attributes = {}
+
+        if allowed?(HTTP_URL_KEY)
+          agent_attributes[HTTP_URL_KEY] = truncate(segment.uri)
+        end
+
+        [intrinsics, EMPTY_HASH, agent_attributes]
       end
 
       def for_datastore_segment(segment)
         intrinsics = intrinsics_for(segment)
 
         intrinsics[COMPONENT_KEY] = segment.product
+        intrinsics[SPAN_KIND_KEY] = CLIENT
+        intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
+
+        agent_attributes = {}
 
-        if segment.database_name
-          intrinsics[DB_INSTANCE_KEY] = truncate(segment.database_name)
+        if segment.database_name && allowed?(DB_INSTANCE_KEY)
+          agent_attributes[DB_INSTANCE_KEY] = truncate(segment.database_name)
         end
-        if segment.host && segment.port_path_or_id
-          intrinsics[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
+        if segment.host && segment.port_path_or_id && allowed?(PEER_ADDRESS_KEY)
+          agent_attributes[PEER_ADDRESS_KEY] = truncate("#{segment.host}:#{segment.port_path_or_id}")
         end
-        if segment.host
-          intrinsics[PEER_HOSTNAME_KEY] = truncate(segment.host)
+        if segment.host && allowed?(PEER_HOSTNAME_KEY)
+          agent_attributes[PEER_HOSTNAME_KEY] = truncate(segment.host)
         end
 
-        intrinsics[SPAN_KIND_KEY] = CLIENT
-        intrinsics[CATEGORY_KEY] = DATASTORE_CATEGORY
-
-        if segment.sql_statement
-          intrinsics[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
-        elsif segment.nosql_statement
-          intrinsics[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
+        if segment.sql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.sql_statement.safe_sql, 2000)
+        elsif segment.nosql_statement && allowed?(DB_STATEMENT_KEY)
+          agent_attributes[DB_STATEMENT_KEY] = truncate(segment.nosql_statement, 2000)
         end
 
-        [intrinsics, EMPTY_HASH, EMPTY_HASH]
+        [intrinsics, EMPTY_HASH, agent_attributes]
       end
 
       private
@@ -139,6 +145,10 @@ module NewRelic
           value
         end
       end
+
+      def allowed?(key)
+        NewRelic::Agent.instance.attribute_filter.allows_key?(key, AttributeFilter::DST_SPAN_EVENTS)
+      end
     end
   end
 end

data/lib/new_relic/agent/transaction.rb

@@ -288,6 +288,8 @@ module NewRelic
         @sampled = nil
         @priority = nil
 
+        @starting_thread_id = Thread.current.object_id
+
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
         merge_request_parameters(@filtered_params)
@@ -541,7 +543,7 @@ module NewRelic
 
         outermost_frame.finish
 
-        NewRelic::Agent::TransactionTimeAggregator.transaction_stop(@end_time)
+        NewRelic::Agent::TransactionTimeAggregator.transaction_stop(@end_time, @starting_thread_id)
 
         commit!(outermost_frame.name) unless @ignore_this_transaction
       end

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

@@ -109,13 +109,11 @@ module NewRelic
         end
 
         def add_instance_parameters
-          return unless NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
           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
-          return unless NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
           params[:database_name] = database_name if database_name
         end
 

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

@@ -21,8 +21,10 @@ module NewRelic
           @entry_timestamp = relative_start
           @metric_name     = metric_name || UNKNOWN_NODE_NAME
           @exit_timestamp  = relative_end
-          @children    = nil
-          @params          = params
+          @children        = nil
+          @params          = params.select do |p|
+            NewRelic::Agent.instance.attribute_filter.allows_key? p, AttributeFilter::DST_TRANSACTION_SEGMENTS
+          end if params
           @parent_node     = parent
         end
 

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -23,37 +23,37 @@ module NewRelic
         h[k] = TransactionStats.new nil, 0.0
       end
 
-      def reset!(now = Time.now)
-        @harvest_cycle_started_at = now
+      def reset!(timestamp = Time.now)
+        @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(now = Time.now)
+      def transaction_start(timestamp = Time.now)
         @lock.synchronize do
-          set_transaction_start_time now
+          set_transaction_start_time timestamp
         end
       end
 
-      def transaction_stop(now = Time.now)
+      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
         @lock.synchronize do
-          record_elapsed_transaction_time_until now
-          set_transaction_start_time nil
+          record_elapsed_transaction_time_until timestamp, starting_thread_id
+          set_transaction_start_time nil, starting_thread_id
         end
       end
 
       INSTANCE_BUSY_METRIC = 'Instance/Busy'.freeze
 
-      def harvest!(now = Time.now)
+      def harvest!(timestamp = Time.now)
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread
           elapsed_transaction_time = @stats.inject(0.0) do |total, (thread_id, entry)|
-            total + transaction_time_in_thread(thread_id, entry, now)
+            total + transaction_time_in_thread(timestamp, thread_id, entry)
           end
 
           active_threads = @stats.size
-          elapsed_harvest_time      = (now - @harvest_cycle_started_at) * active_threads
-          @harvest_cycle_started_at = now
+          elapsed_harvest_time      = (timestamp - @harvest_cycle_started_at) * active_threads
+          @harvest_cycle_started_at = timestamp
 
           # Clear out the stats for all threads, _except_ the live ones
           # that have transactions still open (we'll count the rest of
@@ -81,12 +81,16 @@ module NewRelic
                       :transaction_stop,
                       :harvest!
 
-      class <<self
+      class << self
         private
 
-        def record_elapsed_transaction_time_until(timestamp, thread_id: current_thread)
-          @stats[thread_id].elapsed_transaction_time +=
-            (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+        def record_elapsed_transaction_time_until(timestamp, thread_id = current_thread)
+          if @stats[thread_id].transaction_started_at
+            @stats[thread_id].elapsed_transaction_time +=
+              (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+          else
+            log_missing_elapsed_transaction_time
+          end
         end
 
         def in_transaction?(thread_id = current_thread)
@@ -104,27 +108,33 @@ module NewRelic
           false
         end
 
-        def set_transaction_start_time(timestamp)
-          @stats[current_thread].transaction_started_at = timestamp
+        def set_transaction_start_time(timestamp, thread_id = current_thread)
+          @stats[thread_id].transaction_started_at = timestamp
         end
 
-        def split_transaction_at_harvest(now, thread_id: nil)
+        def split_transaction_at_harvest(timestamp, thread_id = nil)
           raise ArgumentError, 'thread_id required' unless thread_id
-          @stats[thread_id].transaction_started_at = now
+          @stats[thread_id].transaction_started_at = timestamp
           @stats[thread_id].elapsed_transaction_time = 0.0
         end
 
-        def transaction_time_in_thread thread_id, entry, now
+        def transaction_time_in_thread timestamp, thread_id, entry
           return entry.elapsed_transaction_time unless in_transaction? thread_id
 
           # Count the portion of the transaction that's elapsed so far,...
-          elapsed = record_elapsed_transaction_time_until now, thread_id: thread_id
+          elapsed = record_elapsed_transaction_time_until timestamp, thread_id
 
           # ...then readjust the transaction start time to the next harvest
-          split_transaction_at_harvest now, thread_id: thread_id
+          split_transaction_at_harvest timestamp, thread_id
 
           elapsed
         end
+
+        def log_missing_elapsed_transaction_time
+          state = NewRelic::Agent::TransactionState.tl_get
+          transaction_name = state.current_transaction.best_name
+          NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
+        end
       end
     end
   end

data/lib/new_relic/version.rb

@@ -11,7 +11,7 @@ module NewRelic
     end
 
     MAJOR = 5
-    MINOR = 5
+    MINOR = 6
     TINY  = 0
 
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 5.5.0.348
+  version: 5.6.0.349
 platform: ruby
 authors:
 - Matthew Wear
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2018-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -273,6 +273,8 @@ files:
 - lib/new_relic/agent/instrumentation/active_record_helper.rb
 - lib/new_relic/agent/instrumentation/active_record_prepend.rb
 - lib/new_relic/agent/instrumentation/active_record_subscriber.rb
+- lib/new_relic/agent/instrumentation/active_storage.rb
+- lib/new_relic/agent/instrumentation/active_storage_subscriber.rb
 - lib/new_relic/agent/instrumentation/acts_as_solr.rb
 - lib/new_relic/agent/instrumentation/authlogic.rb
 - lib/new_relic/agent/instrumentation/bunny.rb