Skip to content
BranchesTags

Repository files navigation

Build StatusGitter chat

Pull based, language agnostic exception aggregator for microservice environments.

Periskop scales well with the number of exceptions and application instances:

  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.

A UI component is provided for convenience.

Scraping

Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.

Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery mirrors the one from Prometheus. See Prometheus's official documentation for reference.

A full example of service configuration for Periskop can be found in the sample configuration.

Format

The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).

UI

The UI allows navigating and inspecting exceptions as they occur.

ui

Run project locally

Please see CONTRIBUTING.md

Building & Running

We are looking into distributing Periskop via Docker Hub. In the meantime, you can build and run Periskop from source:

docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage

By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage. Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.

For SQLite, add these lines to your config.yaml file:

repository:
type: sqlitepath: periskop.db

For MySQL:

repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local

For PostgreSQL:

repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable

Alert reported exceptions

All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:

groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"

Pushgateway

See periskop-pushgateway if you want to use Periskop as push based metric system.

Client Libraries

Integrations

backstage-plugin

About

Exception Monitoring Service

Topics

error-monitoringerror-reportingerrorsexceptionsmonitoring

Resources

Readme
Apache-2.0 license

Code of conduct

Code of conduct

Contributing

Contributing
Activity
Custom properties

Stars

188 stars

Watchers

61 watching

Forks

13 forks
Report repository

Releases

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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
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 - periskop-dev/periskop: Exception Monitoring Service · GitHub
Skip to content
BranchesTags
Repository files navigation
Build StatusGitter chat
Pull based, language agnostic exception aggregator for microservice environments.
Periskop scales well with the number of exceptions and application instances:
  • Exceptions are pre-aggregated in client libraries and stored efficiently in memory, while keeping a sample of concrete occurrences for inspection.
  • Exceptions are scraped and aggregated across instances by the server component.
  • More application instances result in longer refresh cycles but the memory usage remains constant.
A UI component is provided for convenience.
Scraping
Errors are scraped and aggregated using a configured endpoint from each of the instances discovered via service discovery.
Periskop supports all service discovery mechanisms supported by Prometheus. The configuration format for service discovery
mirrors the one from Prometheus. See Prometheus's official documentation
for reference.
A full example of service configuration for Periskop can be found in the sample configuration.
Format
The format for scraped errors is defined in a proto3 IDL. Currently the only supported protocol is snake_cased JSON over HTTP (example).
UI
The UI allows navigating and inspecting exceptions as they occur.
ui
Run project locally
Please see CONTRIBUTING.md
Building & Running
We are looking into distributing Periskop via Docker Hub.
In the meantime, you can build and run Periskop from source:
docker build --tag periskop .
docker run -v path/to/config.yaml:/etc/periskop/periskop.yaml -p 8080:8080 periskop

Enable persistance storage
By default Periskop stores all the scrapped errors in memory repository. You can configure your Periskop deployment to use persistent storage.
Currently the supported persistance storages are SQLite, MySQL and PostgreSQL.
For SQLite, add these lines to your config.yaml file:
repository:
type: sqlitepath: periskop.db
For MySQL:
repository:
type: mysqldsn: user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local
For PostgreSQL:
repository:
type: postgresdsn: host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable
Alert reported exceptions
All reported errors are instrumented with Prometheus which provides alerting capabilities using Alertmanager. You can configure an alert when you reach some threshold of errors. Here's an example:
groups:
- name: periskoprules:
- alert: TooManyErrorsexpr: periskop_error_occurrences{severity="error"} > 1000for: 5mlabels:
severity: critical annotations:
summary: "Too many errors on {{ $labels.service_name }}"description: "Errors for {{ $labels.service_name }}({{ $labels.aggregation_key }}) is {{ $value }}"dashboard: "https://periskop.example.com/#/{{ $labels.service_name }}/errors/{{ $labels.aggregation_key }}"
Pushgateway
See periskop-pushgateway if you want to use Periskop as push based metric system.
Client Libraries
Integrations
backstage-plugin
About
Exception Monitoring Service
Topics
error-monitoringerror-reportingerrorsexceptionsmonitoring
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Custom properties
Stars
188 stars
Watchers
61 watching
Forks
13 forks
Report repository
Releases
Packages
Used by
Contributors
Languages