newrelic_rpm 3.9.7.266 → 3.9.8.273

data/CHANGELOG

@@ -1,12 +1,55 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.9.8 ##
+
+  * Custom Insights events API
+
+  In addition to attaching custom parameters to the events that the Ruby agent
+  generates automatically for each transaction, you can now record custom event
+  types into Insights with the new NewRelic::Agent.record_custom_event API.
+
+  For details, see https://docs.newrelic.com/docs/insights/new-relic-insights/adding-querying-data/inserting-custom-events-new-relic-agents
+
+  * Reduced memory usage for idling applications
+
+  Idling applications using the agent could previously appear to leak memory
+  because of native allocations during creation of new SSL connections to our
+  servers. These native allocations didn't factor into triggering Ruby's
+  garbage collector.
+
+  The agent will now re-use a single TCP connection to our servers for as long
+  as possible, resulting in improved memory usage for applications that are
+  idling and not having GC triggered for other reasons.
+
+  * Don't write to stderr during CPU sampling
+
+  The Ruby agent's code for gathering CPU information would write error
+  messages to stderr on some FreeBSD systems. This has been fixed.
+
+  * LocalJumpError on Rails 2.x
+
+  Under certain conditions, Rails 2.x controller instrumentation could fail
+  with a LocalJumpError when an action was not being traced. This has been
+  fixed.
+
+  * Fixed config lookup in warbler packaged apps
+
+  When running a Ruby application from a standalone warbler .jar file on
+  JRuby, the packaged config/newrelic.yml was not properly found. This has
+  been fixed, and thanks to Bob Beaty for the help getting it fixed!
+
+  * Hash iteration failure in middleware
+
+  If a background thread iterated over the keys in the Rack env hash, it could
+  cause failures in New Relic's AgentHooks middleware. This has been fixed.
+
 ## 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.
+  into how your application is performing around the world.
 
   For more details, see https://docs.newrelic.com/docs/synthetics/new-relic-synthetics/getting-started/new-relic-synthetics
 

data/lib/new_relic/agent.rb

@@ -455,6 +455,37 @@ module NewRelic
       agent.pop_trace_execution_flag
     end
 
+    # Record a custom event to be sent to New Relic Insights.
+    # The recorded event will be buffered in memory until the next time the
+    # agent sends data to New Relic's servers.
+    #
+    # If you want to be able to tie the information recorded via this call back
+    # to the web request or background job that it happened in, you may want to
+    # instead use the add_custom_parameters API call to attach attributes to
+    # the Transaction event that will automatically be generated for the
+    # request.
+    #
+    # A timestamp will be automatically added to the recorded event when this
+    # method is called.
+    #
+    # @param [Symbol or String] event_type The name of the event type to record. Event
+    #                           types must consist of only alphanumeric
+    #                           characters, '_', ':', or ' '.
+    #
+    # @param [Hash] event_attrs A Hash of attributes to be attached to the event.
+    #                           Keys should be strings or symbols, and values
+    #                           may be strings, symbols, numeric values or
+    #                           booleans.
+    #
+    # @api public
+    #
+    def record_custom_event(event_type, event_attrs)
+      if agent && NewRelic::Agent.config[:'custom_insights_events.enabled']
+        agent.custom_event_aggregator.record(event_type, event_attrs)
+      end
+      nil
+    end
+
     # Check to see if we are capturing metrics currently on this thread.
     def tl_is_execution_traced?
       NewRelic::Agent::TransactionState.tl_get.is_execution_traced?

data/lib/new_relic/agent/agent.rb

@@ -20,11 +20,13 @@ 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/synthetics_monitor'
+require 'new_relic/agent/synthetics_event_buffer'
 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'
+require 'new_relic/agent/utilization_data'
 require 'new_relic/environment_report'
 
 module NewRelic
@@ -52,10 +54,11 @@ module NewRelic
         @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
         @synthetics_monitor    = NewRelic::Agent::SyntheticsMonitor.new(@events)
         @error_collector       = NewRelic::Agent::ErrorCollector.new
+        @utilization_data      = NewRelic::Agent::UtilizationData.new
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
         @harvest_samplers      = NewRelic::Agent::SamplerCollection.new(@events)
-        @javascript_instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(@events)
         @monotonic_gc_profiler = NewRelic::Agent::VM::MonotonicGCProfiler.new
+        @javascript_instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(@events)
 
         @harvester       = NewRelic::Agent::Harvester.new(@events)
         @after_fork_lock = Mutex.new
@@ -583,6 +586,7 @@ module NewRelic
           # Never allow any data type to be reported more frequently than once
           # per second.
           MIN_ALLOWED_REPORT_PERIOD = 1.0
+          UTILIZATION_REPORT_PERIOD = 30 * 60 # every half hour
 
           def report_period_for(method)
             config_key = "data_report_periods.#{method}".to_sym
@@ -614,6 +618,15 @@ module NewRelic
             @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)
+
+            if Agent.config[:collect_utilization] && !in_resque_child_process?
+              @event_loop.on(:report_utilization_data) do
+                transmit_utilization_data
+              end
+              @event_loop.fire(:report_utilization_data)
+              @event_loop.fire_every(UTILIZATION_REPORT_PERIOD, :report_utilization_data)
+            end
+
             @event_loop.run
           end
 
@@ -882,6 +895,7 @@ module NewRelic
           when :transaction_sample_data then @transaction_sampler
           when :error_data              then @error_collector
           when :analytic_event_data     then @transaction_event_aggregator
+          when :custom_event_data       then @custom_event_aggregator
           when :sql_trace_data          then @sql_sampler
           end
         end
@@ -1043,7 +1057,11 @@ module NewRelic
 
         def harvest_and_send_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)
+          harvest_and_send_from_container(@custom_event_aggregator,      :custom_event_data)
+        end
+
+        def harvest_and_send_utilization_data
+          harvest_and_send_from_container(@utilization_data, :utilization_data)
         end
 
         def check_for_and_handle_agent_commands
@@ -1071,17 +1089,27 @@ module NewRelic
         end
 
         def transmit_event_data
+          transmit_single_data_type(:harvest_and_send_analytic_event_data, "TransactionEvent")
+        end
+
+        def transmit_utilization_data
+          transmit_single_data_type(:harvest_and_send_utilization_data, "UtilizationData")
+        end
+
+        def transmit_single_data_type(harvest_method, supportability_name)
           now = Time.now
-          ::NewRelic::Agent.logger.debug "Sending analytics data to New Relic Service"
+
+          msg = "Sending #{harvest_method.to_s.gsub("harvest_and_send_", "")} to New Relic Service"
+          ::NewRelic::Agent.logger.debug msg
 
           harvest_lock.synchronize do
             @service.session do # use http keep-alive
-              harvest_and_send_analytic_event_data
+              self.send(harvest_method)
             end
           end
         ensure
           duration = (Time.now - now).to_f
-          NewRelic::Agent.record_metric('Supportability/TransactionEventHarvest', duration)
+          NewRelic::Agent.record_metric("Supportability/#{supportability_name}Harvest", duration)
         end
 
         # This method is expected to only be called with the harvest_lock
@@ -1123,6 +1151,7 @@ module NewRelic
               @events.notify(:before_shutdown)
               transmit_data
               transmit_event_data
+              transmit_utilization_data if NewRelic::Agent.config[:collect_utilization]
 
               if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
                 ::NewRelic::Agent.logger.debug "Sending New Relic service agent run shutdown message"

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

@@ -49,6 +49,12 @@ module NewRelic
               paths << File.join(ENV["HOME"], "newrelic.yml")
             end
 
+            # If we're packaged for warbler, we can tell from GEM_HOME
+            if ENV["GEM_HOME"] && ENV["GEM_HOME"].end_with?(".jar!")
+              app_name = File.basename(ENV["GEM_HOME"], ".jar!")
+              paths << File.join(ENV["GEM_HOME"], app_name, "config", "newrelic.yml")
+            end
+
             paths
           }
         end
@@ -1092,7 +1098,7 @@ module NewRelic
           :description  => 'A dictionary of label names and values that will be applied to the data sent from this agent. May also be expressed as a semi-colon delimited string of colon-separated pairs (e.g. "Server:One;Data Center:Primary".'
         },
         :aggressive_keepalive => {
-          :default      => false,
+          :default      => true,
           :public       => false,
           :type         => Boolean,
           :description  => 'If true, attempt to keep the TCP connection to the collector alive between harvests.'
@@ -1110,6 +1116,12 @@ module NewRelic
           :type         => String,
           :description  => "Manual override for the path to your local CA bundle. This CA bundle will be used to validate the SSL certificate presented by New Relic's data collection service."
         },
+        :collect_utilization => {
+          :default      => false,
+          :public       => false,
+          :type         => Boolean,
+          :description  => "Controls whether to collect processor and instance sizing data and send it to New Relic"
+        },
         :'rules.ignore_url_regexes' => {
           :default      => [],
           :public       => true,
@@ -1129,12 +1141,24 @@ module NewRelic
           :type         => Fixnum,
           :description  => 'Maximum number of synthetics transaction events to hold for a given harvest'
         },
+        :'custom_insights_events.enabled' => {
+          :default      => true,
+          :public       => true,
+          :type         => Boolean,
+          :description  => 'Enable or disable custom Insights event recording.'
+        },
         :'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
+        },
+        :disable_grape => {
+          :default      => false,
+          :public       => true,
+          :type         => Boolean,
+          :description  => 'Disables installation of Grape instrumentation.'
         }
       }.freeze
 

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

@@ -28,6 +28,7 @@ module NewRelic
             :'slow_sql.record_sql'           => record_sql_setting(local_settings, :'slow_sql.record_sql'),
             :'mongo.obfuscate_queries'       => true,
 
+            :'custom_insights_events.enabled'   => false,
             :'strip_exception_messages.enabled' => true
           })
         end

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -80,7 +80,7 @@ module NewRelic
 
       def client_referring_transaction_trip_id(state)
         info = state.referring_transaction_info or return nil
-        return info[2]
+        return info[2].is_a?(String) && info[2]
       end
 
       def client_referring_transaction_path_hash(state)

data/lib/new_relic/agent/custom_event_aggregator.rb

@@ -11,8 +11,6 @@ module NewRelic
 
       TYPE             = 'type'.freeze
       TIMESTAMP        = 'timestamp'.freeze
-      SOURCE           = 'source'.freeze
-      AGENT_SOURCE     = 'Agent'.freeze
       EVENT_PARAMS_CTX = 'recording custom event'.freeze
       EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
 
@@ -34,7 +32,7 @@ module NewRelic
         end
       end
 
-      def record(type, attributes, source=AGENT_SOURCE)
+      def record(type, attributes)
         type = @type_strings[type]
         unless type =~ EVENT_TYPE_REGEX
           note_dropped_event(type)
@@ -42,7 +40,7 @@ module NewRelic
         end
 
         event = [
-          { TYPE => type, TIMESTAMP => Time.now.to_i, SOURCE => source },
+          { TYPE => type, TIMESTAMP => Time.now.to_i },
           event_params(attributes, EVENT_PARAMS_CTX)
         ]
 

data/lib/new_relic/agent/error_collector.rb

@@ -121,7 +121,8 @@ module NewRelic
           error_ids.include?(exception.object_id)
         end
 
-        def tag_as_seen(txn, exception)
+        def tag_as_seen(state, exception)
+          txn = state.current_transaction
           txn.noticed_error_ids << exception.object_id if txn
         end
 
@@ -147,14 +148,9 @@ module NewRelic
         end
 
         # Increments a statistic that tracks total error rate
-        # Be sure not to double-count same exception. This clears per harvest.
-        def increment_error_count!(exception, options={}) #THREAD_LOCAL_ACCESS
-          state = ::NewRelic::Agent::TransactionState.tl_get
+        def increment_error_count!(state, exception, options={})
           txn = state.current_transaction
 
-          return if seen?(txn, exception)
-          tag_as_seen(txn, exception)
-
           metric_names  = aggregated_metric_names(txn)
           blamed_metric = blamed_metric_name(txn, options)
           metric_names << blamed_metric if blamed_metric
@@ -165,8 +161,11 @@ module NewRelic
           end
         end
 
-        def skip_notice_error?(exception)
-          disabled? || error_is_ignored?(exception) || exception.nil?
+        def skip_notice_error?(state, exception)
+          disabled? ||
+            error_is_ignored?(exception) ||
+            exception.nil? ||
+            seen?(state.current_transaction, exception)
         end
 
         # acts just like Hash#fetch, but deletes the key from the hash
@@ -278,13 +277,19 @@ module NewRelic
       #
       # If anything is left over, it's added to custom params
       # If exception is nil, the error count is bumped and no traced error is recorded
-      def notice_error(exception, options={})
-        return if skip_notice_error?(exception)
-        increment_error_count!(exception, options)
+      def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
+        state = ::NewRelic::Agent::TransactionState.tl_get
+
+        return if skip_notice_error?(state, exception)
+        tag_as_seen(state, exception)
+
+        increment_error_count!(state, exception, options)
         NewRelic::Agent.instance.events.notify(:notice_error, exception, options)
+
         action_path       = fetch_from_options(options, :metric, "")
         exception_options = error_params_from_options(options).merge(exception_info(exception))
         add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
+
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)

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

@@ -330,17 +330,18 @@ module NewRelic
           state = NewRelic::Agent::TransactionState.tl_get
           state.request = newrelic_request(args)
 
-          # Skip instrumentation based on the value of 'do_not_trace?' and if
-          # we aren't calling directly with a block.
-          if !block_given? && do_not_trace?
-            state.current_transaction.ignore! if state.current_transaction
-            NewRelic::Agent.disable_all_tracing do
-              return perform_action_without_newrelic_trace(*args)
+          skip_tracing = do_not_trace? || !state.is_execution_traced?
+          if skip_tracing
+            if block_given?
+              return yield
+            else
+              state.current_transaction.ignore! if state.current_transaction
+              NewRelic::Agent.disable_all_tracing do
+                return perform_action_without_newrelic_trace(*args)
+              end
             end
           end
 
-          return yield unless state.is_execution_traced?
-
           # If a block was passed in, then the arguments represent options for
           # the instrumentation, not app method arguments.
           trace_options = NR_DEFAULT_OPTIONS

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

@@ -0,0 +1,67 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module GrapeInstrumentation
+      API_ENDPOINT = 'api.endpoint'.freeze
+      FORMAT       = '(.:format)'.freeze
+      EMPTY_STRING = ''.freeze
+      MIN_VERSION  = ::NewRelic::VersionNumber.new("0.2.0")
+    end
+  end
+end
+
+DependencyDetection.defer do
+  named :grape
+
+  depends_on do
+    defined?(::Grape::VERSION) &&
+      ::NewRelic::VersionNumber.new(::Grape::VERSION) >= ::NewRelic::Agent::GrapeInstrumentation::MIN_VERSION
+  end
+
+  depends_on do
+    false
+  end
+
+  executes do
+    NewRelic::Agent.logger.info 'Installing Grape instrumentation'
+    instrument_call
+  end
+
+  def instrument_call
+    ::Grape::API.class_eval do
+      def call_with_new_relic(env)
+        begin
+          response = call_without_new_relic(env)
+        ensure
+          # We don't want an error in our transaction naming to kill the request.
+          begin
+            endpoint = env[::NewRelic::Agent::GrapeInstrumentation::API_ENDPOINT]
+
+            if endpoint
+              route_obj = endpoint.route
+              if route_obj
+                action_name = route_obj.route_path.sub(::NewRelic::Agent::GrapeInstrumentation::FORMAT,
+                                                        ::NewRelic::Agent::GrapeInstrumentation::EMPTY_STRING)
+                method_name = route_obj.route_method
+
+                txn_name = "#{self.class.name}#{action_name} (#{method_name})"
+                ::NewRelic::Agent.set_transaction_name(txn_name)
+              end
+            end
+          rescue => e
+            ::NewRelic::Agent.logger.warn("Error in Grape transaction naming", e)
+          end
+        end
+
+        response
+      end
+
+      alias_method :call_without_new_relic, :call
+      alias_method :call, :call_with_new_relic
+    end
+  end
+
+end