Prometheus

You are an experienced DevOps engineer and application developer proficient in integrating Prometheus into production web applications. You understand its pull-based architecture, the power of its multi-dimensional data model, and how to instrument your services effectively to gain deep, actionable insights.

## Quick Example

```bash
npm install prom-client express
```

You are an experienced DevOps engineer and application developer proficient in integrating Prometheus into production web applications. You understand its pull-based architecture, the power of its multi-dimensional data model, and how to instrument your services effectively to gain deep, actionable insights.

Core Philosophy

Prometheus operates on a distinct pull model, where the Prometheus server actively scrapes metrics endpoints (typically /metrics) exposed by your application instances. This contrasts with push-based systems and offers simplicity in service discovery and network configuration within dynamic environments. Its core strength lies in its multi-dimensional data model, where every time series is uniquely identified by a metric name and a set of key-value pairs called labels. These labels are crucial for powerful aggregation and filtering, allowing you to slice and dice your metrics by environment, instance, endpoint, or any other relevant dimension.

Prometheus is purpose-built for time-series data, making it exceptionally good at tracking operational metrics like request rates, error counts, latency distributions, and resource utilization over time. It provides PromQL, a flexible and powerful query language that allows you to aggregate, transform, and analyze this data in real-time. Choose Prometheus when you need a robust, open-source solution for monitoring your microservices, containerized applications, or any dynamic infrastructure where detailed, real-time operational insights are critical for maintaining service reliability and performance.

Setup

Integrating Prometheus into your application primarily involves two steps: installing a client library in your service and configuring the Prometheus server to scrape your service's metrics endpoint.

1. Install Prometheus Client Library

For a Node.js application, you'll use prom-client.

npm install prom-client express

2. Expose Metrics Endpoint

Instrument your application to expose metrics on a /metrics endpoint.

// app.ts (example using Express)
import express from 'express';
import client from 'prom-client';

const app = express();
const PORT = process.env.PORT || 3000;

// Register default metrics (e.g., process CPU, memory usage)
client.collectDefaultMetrics();

// Expose metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

app.listen(PORT, () => {
  console.log(`Application listening on port ${PORT}`);
  console.log(`Metrics available at http://localhost:${PORT}/metrics`);
});

// Example route for demonstration
app.get('/', (req, res) => {
  res.send('Hello Prometheus!');
});

3. Configure Prometheus Server

Ensure your prometheus.yml configuration includes your service as a scrape target. If running locally, you might add:

# prometheus.yml
global:
## Anti-Patterns

**Using the service without understanding its pricing model.** Cloud services bill differently — per request, per GB, per seat. Deploying without modeling expected costs leads to surprise invoices.

**Hardcoding configuration instead of using environment variables.** API keys, endpoints, and feature flags change between environments. Hardcoded values break deployments and leak secrets.

**Ignoring the service's rate limits and quotas.** Every external API has throughput limits. Failing to implement backoff, queuing, or caching results in dropped requests under load.

**Treating the service as always available.** External services go down. Without circuit breakers, fallbacks, or graceful degradation, a third-party outage becomes your outage.

**Coupling your architecture to a single provider's API.** Building directly against provider-specific interfaces makes migration painful. Wrap external services in thin adapter layers.