Skip to content
BranchesTags

Repository files navigation

Smart-Log README

Visual Studio Marketplace Version

This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.

Smart-Log in action

Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).

Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.

Features

  • Configurable event tree-view: Icons in tree-view

    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)

  • Configurable decorations (todo picture).

  • Time sync feature (todo movie...):

    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).

    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).

  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).

Requirements

To open large log files please consider installing "vsc-lfs" extension.

Extension Settings

This extension contributes the following settings:

  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.

(todo add example configs)

Known Issues

  • processing large files is kind of slow. Need to process time info and decorations in the background.

Contributions

Any and all test, code or feedback contributions are welcome. Open an issue or create a pull request to make this extension work better for all.

Donations are welcome! (Contact me for commercial use or different license).

GitHub ♥︎ Sponsors are welcome!

Planned features

  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync

Release Notes

See Changelog

semantic-releaserelease

Third-party Content

This project leverages the following third party content.

d3-time-format (2.2.3)

About

Visual Studio Code extension that provides analysis and visualization features for text based log files.

Resources

Readme
License
Activity

Stars

12 stars

Watchers

1 watching

Forks

4 forks
Report repository

Releases

Sponsor this project

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - mbehr1/smart-log: Visual Studio Code extension that provides analysis and visualization features for text based log files. · GitHub
Skip to content
BranchesTags
Repository files navigation
Smart-Log README
Visual Studio Marketplace Version
This Visual Studio Code(tm) extension adds analysis and visualization features for log files and should ease debugging especially of complex systems where multiple log files need to be considered at the same time.
Smart-Log in action
Note: It works well with Visual Studio Marketplace Version to handle large log files (few hundred MBs).
Note: The time-sync feature works well with Visual Studio Marketplace Version for DLT (diagnostic log and trace) and Visual Studio Marketplace Version for pcap/pcapng-network trace files.
Features
  • Configurable event tree-view:
Icons in tree-view
    • Helps quickly to understand the structure or to highlight events (errors/warnings,...).
    • Icons can be added to the tree-view.
    • Quickly jump to the event by selecting the item in the tree-view.
    • Open a text document with the full set of events or the selected event and its leaves.
    • Compare two tree events quickly (select/click one tree event and then click on the diff icon on the 2nd event)
  • Configurable decorations (todo picture).
  • Time sync feature (todo movie...):
    • Detects time for each line.
    • An offset for the full file can be set via context menu item adjust time....
    • If a time was received already the adjust-time... will propose to adjust/sync that line to the selected one.
    • Posts events of the selected time to other documents/plugins. (See ... ).
    • Allows to "synchronize" this time with other visible documents from all plugins that support "onDidChangeSelectedTime" events.
    • Automatic time synchronization of multiple documents by "time-sync events" (see settings event.timeSyncId and event.timeSyncPrio) (todo add example).
    Note:Time sync is restricted to documents within the same workspace/editor window and revealing line works if used with multiple columns/rows (so the documents must be visible).
  • Allows configuration of multiple file types (see settings smart-log.fileConfigs).
Requirements
To open large log files please consider installing "vsc-lfs" extension.
Extension Settings
This extension contributes the following settings:
  • smart-log.timeRegex: Regular expression (regex) to identify the time of a log line.
  • smart-log.timeFormat: Optional time format specifier (details see config example).
  • smart-log.decorations: Definition of the decoration types supported for events.
  • smart-log.fileConfigs: Definition of the configuration per file type.
(todo add example configs)
Known Issues
  • processing large files is kind of slow. Need to process time info and decorations in the background.
Contributions
Any and all test, code or feedback contributions are welcome.
Open an issue or create a pull request to make this extension work better for all.
Donations are welcome! (Contact me for commercial use or different license).
GitHub ♥︎ Sponsors are welcome!
Planned features
  • Add possibility to select from which other documents time events should be considered.
  • Use outline instead of own tree view
  • add filtering based on events (remove all but the events)
  • automatic timezone detection
  • change "smart-log" file type automatically to sub-types
  • change file type back to e.g. Log or Plain text if no config is found.
  • add event support to modify parent title
  • add decoration for time-sync
Release Notes
See Changelog
semantic-releaserelease
Third-party Content
This project leverages the following third party content.
d3-time-format (2.2.3)
About
Visual Studio Code extension that provides analysis and visualization features for text based log files.
Resources
Readme
License
Activity
Stars
12 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Sponsor this project
Packages
Used by
Contributors
Languages