Mis apuntes · Aprende awk desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 31 de 31 · Proyecto final: el informe del log ✦ WebMCP implementado

Fase 5 · El informe completo y cómo usarlo en tu servidor

10 min de lectura 2 retos

Tu informe ya calcula todo lo que tiene que calcular. Le falta presentarlo: títulos, porcentajes, tamaños que se lean y de qué horas a qué horas habla. En esta última fase lo dejas terminado, lo ves entero y aprendes a usarlo donde de verdad hace falta: en tu servidor.

¿De dónde vienen los nombres?

zcat = z (de gzip) + cat
El cat de los ficheros comprimidos: escribe su contenido descomprimido sin tocar el fichero. Sirve para leer los logs antiguos, que el servidor guarda en .gz.
cron = del griego chrónos (tiempo)
El programa de Linux que ejecuta comandos a una hora fija: cada noche, cada lunes. Es lo que usarías para lanzar un script de PHP programado.
KB, MB = kilobyte, megabyte
1 KB son 1024 bytes y 1 MB son 1024 KB (1.048.576 bytes). El log guarda siempre bytes; las personas leen mejor megas.
GoAccess = inglés go + access (por access log)
Un programa libre que analiza logs de acceso y los enseña en un panel. Es lo que hace tu informe, hecho por gente que lleva años en ello.
En 4 ideas
1/4

Tres ayudantes de formato: titulo() subraya, porcentaje() hace la regla de tres y tamano() pasa bytes a KB o MB con sprintf. En PHP serían tres funciones de un helper de vistas.

1 · Lo que le falta a tu informe

Ejecuta mentalmente el informe de la fase 4 y ponte en el lugar de quien lo recibe. Dice «Bytes servidos 1166236». ¿Eso es mucho? Dice «Peticiones de bots 9». ¿De cuántas? Y no dice de qué día es. Los números están bien; lo que falla es que hay que pensar para entenderlos.

Un buen informe es como el marcador de un partido: se entiende de un vistazo. Estos son los cambios de la fase 5, todos de presentación:

  1. Una cabecera con el periodo: la fecha de la primera línea válida y la de la última.
  2. Un título subrayado en cada sección, con una línea en blanco delante.
  3. Porcentajes al lado de los números: 9 robots son el 45,0 % de las peticiones.
  4. Los bytes, en la unidad que toque: 1.1 MB en vez de 1166236.
  5. Una sección nueva, NAVEGADORES, que por fin usa la función navegador() de la fase 1.

Para el periodo hace falta un dato más de la línea, así que la fase 1 gana una función: momento(), que devuelve la fecha y la hora sin el corchete. El programa guarda el primero que ve y va pisando el último:

awkprograma.awk
# En PHP: return substr($this->campos[3], 1);
function momento() {
    return substr($4, 2)
}

{
    # En PHP: $desde ??= $linea->momento();
    if (desde == "") {
        desde = momento()
    }
    hasta = momento()
}

No hace falta convertir fechas ni comparar nada: el log está escrito en orden, así que la primera línea es la más antigua y la última la más reciente. desde solo se asigna cuando está vacía; hasta se asigna siempre, y al acabar se queda con la última.

2 · Tres ayudantes: titulo(), porcentaje() y tamano()

Las tres cosas se repiten por todo el informe, así que van en funciones. Las dos primeras se prueban sin fichero, con números puestos a mano en un BEGIN:

awkprograma.awk
# En PHP: echo PHP_EOL, $texto, PHP_EOL, str_repeat("-", strlen($texto)), PHP_EOL;
function titulo(texto,    raya) {
    raya = texto
    gsub(/./, "-", raya)
    print ""
    print texto
    print raya
}

# En PHP: return $total === 0 ? 0.0 : $parte * 100 / $total;
function porcentaje(parte, total) {
    if (total == 0) {
        return 0
    }
    return parte * 100 / total
}

BEGIN {
    titulo("RESUMEN")
    printf "%-20s %7d %6.1f%%\n", "Visitas reales", 9, porcentaje(9, 20)
    printf "%-20s %7d %6.1f%%\n", "Peticiones de bots", 9, porcentaje(9, 20)
    printf "%-20s %7d %6.1f%%\n", "Ficheros estaticos", 2, porcentaje(2, 20)

    titulo("UN LOG VACIO")
    printf "%-20s %7d %6.1f%%\n", "Visitas reales", 0, porcentaje(0, 0)
}
$ awk -f programa.awk
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. Sin fichero de datos: este programa solo tiene BEGIN, así que no lee nada.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

  • titulo() hace la raya a la medida del texto: copia el título y cambia cada carácter por un guion con gsub(/./, "-", raya). Recuerda del módulo 06 que gsub cambia la variable que le das: por eso trabaja sobre una copia local.
  • porcentaje() es la regla de tres de siempre: parte * 100 / total. Devuelve un número con sus decimales; quien lo imprime decide cuántos enseña (%6.1f, uno).
  • En el formato de printf, %% es la forma de escribir un signo de porcentaje, igual que en PHP.

¿Por qué? · En PHP no existe

¿Por qué porcentaje() mira si el total es cero?

Porque un día tu informe leerá un log vacío. Pasa más de lo que parece: justo después de que el servidor rote los logs a medianoche, access.log tiene cero líneas. Sin esa comprobación, esto es lo que ocurre al dividir:

$ gawk -f informe.awk access.log
gawk: informe.awk:2: fatal: division by zero attempted

fatal significa que awk se para ahí mismo: no imprime ni lo que ya tenía calculado. En PHP 8 es igual de serio: dividir entre cero lanza un DivisionByZeroError.

La diferencia es que en PHP lo arreglarías con un try/catch y en awk no existe. Lo único que puedes hacer es no llegar a la división: preguntar antes y devolver 0. Un informe de un log vacío tiene que decir «0 visitas», no romperse.

tamano() elige la unidad según lo grande que sea el número. Devuelve un texto ya montado con sprintf, que es el printf que no imprime (módulo 04):

PHP 8.5tamano.php
<?php
function tamano(int $cantidad): string
{
    return match (true) {
        $cantidad >= 1_048_576 => sprintf("%.1f MB", $cantidad / 1_048_576),
        $cantidad >= 1024 => sprintf("%.1f KB", $cantidad / 1024),
        default => sprintf("%d B", $cantidad),
    };
}

foreach ([512, 1536, 1_166_236] as $cantidad) {
    echo $cantidad, " -> ", tamano($cantidad), PHP_EOL;
}
awkprograma.awk
# En PHP: function tamano(int $cantidad): string
function tamano(cantidad) {
    if (cantidad >= 1048576) {
        return sprintf("%.1f MB", cantidad / 1048576)
    }
    if (cantidad >= 1024) {
        return sprintf("%.1f KB", cantidad / 1024)
    }
    return sprintf("%d B", cantidad)
}

BEGIN {
    print 512, "->", tamano(512)
    print 1536, "->", tamano(1536)
    print 1166236, "->", tamano(1166236)
}
$ awk -f programa.awk
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. Sin fichero de datos: este programa solo tiene BEGIN, así que no lee nada.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

awk no tiene match ni los guiones bajos de 1_048_576, así que son if en fila y el número escrito de un tirón. El orden importa otra vez, como en navegador(): primero se pregunta por lo más grande.

3 · El informe completo

Este es informe.awk terminado. Arriba, las funciones por fases, con los mismos nombres que les diste al escribirlas. En medio, las secciones, que ahora llaman a titulo(), porcentaje() y tamano(). Abajo, el programa: el embudo de siempre y un END que es el índice del informe.

awkprograma.awk
# informe.awk: el informe de un dia de tu web (necesita gawk)
# Uso: gawk -v top=3 -v umbral=3 -f informe.awk ips-bloqueadas.txt access.log

# ---------- Fase 1: sacar los datos de la linea ----------
function ip() {
    return $1
}

function momento() {
    return substr($4, 2)
}

function hora() {
    return substr($4, 14, 2)
}

function metodo() {
    return substr($6, 2)
}

function url(    ruta) {
    ruta = $7
    sub(/\?.*/, "", ruta)
    return ruta
}

function estado() {
    return $9
}

function bytes() {
    return $10 + 0
}

function agente(    trozos) {
    split($0, trozos, "\"")
    return trozos[6]
}

function navegador(    texto) {
    texto = agente()
    if (texto ~ /Firefox\//) {
        return "Firefox"
    }
    if (texto ~ /Chrome\//) {
        return "Chrome"
    }
    if (texto ~ /Safari\//) {
        return "Safari"
    }
    return "otro"
}

function linea_valida() {
    return NF >= 12 && estado() ~ /^[0-9][0-9][0-9]$/
}

# ---------- Fase 2: filtrar y contar ----------
function es_bot() {
    return tolower(agente()) ~ /bot|spider|crawl|curl|wget|python-requests/
}

function es_estatico() {
    return tolower(url()) ~ /\.(css|js|png|jpg|jpeg|gif|svg|ico|woff2)$/
}

# ---------- Fase 3: ordenar y dibujar ----------
function por_valor_y_clave(clave1, valor1, clave2, valor2) {
    if (valor1 != valor2) {
        return valor2 - valor1
    }
    if (clave1 < clave2) {
        return -1
    }
    return clave1 > clave2
}

function barra(valor, maximo,    largo, texto, i) {
    largo = int(valor * 20 / maximo)
    for (i = 1; i <= largo; i++) {
        texto = texto "#"
    }
    return texto
}

# ---------- Fase 4: ataques ----------
function es_escaneo() {
    return estado() == 404 && tolower(url()) ~ /wp-login|wp-admin|phpmyadmin|\.env|\.git|\/admin|backup/
}

function es_login_fallido() {
    return estado() == 401 && url() == "/login"
}

function etiqueta_bloqueo(ip_sospechosa) {
    if (ip_sospechosa in bloqueada) {
        return "YA BLOQUEADA (" bloqueada[ip_sospechosa] ")"
    }
    return "SIN BLOQUEAR"
}

# ---------- Fase 5: dar formato ----------
function titulo(texto,    raya) {
    raya = texto
    gsub(/./, "-", raya)
    print ""
    print texto
    print raya
}

function porcentaje(parte, total) {
    if (total == 0) {
        return 0
    }
    return parte * 100 / total
}

function tamano(cantidad) {
    if (cantidad >= 1048576) {
        return sprintf("%.1f MB", cantidad / 1048576)
    }
    if (cantidad >= 1024) {
        return sprintf("%.1f KB", cantidad / 1024)
    }
    return sprintf("%d B", cantidad)
}

# ---------- Las secciones del informe ----------
function imprimir_resumen(    validas) {
    validas = leidas - rotas
    titulo("RESUMEN")
    printf "%-20s %7d\n", "Lineas leidas", leidas
    printf "%-20s %7d\n", "Lineas rotas", rotas
    printf "%-20s %7d %6.1f%%\n", "Peticiones de bots", de_bots, porcentaje(de_bots, validas)
    printf "%-20s %7d %6.1f%%\n", "Ficheros estaticos", estaticos, porcentaje(estaticos, validas)
    printf "%-20s %7d %6.1f%%\n", "Visitas reales", visitas, porcentaje(visitas, validas)
    printf "%-20s %7s\n", "Bytes servidos", tamano(total_bytes)
}

function imprimir_estados(    codigo) {
    titulo("ESTADOS")
    PROCINFO["sorted_in"] = "@ind_str_asc"
    for (codigo in por_estado) {
        printf "%-20s %7d %6.1f%%\n", codigo, por_estado[codigo], porcentaje(por_estado[codigo], leidas - rotas)
    }
}

function imprimir_top(texto, cuenta, cuantos,    clave, puesto) {
    titulo(texto)
    PROCINFO["sorted_in"] = "por_valor_y_clave"
    for (clave in cuenta) {
        puesto++
        if (puesto > cuantos) {
            break
        }
        printf "%d. %-25s %4d %6.1f%%\n", puesto, clave, cuenta[clave], porcentaje(cuenta[clave], visitas)
    }
    if (puesto == 0) {
        print "(sin datos)"
    }
}

function imprimir_horas(    franja, maximo) {
    titulo("VISITAS POR HORA")
    for (franja in por_hora) {
        if (por_hora[franja] > maximo) {
            maximo = por_hora[franja]
        }
    }
    PROCINFO["sorted_in"] = "@ind_str_asc"
    for (franja in por_hora) {
        printf "%sh %-20s %4d\n", franja, barra(por_hora[franja], maximo), por_hora[franja]
    }
}

function imprimir_sospechosas(texto, cuenta, minimo,    clave, cuantas) {
    print texto
    PROCINFO["sorted_in"] = "por_valor_y_clave"
    for (clave in cuenta) {
        if (cuenta[clave] < minimo) {
            break
        }
        cuantas++
        printf "  %-15s %4d  %s\n", clave, cuenta[clave], etiqueta_bloqueo(clave)
    }
    if (cuantas == 0) {
        print "  (ninguna)"
    }
}

function imprimir_ataques() {
    titulo("ATAQUES")
    imprimir_sospechosas("Escaneos (404 a rutas trampa):", escaneos, 1)
    imprimir_sospechosas("Fuerza bruta (" umbral " o mas 401 en /login):", fallos_login, umbral)
}

# ---------- El programa ----------
BEGIN {
    if (top == "") {
        top = 3
    }
    if (umbral == "") {
        umbral = 3
    }
}

FILENAME ~ /bloqueadas/ {
    bloqueada[$1] = $2
    next
}

{
    leidas++
}

!linea_valida() {
    rotas++
    next
}

{
    if (desde == "") {
        desde = momento()
    }
    hasta = momento()
    total_bytes += bytes()
    por_estado[estado()]++
}

es_escaneo() {
    escaneos[ip()]++
}

es_login_fallido() {
    fallos_login[ip()]++
}

es_bot() {
    de_bots++
    next
}

es_estatico() {
    estaticos++
    next
}

{
    visitas++
    paginas[url()]++
    visitas_ip[ip()]++
    por_hora[hora()]++
    navegadores[navegador()]++
}

END {
    print "INFORME DE ACCESOS"
    print "=================="
    print "Desde: " desde
    print "Hasta: " hasta
    imprimir_resumen()
    imprimir_estados()
    imprimir_top("TOP " top " PAGINAS", paginas, top)
    imprimir_top("TOP " top " IP", visitas_ip, top)
    imprimir_top("NAVEGADORES", navegadores, 10)
    imprimir_horas()
    imprimir_ataques()
}
$ awk -f programa.awk ips-bloqueadas.txt access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. ips-bloqueadas.txt access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Fíjate en qué ha cambiado y qué no respecto a la fase 4:

  • Las reglas del programa son las mismas. Solo hay dos líneas nuevas en el embudo: las de desde y hasta, y navegadores[navegador()]++ al fondo.
  • La sección de navegadores no ha necesitado ninguna función nueva: es otra llamada a imprimir_top() con otro array. Eso es lo que se gana al escribir una función que recibe el array.
  • Los print "" que separaban secciones en el END han desaparecido: ahora la línea en blanco la pone titulo().

4 · En tu servidor

Hasta aquí todo ha corrido en tu navegador. Lo que sigue es de solo lectura: son comandos para la terminal de tu servidor, donde sí hay tuberías y otros programas. Guarda el informe como informe.awk, súbelo y entra por SSH.

El log de hoy. El fichero suele ser de root, así que hace falta sudo. Las dos variables son opcionales:

awkprograma.awkSolo lectura: necesita la terminal
sudo gawk -v top=10 -v umbral=5 -f informe.awk /etc/nginx/ips-bloqueadas.txt /var/log/nginx/access.log

Los logs antiguos. Cada noche el servidor aparta el log del día y empieza uno nuevo (se llama rotar). Los antiguos se quedan comprimidos: access.log.2.gz, access.log.3.gz… awk no sabe leer un .gz, pero zcat sí: lo descomprime y se lo pasa por una tubería. Sin fichero en la línea de comando, awk lee lo que le llega por ella:

awkprograma.awkSolo lectura: necesita la terminal
zcat /var/log/nginx/access.log.2.gz | gawk -f informe.awk
$ zcat access.log.2.gz | gawk -f informe.awk | head -4
INFORME DE ACCESOS
==================
Desde: 19/Nov/2026:10:15:32
Hasta: 19/Nov/2026:12:14:50

Si además quieres cruzar con la lista, un guion (-) le dice a awk en qué momento leer la tubería: zcat access.log.2.gz | gawk -f informe.awk ips-bloqueadas.txt -.

Todas las mañanas, solo. Con cron el informe de ayer te espera cada día en un fichero. Esta línea, añadida con crontab -e, lo genera a las 7:00 con el log que se rotó por la noche:

awkprograma.awkSolo lectura: necesita la terminal
0 7 * * * gawk -f /home/tu-usuario/informe.awk /var/log/nginx/access.log.1 > /home/tu-usuario/informe-de-ayer.txt

¿Por qué? · En PHP no existe

¿Por qué con tail -f el informe no imprime nada?

tail -f access.log enseña las líneas nuevas según llegan, y no termina nunca. Es tentador enchufarle el informe: tail -f access.log | gawk -f informe.awk. Lo haces y la pantalla se queda en blanco.

Todo lo que imprime tu informe está en el END, y el END se ejecuta cuando se acaba la entrada. Con tail -f la entrada no se acaba. Y si cortas con Ctrl+C, mueren los dos programas a la vez y el END tampoco llega.

En PHP te pasaría lo mismo con un while (true) que acumula en un array y un echo puesto después del bucle. Para vigilar en directo hace falta otro tipo de programa: uno que imprima en la regla, línea a línea. Puedes reutilizar tus funciones:

awkprograma.awkSolo lectura: se usa con tail -f access.log | gawk -f vigilar.awk
function ip() {
    return $1
}

function url() {
    return $7
}

function estado() {
    return $9
}

function es_escaneo() {
    return estado() == 404 && tolower(url()) ~ /wp-login|wp-admin|phpmyadmin|\.env|\.git|\/admin|backup/
}

es_escaneo() {
    print "ESCANEO", ip(), url()
    fflush()
}

fflush() obliga a awk a escribir ya, sin esperar a llenar su memoria intermedia. Sin él, los avisos saldrían a golpes y con retraso.

5 · Cuándo dejar awk

Has escrito un analizador de logs en menos de 300 líneas, sin instalar nada y sin base de datos. Para saber qué ha pasado hoy en tu web, es difícil hacerlo con menos. Pero awk es un pelapatatas, como dijimos en la primera lección, y hay trabajos que piden otra herramienta:

Necesitas…Usa…Por qué
Una respuesta rápida mirando el logawkYa está en el servidor y la pregunta cabe en una línea
Un resumen diario como el de este móduloawk (tu informe)Un fichero, sin dependencias, lo lanza cron
Un panel con gráficos, países y tiempo realGoAccessYa lo hace, y reconoce miles de navegadores y robots
Guardar el histórico y compararlo mes a mesPHP + base de datosawk no recuerda nada de una ejecución a otra
Cruzar con tus usuarios, pedidos o sesionesPHPEsos datos están en MySQL, no en un fichero de texto
Enseñárselo a alguien en una página webPHPawk imprime texto en una terminal y nada más
Bloquear a los atacantesfail2banHay que tocar el cortafuegos, y eso no se improvisa

La regla para decidir es sencilla: mientras la pregunta sea «¿qué hay en este fichero?», awk. En cuanto sea «¿y qué hago con ello?», PHP. Y los dos se llevan bien: un script de PHP puede ejecutar tu informe cada noche y guardar sus números en una tabla.

La pregunta que te vas a hacer

¿Y ahora qué? ¿Por dónde sigo?

Lo mejor que puedes hacer es ejecutar tu informe sobre el log de tu propia web y mirar qué sale. Verás rutas trampa que no están en la lista, robots que no conocías y páginas con más visitas de las que creías. Cada sorpresa es una mejora: una palabra más en una regex, una sección nueva.

  • GoAccess: pruébalo con el mismo log y compara sus números con los tuyos. Si no coinciden, averiguar por qué enseña mucho.
  • Manual de GNU awk: la referencia completa. Con lo que sabes ya puedes leer cualquier capítulo.
  • crontab.guru: escribe los cinco campos de una línea de cron y te dice en cristiano cuándo se ejecuta.
  • logrotate: el programa que rota y comprime los logs; su manual explica de dónde salen access.log.1 y los .gz.

Hora de practicar

Retos · 0/2 resueltos

Reto 1 de 2

tamano(): bytes que se leen

tamano() lo devuelve todo en bytes. Hazla elegir la unidad: desde 1048576, megas con un decimal (1.0 MB); desde 1024, kilos con un decimal (1.5 KB); por debajo, bytes sin decimales (512 B). Al comprobar se prueban siete cantidades (1023 sigue siendo 1023 B y 1024 ya es 1.0 KB) y después tu informe imprime cuánto se ha llevado cada IP, como 192.0.2.140 1.0 MB. En PHP: un match (true) con tres sprintf().

Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.

awkprograma.awk · editable
$ awk -f programa.awk access.log
¿Qué significa esta línea?
  1. awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
  2. -f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
  3. access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.

Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.

Resumen

Lo que te llevas de esta lección

  1. titulo(), porcentaje() y tamano() separan calcular de presentar. En PHP serían funciones de un helper de vistas.
  2. Antes de dividir, se mira que el divisor no sea cero: en awk es un fatal que para el programa y no hay try/catch. En PHP, un DivisionByZeroError.
  3. sprintf monta un texto sin imprimirlo: tamano() devuelve "1.1 MB" y quien llama lo coloca con %7s.
  4. En el servidor: gawk -f informe.awk lista log; los .gz, con zcat … | gawk -f informe.awk; cada mañana, con cron.
  5. Un programa que imprime en el END no sirve con tail -f: la entrada no termina. Para vigilar en directo se imprime en la regla y se llama a fflush().
  6. awk contesta «¿qué hay en este fichero?». Para guardar, cruzar con la base de datos o publicar en una web, vuelve a PHP; para un panel, GoAccess.

Para recordarlo: Las cinco fases: «Para Filtrar Tanto Ataque, Formato»

PParsear
url(), estado()…
FFiltrar
es_bot(), es_estatico()
TTop
imprimir_top(), barra()
AAtaques
es_escaneo(), umbral
FFormato
titulo(), tamano()

Es el orden en que has construido el informe, y el orden en que se lee el fichero de arriba abajo. Si un día tienes que arreglar algo, la inicial te dice en qué bloque de funciones mirar.

Los programas se ejecutan con GNU awk 5.4.1 compilado a WebAssembly, software libre con licencia GPL-3.0. Código fuente: gawk en ftp.gnu.org · receta de compilación.