Posts Tagged - azure-monitor

Export telemetry to Azure Monitor (OpenTelemetry)

Understand telemetry export to Application Insights

La pipe de export de telemetria mueve tus datos desde tu app a Application Insights siguiendo una serie de pasos.

El OpenTelemetry SDK recoge telemetria de instrumentation libraries y custom spans. El Azure Monitor exporter serializa los datos que envia al Application Insights ingestion endpoint identificado por tu connection string. Este proceso ocurre entero dentro de los limites de tu app.

La Azure Monitor OpenTelemetry Distro usa direct export by default. Esto significa que la app envia la telemetria directamente al ingestion endpoint del Application Insights, sin un intermediario.
Este approach simplifica el deployment ya que no hay infraestructura adicional.
La alternativa es usar OpenTelemetry Collector, un proceso separado que recibe telemetria de apps, la procesa y la reenvia a uno o más backends. El Collector añade complejidad operacional pero ofrece más capacidades como sampling centralizado, data transformation y multi-backend routing.

Cuando la telemetría llega a Application Insights, se mapea en diferentes tablas:

  • Server spans (SpanKind.SERVER y SpanKind.CONSUMER) aparecen en la tabla requests
  • Client, internal, producer spans (SpanKind.CLIENT, SpanKind.INTERNAL, SpanKind.PRODUCER) aparecen en la tabla dependencies
  • Log records emitidos a través de python’s logging module u OpenTelemetry logging API aparecen en la tabla traces
  • Exceptions aparecen en la tabla exceptions
  • Custom metrics aparecen en la tabla customMetrics

Configure sampling to control telemetry volume

Sampling reduce el volumen de telemetria que se envia a Application Insights, recogiendo solo un porcentaje de las trazas. Esto es esencial para apps con un gran volumen de requests y controlar los costes de ingestion.

Estrategias de sampling para traces:

  • Fixed-percentage sampling: Recoge una fixed fraction de todas las trazas. Especificas un ratio entre 0.0 y 1.0 donde 0.1 significa el 10% de las trazas
  • Rage-limited sampling: Pone un cap al number de trazas recolectadas por segundo. Especificas 1.5 donde es aprox. una traza y media cada segundo

Podemos configurar fixed-percentage sampling en codigo usando sampling_ratio param, o rate-limited sampling usando traces_per_second

# Code fragment - focus on configuring sampling via configure_azure_monitor()
from azure.monitor.opentelemetry import configure_azure_monitor

# Fixed-percentage sampling: sample approximately 10% of traces
configure_azure_monitor(
    sampling_ratio=0.1,
)

# Rate-limited sampling: sample approximately 1.5 traces per second
# configure_azure_monitor(
#     traces_per_second=1.5,
# )

Enable offline storage and automatic retries

El Azuer Monitor exporter cachea la telemetria de manera local cuando la app pierde conexion y lo reintenta durante 48 horas.

Se puede hacer override del default storage directory si necesitas la cache en un directorio especifico

# Code fragment - focus on configuring offline storage directory
from azure.monitor.opentelemetry import configure_azure_monitor

configure_azure_monitor(
    storage_directory="/var/telemetry/rag-pipeline",
)

Verify telemetry data flow

Tras el initial setup es importante verificar que la telemetria esta llegando al Application Insights. Los datos pueden no aparecer inmediatamente ya que se hacen en batches.

Para real-time verification durante development, tenemos Live Metricos que ofrece un dashboard para hacer displays con un delay minimo.

Podemos ejecutar KQL queries en Application Insights Logs para verificar que los trace data están disponibles

devuelve las 20 requests mas recientes de la ultima hora, mostrando operation name, duration, success status y cloud role name del servicio

requests
| where timestamp > ago(1h)
| project timestamp, name, duration, success, cloud_RoleName
| order by timestamp desc
| take 20

Read More

Debug distributed flows with trace data (OpenTelemetry)

Recoger y exportar telemetría solo es util si puedes usar esos datos para encontrar y arreglar problemas

El Application Map provee de una topología visual de todos tus servicios dentro de tu aplicación distribuida, mostrando la manera en que se conectan y donde hay fallos o problemas de latencia.

Cada nodo de un mapa representa un cloud role, identificado por el resource attribute service.name configurado durante el setup.

Los limites entre nodos representan llamadas de un servicio a otro.

El Application Map muestra key metrics en cada nodo y edge, incluyendo avg response time, request count o failure rate.

Puedes usar este mapa para reducir rápidamente el área de tu investigación.

Use end-to-end transaction details

La transaction view end-to-end muestra un waterfall chart de todos los spans en una single trace, mostrando timing, duration y dependencias de cada operación.

Esta view es la primary tool para entender que pasa durante una specific request e identificar donde se ocupa el tiempo.

El waterfall chart muestra el root span en el top, representando el entry point de la request. Child spans se muestran bajo sus parent spans.

Write KQL queries to analyze trace data

El application insights almacena telemtria en las tablas de Log Analytics, a las que podemos hacer queries usando Kusto Query Language (KQL).

Las trazas se almacenan en 4 tablas primarias

  • tabla requests contiene server spans y consumer spans
  • tabla dependencies contiene client, internal y producer spans
  • tabla traces contiene log records
  • tabla exceptions contiene excepciones grabadas

Todas las tablas comparten una columna operation_id, la cual corresponden con el OpenTelemetry trace ID para poder correlacionar items que pertenecen a la misma traza distribuida

find slow requests and summarize by service

requests
| where duration > 3000
| summarize count(), avg(duration) by cloud_RoleName
| order by avg_duration desc

You can join request with their dependencies

this query connects each slow request with its downstream dependency calls

requests
| where duration > 5000
| join kind=inner (dependencies) on operation_Id
| project timestamp, requestName = name, requestDuration = duration,
    dependencyName = name1, dependencyDuration = duration1,
    dependencyTarget = target
| order by requestDuration desc

You can query custom attributes stored in customDimensions

analyzes embedding generation performance by model, showing avg and 95th-percentile durations alongside avg token counts

dependencies
| where name == "GenerateEmbedding"
| extend tokenCount = toint(customDimensions["embedding.token_count"]),
    model = tostring(customDimensions["embedding.model"])
| summarize avg(duration), percentile(duration, 95),
    avg(tokenCount) by model
| order by avg_duration desc

Read More