Salta una alerta: la tasa de errores de un servicio sube. Encuentras la traza lenta y después buscas a mano los logs correspondientes, por marca de tiempo, en tres pods distintos. Con los logs de OpenTelemetry en Dynatrace te ahorras ese paso gracias al trace_id: desde una traza abres directamente las líneas de log que ha producido.
Objetivo de este tutorial: hacer que cada log lleve el contexto de traza (trace_id, span_id) por dos caminos, el SDK de OpenTelemetry que exporta los logs en OTLP y el Collector que lee archivos de logs existentes, y verificar después la correlación. El contenido se centra en Dynatrace SaaS (logs sobre Grail); en Dynatrace Managed también existe la ingesta OTLP de logs, pero comprueba la versión mínima y las pantallas disponibles en la documentación de tu clúster.
Este tema complementa el Collector de OpenTelemetry hacia Dynatrace y su despliegue en Kubernetes.
Requisitos previos
- Un token de API con el scope
logs.ingest(yopenTelemetryTrace.ingestpara las trazas). - Una aplicación ya trazada con OpenTelemetry. El ejemplo usa Python 3.10+; el principio es idéntico en Java, Go o .NET.
- Para la parte de archivos: un Collector contrib (receiver
filelog, renombradofile_logen las versiones recientes; el nombre antiguo sigue aceptándose como alias obsoleto). - Endpoint OTLP:
https://<env-id>.live.dynatrace.com/api/v2/otlp(SaaS) ohttps://<votre-domaine>/e/<env-id>/api/v2/otlp(Managed).
Logs de OpenTelemetry en Dynatrace: correlación por trace_id
Un log de OpenTelemetry es un registro estructurado. El modelo de datos prevé dos campos específicos, TraceId y SpanId. Cuando el log se emite dentro de un span activo, el SDK los rellena automáticamente. Dynatrace almacena entonces esos identificadores junto con el log, lo que permite pasar de la traza al log y viceversa. Sin esos campos, la correlación depende de la hora, y eso no aguanta bajo carga.
Conviene recordar que un log no es un span. No emitas eventos de span para sustituir a los logs, ni al revés.
Camino 1: exportar los logs de OpenTelemetry a Dynatrace desde el SDK
Paso 1: instalar los paquetes
pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
Paso 2: conectar el handler de logs
import logging
from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry._logs import set_logger_provider
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
resource = Resource.create({"service.name": "checkout"})
tp = TracerProvider(resource=resource)
tp.add_span_processor(BatchSpanProcessor(OTLPSpanExporter()))
trace.set_tracer_provider(tp)
lp = LoggerProvider(resource=resource)
lp.add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter()))
set_logger_provider(lp)
logging.getLogger().addHandler(LoggingHandler(level=logging.INFO, logger_provider=lp))
logging.getLogger().setLevel(logging.INFO)
tracer = trace.get_tracer("checkout")
log = logging.getLogger("checkout")
with tracer.start_as_current_span("payer-commande"):
log.warning("paiement refusé", extra={"order.id": "A-1042"})
Las líneas críticas:
- El mismo
Resourcepara trazas y logs: así Dynatrace asocia ambos al mismo servicio. LoggingHandlerconvierte cada registro deloggingen un log de OpenTelemetry, con eltrace_iddel span activo.- Los módulos
_logsllevan un guion bajo: la API de logs del SDK de Python sigue marcada como experimental. Desde opentelemetry-sdk 1.40,LoggingHandlerestá además obsoleto en favor del paqueteopentelemetry-instrumentation-logging(LoggingInstrumentor); el código anterior sigue funcionando, pero fija tus versiones y prevé la migración. extrase convierte en atributos del log: mantén claves estables y poco numerosas.
Paso 3: configurar la exportación con variables de entorno
export OTEL_EXPORTER_OTLP_ENDPOINT="https://<env-id>.live.dynatrace.com/api/v2/otlp"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Api-Token%20dt0c01.XXXX"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
El espacio tras Api-Token se codifica como %20. Los exporters añaden por sí mismos /v1/traces y /v1/logs al endpoint. En producción, apunta mejor a un Collector local.
Camino 2: leer archivos de logs con el Collector
Muchas aplicaciones ya escriben logs JSON en la salida estándar. Si incluyen el trace_id (por ejemplo, mediante la instrumentación de logging que añade otelTraceID al formato), el Collector puede promoverlo a campo de traza.
receivers:
filelog:
include: [/var/log/pods/*/*/*.log]
include_file_path: true
operators:
- type: container # retire l'enveloppe du runtime
- type: json_parser
parse_from: body
parse_to: attributes
- type: trace_parser
trace_id:
parse_from: attributes.trace_id
span_id:
parse_from: attributes.span_id
processors:
batch: {}
exporters:
otlphttp/dynatrace:
endpoint: ${env:DT_ENDPOINT}
headers:
Authorization: "Api-Token ${env:DT_API_TOKEN}"
service:
pipelines:
logs:
receivers: [filelog]
processors: [batch]
exporters: [otlphttp/dynatrace]
container: el operador reconoce los formatos CRI y Docker. En las versiones antiguas del Collector no existe; usa entonces los operadores de parsing descritos en la documentación del receiver.trace_parser: copia el atributo a los camposTraceId/SpanIddel modelo OTel. Eso es lo que hace nativa la correlación.- Adapta
attributes.trace_idal nombre real del campo en tus logs (traceId,otelTraceID…).
En Kubernetes, añade k8sattributes para recuperar el pod y el namespace. Si prefieres transformar los logs en Dynatrace, la ingesta de logs en self-service y OpenPipeline ofrecen una alternativa.
Cómo comprobar que funciona
- En el Collector, busca errores de exportación:
kubectl -n observability logs ds/otel-node-opentelemetry-collector | grep -iE "logs|error|401|413"Un
413indica un lote demasiado grande: reducesend_batch_size. - En SaaS, en un Notebook:
fetch logs, from: now() - 30m | filter isNotNull(trace_id) | summarize logs = count(), by: {service.name, loglevel}El nombre exacto de los campos de traza en los logs puede variar según la fuente; inspecciona un registro con
fetch logs | limit 1antes de filtrar. - Toma un
trace_idencontrado y después:fetch spans, from: now() - 30m | filter trace.id == "<trace_id>" | fields start_time, span.name, durationSi la traza y los logs salen con el mismo identificador, la correlación está en marcha. En la interfaz, la vista de una traza también debe ofrecer los logs asociados.
- En Managed, abre el visor de logs, filtra por el servicio y comprueba que el log muestra un enlace a la traza. La ubicación exacta depende de la versión: consulta docs.dynatrace.com.
Buenas prácticas
- Un solo camino por log: si la aplicación exporta en OTLP, no vuelvas a leer también su archivo, o cada línea llegará dos veces.
- Nivel INFO como mínimo en producción: el volumen de logs suele ser la primera partida de coste.
- Sin datos personales en el cuerpo ni en los atributos; enmascáralos en el Collector o en OpenPipeline.
- Logs estructurados: un JSON estable se parsea una sola vez y reduce el toil.
- Muestreo coherente: si muestreas las trazas, algunos logs apuntarán a una traza ausente. Es normal; conserva todos los logs de error.
Preguntas frecuentes
¿OneAgent ya hace esta correlación?
Para las tecnologías que instrumenta, OneAgent puede enriquecer los logs con el contexto de traza. El camino de OpenTelemetry sirve cuando OneAgent no está presente o cuando estandarizas en OTel.
¿Por qué mis logs llegan sin trace_id?
El log se emitió fuera de un span activo (arranque, tarea en segundo plano), o el parsing no encontró el campo. Comprueba el nombre del campo y el contexto de ejecución.
¿Hay que enviar los logs por gRPC o por HTTP?
La API OTLP de Dynatrace acepta HTTP con protobuf. Usa otlphttp hacia Dynatrace; gRPC sigue siendo posible entre tus aplicaciones y el Collector.
Conclusión
Unos logs de OpenTelemetry que llevan su trace_id ahorran minutos valiosos en cada incidente: la traza muestra dónde, el log explica por qué. Empieza por un servicio crítico, verifica la unión en DQL y extiende después a tus otras cargas de trabajo. Como siguiente paso, vincula estas señales con tus objetivos mediante SLO de OpenTelemetry en DQL.
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión. Los campos y las pantallas evolucionan: compruébalos en la documentación oficial.