Agrupación predeterminada

Error Tracking agrupa de forma inteligente errores similares en incidentes. Esta agrupación se basa en las siguientes propiedades de los errores:

• service: el servicio donde se ha producido el error.
• error.type o error.kind: la clase del error.
• error.message: descripción del error.
• error.stack: el nombre de archivo y el nombre de función del marco de stack tecnológico más significativo.

El stack trace de errores es la ruta de código seguida por un error que está entre ser lanzado y capturado por la instrumentación de Datadog. Error Tracking evalúa el marco de stack tecnológico superior (la localización del error) y lo utiliza para agrupar el error.

Si alguna de las propiedades del marco de stack tecnológico difiere para dos errores dados, los dos errores se agrupan en incidentes diferentes. Por ejemplo, Error Tracking no agrupa incidentes en servicios o tipos de error. Error Tracking también ignora números, signos de puntuación y todo lo que se encuentre entre comillas o paréntesis: sólo se utilizan símbolos similares a palabras.

Nota: Para mejorar la precisión de la agrupación, Error Tracking elimina las propiedades variables del marco de stack tecnológico, como versiones, ids, fechas, etc.

Agrupación personalizada

Error Tracking agrupa de forma inteligente errores similares en incidentes con una estrategia predeterminada. Al utilizar huellas personalizadas, puedes obtener un control total sobre la decisión de agrupación y personalizar el comportamiento de agrupación para tus tramos de errores.

Puedes personalizar la agrupación proporcionando una error.fingerprint para el error. La huella digital se proporciona en un atributo o en una etiqueta, dependiendo de la fuente del error (consulta Configuración para más detalles). Aunque el valor de error.fingerprint no tiene ningún formato o requisito en particular, el contenido debe ser una cadena.

Si se proporciona error.fingerprint, el comportamiento de agrupación sigue estas reglas:

• La agrupación personalizada tiene prioridad sobre la estrategia por defecto.
• La agrupación personalizada puede aplicarse sólo a un subconjunto de tus errores y puede coexistir con la estrategia por defecto.
• El contenido de error.fingerprint se utiliza tal cual, sin ninguna modificación (aunque se convierte a un formato de huella digital normalizado).
• Los errores del mismo servicio y con el mismo atributo error.fingerprint se agrupan en el mismo incidente.
• Los errores con diferentes atributos servicio se agrupan en diferentes incidentes.

Configuración

APM

La agrupación personalizada sólo necesita un tramo de error y una etiqueta de tramo de cadena error.fingerprint.

Si aún no estás recopilando trazas de APM con Datadog, consulta la documentación de APM para configurar APM.

Ejemplo

Si ya estás enviando tramos de APM, añade una nueva etiqueta error.fingerprint a tu tramo de error.

He aquí un ejemplo en Python:

with tracer.trace("throws.an.error") as span:
  span.set_tag('error.fingerprint', 'my-custom-grouping-material')
  raise Exception("Something went wrong")

La información de la excepción se captura y se adjunta a un tramo si hay uno activo cuando se produce la excepción. En este caso, my-custom-grouping-material se utiliza para agrupar estos tramos de error en un único incidente en Error Tracking.

Gestión de Logs

La agrupación personalizada sólo necesita un log de error y un atributo de cadena error.fingerprint.

Si aún no estás recopilando logs con Datadog, consulta la documentación de Log Management para configurar logs.

Asegúrate de que la etiqueta source (que especifica el lenguaje) está correctamente configurada.

Ejemplo

Si ya estás recopilando logs en formato JSON, añade un nuevo atributo error.fingerprint a tu log de error.

He aquí un ejemplo en Python para un registrador con formato JSON:

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'})

En este caso, my-custom-grouping-material se utiliza para agrupar estos logs de errores en un único incidente en Error Tracking.

Ejemplo de móvil

En los SDKs móviles de Datadog, puedes añadir una huella digital de error personalizada cuando registras un error al añadir un atributo predefinido a la llamada de log:

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

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

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

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

O bien, puedes añadir o ajustar la huella digital en el asignador de logs:

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)

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

final loggingConfiguration = DatadogLoggingConfiguration(
  eventMapper: mapLogEvent,
);

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

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

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

RUM

Ejemplo

Si aún no estás recopilando eventos de navegador de RUM con Datadog, consulta la Documentación de configuración de la Monitorización del navegador RUM o la Documentación de configuración de la Monitorización de RUM Mobile y TV.

GlobalRumMonitor.get().addError(
  "My error message",
  RumErrorSource.SOURCE,
  exception,
  mapOf(
    RumAttributes.ERROR_CUSTOM_FINGERPRINT to "my-custom-grouping-fingerprint"
  )
)

val rumConfiguration = RumConfiguration.Builder("rum-application-id")
  .setErrorEventMapper(object : EventMapper<ErrorEvent> {
    override fun map(event: ErrorEvent): ErrorEvent {
        event.error.fingerprint = "my-custom-grouping-fingerprint"
        return event
    }
  }).build()
RUM.enable(rumConfiguration)

import { datadogRum } from '@datadog/browser-rum';
// Send a custom error with context
const error = new Error('Something went wrong');
error.dd_fingerprint = 'my-custom-grouping-fingerprint'
datadogRum.addError(error);

DD_RUM.init({
  ...
  beforeSend: () => {
    if (event.type === 'error') {
      event.error.fingerprint = 'my-custom-grouping-fingerprint'
    }
  },
})

final rum = DatadogSdk.instance.rum;
rum?.addErrorInfo("My error message",
  RumErrorSource.source,
  attributes: {
    DatadogAttributes.errorFingerprint: 'my-custom-grouping-fingerprint',
  },
);

RumErrorEvent? mapRumErrorEvent(RumErrorEvent event) {
  event.error.fingerprint = "my-custom-grouping-fingerprint";
  return event;
}

final rumConfiguration = DatadogRumConfiguration(
  // ...
  errorEventMapper: mapRumErrorEvent,
);

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

RUMMonitor.shared().addError(
  message: "My error message",
  source: .source,
  attributes: [
    RUM.Attributes.errorFingerprint: "my-custom-grouping-fingerprint"
  ]
)

var config = RUM.Configuration(applicationID: "rum-application-id")
config.errorEventMapper = { errorEvent in
  var errorEvent = errorEvent
  errorEvent.error.fingerprint = "my-custom-grouping-fingerprint"
  return errorEvent
}
RUM.enable(with: config)

DdRum.addError(
  'message',       
  'my-source',       
  'my-stack-trace',  
  { my: 'context' },
  Date.now(), 
  'my-custom-fingerprint'        
);

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