nginx-ui/internal/nginx_log/utils

Nginx Log Performance Utils

This package provides performance optimization utilities for the nginx-ui log processing system.

Overview

This package consolidates performance optimization code that was previously duplicated across indexer, parser, and searcher packages. The utilities focus on reducing memory allocations, improving concurrency, and providing efficient data structures.

Components

StringPool

• Provides efficient string reuse and interning to reduce memory allocations
• Thread-safe string interning with configurable limits
• Byte buffer pooling for temporary string operations

pool := utils.NewStringPool()
buf := pool.Get()           // Get a reusable byte buffer
str := pool.Intern("text")  // Intern strings to reduce duplicates
pool.Put(buf)              // Return buffer to pool

MemoryPool

• Multi-size buffer pooling for different allocation needs
• Automatic size selection based on requirements
• Prevents memory fragmentation and reduces GC pressure

pool := utils.NewMemoryPool()
buf := pool.Get(1024)  // Get buffer with at least 1024 bytes capacity
pool.Put(buf)          // Return buffer to appropriate pool

WorkerPool

• Optimized goroutine management with bounded concurrency
• Queue-based work distribution
• Graceful shutdown support

pool := utils.NewWorkerPool(10, 100) // 10 workers, 100 queue size
pool.Submit(func() { /* work */ })   // Submit work
pool.Close()                         // Shutdown gracefully

BatchProcessor

• Efficient batch collection and processing
• Thread-safe operations with configurable capacity
• Automatic batch reset after retrieval

bp := utils.NewBatchProcessor(100)
bp.Add(item)        // Add items to batch
batch := bp.GetBatch() // Get and reset batch

MemoryOptimizer

• Memory usage monitoring and GC optimization
• Configurable thresholds and intervals
• Detailed memory statistics

mo := utils.NewMemoryOptimizer(512 * 1024 * 1024) // 512MB threshold
mo.CheckMemoryUsage()  // Trigger GC if needed
stats := mo.GetMemoryStats() // Get memory statistics

PerformanceMetrics

• Thread-safe performance tracking
• Operation counting, timing, and error rates
• Cache hit/miss ratio tracking

pm := utils.NewPerformanceMetrics()
pm.RecordOperation(itemCount, duration, success)
pm.RecordCacheHit()
metrics := pm.GetMetrics() // Get performance snapshot

Unsafe Conversions

Zero-allocation string/byte conversions for performance-critical code:

• BytesToStringUnsafe([]byte) string
• StringToBytesUnsafe(string) []byte
• AppendInt([]byte, int) []byte

⚠️ Warning: These functions use unsafe operations and should be used carefully.

Testing

The package includes comprehensive tests covering:

• Basic functionality for all components
• Concurrent access patterns
• Performance benchmarks
• Edge cases and error conditions

Run tests with:

go test ./internal/nginx_log/utils/... -v

Run benchmarks with:

go test ./internal/nginx_log/utils/... -bench=.

Migration Notes

This package replaces the previous performance_optimizations.go files in:

• internal/nginx_log/indexer/performance_optimizations.go (removed)
• internal/nginx_log/parser/performance_optimizations.go (removed)
• internal/nginx_log/searcher/performance_optimizations.go (removed)

The consolidated implementation provides:

• Better code reuse and maintenance
• Consistent performance optimizations across packages
• Comprehensive test coverage
• Improved documentation

Usage Guidelines

1. Use StringPool for frequent string operations and temporary buffers
2. Use MemoryPool for variable-size buffer allocations
3. Use WorkerPool for CPU-bound tasks requiring concurrency control
4. Use BatchProcessor for collecting items before bulk operations
5. Use MemoryOptimizer in long-running processes to manage memory
6. Use PerformanceMetrics to track and monitor system performance
7. Use unsafe conversions sparingly and only in performance-critical sections