Ruby agent configuration

You can configure the New Relic Ruby agent with settings in a configuration file, environment variables, or programmatically with server-side configuration. This document summarizes the configuration options available for the Ruby agent.

If the default value for a configuration option is (Dynamic), this means the Ruby agent calculates the default at runtime. The value for the config setting defaults to the value of another setting as appropriate.

Configuration methods and precedence

The primary (default) method to configure the Ruby agent is via the configuration file (newrelic.yml) in the config subdirectory. To set configuration values using environment variables:

Add the prefix NEW_RELIC_ to the setting's name.
Replace any periods . with underscores _.

You can also configure a few values in the UI via server-side configuration.

The Ruby agent follows this order of precedence for configuration:

Environment variables
Server-side configuration
Configuration file (newrelic.yml)
Default configuration settings

In other words, environment variables override all other configuration settings and info, server-side configuration overrides the configuration file and default config settings, and so on.

View and edit config file options

The Ruby agent's newrelic.yml is a standard YAML configuration file. It typically includes a Defaults section at the top, plus sections below for each application environment (Development, Test, Staging, and Production).

The Ruby agent determines which section of the newrelic.yml config file to read from by looking at certain environment variables to derive the application's environment. This can be useful when you want to use info for the log_level config setting in your production environment, and you want more verbose log_level config settings (such as debug) in your development environment.

Here is an example newrelic.yml config file:

common: &default_settings
  license_key: 'YOUR_LICENSE_KEY'
  app_name: 'My Application Name'
production:
  <<: *default_settings
  log_level: info
development:
  <<: *default_settings
  log_level: debug

The Ruby agent looks for the following environment variables, in this order, to find the application environment:

NEW_RELIC_ENV
RUBY_ENV
RAILS_ENV
APP_ENV
RACK_ENV

If the Ruby agent doesn't detect values for any of those environment variables, it will default the application environment to development and read from the development section of the newrelic.yml config file.

When running the Ruby agent in a Rails app, the agent first looks for the NEW_RELIC_ENV environment variable to find the application environment and which section of the newrelic.yml to use. If NEW_RELIC_ENV is not present, the agent uses the Rails environment (RAILS_ENV).

When you edit the config file, be sure to:

Indent only with two spaces.
Indent only where relevant, in sections such as error_collector.

If you do not indent correctly, the agent may throw an Unable to parse configuration file error on startup.

To view the most current list of available Ruby agent configuration options, use the rake newrelic:config:docs command. This document describes the most common options.

Update the config file

This documentation applies to the Ruby agent's latest release. For details on earlier versions, refer to the comments in newrelic.yml itself.

To update newrelic.yml file after a new release, use the template in the base directory of the agent gem. When you update to new gem versions, examine or diff config/newrelic.yml and newrelic.yml in the installation directory to take advantage of new configuration options.

Important

Updating the gem does not automatically update config/newrelic.yml.

General

These settings are available for agent configuration. Some settings depend on your New Relic subscription level.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_AGENT_ENABLED`

If true, allows the Ruby agent to run.

Type	String
Default	`(Dynamic)`
Environ variable	`NEW_RELIC_APP_NAME`

Specify the application name used to aggregate data in the New Relic UI. To report data to multiple apps at the same time, specify a list of names separated by a semicolon ;. For example, MyApp or MyStagingApp;Instance1.

Type	String
Default	`""`
Environ variable	`NEW_RELIC_LICENSE_KEY`

Your New Relic .

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_ACTIVE_SUPPORT_CUSTOM_EVENTS_NAMES`

An array of ActiveSupport custom event names to subscribe to and instrument. For example,

one.custom.event
another.event
a.third.event

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_BACKPORT_FAST_ACTIVE_RECORD_CONNECTION_LOOKUP`

Backports the faster ActiveRecord connection lookup introduced in Rails 6, which improves agent performance when instrumenting ActiveRecord. Note that this setting may not be compatible with other gems that patch ActiveRecord.

Type	String
Default	`nil`
Environ variable	`NEW_RELIC_CA_BUNDLE_PATH`

Manual override for the path to your local CA bundle. This CA bundle validates the SSL certificate presented by New Relic's data collection service.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_CAPTURE_PARAMS`

When true, the agent captures HTTP request parameters and attaches them to transaction traces, traced errors, and TransactionError events.

Caution

When using the capture_params setting, the Ruby agent will not attempt to filter secret information. Recommendation: To filter secret information from request parameters, use the attributes.include setting instead. For more information, see the Ruby attribute examples.

Type	String
Default	`(Dynamic)`
Environ variable	`NEW_RELIC_CONFIG_PATH`

Path to newrelic.yml. If undefined, the agent checks the following directories (in order):

config/newrelic.yml
newrelic.yml
$HOME/.newrelic/newrelic.yml
$HOME/newrelic.yml

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_FORCE_INSTALL_EXIT_HANDLER`

The exit handler that sends all cached data to the collector before shutting down is forcibly installed. This is true even when it detects scenarios where it generally should not be. The known use case for this option is when Sinatra runs as an embedded service within another framework. The agent detects the Sinatra app and skips the at_exit handler as a result. Sinatra classically runs the entire application in an at_exit block and would otherwise misbehave if the agent's at_exit handler was also installed in those circumstances. Note: send_data_on_exit should also be set to true in tandem with this setting.

Type	String
Default	`""`
Environ variable	`NEW_RELIC_LABELS`

A dictionary of label names and values that will be applied to the data sent from this agent. May also be expressed as a semicolon-delimited ; string of colon-separated : pairs. For example, Server:One;Data Center:Primary.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_SYNC_STARTUP`

When set to true, forces a synchronous connection to the New Relic collector during application startup. For very short-lived processes, this helps ensure the New Relic agent has time to report.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST`

An array of CLASS#METHOD (for instance methods) and/or CLASS.METHOD (for class methods) strings representing Ruby methods that the agent can automatically add custom instrumentation to. This doesn't require any modifications of the source code that defines the methods.

Use fully qualified class names (using the :: delimiter) that include any module or class namespacing.

Here is some Ruby source code that defines a render_png instance method for an Image class and a notify class method for a User class, both within a MyCompany module namespace:

module MyCompany
  class Image
    def render_png
      # code to render a PNG
    end
  end

  class User
    def self.notify
      # code to notify users
    end
  end
end

Given that source code, the newrelic.yml config file might request instrumentation for both of these methods like so:

automatic_custom_instrumentation_method_list:
  - MyCompany::Image#render_png
  - MyCompany::User.notify

That configuration example uses YAML array syntax to specify both methods. Alternatively, you can use a comma-delimited string:

automatic_custom_instrumentation_method_list: 'MyCompany::Image#render_png, MyCompany::User.notify'

Whitespace around the comma(s) in the list is optional. When configuring the agent with a list of methods via the NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST environment variable, use this comma-delimited string format:

bash

$export NEW_RELIC_AUTOMATIC_CUSTOM_INSTRUMENTATION_METHOD_LIST='MyCompany::Image#render_png, MyCompany::User.notify'

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_DEFER_RAILS_INITIALIZATION`

If true, when the agent is in an application using Ruby on Rails, it will start after config/initializers run.

Caution

This option may only be set by environment variable.

Transaction Tracer

The transaction traces feature collects detailed information from a selection of transactions, including a summary of the calling sequence, a breakdown of time spent, and a list of SQL queries and their query plans (on mysql and postgresql). Available features depend on your New Relic subscription level.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_TRANSACTION_TRACER_EXPLAIN_ENABLED`

If true, enables the collection of explain plans in transaction traces. This setting will also apply to explain plans in slow SQL traces if slow_sql.explain_enabled is not set separately.

Type	String
Default	`"obfuscated"`
Environ variable	`NEW_RELIC_TRANSACTION_TRACER_RECORD_SQL`

Obfuscation level for SQL queries reported in transaction trace nodes.

By default, this is set to obfuscated, which strips out the numeric and string literals.

If you do not want the agent to capture query information, set this to none.
If you want the agent to capture all query information in its original form, set this to raw.
When you enable high security mode, this is automatically set to obfuscated.

Type	Float
Default	`0.5`
Environ variable	`NEW_RELIC_TRANSACTION_TRACER_STACK_TRACE_THRESHOLD`

Specify a threshold in seconds. The agent includes stack traces in transaction trace nodes when the stack trace duration exceeds this threshold.

Type	Float
Default	`(Dynamic)`
Environ variable	`NEW_RELIC_TRANSACTION_TRACER_TRANSACTION_THRESHOLD`

Specify a threshold in seconds. Transactions with a duration longer than this threshold are eligible for transaction traces. Specify a float value or the string apdex_f.

Error Collector

The agent collects and reports all uncaught exceptions by default. These configuration options allow you to customize the error collection.

For information on ignored and expected errors, see this page on Error Analytics in APM. To set expected errors via the NewRelic::Agent.notice_error Ruby method, consult the Ruby agent API.

Type	Array
Default	`["ActionController::RoutingError", "Sinatra::NotFound"]`
Environ variable	`None`

A list of error classes that the agent should ignore.

Caution

This option can't be set via environment variable.

Type	Hash
Default	`{}`
Environ variable	`None`

A map of error classes to a list of messages. When an error of one of the classes specified here occurs, if its error message contains one of the strings corresponding to it here, that error will be treated as expected.

Caution

This option can't be set via environment variable.

Type	String
Default	`""`
Environ variable	`NEW_RELIC_ERROR_COLLECTOR_EXPECTED_STATUS_CODES`

A comma separated list of status codes, possibly including ranges. Errors associated with these status codes, where applicable, will be treated as expected.

Type	Hash
Default	`{}`
Environ variable	`None`

Caution

This option can't be set via environment variable.

Type	String
Default	`""`
Environ variable	`NEW_RELIC_ERROR_COLLECTOR_IGNORE_STATUS_CODES`

A comma separated list of status codes, possibly including ranges. Errors associated with these status codes, where applicable, will be ignored.

Type	Integer
Default	`50`
Environ variable	`NEW_RELIC_ERROR_COLLECTOR_MAX_BACKTRACE_FRAMES`

Defines the maximum number of frames in an error backtrace. Backtraces over this amount are truncated in the middle, preserving the beginning and the end of the stack trace.

Browser Monitoring

The page load timing feature (sometimes referred to as real user monitoring or RUM) gives you insight into the performance real users are experiencing with your website. This is accomplished by measuring the time it takes for your users' browsers to download and render your web pages by injecting a small amount of JavaScript code into the header and footer of each page.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_BROWSER_MONITORING_AUTO_INSTRUMENT`

If true, enables auto-injection of the JavaScript header for page load timing (sometimes referred to as real user monitoring or RUM).

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_BROWSER_MONITORING_CONTENT_SECURITY_POLICY_NONCE`

If true, enables auto-injection of Content Security Policy Nonce in browser monitoring scripts. For now, auto-injection only works with Rails 5.2+.

Transaction Events

Application Logging

The Ruby agent supports APM logs in context. For some tips on configuring logs for the Ruby agent, see Configure Ruby logs in context.

Available logging-related config options include:

Type	String
Default	`"debug"`
Environ variable	`NEW_RELIC_APPLICATION_LOGGING_FORWARDING_LOG_LEVEL`

Sets the minimum level a log event must have to be forwarded to New Relic.

This is based on the integer values of Ruby's Logger::Severity constants: https://github.com/ruby/ruby/blob/master/lib/logger/severity.rb

The intention is to forward logs with the level given to the configuration, as well as any logs with a higher level of severity.

For example, setting this value to "debug" will forward all log events to New Relic. Setting this value to "error" will only forward log events with the levels "error", "fatal", and "unknown".

Valid values (ordered lowest to highest):

"debug"
"info"
"warn"
"error"
"fatal"
"unknown"

Type	Hash
Default	`{}`
Environ variable	`NEW_RELIC_APPLICATION_LOGGING_FORWARDING_CUSTOM_ATTRIBUTES`

A hash with key/value pairs to add as custom attributes to all log events forwarded to New Relic. If sending using an environment variable, the value must be formatted like: "key1=value1,key2=value2"

AI Monitoring

This section includes Ruby agent configurations for setting up AI monitoring.

Important

You need to enable distributed tracing to capture trace and feedback data. It is turned on by default in Ruby agents 8.0.0 and higher.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_AI_MONITORING_ENABLED`

If false, all LLM instrumentation (OpenAI only for now) will be disabled and no metrics, events, or spans will be sent. AI Monitoring is automatically disabled if high_security mode is enabled.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_AI_MONITORING_RECORD_CONTENT_ENABLED`

If false, LLM instrumentation (OpenAI only for now) will not capture input and output content on specific LLM events.

The excluded attributes include:

content from LlmChatCompletionMessage events
input from LlmEmbedding events
This is an optional security setting to prevent recording sensitive data sent to and received from your LLMs.

Attributes

Attributes are key-value pairs containing information that determines the properties of an event or transaction. These key-value pairs can be viewed within transaction traces in APM, traced errors in APM, transaction events in dashboards, and page views in dashboards. You can customize exactly which attributes will be sent to each of these destinations

Audit Log

Autostart

Type	String
Default	`"Rails::Command::ConsoleCommand,Rails::Command::CredentialsCommand,Rails::Command::Db::System::ChangeCommand,Rails::Command::DbConsoleCommand,Rails::Command::DestroyCommand,Rails::Command::DevCommand,Rails::Command::EncryptedCommand,Rails::Command::GenerateCommand,Rails::Command::InitializersCommand,Rails::Command::NotesCommand,Rails::Command::RoutesCommand,Rails::Command::RunnerCommand,Rails::Command::SecretsCommand,Rails::Console,Rails::DBConsole"`
Environ variable	`NEW_RELIC_AUTOSTART_DENYLISTED_CONSTANTS`

Specify a list of constants that should prevent the agent from starting automatically. Separate individual constants with a comma ,. For example, "Rails::Console,UninstrumentedBackgroundJob".

Type	String
Default	`"irb,rspec"`
Environ variable	`NEW_RELIC_AUTOSTART_DENYLISTED_EXECUTABLES`

Defines a comma-delimited list of executables that the agent should not instrument. For example, "rake,my_ruby_script.rb".

Type	String
Default	"about,assets:clean,assets:clobber,assets:environment,assets:precompile,assets:precompile:all,db:create,db:drop,db:fixtures:load,db:migrate,db:migrate:status,db:rollback,db:schema:cache:clear,db:schema:cache:dump,db:schema:dump,db:schema:load,db:seed,db:setup,db:structure:dump,db:version,doc:app,log:clear,middleware,notes,notes:custom,rails:template,rails:update,routes,secret,spec,spec:features,spec:requests,spec:controllers,spec:helpers,spec:models,spec:views,spec:routing,spec:rcov,stats,test,test:all,test:all:db,test:recent,test:single,test:uncommitted,time:zones:all,tmp:clear,tmp:create,webpacker:compile"
Environ variable	`NEW_RELIC_AUTOSTART_DENYLISTED_RAKE_TASKS`

Defines a comma-delimited list of Rake tasks that the agent should not instrument. For example, "assets:precompile,db:migrate".

Cloud

Code Level Metrics

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_CODE_LEVEL_METRICS_ENABLED`

If true, the agent will report source code level metrics for traced methods. See: https://docs.newrelic.com/docs/apm/agents/ruby-agent/features/ruby-codestream-integration/

Cross Application Tracer

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_CROSS_APPLICATION_TRACER_ENABLED`

DEPRECATED Please see: distributed_tracing.enabled.

If true, enables cross-application tracing when distributed_tracing.enabled is set to false.

Custom Attributes

Custom Events

Type	Integer
Default	`3000`
Environ variable	`NEW_RELIC_CUSTOM_INSIGHTS_EVENTS_MAX_SAMPLES_STORED`

Specify a maximum number of custom events to buffer in memory at a time.
When configuring the agent for AI monitoring, set to max value 100000. This ensures the agent captures the maximum amount of LLM events.

Datastore Tracer

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_DATASTORE_TRACER_INSTANCE_REPORTING_ENABLED`

If false, the agent will not report datastore instance metrics, nor add host or port_path_or_id parameters to transaction or slow SQL traces.

Disabling

Use these settings to toggle instrumentation types during agent startup.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_DISABLE_MIDDLEWARE_INSTRUMENTATION`

If true, the agent won't wrap third-party middlewares in instrumentation (regardless of whether they are installed via Rack::Builder or Rails).

Important

When middleware instrumentation is disabled, if an application is using middleware that could alter the response code, the HTTP status code reported on the transaction may not reflect the altered value.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_DISABLE_SAMPLERS`

If true, disables the collection of sampler metrics. Sampler metrics are metrics that are not event-based (such as CPU time or memory usage).

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_DISABLE_RODA_AUTO_MIDDLEWARE`

If true, disables agent middleware for Roda. This middleware is responsible for advanced feature support such as page load timing and error collection.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_DISABLE_SINATRA_AUTO_MIDDLEWARE`

If true, disables agent middleware for Sinatra. This middleware is responsible for advanced feature support such as cross application tracing, page load timing, and error collection.

Important

Cross application tracing is deprecated in favor of distributed tracing. Distributed tracing is on by default for Ruby agent versions 8.0.0 and above. Middlewares are not required to support distributed tracing.

To continue using cross application tracing, update the following options in your newrelic.yml configuration file:

# newrelic.yml

  cross_application_tracer:
    enabled: true
  distributed_tracing:
    enabled: false

Distributed Tracing

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_DISTRIBUTED_TRACING_ENABLED`

Distributed tracing lets you see the path that a request takes through your distributed system. Enabling distributed tracing changes the behavior of some New Relic features, so carefully consult the transition guide before you enable this feature.

Elasticsearch

Heroku

Type	Array
Default	`["scheduler", "run"]`
Environ variable	`NEW_RELIC_HEROKU_DYNO_NAME_PREFIXES_TO_SHORTEN`

Ordinarily the agent reports dyno names with a trailing dot and process ID (for example, worker.3). You can remove this trailing data by specifying the prefixes you want to report without trailing data (for example, worker).

Infinite Tracing

Type	String
Default	`""`
Environ variable	`NEW_RELIC_INFINITE_TRACING_TRACE_OBSERVER_HOST`

Configures the hostname for the trace observer Host. When configured, enables tail-based sampling by sending all recorded spans to a trace observer for further sampling decisions, irrespective of any usual agent sampling decision.

Type	Symbol
Default	`:high`
Environ variable	`NEW_RELIC_INFINITE_TRACING_COMPRESSION_LEVEL`

Configure the compression level for data sent to the trace observer.

May be one of: :none, :low, :medium, :high.

Set the level to :none to disable compression.

Instrumentation

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_ACTIVE_SUPPORT_BROADCAST_LOGGER`

Controls auto-instrumentation of ActiveSupport::BroadcastLogger at start up. May be one of: auto, prepend, chain, disabled. Used in Rails versions >= 7.1.

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_ACTIVE_SUPPORT_LOGGER`

Controls auto-instrumentation of ActiveSupport::Logger at start up. May be one of: auto, prepend, chain, disabled. Used in Rails versions below 7.1.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_INSTRUMENTATION_GRPC_HOST_DENYLIST`

Specifies a list of hostname patterns separated by commas that will match gRPC hostnames that traffic is to be ignored by New Relic for. New Relic's gRPC client instrumentation will ignore traffic streamed to a host matching any of these patterns, and New Relic's gRPC server instrumentation will ignore traffic for a server running on a host whose hostname matches any of these patterns. By default, no traffic is ignored when gRPC instrumentation is itself enabled. For example, "private.com$,exception.*"

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_MEMCACHE_CLIENT`

Controls auto-instrumentation of memcache-client gem for Memcache at start-up. May be one of: auto, prepend, chain, disabled.

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_RUBY_OPENAI`

Controls auto-instrumentation of the ruby-openai gem at start-up. May be one of: auto, prepend, chain, disabled. Defaults to disabled in high security mode.

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_PUMA_RACK`

Controls auto-instrumentation of Puma::Rack. When enabled, the agent hooks into the to_app method in Puma::Rack::Builder to find gems to instrument during application startup. May be one of: auto, prepend, chain, disabled.

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_RACK`

Controls auto-instrumentation of Rack. When enabled, the agent hooks into the to_app method in Rack::Builder to find gems to instrument during application startup. May be one of: auto, prepend, chain, disabled.

Type	String
Default	`auto`
Environ variable	`NEW_RELIC_INSTRUMENTATION_THREAD`

Controls auto-instrumentation of the Thread class at start-up to allow the agent to correctly nest spans inside of an asynchronous transaction. This does not enable the agent to automatically trace all threads created (see instrumentation.thread.tracing). May be one of: auto, prepend, chain, disabled.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_INSTRUMENTATION_THREAD_TRACING`

Controls auto-instrumentation of the Thread class at start-up to automatically add tracing to all Threads created in the application.

Message Tracer

Mongo

Opensearch

Process Host

Rake

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_RAKE_TASKS`

Specify an Array of Rake tasks to automatically instrument. This configuration option converts the Array to a RegEx list. If you'd like to allow all tasks by default, use rake.tasks: [.+]. No rake tasks will be instrumented unless they're added to this list. For more information, visit the New Relic Rake Instrumentation docs.

Rules

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_RULES_IGNORE_URL_REGEXES`

Define transactions you want the agent to ignore, by specifying a list of patterns matching the URI you want to ignore. For more detail, see the docs on ignoring specific transactions.

Security

Type	Integer
Default	`nil`
Environ variable	`NEW_RELIC_SECURITY_APPLICATION_INFO_PORT`

The port the application is listening on. This setting is mandatory for Passenger servers. The agent detects other servers by default.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_SECURITY_EXCLUDE_FROM_IAST_SCAN_API`

Defines API paths the security agent should ignore in IAST scans. Accepts an array of regex patterns matching the URI to ignore. The regex pattern should find a complete match for the URL without the endpoint. For example, [".*account.*"], [".*/\api\/v1\/.*?\/login"]

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_SECURITY_EXCLUDE_FROM_IAST_SCAN_HTTP_REQUEST_PARAMETERS_HEADER`

An array of HTTP request headers the security agent should ignore in IAST scans. The array should specify a list of patterns matching the headers to ignore.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_SECURITY_EXCLUDE_FROM_IAST_SCAN_HTTP_REQUEST_PARAMETERS_QUERY`

An array of HTTP request query parameters the security agent should ignore in IAST scans. The array should specify a list of patterns matching the HTTP request query parameters to ignore.

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_SECURITY_EXCLUDE_FROM_IAST_SCAN_IAST_DETECTION_CATEGORY_INSECURE_SETTINGS`

If true, disables the detection of low-severity insecure settings. For example, hash, crypto, cookie, random generators, trust boundary).

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_SECURITY_EXCLUDE_FROM_IAST_SCAN_IAST_DETECTION_CATEGORY_INVALID_FILE_ACCESS`

If true, disables file operation-related IAST detections (File Access & Application integrity violation)

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_SECURITY_SCAN_SCHEDULE_ALWAYS_SAMPLE_TRACES`

If true, allows IAST to continuously gather trace data in the background. Collected data will be used by the security agent to perform an IAST scan at the scheduled time.

Type	Integer
Default	`3600`
Environ variable	`NEW_RELIC_SECURITY_SCAN_CONTROLLERS_IAST_SCAN_REQUEST_RATE_LIMIT`

Sets the maximum number of HTTP requests allowed for the IAST scan per minute. Any Integer between 12 and 3600 is valid. The default value is 3600.

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_SECURITY_SCAN_CONTROLLERS_REPORT_HTTP_RESPONSE_BODY`

If true, enables the sending of HTTP responses bodies. Disabling this also disables Reflected Cross-Site Scripting (RXSS) vulnerability detection.

Type	String
Default	`nil`
Environ variable	`NEW_RELIC_SECURITY_IAST_TEST_IDENTIFIER`

A unique test identifier when runnning IAST in a CI/CD environment to differentiate between different test runs. For example, a build number.

Serverless Mode

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_SERVERLESS_MODE_ENABLED`

If true, the agent will operate in a streamlined mode suitable for use with short-lived serverless functions. NOTE: Only AWS Lambda functions are supported currently and this option is not intended for use without New Relic's Ruby Lambda layer offering.

Sidekiq

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_SIDEKIQ_ARGS_INCLUDE`

An array of strings that will collectively serve as an allowlist for filtering which Sidekiq job arguments get reported to New Relic. To capture any Sidekiq arguments, 'job.sidekiq.args.*' must be added to the separate :'attributes.include' configuration option. Each string in this array will be turned into a regular expression via Regexp.new to permit advanced matching. For job argument hashes, if either a key or value matches the pair will be included. All matching job argument array elements and job argument scalars will be included.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_SIDEKIQ_ARGS_EXCLUDE`

An array of strings that will collectively serve as a denylist for filtering which Sidekiq job arguments get reported to New Relic. To capture any Sidekiq arguments, 'job.sidekiq.args.*' must be added to the separate :'attributes.include' configuration option. Each string in this array will be turned into a regular expression via Regexp.new to permit advanced matching. For job argument hashes, if either a key or value matches the pair will be excluded. All matching job argument array elements and job argument scalars will be excluded.

Slow SQL

Type	Boolean
Default	`true`
Environ variable	`NEW_RELIC_SLOW_SQL_EXPLAIN_ENABLED`

If true, the agent collects explain plans in slow SQL queries. If this setting is omitted, the transaction_tracer.explain_enabled setting will be applied as the default setting for explain plans in slow SQL as well.

Span Events

Type	Integer
Default	`2000`
Environ variable	`NEW_RELIC_SPAN_EVENTS_MAX_SAMPLES_STORED`

Defines the maximum number of span events reported from a single harvest. Any Integer between 1 and 10000 is valid.'
When configuring the agent for AI monitoring, set to max value 10000.This ensures the agent captures the maximum amount of distributed traces.

Strip Exception Messages

Type	Boolean
Default	`false`
Environ variable	`NEW_RELIC_STRIP_EXCEPTION_MESSAGES_ENABLED`

If true, the agent strips messages from all exceptions except those in the allowlist. Enabled automatically in high security mode.

Type	String
Default	`""`
Environ variable	`NEW_RELIC_STRIP_EXCEPTION_MESSAGES_ALLOWED_CLASSES`

Specify a list of exceptions you do not want the agent to strip when strip_exception_messages is true. Separate exceptions with a comma. For example, "ImportantException,PreserveMessageException".

Stripe

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_STRIPE_USER_DATA_INCLUDE`

An array of strings to specify which keys inside a Stripe event's user_data hash should be reported to New Relic. Each string in this array will be turned into a regular expression via Regexp.new to permit advanced matching. Setting the value to ["."] will report all user_data.

Type	Array
Default	`[]`
Environ variable	`NEW_RELIC_STRIPE_USER_DATA_EXCLUDE`

An array of strings to specify which keys and/or values inside a Stripe event's user_data hash should not be reported to New Relic. Each string in this array will be turned into a regular expression via Regexp.new to permit advanced matching. For each hash pair, if either the key or value is matched the pair is not reported. By default, no user_data is reported. Use this option only if the stripe.user_data.include option is also used.

Configuration methods and precedence .css-21sua1{background:none;border:none;width:0;padding:0;}

View and edit config file options

Update the config file

Important

General

app_name

license_key

log_level

active_support_custom_events_names

api_key

backport_fast_active_record_connection_lookup

ca_bundle_path

capture_memcache_keys

capture_params

clear_transaction_state_after_fork

config_path

exclude_newrelic_header

force_install_exit_handler

high_security

labels

log_file_name

log_file_path

marshaller

monitor_mode

prepend_active_record_instrumentation

proxy_host

proxy_pass

proxy_port

proxy_user

security_policies_token

send_data_on_exit

sync_startup

thread_local_tracer_state

timeout

allow_all_headers

automatic_custom_instrumentation_method_list

defer_rails_initialization

Transaction Tracer

transaction_tracer.enabled

transaction_tracer.explain_enabled

transaction_tracer.explain_threshold

transaction_tracer.limit_segments

transaction_tracer.record_redis_arguments

transaction_tracer.record_sql

transaction_tracer.stack_trace_threshold

transaction_tracer.transaction_threshold

Error Collector

error_collector.ignore_classes

error_collector.capture_events

error_collector.enabled

error_collector.expected_classes

error_collector.expected_messages

error_collector.expected_status_codes

error_collector.ignore_messages

error_collector.ignore_status_codes

error_collector.max_backtrace_frames

error_collector.max_event_samples_stored

Browser Monitoring

browser_monitoring.auto_instrument

browser_monitoring.content_security_policy_nonce

Transaction Events

transaction_events.enabled

transaction_events.max_samples_stored

Application Logging

application_logging.enabled

application_logging.forwarding.enabled

application_logging.forwarding.log_level

application_logging.forwarding.custom_attributes

application_logging.forwarding.labels.enabled

application_logging.forwarding.labels.exclude

application_logging.forwarding.max_samples_stored

application_logging.local_decorating.enabled

application_logging.metrics.enabled

AI Monitoring

Important

ai_monitoring.enabled

ai_monitoring.record_content.enabled

Attributes

attributes.enabled

Configuration methods and precedence