Monitorización de cron jobs y scripts programados que se configura sola
Deja de enterarte por tu jefe de que el informe de anoche no se ejecutó. Dile a Claude o a ChatGPT “monitoriza mis scripts programados”. Configura los jobs y añade unas pocas líneas a cada script. Te avisamos cuando uno falla, se retrasa, no se ejecuta o el número de filas no cuadra, y puedes preguntarle qué pasó.
Empezar es gratis · por ahora todas las funciones están abiertas · sin tarjeta de crédito
Configura y revisa tus jobs desde Claude o ChatGPT
02:14. La importación nocturna falla. Nadie se entera hasta que pregunta el jefe.
- A las 02:14 la importación nocturna de ventas falla por un timeout de la base de datos, y no se avisa a nadie.
- En Claude escribes “Ayúdame a empezar con TaskBeacon.” y nombras el script y su horario. Crea el job y te da las líneas para el inicio y el final del script.
- O en Claude Code escribes “Revisa mis tareas programadas y recomiéndame qué monitorizar.” Lee el Programador de tareas (Task Scheduler) y, cuando dices que sí, configura tres jobs en TaskBeacon y añade las líneas a los tres scripts.
- El job aparece solo en la lista de jobs de TaskBeacon y pasa a OK después de su primera ejecución.
- Cuando el script falla recibes al instante un correo con el error y las últimas líneas de la salida, y otro cuando vuelve a estar OK.
- A la mañana siguiente preguntas a ChatGPT “¿Qué falló anoche?” y te responde con los datos de TaskBeacon.
- Pides a Claude que pase la importación del CRM a las 06:00 y que pause la copia de seguridad; primero te pregunta y luego cambia las dos cosas.
- Puedes hacer lo mismo a mano en la app o escribiendo al asistente. Después funciona solo.
Cómo funciona la monitorización de jobs programados
- 1Conecta tu asistente de IA
Añade TaskBeacon a Claude o ChatGPT e inicia sesión. Un minuto.
- 2Pídele que vigile tus scripts
Crea los jobs con sus horarios y añade unas pocas líneas a cada script. ¿Prefieres hacerlo tú? La pestaña “Code” (Código) escribe las líneas por ti.
- 3Recibe alertas y pregunta
Por correo electrónico, Slack, Teams y más, cuando un job falla, no se ejecuta, se retrasa o envía datos raros. Pregunta “¿qué falló anoche?” cuando quieras.
Pregunta qué falló anoche y cambia jobs con solo pedirlo
Conversaciones de ejemplo en Claude o ChatGPT con TaskBeacon conectado. El asistente te pregunta antes de crear o cambiar algo.
Monitorea todos mis scripts programados en este servidor.
Encontré 6 tareas de cron. Después de que confirmaras la lista, creé 6 tareas en TaskBeacon con las mismas programaciones y añadí las líneas a cada script. nightly_backup.sh ya informó: OK. Las alertas van a tu correo, de inmediato.
¿Qué falló anoche y por qué?
La importación del CRM falló a las 02:14 con KeyError: 'amount'. La columna de la exportación ahora se llama 'total_amount'; cambia la línea 41 de crm_import.py. Las otras 5 tareas se ejecutaron a tiempo.
¿Por qué la carga de ventas tuvo solo 12 filas hoy?
Normalmente carga unas 48,000. La ejecución de hoy empezó a las 06:30, pero el archivo de origen llegó a las 06:58. Mueve la tarea a las 07:15 o espera el archivo en el script.
Mueve el pronóstico semanal a los lunes a las 07:30 y pausa la antigua exportación FTP.
Hecho: Weekly forecast ahora espera una ejecución los lunes a las 07:30. La exportación FTP está en pausa, así que no envía alertas hasta que la reanudes.
Funciona con Claude, ChatGPT y otras apps que se conectan a servidores MCP. La lectura está en todos los planes; configurar jobs desde un chat está en Pro y Team. Cómo conectarlo
Tres líneas en tu script de Python, R, Stata o PowerShell
El código real que genera TaskBeacon, con la dirección propia de tu job. Lo pone tu asistente o lo pegas tú.
# --- TaskBeacon: top of the script (standard library only) ---
import json, traceback, urllib.request
TB = "https://taskbeacon.io/ping/your-job-id"
def tb_ping(path="", data=None):
body = json.dumps(data).encode() if data else None
req = urllib.request.Request(TB + path, data=body, headers={"Content-Type": "application/json"})
try:
urllib.request.urlopen(req, timeout=10)
except Exception as e:
print("TaskBeacon ping failed:", e)
tb_ping("/start")
try:
# --- your code here ---
df = [1, 2, 3] # example data: replace with your own (e.g. pandas.read_csv)
except Exception as e:
# the error and the last 20 lines of the traceback go with the failure
tb_ping("/fail", {"error": f"{type(e).__name__}: {e}"[:200],
"log": "\n".join(traceback.format_exc().splitlines()[-20:])[-4000:]})
raise
# --- TaskBeacon: end of the script ---
tb_ping("", {"rows": len(df)})
# Save as C:\jobs\taskbeacon-run.ps1
# Task Scheduler > Action: Start a program
# Program: powershell.exe
# Arguments: -NoProfile -ExecutionPolicy Bypass -File C:\jobs\taskbeacon-run.ps1 "C:\path\to\program.exe" "arg1" "arg2"
# Runs the program, then reports success or failure from its exit code.
# A .ps1 script as the program is run with powershell.exe -NoProfile -ExecutionPolicy Bypass -File script.ps1
# (an execution policy set by Group Policy still wins over Bypass).
$tb = "https://taskbeacon.io/ping/your-job-id"
$program, $programArgs = $args
# a .ps1 file is not a program Windows can start on its own ("not a valid Win32 application")
if ($program -match '\.ps1$') {
$programArgs = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $program) + @($programArgs | Where-Object { $null -ne $_ })
$program = 'powershell.exe'
}
function Send-TaskBeacon($path, $text) {
$send = @{ UseBasicParsing = $true; TimeoutSec = 10; Uri = ($tb + $path) }
if ($text) { $send.Method = 'Post'; $send.ContentType = 'text/plain; charset=utf-8'; $send.Body = [Text.Encoding]::UTF8.GetBytes($text) }
try { Invoke-WebRequest @send | Out-Null }
catch { Write-Host "TaskBeacon ping failed: $_" }
}
Send-TaskBeacon "/start"
# keep arguments that contain spaces together
$argLine = ($programArgs | ForEach-Object { if ($_ -eq '' -or $_ -match '[\s"]') { '"' + ($_ -replace '"', '\"') + '"' } else { $_ } }) -join ' '
# Windows PowerShell 5.1 refuses an empty -ArgumentList: pass it only when there are arguments
$run = @{ FilePath = $program; Wait = $true; PassThru = $true; NoNewWindow = $true; ErrorAction = 'Stop' }
if ($argLine) { $run.ArgumentList = $argLine }
# the program's output goes to temporary files: shown below, and its last 20 lines go with a failure
$out = [IO.Path]::GetTempFileName(); $err = [IO.Path]::GetTempFileName()
$run.RedirectStandardOutput = $out; $run.RedirectStandardError = $err
$code = 1
$note = ''
try {
$p = Start-Process @run
if ($null -ne $p.ExitCode) { $code = $p.ExitCode }
} catch { $note = "Could not start ${program}: $_"; Write-Host $note }
Get-Content -LiteralPath $out, $err -ErrorAction SilentlyContinue
$tail = ''
if ($code -ne 0) {
$lines = @(Get-Content -LiteralPath $out, $err -Tail 20 -ErrorAction SilentlyContinue) + @($note)
$tail = ($lines | Where-Object { $_ } | ForEach-Object { if ($_.Length -gt 300) { $_.Substring(0, 300) } else { $_ } }) -join "`n"
}
# the exit code goes at the end of the address: /0 = OK, any other number = failed
Send-TaskBeacon "/$code" $tail
Remove-Item -LiteralPath $out, $err -ErrorAction SilentlyContinue
exit $code # not 0 when it failed, so Task Scheduler shows the failure too
# --- TaskBeacon: top of the script (base R only) ---
tb <- "https://taskbeacon.io/ping/your-job-id"
tb_log <- "" # optional: this script's log file (e.g. Rscript job.R > job.log 2>&1); its last 20 lines go with a failure
tb_ping <- function(path = "") {
old <- options(timeout = 10) # wait at most 10 seconds (R's default is 60)
on.exit(options(old))
invisible(try(suppressWarnings(readLines(paste0(tb, path), warn = FALSE)), silent = TRUE))
}
tb_num <- function(x) utils::URLencode(format(x, scientific = FALSE, digits = 15, trim = TRUE), reserved = TRUE)
tb_tail <- function() {
if (!nzchar(tb_log) || !file.exists(tb_log)) return("")
text <- paste(utils::tail(readLines(tb_log, warn = FALSE), 20), collapse = "\n")
if (nchar(text) > 700) text <- sub("^[^\n]*\n", "", substr(text, nchar(text) - 700, nchar(text)))
paste0("&log=", utils::URLencode(text, reserved = TRUE))
}
tb_ping("/start")
tryCatch({
# --- your code here ---
df <- data.frame(x = 1:3) # example data: replace with your own
}, error = function(e) {
tb_ping(paste0("/fail?error=", utils::URLencode(substr(conditionMessage(e), 1, 200), reserved = TRUE), tb_tail()))
stop(e)
})
# --- TaskBeacon: end of the script ---
tb_ping(paste0("?", "rows=", tb_num(nrow(df))))
* --- TaskBeacon: top of the do-file ---
local tb "https://taskbeacon.io/ping/your-job-id"
* curl.exe is built into Windows 10 and 11; macOS and Linux have curl
local tb_curl = cond(c(os) == "Windows", "curl.exe", "curl")
local tb_log "" // optional: this do-file's log (batch mode: stata -b do job.do, or StataMP-64.exe /e do job.do on Windows, writes job.log in the current folder); its last 20 lines go with a failure
shell `tb_curl' -fsS -m 10 "`tb'/start"
capture noisily {
* --- your code here (the example data: replace with your own) ---
sysuse auto, clear
}
quietly {
local tb_rc = _rc
if `tb_rc' {
* the last 20 lines of the log (if tb_log is set) go with the failure
local tb_data ""
if `"`tb_log'"' != "" {
tempfile tb_tail
tempname tb_in tb_out
capture {
file open `tb_in' using `"`tb_log'"', read text
local tb_n 0
file read `tb_in' tb_line
while r(eof) == 0 {
local tb_n = `tb_n' + 1
local tb_k = mod(`tb_n', 20)
local tb_l`tb_k' = substr(`"`macval(tb_line)'"', 1, 300)
file read `tb_in' tb_line
}
file close `tb_in'
file open `tb_out' using `"`tb_tail'"', write text replace
forvalues tb_i = `=max(1, `tb_n' - 19)'/`tb_n' {
local tb_k = mod(`tb_i', 20)
file write `tb_out' `"`macval(tb_l`tb_k')'"' _n
}
file close `tb_out'
local tb_data `"--data-binary "@`tb_tail'" -H "Content-Type: text/plain""'
}
capture file close `tb_in'
capture file close `tb_out'
}
shell `tb_curl' -fsS -m 10 `tb_data' "`tb'/fail?rc=`tb_rc'"
exit `tb_rc'
}
}
* --- TaskBeacon: end of the do-file ---
local tb_rows = _N
shell `tb_curl' -fsS -m 10 "`tb'?rows=`tb_rows'"
@echo off
REM Save as C:\jobs\taskbeacon-run.bat
REM Task Scheduler > Action: Start a program
REM Program: C:\jobs\taskbeacon-run.bat
REM Runs your job, then reports success or failure from its exit code.
set "TB=https://taskbeacon.io/ping/your-job-id"
curl.exe -fsS -m 10 "%TB%/start" >nul
REM --- your job here (a program, a script, another .bat with call): replace the path ---
REM its output goes to a temporary file: shown below, and its last 20 lines go with a failure
set "TB_LOG=%TEMP%\taskbeacon-%RANDOM%.log"
call "C:\path\to\your-job.bat" > "%TB_LOG%" 2>&1
set TB_RC=%ERRORLEVEL%
type "%TB_LOG%"
type nul > "%TB_LOG%.tail"
if not "%TB_RC%"=="0" powershell.exe -NoProfile -Command "Get-Content -LiteralPath $env:TB_LOG -Tail 20 | ForEach-Object { if ($_.Length -gt 300) { $_.Substring(0, 300) } else { $_ } }" > "%TB_LOG%.tail" 2>nul
REM the exit code goes at the end of the address: /0 = OK, any other number = failed
curl.exe -fsS -m 10 --data-binary "@%TB_LOG%.tail" -H "Content-Type: text/plain" "%TB%/%TB_RC%" >nul
del "%TB_LOG%" "%TB_LOG%.tail" 2>nul
exit /b %TB_RC%
# crontab -e (this example runs every day at 06:00)
0 6 * * * curl -fsS -m 10 https://taskbeacon.io/ping/your-job-id/start >/dev/null; /path/to/your-job.sh; curl -fsS -m 10 "https://taskbeacon.io/ping/your-job-id/$?" >/dev/null
Panel de jobs, alertas e historial de ejecuciones
Pantallas reales de TaskBeacon, con jobs inventados.


Todos los jobs en una pantalla
- Primero los problemas: fallidos, retrasados, no ejecutados, datos raros.
- Unas barras pequeñas muestran cada ejecución reciente.


Cada job se explica solo
- Qué salió mal, en una frase sencilla.
- Filas por ejecución frente al nivel habitual.


Código que pegas, no un agente que instalas
- Elige el lenguaje y marca qué quieres que informe.
- Inicio, errores, número de filas, la fecha más reciente, el tamaño de una copia de seguridad.


Alertas que dicen qué hacer
- El motivo, la máquina y la última ejecución correcta.
- Tu propia nota: a quién llamar, qué volver a ejecutar.
“Se ejecutó” no significa que los datos estén bien.
El Programador de tareas (Task Scheduler) y cron solo conocen el código de salida. Un script que carga cero filas sale igualmente con 0.
El script informó de un error, con el mensaje.
No se ejecutó a la hora prevista.
Empezó y está tardando mucho más de lo habitual.
Se ejecutó, pero las filas bajaron, el archivo está vacío o la fecha más reciente es antigua.
Funciona con cron, el Programador de tareas de Windows y tus herramientas
Cualquier cosa que pueda llamar a una dirección web. Cada tarjeta abre el código listo y las notas para ella.
TUS SCRIPTS Y PROGRAMADORES
- Python™ Idioma
- PowerShell Task Scheduler
- R Idioma
- Stata Estadística
- SAS Estadística · nuevo
- SPSS Estadística · nuevo
- SQL Server Agent Programador · nuevo
- Excel VBA Macro · nuevo
- Batch (.bat) Script de Windows
- Node.js Idioma
- Linux cron Programador
- Herramientas no-code Power Automate, KNIME, Zapier…
- Sitios web y API Disponibilidad, comprobada por nosotros
- SSL y dominios Avisos de vencimiento
ADÓNDE VAN LAS ALERTAS
INTEGRACIONES · SIN CÓDIGO, LEEMOS LOS RESULTADOS
Los nombres y logotipos de productos pertenecen a sus dueños y se muestran solo para indicar que TaskBeacon funciona con ellos. Logotipo de R © 2016 The R Foundation, CC BY-SA 4.0.
Jobs fallidos, no ejecutados, retrasados o con datos incorrectos que detecta
Cada caso explicado: por qué ocurre y cómo recibir una alerta.
Qué significa de verdad el Last Run Result.
Stata sale con 0 después de un error.
Ni error ni log: solo una ejecución que falta.
Un éxito que no cargó nada.
Más allá de la bandeja de entrada del propietario.
Lo comprobamos desde fuera; nada que instalar.
Cómo nos comparamos
Precios
Empezar es gratis, y por ahora todas las funciones están abiertas. El plan gratuito se queda, y recibirás un aviso con al menos 60 días de antelación antes de que algo cueste dinero.
Free
DISPONIBLE YAPara un analista y sus propios scripts.
sin tarjeta
Empieza gratis- 20 jobs
- Pings del script: inicio, fin, código de salida
- 3 comprobaciones de sitios web, cada 5 min
- Reglas de número de filas
- Pregunta a Claude o ChatGPT qué falló (MCP)
- Alertas por correo y Slack
- Informe diario o semanal
- 30 días de historial
Pro
Para un analista con muchos jobs programados.
por ahora todas las funciones de Pro son gratis
Empieza gratis y mejora después- 100 jobs
- Todo lo de Free
- Comprobaciones de sitios web cada minuto, alertas de SSL y dominio
- Integraciones: Power BI, SharePoint, dbt, Fivetran, Azure Data Factory
- Reglas de palabras clave, fechas desactualizadas y números propios
- Alertas por Teams, Discord, Google Chat, ntfy y webhook
- Recordatorios cada hora y un informe mensual
- 1 página de estado para tu jefe
- 12 meses de historial
Team
Para un equipo que comparte proyectos.
por ahora todas las funciones de Team son gratis
Empieza gratis y mejora después- 500 jobs
- Todo lo de Pro
- Proyectos compartidos: cualquier número de colegas, con roles
- Alertas enrutadas por proyecto
- Registro de cambios y “Send me alerts” para miembros
- API
- Páginas de estado ilimitadas, sin nuestra marca
- 24 meses de historial
- Soporte prioritario, el mismo día hábil
Apoya a TaskBeacon: suscríbete ahora. Por ahora todas las funciones son gratis; una suscripción sube tu límite de jobs al del plan y lo mantiene cuando empiecen los planes de pago.
Primero crea una cuenta gratuita y luego mejora tu plan desde Precios o desde Settings → Plan & billing (Configuración → Plan y facturación).
Todas las funciones y nuestra promesa a los primeros usuarios · Los precios no incluyen el IVA.
Preguntas antes del primer job
¿Mis datos salen de mi servidor?
No. Solo sale el ping: su estado (inicio, fin, fallo), los tiempos, los números que añadas (como un número de filas) y, si hay un fallo, las últimas 20 líneas de la salida (o el mensaje de error). También vemos la dirección IP de origen y el user agent. Tus datos, archivos y bases de datos se quedan donde están.
¿Qué tengo que instalar?
Nada. El script hace una llamada HTTP al empezar y otra al terminar, con curl, PowerShell o la biblioteca propia del lenguaje.
¿Y si el departamento de TI bloquea el HTTPS saliente?
El equipo necesita llegar a una sola dirección por HTTPS. Pide a TI que permita ese único dominio; no hace falta que nada entre desde fuera.