Module: NewRelic::Agent::Instrumentation::ControllerInstrumentation

Extended by:
ClassMethods
Defined in:
lib/new_relic/agent/instrumentation/controller_instrumentation.rb

Overview

NewRelic instrumentation for controller actions and tasks

This module can also be used to capture performance information for background tasks and other non-web transactions, including detailed transaction traces and traced errors.

For details on how to instrument background tasks see ClassMethods#add_transaction_tracer and #perform_action_with_newrelic_trace

Defined Under Namespace

Modules: ClassMethods

Instance Method Summary collapse

Methods included from ClassMethods

add_transaction_tracer, newrelic_ignore, newrelic_ignore_apdex, newrelic_ignore_enduser

Instance Method Details

#perform_action_with_newrelic_trace(*args, &block) ⇒ Object

Yield to the given block with NewRelic tracing. Used by default instrumentation on controller actions in Rails and Merb. But it can also be used in custom instrumentation of controller methods and background tasks.

This is the method invoked by instrumentation added by the ClassMethods#add_transaction_tracer.

Here's a more verbose version of the example shown in ClassMethods#add_transaction_tracer using this method instead of #add_transaction_tracer.

Below is a controller with an invoke_operation action which dispatches to more specific operation methods based on a parameter (very dangerous, btw!). With this instrumentation, the invoke_operation action is ignored but the operation methods show up in New Relic as if they were first class controller actions

MyController < ActionController::Base
  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
  # dispatch the given op to the method given by the service parameter.
  def invoke_operation
    op = params['operation']
    perform_action_with_newrelic_trace(:name => op) do
      send op, params['message']
    end
  end
  # Ignore the invoker to avoid double counting
  newrelic_ignore :only => 'invoke_operation'
end

When invoking this method explicitly as in the example above, pass in a block to measure with some combination of options:

  • :category => :controller indicates that this is a controller action and will appear with all the other actions. This is the default.

  • :category => :task indicates that this is a background task and will show up in New Relic with other background tasks instead of in the controllers list

  • :category => :middleware if you are instrumenting a rack middleware call. The :name is optional, useful if you have more than one potential transaction in the #call.

  • :category => :uri indicates that this is a web transaction whose name is a normalized URI, where 'normalized' means the URI does not have any elements with data in them such as in many REST URIs.

  • :name => action_name is used to specify the action name used as part of the metric name

  • :params => {...} to provide information about the context of the call, used in transaction trace display, for example: :params => { :account => @account.name, :file => file.name } These are treated similarly to request parameters in web transactions.

Seldomly used options:

  • :class_name => aClass.name is used to override the name of the class when used inside the metric name. Default is the current class.

  • :path => metric_path is deprecated in the public API. It allows you to set the entire metric after the category part. Overrides all the other options.

  • :request => Rack::Request#new(env) is used to pass in a request object that may respond to path and referer.


347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
# File 'lib/new_relic/agent/instrumentation/controller_instrumentation.rb', line 347

def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
  NewRelic::Agent.record_api_supportability_metric(:perform_action_with_newrelic_trace)
  state = NewRelic::Agent::Tracer.state
  request = newrelic_request(args)
  queue_start_time = detect_queue_start_time(request)

  skip_tracing = do_not_trace? || !state.is_execution_traced?

  if skip_tracing
    state.current_transaction.ignore! if state.current_transaction
    NewRelic::Agent.disable_all_tracing { return yield }
  end

  # 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.

  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, queue_start_time)

  begin
    finishable = Tracer.start_transaction_or_segment(
      name: txn_options[:transaction_name],
      category: category,
      options: txn_options
    )

    begin
      yield
    rescue => e
      NewRelic::Agent.notice_error(e)
      raise
    end

  ensure
    finishable.finish if finishable
  end
end