rdapify 0.3.0 → 0.3.2

package/dist/esm/infrastructure/logging/AuditLogger.js

@@ -0,0 +1,187 @@
+import * as fs from 'fs/promises';
+export class InMemoryAuditAdapter {
+    constructor(options) {
+        this.events = [];
+        this.maxEvents = options?.maxEvents ?? 10000;
+        this.retentionMs = (options?.retentionHours ?? 24) * 60 * 60 * 1000;
+    }
+    write(event) {
+        this.evict();
+        this.events.push(event);
+        if (this.events.length > this.maxEvents) {
+            this.events = this.events.slice(-this.maxEvents);
+        }
+    }
+    getEvents(since) {
+        if (!since) {
+            return [...this.events];
+        }
+        const sinceMs = new Date(since).getTime();
+        return this.events.filter((e) => new Date(e.timestamp).getTime() >= sinceMs);
+    }
+    getEventsByType(type) {
+        return this.events.filter((e) => e.eventType === type);
+    }
+    clear() {
+        this.events = [];
+    }
+    size() {
+        return this.events.length;
+    }
+    evict() {
+        const cutoff = Date.now() - this.retentionMs;
+        this.events = this.events.filter((e) => new Date(e.timestamp).getTime() >= cutoff);
+    }
+}
+export class FileAuditAdapter {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async write(event) {
+        const line = JSON.stringify(event) + '\n';
+        await fs.appendFile(this.filePath, line, 'utf8');
+    }
+    async flush() {
+    }
+}
+export class AuditLogger {
+    constructor(options) {
+        this.eventsLogged = 0;
+        this.enabled = options?.enabled ?? true;
+        this.adapter = options?.adapter ?? new InMemoryAuditAdapter({
+            retentionHours: options?.retentionHours ?? 24,
+        });
+        this.includeRequestHeaders = options?.includeRequestHeaders ?? false;
+        this.includeResponseSize = options?.includeResponseSize ?? false;
+        this.sessionId = options?.sessionId;
+        this.clientId = options?.clientId;
+        this.tags = options?.tags;
+    }
+    log(event) {
+        if (!this.enabled)
+            return;
+        const fullEvent = {
+            ...event,
+            id: this.generateId(),
+            timestamp: new Date().toISOString(),
+        };
+        if (!this.includeRequestHeaders) {
+            delete fullEvent.requestHeaders;
+        }
+        if (!this.includeResponseSize) {
+            delete fullEvent.responseSize;
+        }
+        if (this.tags) {
+            fullEvent.tags = { ...this.tags, ...fullEvent.tags };
+        }
+        this.adapter.write(fullEvent);
+        this.eventsLogged++;
+    }
+    logQueryStart(params) {
+        this.log({
+            eventType: 'QUERY_START',
+            queryType: params.queryType,
+            query: params.query,
+            success: false,
+            durationMs: 0,
+            cached: false,
+            sessionId: params.sessionId ?? this.sessionId,
+            clientId: params.clientId ?? this.clientId,
+        });
+    }
+    logQuerySuccess(params) {
+        this.log({
+            eventType: 'QUERY_SUCCESS',
+            queryType: params.queryType,
+            query: params.query,
+            normalizedQuery: params.normalizedQuery,
+            success: true,
+            durationMs: params.durationMs,
+            cached: params.cached,
+            serverUrl: params.serverUrl,
+            responseSize: this.includeResponseSize ? params.responseSize : undefined,
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    logQueryFailure(params) {
+        this.log({
+            eventType: 'QUERY_FAILURE',
+            queryType: params.queryType,
+            query: params.query,
+            success: false,
+            durationMs: params.durationMs,
+            cached: false,
+            errorCode: params.errorCode,
+            errorMessage: params.errorMessage,
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    logCacheHit(params) {
+        this.log({
+            eventType: 'CACHE_HIT',
+            queryType: params.queryType,
+            query: params.query,
+            success: true,
+            durationMs: 0,
+            cached: true,
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    logRateLimitExceeded(params) {
+        this.log({
+            eventType: 'RATE_LIMIT_EXCEEDED',
+            queryType: params.queryType,
+            query: params.query,
+            success: false,
+            durationMs: 0,
+            cached: false,
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    logSSRFBlocked(params) {
+        this.log({
+            eventType: 'SSRF_BLOCKED',
+            queryType: 'domain',
+            query: params.url,
+            success: false,
+            durationMs: 0,
+            cached: false,
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    logPIIRedacted(params) {
+        this.log({
+            eventType: 'PII_REDACTED',
+            queryType: params.queryType,
+            query: params.query,
+            success: true,
+            durationMs: 0,
+            cached: false,
+            tags: { fieldsRedacted: String(params.fieldsRedacted) },
+            sessionId: this.sessionId,
+            clientId: this.clientId,
+        });
+    }
+    async flush() {
+        if (this.adapter.flush) {
+            await this.adapter.flush();
+        }
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    getStats() {
+        return {
+            enabled: this.enabled,
+            eventsLogged: this.eventsLogged,
+        };
+    }
+    generateId() {
+        return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
+    }
+}

package/dist/esm/infrastructure/logging/Logger.js

@@ -0,0 +1,145 @@
+export class Logger {
+    constructor(options = {}) {
+        this.logs = [];
+        this.maxLogs = 1000;
+        this.levelPriority = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3,
+        };
+        this.level = options.level || 'info';
+        this.enabled = options.enabled ?? true;
+        this.logRequests = options.logRequests ?? true;
+        this.logResponses = options.logResponses ?? true;
+        this.format = options.format || 'text';
+        this.output = options.output || this.defaultOutput.bind(this);
+    }
+    debug(message, context) {
+        this.log('debug', message, context);
+    }
+    info(message, context) {
+        this.log('info', message, context);
+    }
+    warn(message, context) {
+        this.log('warn', message, context);
+    }
+    error(message, context) {
+        this.log('error', message, context);
+    }
+    logRequest(type, query, context) {
+        if (!this.logRequests)
+            return;
+        this.info(`REQUEST → ${type}: ${query}`, {
+            queryType: type,
+            queryValue: query,
+            ...context,
+        });
+    }
+    logResponse(type, query, success, duration, context) {
+        if (!this.logResponses)
+            return;
+        const status = success ? '✓' : '✗';
+        const message = `RESPONSE ${status} ${type}: ${query} (${duration}ms)`;
+        if (success) {
+            this.info(message, {
+                queryType: type,
+                queryValue: query,
+                success,
+                durationMs: duration,
+                ...context,
+            });
+        }
+        else {
+            this.warn(message, {
+                queryType: type,
+                queryValue: query,
+                success,
+                durationMs: duration,
+                ...context,
+            });
+        }
+    }
+    logPerformance(operation, duration, context) {
+        this.debug(`PERFORMANCE: ${operation} took ${duration}ms`, {
+            operation,
+            durationMs: duration,
+            ...context,
+        });
+    }
+    logCache(operation, key, context) {
+        const emoji = operation === 'hit' ? '✓' : operation === 'miss' ? '✗' : '→';
+        this.debug(`CACHE ${emoji} ${operation}: ${key}`, {
+            operation,
+            cacheKey: key,
+            ...context,
+        });
+    }
+    log(level, message, context) {
+        if (!this.enabled)
+            return;
+        if (this.levelPriority[level] < this.levelPriority[this.level])
+            return;
+        const entry = {
+            level,
+            message,
+            timestamp: Date.now(),
+            context,
+        };
+        this.logs.push(entry);
+        if (this.logs.length > this.maxLogs) {
+            this.logs = this.logs.slice(-this.maxLogs);
+        }
+        this.output(entry);
+    }
+    defaultOutput(entry) {
+        if (this.format === 'json') {
+            console.log(JSON.stringify(entry));
+            return;
+        }
+        const timestamp = new Date(entry.timestamp).toISOString();
+        const level = entry.level.toUpperCase().padEnd(5);
+        const contextStr = entry.context ? ` ${JSON.stringify(entry.context)}` : '';
+        const colors = {
+            debug: '\x1b[36m',
+            info: '\x1b[32m',
+            warn: '\x1b[33m',
+            error: '\x1b[31m',
+        };
+        const reset = '\x1b[0m';
+        const color = colors[entry.level];
+        console.log(`${color}[${timestamp}] ${level}${reset} ${entry.message}${contextStr}`);
+    }
+    getLogs(count) {
+        return count ? this.logs.slice(-count) : [...this.logs];
+    }
+    getLogsByLevel(level) {
+        return this.logs.filter((log) => log.level === level);
+    }
+    getLogsInRange(startTime, endTime) {
+        return this.logs.filter((log) => log.timestamp >= startTime && log.timestamp <= endTime);
+    }
+    clear() {
+        this.logs = [];
+    }
+    export() {
+        return [...this.logs];
+    }
+    getStats() {
+        const logsByLevel = {
+            debug: 0,
+            info: 0,
+            warn: 0,
+            error: 0,
+        };
+        this.logs.forEach((log) => {
+            logsByLevel[log.level]++;
+        });
+        return {
+            enabled: this.enabled,
+            level: this.level,
+            totalLogs: this.logs.length,
+            logsByLevel,
+        };
+    }
+}

package/dist/esm/infrastructure/monitoring/GrafanaDashboard.js

@@ -0,0 +1,115 @@
+export const RDAPIFY_GRAFANA_DASHBOARD = {
+    __inputs: [
+        {
+            name: 'DS_PROMETHEUS',
+            label: 'Prometheus',
+            description: '',
+            type: 'datasource',
+            pluginId: 'prometheus',
+            pluginName: 'Prometheus',
+        },
+    ],
+    __requires: [
+        { type: 'grafana', id: 'grafana', name: 'Grafana', version: '9.0.0' },
+        { type: 'datasource', id: 'prometheus', name: 'Prometheus', version: '1.0.0' },
+        { type: 'panel', id: 'timeseries', name: 'Time series', version: '' },
+        { type: 'panel', id: 'stat', name: 'Stat', version: '' },
+        { type: 'panel', id: 'gauge', name: 'Gauge', version: '' },
+    ],
+    annotations: { list: [{ builtIn: 1, datasource: { type: 'grafana', uid: '-- Grafana --' }, enable: true, hide: true, iconColor: 'rgba(0, 211, 255, 1)', name: 'Annotations & Alerts', type: 'dashboard' }] },
+    description: 'RDAPify RDAP client metrics — query rates, cache performance, and error tracking',
+    editable: true,
+    fiscalYearStartMonth: 0,
+    graphTooltip: 1,
+    id: null,
+    links: [],
+    liveNow: false,
+    panels: [
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'thresholds' }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'green', value: null }] }, unit: 'short' }, overrides: [] },
+            gridPos: { h: 4, w: 4, x: 0, y: 0 },
+            id: 1,
+            options: { colorMode: 'background', graphMode: 'area', justifyMode: 'auto', orientation: 'auto', reduceOptions: { calcs: ['lastNotNull'], fields: '', values: false }, textMode: 'auto' },
+            title: 'Total Queries',
+            type: 'stat',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_queries_total', legendFormat: 'Queries', refId: 'A' }],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'thresholds' }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'red', value: null }, { color: 'orange', value: 0.8 }, { color: 'green', value: 0.95 }] }, unit: 'percentunit', max: 1, min: 0 }, overrides: [] },
+            gridPos: { h: 4, w: 4, x: 4, y: 0 },
+            id: 2,
+            options: { colorMode: 'background', graphMode: 'none', justifyMode: 'auto', orientation: 'auto', reduceOptions: { calcs: ['lastNotNull'], fields: '', values: false }, textMode: 'auto' },
+            title: 'Success Rate',
+            type: 'stat',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_success_rate', legendFormat: 'Success Rate', refId: 'A' }],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'thresholds' }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'red', value: null }, { color: 'orange', value: 0.3 }, { color: 'green', value: 0.7 }] }, unit: 'percentunit', max: 1, min: 0 }, overrides: [] },
+            gridPos: { h: 4, w: 4, x: 8, y: 0 },
+            id: 3,
+            options: { colorMode: 'background', graphMode: 'none', justifyMode: 'auto', orientation: 'auto', reduceOptions: { calcs: ['lastNotNull'], fields: '', values: false }, textMode: 'auto' },
+            title: 'Cache Hit Rate',
+            type: 'stat',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_cache_hit_rate', legendFormat: 'Cache Hit Rate', refId: 'A' }],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'thresholds' }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'green', value: null }, { color: 'orange', value: 500 }, { color: 'red', value: 2000 }] }, unit: 'ms' }, overrides: [] },
+            gridPos: { h: 4, w: 4, x: 12, y: 0 },
+            id: 4,
+            options: { colorMode: 'value', graphMode: 'area', justifyMode: 'auto', orientation: 'auto', reduceOptions: { calcs: ['lastNotNull'], fields: '', values: false }, textMode: 'auto' },
+            title: 'Avg Response Time',
+            type: 'stat',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_response_time_avg_ms', legendFormat: 'Avg', refId: 'A' }],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'palette-classic' }, custom: { axisCenteredZero: false, axisColorMode: 'text', axisLabel: '', axisPlacement: 'auto', barAlignment: 0, drawStyle: 'line', fillOpacity: 10, gradientMode: 'none', hideFrom: { legend: false, tooltip: false, viz: false }, lineInterpolation: 'linear', lineWidth: 1, pointSize: 5, scaleDistribution: { type: 'linear' }, showPoints: 'auto', spanNulls: false, stacking: { group: 'A', mode: 'none' }, thresholdsStyle: { mode: 'off' } }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'green', value: null }, { color: 'red', value: 80 }] }, unit: 'ms' }, overrides: [] },
+            gridPos: { h: 8, w: 12, x: 0, y: 4 },
+            id: 5,
+            options: { legend: { calcs: [], displayMode: 'list', placement: 'bottom', showLegend: true }, tooltip: { mode: 'single', sort: 'none' } },
+            title: 'Response Time Percentiles',
+            type: 'timeseries',
+            targets: [
+                { datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_response_time_p50_ms', legendFormat: 'P50', refId: 'A' },
+                { datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_response_time_p90_ms', legendFormat: 'P90', refId: 'B' },
+                { datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_response_time_p99_ms', legendFormat: 'P99', refId: 'C' },
+            ],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'palette-classic' }, custom: { axisCenteredZero: false, axisColorMode: 'text', axisLabel: '', axisPlacement: 'auto', barAlignment: 0, drawStyle: 'line', fillOpacity: 10, gradientMode: 'none', hideFrom: { legend: false, tooltip: false, viz: false }, lineInterpolation: 'linear', lineWidth: 1, pointSize: 5, scaleDistribution: { type: 'linear' }, showPoints: 'auto', spanNulls: false, stacking: { group: 'A', mode: 'none' }, thresholdsStyle: { mode: 'off' } }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'green', value: null }] }, unit: 'short' }, overrides: [] },
+            gridPos: { h: 8, w: 12, x: 12, y: 4 },
+            id: 6,
+            options: { legend: { calcs: [], displayMode: 'list', placement: 'bottom', showLegend: true }, tooltip: { mode: 'single', sort: 'none' } },
+            title: 'Queries by Type',
+            type: 'timeseries',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_queries_by_type_total', legendFormat: '{{type}}', refId: 'A' }],
+        },
+        {
+            datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' },
+            fieldConfig: { defaults: { color: { mode: 'palette-classic' }, custom: { axisCenteredZero: false, axisColorMode: 'text', axisLabel: '', axisPlacement: 'auto', barAlignment: 0, drawStyle: 'bars', fillOpacity: 80, gradientMode: 'none', hideFrom: { legend: false, tooltip: false, viz: false }, lineInterpolation: 'linear', lineWidth: 1, pointSize: 5, scaleDistribution: { type: 'linear' }, showPoints: 'auto', spanNulls: false, stacking: { group: 'A', mode: 'normal' }, thresholdsStyle: { mode: 'off' } }, mappings: [], thresholds: { mode: 'absolute', steps: [{ color: 'green', value: null }] }, unit: 'short' }, overrides: [] },
+            gridPos: { h: 8, w: 24, x: 0, y: 12 },
+            id: 7,
+            options: { legend: { calcs: [], displayMode: 'list', placement: 'bottom', showLegend: true }, tooltip: { mode: 'single', sort: 'none' } },
+            title: 'Errors by Type',
+            type: 'timeseries',
+            targets: [{ datasource: { type: 'prometheus', uid: '${DS_PROMETHEUS}' }, expr: 'rdapify_errors_by_type_total', legendFormat: '{{error_type}}', refId: 'A' }],
+        },
+    ],
+    refresh: '30s',
+    schemaVersion: 38,
+    style: 'dark',
+    tags: ['rdapify', 'rdap'],
+    templating: { list: [] },
+    time: { from: 'now-1h', to: 'now' },
+    timepicker: {},
+    timezone: '',
+    title: 'RDAPify',
+    uid: 'rdapify-dashboard',
+    version: 1,
+    weekStart: '',
+};