Vector: Recolección de Logs de Alto Rendimiento y Pipelines de Observabilidad

TL;DR — Resumen Rápido

Vector es un pipeline de observabilidad en Rust de Datadog. Recolecta logs, métricas y trazas desde cualquier fuente y los enruta con transformaciones VRL.

Vector es un pipeline de datos de observabilidad de alto rendimiento escrito en Rust, mantenido por Datadog. Recolecta logs, métricas y trazas desde cualquier fuente, los transforma con VRL (Vector Remap Language) y los enruta hacia cualquier destino, todo en un único binario enlazado estáticamente que usa una fracción de la memoria que consumen Logstash o Fluentd. Esta guía cubre el stack completo de Vector: arquitectura, instalación, configuración, transformaciones VRL, patrones de despliegue, garantías de entrega y un pipeline de producción que recolecta logs de Nginx y los enruta a Loki y ClickHouse.

Requisitos Previos

• Servidor Linux (Ubuntu 22.04+, Debian 12+, RHEL 9+) o macOS para pruebas locales.
• Docker o clúster de Kubernetes (opcional, para despliegues en contenedores).
• Familiaridad básica con configuración YAML.
• Destinos funcionando y accesibles (Loki, Elasticsearch, ClickHouse, S3, etc.).

---

Arquitectura de Vector

Vector procesa datos de observabilidad como un grafo dirigido acíclico (DAG) de fuentes → transformaciones → destinos.

• Fuentes — ingieren datos desde archivos, journals, sockets, HTTP, Kafka, APIs en la nube.
• Transformaciones — parsean, enriquecen, filtran, enrutan, agregan o deduplicar eventos.
• Destinos — entregan datos a sistemas de almacenamiento, búsqueda, métricas y alertas.

Bajo el capó, Vector logra su rendimiento mediante varias decisiones de diseño nativas de Rust:

• Parseo sin copia — las líneas de log se parsean en el lugar sin asignaciones adicionales de heap.
• Concurrencia adaptativa — Vector ajusta automáticamente el número de peticiones en vuelo hacia cada destino usando un algoritmo AIMD, evitando sobrecarga sin configuración manual.
• Confirmaciones de extremo a extremo — una línea de log no se elimina de su fuente (o buffer) hasta que todos los destinos configurados confirman su recepción.
• Buffers en disco — los eventos se desbordan a disco cuando la cola en memoria se llena, sobreviviendo reinicios y evitando pérdidas durante interrupciones del destino.

---

Instalación

apt (Debian/Ubuntu)

curl -1sLf 'https://repositories.timber.io/public/vector/cfg/setup/bash.deb.sh' \
  | sudo -E bash
sudo apt install -y vector
sudo systemctl enable --now vector

yum/dnf (RHEL/Fedora/Rocky)

curl -1sLf 'https://repositories.timber.io/public/vector/cfg/setup/bash.rpm.sh' \
  | sudo -E bash
sudo yum install -y vector
sudo systemctl enable --now vector

Docker

docker run -d \
  --name vector \
  -v /var/log:/var/log:ro \
  -v $(pwd)/vector.yaml:/etc/vector/vector.yaml:ro \
  timberio/vector:latest-alpine

Kubernetes DaemonSet via Helm

helm repo add vector https://helm.vector.dev
helm repo update
helm install vector vector/vector \
  --namespace vector \
  --create-namespace \
  --values vector-values.yaml

Homebrew (macOS)

brew tap vectordotdev/brew
brew install vector

---

Configuración

Vector lee vector.yaml (o vector.toml, vector.json) desde /etc/vector/ por defecto:

data_dir: /var/lib/vector

sources:
  mi_fuente:
    type: file
    include: ["/var/log/nginx/*.log"]

transforms:
  mi_transformacion:
    type: remap
    inputs: ["mi_fuente"]
    source: |
      . = parse_json!(string!(.message))

sinks:
  mi_destino:
    type: loki
    inputs: ["mi_transformacion"]
    endpoint: "http://loki:3100"
    labels:
      job: nginx

Cada componente tiene una clave de cadena única. inputs conecta los componentes entre sí.

---

Referencia de Fuentes

Fuente	Clave type	Descripción
Seguimiento de archivos	file	Sigue archivos de log con patrones glob
Journal systemd	journald	Lee de journald con filtros de unidad
Contenedores Docker	docker_logs	Recolecta del socket del daemon Docker
Pods de Kubernetes	kubernetes_logs	Recolección nativa de k8s con metadatos de pod
Syslog UDP/TCP	syslog	Recibe mensajes syslog RFC 3164 / RFC 5424
Servidor HTTP	http_server	Expone un endpoint HTTP para logs enviados
Kafka	kafka	Consume de uno o más tópicos de Kafka
Métricas del host	host_metrics	Recolecta CPU, memoria, disco, red
Métricas internas	internal_metrics	Contadores de rendimiento y error propios de Vector

---

VRL — Vector Remap Language

VRL es el lenguaje de transformación en el núcleo de Vector. Es un lenguaje de expresiones de tipo estático diseñado para ser rápido, seguro y legible. Cada programa VRL recibe un evento como . (punto) y debe devolver el evento mutado.

Parsear JSON

transforms:
  parsear_json:
    type: remap
    inputs: ["nginx_access"]
    source: |
      . = parse_json!(string!(.message))

El sufijo ! en una llamada de función significa “abortar el evento si esto falla.” Los eventos que fallan se enrutan a la salida dropped del componente.

Parsear Syslog

transforms:
  parsear_syslog:
    type: remap
    inputs: ["syslog_entrada"]
    source: |
      parsed = parse_syslog!(.message)
      .severity = parsed.severity
      .facility = parsed.facility
      .appname = parsed.appname
      .message = parsed.message

Lógica Condicional y Redacción de PII

source: |
  if .status_code >= 500 {
    .severity = "error"
  } else if .status_code >= 400 {
    .severity = "warn"
  } else {
    .severity = "info"
  }

  .message = redact(.message, filters: [
    { type: "pattern", pattern: r'\b(?:\d[ -]*?){13,16}\b' }
  ])

  del(.trace_id_interno)

Parseo con Expresión Regular para Nginx

transforms:
  parsear_nginx:
    type: remap
    inputs: ["nginx_access"]
    source: |
      parsed, err = parse_regex(.message, r'^(?P<remote_addr>\S+) - (?P<user>\S+) \[(?P<time>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+) (?P<protocol>[^"]+)" (?P<status>\d+) (?P<bytes>\d+)')
      if err == null {
        . = merge(., parsed)
        .status = to_int!(.status)
        .bytes = to_int!(.bytes)
        del(.message)
      }

---

Referencia de Transformaciones

Transformación	Propósito
remap	Transformación VRL completa — parsear, enriquecer, filtrar, mutar
filter	Descartar eventos que no coincidan con una condición VRL
route	Dividir el stream en carriles nombrados por condición
aggregate	Combinar múltiples eventos en uno (agrupación, ventanas de tiempo)
dedupe	Descartar eventos duplicados dentro de una ventana de tiempo
sample	Conservar un porcentaje configurable de eventos
log_to_metric	Derivar contadores/medidores desde campos de log

---

Referencia de Destinos

Destino	Clave type	Caso de uso
Loki	loki	Almacenamiento de logs de Grafana
Elasticsearch / OpenSearch	elasticsearch	Búsqueda de texto completo y analítica
ClickHouse	clickhouse	Almacenamiento analítico de logs de alto volumen
S3 / R2	aws_s3	Archivado a largo plazo
Kafka	kafka	Republica a consumidores posteriores
Prometheus Exporter	prometheus_exporter	Expone métricas en /metrics
Datadog Logs	datadog_logs	Envía a la ingesta de Datadog
Splunk HEC	splunk_hec_logs	Envía al Splunk HTTP Event Collector

---

Buffers y Garantías de Entrega

Para producción, habilitar buffers en disco y confirmaciones:

sinks:
  clickhouse_destino:
    type: clickhouse
    inputs: ["parsear_nginx"]
    endpoint: "http://clickhouse:8123"
    database: logs
    table: nginx_access
    buffer:
      type: disk
      max_size: 268435456
      when_full: block
    acknowledgements:
      enabled: true

Con acknowledgements.enabled: true, Vector espera la confirmación del destino antes de avanzar la posición de lectura en la fuente, logrando entrega duradera al menos una vez.

---

Pruebas Unitarias de Transformaciones

tests:
  - name: "parsear_nginx procesa solicitud 200 correctamente"
    inputs:
      - insert_at: parsear_nginx
        type: log
        log_fields:
          message: '127.0.0.1 - - [23/Mar/2026:10:00:00 +0000] "GET /api/health HTTP/1.1" 200 42'
    outputs:
      - extract_from: parsear_nginx
        conditions:
          - type: vrl
            source: |
              assert_eq!(.status, 200)
              assert_eq!(.method, "GET")

vector test /etc/vector/vector.yaml

---

Monitorización de Vector

# Rendimiento por componente en tiempo real
vector top

# Validar configuración sin arrancar
vector validate /etc/vector/vector.yaml

Exponer las propias métricas de Vector a Prometheus:

sources:
  metricas_internas:
    type: internal_metrics
    scrape_interval_secs: 15

sinks:
  prometheus:
    type: prometheus_exporter
    inputs: ["metricas_internas"]
    address: "0.0.0.0:9598"

---

Vector vs Alternativas

Característica	Vector	Fluentd	Fluent Bit	Logstash	Filebeat	Promtail	Grafana Alloy
Lenguaje	Rust	Ruby	C	JVM	Go	Go	Go
Memoria	~20 MB	~200 MB	~1 MB	~512 MB	~50 MB	~30 MB	~60 MB
Rendimiento	Muy alto	Medio	Alto	Medio	Alto	Medio	Alto
Transformaciones	VRL	DSL Fluentd	Lua	Ruby/Grok	Mínimo	Stages	DSL Alloy
Pipeline de métricas	Sí	Plugin	Limitado	Plugin	No	No	Sí
Buffers en disco	Nativo	Plugin	Sí	Nativo	Nativo	No	Sí
Pruebas unitarias	Integradas	No	No	No	No	No	Limitado
Kubernetes nativo	Sí	Sí	Sí	No	Sí	Sí	Sí

---

Casos Límite y Trampas Comunes

• VRL ! vs ? — parse_json! aborta el evento ante un error; parse_json? devuelve null. Elige conscientemente.
• Seguimiento de posición de archivos — Vector almacena offsets en data_dir. Borrar este directorio causa re-ingesta de archivos existentes.
• Cardinalidad de etiquetas en Loki — evita usar campos de alta cardinalidad (IDs de usuario, IDs de solicitud) como etiquetas de Loki.
• Tipos de datos en ClickHouse — predefine el esquema de la tabla y establece skip_unknown_fields: true para evitar errores de ingesta.

---

Resumen

• Vector es un pipeline de observabilidad basado en Rust con un modelo DAG de fuentes → transformaciones → destinos.
• VRL maneja todo el parseo, enriquecimiento, filtrado y enrutamiento en un lenguaje seguro y testeable.
• Modos de despliegue: agente (por host), agregador (centralizado), sidecar (pod de Kubernetes).
• Buffers en disco + confirmaciones proveen entrega duradera al menos una vez sin pérdida de datos ante caídas.
• Pruebas unitarias en vector.yaml validan las transformaciones antes del despliegue en producción.
• Vector maneja logs y métricas en un único pipeline, reemplazando Fluentd, Logstash, Filebeat y Promtail simultáneamente.

Artículos Relacionados

• Grafana Loki Log Aggregation Setup
• Docker Compose Multi-Container Applications
• Prometheus Monitoring with Grafana Dashboards
• Kubernetes DaemonSet Configuration Guide