newrelic_rpm 3.9.6.257 → 3.9.7.266

data/CHANGELOG

@@ -1,5 +1,50 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.9.7 ##
+
+  * Support for New Relic Synthetics
+
+  The Ruby agent now gives you additional information for requests from New
+  Relic Synthetics. More transaction traces and events give you a clearer look
+  into how your applicaiton is performing around the world.
+
+  For more details, see https://docs.newrelic.com/docs/synthetics/new-relic-synthetics/getting-started/new-relic-synthetics
+
+  * Support for multiple job per fork gems with Resque
+
+  The resque-jobs-per-fork and resque-multi-job-forks gems alter Resque to
+  fork every N jobs instead of every job. This previously caused issues for
+  the Ruby agent, but those have been resolved. These gems are fully supported.
+
+  Running Resque with the FORK_PER_JOB=false environment variable setting is
+  also supported now.
+
+  For more details on our Resque support, see https://docs.newrelic.com/docs/agents/ruby-agent/background-jobs/resque-instrumentation
+
+  * Support agent when starting Resque Pool from Rake task
+
+  When running resque-pool with its provided rake tasks, the agent would not
+  start up properly. Thanks Tiago Sousa for the fix!
+
+  * Fix for DelayedJob + Rails 4.x queue depth metrics
+
+  The Ruby agent periodically records DelayedJob queuedepth as a metric, but
+  this didn't work properly in Rails 4.x applications.  This has been fixed.
+  Thanks Jonathan del Strother for his help with the issue!
+
+  * Fix for failure in background transactions with rules.ignore_url_regexes
+
+  The recently added feature for ignoring transactions via URL regexes caused
+  errors for non-web transactions. This has been fixed.
+
+  * Rename the TransactionNamer.name method to TransactionNamer.name_for
+
+  The internal TransactionNamer class had a class method called 'name', with a
+  different signature than the existing Class#name method and could cause
+  problems when trying to introspect instances of the class.
+
+  Thanks to Dennis Taylor for contributing this fix!
+
 ## v3.9.6 ##
 
   * Rails 4.2 ActiveJob support

data/lib/new_relic/agent.rb

@@ -76,7 +76,6 @@ module NewRelic
     require 'new_relic/metric_spec'
     require 'new_relic/metric_data'
     require 'new_relic/collection_helper'
-    require 'new_relic/transaction_analysis'
     require 'new_relic/transaction_sample'
     require 'new_relic/url_rule'
     require 'new_relic/noticed_error'

data/lib/new_relic/agent/agent.rb

@@ -19,7 +19,9 @@ require 'new_relic/agent/database'
 require 'new_relic/agent/commands/agent_command_router'
 require 'new_relic/agent/event_listener'
 require 'new_relic/agent/cross_app_monitor'
-require 'new_relic/agent/request_sampler'
+require 'new_relic/agent/synthetics_monitor'
+require 'new_relic/agent/transaction_event_aggregator'
+require 'new_relic/agent/custom_event_aggregator'
 require 'new_relic/agent/sampler_collection'
 require 'new_relic/agent/javascript_instrumentor'
 require 'new_relic/agent/vm/monotonic_gc_profiler'
@@ -48,14 +50,19 @@ module NewRelic
         @sql_sampler           = NewRelic::Agent::SqlSampler.new
         @agent_command_router  = NewRelic::Agent::Commands::AgentCommandRouter.new(@events)
         @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
+        @synthetics_monitor    = NewRelic::Agent::SyntheticsMonitor.new(@events)
         @error_collector       = NewRelic::Agent::ErrorCollector.new
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
-        @request_sampler       = NewRelic::Agent::RequestSampler.new(@events)
         @harvest_samplers      = NewRelic::Agent::SamplerCollection.new(@events)
         @javascript_instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(@events)
-        @harvester             = NewRelic::Agent::Harvester.new(@events)
         @monotonic_gc_profiler = NewRelic::Agent::VM::MonotonicGCProfiler.new
 
+        @harvester       = NewRelic::Agent::Harvester.new(@events)
+        @after_fork_lock = Mutex.new
+
+        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new(@events)
+        @custom_event_aggregator      = NewRelic::Agent::CustomEventAggregator.new
+
         @connect_state      = :pending
         @connect_attempts   = 0
         @environment_report = nil
@@ -112,6 +119,7 @@ module NewRelic
         attr_reader :harvest_lock
         # GC::Profiler.total_time is not monotonic so we wrap it.
         attr_reader :monotonic_gc_profiler
+        attr_reader :custom_event_aggregator
 
         # This method should be called in a forked process after a fork.
         # It assumes the parent process initialized the agent, but does
@@ -133,28 +141,22 @@ module NewRelic
         #   connection, this tells me to only try it once so this method returns
         #   quickly if there is some kind of latency with the server.
         def after_fork(options={})
-          # Mark started early because if we've explicitly called after_fork,
-          # we should be ready to run and shouldn't restarting if we can't.
-          @harvester.mark_started
-
-          if channel_id = options[:report_to_channel]
-            @service = NewRelic::Agent::PipeService.new(channel_id)
-            if connected?
-              @connected_pid = Process.pid
-            else
-              ::NewRelic::Agent.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
-              @service.shutdown(Time.now)
-              disconnect
-            end
+          needs_restart = false
+          @after_fork_lock.synchronize do
+            needs_restart = @harvester.needs_restart?
+            @harvester.mark_started
           end
 
-          return if !Agent.config[:agent_enabled] ||
+          return if !needs_restart ||
+            !Agent.config[:agent_enabled] ||
             !Agent.config[:monitor_mode] ||
-            disconnected? ||
-            @worker_thread && @worker_thread.alive?
+            disconnected?
 
           ::NewRelic::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
 
+          channel_id = options[:report_to_channel]
+          install_pipe_service(channel_id) if channel_id
+
           # Clear out locks and stats left over from parent process
           reset_objects_with_locks
           drop_buffered_data
@@ -162,6 +164,17 @@ module NewRelic
           setup_and_start_agent(options)
         end
 
+        def install_pipe_service(channel_id)
+          @service = NewRelic::Agent::PipeService.new(channel_id)
+          if connected?
+            @connected_pid = Process.pid
+          else
+            ::NewRelic::Agent.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
+            @service.shutdown(Time.now)
+            disconnect
+          end
+        end
+
         # True if we have initialized and completed 'start'
         def started?
           @started
@@ -514,7 +527,8 @@ module NewRelic
           @stats_engine.reset!
           @error_collector.reset!
           @transaction_sampler.reset!
-          @request_sampler.reset!
+          @transaction_event_aggregator.reset!
+          @custom_event_aggregator.reset!
           @sql_sampler.reset!
         end
 
@@ -531,6 +545,13 @@ module NewRelic
           reset_harvest_locks
         end
 
+        def flush_pipe_data
+          if connected? && @service.is_a?(::NewRelic::Agent::PipeService)
+            transmit_data
+            transmit_event_data
+          end
+        end
+
         private
 
         # All of this module used to be contained in the
@@ -577,6 +598,8 @@ module NewRelic
             period
           end
 
+          LOG_ONCE_KEYS_RESET_PERIOD = 60.0
+
           def create_and_run_event_loop
             @event_loop = create_event_loop
             @event_loop.on(:report_data) do
@@ -585,8 +608,12 @@ module NewRelic
             @event_loop.on(:report_event_data) do
               transmit_event_data
             end
+            @event_loop.on(:reset_log_once_keys) do
+              ::NewRelic::Agent.logger.clear_already_logged
+            end
             @event_loop.fire_every(Agent.config[:data_report_period],       :report_data)
             @event_loop.fire_every(report_period_for(:analytic_event_data), :report_event_data)
+            @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD,              :reset_log_once_keys)
             @event_loop.run
           end
 
@@ -854,7 +881,7 @@ module NewRelic
           when :metric_data             then @stats_engine
           when :transaction_sample_data then @transaction_sampler
           when :error_data              then @error_collector
-          when :analytic_event_data     then @request_sampler
+          when :analytic_event_data     then @transaction_event_aggregator
           when :sql_trace_data          then @sql_sampler
           end
         end
@@ -978,6 +1005,9 @@ module NewRelic
             NewRelic::Agent.logger.warn("Failed to serialize data for #{endpoint}, discarding. Error: ", e)
           rescue UnrecoverableServerException => e
             NewRelic::Agent.logger.warn("#{endpoint} data was rejected by remote service, discarding. Error: ", e)
+          rescue ServerConnectionException => e
+            log_remote_unavailable(endpoint, e)
+            container.merge!(items)
           rescue => e
             NewRelic::Agent.logger.info("Unable to send #{endpoint} data, will try again later. Error: ", e)
             container.merge!(items)
@@ -1012,7 +1042,8 @@ module NewRelic
         end
 
         def harvest_and_send_analytic_event_data
-          harvest_and_send_from_container(@request_sampler, :analytic_event_data)
+          harvest_and_send_from_container(@transaction_event_aggregator, :analytic_event_data)
+          harvest_and_send_from_container(@custom_event_aggregator,      :analytic_event_data)
         end
 
         def check_for_and_handle_agent_commands
@@ -1020,11 +1051,19 @@ module NewRelic
             @agent_command_router.check_for_and_handle_agent_commands
           rescue ForceRestartException, ForceDisconnectException
             raise
+          rescue ServerConnectionException => e
+            log_remote_unavailable(:get_agent_commands, e)
           rescue => e
             NewRelic::Agent.logger.info("Error during check_for_and_handle_agent_commands, will retry later: ", e)
           end
         end
 
+        def log_remote_unavailable(endpoint, e)
+          NewRelic::Agent.logger.debug("Unable to send #{endpoint} data, will try again later. Error: ", e)
+          NewRelic::Agent.record_metric("Supportability/remote_unavailable", 0.0)
+          NewRelic::Agent.record_metric("Supportability/remote_unavailable/#{endpoint.to_s}", 0.0)
+        end
+
         def transmit_data
           harvest_lock.synchronize do
             transmit_data_already_locked

data/lib/new_relic/agent/agent_logger.rb

@@ -9,7 +9,10 @@ module NewRelic
   module Agent
     class AgentLogger
 
+      attr_reader :already_logged
+
       def initialize(root = "", override_logger=nil)
+        clear_already_logged
         create_log(root, override_logger)
         set_log_level!
         set_log_format!
@@ -40,10 +43,14 @@ module NewRelic
       NUM_LOG_ONCE_KEYS = 1000
 
       def log_once(level, key, *msgs)
-        return if already_logged.include?(key)
+        # Since `already_logged` might change between calls, just grab it once
+        # and use it throughout this method.
+        logged = already_logged
+
+        return if logged.include?(key)
 
-        if already_logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
-          # The reason for preventing too many keys in `already_logged` is for
+        if logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+          # The reason for preventing too many keys in `logged` is for
           # memory concerns.
           # The reason for checking the type of the key is that we always want
           # to allow symbols to log, since there are very few of them.
@@ -54,7 +61,7 @@ module NewRelic
           return
         end
 
-        already_logged[key] = true
+        logged[key] = true
         self.send(level, *msgs)
       end
 
@@ -140,11 +147,6 @@ module NewRelic
         @log = ::NewRelic::Agent::NullLogger.new
       end
 
-      def already_logged
-        @already_logged ||= {}
-        @already_logged
-      end
-
       def clear_already_logged
         @already_logged = {}
       end

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

@@ -202,10 +202,13 @@ module NewRelic
           case value
           when String
             value.split(',')
-          else
+          when Array
             value
+          else
+            raise ArgumentError.new("Config value '#{value}' couldn't be turned into a list.")
           end
         end
+
       end
 
       AUTOSTART_BLACKLISTED_RAKE_TASKS = [
@@ -1079,6 +1082,7 @@ module NewRelic
           :default      => ['scheduler', 'run'],
           :public       => true,
           :type         => Array,
+          :transform    => DefaultSource.method(:convert_to_list),
           :description  => 'List of prefixes for heroku dyno names (such as "scheduler") to report as hostname without trailing dot and process ID.'
         },
         :labels => {
@@ -1112,7 +1116,26 @@ module NewRelic
           :type         => Array,
           :transform    => DefaultSource.rules_ignore,
           :description  => 'A list of patterns that will cause a transaction to be ignored if any of them match the URI.'
-         }
+        },
+        :'synthetics.traces_limit' => {
+          :default      => 20,
+          :public       => false,
+          :type         => Fixnum,
+          :description  => 'Maximum number of synthetics transaction traces to hold for a given harvest'
+        },
+        :'synthetics.events_limit' => {
+          :default      => 200,
+          :public       => false,
+          :type         => Fixnum,
+          :description  => 'Maximum number of synthetics transaction events to hold for a given harvest'
+        },
+        :'custom_insights_events.max_samples_stored' => {
+          :default      => 1000,
+          :public       => true,
+          :type         => Fixnum,
+          :description  => 'Maximum number of custom Insights events buffered in memory at a time.',
+          :dynamic_name => true
+        }
       }.freeze
 
     end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -4,51 +4,33 @@
 
 require 'digest'
 
+require 'new_relic/agent/inbound_request_monitor'
 require 'new_relic/agent/transaction_state'
 require 'new_relic/agent/threading/agent_thread'
 
 module NewRelic
   module Agent
+    class CrossAppMonitor < InboundRequestMonitor
 
-    class CrossAppMonitor
-
-      NEWRELIC_ID_HEADER = 'X-NewRelic-ID'
+      NEWRELIC_ID_HEADER      = 'X-NewRelic-ID'
+      NEWRELIC_TXN_HEADER     = 'X-NewRelic-Transaction'
       NEWRELIC_APPDATA_HEADER = 'X-NewRelic-App-Data'
-      NEWRELIC_TXN_HEADER = 'X-NewRelic-Transaction'
-      NEWRELIC_TXN_HEADER_KEYS = %W{
-        #{NEWRELIC_TXN_HEADER} HTTP_X_NEWRELIC_TRANSACTION X_NEWRELIC_TRANSACTION
-      }
-      NEWRELIC_ID_HEADER_KEYS = %W{
-        #{NEWRELIC_ID_HEADER} HTTP_X_NEWRELIC_ID X_NEWRELIC_ID
-      }
-      CONTENT_LENGTH_HEADER_KEYS = %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH}
-
-      attr_reader :obfuscator
-
-      def initialize(events = nil)
-        # When we're starting up for real in the agent, we get passed the events
-        # Other spots can pull from the agent, during startup the agent doesn't exist yet!
-        events ||= Agent.instance.events
-
-        events.subscribe(:finished_configuring) do
-          on_finished_configuring
-        end
-      end
 
-      def on_finished_configuring
-        setup_obfuscator
-        register_event_listeners
+      NEWRELIC_ID_HEADER_KEY    = 'HTTP_X_NEWRELIC_ID'.freeze
+      NEWRELIC_TXN_HEADER_KEY   = 'HTTP_X_NEWRELIC_TRANSACTION'.freeze
+      CONTENT_LENGTH_HEADER_KEY = 'HTTP_CONTENT_LENGTH'.freeze
+
+      def on_finished_configuring(events)
+        register_event_listeners(events)
       end
 
       # Expected sequence of events:
       #   :before_call will save our cross application request id to the thread
-      #   :start_transaction will get called when a transaction starts up
       #   :after_call will write our response headers/metrics and clean up the thread
-      def register_event_listeners
+      def register_event_listeners(events)
         NewRelic::Agent.logger.
           debug("Wiring up Cross Application Tracing to events after finished configuring")
 
-        events = Agent.instance.events
         events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
           if should_process_request(env)
             state = NewRelic::Agent::TransactionState.tl_get
@@ -72,11 +54,6 @@ module NewRelic
         end
       end
 
-      # This requires :encoding_key, so must wait until :finished_configuring
-      def setup_obfuscator
-        @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
-      end
-
       def save_client_cross_app_id(state, request_headers)
         state.client_cross_app_id = decoded_id(request_headers)
       end
@@ -86,9 +63,8 @@ module NewRelic
       end
 
       def save_referring_transaction_info(state, request_headers)
-        txn_header = from_headers(request_headers, NEWRELIC_TXN_HEADER_KEYS) or return
-        txn_header = obfuscator.deobfuscate(txn_header)
-        txn_info = NewRelic::JSONWrapper.load(txn_header)
+        txn_header = request_headers[NEWRELIC_TXN_HEADER_KEY] or return
+        txn_info = deserialize_header(txn_header, NEWRELIC_TXN_HEADER)
         state.referring_transaction_info = txn_info
       end
 
@@ -182,14 +158,14 @@ module NewRelic
       end
 
       def decoded_id(request)
-        encoded_id = from_headers(request, NEWRELIC_ID_HEADER_KEYS)
+        encoded_id = request[NEWRELIC_ID_HEADER_KEY]
         return "" if encoded_id.nil?
 
         obfuscator.deobfuscate(encoded_id)
       end
 
       def content_length_from_request(request)
-        from_headers(request, CONTENT_LENGTH_HEADER_KEYS) || -1
+        request[CONTENT_LENGTH_HEADER_KEY] || -1
       end
 
       def hash_transaction_name(identifier)
@@ -202,20 +178,6 @@ module NewRelic
         identifier = "#{app_name};#{txn_name}"
         sprintf("%08x", rotated ^ hash_transaction_name(identifier))
       end
-
-      private
-
-      def from_headers(request, try_keys)
-        # For lookups, upcase all our keys on both sides just to be safe
-        upcased_keys = try_keys.map{|k| k.upcase}
-        upcased_keys.each do |header|
-          found_key = request.keys.find { |k| k.upcase == header }
-          return request[found_key] unless found_key.nil?
-        end
-        nil
-      end
-
     end
-
   end
 end