This is the Prometheus monitoring system, a production-grade application that scrapes and stores time-series metrics, evaluates PromQL queries, generates alerts, and supports remote write/read. The codebase is structured as a monolith with clearly separated packages: a time-series database (TSDB) with advanced compression (XOR, varbit, histogram encoding), a PromQL parser and engine, a scrape manager with start-time synthesis for cumulative metrics, a notifier for Alertmanager integration, service discovery for 15+ cloud/container platforms, remote storage adapters, and a REST API with OpenAPI specs. The system runs as a single binary with optional agent mode. Two web UIs (React and Mantine) provide querying, alert management, and configuration views. The architecture is modular: each major component (TSDB, PromQL, scrape, notifier) has a clean interface and can be independently tested or replaced.

Prometheus Alertmanager is a production-grade Go service that receives alert notifications from Prometheus or any HTTP client, deduplicates and groups them by routing rules, applies silences and inhibition rules, and dispatches notifications through 20+ integrations (Slack, PagerDuty, email, webhook, Telegram, Jira, etc.). It runs as a single binary with an embedded web UI, a REST API v2, an experimental Connect/gRPC API, and an amtool CLI. The architecture is a modular monolith: the app package wires together config loading, cluster membership, HTTP listeners, and a pipeline of notification stages (mute, dedup, retry, fanout).

The prometheus/statsd_exporter is a production-grade Go application that receives StatsD metrics over UDP, TCP, or Unix sockets and translates them into Prometheus metrics. It acts as a drop-in replacement for StatsD, supporting multiple tagging formats (DogStatsD, InfluxDB, Librato, SignalFX) and providing flexible metric mapping via glob or regex patterns. The exporter is designed to run as a sidecar alongside application instances, converting ephemeral StatsD events into persistent Prometheus time series that can be scraped by a Prometheus server. Architecturally, the application consists of several well-separated layers: network listeners (UDP, TCP, Unixgram) that receive raw lines, a line parser that converts text into typed events (counter, gauge, observer), a metric mapper that applies user-defined mapping rules using a finite state machine (FSM) for glob patterns or regular expressions, and an exporter that registers and updates Prometheus metrics via a custom registry. Events are batched through an internal queue to improve throughput. The mapper supports caching (LRU or random replacement) to accelerate repeated lookups. Key entry points include the main.go binary with CLI flags for configuring listeners, mapping files, cache size, relay targets, and tagging options. The primary data flow is: incoming StatsD line → line parser → event queue → mapper → exporter → Prometheus registry. External dependencies are limited to Prometheus client libraries, a YAML parser, and the Go standard library. The codebase is well-tested with unit tests, integration tests, and benchmarks, and follows Prometheus project conventions.

The CloudWatch Exporter is a Java-based Prometheus exporter that collects metrics from AWS CloudWatch and exposes them in Prometheus format. It runs as a standalone web server with an embedded Jetty server, periodically polling AWS CloudWatch APIs based on YAML configuration. The architecture features clear separation of concerns with distinct components for configuration management, AWS API interaction, dimension caching, and metric collection. Key entry points include the WebServer main method which takes port and config file arguments, and the CloudWatchCollector which handles the core metrics collection logic. The exporter supports both GetMetricStatistics and GetMetricData APIs, includes special handling for services like DynamoDB, and provides configuration reload via SIGHUP or HTTP endpoint. External dependencies include AWS SDK, Prometheus Java client, Jetty, Caffeine for caching, and Snakeyaml for YAML parsing.

This repository is a collection of shared Go libraries used across Prometheus components. It is not a standalone application but a modular library providing core infrastructure for metric exposition formatting (text, protobuf, OpenMetrics), HTTP client configuration (authentication, TLS, OAuth2, proxy), metric model types and validation, logging, routing, and version information. The architecture is package-oriented with clear interfaces and separation of concerns. Key entry points include `config.NewClientFromConfig` for constructing HTTP round trippers with hot-reloadable TLS and credentials, `expfmt.NewTextParser` for parsing Prometheus text format, and `model.EscapeName` for metric name escaping. The codebase is well-tested, actively maintained, and exhibits strong engineering practices such as interface-based design, table-driven tests, and reusable build infrastructure (Makefile.common). It is primarily consumed by Prometheus server, exporters, and other ecosystem tools.