Monitoring Flask Applications with Prometheus and Grafana

Monitoring is your early warning system. Without it, you discover problems through user complaints—always too late. Prometheus + Grafana is the de facto open-source monitoring stack for Python web applications, offering powerful metrics collection, alerting, and beautiful dashboards.

Instrumenting Flask with prometheus_flask_exporter

from prometheus_flask_exporter import PrometheusMetrics

metrics = PrometheusMetrics(app)

# Custom business metrics
article_views = metrics.counter(
    "article_views_total",
    "Total article view count",
    labels={"slug": lambda: request.view_args.get("slug")}
)

@app.route("/blog/")
@article_views
def article(slug):
    ...

Key Metrics to Track

• flask_http_request_duration_seconds: Request latency histogram by endpoint
• flask_http_request_total: Request count by status code
• flask_http_exceptions_total: Unhandled exceptions
• Custom: db_query_duration_seconds, celery_task_duration_seconds

Alerting Rules

groups:
- name: mirahlabs-api
  rules:
  - alert: HighErrorRate
    expr: rate(flask_http_request_total{status=~"5.."}[5m]) > 0.05
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "Error rate above 5% for 2 minutes"
      runbook_url: "https://wiki.mirahlabs.com/runbooks/high-error-rate"

  - alert: SlowAPIResponses
    expr: histogram_quantile(0.99, flask_http_request_duration_seconds_bucket) > 2
    for: 5m
    labels:
      severity: warning

Alertmanager: PagerDuty and Slack Routing

Route critical alerts (5xx spike, database unreachable) to PagerDuty for on-call paging. Route warning alerts (slow queries, high memory) to a Slack channel for awareness. Never page for things that don't require immediate human intervention—alert fatigue kills response quality.

Production Application Telemetry Wrapper

Here is an enterprise-grade telemetry decorator in Python to measure execution latency, record counts, and catch pipeline boundaries:

import time
import logging
from functools import wraps

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("MirahLabs.Telemetry")

def monitor_performance(operation_name: str):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            t0 = time.perf_counter()
            try:
                res = func(*args, **kwargs)
                dt = time.perf_counter() - t0
                logger.info(f"{operation_name} succeeded in {dt:.4f}s")
                return res
            except Exception as e:
                dt = time.perf_counter() - t0
                logger.error(f"{operation_name} failed after {dt:.4f}s: {str(e)}")
                raise e
        return wrapper
    return decorator

Cloud Infrastructure Performance Profile

Below is a comparative latency and throughput profile of this infrastructure pattern deployed under a simulated load of 10,000 concurrent requests:

US & UK DevOps Governance & Infrastructure Security

Automating infrastructure and deployment workflows must respect regional privacy laws. Under the UK GDPR and US California Consumer Privacy Act (CCPA), system administrators must ensure that data pipelines respect strict boundaries regarding where user telemetry and system logs are stored (data residency). Implementing secure deployment methods (such as the NIST Secure Software Development Framework - SSDF) ensures that pipeline secrets are securely managed in systems like HashiCorp Vault, and that container configurations undergo automated security scanning before being shipped to production environments.