🚀 Smart Log Highlighter
See It in Action
For any file VS Code opens as text: application logs, source code, configuration, test output, and plain text. Use reusable regex filters to highlight matching lines, focus the view, bookmark findings, and share filter settings.
These real VS Code demos use sample data to illustrate the tools; they do not limit which text formats you can work with. The short demos loop automatically; each has a still-image alternative.
Highlight Source Code, Not Just Logs
This example uses a Java source file, one internal project for declaration patterns, and an external project for review notes. The same line-based workflow works with other languages and text files. It does not parse or extract entire class/function bodies. View still image.
Highlight Text and Logs
Add regex filters in Filters+, then use the paint-can icon to toggle highlighting. Each filter keeps its own color and match count. View still image.
Bookmark Important Lines
Right-click a log line and choose Bookmark Log Line.... Add a note, then use Change Bookmark Color... in Bookmarks to choose a color. Hover over the marked line's text to read the note. View still image.
Filter by Time or Cycle
Run Time / Cycle Range..., choose a profile matching your timestamps or counters, enter inclusive bounds, and confirm the parsed preview. The demo keeps counts 65689-65691; the same wizard also supports elapsed simulation time and wall-clock profiles. View still image.
Focus on Matching Lines
Enable filter visibility, then run Turn on Focus Mode or press Ctrl+H (Cmd+H on macOS). Matching lines retain their colors and bookmarks; filtered lines link back to the original log. View still image.
Run Smart Log Highlighter: Performance Settings from the Command Palette, or use the lightning icon in Projects. Choose Active Only to work on the current text file. Visible Only processes visible split editors; Adaptive limits the number of visible editors processed; Relevant Only restricts processing to configured file extensions. Add source-file extensions such as .java in VS Code settings when using Relevant Only. Percentages in the existing picker are illustrative, not a speed guarantee for your files.
Save Internal and External Projects
Projects are saved filter configurations, not copies of your source files. Saving filters never rewrites the Java file, log, or other text you are analyzing. View destination choices.
- Internal storage: use Internal in Storage Files for local extension-owned configurations. Its row and tooltip show the exact storage path; Copy Settings File Path copies it. Create groups and filters in that source, run Save Project Settings, and select Internal Settings. Internal save screenshot.
- External storage: use Create Empty Settings File in Storage Files to create a JSON destination, or Load Shared Filter File to open existing JSON files. Choose the external file when adding a group/project, or use Add Filter to Another File... for a filter. Save Project Settings then lists that file by name and full path. External save screenshot.
- Choose what to save: Filters, Exclusions and Settings, Filters Only, Exclusion Filters Only, or Settings Only. A file-row save button preselects that destination. Only that source's content is written; this does not copy another source's filters into it.
- Share the external JSON with teammates. Load it on another machine and use Apply Settings from This File when you also want its editor/performance preferences. Profile paths may need adapting on another machine.
- Save All Changed Filters saves dirty filter/exclusion data back to each original file, without replacing global settings. Unsaved files show
*; unload/reload offers save, discard, or cancel. The X unloads an external file without deleting it.
Both internal and loaded external configurations are remembered across restarts. You can keep several files loaded and switch the selected project independently inside each source.
What's New in v1.6.1
- Clear general-purpose text/source-code guidance, including tested Java declaration patterns and their limitations.
- New real Java and internal/external-save GIFs, plus performance and save-dialog screenshots.
- Generic documentation examples instead of domain-specific product positioning. Extension behavior is unchanged from v1.6.0.
Features Included Since v1.6.0
- Time/cycle ranges for numeric counters, elapsed time, and wall-clock logs, with parsed previews and exact simulation counts.
- Colored bookmarks, note hovers, context lines, selection filters, and focused-result export.
- Multi-file settings with visible sources, selective saves, Save All, filter search, and undo/redo.
- Cancellable worker processing, live regex previews, and 63 regression tests.
See CHANGELOG.md for full release notes.
Highlight, filter, and investigate text files with reusable, shareable patterns.
Use the same workflow for application logs, Java or other source files, configuration files, build output, and plain text. Editor-selection strategies let you control which open documents are processed. Performance depends on file size, regex complexity, and the number of editors; this is not a streaming viewer for arbitrarily large files.
Work with Any Text File
Open a .java, .js, .ts, .py, .c, .cpp, .json, .xml, .yaml, .txt, .log, or another file in VS Code's text editor. Choose Performance Settings > Active Only for the current document, or Visible Only for visible split editors. Relevant Only restricts processing to configured extensions (log-oriented by default); add .java or other extensions under logAnalysisGamma.relevantFileExtensions when using that strategy.
- Add a group in Filters+, then add a regex pattern or right-click selected text and choose Highlight This Text.
- Use the paint-can control for highlighting and the eye control to include matching lines in Focus Mode. Exclusion filters remove unwanted matches.
- Open Focus Mode to scan matching lines, add context if needed, and navigate back to the original file. The original text is never rewritten by filtering.
Java Classes and Methods
Example patterns for conventional single-line Java declarations:
Classes, interfaces, enums, and records:
\b(class|interface|enum|record)\s+[A-Za-z_$][\w$]*
Public methods with a return type:
^\s*public\s+(?:static\s+)?[\w<>\[\], ?]+\s+[A-Za-z_$][\w$]*\s*\([^;]*\)\s*(?:throws\s+[\w., ]+)?\s*\{
Annotations:
^\s*@[A-Za-z_$][\w$.]*
TODO and FIXME notes:
\b(TODO|FIXME)\b
These are text patterns, not Java syntax analysis: they can match comments or strings, miss multiline declarations or constructors, and do not extract entire class/method bodies. Add context lines for nearby code or use VS Code's language Outline for semantic navigation. Other languages work the same way with patterns appropriate to their text. Binary files, images, and rendered PDF content are not supported as text input. Time-range filtering is optional and only useful when the file contains a timestamp or counter.
🎥 Visual Interface Overview
📁 Main Extension Interface
┌─ Smart Log Highlighter (Activity Bar) ──────────────────┐
│ │
│ 📂 Projects │
│ ├─ 📄 Production Logs ✓ (Selected) │
│ ├─ 📄 Debug Session │
│ └─ 📄 NEWYORK Project │
│ │
│ 🎯 Filters+ │
│ ├─ 🗂️ Critical Issues │
│ │ ├─ 🔴 FATAL.* (15 matches) │
│ │ └─ 🟠 ERROR.* (8 matches) │
│ └─ 🗂️ Application Logs │
│ ├─ 🔵 INFO.* (245 matches) │
│ └─ 🟡 WARN.* (32 matches) │
│ │
│ ❌ EXCLUDE_FILTER │
│ ├─ 🚫 DEBUG.*verbose (Hidden: 1,247 lines) │
│ └─ 🚫 .*noise.* (Hidden: 823 lines) │
│ │
└─────────────────────────────────────────────────────────┘
┌─ Performance Strategy Selection ────────────────────────┐
│ │
│ 🚀 Active Only │
│ Maximum Performance (90% improvement) │
│ ► Best for: Large projects (10+ files) │
│ │
│ 👁️ Visible Only │
│ Balanced Performance (30-50% improvement) │
│ ► Best for: Split workflows (2-4 panes) │
│ │
│ 📄 Relevant Only │
│ Smart Selection (70% improvement) │
│ ► Best for: Mixed projects (code + logs) │
│ │
│ 💡 Adaptive (Default) │
│ Intelligent (60% improvement) │
│ ► Best for: Variable workflows │
│ │
│ 🔧 Configure File Types │
│ ⚙️ Open Full Settings │
│ │
└─────────────────────────────────────────────────────────┘
🔧 File Type Configuration
┌─ Relevant File Extensions ──────────────────────────────┐
│ │
│ Primary Log Files │
│ ☑️ .log Standard application logs │
│ ☑️ .txt Text-based log files │
│ ☑️ .out Output/stdout files │
│ ☑️ .err Error/stderr files │
│ ☑️ .trace Stack trace files │
│ │
│ Log Levels │
│ ☐ .debug Debug level logs │
│ ☐ .info Info level logs │
│ ☐ .warn Warning level logs │
│ ☐ .error Error level logs │
│ ☐ .fatal Fatal error logs │
│ │
│ Specialized Logs │
│ ☐ .access Web server access logs │
│ ☐ .audit Security audit logs │
│ ☐ .perf Performance metrics │
│ │
│ System Logs │
│ ☐ .console Console output │
│ ☐ .crash Crash report files │
│ │
└─────────────────────────────────────────────────────────┘
🎯 Focus Mode Demo
Before Focus Mode:
app.log (Original Document)
─────────────────────────────────────────────────────────
2024-11-07 10:30:10 [DEBUG] Connecting to database...
2024-11-07 10:30:12 [INFO] Connection established
2024-11-07 10:30:15 [ERROR] Failed to authenticate user ← Important
2024-11-07 10:30:17 [DEBUG] Retrying authentication...
2024-11-07 10:30:20 [FATAL] Database connection lost! ← Critical
2024-11-07 10:30:22 [TRACE] Stack trace: line 245...
2024-11-07 10:30:25 [ERROR] Unable to process request ← Important
2024-11-07 10:30:27 [DEBUG] Processing queue: 15 items
2024-11-07 10:30:30 [CRIT] System overload detected ← Critical
After Focus Mode (Filtered View):
app.log (Focus Mode - Click lines to jump to source)
─────────────────────────────────────────────────────────
2024-11-07 10:30:15 [ERROR] Failed to authenticate user ← Click
2024-11-07 10:30:20 [FATAL] Database connection lost! ← Click
2024-11-07 10:30:25 [ERROR] Unable to process request ← Click
2024-11-07 10:30:30 [CRIT] System overload detected ← Click
🎯 Only matching lines shown
🔗 Click any line to jump to original location
⚡ Real-time updates when filters change
📊 From 9 lines → 4 critical issues (56% noise reduction)
🎨 Color Management System
Enhanced Color Picker Interface:
┌─ Filter Color Selection ────────────────────────────────┐
│ │
│ Predefined Colors: │
│ 🔴 Red 🟠 Orange 🟡 Yellow 🟢 Green │
│ 🔵 Blue 🟣 Purple 🟤 Brown ⚫ Black │
│ │
│ Smart Options: │
│ 🎲 Smart Random Color │
│ 🎰 Truly Random Color │
│ │
│ Recently Used: │
│ 🎨 #ff5733 ❌ 🎨 #33ff57 ❌ │
│ 🎨 #3357ff ❌ 🎨 #ff3399 ❌ │
│ │
│ ✏️ Custom Color (Enter hex: #________) │
│ │
└─────────────────────────────────────────────────────────┘
CPU Usage Comparison:
Before v1.5.1 (All editors processed):
████████████████████████████████████████ 100%
After v1.5.1 with Active Only:
████ 10% (-90% improvement!)
After v1.5.1 with Relevant Only:
████████████ 30% (-70% improvement!)
After v1.5.1 with Visible Only:
████████████████████ 50% (-50% improvement!)
After v1.5.1 with Adaptive:
████████████████ 40% (-60% improvement!)
Memory Usage Impact (Large Project - 20 open files):
Before: [████████████████████████████████████████] High Memory
After: [████████] Minimal Memory (Active Only)
[████████████] Low Memory (Relevant Only)
[████████████████] Medium Memory (Visible Only)
[██████████████] Low-Medium Memory (Adaptive)
🤝 Team Collaboration Workflow
Step 1: Create Unified Settings
1. Configure your filters and performance settings
2. Click "Save Unified Settings" in Projects view
3. Choose location: /team-shared/log-analysis-config.json
Step 2: Share Configuration File
{
"editorSelectionStrategy": "relevant",
"relevantFileExtensions": [".log", ".txt", ".err"],
"maxEditorsToProcess": 3,
"projects": [
{
"name": "Production Monitoring",
"groups": [
{
"name": "Critical Issues",
"filters": [
{
"pattern": "FATAL|CRITICAL|ERROR",
"color": "#dc143c"
}
]
}
]
}
]
}
Step 3: Team Members Load
1. Receive shared file from teammate
2. Click "Load Unified Settings" in Projects view
3. Select the shared JSON file
4. ✅ Identical configuration loaded instantly!
5. 🎯 Everyone has the same filters and performance settings
🚀 Previous Updates - v1.5.6
💾 Improved Save Workflow
- ✅ Save prompt always shown — clicking Save now always presents a QuickPick with options:
- Save to Current Shared File (when a shared file is loaded)
- Save to External Project File (create new shareable JSON)
- Save to Internal Project (VS Code extension storage)
- ✅ No more silent saves — users always see where settings are being saved
🔄 Unified Refresh
- ✅ Refresh reloads the active settings source: the loaded shared file, or internal settings when no shared file is loaded
- ✅ No warning when no shared file is loaded — internal settings still refresh
- ✅ Clear feedback message showing what was refreshed
🏷️ Updated Command Titles
- ✅ "Save Project Settings" — reflects the new multi-target save behavior
- ✅ "Refresh Project Settings" — reflects the unified refresh behavior
🚀 Previous Updates - v1.5.3
🎯 Enhanced Professional Branding
- ✅ Rebranded to "Smart Log Highlighter" - Unique, distinct extension name
- ✅ Enhanced marketplace description - Emphasizes advanced capabilities and enterprise features
- ✅ Continued version progression - Seamless update for existing users
- ✅ Maintained marketplace presence - All existing ratings, downloads, and user base preserved
🔧 All v1.5.x Features Included
- ✅ Configurable file types for "Relevant Only" strategy with 90% performance boost
- ✅ Professional VS Code interface with native icons throughout
- ✅ Unified project settings for seamless team collaboration
- ✅ 4 smart processing strategies (Active/Visible/Relevant/Adaptive)
- ✅ Complete visual documentation with ASCII art interface representations
🚀 Previous Updates - v1.5.1 & v1.5.2
🚀 Previous Updates - v1.5.1 & v1.5.2
- ✅ Customizable file extensions for "Relevant Only" strategy
- ✅ Visual configuration interface with 20+ predefined log file types
- ✅ Real-time updates - changes apply immediately without restart
- ✅ Enhanced user guidance with detailed strategy descriptions
📖 Professional Interface Improvements (v1.5.1)
- ✅ VS Code native icons throughout (removed emojis for professional look)
- ✅ Comprehensive strategy guidance - know exactly when to use each option
- ✅ Detailed tooltips for informed decision-making
- ✅ Organized file type categories - Primary, Log Levels, Specialized, System
📸 Complete Visual Documentation (v1.5.2)
- ✅ ASCII art interface representations - No external image dependencies
- ✅ Performance charts and metrics embedded directly in README
- ✅ Team collaboration workflow demonstrations with JSON examples
- ✅ Focus mode before/after comparisons showing noise reduction
- ✅ Marketplace-optimized presentation for immediate feature discovery
Large Project Performance Test Results:
┌─────────────────────┬──────────────┬──────────────┐
│ Strategy │ CPU Usage │ Memory Usage │
├─────────────────────┼──────────────┼──────────────┤
│ All Editors (Old) │ 100% │ High │
│ Active Only │ 10% (-90%) │ Minimal │
│ Visible Only │ 50% (-50%) │ Medium │
│ Relevant Only │ 30% (-70%) │ Low │
│ Adaptive (Smart) │ 40% (-60%) │ Low-Medium │
└─────────────────────┴──────────────┴──────────────┘
🚀 What's New in v1.5.0 - MAJOR RELEASE
🎯 Unified Project Settings System
- 🤝 Team collaboration ready - share complete configurations in one file
- 📁 Single JSON format combining projects + settings
- 🔄 Import functionality to migrate existing projects
- ⚡ Backward compatible - existing projects work seamlessly
4 Smart Processing Strategies:
🚀 ACTIVE ONLY → Process only active editor
Best for: Large projects (10+ open files)
Performance: 90% improvement
👁️ VISIBLE ONLY → Process split-view editors
Best for: Multi-pane workflows (2-4 panes)
Performance: 50% improvement
📄 RELEVANT ONLY → Smart log file detection
Best for: Mixed projects (code + logs)
Performance: 70% improvement
💡 ADAPTIVE → Intelligent adjustment
Best for: Variable workflows (Recommended)
Performance: 60% improvement
📱 Key Features Overview
✨ Smart Filtering System
🎯 Regex-based filters with real-time match counting
🎨 15+ predefined colors + custom hex color support
🗂️ Organized filter groups for logical categorization
👁️ Show/hide toggle for each filter and group
🎲 Smart random color generation with memory
❌ Exclusion filters to remove noise from results
🔍 Advanced Focus Mode
📄 Virtual read-only document with filtered results
🔗 Click any line to jump to original location
⚡ Real-time updates when filters change
🧹 Clean interface without visual distractions
📊 Noise reduction metrics (e.g., "56% noise removed")
⚡ 4 processing strategies with visual impact preview
🔧 Configurable file type filtering (20+ extensions)
📊 Real-time performance metrics display
🎯 Auto-detection of log files for smart processing
⚙️ Adjustable max editors to process (1-10)
🤝 Team Collaboration
📁 Unified JSON configuration format
📤 Export complete settings (filters + performance)
📥 Import team configurations instantly
🔄 Merge capabilities for collaborative development
📋 Version control ready (Git-friendly JSON)
🏃 Quick Start Guide
1. Basic Usage (Individual Developer)
1️⃣ Open Smart Log Highlighter from Activity Bar
2️⃣ Create a new project or use default "NONAME"
3️⃣ Add filter group (e.g., "Errors")
4️⃣ Add regex filter (e.g., "ERROR|FATAL")
5️⃣ Choose color from visual picker
6️⃣ Press Ctrl+H (Cmd+H on Mac) for Focus Mode
7️⃣ Click filtered lines to jump to original location
2. Team Setup (Collaborative Development)
Team Lead:
1️⃣ Configure filters and performance settings
2️⃣ Click "Save Unified Settings" → save as team-config.json
3️⃣ Share file with team (email, Slack, Git repo)
Team Members:
1️⃣ Click "Load Unified Settings" in Projects view
2️⃣ Select received team-config.json file
3️⃣ ✅ Identical configuration loaded instantly!
1️⃣ Click "Performance Settings" (⚡ icon) in Projects view
2️⃣ Choose strategy based on your workflow:
• Large projects (10+ files) → Active Only
• Split-screen work → Visible Only
• Mixed code/logs → Relevant Only
• Variable workflow → Adaptive (recommended)
3️⃣ Configure file types if using "Relevant Only"
4️⃣ ✅ Enjoy up to 90% performance improvement!
📋 Extension Interface Breakdown
Projects View (Top Priority)
📂 Projects
├─ 📄 Production Logs ✓ (Currently Selected)
├─ 📄 Development Debug
├─ 📄 QA Testing
└─ 📄 Performance Analysis
Action Buttons:
📂 Load Unified Settings 💾 Save Unified Settings
🔄 Refresh Settings ⚡ Performance Settings
Filters+ View (Main Filtering)
🎯 Filters+
├─ 🗂️ Critical Issues [👁️ 🎨 ❌]
│ ├─ 🔴 FATAL.* (15 matches) [👁️ 🎨 ✏️ ❌]
│ ├─ 🟠 CRITICAL.* (8 matches) [👁️ 🎨 ✏️ ❌]
│ └─ 🔶 EMERGENCY.* (2 matches) [👁️ 🎨 ✏️ ❌]
│
├─ 🗂️ Application Logs [👁️ 🎨 ❌]
│ ├─ 🔵 INFO.* (245 matches) [👁️ 🎨 ✏️ ❌]
│ ├─ 🟡 WARN.* (32 matches) [👁️ 🎨 ✏️ ❌]
│ └─ 🟢 SUCCESS.* (18 matches) [👁️ 🎨 ✏️ ❌]
│
└─ 🗂️ Performance [👁️ 🎨 ❌]
├─ 📊 PERF.* (67 matches) [👁️ 🎨 ✏️ ❌]
└─ ⏱️ TIMING.* (12 matches) [👁️ 🎨 ✏️ ❌]
Icons: 👁️=Show/Hide 🎨=Color ✏️=Edit ❌=Delete
EXCLUDE_FILTER View (Noise Reduction)
❌ EXCLUDE_FILTER
├─ 🚫 DEBUG.*verbose (Hidden: 1,247 lines) [👁️ ✏️ ❌]
├─ 🚫 .*noise.* (Hidden: 823 lines) [👁️ ✏️ ❌]
├─ 🚫 TRACE.*internal (Hidden: 445 lines) [👁️ ✏️ ❌]
└─ 🚫 .*temporary.* (Hidden: 156 lines) [👁️ ✏️ ❌]
Total Noise Reduced: 2,671 lines (78% of original content)
🎯 Use Cases & Scenarios
🔍 Debugging Production Issues
Scenario: Finding critical errors in 50MB log file
Solution:
1. Load "Production" project configuration
2. Use "Relevant Only" + .log/.err extensions
3. Focus on "Critical Issues" filter group
4. 90% performance boost + only critical lines shown
Result: From 2M lines → 47 critical issues in seconds
👥 Team Onboarding
Scenario: New developer needs same log analysis setup
Solution:
1. Senior dev shares team-config.json file
2. New dev clicks "Load Unified Settings"
3. Identical filters, colors, performance settings loaded
Result: Zero configuration time, instant productivity
Scenario: Analyzing performance logs across multiple files
Solution:
1. Configure .perf, .timing, .metrics extensions
2. Create "Performance" filter groups
3. Use "Adaptive" strategy for optimal processing
4. Focus mode shows only performance-related entries
Result: Clear performance insights without noise
🏆 Why Choose Smart Log Highlighter?
📊 Up to 90% CPU improvement over standard log analysis
⚡ Smart processing strategies adapt to your workflow
🎯 Configurable file types for precise optimization
📈 Measurable performance metrics in real-time
✅ Team Collaboration
🤝 One-file configuration sharing (JSON format)
🔄 Git-friendly version control support
📋 Import/export existing projects seamlessly
👥 Identical setup across entire team in seconds
✅ Professional Interface
🎨 VS Code native icons throughout
📱 Clean, distraction-free design
🎯 Intuitive workflow with logical grouping
⚙️ Visual configuration without JSON editing
✅ Advanced Features
🔍 Regex-based filtering with real-time match counts
🎨 15+ colors + custom hex + smart random generation
👁️ Focus mode with clickable navigation
❌ Exclusion filters for noise reduction
📊 Performance impact visualization
🛠️ Technical Specifications
📋 Requirements
- VS Code version 1.49.0 or higher
- No additional dependencies required
- Works with files up to 50MB (use vsc-lfs extension for larger files)
🔧 Supported File Types
Primary: .log, .txt, .out, .err, .trace
Levels: .debug, .info, .warn, .error, .fatal
System: .console, .crash, .syslog, .dmesg
Web: .access, .nginx, .apache, .iis
Custom: Configure your own extensions!
- Selective editor processing (not all open files)
- Smart log file detection and prioritization
- Configurable processing limits (1-10 editors max)
- Real-time performance monitoring
- Memory-efficient virtual document rendering
📞 Support & Contributing
This extension is a fork of the original Log Analysis project, created to introduce and test new features. We encourage feedback and contributions to help improve the extension.
🔗 Links
- 📧 Report issues on GitHub
- 💡 Suggest features via GitHub Issues
- 🤝 Contributing guidelines available
- 📚 Full documentation in repository
🏷️ Keywords
log analysis • debugging • filtering • regex • highlight • focus mode • team collaboration • performance • monitoring • log viewer
🎉 Ready to transform your log analysis workflow? Install Smart Log Highlighter and experience the difference!
🚀 Previous Updates - Gamma v1.5.1
- Customizable file extensions for "Relevant Only" strategy - now you control which files get processed!
- Visual configuration interface with 18+ predefined log file types organized in categories
- Real-time updates - changes apply immediately without restart
- Enhanced user guidance - detailed descriptions help you choose the optimal performance strategy
📖 Enhanced User Experience with Professional Interface
- Comprehensive strategy guidance - know exactly when to use each performance option
- VS Code native icons throughout (no more emojis) for consistent, professional appearance
- Detailed tooltips and descriptions for informed decision-making
- Organized file type categories - Primary, Log Levels, Specialized, and System logs
See comprehensive screenshots and examples of all features including performance settings, file type configuration, and team collaboration workflows.
🚀 What's New in Gamma v1.5.0 - MAJOR RELEASE
🎯 Unified Project Settings System
- Revolutionary single JSON format combining internal projects + external shareable settings
- Team collaboration ready - share complete configurations in one file with teammates
- Import functionality to migrate existing internal projects to external format
- Merge capabilities for collaborative development environments
- Backward compatible - existing projects work seamlessly
- Selective editor processing - no more processing ALL open editors
- Smart editor selection strategies:
- Active: Maximum performance (process only active editor) - 90% improvement
- Visible: Balanced performance (process visible split-view editors) - 50% improvement
- Relevant: Smart detection (auto-detect and prioritize log files) - 70% improvement
- Adaptive: Intelligent adjustment (adapts based on number of open editors) - 60% improvement
- Configurable max editors to process simultaneously (1-10 editors)
- Auto log file detection (.log, .txt, .out, .err, .trace files prioritized)
🎨 Enhanced UI/UX Organization
- Projects view moved to top for better workflow (Projects → Filters+ → EXCLUDE_FILTER)
- Performance Settings moved to Projects view with ⚡ lightning icon (was confusing gear)
- Renamed "Filters-" to "EXCLUDE_FILTER" for better clarity
- Simplified unified commands - no more confusion between project systems
- Clean interface with logical grouping and improved navigation
🔧 New Unified Commands
Load Unified Settings - Load complete configuration from external JSON fileSave Unified Settings - Save everything to unified format (with internal fallback option)Refresh Unified Settings - Reload from external filePerformance Settings - Quick access to performance configuration with visual optionsImport Internal Projects - Migrate existing projects to shareable external format
Previous Updates - Gamma v1.4.0 to v1.4.4
🎲 Complete Color Management System
- Random Color Generator - Smart random colors from curated palette or truly random mathematical generation
- Color Memory System - Automatically remembers up to 10 recently used custom colors
- Individual Color Removal - Remove specific colors with ❌ buttons without clearing entire history
- Smart UI Refresh - Color picker automatically updates after changes
- Custom Hex Input - Enter any hex color with real-time validation
🗑️ Advanced Color Management
- CRUD Operations - Full Create, Read, Update, Delete for color memory
- Visual Feedback - Clear confirmation messages for all actions
- Auto-Persistence - Colors saved globally across all workspaces
- Configurable Settings - Control max remembered colors (5-20) and notifications
🎨 Interactive Color Picker
- 15 emoji-themed color options for better visual organization
- Quick color selection with intuitive emoji color combinations
- Instant color preview when changing filter colors
🔗 Enhanced Focus Mode
- Clean interface - removed underlines from clickable links while maintaining full functionality
- Seamless navigation - click any filtered line to jump to the original location
- Improved readability - focus on content without visual distractions
🔄 Real-time Updates
- Automatic refresh - focus mode updates instantly when filters change
- Better synchronization - no more manual refresh needed when adding/editing filters
- Improved performance - optimized decoration handling
🎯 Enhanced Project Navigation
- Activity bar integration - all views moved to dedicated Smart Log Highlighter activity bar
- Improved project switching - seamless navigation between different log analysis setups
- Better organization - cleaner interface with logical grouping
Features
- Create filters using regular expressions provided by the user
- Highlight lines that match the filters with customizable colors using interactive color picker
- 15 emoji-themed color options for better visual organization and quick identification
- Focus mode: display only lines that match your filters, hiding everything else for better readability
- Clean focus mode interface - clickable links without underlines for improved readability
- Exclude meaningless filters from the filtered content in Focus mode for more accurate log analysis
- Organize filters into groups based on their purpose and apply changes to the entire group collectively
- Real-time updates - focus mode refreshes automatically when filters change
- Manage filters on a per-project basis to accommodate different log formats across various devices and frameworks
- Click a filtered line in focus mode to jump directly to its corresponding location in the original document
- Enhanced project navigation with dedicated activity bar integration
- 🎯 Unified Project Settings - Single JSON format combining internal projects with external shareable configurations
- ⚡ Revolutionary Performance - Up to 90% improvement with selective editor processing and smart strategies
- 🤝 Team Collaboration - Import/export functionality for sharing complete filter configurations
- 🎛️ Performance Control - Visual interface for selecting optimal editor processing strategy
- 📁 Enhanced UI Organization - Improved view structure with Projects at top, logical grouping
🎯 Unified Project Settings System
What's New in v1.5.0
The unified project settings system revolutionizes how you manage and share log analysis configurations. No more confusion between internal and external project systems - everything is now unified into a single, powerful JSON format.
Key Benefits:
🤝 Team Collaboration Made Easy
- Single file sharing - Send one JSON file containing complete team configuration
- Import existing projects - Migrate your internal projects to shareable external format
- Merge capabilities - Combine configurations from multiple team members
- Version control ready - JSON files work perfectly with Git and other VCS
- Up to 90% performance improvement with selective editor processing
- Smart strategies automatically choose optimal processing approach:
- Active: Process only active editor (maximum performance)
- Visible: Process split-view editors (balanced performance)
- Relevant: Auto-detect log files (smart performance)
- Adaptive: Intelligent adjustment based on open editors (recommended)
Your project settings now contain everything in one place:
{
"editorSelectionStrategy": "adaptive",
"maxEditorsToProcess": 3,
"projects": [
{
"name": "Production Monitoring",
"groups": [
{
"name": "Error Analysis",
"filters": [...]
}
]
}
],
"filters": [...],
"exclusionFilters": [...]
}
Saving and Restoring Filters
- Save Project Settings preserves regex patterns, regex flags, highlight/visibility toggles, the selected project, and exclusion filters. Exclusion-only projects can also be saved internally.
- Restarting VS Code restores internal storage and all remembered external files. Refresh Project Settings reloads these files, with a save/discard/cancel prompt for unsaved filter changes.
- Saved filters use
regex (plain pattern text), flags, color, isHighlighted, and isShown. Runtime icons and match counts are rebuilt on load. Older files using pattern and enabled are still accepted.
- Files affected by earlier save bugs may contain
"regex": {} or exclusions with no pattern. Those patterns are already lost: restore a backup or re-enter them. Invalid files report an error instead of silently creating unusable filters.
Storage Files and Multiple Sources
- Project file paths are hidden beside project names by default. Use the eye button in the Projects toolbar to Show Project File Paths or Hide Project File Paths. The preference is remembered, and full paths remain available on hover. The Storage Files view continues to show full paths.
- The Storage Files view lists the exact internal storage path and every loaded external file. Full paths appear beside each entry and in its tooltip; use Copy Settings File Path from the context menu to copy one.
- Load Shared Filter File accepts multiple JSON files. Each file's selected project contributes groups to Filters+, and exclusions from all loaded files participate in Focus Mode. Switching projects affects only that file. Projects and filter tooltips identify their source path.
- Use the X beside an external file to unload only that file. It does not delete the file. Unsaved filter changes offer Save and Unload, Discard and Unload, or Cancel; a failed save keeps the file loaded. Internal storage remains available.
- Add Filter uses its group's source file automatically. Use the group's Add Filter to Another File... context action to choose a different source; it uses a matching group name there, creating the group if needed. New groups, exclusions, and projects ask for a destination only when more than one file is available. Changes stay in memory until saved; an asterisk marks unsaved filter changes.
- Save Project Settings first asks for a destination, showing each full path, then offers Filters, Exclusions and Settings, Filters Only, Exclusion Filters Only, or Settings Only. A row's save button selects that row as the destination. Only content belonging to that file is saved; other loaded files and unselected sections are unchanged.
- Create Empty Settings File creates and loads a new destination without overwriting an existing file. Load or create a destination before assigning new filters to it.
- Loading external filters does not change global VS Code settings. Use Apply Settings from This File in the file's context menu to select its settings explicitly. The chosen settings source is remembered for restart. Saved settings include the editor strategy/limits, log detection, relevant file extensions, color memory, and notification preferences.
- Missing or invalid remembered files remain visible with a warning and can be reloaded or unloaded. Failed loads leave working filters untouched.
Productivity Controls
- Save All Changed Filters in Storage Files saves changed regular filters and exclusions to their original files in one action. It preserves each file's settings and skips unchanged files. Failed files remain dirty and can be retried; the result reports both successes and failures.
- Search Filters... in either filter toolbar searches group names, regex text, and source paths across the currently active groups and exclusions. Clear Filter Search restores all rows. Search only changes the sidebar, not highlighting or Focus Mode behavior.
- Filter creation and regex editing show a live regex preview with a matching-line count and up to three sample lines from the active document. Preview scans the first 10,000 lines or 1,000,000 characters, whichever limit comes first, and labels partial scans. Invalid or timed-out previews cannot be accepted. Without an active document it checks syntax only; editing preserves regex flags. The worker has a 500ms deadline and is canceled when input changes or closes.
- Undo Filter Change and Redo Filter Change in the filter toolbars restore additions, deletions, regex edits, colors, highlight/visibility toggles, and group/project edits. History retains 30 changes for the current session. Undo does not write files: save afterward to persist it. Saving retains history; a successful file load/reload or unload clears it to avoid restoring stale sources. These commands do not replace the text editor's Undo/Redo shortcuts.
- Projects groups entries under compact source-file rows, with project counts, unsaved markers, and warnings. File and project tooltips retain full paths; the existing Show/Hide Paths toggle still controls visible paths. Source-row context actions open, copy the path, or unload the file.
- Context Lines... adds 0-100 lines before and after Focus Mode matches (default zero). Overlapping windows are merged in source order. Exclusions and an active time range also apply to context, and links retain the original line numbers.
- Select text on one line and use Highlight This Text or Exclude This Text in the editor context menu. These escape regex metacharacters by default. Regex Filter from Selection... is the explicit regex option. Creation follows source-file selection and supports undo.
- Export Focused Results... and Copy Focused Results... export a fresh result, with optional one-based original line numbers. The synthetic Focus Mode header is omitted; file export refuses the source log as its destination.
- Bookmark Log Line... stores an optional note in workspace storage. The Bookmarks view supports opening, editing notes, removal, and previous/next navigation within the current log. Focus Mode bookmarks reference the original file. If a log moves lines, opening a bookmark searches for a unique text match; changed, missing, or ambiguous anchors show a warning. Bookmarks are not part of shared filter files and cannot reliably track externally rewritten logs with duplicate lines.
- Bookmarks display a blue bookmark glyph beside the line number by default, including bookmarks saved before color support. Use the color button beside a bookmark in Bookmarks, or Change Bookmark Color... from its context menu/Command Palette, to choose a swatch or custom hex color. Colors are saved per bookmark and shown in both the sidebar and editor gutter. Editing the note keeps the chosen color. Markers also appear on matching Focus Mode lines and disappear when the bookmark is removed or its source location cannot be verified.
- Hover over the bookmarked line's text to see its note and original line number. VS Code's stable extension API does not provide a separate hover message for the gutter glyph itself. Notes are displayed as untrusted plain text, not executable Markdown links. If gutter markers are hidden, enable the VS Code Editor: Glyph Margin setting.
- Pause / Resume Log Processing and Cancel Active Log Processing are available in the Command Palette, Filters+ menu, and processing status bar. Pause clears highlights and stops new work until resumed. Cancellation may leave the last completed focus view visible. Focus filtering, timestamp extraction, and highlight cache misses run in workers with a configurable deadline (10 seconds by default); superseded jobs are canceled and stale document results are discarded. At most four worker jobs run concurrently. This still reads the document into memory; it is not a streaming viewer for arbitrarily large files.
Time and Cycle Profiles
Use Time / Cycle Range... from the editor context menu or Command Palette with the source log active. Profiles are scoped to the original document URI, so unrelated logs can use different clocks. The wizard previews up to the first 5,000 lines or 1,000,000 characters before Apply. Full processing uses the complete document. Time / Cycle Summary reports first/last/minimum/maximum parsed values, invalid and untimestamped lines, sample conversions, and backward jumps. The status bar shows the active range; Clear Time / Cycle Range removes it for that document.
For a text file with a numeric counter:
[Worker] |(cycle:65689)| INFO Processing item 42
- Choose the Cycle Count profile in Time / Cycle Range....
- Keep the capture pattern
\(\s*cycle\s*:\s*(\d+)\s*\).
- Enter inclusive cycle bounds, for example
65000 through 66000.
- Choose whether untimestamped continuation lines inherit the preceding timestamp or are excluded.
- Confirm the preview showing
65689 cycles, then turn on Focus Mode. A time range can work alone without a regular filter.
Clock types are explicit:
- Cycles are non-negative whole counts, compared exactly even beyond JavaScript's safe integer limit. Unrelated numbers are not treated as time. No clock period is guessed. For conversion using a known period, choose the simulation profile, replace its capture pattern with the cycle pattern, choose the physical unit, and set the duration of one unitless tick.
- Simulation / elapsed time uses
@ timestamps by default, for example INFO @ 1250 ns: or INFO @ 1250:. Capture group 1 is the number; optional group 2 is a unit. Supported units are fs, ps, ns, us, ms, and s. Explicit units are normalized exactly; unitless values use the chosen unit and scale. A tick of 10 ns is configured as unit ns, scale 10. Bounds with units such as 1.25 us override the unitless scale.
- Wall-clock timestamps support full ISO dates with UTC offsets, or custom Luxon date-format tokens and an explicit UTC/IANA timezone (for example
yyyy-MM-dd HH:mm:ss.SSS and Asia/Kolkata). Invalid dates, timezone gaps, ambiguous daylight-saving times without offsets, and fractions finer than milliseconds are rejected. Time-only wall-clock strings cannot supply an unknown date; use a numeric elapsed-time profile or provide a full date.
- All preset capture patterns are editable for other log formats and specific clock domains. Group 1 must capture only the desired clock value. Numeric captures and scales support up to 80 decimal digits; scientific notation is not supported. An unmatched line can inherit its preceding timestamp, but malformed matching timestamps break inheritance; preamble lines without a preceding timestamp are excluded.
- Bounds are inclusive. If shown regular filters exist, both regex and time conditions must match. Exclusions win, including on context lines. Counter resets and backward timestamps are reported, not sorted or assigned invented epochs: every event whose local value falls in the range is eligible, including events in repeated runs. Narrow the input or capture pattern when one file mixes clocks or simulation runs.
- Profiles, context settings, and the worker deadline are included in Settings Only / Filters, Exclusions and Settings saves for internal or external files. Save All Changed Filters does not replace settings. When sharing across machines, document URI keys may need adapting to local file locations; use Apply Settings from This File to apply saved settings explicitly.
🔄 Easy Migration
- Click "Import Internal Projects" in Projects view
- Choose "Create New Unified Settings File"
- Save to shared location
- Team members load the same file
- Everyone has identical configuration!
- Visual selection of processing strategy with performance impact preview
- Real-time configuration without editing JSON manually
- Automatic optimization recommendations based on your workflow
Usage
We distinguish between Basic Users and Advanced Users to cater to different user needs and expertise levels. Basic Users focus on simple filter management for log analysis without needing to understand or interact with project features. In contrast, Advanced Users manage multiple projects and filter configurations to handle more complex log analysis scenarios.
Basic Users
Basic users simply set up and manage filter groups to use for log analysis. The Primary SideBar (FILTERS+/FILTERS-) is designed for their use, where they can configure filters within these groups without worrying about project management. They can save the filter configurations for reuse, ensuring that settings persist even after restarting VSCode. If users don't need the advanced project management features, they can disable the ActivityBar (Smart Log Highlighter) menu for a simpler interface.
Basic Operation
The basic operation for log analysis is as follows.
For basic users, log analysis can be performed directly in the FILTERS+ tab without needing to access the Smart Log Highlighter menu. The FILTERS+ tab, a NONAME project is automatically created and used. When saving filters, the project will be saved, and a message confirming the save will appear in the status bar. The tab will display all the necessary filter groups, where users can activate filters or control highlights to focus on log analysis using Focus Mode.
The left editor holds the original document, and all the lines that matches any of the filters have been highlighted. The right editor holds the focus mode of the left document, and notice that the lines which don't match any of the filters' regex are gone. The focus mode is implemented as a virtual document (read-only), and the original document is not modified.
If there are lines in the filtered results that you want to exclude, you can add filters for this purpose in the FILTERS- tab.
Customization for filters
This extension creates a tab FILTERS+ in the explorer sidebar. This tab holds all the filters created and allows for filter management.
Group
A group can contain multiple filters, and filters within a group can be controlled collectively. This allows you to group filters suitable for log analysis.
For each group, there are two controls and three attributes:
- add
- regex (name) : change group name
- isHighlighted
- isShown
- remove
Filter
The filled/unfilled circle represents the color of the filter and whether the highlight is applied to documents. The text represents the regex of the filter, and the number in a smaller font, if there is one, represents the number of lines that match the regex in the active editor.
For each filter, there is one control and four attributes:
- regex
- isHighlighted
- isShown
- remove
Exclusion Filter
This extension also creates a FILTERS- tab in the explorer sidebar.
In this tab, you can add exclusion filters to remove unnecessary information from the focused filter results during log analysis. For exclusion filters, there are two controls and one attribute:
Filter Control
- add
- add filter in group item
- add group in
FILTERS+ tab
- remove
- remove selected filter
- remove group including filters
Filter Properties
- Color: The color is generated randomly, but if you don't like it, you can generate a new filter.
- Regex: You can change the regex by clicking the pencil icon.
- isHighlighted: If true, the lines that match the regex will be highlighted with the filter's color. If false, this filter will be ignored for color highlighting. You can toggle this attribute by clicking the paint bucket icon.
- isShown: Used in focus mode. If true, the lines that match the regex will be kept; if false, the lines will be removed, unless other filters keep the line. You can toggle this attribute by clicking the eye icon.
If one line matches multiple regexes, because the highlight will overwrite themselves, the final color is not deterministic. However, the line is still counted in all the filters.
Focus Mode
You can use log-analysis-gamma.turnOnFocusMode command to activate focus mode for the active editor. The command has a default shortcut: ctrl/cmd + h, or the second icon located on the top of the tab can achieve the same goal. And as the focus mode is just another tab, you can close focus mode as how you close any vscode tab.
Clickable Filtered Result Navigation
In Focus Mode, filtered log lines are now displayed in a read-only virtual document with clickable links. When you click a filtered line, the extension automatically retrieves the original file’s URI and the corresponding line number from an internal mapping. If the original file is already open, the extension focuses on that editor and scrolls directly to the target line; if not, it opens the original file in a new editor at the specified location. This feature streamlines your log analysis by allowing quick navigation between the focused view and the complete log context.
Advanced Users
Advanced users can leverage the project management features available. For these users, projects are used as containers for filter groups, allowing them to manage different log analyses across multiple projects. Unlike a physical folder structure, project in this extension represents a logical unit for organizing filter configurations based on platform, framework, or log analysis use cases.
Since logs can be accessed independently of any specific workspace or folder, these projects enable users to centralize and consistently manage their filter settings, ensuring they can switch between different log analysis setups without confusion. This flexibility allows advanced users to efficiently manage various log types, such as development logs, QA issue logs, or platform-specific logs, within distinct projects.
This extension also creates a Smart Log Highlighter in the ActivityBar.
In the Smart Log Highlighter menu, advanced users can add, remove, or select projects, and the selected project's filter configuration will be reflected in the FILTERS+ tab. After selecting a project, users will be directed to the FILTERS+ tab, where you can see the project name. From there, users can click the add group icon to create a group, then add necessary filters within the group. To save the configured project, click the project save icon in the FILTERS+ tab.
All filters will initially be set to the disabled state when a project is selected and loaded. Clicking the refresh icon in the Smart Log Highlighter menu will reload the saved filter information. Advanced users can also modify the filter setup directly by editing the JSON configuration file via the settings gear icon in the Smart Log Highlighter menu. (Note: After modifying the JSON file, users must refresh to apply the changes.)
Handling Huge Files
In VS Code, when opening files larger than 50MB, the use of extensions is restricted to ensure performance and memory efficiency. This limitation helps maintain a responsive and stable environment when handling large files. More details on this can be found in #31078. By using the extension below, you can enable extension functionality when opening large files, allowing for log analysis.
It works well with 
to handle large log files.
Contributing
We welcome contributions! If you would like to contribute, please refer to our Contributing Guidelines for more information on how to get involved.
