@gguf/coder 0.3.0 → 0.3.1

package/source/utils/logging/log-query/aggregation/facet-generator.spec.ts

@@ -0,0 +1,159 @@
+/**
+ * Tests for facet generator
+ */
+
+import test from 'ava';
+import {generateFacets} from './facet-generator.js';
+import type {LogEntry} from '../types.js';
+
+// Helper to create test log entry
+function createLogEntry(overrides: Partial<LogEntry> = {}): LogEntry {
+	return {
+		timestamp: new Date().toISOString(),
+		level: 'info',
+		message: 'Test message',
+		...overrides,
+	};
+}
+
+test('generateFacets: empty entries returns empty facets', t => {
+	const facets = generateFacets([]);
+
+	t.deepEqual(facets.levels, {});
+	t.deepEqual(facets.sources, {});
+	t.deepEqual(facets.tags, {});
+	t.deepEqual(facets.errorTypes, {});
+	t.deepEqual(facets.hours, {});
+});
+
+test('generateFacets: counts levels correctly', t => {
+	const entries = [
+		createLogEntry({level: 'error'}),
+		createLogEntry({level: 'error'}),
+		createLogEntry({level: 'warn'}),
+		createLogEntry({level: 'info'}),
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.levels.error, 2);
+	t.is(facets.levels.warn, 1);
+	t.is(facets.levels.info, 1);
+});
+
+test('generateFacets: counts sources correctly', t => {
+	const entries = [
+		createLogEntry({source: 'api-server'}),
+		createLogEntry({source: 'api-server'}),
+		createLogEntry({source: 'db-server'}),
+		createLogEntry({}), // No source
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.sources['api-server'], 2);
+	t.is(facets.sources['db-server'], 1);
+	t.is(Object.keys(facets.sources).length, 2);
+});
+
+test('generateFacets: counts tags correctly', t => {
+	const entries = [
+		createLogEntry({tags: ['auth', 'security']}),
+		createLogEntry({tags: ['auth']}),
+		createLogEntry({tags: ['performance']}),
+		createLogEntry({}), // No tags
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.tags.auth, 2);
+	t.is(facets.tags.security, 1);
+	t.is(facets.tags.performance, 1);
+});
+
+test('generateFacets: counts error types correctly', t => {
+	const entries = [
+		createLogEntry({error: {type: 'ValidationError'}}),
+		createLogEntry({error: {type: 'ValidationError'}}),
+		createLogEntry({error: {type: 'TypeError'}}),
+		createLogEntry({}), // No error
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.errorTypes.ValidationError, 2);
+	t.is(facets.errorTypes.TypeError, 1);
+	t.is(Object.keys(facets.errorTypes).length, 2);
+});
+
+test('generateFacets: counts hours correctly', t => {
+	const entries = [
+		createLogEntry({timestamp: '2025-01-15T10:30:00Z'}),
+		createLogEntry({timestamp: '2025-01-15T10:45:00Z'}),
+		createLogEntry({timestamp: '2025-01-15T11:00:00Z'}),
+		createLogEntry({timestamp: '2025-01-15T11:30:00Z'}),
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.hours['2025-01-15T10'], 2);
+	t.is(facets.hours['2025-01-15T11'], 2);
+});
+
+test('generateFacets: handles multiple facets together', t => {
+	const entries = [
+		createLogEntry({
+			level: 'error',
+			source: 'api-server',
+			tags: ['critical', 'database'],
+			error: {type: 'ConnectionError'},
+			timestamp: '2025-01-15T14:00:00Z',
+		}),
+		createLogEntry({
+			level: 'error',
+			source: 'api-server',
+			tags: ['critical'],
+			error: {type: 'TimeoutError'},
+			timestamp: '2025-01-15T14:30:00Z',
+		}),
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.levels.error, 2);
+	t.is(facets.sources['api-server'], 2);
+	t.is(facets.tags.critical, 2);
+	t.is(facets.tags.database, 1);
+	t.is(facets.errorTypes.ConnectionError, 1);
+	t.is(facets.errorTypes.TimeoutError, 1);
+	t.is(facets.hours['2025-01-15T14'], 2);
+});
+
+test('generateFacets: single entry with all fields', t => {
+	const entries = [
+		createLogEntry({
+			level: 'warn',
+			source: 'db-server',
+			tags: ['slow', 'query'],
+			error: {type: 'SlowQueryWarning'},
+			timestamp: '2025-01-15T09:00:00Z',
+		}),
+	];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.levels.warn, 1);
+	t.is(facets.sources['db-server'], 1);
+	t.is(facets.tags.slow, 1);
+	t.is(facets.tags.query, 1);
+	t.is(facets.errorTypes.SlowQueryWarning, 1);
+	t.is(facets.hours['2025-01-15T09'], 1);
+});
+
+test('generateFacets: handles duplicate tag in same entry', t => {
+	const entries = [createLogEntry({tags: ['test', 'test']})];
+
+	const facets = generateFacets(entries);
+
+	t.is(facets.tags.test, 2); // Should count both occurrences
+});

package/source/utils/logging/log-query/aggregation/facet-generator.ts

@@ -0,0 +1,47 @@
+/**
+ * Facet generation for query results
+ */
+
+import type {LogEntry} from '../types';
+
+/**
+ * Generate facets (counts by category) for filtered log entries
+ */
+export function generateFacets(entries: LogEntry[]) {
+	const facets = {
+		levels: {} as Record<string, number>,
+		sources: {} as Record<string, number>,
+		tags: {} as Record<string, number>,
+		errorTypes: {} as Record<string, number>,
+		hours: {} as Record<string, number>,
+	};
+
+	for (const entry of entries) {
+		// Level facet
+		facets.levels[entry.level] = (facets.levels[entry.level] || 0) + 1;
+
+		// Source facet
+		if (entry.source) {
+			facets.sources[entry.source] = (facets.sources[entry.source] || 0) + 1;
+		}
+
+		// Tags facet
+		if (entry.tags) {
+			for (const tag of entry.tags) {
+				facets.tags[tag] = (facets.tags[tag] || 0) + 1;
+			}
+		}
+
+		// Error type facet
+		if (entry.error?.type) {
+			facets.errorTypes[entry.error.type] =
+				(facets.errorTypes[entry.error.type] || 0) + 1;
+		}
+
+		// Hour facet
+		const hour = new Date(entry.timestamp).toISOString().substring(0, 13);
+		facets.hours[hour] = (facets.hours[hour] || 0) + 1;
+	}
+
+	return facets;
+}

package/source/utils/logging/log-query/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Log query interface for searching and analyzing log data
+ * Provides powerful filtering, searching, and analytics capabilities
+ */
+
+// Re-export types (may be used for type annotations)
+export type {
+	LogEntry,
+	LogQuery,
+	QueryResult,
+	AggregationOptions,
+	AggregationResult,
+} from './types';
+
+// Re-export global storage instance (used by logging system)
+export {globalLogStorage} from './storage/log-storage';
+
+/**
+ * Internal exports - import directly from specific modules if needed:
+ * - LogStorage: './storage/log-storage'
+ * - LogQueryBuilder, createLogQuery: './query/query-builder'
+ * - logQueries: './utils/helpers'
+ */

package/source/utils/logging/log-query/query/filter-predicates.spec.ts

@@ -0,0 +1,247 @@
+/**
+ * Tests for filter predicates
+ */
+
+import test from 'ava';
+import {matchesQuery} from './filter-predicates.js';
+import type {LogEntry, LogQuery} from '../types.js';
+
+// Helper to create test log entry
+function createLogEntry(overrides: Partial<LogEntry> = {}): LogEntry {
+	return {
+		timestamp: '2025-01-01T12:00:00Z',
+		level: 'info',
+		message: 'Test message',
+		...overrides,
+	};
+}
+
+test('matchesQuery: empty query matches all entries', t => {
+	const entry = createLogEntry();
+	const query: LogQuery = {};
+
+	t.true(matchesQuery(entry, query));
+});
+
+test('matchesQuery: time range - startTime filter', t => {
+	const entry = createLogEntry({timestamp: '2025-01-02T00:00:00Z'});
+
+	t.true(matchesQuery(entry, {startTime: new Date('2025-01-01T00:00:00Z')}));
+	t.false(matchesQuery(entry, {startTime: new Date('2025-01-03T00:00:00Z')}));
+});
+
+test('matchesQuery: time range - endTime filter', t => {
+	const entry = createLogEntry({timestamp: '2025-01-02T00:00:00Z'});
+
+	t.true(matchesQuery(entry, {endTime: new Date('2025-01-03T00:00:00Z')}));
+	t.false(matchesQuery(entry, {endTime: new Date('2025-01-01T00:00:00Z')}));
+});
+
+test('matchesQuery: level filter - includes', t => {
+	const entry = createLogEntry({level: 'error'});
+
+	t.true(matchesQuery(entry, {levels: ['error', 'warn']}));
+	t.false(matchesQuery(entry, {levels: ['info', 'debug']}));
+});
+
+test('matchesQuery: level filter - excludes', t => {
+	const entry = createLogEntry({level: 'info'});
+
+	t.false(matchesQuery(entry, {excludeLevels: ['info', 'debug']}));
+	t.true(matchesQuery(entry, {excludeLevels: ['error', 'warn']}));
+});
+
+test('matchesQuery: message contains', t => {
+	const entry = createLogEntry({message: 'User login successful'});
+
+	t.true(matchesQuery(entry, {messageContains: 'login'}));
+	t.false(matchesQuery(entry, {messageContains: 'logout'}));
+});
+
+test('matchesQuery: message regex', t => {
+	const entry = createLogEntry({message: 'Error: File not found'});
+
+	t.true(matchesQuery(entry, {messageRegex: /Error:.*/}));
+	t.false(matchesQuery(entry, {messageRegex: /Warning:.*/}));
+});
+
+test('matchesQuery: message starts with', t => {
+	const entry = createLogEntry({message: 'Starting application'});
+
+	t.true(matchesQuery(entry, {messageStartsWith: 'Starting'}));
+	t.false(matchesQuery(entry, {messageStartsWith: 'Stopping'}));
+});
+
+test('matchesQuery: message ends with', t => {
+	const entry = createLogEntry({message: 'Process completed successfully'});
+
+	t.true(matchesQuery(entry, {messageEndsWith: 'successfully'}));
+	t.false(matchesQuery(entry, {messageEndsWith: 'failed'}));
+});
+
+test('matchesQuery: correlation ID filter', t => {
+	const entry = createLogEntry({correlationId: 'corr-123'});
+
+	t.true(matchesQuery(entry, {correlationIds: ['corr-123', 'corr-456']}));
+	t.false(matchesQuery(entry, {correlationIds: ['corr-456', 'corr-789']}));
+});
+
+test('matchesQuery: correlation ID filter - missing correlationId', t => {
+	const entry = createLogEntry({}); // No correlationId
+
+	t.false(matchesQuery(entry, {correlationIds: ['corr-123']}));
+});
+
+test('matchesQuery: source filter', t => {
+	const entry = createLogEntry({source: 'api-server'});
+
+	t.true(matchesQuery(entry, {sources: ['api-server', 'db-server']}));
+	t.false(matchesQuery(entry, {sources: ['db-server', 'cache-server']}));
+});
+
+test('matchesQuery: exclude sources filter', t => {
+	const entry = createLogEntry({source: 'api-server'});
+
+	t.false(matchesQuery(entry, {excludeSources: ['api-server']}));
+	t.true(matchesQuery(entry, {excludeSources: ['db-server']}));
+});
+
+test('matchesQuery: tags filter', t => {
+	const entry = createLogEntry({tags: ['auth', 'security']});
+
+	t.true(matchesQuery(entry, {tags: ['auth']}));
+	t.true(matchesQuery(entry, {tags: ['security']}));
+	t.false(matchesQuery(entry, {tags: ['performance']}));
+});
+
+test('matchesQuery: hasTags filter', t => {
+	const entryWithTags = createLogEntry({tags: ['test']});
+	const entryWithoutTags = createLogEntry({});
+
+	t.true(matchesQuery(entryWithTags, {hasTags: true}));
+	t.false(matchesQuery(entryWithoutTags, {hasTags: true}));
+});
+
+test('matchesQuery: exclude tags filter', t => {
+	const entry = createLogEntry({tags: ['auth', 'security']});
+
+	t.true(matchesQuery(entry, {excludeTags: ['performance']}));
+	t.false(matchesQuery(entry, {excludeTags: ['auth']}));
+});
+
+test('matchesQuery: metadata key exists', t => {
+	const entry = createLogEntry({metadata: {userId: '123'}});
+
+	t.true(matchesQuery(entry, {metadataKey: 'userId'}));
+	t.false(matchesQuery(entry, {metadataKey: 'requestId'}));
+});
+
+test('matchesQuery: metadata value matches', t => {
+	const entry = createLogEntry({metadata: {status: 'active'}});
+
+	t.true(matchesQuery(entry, {metadataKey: 'status', metadataValue: 'active'}));
+	t.false(
+		matchesQuery(entry, {metadataKey: 'status', metadataValue: 'inactive'}),
+	);
+});
+
+test('matchesQuery: metadata exists filter', t => {
+	const entry = createLogEntry({metadata: {userId: '123'}});
+
+	t.true(matchesQuery(entry, {metadataExists: 'userId'}));
+	t.false(matchesQuery(entry, {metadataExists: 'requestId'}));
+});
+
+test('matchesQuery: duration min filter', t => {
+	const entry = createLogEntry({performance: {duration: 1500}});
+
+	t.true(matchesQuery(entry, {durationMin: 1000}));
+	t.false(matchesQuery(entry, {durationMin: 2000}));
+});
+
+test('matchesQuery: duration max filter', t => {
+	const entry = createLogEntry({performance: {duration: 1500}});
+
+	t.true(matchesQuery(entry, {durationMax: 2000}));
+	t.false(matchesQuery(entry, {durationMax: 1000}));
+});
+
+test('matchesQuery: memory threshold filter', t => {
+	const entry = createLogEntry({
+		performance: {memory: {heapUsed: 50000000}},
+	});
+
+	// memoryThreshold acts as minimum - entries below threshold are filtered out
+	t.true(matchesQuery(entry, {memoryThreshold: 30000000})); // 50MB >= 30MB
+	t.false(matchesQuery(entry, {memoryThreshold: 100000000})); // 50MB < 100MB
+});
+
+test('matchesQuery: has errors filter', t => {
+	const entryWithError = createLogEntry({error: {message: 'Error occurred'}});
+	const entryWithoutError = createLogEntry({});
+
+	t.true(matchesQuery(entryWithError, {hasErrors: true}));
+	t.false(matchesQuery(entryWithoutError, {hasErrors: true}));
+	t.true(matchesQuery(entryWithoutError, {hasErrors: false}));
+});
+
+test('matchesQuery: error types filter', t => {
+	const entry = createLogEntry({error: {type: 'ValidationError'}});
+
+	t.true(matchesQuery(entry, {errorTypes: ['ValidationError', 'TypeError']}));
+	t.false(matchesQuery(entry, {errorTypes: ['ReferenceError']}));
+});
+
+test('matchesQuery: request methods filter', t => {
+	const entry = createLogEntry({request: {method: 'POST'}});
+
+	t.true(matchesQuery(entry, {requestMethods: ['POST', 'PUT']}));
+	t.false(matchesQuery(entry, {requestMethods: ['GET', 'DELETE']}));
+});
+
+test('matchesQuery: request status codes filter', t => {
+	const entry = createLogEntry({request: {statusCode: 404}});
+
+	t.true(matchesQuery(entry, {requestStatusCodes: [404, 500]}));
+	t.false(matchesQuery(entry, {requestStatusCodes: [200, 201]}));
+});
+
+test('matchesQuery: request duration min filter', t => {
+	const entry = createLogEntry({request: {duration: 1500}});
+
+	t.true(matchesQuery(entry, {requestDurationMin: 1000}));
+	t.false(matchesQuery(entry, {requestDurationMin: 2000}));
+});
+
+test('matchesQuery: request duration max filter', t => {
+	const entry = createLogEntry({request: {duration: 1500}});
+
+	t.true(matchesQuery(entry, {requestDurationMax: 2000}));
+	t.false(matchesQuery(entry, {requestDurationMax: 1000}));
+});
+
+test('matchesQuery: multiple filters combined', t => {
+	const entry = createLogEntry({
+		level: 'error',
+		message: 'Database connection failed',
+		source: 'db-server',
+		tags: ['database', 'critical'],
+	});
+
+	t.true(
+		matchesQuery(entry, {
+			levels: ['error'],
+			messageContains: 'Database',
+			sources: ['db-server'],
+			tags: ['database'],
+		}),
+	);
+
+	t.false(
+		matchesQuery(entry, {
+			levels: ['error'],
+			messageContains: 'API', // This doesn't match
+			sources: ['db-server'],
+		}),
+	);
+});

package/source/utils/logging/log-query/query/filter-predicates.ts

@@ -0,0 +1,154 @@
+/**
+ * Filter predicates for matching log entries against queries
+ */
+
+import type {LogEntry, LogQuery} from '../types';
+
+/**
+ * Check if a log entry matches the given query filters
+ */
+export function matchesQuery(entry: LogEntry, query: LogQuery): boolean {
+	// Time range filtering
+	if (query.startTime && new Date(entry.timestamp) < query.startTime)
+		return false;
+	if (query.endTime && new Date(entry.timestamp) > query.endTime) return false;
+
+	// Level filtering
+	if (query.levels && !query.levels.includes(entry.level)) return false;
+	if (query.excludeLevels && query.excludeLevels.includes(entry.level))
+		return false;
+
+	// Message filtering
+	if (query.messageContains && !entry.message.includes(query.messageContains))
+		return false;
+	if (query.messageRegex && !query.messageRegex.test(entry.message))
+		return false;
+	if (
+		query.messageStartsWith &&
+		!entry.message.startsWith(query.messageStartsWith)
+	)
+		return false;
+	if (query.messageEndsWith && !entry.message.endsWith(query.messageEndsWith))
+		return false;
+
+	// Correlation and request filtering
+	if (query.correlationIds) {
+		if (!entry.correlationId) return false;
+		if (!query.correlationIds.includes(entry.correlationId)) return false;
+	}
+	if (
+		query.requestIds &&
+		entry.requestId &&
+		!query.requestIds.includes(entry.requestId)
+	)
+		return false;
+	if (query.userIds && entry.userId && !query.userIds.includes(entry.userId))
+		return false;
+	if (
+		query.sessionIds &&
+		entry.sessionId &&
+		!query.sessionIds.includes(entry.sessionId)
+	)
+		return false;
+
+	// Source filtering
+	if (query.sources) {
+		if (!entry.source) return false;
+		if (!query.sources.includes(entry.source)) return false;
+	}
+	if (
+		query.excludeSources &&
+		entry.source &&
+		query.excludeSources.includes(entry.source)
+	)
+		return false;
+
+	// Tag filtering
+	if (query.hasTags && (!entry.tags || entry.tags.length === 0)) return false;
+	if (query.tags && entry.tags) {
+		const hasAnyTag = query.tags.some(tag => entry.tags?.includes(tag));
+		if (!hasAnyTag) return false;
+	}
+	if (query.excludeTags && entry.tags) {
+		const hasExcludedTag = query.excludeTags.some(tag =>
+			entry.tags?.includes(tag),
+		);
+		if (hasExcludedTag) return false;
+	}
+
+	// Metadata filtering
+	if (
+		query.metadataKey &&
+		(!entry.metadata || !(query.metadataKey in entry.metadata))
+	)
+		return false;
+	if (query.metadataKey && query.metadataValue !== undefined) {
+		if (entry.metadata?.[query.metadataKey] !== query.metadataValue)
+			return false;
+	}
+	if (
+		query.metadataExists &&
+		(!entry.metadata || !(query.metadataExists in entry.metadata))
+	)
+		return false;
+
+	// Performance filtering
+	if (
+		query.durationMin &&
+		entry.performance?.duration &&
+		entry.performance.duration < query.durationMin
+	)
+		return false;
+	if (
+		query.durationMax &&
+		entry.performance?.duration &&
+		entry.performance.duration > query.durationMax
+	)
+		return false;
+	if (
+		query.memoryThreshold &&
+		entry.performance?.memory?.heapUsed &&
+		entry.performance.memory.heapUsed < query.memoryThreshold
+	)
+		return false;
+
+	// Error filtering
+	if (query.hasErrors !== undefined) {
+		const hasError = !!entry.error;
+		if (hasError !== query.hasErrors) return false;
+	}
+	if (
+		query.errorTypes &&
+		entry.error &&
+		!query.errorTypes.includes(entry.error.type || '')
+	)
+		return false;
+
+	// Request filtering
+	if (
+		query.requestMethods &&
+		entry.request?.method &&
+		!query.requestMethods.includes(entry.request.method)
+	)
+		return false;
+	if (
+		query.requestStatusCodes &&
+		entry.request?.statusCode &&
+		!query.requestStatusCodes.includes(entry.request.statusCode)
+	)
+		return false;
+	if (
+		query.requestDurationMin &&
+		entry.request?.duration &&
+		entry.request.duration < query.requestDurationMin
+	)
+		return false;
+	if (
+		query.requestDurationMax &&
+		entry.request?.duration &&
+		entry.request.duration > query.requestDurationMax
+	)
+		return false;
+
+	return true;
+}