Integrations & Transports Integraciones y Transportes

Panoptes SDK integrates seamlessly with your existing stack. Send audit events to multiple destinations using transports. Panoptes SDK se integra perfectamente con tu stack existente. Envía eventos de auditoría a múltiples destinos usando transportes.

What are Transports? ¿Qué son los Transportes?

Transports define where your audit events are sent. You can configure multiple transports to send the same audit event to different destinations simultaneously - for example, both console output for development and a dedicated audit database for production. Los transportes definen dónde se envían tus eventos de auditoría. Puedes configurar múltiples transportes para enviar el mismo evento de auditoría a diferentes destinos simultáneamente - por ejemplo, tanto salida de consola para desarrollo como una base de datos de auditoría dedicada para producción.

Built-in Transports Transportes Integrados

Panoptes SDK includes 4 built-in transports ready to use: Panoptes SDK incluye 4 transportes integrados listos para usar:

Console Transport Transporte de Consola

Development Desarrollo

Perfect for development and debugging. Logs audit events to the console with a clear prefix. Perfecto para desarrollo y depuración. Registra eventos de auditoría en la consola con un prefijo claro.

javascript

import { initAudit } from '@panoptes/sdk';

// Enable console transport
initAudit({
  appName: 'my-app',
  environment: 'development',
  transports: {
    enabled: ['console']
  }
});

// Output format: [Panoptes][audit-event] {"meta":{...}, "db":{...}, ...}

File Transport Transporte de Archivo

Log Files Archivos Log

Write audit events to log files. Each event is appended as a JSON line (JSONL format). Escribe eventos de auditoría en archivos de log. Cada evento se agrega como una línea JSON (formato JSONL).

javascript

import { initAudit } from '@panoptes/sdk';

// Enable file transport
initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['file'],
    file: {
      path: './logs/panoptes-audit.log'  // Default: panoptes-audit.log
    }
  }
});

// Each audit event is appended to the file as a new JSON line
// You can use tools like jq to parse and analyze the logs:
// cat panoptes-audit.log | jq '.operation.type'

HTTP Transport Transporte HTTP

Webhooks Webhooks

Send audit events to any HTTP endpoint. Perfect for integrating with webhooks, SIEM systems, or custom audit services. Envía eventos de auditoría a cualquier endpoint HTTP. Perfecto para integrar con webhooks, sistemas SIEM, o servicios de auditoría personalizados.

javascript

import { initAudit } from '@panoptes/sdk';

// Enable HTTP transport
initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['http'],
    http: {
      endpoint: 'https://your-audit-service.com/api/events'
    }
  }
});

// Sends POST request with JSON body for each audit event
// Headers: { "content-type": "application/json" }
// Body: { meta: {...}, db: {...}, operation: {...}, ... }

Database Transport Transporte de Base de Datos

Recommended Recomendado

Store audit events in a dedicated database. Supports all 5 database engines (PostgreSQL, MySQL, MSSQL, SQLite, Oracle). Almacena eventos de auditoría en una base de datos dedicada. Soporta los 5 motores de base de datos (PostgreSQL, MySQL, MSSQL, SQLite, Oracle).

javascript

import { initAudit, generateAuditTableSQL } from '@panoptes/sdk';
import { Client } from 'pg';

// 1. Create connection to your AUDIT database (separate from app database)
const auditDbClient = new Client({
  host: 'localhost',
  database: 'audit_logs',  // Separate database for audits
  user: 'audit_user',
  password: 'audit_password'
});

await auditDbClient.connect();

// 2. Create audit table (run once)
const createTableSQL = generateAuditTableSQL('postgres');
await auditDbClient.query(createTableSQL);

// 3. Initialize with database transport
initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['database'],
    database: {
      client: auditDbClient,
      engine: 'postgres',  // or 'mysql', 'mssql', 'sqlite', 'oracle'
      tableName: 'panoptes_audit_log',  // Default table name
      autoCreateTable: true  // Automatically create table if it doesn't exist
    }
  }
});

Multiple Transports Múltiples Transportes

Enable All Transports Simultaneously Habilitar Todos los Transportes Simultáneamente

All enabled transports receive every audit event Todos los transportes habilitados reciben cada evento de auditoría

javascript

import { initAudit } from '@panoptes/sdk';

// Enable multiple transports
initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    // Enable all four transports
    enabled: ['console', 'file', 'http', 'database'],

    // Configure each transport
    file: {
      path: './logs/audit.log'
    },
    http: {
      endpoint: 'https://siem-system.com/api/audit'
    },
    database: {
      client: auditDbClient,
      engine: 'postgres',
      autoCreateTable: true
    }
  }
});

// Now every audit event goes to:
// 1. Console (for real-time monitoring)
// 2. File (for log aggregation)
// 3. HTTP endpoint (for SIEM integration)
// 4. Database (for querying and analysis)

Best Practice Mejor Práctica

Development: Desarrollo: Use console transport for quick debugging Usa transporte de consola para depuración rápida
Staging: Staging: Combine console + file for testing Combina consola + archivo para pruebas
Production: Producción: Use database + HTTP for compliance and monitoring Usa base de datos + HTTP para cumplimiento y monitoreo

Audit Table Schema Esquema de Tabla de Auditoría

When using the database transport, Panoptes creates a comprehensive audit table with all relevant fields: Cuando uses el transporte de base de datos, Panoptes crea una tabla de auditoría completa con todos los campos relevantes:

sql

-- The audit table includes:
CREATE TABLE panoptes_audit_log (
  id BIGSERIAL PRIMARY KEY,

  -- Metadata
  app_name VARCHAR(255),
  environment VARCHAR(50),
  timestamp TIMESTAMP,
  timestamp_unix BIGINT,
  date DATE,
  time TIME,
  duration_ms INTEGER,
  reason VARCHAR(500),

  -- Database info
  db_engine VARCHAR(50),
  db_host VARCHAR(255),
  db_name VARCHAR(255),
  db_user VARCHAR(255),
  db_schema VARCHAR(255),

  -- Operation details
  operation_type VARCHAR(50),
  operation_category VARCHAR(50),
  main_table VARCHAR(255),
  tables_involved JSONB,

  -- SQL details
  sql_raw TEXT,
  sql_normalized TEXT,
  sql_parameters JSONB,
  row_count INTEGER,
  success BOOLEAN,
  error_code VARCHAR(50),
  error_message TEXT,

  -- Data changes (before/after snapshots)
  data_before JSONB,
  data_after JSONB,

  -- Actor (who made the change)
  actor_type VARCHAR(50),
  actor_user_id VARCHAR(255),
  actor_username VARCHAR(255),
  actor_roles JSONB,
  actor_tenant_id VARCHAR(255),

  -- Request context
  request_ip VARCHAR(45),
  request_user_agent TEXT,
  request_id VARCHAR(255),
  request_session_id VARCHAR(255)
);

Querying Audit Logs Consultando Logs de Auditoría

With the database transport, you can easily query your audit logs: Con el transporte de base de datos, puedes consultar fácilmente tus logs de auditoría:

Common Audit Queries Consultas de Auditoría Comunes

sql

-- Find all changes to users table today
SELECT timestamp, operation_type, actor_username, sql_raw
FROM panoptes_audit_log
WHERE main_table = 'users'
  AND date = CURRENT_DATE
ORDER BY timestamp DESC;

-- Find all DELETE operations by a specific user
SELECT timestamp, main_table, data_before
FROM panoptes_audit_log
WHERE operation_type = 'DELETE'
  AND actor_username = 'john.doe'
ORDER BY timestamp DESC;

-- Find failed operations
SELECT timestamp, operation_type, main_table, error_message
FROM panoptes_audit_log
WHERE success = FALSE
ORDER BY timestamp DESC;

-- Track changes to a specific record
SELECT timestamp, operation_type, actor_username,
       data_before, data_after
FROM panoptes_audit_log
WHERE main_table = 'users'
  AND sql_raw LIKE '%WHERE id = 123%'
ORDER BY timestamp DESC;

Integration Examples Ejemplos de Integración

Popular integrations with external systems and tools: Integraciones populares con sistemas y herramientas externas:

Splunk Integration (via HTTP) Integración con Splunk (vía HTTP)

javascript

initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['http'],
    http: {
      endpoint: 'https://your-splunk-instance:8088/services/collector/event',
      headers: {
        'Authorization': 'Splunk your-hec-token'
      }
    }
  }
});

Elasticsearch Integration (via HTTP) Integración con Elasticsearch (vía HTTP)

javascript

initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['http'],
    http: {
      endpoint: 'https://your-elasticsearch:9200/audit-logs/_doc',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Basic ' + btoa('username:password')
      }
    }
  }
});

Log Aggregation (File + External Service) Agregación de Logs (Archivo + Servicio Externo)

Use file transport with log shipping tools like Filebeat, Fluentd, or Logstash Usa el transporte de archivo con herramientas de envío de logs como Filebeat, Fluentd, o Logstash

javascript

// Write to file
initAudit({
  appName: 'my-app',
  environment: 'production',
  transports: {
    enabled: ['file'],
    file: {
      path: '/var/log/panoptes/audit.log'
    }
  }
});

// Then configure Filebeat to ship logs to your ELK stack
// filebeat.yml:
// filebeat.inputs:
// - type: log
//   enabled: true
//   paths:
//     - /var/log/panoptes/audit.log
//   json.keys_under_root: true

Next Steps Próximos Pasos

Now that you understand transports and integrations, continue to Comparison to see how Panoptes compares to other solutions. Ahora que entiendes transportes e integraciones, continúa a Comparación para ver cómo Panoptes se compara con otras soluciones.

Continue to Comparison Continuar a Comparación

Compare Panoptes with other audit solutions Compara Panoptes con otras soluciones de auditoría