DevOps y observabilidad

Monitoreo de pipelines y notebooks de Microsoft Fabric en producción

Cómo monitorear pipelines y notebooks de Fabric lo bastante bien para detectar fallos, lentitud, reintentos, presión de capacidad y datos incorrectos antes que los usuarios, con correlación de ejecuciones, registros de ejecución, referencias de duración y alertas.

Por JaviPublicado Actualizado 19 min de lecturaIntermedio

Flujo de ejecución de un pipeline y notebook de Fabric conectado con el monitoreo operativo

Un pipeline en verde es el estado más engañoso de una plataforma de datos. Te dice que todas las actividades terminaron sin error. No te dice que llegaron las filas correctas, que el watermark avanzó, que la ejecución tardó un tiempo normal ni que el informe de las 06:00 mostrará las cifras de ayer y no las de la semana pasada.

La mayoría de los equipos de Fabric empiezan con el centro de supervisión y un correo de fallo. Eso detecta los problemas ruidosos: una conexión rota, una excepción en un notebook, un tiempo de espera agotado. Los problemas caros son silenciosos. Un notebook que termina con éxito y cero filas porque cambió la ruta del origen. Una carga que tarda 40 minutos en lugar de 10 porque ahora comparte la capacidad con una carga nueva. Un reintento que anexa en silencio la misma ventana dos veces. Esos los descubren los usuarios, normalmente en una reunión.

Esta guía trata de monitorear pipelines y notebooks de Fabric lo bastante bien como para encontrar esos problemas primero. Se organiza en torno a cuatro preguntas que toda ejecución de producción debe responder:

  1. ¿Se ejecutó la carga? ¿Se desencadenó, empezó, empezó a tiempo?
  2. ¿Terminó correctamente? Cada actividad, incluidos los reintentos, los pipelines hijos y los notebooks a los que llaman.
  3. ¿Produjo los datos esperados? Recuentos de filas, claves, totales, frescura, watermarks.
  4. ¿Consumió un tiempo y una capacidad aceptables? Comparado con su propio historial, no con un número que alguien supuso.

Fabric responde bien a las dos primeras sin configuración adicional. Las dos últimas requieren un poco de ingeniería deliberada: parámetros, un registro de ejecución, comprobaciones de validación y una referencia. Esa ingeniería es lo que cubre este artículo.

El comportamiento de los productos se comprobó en Microsoft Learn en octubre de 2026. Varias funciones de monitoreo, incluido el nuevo centro de supervisión, estaban entonces en versión preliminar y se indican como tales.

Ninguna pantalla responde a todas las preguntas

En Fabric, el monitoreo llega por capas, y cada una responde a preguntas distintas:

Capa Qué te da Qué no puede decirte
Centro de supervisión e historial de ejecuciones de pipelines Estado, duración, ejecuciones de actividades con entradas, salidas y errores, relaciones entre ejecuciones anteriores y posteriores, reejecuciones Si los datos son correctos; el historial más allá de la retención de la plataforma; tu contexto de negocio
Detalles de la aplicación Spark (desde la ejecución de un notebook) Sesión, etapas, ejecutores y logs de una ejecución de notebook A qué ejecución de pipeline y ventana de negocio pertenecía el notebook, salvo que se lo pases
Monitoreo del workspace (workspace monitoring) Logs de jobs y actividades guardados en un Eventhouse y consultables con KQL en todo el workspace Los recuentos de filas, watermarks y resultados de validación que produce tu código
Tu registro de ejecución Evidencia a nivel de negocio: ventanas, recuentos de filas, watermarks, resultados de validación, correlación entre ejecuciones Los detalles internos de la plataforma; todo lo que no registraste
Aplicación Capacity Metrics Qué operaciones consumieron capacidad, suavizado, limitación Por qué un job concreto hizo lo que hizo
Alertas (alertas de pipeline, Activator, actividades de Teams u Outlook, herramientas externas) Un aviso cuando algo cruza un límite Todo aquello para lo que no definiste una regla

Un incidente de producción suele tocar tres de estas capas. El objetivo del resto del artículo es conectarlas.

Qué monitorear

Señal Por qué importa Dónde obtenerla Qué debe generar alerta
Estado de la ejecución del pipeline La primera señal de que algo se rompió Centro de supervisión, monitoreo del workspace, alertas de pipeline Fallo de un pipeline de producción
Inicio que no ocurrió o con retraso Una programación que no se disparó parece «sin fallos» Lista de ejecuciones esperadas frente a reales; registro de ejecución Ejecución esperada ausente pasada su ventana
Duración del pipeline La lentitud precede a los fallos y a los SLA incumplidos Historial de ejecuciones, monitoreo del workspace, registro de ejecución Duración muy alejada de la referencia propia de la carga
Actividad fallida y error Indica dónde mirar primero Ejecuciones de actividades en la vista de detalle Incluido en la alerta de fallo
Número de reintentos Inestabilidad oculta; los reintentos también pueden duplicar trabajo Ejecuciones de actividades; retry_count en el registro de ejecución Reintentos repetidos o que crecen con el tiempo
Parámetros (fecha, ventana, entorno) La mayoría de los incidentes de «datos incorrectos» son entradas incorrectas Entrada de la actividad; registro de ejecución Parámetros fuera de los valores esperados
Ejecuciones anteriores y posteriores El fallo de un hijo aparece como un error vago en el padre Columnas de ejecuciones anteriores y posteriores del centro de supervisión Parte de la investigación del fallo
Estado de salida y excepción del notebook El notebook sabe por qué falló; el pipeline solo sabe que falló Ejecución del notebook, logs de Spark, registro de ejecución Fallo de un notebook en una ejecución de producción
Filas leídas, escritas y rechazadas Los recuentos cero o inusuales son el fallo silencioso más común Registro de ejecución (a partir de las métricas de operación de Delta) Cero filas donde se esperan datos; recuentos muy alejados de la referencia
Ventana de origen y watermark La corrección incremental depende de ellos Registro de ejecución, tabla de watermarks Datos escritos pero watermark sin avanzar, o al revés
Claves duplicadas y nulos Corrupción silenciosa de datos Paso de validación Cualquier clave de negocio duplicada; tasa de nulos por encima de un límite acordado
Totales de conciliación Demuestran que origen y destino coinciden Paso de validación Diferencia por encima de una tolerancia acordada
Frescura A los usuarios les importa cuándo fueron correctos los datos por última vez, no cuándo se ejecutó un job Marca de tiempo de negocio máxima por tabla; registro de ejecución Datos más antiguos que la frescura acordada
Archivos descubiertos, procesados y fallidos La ingesta de archivos falla archivo por archivo Tabla de archivos procesados; registro de ejecución Archivos fallidos o sin procesar pasada su ventana
Retraso de inicio o de cola Problemas de capacidad o de sesión de Spark, no de código Detalles de la aplicación Spark; separación entre inicio y procesamiento en el registro Inicio sistemáticamente muy por encima de lo normal
Presión de capacidad La limitación ralentiza o rechaza todo lo que se ejecuta en la capacidad Aplicación Capacity Metrics; eventos de capacidad Limitación que afecta a una carga crítica

La tabla no incluye umbrales a propósito. Una duración «normal» para una carga nocturna y para un microlote de cinco minutos difiere en varios órdenes de magnitud. Los umbrales salen del historial propio de cada carga, como se explica en la sección sobre referencias de duración.

Monitoreo integrado de pipelines

Data Factory en Fabric te da una base sólida sin ningún desarrollo propio.

Centro de supervisión. En el momento de escribir esto hay dos experiencias: el centro de supervisión establecido, que Microsoft llama ahora la experiencia heredada, y un nuevo centro de supervisión en versión preliminar que añade vistas de salud de pipelines entre workspaces y gestión de alertas. Ambos permiten:

  • Buscar ejecuciones de pipelines por nombre, estado, hora de inicio, remitente y ubicación.
  • Abrir la vista de detalle de una ejecución: el diagrama del pipeline, el ID de ejecución, el estado, los errores y cada ejecución de actividad.
  • Abrir la entrada y la salida de una actividad para ver los parámetros que recibió y lo que devolvió, además de sus detalles de rendimiento (incluido el desglose de duración de las actividades Copy).
  • Ver las ejecuciones anteriores y posteriores, es decir, qué ejecución desencadenó esta y cuáles desencadenó ella. Activa esas columnas para seguir una cadena de Invoke pipeline.
  • Usar la vista de Gantt para comparar duraciones entre ejecuciones y detectar solapamientos.
  • Volver a ejecutar un pipeline: la ejecución completa, desde la actividad fallida o desde una actividad seleccionada.
  • Exportar las ejecuciones de actividades a CSV.

Monitoreo del workspace. Cuando está habilitado en un workspace, Fabric escribe los logs de ejecución de jobs en un Eventhouse de monitoreo, incluida una tabla ItemJobEventLogs con el nombre del elemento, el estado del job, las horas de inicio y fin y la duración. Así el historial de ejecuciones se convierte en algo que puedes consultar, representar en gráficos y usar para alertas en todos los pipelines del workspace:

// Pipeline duration per day over two weeks, from workspace monitoring
ItemJobEventLogs
| where ItemKind == "Data Pipeline" and JobStatus == "Completed"
| where JobStartTime > ago(14d)
| summarize runs = count(),
            p50_minutes = percentile(DurationMs, 50) / 60000.0,
            p90_minutes = percentile(DurationMs, 90) / 60000.0
          by ItemName, bin(JobStartTime, 1d)
| order by ItemName asc, JobStartTime asc

Comprueba los valores exactos de las columnas en tu propio Eventhouse de monitoreo antes de construir sobre ellos; Microsoft documenta el esquema, pero es fácil escribir mal los tipos de elemento y los estados.

Lo que la capa integrada no hace es conocer tus datos. Puede decirte que nb_silver_orders terminó con éxito en cuatro minutos. No puede decirte que fusionó cero filas porque el parámetro de ventana iba un día adelantado.

Monitoreo de notebooks: captura más que «succeeded»

El estado de una actividad de notebook es binario. Las preguntas que harás durante un incidente no lo son:

  • ¿Qué ejecución era? El ID de ejecución del notebook, más la ejecución de pipeline que lo llamó.
  • ¿Qué se le pidió? Fecha de negocio, ventana de origen, entorno, tabla de destino.
  • ¿Qué hizo en realidad? Filas leídas, escritas, rechazadas; tablas afectadas; ubicación de salida.
  • ¿Cuánto tardó cada parte? Espera e inicio frente a procesamiento frente a la escritura final.
  • Si falló, ¿por qué? El tipo y el mensaje de la excepción, depurados.

Fabric puede decirte parte de esto. Los detalles de la aplicación Spark muestran etapas, ejecutores y logs. notebookutils.runtime.context informa del nombre del notebook, el workspace, el Lakehouse predeterminado, si la ejecución es para un pipeline y el ID del job de Livy de la actividad actual. Lo que el notebook no sabe por sí solo es qué ejecución de pipeline lo inició: el contexto de ejecución solo contiene ID de ejecución en las ejecuciones de referencia de notebooks. Así que pásale la identidad del pipeline.

En los parámetros base de la actividad de notebook:

Parámetro Valor
pipeline_run_id @pipeline().RunId
parent_pipeline_run_id @pipeline()?.TriggeredByPipelineRunId (null salvo que lo haya invocado un pipeline padre)
pipeline_name @pipeline().PipelineName
trigger_time @pipeline().TriggerTime
window_start, window_end la ventana de procesamiento calculada por el pipeline

El notebook los declara en su celda de parámetros con valores predeterminados seguros para las ejecuciones interactivas. Los parámetros de notebooks cubren el patrón, incluida la validación, y la actividad Invoke Pipeline cómo pasar valores de pipelines padre a hijos.

Usa el registro de ejecución para lo que Fabric no ve

El registro de ejecución es la tabla que escribe tu código: una fila por intento, escrita al inicio y finalizada al terminar. Es donde el monitoreo responde a las preguntas tres y cuatro. Este artículo usa los nombres de campo de ese modelo en lugar de inventar otros nuevos:

Campo Uso para el monitoreo
execution_id Uno por intento; un reintento recibe uno nuevo
parent_execution_id La ejecución de pipeline que llamó, para vincular una fila de notebook con su pipeline
correlation_id La operación de negocio a través de los servicios, como una carga diaria
pipeline_name, notebook_name, environment Qué se ejecutó y dónde
start_time, end_time, duration_ms Duración y referencias
status started, succeeded, failed, cancelled, timed_out
rows_read, rows_written Volumen y ejecuciones silenciosas con cero filas
retry_count, trigger_type Reintentos, y reejecuciones programadas o manuales
error_code, error_message Motivo del fallo, depurado

Merece la pena añadir dos extensiones para el monitoreo: window_start y window_end para las cargas incrementales, y rows_rejected para la validación. El artículo sobre cargas incrementales (en inglés) añade rows_inserted, rows_updated y rows_deleted a partir de las métricas del MERGE de Delta.

Un envoltorio compacto para notebooks que lo escribe:

PySpark
import time, uuid
from datetime import datetime, timezone

ctx = notebookutils.runtime.context
execution_id = str(uuid.uuid4())   # one per execution, even if the notebook runs twice in a pipeline run
started = time.time()

def log(status, **metrics):
    row = {
        "execution_id": execution_id,
        "parent_execution_id": pipeline_run_id,          # notebook parameter from @pipeline().RunId
        "correlation_id": correlation_id,                 # notebook parameter, e.g. "sales-daily-2026-10-24"
        "pipeline_name": pipeline_name,
        "notebook_name": ctx["currentNotebookName"],
        "environment": environment,
        "status": status,
        "start_time": datetime.fromtimestamp(started, timezone.utc),
        "end_time": datetime.now(timezone.utc) if status != "started" else None,
        "duration_ms": int((time.time() - started) * 1000) if status != "started" else None,
        "window_start": window_start,
        "window_end": window_end,
        **metrics,
    }
    spark.createDataFrame([row]).write.format("delta").mode("append").option("mergeSchema", "true").saveAsTable("execution_log")

log("started")
try:
    rows_read, rows_written = run_load(window_start, window_end)      # your transformation
    log("succeeded", rows_read=rows_read, rows_written=rows_written)
except Exception as e:
    log("failed", error_code=type(e).__name__, error_message=str(e)[:500])
    raise
PySpark32 líneasCelda de ejemplo de solo lectura. Nada en esta página ejecuta código.

Vuelve a lanzar la excepción después de registrarla. Un notebook que registra un fallo y luego termina limpiamente convierte una actividad roja en verde.

Sea cual sea el almacén (una tabla de Lakehouse como arriba, una tabla de Warehouse o una SQL database), mantén el registro independiente de la retención del historial de ejecuciones de la plataforma, para poder comparar este mes con el trimestre pasado.

Correlacionar ejecuciones padre e hijo

Las cargas reales son árboles, no ejecuciones sueltas:

pl_daily_sales                     pipeline run  9f1c…   (correlation_id = sales-daily-2026-10-24)
├── Invoke pl_load_orders          child run     47ab…   parent = 9f1c…
│   ├── Copy job activity          copy run
│   └── nb_silver_orders           notebook run          parent_execution_id = 47ab…
└── nb_validate_sales              notebook run          parent_execution_id = 9f1c…

Cuando nb_silver_orders falla, el pipeline padre solo informa de que falló el pipeline invocado. Sin correlación, un operador abre el padre, entra en el hijo, encuentra la ejecución del notebook, abre sus logs de Spark y después adivina qué ventana estaba procesando. Con correlación, una sola consulta devuelve el árbol completo:

Consulta SQL: Correlacionar ejecuciones padre e hijoSpark SQL
-- Everything that happened for one business operation
SELECT pipeline_name, notebook_name, status, start_time, duration_ms,
       rows_read, rows_written, retry_count, error_message
FROM execution_log
WHERE correlation_id = 'sales-daily-2026-10-24'
ORDER BY start_time;
Spark SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Las reglas son sencillas: cada pipeline pasa @pipeline().RunId (y el ID de ejecución del padre cuando lo invocan) a lo que llama; cada notebook registra ambos; y un único correlation_id identifica la operación de negocio a través de las reejecuciones. Las columnas de ejecuciones anteriores y posteriores del centro de supervisión dan el mismo árbol del lado de la plataforma, así que puedes moverte entre ambos.

Monitoreo de cargas incrementales

Las cargas incrementales añaden estado, y el estado añade modos de fallo que el estado de la ejecución no ve. El artículo sobre cargas incrementales (en inglés) cubre el diseño. Para el monitoreo, registra en cada ejecución:

  • El watermark anterior y el límite superior capturado para esta ejecución.
  • Las filas extraídas de la ventana.
  • Las filas insertadas, actualizadas y eliminadas por el MERGE.
  • ¿Avanzó el watermark? ¿Se movió last_successful_watermark hasta el límite superior?
  • El estado de conciliación de la comprobación más reciente.

Las dos situaciones que merecen una alerta:

  • Datos escritos, watermark sin avanzar. La ejecución confirmó Silver o Gold, pero falló antes de guardar el watermark. Con un diseño idempotente, la siguiente ejecución vuelve a procesar la ventana sin riesgo, pero debes saberlo, y si se repite significa que algo falla al final de cada ejecución.
  • Watermark avanzado, escritura posterior fallida o ausente. La peligrosa. Los cambios de esa ventana pueden saltarse para siempre. Debería ser imposible por diseño (el watermark se mueve al final), así que, si ocurre, trátalo como un incidente.

Una comprobación sencilla compara la tabla de watermarks con el registro de ejecución:

Consulta SQL: Monitoreo de cargas incrementalesSpark SQL
-- Watermark advanced without a succeeded run for that window
SELECT w.pipeline_name, w.last_successful_watermark, w.last_execution_id
FROM etl_watermark AS w
LEFT JOIN execution_log AS l
  ON l.execution_id = w.last_execution_id AND l.status = 'succeeded'
WHERE l.execution_id IS NULL;
Spark SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Vigila también el retraso del watermark: cuánto se queda atrás last_successful_watermark respecto a la hora actual. Un watermark que deja de moverse mientras todas las ejecuciones informan éxito suele indicar una ventana vacía o incorrecta.

Monitoreo de reintentos y reejecuciones

Los reintentos ocultan la inestabilidad. Una actividad configurada con reintentos puede fallar dos veces, tener éxito al tercer intento y dejar el pipeline en verde. Una vez está bien. Cada noche es un aviso, y es un incidente cuando los reintentos empiezan a duplicar trabajo.

Distingue cuatro casos:

  • Reintento transitorio: un reintento tras un corte de red o un breve tiempo de espera del origen. Regístralo, sin alertar.
  • Tormenta de reintentos: muchos reintentos en varias actividades o ejecuciones, a menudo tras una caída del origen. Cada reintento puede relanzar trabajo pesado y añadir carga a la capacidad. Alerta sobre el crecimiento, no sobre casos aislados.
  • Reejecución correcta tras un fallo parcial: un operador o una programación vuelve a ejecutar una ventana fallida. Es correcto cuando las escrituras son idempotentes, pero hazlo visible: trigger_type y un execution_id nuevo muestran que fue una reejecución, y correlation_id la vincula con el intento original.
  • Reejecución desde la actividad fallida: Fabric puede reanudar desde la actividad que falló. Es útil, pero solo es seguro si no se espera que las actividades anteriores vuelvan a ejecutarse para la misma ventana.

Conserva los intentos fallidos en el registro; nunca los sobrescribas cuando un reintento tiene éxito. «Correcto tras tres reintentos» y «correcto» son estados de salud distintos, y solo el registro permite distinguirlos después.

Referencias de duración

Los umbrales fijos de duración («alerta si supera 30 minutos») son demasiado estrictos para los días con mucha carga o demasiado laxos para los días ligeros. Compara cada ejecución con su propio historial:

  • La misma carga, no una media de toda la plataforma.
  • Historial reciente: las últimas dos a cuatro semanas, para que la referencia siga un crecimiento gradual.
  • Volumen de entrada similar cuando varía mucho. La ventana de recuperación del lunes no es comparable con la del martes.
  • Percentiles (mediana y un percentil alto) en lugar de medias, que una sola mala noche distorsiona.

Por ejemplo (solo a modo ilustrativo), una carga cuyas ejecuciones recientes tardan entre 8 y 12 minutos y que hoy tarda 35 merece una investigación, aunque 35 minutos no tendrían nada de raro para otra carga. La consulta de monitoreo del workspace de antes te da la vista de la plataforma; el mismo cálculo sobre execution_log.duration_ms te da referencias por notebook y por ventana.

Mira también las tendencias. Una ejecución que es un poco más lenta cada semana suele deberse a una tabla que acumula archivos pequeños o a un origen que crece más rápido de lo previsto. El mantenimiento de tablas Delta (en inglés) cubre la parte de organización de archivos. Vuelve a revisar las referencias después de cada despliegue, porque una publicación por CI/CD es el motivo más habitual de que una duración estable cambie de un día para otro.

Monitoreo consciente de la capacidad

Una carga puede volverse lenta sin ningún cambio en su código ni en sus datos, porque comparte la capacidad con todo lo demás. Causas habituales:

  • Cargas que se solapan a la misma hora.
  • Suavizado: el trabajo en segundo plano de horas antes sigue pesando sobre la capacidad.
  • Limitación (throttling): retrasos o rechazos interactivos en cuanto el uso suavizado supera los límites.
  • Límites de concurrencia de Spark: jobs en cola (desencadenados por pipelines) o rechazados (interactivos) cuando los núcleos de Spark están ocupados.

El camino de diagnóstico es corto:

  1. Revisa el historial de la carga. ¿Es esta ejecución un valor atípico frente a su referencia? ¿Creció el tiempo de inicio o el de procesamiento?
  2. Revisa la ventana de capacidad en la aplicación Capacity Metrics para el mismo periodo. ¿Hubo limitación? ¿Qué operaciones dominaron?
  3. Correlaciona con otras operaciones. ¿Qué otros pipelines, notebooks, actualizaciones o consultas se ejecutaron al mismo tiempo?

Si la capacidad estaba bajo presión y la carga en sí no cambió, reprogramarla o aislarla suele ser más eficaz que optimizarla. La capacidad de Microsoft Fabric explicada (en inglés) cubre el suavizado, las fases de limitación y cómo leer la aplicación Capacity Metrics; este artículo no lo repite.

Separar el inicio del procesamiento

Cuando la duración total de un notebook crece pero su lógica no cambió, divide el tiempo en tres partes:

  • Espera e inicio: cola, adquisición de la sesión de Spark, preparación del entorno y las bibliotecas.
  • Procesamiento: lectura, transformación, shuffle.
  • Escritura y confirmación: escritura de archivos y confirmación de la transacción Delta, más cualquier mantenimiento que se dispare tras la escritura.

Cada una apunta a un sitio distinto. Un inicio que crece apunta a la configuración de la sesión, los entornos, las bibliotecas o la capacidad, de lo que se ocupan el tiempo de inicio de los notebooks y los session tags. Un procesamiento que crece apunta al volumen de datos, el desequilibrio, los escaneos o los joins; consulta Cómo acelerar los notebooks de Fabric. Una escritura que crece apunta a la organización de archivos, el alcance del MERGE o la compactación.

Una forma barata de obtener esta separación es registrar marcas de tiempo dentro del notebook: cuando se ejecuta la primera celda (fin del inicio), antes de la escritura final y después de la confirmación. La diferencia entre el inicio de la actividad del pipeline y la primera celda es espera e inicio; el resto es tuyo.

Compara lo comparable: una sesión en frío y una sesión reutilizada responden a preguntas distintas, igual que ventanas de entrada distintas.

Monitoreo de la calidad de datos

El éxito de la infraestructura no es el éxito de los datos. Un pipeline puede estar en verde y entregar datos malos, así que la validación tiene que formar parte de la ejecución, no ser un informe aparte que alguien mira más tarde.

Comprobaciones prácticas, ejecutadas como paso de validación tras la carga:

Consulta SQL: Monitoreo de la calidad de datosSpark SQL
-- Duplicates on the business key
SELECT COUNT(*) - COUNT(DISTINCT sales_order_id) AS duplicate_rows FROM silver_sales_orders;

-- Null rate on a required column
SELECT AVG(CASE WHEN customer_id IS NULL THEN 1.0 ELSE 0.0 END) AS null_rate FROM silver_sales_orders;

-- Freshness: newest business timestamp
SELECT MAX(order_timestamp) AS newest_order FROM silver_sales_orders;
Spark SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Y las comprobaciones que necesitan contexto:

  • Variaciones del recuento de filas: las filas de hoy frente a la referencia reciente del mismo día de la semana.
  • Claves que faltan: claves presentes en el origen pero no en el destino, o al revés, para un periodo reciente.
  • Totales y conciliación: sumas por fecha en origen y destino.
  • Particiones o fechas esperadas: que estén en Gold todas las fechas esperadas.
  • Archivos retrasados: entradas esperadas que no han llegado.
  • Datos obsoletos: la marca de tiempo más reciente es más antigua que la frescura acordada, aunque el job se haya ejecutado.

Decide qué hace cada comprobación fallida. Algunas deben hacer fallar la ejecución (claves duplicadas en una tabla de estado actual), para que se disparen la ruta de fallo y las alertas del pipeline. Otras deben avisar (un recuento de filas un 20 % por debajo de la referencia en un día festivo). Guarda cada resultado en el registro de ejecución para que las tendencias sean visibles.

Monitoreo de la ingesta de archivos

Las cargas basadas en archivos fallan archivo por archivo, así que monitorízalas a ese nivel:

  • Archivos descubiertos en la zona de aterrizaje en esta ejecución.
  • Archivos procesados, omitidos y fallidos, con el motivo de las omisiones y los fallos.
  • Archivos duplicados: mismo nombre o checksum ya procesado.
  • Retraso de procesamiento: la antigüedad del archivo más antiguo sin procesar.

Una tabla de archivos procesados, como la que se describe en la guía de cargas incrementales (en inglés), te da estos recuentos sin esfuerzo. Alerta sobre los archivos fallidos y el retraso, no sobre omisiones individuales.

Alertas

Alerta sobre lo que alguien debe atender; sigue el resto como tendencia.

Alertas inmediatas:

  • Fallo de un pipeline de producción.
  • Fallo repetido de un notebook en la misma carga.
  • Un fallo de validación de datos que bloquea el uso posterior.
  • Watermark avanzado sin una escritura posterior correcta.
  • Limitación de capacidad que afecta a una carga crítica.
  • Una ejecución esperada que no empezó.

Avisos y tendencias:

  • Duración que empeora frente a la referencia.
  • Número de reintentos en aumento.
  • Número de archivos pequeños en aumento en tablas clave.
  • Deriva gradual del recuento de filas.
  • Tiempos de inicio en aumento.

Lo que Fabric ofrece de forma nativa, a octubre de 2026:

  • Alertas a nivel de actividad: añade una actividad de Outlook o Teams en la ruta de fallo de una actividad.
  • Alertas a nivel de pipeline en el nuevo centro de supervisión (versión preliminar), y notificaciones de fallo en las ejecuciones programadas de pipelines.
  • Reglas de Activator sobre eventos de jobs de pipelines, para notificaciones de éxito o fallo por correo o Teams.
  • Alertas a nivel de workspace: una consulta KQL sobre ItemJobEventLogs del monitoreo del workspace, con una regla de Activator encima.
  • Eventos de capacidad en el Real-Time hub, para los cambios de estado de la capacidad.

Lo que normalmente requiere trabajo propio: alertas sobre los datos del registro de ejecución (recuentos de filas, watermarks, validación), reglas de duración frente a la referencia y el enrutamiento a un sistema de guardias fuera de Microsoft 365. Un notebook de validación que hace fallar el pipeline es el puente más sencillo: convierte un problema de datos en un fallo que las alertas nativas ya detectan.

Cada alerta necesita un destinatario y una primera acción. Una alerta de la que nadie es responsable enseña a la gente a ignorar el canal.

Un flujo de diagnóstico en producción

  1. 1Alerta o queja de un usuario¿Qué falla, en qué datos y desde cuándo?
  2. 2Encontrar la ejecución afectadaCentro de supervisión, o correlation_id en el registro de ejecución
  3. 3¿Fallo o lentitud?Ejecución en rojo, en verde pero incorrecta, o en verde pero lenta
  4. 4Detalle de las actividadesActividad fallida, parámetros de entrada, error, ejecuciones hijas
  5. 5Revisar el registro de ejecuciónVentana, filas, reintentos, watermark
  6. 6Revisar la validación de datosDuplicados, totales, frescura
  7. 7Revisar la ventana de capacidadLimitación, cargas que se solapan
  8. 8Comparar con la referencia de duraciónInicio frente a procesamiento frente a escritura
  9. 9Identificar la causa
    • Origen
    • Código
    • Capacidad
    • Datos
  10. 10Volver a ejecutar con seguridadMisma ventana, escrituras idempotentes
  11. 11Verificar el estado posteriorValidación correcta, watermark correcto, informes actualizados
Investigar un incidente de pipeline o notebook de Fabric. Evidencias en un orden fijo. La mayoría de los incidentes se explican en el paso 5, 6 o 7, pero comprobar la capacidad y la referencia evita arreglar lo que no es.

Hay dos pasos que se saltan más que ninguno: comprobar la capacidad antes de optimizar el código y verificar el estado posterior después de la reejecución. Una reejecución que termina bien pero deja Gold o el modelo semántico desactualizados no ha cerrado el incidente. Depurar pipelines y notebooks de Microsoft Fabric en producción (en inglés) recorre cada paso para ejecuciones fallidas, lentas o con resultados incorrectos.

Las fichas Monitorear pipelines y notebooks de Fabric y Depurar pipelines de Fabric reúnen los comandos y los lugares que revisar en cada paso.

Ejemplo ilustrativo: la carga diaria que tardó 42 minutos

Este es un recorrido de diagnóstico ilustrativo, no un incidente medido.

El pipeline diario de ventas termina normalmente en unos 11 minutos. Una mañana tarda 42. Está en verde, el informe llega tarde y alguien pregunta si hay que optimizar el notebook.

  1. Encontrar la ejecución. El centro de supervisión muestra que la ejecución terminó bien; la vista de Gantt muestra que empezó a tiempo y duró mucho.
  2. Revisar el detalle de las actividades. La actividad del Copy job tardó lo habitual. La actividad del notebook Silver concentra casi toda la media hora adicional.
  3. Revisar el registro de ejecución. Mismo tamaño de ventana de siempre, recuentos de filas normales, sin reintentos, validación correcta. Los datos están bien; solo falla el tiempo.
  4. Separar inicio y procesamiento. El inicio fue normal. El procesamiento tardó unas cuatro veces su referencia.
  5. Revisar la capacidad. La aplicación Capacity Metrics muestra la capacidad muy cargada durante la misma ventana, con un notebook pesado de recarga histórica, recién programado en otro workspace de la misma capacidad, que se solapa con la carga.
  6. Buscar cambios. Ningún despliegue, ningún cambio de código, ningún crecimiento de datos.
  7. Decidir. La causa es la contención, no el notebook. Mover la recarga histórica a una ventana más tranquila restablece la duración normal al día siguiente.

Sin el registro de ejecución y la comprobación de capacidad, la respuesta probable habría sido reescribir un notebook que no era el problema.

Errores de monitoreo frecuentes

  • Alertar solo sobre fallos. Las ejecuciones lentas, vacías o incorrectas están en verde.
  • No guardar los ID de ejecución. Sin ellos, los logs de los notebooks no se pueden vincular con las ejecuciones de pipelines.
  • Sin correlación padre-hijo. Cada fallo de un hijo se convierte en una navegación manual clic a clic.
  • Sin registro de recuentos de filas. Las ejecuciones con cero filas pasan desapercibidas durante días.
  • Sin conciliación. Las eliminaciones perdidas y las ventanas saltadas solo aparecen cuando alguien compara totales a mano.
  • Tratar un pipeline en verde como datos entregados. El estado no es la corrección.
  • Sin referencia de duración. Sin historial, «lento» es una opinión.
  • Ignorar los reintentos. Ocultan la inestabilidad y pueden duplicar trabajo.
  • Optimizar notebooks sin revisar la capacidad. Desde dentro del notebook, la contención se ve exactamente igual que código lento.
  • Registrarlo todo y no usar nada. Los logs sin consultas, paneles ni alertas son coste de almacenamiento, no monitoreo.

Lista de comprobación para producción

  • Estado de las ejecuciones monitoreado, con alertas ante fallos de pipelines de producción.
  • Ejecuciones que no ocurrieron detectadas: programaciones esperadas frente a ejecuciones reales.
  • Duración comparada con la referencia propia de cada carga, no con umbrales fijos.
  • Reintentos registrados y seguidos como tendencia; intentos fallidos conservados.
  • ID de ejecución pasados de los pipelines a los notebooks y guardados.
  • Correlación padre-hijo mediante los ID de ejecución padre y un correlation_id.
  • Parámetros (fecha, ventana, entorno) registrados en cada ejecución.
  • Watermarks registrados, con alertas ante desajustes entre watermark y escrituras.
  • Filas leídas, escritas y rechazadas registradas en cada carga.
  • Validación (duplicados, nulos, totales, frescura) integrada en la ejecución, con reglas claras de fallo o aviso.
  • Capacidad revisada durante las investigaciones, con eventos de capacidad para las cargas críticas.
  • Alertas con responsable: cada alerta tiene un destinatario y una primera acción.
  • Seguridad de las reejecuciones confirmada: escrituras idempotentes y reejecuciones visibles en el registro.

Para una lista de comprobación más amplia que abarque API, SQL y SLA de datos, consulta la lista de comprobación de monitoreo de una plataforma de datos (en inglés). Para decidir qué herramienta debe encargarse de cada paso, y cómo afecta eso a dónde vive la evidencia, consulta Pipelines, notebooks, Dataflow Gen2 o Copy Job (en inglés).

Etiquetas

  • Microsoft Fabric
  • Fabric Notebook
  • Pipelines de datos
  • Observabilidad
  • Monitorización
  • Rendimiento