@sonde/packs 0.0.0 → 0.1.1

package/src/mysql/probes/status.ts

@@ -0,0 +1,56 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface MysqlStatusResult {
+  uptime: number;
+  threads: number;
+  questions: number;
+  slowQueries: number;
+  opens: number;
+  openTables: number;
+  queriesPerSecondAvg: number;
+  variables: Record<string, string>;
+}
+
+export const status: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? 'localhost';
+  const port = String((params?.port as number) ?? 3306);
+  const user = (params?.user as string) ?? 'root';
+
+  const stdout = await exec('mysql', [
+    '-h',
+    host,
+    '-P',
+    port,
+    '-u',
+    user,
+    '--batch',
+    '--skip-column-names',
+    '-e',
+    'SHOW GLOBAL STATUS',
+  ]);
+  return parseMysqlStatus(stdout);
+};
+
+export function parseMysqlStatus(stdout: string): MysqlStatusResult {
+  const variables: Record<string, string> = {};
+  for (const line of stdout.split('\n')) {
+    const parts = line.split('\t');
+    if (parts.length >= 2) {
+      variables[parts[0]!] = parts[1]!;
+    }
+  }
+
+  const uptime = Number(variables['Uptime']) || 0;
+  const questions = Number(variables['Questions']) || 0;
+
+  return {
+    uptime,
+    threads: Number(variables['Threads_connected']) || 0,
+    questions,
+    slowQueries: Number(variables['Slow_queries']) || 0,
+    opens: Number(variables['Opened_tables']) || 0,
+    openTables: Number(variables['Open_tables']) || 0,
+    queriesPerSecondAvg: uptime > 0 ? Math.round((questions / uptime) * 100) / 100 : 0,
+    variables,
+  };
+}

package/src/nginx/index.ts

@@ -0,0 +1,14 @@
+import type { Pack } from '../types.js';
+import { nginxManifest } from './manifest.js';
+import { accessLogTail } from './probes/access-log-tail.js';
+import { configTest } from './probes/config-test.js';
+import { errorLogTail } from './probes/error-log-tail.js';
+
+export const nginxPack: Pack = {
+  manifest: nginxManifest,
+  handlers: {
+    'nginx.config.test': configTest,
+    'nginx.access.log.tail': accessLogTail,
+    'nginx.error.log.tail': errorLogTail,
+  },
+};

package/src/nginx/manifest.ts

@@ -0,0 +1,69 @@
+import type { PackManifest } from '@sonde/shared';
+
+export const nginxManifest: PackManifest = {
+  name: 'nginx',
+  version: '0.1.0',
+  description: 'Nginx web server probes: config validation, access/error log tailing',
+  requires: {
+    groups: [],
+    files: ['/etc/nginx/nginx.conf'],
+    commands: ['nginx'],
+  },
+  probes: [
+    {
+      name: 'config.test',
+      description: 'Test nginx configuration for syntax errors',
+      capability: 'observe',
+      timeout: 10_000,
+    },
+    {
+      name: 'access.log.tail',
+      description: 'Tail recent lines from the nginx access log',
+      capability: 'observe',
+      params: {
+        logPath: {
+          type: 'string',
+          description: 'Path to access log file',
+          required: false,
+          default: '/var/log/nginx/access.log',
+        },
+        lines: {
+          type: 'number',
+          description: 'Number of lines to tail',
+          required: false,
+          default: 100,
+        },
+      },
+      timeout: 10_000,
+    },
+    {
+      name: 'error.log.tail',
+      description: 'Tail recent lines from the nginx error log',
+      capability: 'observe',
+      params: {
+        logPath: {
+          type: 'string',
+          description: 'Path to error log file',
+          required: false,
+          default: '/var/log/nginx/error.log',
+        },
+        lines: {
+          type: 'number',
+          description: 'Number of lines to tail',
+          required: false,
+          default: 100,
+        },
+      },
+      timeout: 10_000,
+    },
+  ],
+  runbook: {
+    category: 'nginx',
+    probes: ['config.test', 'error.log.tail'],
+    parallel: true,
+  },
+  detect: {
+    commands: ['nginx'],
+    files: ['/etc/nginx/nginx.conf'],
+  },
+};

package/src/nginx/probes/access-log-tail.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { AccessLogTailResult } from './access-log-tail.js';
+import { accessLogTail, parseLogTail } from './access-log-tail.js';
+
+const SAMPLE_LOG = `192.168.1.1 - - [15/Jan/2024:10:30:00 +0000] "GET / HTTP/1.1" 200 612
+192.168.1.2 - - [15/Jan/2024:10:30:01 +0000] "GET /api HTTP/1.1" 200 1234
+192.168.1.1 - - [15/Jan/2024:10:30:02 +0000] "POST /login HTTP/1.1" 302 0
+`;
+
+describe('parseLogTail', () => {
+  it('parses log lines correctly', () => {
+    const result = parseLogTail('/var/log/nginx/access.log', SAMPLE_LOG);
+    expect(result.logPath).toBe('/var/log/nginx/access.log');
+    expect(result.lineCount).toBe(3);
+    expect(result.lines[0]).toContain('GET / HTTP/1.1');
+  });
+
+  it('handles empty log', () => {
+    const result = parseLogTail('/var/log/nginx/access.log', '');
+    expect(result.lineCount).toBe(0);
+    expect(result.lines).toEqual([]);
+  });
+});
+
+describe('accessLogTail handler', () => {
+  it('uses default path and line count', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('tail');
+      expect(args).toEqual(['-n', '100', '/var/log/nginx/access.log']);
+      return SAMPLE_LOG;
+    };
+
+    const result = (await accessLogTail(undefined, mockExec)) as AccessLogTailResult;
+    expect(result.lineCount).toBe(3);
+  });
+
+  it('uses custom path and lines', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('tail');
+      expect(args).toEqual(['-n', '50', '/custom/access.log']);
+      return SAMPLE_LOG;
+    };
+
+    const result = (await accessLogTail(
+      { logPath: '/custom/access.log', lines: 50 },
+      mockExec,
+    )) as AccessLogTailResult;
+    expect(result.logPath).toBe('/custom/access.log');
+  });
+});

package/src/nginx/probes/access-log-tail.ts

@@ -0,0 +1,23 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface AccessLogTailResult {
+  logPath: string;
+  lines: string[];
+  lineCount: number;
+}
+
+export const accessLogTail: ProbeHandler = async (params, exec) => {
+  const logPath = (params?.logPath as string) ?? '/var/log/nginx/access.log';
+  const lines = (params?.lines as number) ?? 100;
+
+  const stdout = await exec('tail', ['-n', String(lines), logPath]);
+  return parseLogTail(logPath, stdout);
+};
+
+export function parseLogTail(logPath: string, stdout: string): AccessLogTailResult {
+  const lines = stdout.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return { logPath, lines, lineCount: lines.length };
+}

package/src/nginx/probes/config-test.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { ConfigTestResult } from './config-test.js';
+import { configTest, parseConfigTest } from './config-test.js';
+
+const SUCCESS_OUTPUT =
+  'nginx: the configuration file /etc/nginx/nginx.conf syntax is ok\nnginx: configuration file /etc/nginx/nginx.conf test is successful';
+
+describe('parseConfigTest', () => {
+  it('parses successful config test', () => {
+    const result = parseConfigTest(SUCCESS_OUTPUT, true);
+    expect(result.valid).toBe(true);
+    expect(result.output).toContain('syntax is ok');
+  });
+
+  it('parses failed config test', () => {
+    const result = parseConfigTest(
+      'nginx: [emerg] unexpected "}" in /etc/nginx/nginx.conf:42',
+      false,
+    );
+    expect(result.valid).toBe(false);
+    expect(result.output).toContain('unexpected');
+  });
+});
+
+describe('configTest handler', () => {
+  it('calls nginx -t and returns success', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('nginx');
+      expect(args).toEqual(['-t']);
+      return SUCCESS_OUTPUT;
+    };
+
+    const result = (await configTest(undefined, mockExec)) as ConfigTestResult;
+    expect(result.valid).toBe(true);
+  });
+
+  it('handles config error gracefully', async () => {
+    const mockExec: ExecFn = async () => {
+      throw new Error('nginx: [emerg] unknown directive');
+    };
+
+    const result = (await configTest(undefined, mockExec)) as ConfigTestResult;
+    expect(result.valid).toBe(false);
+    expect(result.output).toContain('unknown directive');
+  });
+});

package/src/nginx/probes/config-test.ts

@@ -0,0 +1,24 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface ConfigTestResult {
+  valid: boolean;
+  output: string;
+}
+
+export const configTest: ProbeHandler = async (_params, exec) => {
+  try {
+    const stdout = await exec('nginx', ['-t']);
+    return parseConfigTest(stdout, true);
+  } catch (err) {
+    // nginx -t writes to stderr and exits non-zero on failure
+    const message = err instanceof Error ? err.message : String(err);
+    return parseConfigTest(message, false);
+  }
+};
+
+export function parseConfigTest(output: string, valid: boolean): ConfigTestResult {
+  return {
+    valid,
+    output: output.trim(),
+  };
+}

package/src/nginx/probes/error-log-tail.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { ErrorLogTailResult } from './error-log-tail.js';
+import { errorLogTail, parseErrorLogTail } from './error-log-tail.js';
+
+const SAMPLE_ERROR_LOG = `2024/01/15 10:30:00 [error] 1234#1234: *5 open() "/usr/share/nginx/html/favicon.ico" failed (2: No such file or directory)
+2024/01/15 10:30:01 [warn] 1234#1234: conflicting server name "example.com"
+`;
+
+describe('parseErrorLogTail', () => {
+  it('parses error log lines', () => {
+    const result = parseErrorLogTail('/var/log/nginx/error.log', SAMPLE_ERROR_LOG);
+    expect(result.logPath).toBe('/var/log/nginx/error.log');
+    expect(result.lineCount).toBe(2);
+    expect(result.lines[0]).toContain('[error]');
+  });
+});
+
+describe('errorLogTail handler', () => {
+  it('uses default path and line count', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('tail');
+      expect(args).toEqual(['-n', '100', '/var/log/nginx/error.log']);
+      return SAMPLE_ERROR_LOG;
+    };
+
+    const result = (await errorLogTail(undefined, mockExec)) as ErrorLogTailResult;
+    expect(result.lineCount).toBe(2);
+  });
+
+  it('uses custom parameters', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('tail');
+      expect(args).toEqual(['-n', '25', '/custom/error.log']);
+      return SAMPLE_ERROR_LOG;
+    };
+
+    const result = (await errorLogTail(
+      { logPath: '/custom/error.log', lines: 25 },
+      mockExec,
+    )) as ErrorLogTailResult;
+    expect(result.logPath).toBe('/custom/error.log');
+  });
+});

package/src/nginx/probes/error-log-tail.ts

@@ -0,0 +1,23 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface ErrorLogTailResult {
+  logPath: string;
+  lines: string[];
+  lineCount: number;
+}
+
+export const errorLogTail: ProbeHandler = async (params, exec) => {
+  const logPath = (params?.logPath as string) ?? '/var/log/nginx/error.log';
+  const lines = (params?.lines as number) ?? 100;
+
+  const stdout = await exec('tail', ['-n', String(lines), logPath]);
+  return parseErrorLogTail(logPath, stdout);
+};
+
+export function parseErrorLogTail(logPath: string, stdout: string): ErrorLogTailResult {
+  const lines = stdout.split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return { logPath, lines, lineCount: lines.length };
+}

package/src/postgres/index.ts

@@ -0,0 +1,14 @@
+import type { Pack } from '../types.js';
+import { postgresManifest } from './manifest.js';
+import { connectionsActive } from './probes/connections-active.js';
+import { databasesList } from './probes/databases-list.js';
+import { querySlow } from './probes/query-slow.js';
+
+export const postgresPack: Pack = {
+  manifest: postgresManifest,
+  handlers: {
+    'postgres.databases.list': databasesList,
+    'postgres.connections.active': connectionsActive,
+    'postgres.query.slow': querySlow,
+  },
+};

package/src/postgres/manifest.ts

@@ -0,0 +1,91 @@
+import type { PackManifest } from '@sonde/shared';
+
+export const postgresManifest: PackManifest = {
+  name: 'postgres',
+  version: '0.1.0',
+  description: 'PostgreSQL probes: database listing, active connections, slow queries',
+  requires: {
+    groups: [],
+    files: [],
+    commands: ['psql'],
+  },
+  probes: [
+    {
+      name: 'databases.list',
+      description: 'List all PostgreSQL databases with sizes',
+      capability: 'observe',
+      params: {
+        host: {
+          type: 'string',
+          description: 'Database host',
+          required: false,
+          default: 'localhost',
+        },
+        port: { type: 'number', description: 'Database port', required: false, default: 5432 },
+        user: {
+          type: 'string',
+          description: 'Database user',
+          required: false,
+          default: 'postgres',
+        },
+      },
+      timeout: 15_000,
+    },
+    {
+      name: 'connections.active',
+      description: 'List active PostgreSQL connections',
+      capability: 'observe',
+      params: {
+        host: {
+          type: 'string',
+          description: 'Database host',
+          required: false,
+          default: 'localhost',
+        },
+        port: { type: 'number', description: 'Database port', required: false, default: 5432 },
+        user: {
+          type: 'string',
+          description: 'Database user',
+          required: false,
+          default: 'postgres',
+        },
+      },
+      timeout: 15_000,
+    },
+    {
+      name: 'query.slow',
+      description: 'List currently running slow queries (> threshold)',
+      capability: 'observe',
+      params: {
+        host: {
+          type: 'string',
+          description: 'Database host',
+          required: false,
+          default: 'localhost',
+        },
+        port: { type: 'number', description: 'Database port', required: false, default: 5432 },
+        user: {
+          type: 'string',
+          description: 'Database user',
+          required: false,
+          default: 'postgres',
+        },
+        thresholdMs: {
+          type: 'number',
+          description: 'Slow query threshold in ms',
+          required: false,
+          default: 1000,
+        },
+      },
+      timeout: 15_000,
+    },
+  ],
+  runbook: {
+    category: 'postgres',
+    probes: ['databases.list', 'connections.active', 'query.slow'],
+    parallel: true,
+  },
+  detect: {
+    commands: ['psql'],
+  },
+};

package/src/postgres/probes/connections-active.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { ConnectionsActiveResult } from './connections-active.js';
+import { connectionsActive, parseConnectionsActive } from './connections-active.js';
+
+const SAMPLE_OUTPUT = `1234\tmyapp\tappuser\t192.168.1.10\tactive\tSELECT * FROM users\t2024-01-15 10:30:00
+5678\tpostgres\tpostgres\t\tidle\t\t2024-01-15 09:00:00`;
+
+describe('parseConnectionsActive', () => {
+  it('parses connections output', () => {
+    const result = parseConnectionsActive(SAMPLE_OUTPUT);
+    expect(result.total).toBe(2);
+    expect(result.connections[0]).toEqual({
+      pid: 1234,
+      database: 'myapp',
+      user: 'appuser',
+      clientAddr: '192.168.1.10',
+      state: 'active',
+      query: 'SELECT * FROM users',
+      backendStart: '2024-01-15 10:30:00',
+    });
+  });
+
+  it('handles empty output', () => {
+    const result = parseConnectionsActive('');
+    expect(result.total).toBe(0);
+  });
+});
+
+describe('connectionsActive handler', () => {
+  it('calls psql with correct args', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('psql');
+      expect(args).toContain('-t');
+      expect(args).toContain('-A');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await connectionsActive(undefined, mockExec)) as ConnectionsActiveResult;
+    expect(result.total).toBe(2);
+  });
+});

package/src/postgres/probes/connections-active.ts

@@ -0,0 +1,55 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface ConnectionInfo {
+  pid: number;
+  database: string;
+  user: string;
+  clientAddr: string;
+  state: string;
+  query: string;
+  backendStart: string;
+}
+
+export interface ConnectionsActiveResult {
+  connections: ConnectionInfo[];
+  total: number;
+}
+
+export const connectionsActive: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? 'localhost';
+  const port = String((params?.port as number) ?? 5432);
+  const user = (params?.user as string) ?? 'postgres';
+
+  const stdout = await exec('psql', [
+    '-h',
+    host,
+    '-p',
+    port,
+    '-U',
+    user,
+    '-t',
+    '-A',
+    '-F',
+    '\t',
+    '-c',
+    'SELECT pid, datname, usename, client_addr, state, LEFT(query, 200), backend_start FROM pg_stat_activity WHERE state IS NOT NULL AND pid <> pg_backend_pid() ORDER BY backend_start DESC',
+  ]);
+  return parseConnectionsActive(stdout);
+};
+
+export function parseConnectionsActive(stdout: string): ConnectionsActiveResult {
+  const lines = stdout.trim().split('\n').filter(Boolean);
+  const connections: ConnectionInfo[] = lines.map((line) => {
+    const parts = line.split('\t');
+    return {
+      pid: Number(parts[0]) || 0,
+      database: parts[1] ?? '',
+      user: parts[2] ?? '',
+      clientAddr: parts[3] ?? '',
+      state: parts[4] ?? '',
+      query: parts[5] ?? '',
+      backendStart: parts[6] ?? '',
+    };
+  });
+  return { connections, total: connections.length };
+}

package/src/postgres/probes/databases-list.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import type { ExecFn } from '../../types.js';
+import type { DatabasesListResult } from './databases-list.js';
+import { databasesList, parseDatabasesList } from './databases-list.js';
+
+const SAMPLE_OUTPUT = `postgres\tpostgres\tUTF8\t8537 kB
+myapp\tappuser\tUTF8\t156 MB
+analytics\tanalyst\tUTF8\t2345 MB`;
+
+describe('parseDatabasesList', () => {
+  it('parses psql output into structured data', () => {
+    const result = parseDatabasesList(SAMPLE_OUTPUT);
+    expect(result.count).toBe(3);
+    expect(result.databases[0]).toEqual({
+      name: 'postgres',
+      owner: 'postgres',
+      encoding: 'UTF8',
+      sizePretty: '8537 kB',
+    });
+    expect(result.databases[1]?.name).toBe('myapp');
+  });
+
+  it('handles empty output', () => {
+    const result = parseDatabasesList('');
+    expect(result.count).toBe(0);
+    expect(result.databases).toEqual([]);
+  });
+});
+
+describe('databasesList handler', () => {
+  it('calls psql with default params', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(cmd).toBe('psql');
+      expect(args).toContain('-h');
+      expect(args).toContain('localhost');
+      expect(args).toContain('-p');
+      expect(args).toContain('5432');
+      expect(args).toContain('-U');
+      expect(args).toContain('postgres');
+      return SAMPLE_OUTPUT;
+    };
+
+    const result = (await databasesList(undefined, mockExec)) as DatabasesListResult;
+    expect(result.count).toBe(3);
+  });
+
+  it('passes custom host/port/user', async () => {
+    const mockExec: ExecFn = async (cmd, args) => {
+      expect(args).toContain('db.example.com');
+      expect(args).toContain('5433');
+      expect(args).toContain('admin');
+      return SAMPLE_OUTPUT;
+    };
+
+    await databasesList({ host: 'db.example.com', port: 5433, user: 'admin' }, mockExec);
+  });
+});

package/src/postgres/probes/databases-list.ts

@@ -0,0 +1,49 @@
+import type { ProbeHandler } from '../../types.js';
+
+export interface DatabaseInfo {
+  name: string;
+  owner: string;
+  encoding: string;
+  sizePretty: string;
+}
+
+export interface DatabasesListResult {
+  databases: DatabaseInfo[];
+  count: number;
+}
+
+export const databasesList: ProbeHandler = async (params, exec) => {
+  const host = (params?.host as string) ?? 'localhost';
+  const port = String((params?.port as number) ?? 5432);
+  const user = (params?.user as string) ?? 'postgres';
+
+  const stdout = await exec('psql', [
+    '-h',
+    host,
+    '-p',
+    port,
+    '-U',
+    user,
+    '-t',
+    '-A',
+    '-F',
+    '\t',
+    '-c',
+    'SELECT datname, pg_catalog.pg_get_userbyid(datdba), pg_catalog.pg_encoding_to_char(encoding), pg_catalog.pg_size_pretty(pg_catalog.pg_database_size(datname)) FROM pg_catalog.pg_database WHERE datistemplate = false ORDER BY datname',
+  ]);
+  return parseDatabasesList(stdout);
+};
+
+export function parseDatabasesList(stdout: string): DatabasesListResult {
+  const lines = stdout.trim().split('\n').filter(Boolean);
+  const databases: DatabaseInfo[] = lines.map((line) => {
+    const [name, owner, encoding, sizePretty] = line.split('\t');
+    return {
+      name: name ?? '',
+      owner: owner ?? '',
+      encoding: encoding ?? '',
+      sizePretty: sizePretty ?? '',
+    };
+  });
+  return { databases, count: databases.length };
+}