Default Grouping

Error Tracking intelligently groups similar errors into issues. This grouping is based on the following error properties:

• service: The service where the error occurred.
• error.type or error.kind: The class of the error.
• error.message: A description of the error.
• error.stack: The filename and function name of the top-most meaningful stack frame.

The error stack trace is the code path followed by an error between being thrown and being captured by Datadog instrumentation. Error Tracking evaluates the topmost stack frame (the location of the error) and uses it to group the error.

If any stack frame properties differ for two given errors, the two errors are grouped under different issues. For example, Error Tracking does not group issues across services or error types. Error Tracking also ignores numbers, punctuation, and anything that is between quotes or parentheses: only word-like tokens are used.

Note: To improve grouping accuracy, Error Tracking removes variable stack frame properties such as versions, ids, dates, and so on.

Custom Grouping

Error Tracking intelligently groups similar errors into issues with a default strategy. By using custom fingerprinting, you can gain full control over the grouping decision and customize the grouping behavior for your error spans.

You can customize grouping by providing an error.fingerprint for the error. The fingerprint is provided in an attribute or tag, depending on the error source (see Setup for details). While the value of error.fingerprint does not have any particular format or requirement, the content must be a string.

If error.fingerprint is provided, the grouping behavior follows these rules:

• Custom grouping takes precedence over the default strategy.
• Custom grouping can be applied only to a subset of your errors and can coexist with the default strategy.
• The content of error.fingerprint is used as-is without any modification (although it is converted to a standardized fingerprint format).
• Errors from the same service and with the same error.fingerprint attribute are grouped into the same issue.
• Errors with different service attributes are grouped into different issues.

Setup

Custom grouping only needs an error log and an error.fingerprint string attribute.

If you aren't already collecting logs with Datadog, see the Log Management documentation to set up logs.

Ensure that the source tag (specifying language) is properly configured.

import logging
import json_log_formatter

formatter = json_log_formatter.JSONFormatter()

json_handler = logging.FileHandler(filename='/var/log/my-log.json')
json_handler.setFormatter(formatter)

logger = logging.getLogger('my_json')
logger.addHandler(json_handler)
logger.setLevel(logging.INFO)

logger.error('Error processing request', extra={'error.fingerprint': 'my-custom-grouping-material'})

val errorFingerprint = "my-custom-grouping-material"
val attributes = mapOf(LogAttributes.ERROR_FINGERPRINT to errorFingerprint)
logger.e("My error message", error, attributes)

val mapper = object : EventMapper<LogEvent> {
    override fun map(event: LogEvent): LogEvent {
        event.fingerprint = "my-custom-grouping-material"
        return event
    }
}
val logsConfiguration = LogsConfiguration.Builder()
    .setEventMapper(mapper)
    .build()
Logs.enable(logsConfiguration)

final errorFingerprint = "my-custom-grouping-material";
logger.error(
  'My error message',
  errorStackTrace: st,
  attributes {
    DatadogAttributes.errorFingerprint: "my-custom-grouping-material",
  }
);

LogEvent? mapLogEvent(LogEvent event) {
  event.error?.fingerprint = "my-custom-grouping-material";
  return event;
}

final loggingConfiguration = DatadogLoggingConfiguration(
  eventMapper: mapLogEvent,
);

final configuration = DatadogConfiguration(
    // ...
    loggingConfiguration: loggingConfiguration,
);

let errorFingerprint = "my-custom-grouping-material"
logger.error(
  "My error message",
  error: error,
  attributes: [
    Logs.Attributes.errorFingerprint: errorFingerprint
  ]
)

let logsConfiguration = Logs.Configuration(
  eventMapper: { log in
      var log = log
      log.error?.fingerprint = "my-custom-grouping-material"
      return log
  }
)
Logs.enable(
  with: logsConfiguration
)

DdLogs.error(
  'message',
  'my-error-type',
  'my-error-message',
  'my-stack-trace',
  { my: 'context' },
  'my-custom-fingerprint'
);

configuration.errorEventMapper = event => {
  event.fingerprint = 'my-custom-fingerprint'
  return event;
};