+ Alert thresholds depend on the nature of your applications.
+ Some queries may have arbitrary tolerance thresholds.
+ Building an efficient monitoring platform takes time. 😉
+
+ Prometheus reads alert rules from YAML files and evaluates them on every evaluation_interval cycle.
+ Keep both scrape_interval and evaluation_interval consistent — a mismatch causes stale data in range queries.
+
+
+
{`# prometheus.yml
+
+global:
+ scrape_interval: 20s
+
+ # A short evaluation_interval will check alerting rules very often.
+ # It can be costly if you run Prometheus with 100+ alerts.
+ evaluation_interval: 20s
+
+rule_files:
+ - 'alerts/*.yml'
+
+scrape_configs:
+ # ...`}
+ AlertManager receives alerts from Prometheus, deduplicates and groups them, then routes them to the right receiver.
+ The three key timing parameters control when notifications are sent:
+
+
+
group_wait — how long to wait for more alerts to batch into the first notification
+
group_interval — how long to wait before sending a follow-up for an ongoing group
+
repeat_interval — how often to re-notify if an alert hasn't resolved
+ Inhibition suppresses lower-priority alerts when a higher-priority alert is already firing for the same target.
+ A common pattern: silence warning alerts when a critical alert is active on the same instance.
+
+
+
{`# alertmanager.yml
+
+inhibit_rules:
+ # Suppress warnings when a critical is firing for the same instance
+ - source_matchers:
+ - severity = "critical"
+ target_matchers:
+ - severity = "warning"
+ equal:
+ - alertname
+ - instance
+
+ # Suppress all alerts for a node when NodeDown is firing
+ - source_matchers:
+ - alertname = "NodeDown"
+ target_matchers:
+ - job = "node"
+ equal:
+ - instance`}
+
+
Reduce Prometheus server load
+
+
+ For expensive or frequently evaluated PromQL queries, use recording rules to precompute results.
+ AlertManager and dashboards then reference the lightweight recorded metric instead of re-evaluating the full expression.
+
+ The total time from an event occurring to a notification being sent is the sum of several independent delays.
+ Work through them in order:
+
+
+
Scrape delay: up to scrape_interval (20s) before the metric is collected
+
Evaluation delay: up to evaluation_interval (20s) before the rule fires
+
Pending duration: the for: 5m window must be satisfied before the alert state changes to firing
+
GroupWait: AlertManager waits group_wait (10s) for other alerts to batch
+
+
+
+ In the worst case with for: 5m: 20s + 20s + 5m + 10s ≈ 6 minutes from event to notification.
+ Reduce evaluation_interval and for: for time-sensitive alerts, but be careful of false positives from transient spikes.
+
+
diff --git a/site/src/pages/blackbox-exporter.astro b/site/src/pages/blackbox-exporter.astro
new file mode 100644
index 0000000..58eecfb
--- /dev/null
+++ b/site/src/pages/blackbox-exporter.astro
@@ -0,0 +1,191 @@
+---
+import GuideLayout from '../layouts/GuideLayout.astro';
+
+const base = import.meta.env.BASE_URL.replace(/\/$/, '');
+
+const howToJsonLd = {
+ '@context': 'https://schema.org',
+ '@type': 'HowTo',
+ name: 'How to deploy Blackbox Exporter for worldwide endpoint probing',
+ description: 'Deploy blackbox exporters in multiple Points of Presence to monitor HTTP, HTTPS, DNS, TCP, and ICMP endpoints with geolocation support in Grafana.',
+ step: [
+ {
+ '@type': 'HowToStep',
+ name: 'Deploy blackbox exporters worldwide',
+ text: 'Deploy blackbox exporters in multiple PoPs (e.g., Montreal, Paris, Singapore, Sydney). Use community-hosted endpoints at probe-.cleverapps.io or self-host using the samber/blackbox_exporter configuration.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Define targets with encoded labels',
+ text: 'Create a service discovery file (sd/blackbox.yml) encoding the exporter host, probe module, city name, geohash, and target URL in the target address using the :_: separator format.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Configure Prometheus relabeling',
+ text: 'Add a scrape job to prometheus.yml with relabel_configs to extract module, pop, geohash, and instance labels from the compound target address. Use regex patterns to parse each field.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Set up geohash labels for Grafana',
+ text: 'Convert probe PoP coordinates to geohash format using geohash.co. Add the geohash value to your target definitions so Grafana\'s geomap panel can display probe locations on a world map.',
+ },
+ ],
+};
+---
+
+
+
Worldwide probes
+
+
+ Blackbox Exporter
+ gives you the ability to probe endpoints over HTTP, HTTPS, DNS, TCP and ICMP.
+
+
+
+ You should deploy blackbox exporters in multiple Points of Presence around the globe to monitor latency.
+ Feel free to use the following endpoints for your own projects:
+
+
+
+
https://probe-montreal.cleverapps.io
+
https://probe-paris.cleverapps.io
+
https://probe-jeddah.cleverapps.io
+
https://probe-singapore.cleverapps.io
+
https://probe-sydney.cleverapps.io
+
https://probe-warsaw.cleverapps.io
+
+
+
+ ☝️ Server logs have been disabled. More probes from the community would be appreciated —
+ contribute here!
+ These blackbox exporters use the following
+ configuration.
+
+
+
Prometheus Configuration
+
+
+ Blackbox exporters and endpoints must be declared in Prometheus. Here is a simple configuration,
+ inspired by Hayk Davtyan's medium post:
+
+
+
diff --git a/site/src/pages/llms-full.txt.ts b/site/src/pages/llms-full.txt.ts
new file mode 100644
index 0000000..da00ba9
--- /dev/null
+++ b/site/src/pages/llms-full.txt.ts
@@ -0,0 +1,65 @@
+import type { APIRoute } from 'astro';
+import { data, getGroupSlug, getServiceSlug, getTotalRuleCount, getTotalServiceCount } from '../data/rules';
+import { SITE_NAME, SITE_URL, GITHUB_URL, AUTHOR_NAME, LICENSE_CC_BY_NAME } from '../data/site';
+
+export const GET: APIRoute = () => {
+ const totalRules = getTotalRuleCount();
+ const totalServices = getTotalServiceCount();
+ const siteBase = SITE_URL.replace(/\/$/, '');
+
+ const sections = data.groups
+ .map((group) => {
+ const groupSlug = getGroupSlug(group);
+ const serviceBlocks = group.services
+ .map((service) => {
+ const serviceSlug = getServiceSlug(service);
+ const ruleLines = service.exporters
+ .flatMap((exporter) =>
+ (exporter.rules ?? []).map((rule) => {
+ const forPart = rule.for ? `, for: ${rule.for}` : '';
+ return ` - **${rule.name}** (severity: ${rule.severity}${forPart})\n ${rule.description}`;
+ })
+ )
+ .join('\n');
+ return `### [${service.name}](${siteBase}/rules/${groupSlug}/${serviceSlug}/)\n\n${ruleLines}`;
+ })
+ .join('\n\n');
+ return `## ${group.name}\n\n${serviceBlocks}`;
+ })
+ .join('\n\n');
+
+ const content = `# ${SITE_NAME} — Full Content
+
+> ${totalRules} copy-pasteable Prometheus alerting rules for ${totalServices} monitored services.
+
+## Overview
+
+Awesome Prometheus Alerts is the most comprehensive collection of Prometheus alerting rules. Rules are organized by category and service, with each rule containing:
+- Alert name and description explaining what is happening and why it matters
+- PromQL expression tested against the latest exporter version
+- Severity level: critical (requires immediate attention), warning (needs attention soon), or info (awareness only)
+- Duration (for field) to avoid false positives from transient spikes
+
+All rules are copy-paste ready YAML for direct use in Prometheus configuration files.
+
+## Guides
+
+- [AlertManager Configuration](${siteBase}/alertmanager/): Prometheus configuration (scrape_interval, evaluation_interval, rule_files), AlertManager routing with group_wait/group_interval/repeat_interval, Slack and webhook receivers, recorded rules for expensive queries, and troubleshooting notification delays.
+- [Blackbox Exporter](${siteBase}/blackbox-exporter/): Deploy worldwide probes for HTTP, HTTPS, DNS, TCP, ICMP monitoring from multiple Points of Presence. Prometheus relabeling config, geohash setup for Grafana geomap panel, community dashboard links.
+- [Sleep Peacefully](${siteBase}/sleep-peacefully/): Suppress noisy alerts during nights and weekends using day_of_week(), hour(), month() PromQL functions. Timezone-aware recording rules for Europe/London and Europe/Paris, public holiday suppression patterns.
+
+## All rules by category and service
+
+${sections}
+
+## Source
+
+- GitHub: ${GITHUB_URL}
+- Author: ${AUTHOR_NAME}
+- License: ${LICENSE_CC_BY_NAME}
+`;
+
+ return new Response(content, {
+ headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+ });
+};
diff --git a/site/src/pages/llms.txt.ts b/site/src/pages/llms.txt.ts
new file mode 100644
index 0000000..078e187
--- /dev/null
+++ b/site/src/pages/llms.txt.ts
@@ -0,0 +1,70 @@
+import type { APIRoute } from 'astro';
+import { data, getGroupSlug, getServiceSlug, getDistUrl, getTotalRuleCount, getTotalServiceCount } from '../data/rules';
+import { SITE_NAME, SITE_URL, GITHUB_URL, AUTHOR_NAME, LICENSE_CC_BY_NAME } from '../data/site';
+
+export const GET: APIRoute = () => {
+ const totalRules = getTotalRuleCount();
+ const totalServices = getTotalServiceCount();
+ const siteBase = SITE_URL.replace(/\/$/, '');
+
+ const categoryList = data.groups
+ .map((group) => {
+ const services = group.services.map((s) => s.name).join(', ');
+ return `- **${group.name}**: ${services}`;
+ })
+ .join('\n');
+
+ const distTree = data.groups
+ .map((group) => {
+ const groupSlug = getGroupSlug(group);
+ const serviceLines = group.services
+ .map((service) => {
+ const serviceSlug = getServiceSlug(service);
+ const exporterLines = service.exporters
+ .map((exporter) => {
+ const url = getDistUrl(service.name, exporter.slug);
+ const label = exporter.name ? `${exporter.name} (${exporter.slug})` : exporter.slug;
+ return ` - [${label}](${url})`;
+ })
+ .join('\n');
+ return ` - [${service.name}](${siteBase}/rules/${groupSlug}/${serviceSlug}/)\n${exporterLines}`;
+ })
+ .join('\n');
+ return `- **${group.name}**\n${serviceLines}`;
+ })
+ .join('\n');
+
+ const content = `# ${SITE_NAME}
+
+> ${totalRules}+ copy-pasteable Prometheus alerting rules for ${totalServices}+ monitored services. The definitive open-source collection for Prometheus monitoring, covering databases, Kubernetes, cloud providers, message brokers, and more.
+
+## Key pages
+
+- [Alert rules catalog](${siteBase}/rules/): Browse all ${totalRules} alerting rules organized by category and service
+- [AlertManager configuration guide](${siteBase}/alertmanager/): Prometheus and AlertManager configuration examples, recorded rules, and troubleshooting
+- [Blackbox Exporter guide](${siteBase}/blackbox-exporter/): Worldwide endpoint probing over HTTP, HTTPS, DNS, TCP, and ICMP with Grafana maps
+- [Sleep Peacefully guide](${siteBase}/sleep-peacefully/): Time-based alert suppression and timezone-aware PromQL patterns
+
+## Categories and services
+
+${categoryList}
+
+## Downloadable Rule Files
+
+${distTree}
+
+## Full Content
+
+- [llms-full.txt](${siteBase}/llms-full.txt): Complete list of all alert rules with title, description and severity
+
+## About
+
+${SITE_NAME} is a community-driven open-source project maintained by ${AUTHOR_NAME}.
+Source: ${GITHUB_URL}
+License: ${LICENSE_CC_BY_NAME}
+`;
+
+ return new Response(content, {
+ headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+ });
+};
diff --git a/site/src/pages/rules/[group]/[service].astro b/site/src/pages/rules/[group]/[service].astro
new file mode 100644
index 0000000..224b102
--- /dev/null
+++ b/site/src/pages/rules/[group]/[service].astro
@@ -0,0 +1,182 @@
+---
+import BaseLayout from '../../../layouts/BaseLayout.astro';
+import Breadcrumbs from '../../../components/Breadcrumbs.astro';
+import Sidebar from '../../../components/Sidebar.astro';
+import ExporterSection from '../../../components/ExporterSection.astro';
+import CautionBanner from '../../../components/CautionBanner.astro';
+import { data, getGroupSlug, getServiceSlug, getRuleCount, getAllServices } from '../../../data/rules';
+import { SITE_URL, schemaAuthor, schemaPublisher, schemaWebSite, SITE_DATE_PUBLISHED, SCHEMA_IN_LANGUAGE } from '../../../data/site';
+
+export function getStaticPaths() {
+ return getAllServices().map(({ group, service, groupSlug, serviceSlug }) => ({
+ params: { group: groupSlug, service: serviceSlug },
+ props: { group, service },
+ }));
+}
+
+const { group, service } = Astro.props;
+const base = import.meta.env.BASE_URL.replace(/\/$/, '');
+const groupSlug = getGroupSlug(group);
+const serviceSlug = getServiceSlug(service);
+const ruleCount = getRuleCount(service);
+const groupIndex = data.groups.findIndex((g) => getGroupSlug(g) === groupSlug) + 1;
+const serviceIndex = group.services.findIndex((s) => getServiceSlug(s) === serviceSlug) + 1;
+
+// Build exporters summary for meta description
+const exporterNames = service.exporters.map((e) => e.name).filter(Boolean).join(', ');
+const metaDescBase = `${ruleCount} ready-to-use Prometheus alert rules for ${service.name}${exporterNames ? ` (${exporterNames})` : ''}. Copy-paste YAML for critical and warning alerts.`;
+const metaDesc = metaDescBase.length > 160
+ ? `${ruleCount} ready-to-use Prometheus alert rules for ${service.name}. Copy-paste YAML for critical and warning alerts.`
+ : metaDescBase;
+
+// FAQ JSON-LD for GEO (AI search engines)
+const faqItems = service.exporters.flatMap((exp) =>
+ (exp.rules ?? []).map((rule) => ({
+ '@type': 'Question',
+ name: `What is the Prometheus alert rule for "${rule.name}"?`,
+ acceptedAnswer: {
+ '@type': 'Answer',
+ text: `${rule.description} PromQL expression: ${rule.query}. Severity: ${rule.severity}${rule.for ? `. Duration: ${rule.for}` : ''}.`,
+ },
+ }))
+);
+
+const buildDate = new Date().toISOString().slice(0, 10);
+const keywords = [
+ 'Prometheus', 'alerting rules', service.name, 'monitoring', 'PromQL',
+ ...service.exporters.map((e) => e.name).filter(Boolean),
+].join(', ');
+
+const pageUrl = `${SITE_URL}rules/${groupSlug}/${serviceSlug}/`;
+
+const jsonLd = {
+ '@context': 'https://schema.org',
+ '@graph': [
+ {
+ '@type': 'TechArticle',
+ '@id': `${pageUrl}#article`,
+ headline: `${service.name} Prometheus Alert Rules`,
+ description: metaDesc,
+ about: `Prometheus monitoring for ${service.name}`,
+ url: pageUrl,
+ inLanguage: SCHEMA_IN_LANGUAGE,
+ datePublished: SITE_DATE_PUBLISHED,
+ dateModified: buildDate,
+ author: schemaAuthor,
+ publisher: schemaPublisher,
+ isPartOf: schemaWebSite,
+ },
+ ...(faqItems.length > 0 ? [{
+ '@type': 'FAQPage',
+ '@id': `${pageUrl}#faq`,
+ mainEntity: faqItems,
+ }] : []),
+ ],
+};
+---
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{service.name} Prometheus Alert Rules
+
+ {ruleCount} Prometheus alerting rule{ruleCount !== 1 ? 's' : ''} for {service.name}.
+ {exporterNames && `Exported via ${exporterNames}.`}
+ These rules cover critical and warning conditions — copy and paste the YAML into your Prometheus configuration.
+
+
diff --git a/site/src/pages/sleep-peacefully.astro b/site/src/pages/sleep-peacefully.astro
new file mode 100644
index 0000000..c4aad89
--- /dev/null
+++ b/site/src/pages/sleep-peacefully.astro
@@ -0,0 +1,148 @@
+---
+import GuideLayout from '../layouts/GuideLayout.astro';
+
+const howToJsonLd = {
+ '@context': 'https://schema.org',
+ '@type': 'HowTo',
+ name: 'How to suppress Prometheus alerts during nights and weekends',
+ description: 'Use PromQL time functions and timezone-aware recording rules to prevent alert fatigue by silencing alerts during off-hours.',
+ step: [
+ {
+ '@type': 'HowToStep',
+ name: 'Add inline time conditions to alert expressions',
+ text: 'Append time conditions directly to your alert PromQL: e.g., node_load5 > 10 and ON() (0 < day_of_week() < 6) to suppress weekend alerts, or and ON() (8 < hour() < 18) for business hours only.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Create timezone offset recording rules',
+ text: 'Define a european_summer_time_offset recording rule in a "timezones" rule group that returns 1 during DST and 0 otherwise, accounting for exact DST transition weekends.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Derive local time recording rules',
+ text: 'Use the timezone offset to compute local time metrics such as europe_london_time (time() + 3600 * european_summer_time_offset) and derive hour and day-of-week variants from them.',
+ },
+ {
+ '@type': 'HowToStep',
+ name: 'Reference time rules in alerts',
+ text: 'Use the recording rules as gate conditions in alerts: e.g., node_load5 > 10 and ON() (europe_london_weekday and europe_paris_weekday). Use absent() for the inverse (off-hours suppression).',
+ },
+ ],
+};
+---
+
+
+
Alerting time window
+
+
+ In some applications, load and activity can vary over the day, week, or year.
+ To prevent alarm fatigue and busy pager, alerts can be disabled during certain periods
+ (such as nights or weekends).
+
- 
- 
- 
- 
- 
+ 
+
+ 
+