Newrelic Noticeerror Error Detection and Notification

New Relic's NoticeError feature allows you to detect and notify errors in your application.

With NoticeError, you can set up custom error notifications to alert you when specific errors occur.

NoticeError can be configured to send notifications to various channels, including email, Slack, and PagerDuty.

This feature enables you to stay on top of errors and take swift action to resolve them.

Handling errors is a crucial part of ensuring your application's stability and performance. You can collect errors that the PHP agent doesn't handle automatically by adding a call to the function you want to report on.

To report errors from your own error handler in PHP version 5.5 or lower, make sure the PHP agent notices errors from within your own error handler. This can be done by using the newrelic_notice_error function.

The New Relic Ruby agent provides an API to notify it of an error. The notice_error method takes an exception and an optional options hash. You can use this format to record the given error and pass it through the normal error filtering process.

To dynamically apply an error group to each noticed error, you can supply a callback function to the agent. In Ruby, you can use the NewRelic::Agent.set_error_group_callback method to provide the agent with a callback.

The callback function is expected to receive exactly one input argument, a hash containing information about the error. The hash includes the error class instance, custom attributes, request URI, HTTP status code, HTTP method, and whether the error was expected.

In Go, you can use the newrelic.ConfigSetErrorGroupCallbackFunction method to provide the agent with a callback. The callback function is expected to receive exactly one input argument, a newrelic.ErrorInfo object containing information about the error.

If you need to filter exceptions dynamically based on the attributes of a specific exception type, you can supply a callback function. The callback function should return True if the exception should be ignored or expected, False if it should never be ignored or expected, and None if subsequent checks and inbuilt rules should determine if the exception should be ignored or expected.

Here's a summary of the methods you can use to handle errors:

To notify New Relic of an error, you can use the `notice_error` API call. This is especially useful for non-PHP errors that the PHP agent doesn't handle automatically.

You can add a call to `notice_error` in the function you want to report on, passing in the exception and an optional options hash. If needed, you can include options = { }.

The options hash can contain special parameters that receive special treatment. Here are some of them:

To collect errors that the PHP agent doesn't handle automatically, you'll need to add a specific call to the function you want to report on. This will ensure that any non-PHP errors are recorded and reported.

The New Relic Ruby agent has a specific API call to notify it of an error. This call takes the exception and an optional options hash, which allows you to customize the error reporting.

You can use the following format for the API call: notice_error(exception, options = {}). This will record the given error and pass it through the normal error filtering process.

Here are some special parameters that will receive special treatment when using the notice_error API call:

These options allow you to customize the error reporting and provide more detailed information about the error.

Apply Group to Noticed Items

You can dynamically apply an error group to each noticed error using a callback function. This is done by supplying a callback method to the agent, which will then apply the desired error group to each noticed error.

To do this in Ruby, you can use the NewRelic::Agent.set_error_group_callback API method, which takes a callback method of type Proc as its only argument. This method will update to the newest provided callback if subsequent calls are made.

In the Ruby example, a callback proc is created that will accept a hash as its only argument and return the string "Access" for the desired error group name if the hash contains an HTTP status code key with a value of 401.

Similarly, in Go, you can use the newrelic.ConfigSetErrorGroupCallbackFunction API call to provide the agent with a callback function. This API call takes a callback method of type newrelic.ErrorGroupCallback as its only argument.

The callback function in Go is expected to receive exactly one input argument, a newrelic.ErrorInfo object, which contains various attributes such as the noticed error object, time occurred, message, class, and more.

Here's a comparison of the attributes received by the callback function in Ruby and Go:

Note that some attributes are only available in one of the two languages, so be sure to check the specific documentation for your chosen language.

To get accurate error reporting with New Relic, make sure to report exceptions from your own exception handler. This ensures that New Relic notices any exceptions that occur within your application's custom error handling code.

If you're using PHP version 5.5 or lower, report errors from your own error handler as well. This is crucial for getting a complete picture of errors in your application.

New Relic can only notice exceptions that occur within the PHP agent's own exception handling code, so don't rely solely on the PHP agent to catch all exceptions. By reporting exceptions from your own exception handler, you'll get more accurate and comprehensive error reporting.

In PHP version 5.5 or lower, don't forget to report errors from within your own error handler. This will help you identify and fix errors that occur within your custom error handling code.

You can use your own error and exception handler with New Relic by setting newrelic_notice_error as the callback for set_exception_handler() and set_error_handler() in PHP.

In Python, you can record any Python exception as an error using the notice_error() function, which can then be found in the UI. This function reports the details of the exception against the application that the request or task is being reported to.

You can record up to five distinct exceptions per transaction and up to 20 total exceptions across all transactions per harvest cycle in Python. If called outside of a monitored request or task, the call will be ignored unless the application keyword argument is provided.

Passing a message with custom attributes is a powerful way to collect errors in New Relic. This method allows you to specify key/value pairs of attributes to annotate the event.

The agent has some limitations to keep in mind: sending a lot of events can increase the memory overhead, and posts greater than 1MB in size will not be recorded.

You can pass up to 64 attributes, and for more information about how custom attribute values are processed, see the custom attributes guide.

Here are the parameters to keep in mind:

Remember, this method only works when used within a transaction created using the Transaction attribute with the Web property set to true.

The PHP agent handles PHP errors and exceptions automatically for supported frameworks. This means you don't need to do anything extra for most cases.

You can use newrelic_notice_error to collect errors that are not handled automatically, so you can query for those errors in New Relic and view error traces. To do this, you need to add a call to your function that you want to report on.

If you want to use your own error and exception handlers, you can set newrelic_notice_error as the callback. This allows you to handle errors and exceptions in a custom way.

You can also use a callback function to filter exceptions dynamically based on the attributes of a specific exception type. This can be useful if you need to ignore certain exceptions based on specific conditions.

The callback function should return True if the exception is to be ignored or expected, and False if it should never be ignored or expected. If you don't specify a return value, subsequent checks and built-in rules will determine if the exception should be ignored or expected.