Performance Tests #4

Workflow file for this run

.github/workflows/performance.yml at 3f8e7be

	name: Performance Tests

	on:
	schedule:
	# Run weekly on Sundays at 2 AM UTC
	- cron: '0 2 * * 0'
	workflow_dispatch:
	inputs:
	dataset_size:
	description: 'Number of test bookmarks'
	required: false
	default: '1000'
	type: string

	env:
	CI: true
	NODE_ENV: test

	jobs:
	performance-tests:
	name: Performance Benchmarks
	runs-on: ubuntu-latest
	timeout-minutes: 30

	steps:
	- name: Checkout repository
	uses: actions/checkout@v4

	- name: Setup Node.js
	uses: actions/setup-node@v4
	with:
	node-version: 20.x
	cache: "npm"

	- name: Install dependencies
	run: npm ci

	- name: Setup performance test environment
	run: \|
	echo "Setting up performance test environment..."
	mkdir -p performance-results

	# Create performance test data
	node -e "
	const fs = require('fs');
	const datasetSize = parseInt('${{ github.event.inputs.dataset_size \|\| '1000' }}');
	console.log('Creating test dataset with', datasetSize, 'bookmarks...');

	const bookmarks = [];
	for (let i = 0; i < datasetSize; i++) {
	bookmarks.push({
	id: 'bookmark-' + i,
	title: 'Test Bookmark ' + i,
	url: 'https://example.com/page-' + i,
	description: 'Test description for bookmark number ' + i,
	tags: ['tag' + (i % 10), 'category' + (i % 5)],
	created: new Date(Date.now() - i * 60000).toISOString(),
	visited: i % 3 === 0,
	folder: 'folder-' + Math.floor(i / 100)
	});
	}

	fs.writeFileSync('performance-test-data.json', JSON.stringify(bookmarks, null, 2));
	console.log('Test dataset created with', bookmarks.length, 'bookmarks');
	"

	- name: Run search performance tests
	run: \|
	echo "Running search performance benchmarks..."
	node -e "
	const { performance } = require('perf_hooks');

	// Mock search implementation for performance testing
	function mockSearchIndex(bookmarks, query) {
	const start = performance.now();
	const results = bookmarks.filter(b =>
	b.title.toLowerCase().includes(query.toLowerCase()) \|\|
	b.description.toLowerCase().includes(query.toLowerCase()) \|\|
	b.tags.some(tag => tag.toLowerCase().includes(query.toLowerCase()))
	);
	const end = performance.now();
	return { results, duration: end - start };
	}

	const fs = require('fs');
	const bookmarks = JSON.parse(fs.readFileSync('performance-test-data.json', 'utf8'));
	const queries = ['test', 'bookmark', 'example', 'page', 'tag1', 'category2'];

	console.log('Search Performance Results:');
	console.log('==========================');

	const results = [];
	queries.forEach(query => {
	const { results: searchResults, duration } = mockSearchIndex(bookmarks, query);
	console.log('Query: \"' + query + '\"');
	console.log(' Results: ' + searchResults.length);
	console.log(' Duration: ' + duration.toFixed(2) + 'ms');
	console.log('');

	results.push({
	query,
	resultCount: searchResults.length,
	duration: duration,
	throughput: searchResults.length / (duration / 1000)
	});
	});

	// Check for performance regressions
	const avgDuration = results.reduce((sum, r) => sum + r.duration, 0) / results.length;
	console.log('Average search duration: ' + avgDuration.toFixed(2) + 'ms');

	const maxAcceptableDuration = 50; // 50ms max for search
	if (avgDuration > maxAcceptableDuration) {
	console.log('❌ Performance regression detected!');
	console.log('Average search duration (' + avgDuration.toFixed(2) + 'ms) exceeds threshold (' + maxAcceptableDuration + 'ms)');
	process.exit(1);
	} else {
	console.log('✅ Search performance within acceptable range');
	}

	// Save results for trending
	fs.writeFileSync('performance-results/search-results.json', JSON.stringify(results, null, 2));
	"

	- name: Run memory usage tests
	run: \|
	echo "Running memory usage benchmarks..."
	node -e "
	const fs = require('fs');
	const { performance } = require('perf_hooks');

	// Simulate bookmark storage and retrieval
	function measureMemoryUsage(bookmarks) {
	const initialMemory = process.memoryUsage();

	// Simulate operations
	const storage = new Map();
	bookmarks.forEach(bookmark => {
	storage.set(bookmark.id, bookmark);
	});

	// Force garbage collection if available
	if (global.gc) {
	global.gc();
	}

	const finalMemory = process.memoryUsage();

	return {
	heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
	heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
	external: finalMemory.external - initialMemory.external,
	arrayBuffers: finalMemory.arrayBuffers - initialMemory.arrayBuffers
	};
	}

	const bookmarks = JSON.parse(fs.readFileSync('performance-test-data.json', 'utf8'));
	const memoryUsage = measureMemoryUsage(bookmarks);

	console.log('Memory Usage Analysis:');
	console.log('=====================');
	console.log('Dataset size: ' + bookmarks.length + ' bookmarks');
	console.log('Heap used: ' + (memoryUsage.heapUsed / 1024 / 1024).toFixed(2) + ' MB');
	console.log('Heap total: ' + (memoryUsage.heapTotal / 1024 / 1024).toFixed(2) + ' MB');
	console.log('External: ' + (memoryUsage.external / 1024 / 1024).toFixed(2) + ' MB');
	console.log('Array buffers: ' + (memoryUsage.arrayBuffers / 1024 / 1024).toFixed(2) + ' MB');

	// Memory usage per bookmark
	const memoryPerBookmark = memoryUsage.heapUsed / bookmarks.length;
	console.log('Memory per bookmark: ' + memoryPerBookmark.toFixed(0) + ' bytes');

	// Check for memory issues
	const maxMemoryPerBookmark = 1024; // 1KB per bookmark max
	if (memoryPerBookmark > maxMemoryPerBookmark) {
	console.log('❌ High memory usage detected!');
	console.log('Memory per bookmark (' + memoryPerBookmark.toFixed(0) + ' bytes) exceeds threshold (' + maxMemoryPerBookmark + ' bytes)');
	process.exit(1);
	} else {
	console.log('✅ Memory usage within acceptable range');
	}

	fs.writeFileSync('performance-results/memory-results.json', JSON.stringify({
	datasetSize: bookmarks.length,
	memoryUsage,
	memoryPerBookmark,
	timestamp: new Date().toISOString()
	}, null, 2));
	"

	- name: Generate performance report
	run: \|
	echo "Generating performance report..."
	node -e "
	const fs = require('fs');

	const searchResults = JSON.parse(fs.readFileSync('performance-results/search-results.json', 'utf8'));
	const memoryResults = JSON.parse(fs.readFileSync('performance-results/memory-results.json', 'utf8'));

	const report = {
	timestamp: new Date().toISOString(),
	datasetSize: memoryResults.datasetSize,
	search: {
	averageDuration: searchResults.reduce((sum, r) => sum + r.duration, 0) / searchResults.length,
	maxDuration: Math.max(...searchResults.map(r => r.duration)),
	minDuration: Math.min(...searchResults.map(r => r.duration)),
	totalQueries: searchResults.length
	},
	memory: {
	heapUsedMB: memoryResults.memoryUsage.heapUsed / 1024 / 1024,
	memoryPerBookmarkBytes: memoryResults.memoryPerBookmark
	}
	};

	console.log('Performance Report Summary:');
	console.log('==========================');
	console.log(JSON.stringify(report, null, 2));

	fs.writeFileSync('performance-results/performance-report.json', JSON.stringify(report, null, 2));
	"

	- name: Upload performance results
	uses: actions/upload-artifact@v4
	with:
	name: performance-results-${{ github.run_id }}
	path: performance-results/
	retention-days: 90

	- name: Performance summary
	run: \|
	echo "## Performance Test Results" >> $GITHUB_STEP_SUMMARY
	echo "" >> $GITHUB_STEP_SUMMARY
	echo "### Test Configuration" >> $GITHUB_STEP_SUMMARY
	echo "- Dataset size: ${{ github.event.inputs.dataset_size \|\| '1000' }} bookmarks" >> $GITHUB_STEP_SUMMARY
	echo "- Test run: $(date)" >> $GITHUB_STEP_SUMMARY
	echo "" >> $GITHUB_STEP_SUMMARY
	echo "### Results" >> $GITHUB_STEP_SUMMARY
	echo "\`\`\`json" >> $GITHUB_STEP_SUMMARY
	cat performance-results/performance-report.json >> $GITHUB_STEP_SUMMARY
	echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
	echo "" >> $GITHUB_STEP_SUMMARY
	echo "### Benchmarks" >> $GITHUB_STEP_SUMMARY
	echo "- Search queries must complete within 50ms average" >> $GITHUB_STEP_SUMMARY
	echo "- Memory usage must not exceed 1KB per bookmark" >> $GITHUB_STEP_SUMMARY

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Performance Tests #4

Workflow file

Performance Tests #4

Uh oh!

Workflow file for this run