newrelic_rpm 3.9.6.257 → 3.9.7.266

data/lib/new_relic/agent/samplers/delayed_job_sampler.rb

@@ -18,9 +18,16 @@ module NewRelic
       class DelayedJobSampler < NewRelic::Agent::Sampler
         named :delayed_job
 
+        # DelayedJob supports multiple backends, only some of which we can
+        # handle. Check whether we think we've got what we need here.
+        def self.supported_backend?
+          ::Delayed::Worker.backend.to_s == "Delayed::Backend::ActiveRecord::Job"
+        end
+
         def initialize
-          raise Unsupported, "DJ instrumentation disabled" if Agent.config[:disable_dj]
-          raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
+          raise Unsupported, "DJ queue sampler disabled" if Agent.config[:disable_dj]
+          raise Unsupported, "DJ queue sampling unsupported with backend '#{::Delayed::Worker.backend}'" unless self.class.supported_backend?
+          raise Unsupported, "No DJ worker present. Skipping DJ queue sampler" unless NewRelic::DelayedJobInjection.worker_name
         end
 
         def record_failed_jobs(value)
@@ -31,51 +38,72 @@ module NewRelic
           NewRelic::Agent.record_metric("Workers/DelayedJob/locked_jobs", value)
         end
 
+        FAILED_QUERY = 'failed_at is not NULL'.freeze
+        LOCKED_QUERY = 'locked_by is not NULL'.freeze
+
         def failed_jobs
-          Delayed::Job.count(:conditions => 'failed_at is not NULL')
+          count(FAILED_QUERY)
         end
 
         def locked_jobs
-          Delayed::Job.count(:conditions => 'locked_by is not NULL')
+          count(LOCKED_QUERY)
+        end
+
+        def count(query)
+          if ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            ::Delayed::Job.count(query)
+          else
+            ::Delayed::Job.where(query).count
+          end
         end
 
         def self.supported_on_this_platform?
-          defined?(Delayed::Job)
+          defined?(::Delayed::Job)
         end
 
         def poll
           record_failed_jobs(failed_jobs)
           record_locked_jobs(locked_jobs)
-
-          if @queue
-            record_queue_length_across_dimension('queue')
-          else
-            record_queue_length_across_dimension('priority')
-          end
+          record_queue_length_metrics
         end
 
         private
 
-        def record_queue_length_across_dimension(column)
+        def record_queue_length_metrics
+          counts = []
+          counts << record_counts_by("queue", "name") if ::Delayed::Job.instance_methods.include?(:queue)
+          counts << record_counts_by("priority")
+
+          all_metric = "Workers/DelayedJob/queue_length/all"
+          NewRelic::Agent.record_metric(all_metric, counts.max)
+        end
+
+        QUEUE_QUERY_CONDITION = 'run_at <= ? and failed_at is NULL'.freeze
+
+        def record_counts_by(column_name, metric_segment = column_name)
           all_count = 0
-          Delayed::Job.count(:group => column, :conditions => ['run_at < ? and failed_at is NULL', Time.now]).each do | column_val, count |
+          queue_counts(column_name).each do |column_val, count|
             all_count += count
-            metric = "Workers/DelayedJob/queue_length/#{column == 'queue' ? 'name' : column}/#{column_val}"
+            column_val = "default" if column_val.nil? || column_val == ""
+            metric = "Workers/DelayedJob/queue_length/#{metric_segment}/#{column_val}"
             NewRelic::Agent.record_metric(metric, count)
           end
-          all_metric = "Workers/DelayedJob/queue_length/all"
-          NewRelic::Agent.record_metric(all_metric, all_count)
+          all_count
         end
 
-        # Figure out if we get the queues.
-        def setup
-          return unless @queue.nil?
-          @setup = true
-          columns = Delayed::Job.columns
-          columns.each do | c |
-            @queue = true if c.name.to_s == 'priority'
+        def queue_counts(column_name)
+          now = ::Delayed::Job.db_time_now
+          # There is not an ActiveRecord syntax for what we're trying to do
+          # here that's valid on 2.x through 4.1, so split it up.
+          result = if ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            ::Delayed::Job.count(:group => column_name,
+                                 :conditions => [QUEUE_QUERY_CONDITION, now])
+          else
+            ::Delayed::Job.where(QUEUE_QUERY_CONDITION, now).
+                           group(column_name).
+                           count
           end
-          @queue ||= false
+          result.to_a
         end
       end
     end

data/lib/new_relic/agent/sized_buffer.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/event_buffer'
+
+module NewRelic
+  module Agent
+    class SizedBuffer < EventBuffer
+
+      def append_event(x)
+        if @items.size < @capacity
+          @items << x
+          return x
+        else
+          return nil
+        end
+      end
+
+    end
+  end
+end
+

data/lib/new_relic/agent/synthetics_monitor.rb

@@ -0,0 +1,50 @@
+# 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/inbound_request_monitor'
+
+module NewRelic
+  module Agent
+    class SyntheticsMonitor < InboundRequestMonitor
+      SYNTHETICS_HEADER_KEY  = 'HTTP_X_NEWRELIC_SYNTHETICS'.freeze
+
+      SUPPORTED_VERSION = 1
+      EXPECTED_PAYLOAD_LENGTH = 5
+
+      def on_finished_configuring(events)
+        events.subscribe(:before_call, &method(:on_before_call))
+      end
+
+      def on_before_call(request) #THREAD_LOCAL_ACCESS
+        encoded_header = request[SYNTHETICS_HEADER_KEY]
+        return unless encoded_header
+
+        incoming_payload = deserialize_header(encoded_header, SYNTHETICS_HEADER_KEY)
+
+        return unless incoming_payload &&
+            is_valid_payload?(incoming_payload) &&
+            is_supported_version?(incoming_payload) &&
+            is_trusted?(incoming_payload)
+
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.raw_synthetics_header = encoded_header
+        txn.synthetics_payload    = incoming_payload
+      end
+
+      def is_supported_version?(incoming_payload)
+        incoming_payload.first == SUPPORTED_VERSION
+      end
+
+      def is_trusted?(incoming_payload)
+        account_id = incoming_payload[1]
+        NewRelic::Agent.config[:trusted_account_ids].include?(account_id)
+      end
+
+      def is_valid_payload?(incoming_payload)
+        incoming_payload.length == EXPECTED_PAYLOAD_LENGTH
+      end
+    end
+  end
+end

data/lib/new_relic/agent/system_info.rb

@@ -124,6 +124,34 @@ module NewRelic
         proc_try_read('/proc/version')
       end
 
+      def self.docker_container_id
+        return unless ruby_os_identifier =~ /linux/
+
+        cgroup_info = proc_try_read('/proc/self/cgroup')
+        return unless cgroup_info
+
+        parse_docker_container_id(cgroup_info)
+      end
+
+      def self.parse_docker_container_id(cgroup_info)
+        cpu_cgroup = parse_cgroup_ids(cgroup_info)['cpu']
+        return unless cpu_cgroup && cpu_cgroup =~ %r{^/docker/(.*)}
+        return $1
+      end
+
+      def self.parse_cgroup_ids(cgroup_info)
+        cgroup_ids = {}
+
+        cgroup_info.split("\n").each do |line|
+          parts = line.split(':')
+          next unless parts.size == 3
+          _, type, cgroup_id = parts
+          cgroup_ids[type] = cgroup_id
+        end
+
+        cgroup_ids
+      end
+
       # A File.read against /(proc|sysfs)/* can hang with some older Linuxes.
       # See https://bugzilla.redhat.com/show_bug.cgi?id=604887, RUBY-736, and
       # https://github.com/opscode/ohai/commit/518d56a6cb7d021b47ed3d691ecf7fba7f74a6a7

data/lib/new_relic/agent/transaction.rb

@@ -63,6 +63,9 @@ module NewRelic
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
 
+      # Fields for tracking synthetics requests
+      attr_accessor :raw_synthetics_header, :synthetics_payload
+
       # Return the currently active transaction, or nil.
       def self.tl_current
         TransactionState.tl_get.current_transaction
@@ -357,9 +360,24 @@ module NewRelic
         transaction_sampler.ignore_transaction(state)
       end
 
+      WEB_SUMMARY_METRIC   = 'HttpDispatcher'.freeze
+      OTHER_SUMMARY_METRIC = 'OtherTransaction/all'.freeze
+
       def summary_metrics
-        metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named(@frozen_name)
-        metric_parser.summary_metrics
+        if @frozen_name.start_with?(CONTROLLER_PREFIX)
+          [WEB_SUMMARY_METRIC]
+        else
+          background_summary_metrics
+        end
+      end
+
+      def background_summary_metrics
+        segments = @frozen_name.split('/')
+        if segments.size > 2
+          ["OtherTransaction/#{segments[1]}/all", OTHER_SUMMARY_METRIC]
+        else
+          []
+        end
       end
 
       def needs_middleware_summary_metrics?(name)
@@ -402,6 +420,7 @@ module NewRelic
       end
 
       def user_defined_rules_ignore?
+        return unless uri
         return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
 
         parsed = NewRelic::Agent::HTTPClients::URIUtil.parse_url(uri)
@@ -422,7 +441,7 @@ module NewRelic
 
         record_summary_metrics(outermost_segment_name, end_time)
         record_apdex(state, end_time) unless ignore_apdex?
-        NewRelic::Agent::Instrumentation::QueueTime.record_frontend_metrics(apdex_start, start_time) if queue_time > 0.0
+        record_queue_time
 
         record_exceptions
         merge_metrics
@@ -451,6 +470,7 @@ module NewRelic
         }
         append_cat_info(state, duration, payload)
         append_apdex_perf_zone(duration, payload)
+        append_synthetics_to(state, payload)
         append_referring_transaction_guid_to(state, payload)
         append_http_response_code(payload)
 
@@ -462,8 +482,7 @@ module NewRelic
       end
 
       def include_guid?(state, duration)
-        state.is_cross_app? ||
-        (state.request_token && duration > apdex_t)
+        state.is_cross_app? || is_synthetics_request?
       end
 
       def cat_trip_id(state)
@@ -489,6 +508,35 @@ module NewRelic
         NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_path_hash(state)
       end
 
+      def is_synthetics_request?
+        synthetics_payload != nil && raw_synthetics_header != nil
+      end
+
+      def synthetics_version
+        info = synthetics_payload or return nil
+        info[0]
+      end
+
+      def synthetics_account_id
+        info = synthetics_payload or return nil
+        info[1]
+      end
+
+      def synthetics_resource_id
+        info = synthetics_payload or return nil
+        info[2]
+      end
+
+      def synthetics_job_id
+        info = synthetics_payload or return nil
+        info[3]
+      end
+
+      def synthetics_monitor_id
+        info = synthetics_payload or return nil
+        info[4]
+      end
+
       APDEX_S = 'S'.freeze
       APDEX_T = 'T'.freeze
       APDEX_F = 'F'.freeze
@@ -528,6 +576,14 @@ module NewRelic
         end
       end
 
+      def append_synthetics_to(state, payload)
+        return unless is_synthetics_request?
+
+        payload[:synthetics_resource_id] = synthetics_resource_id
+        payload[:synthetics_job_id]      = synthetics_job_id
+        payload[:synthetics_monitor_id]  = synthetics_monitor_id
+      end
+
       def append_referring_transaction_guid_to(state, payload)
         referring_guid = NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_guid(state)
         if referring_guid
@@ -595,6 +651,23 @@ module NewRelic
         end
       end
 
+      QUEUE_TIME_METRIC = 'WebFrontend/QueueTime'.freeze
+
+      def queue_time
+        @apdex_start ? @start_time - @apdex_start : 0
+      end
+
+      def record_queue_time
+        value = queue_time
+        if value > 0.0
+          if value < MethodTracerHelpers::MAX_ALLOWED_METRIC_DURATION
+            @metrics.record_unscoped(QUEUE_TIME_METRIC, value)
+          else
+            ::NewRelic::Agent.logger.log_once(:warn, :too_high_queue_time, "Not recording unreasonably large queue time of #{value} s")
+          end
+        end
+      end
+
       APDEX_METRIC = 'Apdex'.freeze
 
       def had_error?
@@ -669,10 +742,6 @@ module NewRelic
       alias_method :user_attributes, :custom_parameters
       alias_method :set_user_attributes, :add_custom_parameters
 
-      def queue_time
-        @apdex_start ? @start_time - @apdex_start : 0
-      end
-
       # Returns truthy if the current in-progress transaction is considered a
       # a web transaction (as opposed to, e.g., a background transaction).
       #

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

@@ -0,0 +1,25 @@
+# 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/transaction/transaction_sample_buffer'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class SyntheticsSampleBuffer < TransactionSampleBuffer
+        def capacity
+          NewRelic::Agent.config[:'synthetics.traces_limit']
+        end
+
+        def allow_sample?(sample)
+          sample.synthetics_resource_id != nil
+        end
+
+        def truncate_samples
+          @samples.slice!(max_capacity..-1)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/{request_sampler.rb → transaction_event_aggregator.rb}

@@ -8,7 +8,7 @@ require 'monitor'
 require 'newrelic_rpm' unless defined?( NewRelic )
 require 'new_relic/agent' unless defined?( NewRelic::Agent )
 
-class NewRelic::Agent::RequestSampler
+class NewRelic::Agent::TransactionEventAggregator
   include NewRelic::Coerce,
           MonitorMixin
 
@@ -28,14 +28,19 @@ class NewRelic::Agent::RequestSampler
   CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'.freeze
   CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'.freeze
   APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'.freeze
+  SYNTHETICS_RESOURCE_ID_KEY     = "nr.syntheticsResourceId".freeze
+  SYNTHETICS_JOB_ID_KEY          = "nr.syntheticsJobId".freeze
+  SYNTHETICS_MONITOR_ID_KEY      = "nr.syntheticsMonitorId".freeze
 
   def initialize( event_listener )
     super()
 
     @enabled       = false
-    @samples       = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[:'analytics_events.max_samples_stored'])
     @notified_full = false
 
+    @samples            = ::NewRelic::Agent::SampledBuffer.new(NewRelic::Agent.config[:'analytics_events.max_samples_stored'])
+    @synthetics_samples = ::NewRelic::Agent::SizedBuffer.new(NewRelic::Agent.config[:'synthetics.events_limit'])
+
     event_listener.subscribe( :transaction_finished, &method(:on_transaction_finished) )
     self.register_config_callbacks
   end
@@ -47,31 +52,35 @@ class NewRelic::Agent::RequestSampler
 
   # Fetch a copy of the sampler's gathered samples. (Synchronized)
   def samples
-    return self.synchronize { @samples.to_a }
+    return self.synchronize { @samples.to_a.concat(@synthetics_samples.to_a) }
   end
 
   def reset!
-    NewRelic::Agent.logger.debug "Resetting RequestSampler"
-
-    sample_count, request_count = 0
+    sample_count, request_count, synthetics_dropped = 0
     old_samples = nil
 
     self.synchronize do
       sample_count = @samples.size
-      request_count = @samples.seen
-      old_samples = @samples.to_a
-      @samples.reset
+      request_count = @samples.num_seen
+
+      synthetics_dropped = @synthetics_samples.num_dropped
+
+      old_samples = @samples.to_a + @synthetics_samples.to_a
+      @samples.reset!
+      @synthetics_samples.reset!
+
       @notified_full = false
     end
 
-    [old_samples, sample_count, request_count]
+    [old_samples, sample_count, request_count, synthetics_dropped]
   end
 
   # Clear any existing samples, reset the last sample time, and return the
   # previous set of samples. (Synchronized)
   def harvest!
-    old_samples, sample_count, request_count = reset!
+    old_samples, sample_count, request_count, synthetics_dropped = reset!
     record_sampling_rate(request_count, sample_count) if @enabled
+    record_dropped_synthetics(synthetics_dropped)
     old_samples
   end
 
@@ -79,7 +88,7 @@ class NewRelic::Agent::RequestSampler
   # transmission to the collector. (Synchronized)
   def merge!(old_samples)
     self.synchronize do
-      old_samples.each { |s| @samples.append(s) }
+      old_samples.each { |s| append_event(s) }
     end
   end
 
@@ -96,15 +105,28 @@ class NewRelic::Agent::RequestSampler
     ])
 
     engine = NewRelic::Agent.instance.stats_engine
-    engine.tl_record_supportability_metric_count("RequestSampler/requests", request_count)
-    engine.tl_record_supportability_metric_count("RequestSampler/samples", sample_count)
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/requests", request_count)
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/samples", sample_count)
+  end
+
+  def record_dropped_synthetics(synthetics_dropped)
+    return unless synthetics_dropped > 0
+
+    NewRelic::Agent.logger.debug("Synthetics transaction event limit (#{@samples.capacity}) reached. Further synthetics events this harvest period dropped.")
+
+    engine = NewRelic::Agent.instance.stats_engine
+    engine.tl_record_supportability_metric_count("TransactionEventAggregator/synthetics_events_dropped", synthetics_dropped)
   end
 
   def register_config_callbacks
     NewRelic::Agent.config.register_callback(:'analytics_events.max_samples_stored') do |max_samples|
-      NewRelic::Agent.logger.debug "RequestSampler max_samples set to #{max_samples}"
+      NewRelic::Agent.logger.debug "TransactionEventAggregator max_samples set to #{max_samples}"
       self.synchronize { @samples.capacity = max_samples }
-      self.reset!
+    end
+
+    NewRelic::Agent.config.register_callback(:'synthetics.events_limit') do |max_samples|
+      NewRelic::Agent.logger.debug "TransactionEventAggregator limit for synthetics events set to #{max_samples}"
+      self.synchronize { @synthetics_samples.capacity = max_samples }
     end
 
     NewRelic::Agent.config.register_callback(:'analytics_events.enabled') do |enabled|
@@ -113,7 +135,7 @@ class NewRelic::Agent::RequestSampler
   end
 
   def notify_full
-    NewRelic::Agent.logger.debug "Request Sampler capacity of #{@samples.capacity} reached, beginning sampling"
+    NewRelic::Agent.logger.debug "Transaction event capacity of #{@samples.capacity} reached, beginning sampling"
     @notified_full = true
   end
 
@@ -124,8 +146,17 @@ class NewRelic::Agent::RequestSampler
     main_event = create_main_event(payload)
     custom_params = create_custom_parameters(payload)
 
-    is_full = self.synchronize { @samples.append([main_event, custom_params]) }
-    notify_full if is_full && !@notified_full
+    self.synchronize { append_event([main_event, custom_params]) }
+    notify_full if !@notified_full && @samples.full?
+  end
+
+  def append_event(event)
+    main_event, _ = event
+    if main_event.include?(SYNTHETICS_RESOURCE_ID_KEY)
+      @synthetics_samples.append(event)
+    else
+      @samples.append(event)
+    end
   end
 
   def self.map_metric(metric_name, to_add={})
@@ -186,6 +217,9 @@ class NewRelic::Agent::RequestSampler
     optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
     optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
     optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
+    optionally_append(SYNTHETICS_RESOURCE_ID_KEY,     :synthetics_resource_id, sample, payload)
+    optionally_append(SYNTHETICS_JOB_ID_KEY,          :synthetics_job_id, sample, payload)
+    optionally_append(SYNTHETICS_MONITOR_ID_KEY,      :synthetics_monitor_id, sample, payload)
     append_http_response_code(sample, payload)
     append_cat_alternate_path_hashes(sample, payload)
     sample