newrelic_rpm 3.9.9.275 → 3.10.0.279

data/CHANGELOG

@@ -1,5 +1,56 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.10.0 ##
+
+  * Support for the Grape framework
+
+  We now instrument the Grape REST API framework! To avoid conflicts with the
+  third-party newrelic-grape gem, our instrumentation will not be installed if
+  newrelic-grape is present in the Gemfile.
+
+  For more details, see https://docs.newrelic.com/docs/agents/ruby-agent/frameworks/grape-instrumentation
+
+  * Automatic Cross Application Tracing support for all Rack applications
+
+  Previously Rack apps not using Rails or Sinatra needed to include the
+  AgentHooks middleware to get Cross Application Tracing support. With
+  these changes, this is no longer necessary. Any explicit references to
+  AgentHooks can be removed unless the `disable_middleware_instrumentation`
+  setting is set to `true`.
+
+  * Metrics no longer reported from Puma master processes
+
+  When using Puma's cluster mode with the preload_app! configuration directive,
+  the agent will no longer start its reporting thread in the Puma master
+  process. This should result in more accurate instance counts, and more
+  accurate stats on the Ruby VMs page (since the master process will be
+  excluded).
+
+  * Better support for Sinatra apps used with Rack::Cascade
+
+  Previously, using a Sinatra application as part of a Rack::Cascade chain would
+  cause all transactions to be named after the Sinatra application, rather than
+  allowing downstream applications to set the transaction name when the Sinatra
+  application returned a 404 response. This has been fixed.
+
+  * Updated support for Rubinius 2.3+ metrics
+
+  Rubinius 2.3 introduced a new system for gathering metrics from the
+  underlying VM. Data capture for the Ruby VM's page has been updated to take
+  advantage of these. Thanks Yorick Peterse for the contribution!
+
+  * Fix for missing ActiveJob traced errors
+
+  ActiveJobs processed by backends where the Ruby agent lacked existing
+  instrumentation missed reporting traced errors. This did not impact
+  ActiveJobs used with Sidekiq or Resque, and has been fixed.
+
+  * Fix possible crash in middleware tracing
+
+  In rare circumstances, a failure in the agent early during tracing of a web
+  request could lead to a cascading error when trying to capture the HTTP status
+  code of the request. This has been fixed. Thanks to Michal Cichra for the fix!
+
 ## v3.9.9 ##
 
   * Support for Ruby 2.2

data/config.dot

@@ -42,7 +42,6 @@ digraph AgentEnabled {
   "[log_file_path]"
   "[dispatcher]"
   "[force_send]"
-  "[disable_mobile_headers]"
   "[textmate]"
   "[post_size_limit]"
   "[sync_startup]"
@@ -224,8 +223,6 @@ digraph AgentEnabled {
   "ErrorCollector#initialize" -> "[error_collector.ignore_errors]"
   "ErrorCollector#request_params_from_opts" -> "[capture_params]"
 
-  "ControllerInstrumentation#perform_action_with_newrelic_trace" -> "[disable_mobile_headers]"
-
   "NewRelicService#initialize" -> "[timeout]"
   "NewRelicService#initialize" -> "[license_key]"
   "NewRelicService#initialize" -> "Control#server"

data/lib/new_relic/agent.rb

@@ -543,11 +543,13 @@ module NewRelic
       nil # don't return a noticed error datastructure. it can only hurt.
     end
 
-    # Add parameters to any Transaction Trace, Error or Analytics Events that
-    # are recorded during the current transaction.
+    # Add parameters to the transaction trace, Insights Transaction event, and
+    # any traced errors recorded for the current transaction.
     #
-    # If configured to allow it, these custom parameters will also be present
-    # in the RUM script injected into the page.
+    # If Browser Monitoring is enabled, and the
+    # browser_monitoring.capture_attributes configuration setting is enabled,
+    # these custom parameters will also be present in the RUM script injected
+    # into the response body, making them available on Insights PageView events.
     #
     # @api public
     #
@@ -590,7 +592,7 @@ module NewRelic
     # @api public
     #
     def set_transaction_name(name, options={})
-      Transaction.set_overriding_transaction_name(name, options)
+      Transaction.set_overriding_transaction_name(name, options[:category])
     end
 
     # Get the name of the current running transaction.  This is useful if you

data/lib/new_relic/agent/agent.rb

@@ -403,7 +403,7 @@ module NewRelic
               true
             else
               ::NewRelic::Agent.logger.warn("No license key found. " +
-                "This often means your newrelic.yml file was not found, or it lacks a section for the running environment, '#{NewRelic::Control.instance.env}'.")
+                "This often means your newrelic.yml file was not found, or it lacks a section for the running environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml to ensure it is valid YML.")
               false
             end
           end
@@ -428,10 +428,10 @@ module NewRelic
 
           # If we're using a dispatcher that forks before serving
           # requests, we need to wait until the children are forked
-          # before connecting, otherwise the parent process sends odd data
+          # before connecting, otherwise the parent process sends useless data
           def using_forking_dispatcher?
-            if [:passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
-              ::NewRelic::Agent.logger.info 'Connecting workers after forking.'
+            if [:puma, :passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
+              ::NewRelic::Agent.logger.info "Deferring startup of agent reporting thread because #{Agent.config[:dispatcher]} may fork."
               true
             else
               false

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

@@ -42,7 +42,7 @@ module NewRelic
           elsif state.in_background_transaction?
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
               transaction_name_suffix_for_job(job),
-              :category => transaction_category)
+              transaction_category)
             block.call
           else
             run_in_transaction(state, job, block)
@@ -56,13 +56,10 @@ module NewRelic
         end
 
         def self.run_in_transaction(state, job, block)
-          begin
-            ::NewRelic::Agent::Transaction.start(state, :other,
-              :transaction_name => transaction_name_for_job(job))
-            block.call
-          ensure
-            ::NewRelic::Agent::Transaction.stop(state)
-          end
+          ::NewRelic::Agent::Transaction.wrap(state,
+                                              transaction_name_for_job(job),
+                                              :other,
+                                              &block)
         end
 
         def self.transaction_category

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

@@ -218,7 +218,7 @@ module NewRelic
           end
 
           def self.prefix_for_category(txn, category = nil)
-            category ||= (txn && txn.best_category)
+            category ||= (txn && txn.category)
             case category
             when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :task       then ::NewRelic::Agent::Transaction::TASK_PREFIX
@@ -226,6 +226,7 @@ module NewRelic
             when :uri        then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
             when :sinatra    then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
             when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
+            when :grape      then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end
@@ -331,42 +332,25 @@ module NewRelic
           state.request = newrelic_request(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
+            state.current_transaction.ignore! if state.current_transaction
+            NewRelic::Agent.disable_all_tracing { return yield }
           end
 
-          # If a block was passed in, then the arguments represent options for
-          # the instrumentation, not app method arguments.
-          trace_options = NR_DEFAULT_OPTIONS
+          # This method has traditionally taken a variable number of arguments, but the
+          # only one that is expected / used is a single options hash.  We are preserving
+          # the *args method signature to ensure backwards compatibility.
 
-          if block_given?
-            trace_options    = args.last if args.last.is_a?(Hash)
-            available_params = trace_options[:params]
-          else
-            available_params = respond_to?(:params) && params
-          end
-
-          category    = trace_options[:category] || :controller
-          txn_options = create_transaction_options(trace_options, available_params)
-          txn_options[:transaction_name] = TransactionNamer.name_for(nil, self, category, trace_options)
-          txn_options[:apdex_start_time] = detect_queue_start_time(state)
+          trace_options = args.last.is_a?(Hash) ? args.last : NR_DEFAULT_OPTIONS
+          category      = trace_options[:category] || :controller
+          txn_options   = create_transaction_options(trace_options, category, state)
 
           begin
             txn = Transaction.start(state, category, txn_options)
 
             begin
-              if block_given?
-                yield
-              else
-                perform_action_without_newrelic_trace(*args)
-              end
+              yield
             rescue => e
               NewRelic::Agent.notice_error(e)
               raise
@@ -429,15 +413,14 @@ module NewRelic
 
         private
 
-        def create_transaction_options(trace_options, available_params)
+        def create_transaction_options(trace_options, category, state)
           txn_options = {}
           txn_options[:request]   = trace_options[:request]
           txn_options[:request] ||= request if respond_to?(:request)
-
-          if available_params
-            txn_options[:filtered_params] = (respond_to?(:filter_parameters)) ? filter_parameters(available_params) : available_params
-          end
-
+          # params should have been filtered before calling perform_action_with_newrelic_trace
+          txn_options[:filtered_params] = trace_options[:params]
+          txn_options[:transaction_name] = TransactionNamer.name_for(nil, self, category, trace_options)
+          txn_options[:apdex_start_time] = detect_queue_start_time(state)
           txn_options
         end
 

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

@@ -2,13 +2,52 @@
 # 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/parameter_filtering'
+
 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")
+    module Instrumentation
+      module GrapeInstrumentation
+        extend self
+
+        API_ENDPOINT   = 'api.endpoint'.freeze
+        FORMAT_REGEX   = /\(\/?\.:format\)/.freeze
+        VERSION_REGEX  = /:version(\/|$)/.freeze
+        EMPTY_STRING   = ''.freeze
+        MIN_VERSION    = VersionNumber.new("0.2.0")
+
+        def handle_transaction(endpoint, class_name)
+          return unless endpoint && route = endpoint.route
+          name_transaction(route, class_name)
+          capture_params(endpoint) if Agent.config[:capture_params]
+        end
+
+        def name_transaction(route, class_name)
+          txn_name = name_for_transaction(route, class_name)
+          segment_name = "Middleware/Grape/#{class_name}/call"
+          Transaction.set_default_transaction_name(txn_name, :grape, segment_name)
+        end
+
+        def name_for_transaction(route, class_name)
+          action_name = route.route_path.sub(FORMAT_REGEX, EMPTY_STRING)
+          method_name = route.route_method
+
+          if route.route_version
+            action_name = action_name.sub(VERSION_REGEX, EMPTY_STRING)
+            "#{class_name}-#{route.route_version}#{action_name} (#{method_name})"
+          else
+            "#{class_name}#{action_name} (#{method_name})"
+          end
+        end
+
+        def capture_params(endpoint)
+          txn = Transaction.tl_current
+          env = endpoint.request.env
+          params = ParameterFiltering::apply_filters(env, endpoint.params)
+          params.delete("route_info")
+          txn.filtered_params = params
+        end
+      end
     end
   end
 end
@@ -24,15 +63,25 @@ DependencyDetection.defer do
 
   depends_on do
     defined?(::Grape::VERSION) &&
-      ::NewRelic::VersionNumber.new(::Grape::VERSION) >= ::NewRelic::Agent::GrapeInstrumentation::MIN_VERSION
+      ::NewRelic::VersionNumber.new(::Grape::VERSION) >= ::NewRelic::Agent::Instrumentation::GrapeInstrumentation::MIN_VERSION
   end
 
   depends_on do
-    false
+    begin
+      if defined?(Bundler) && Bundler.rubygems.all_specs.map(&:name).include?("newrelic-grape")
+        ::NewRelic::Agent.logger.info("Not installing New Relic supported Grape instrumentation because the third party newrelic-grape gem is present")
+        false
+      else
+        true
+      end
+    rescue => e
+      ::NewRelic::Agent.logger.info("Could not determine if third party newrelic-grape gem is installed")
+      true
+    end
   end
 
   executes do
-    NewRelic::Agent.logger.info 'Installing Grape instrumentation'
+    NewRelic::Agent.logger.info 'Installing New Relic supported Grape instrumentation'
     instrument_call
   end
 
@@ -42,23 +91,11 @@ DependencyDetection.defer do
         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
+            endpoint = env[::NewRelic::Agent::Instrumentation::GrapeInstrumentation::API_ENDPOINT]
+            ::NewRelic::Agent::Instrumentation::GrapeInstrumentation.handle_transaction(endpoint, self.class.name)
           rescue => e
-            ::NewRelic::Agent.logger.warn("Error in Grape transaction naming", e)
+            ::NewRelic::Agent.logger.warn("Error in Grape instrumentation", e)
           end
         end
 

data/lib/new_relic/agent/instrumentation/merb/controller.rb

@@ -29,8 +29,16 @@ DependencyDetection.defer do
 
       protected
 
-      alias_method :perform_action_without_newrelic_trace, :_dispatch
-      alias_method :_dispatch, :perform_action_with_newrelic_trace
+      def _dispatch_with_newrelic_trace(*args)
+        options = {}
+        options[:params] = params
+        perform_action_with_newrelic_trace(options) do
+          _dispatch_without_newrelic_trace(*args)
+        end
+      end
+
+      alias_method :_dispatch_without_newrelic_trace, :_dispatch
+      alias_method :_dispatch, :_dispatch_with_newrelic_trace
     end
   end
 end

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

@@ -26,40 +26,48 @@ module NewRelic
   module Agent
     module Instrumentation
       module MiddlewareTracing
-        CAPTURED_REQUEST_KEY = 'newrelic.captured_request'.freeze unless defined?(CAPTURED_REQUEST_KEY)
+        TXN_STARTED_KEY = 'newrelic.transaction_started'.freeze unless defined?(TXN_STARTED_KEY)
 
         def _nr_has_middleware_tracing
           true
         end
 
-        def build_transaction_options(env)
-          if env[CAPTURED_REQUEST_KEY]
-            transaction_options
-          else
-            env[CAPTURED_REQUEST_KEY] = true
-            queue_timefrontend_timestamp = QueueTime.parse_frontend_timestamp(env)
-            transaction_options.merge(
-              :request          => ::Rack::Request.new(env),
-              :apdex_start_time => queue_timefrontend_timestamp
-            )
+        def build_transaction_options(env, first_middleware)
+          opts = transaction_options
+          opts = merge_first_middleware_options(opts, env) if first_middleware
+          opts
+        end
+
+        def merge_first_middleware_options(opts, env)
+          opts.merge(
+            :request          => ::Rack::Request.new(env),
+            :apdex_start_time => QueueTime.parse_frontend_timestamp(env)
+          )
+        end
+
+        def note_transaction_started(env)
+          env[TXN_STARTED_KEY] = true unless env[TXN_STARTED_KEY]
+        end
+
+        def capture_http_response_code(state, result)
+          if result.is_a?(Array) && state.current_transaction
+            state.current_transaction.http_response_code = result[0]
           end
         end
 
         def call(env)
-          opts = build_transaction_options(env)
+          first_middleware = note_transaction_started(env)
+
           state = NewRelic::Agent::TransactionState.tl_get
 
           begin
-            Transaction.start(state, category, opts)
-            if target == self
-              result = traced_call(env)
-            else
-              result = target.call(env)
-            end
+            Transaction.start(state, category, build_transaction_options(env, first_middleware))
+            events.notify(:before_call, env) if first_middleware
+
+            result = (target == self) ? traced_call(env) : target.call(env)
 
-            if result.is_a?(Array)
-              state.current_transaction.http_response_code = result[0]
-            end
+            capture_http_response_code(state, result)
+            events.notify(:after_call, env, result) if first_middleware
 
             result
           rescue Exception => e
@@ -69,6 +77,10 @@ module NewRelic
             Transaction.stop(state)
           end
         end
+
+        def events
+          NewRelic::Agent.instance.events
+        end
       end
     end
   end