# Lumin: Docker Compose monitoring for small teams

> Uptime checks, logs, metrics, and Slack alerts from one agent. No SDK in your services. Live in 10 minutes.

- Canonical: https://getlumin.dev/
- Sign up: https://app.getlumin.dev/signup (every account starts on the free Hobby tier, no card needed)
- Documentation: https://docs.getlumin.dev/
- Quickstart: https://docs.getlumin.dev/quickstart/

## Uptime, health, errors, users, and a message when it breaks

Five questions cover most of what a small team needs from monitoring. The first is answered from Lumin's servers before you install anything. Three are answered by one agent on your host, with no SDK in your services. The question about users needs one small package in your web or mobile app.

1. **Is my site up?** An HTTP check from Lumin's servers, every 30 seconds to 15 minutes, against any URL you give it. Nothing to install for this one. The dashboard opens on uptime, average response, and incidents per check, and a slow answer past your threshold shows as degraded, not just down.
2. **Is my service healthy?** Request rate, error rate, and latency per route, next to CPU and memory for every container and disk for every host.
3. **What is in the error log?** Tailed straight from container stdout and stderr, with the service and level already parsed. Filter on either, search the message text, and follow it live. Unhandled browser and mobile errors are captured with no code of yours, and land in the session that hit them.
4. **What are users doing?** Sessions, page and screen views, and custom events from `@lumin-monitor/browser` or `@lumin-monitor/react-native`. Each is under 6 kB gzipped, and both write into the same project.
5. **Who tells me when it breaks?** A rule watches one metric, or counts how often a log pattern matches inside a window. Cross the threshold and Lumin posts to the Slack channel you connected, with the condition and the value that tripped it. It posts again when the value recovers.

## That dashboard costs you 18 lines of docker-compose.yml

```yaml
services:
  spring-api:
    image: acme/spring-api:1.4.2
    labels:
      lumin.metrics: "true"
      lumin.metrics.framework: "spring"
  lumin-agent:
    image: luminmonitor/lumin-agent:latest
    environment:
      LUMIN_API_KEY: "lmn_priv_…"
      DOCKER_HOST: tcp://lumin-docker-proxy:2375
  lumin-docker-proxy:
    image: wollomatic/socket-proxy:1.13.1
    user: "0:0"
    environment:
      SP_LISTENIP: 0.0.0.0
      SP_ALLOWFROM: lumin-agent
      SP_ALLOW_HEAD: /_ping
      SP_ALLOW_GET: '/v1\.[0-9]+/containers/(json|[0-9a-f]{64}/(json|stats|logs))'
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
```

- No image rebuilt, and no SDK added to a service you run.
- One Docker socket, read-only and behind an allowlisting proxy.
- The agent finds every labeled container on its own.
- Compose is optional. `docker run`, Swarm, and Coolify work the same.

Then run `docker compose up -d`.

## How it works

Label the services you care about. The agent scrapes their `/metrics` endpoints, tails their stdout, and snapshots the host every 15 seconds.

1. **Your docker-compose.yml.** Add two labels to each service you want watched. A label, not a compose file: `docker run`, Swarm, Portainer, and Coolify label a container just as well.
2. **lumin-agent.** One agent, three jobs: scrape `/metrics` endpoints, tail stdout and stderr, snapshot host and container stats. It reads the Docker API through `lumin-docker-proxy`, which forwards only the five read requests that the agent makes. The agent never touches the socket.
3. **app.getlumin.dev.** Per-service charts for request rate, errors, latency, and saturation. Searchable logs from every labeled container. Host and container CPU, memory, and disk. Slack alerts on any metric, or on a log pattern. Live in 10 minutes.

Uptime checks are the one thing on the dashboard the agent does not produce: Lumin probes your URLs from its own servers, agent or no agent.

## Stack support

Lumin picks up anything that serves a Prometheus `/metrics` endpoint or writes logs to stdout. The five named below have an adapter that maps their metric names onto the three RED charts: request rate, errors, and duration.

| Stack | Setup | What you get |
|---|---|---|
| Spring Boot | 2 deps + 3 settings | **RED**, plus JVM and pool series |
| Gin | client_golang + a middleware | **RED** |
| Express | prom-client + a middleware | **RED** |
| FastAPI | 1 pip install + 5 lines | **RED** |
| Axum | axum-prometheus layer | **RED** |
| Anything else | expose /metrics | Your metric names, charted as they are |
| Off-the-shelf (Caddy, Postgres) | just the lumin.logs=true label | **Logs tailed** |

## Setup compared

Other tools want their SDK inside every service image and their collector next to it. A typical Datadog setup adds a tracer to every Dockerfile, wraps every entrypoint, and mounts the Docker socket, `/proc`, and cgroups into an agent. Every service image is rebuilt and redeployed before you see a single chart.

Lumin wants two labels on each service you want watched, one `lumin-agent` container, and one read-only `socket-proxy`. No Dockerfile edited, no image rebuilt, no SDK added to a service you run. Lumin scrapes the endpoint your services already expose.

## Your production data, inside Claude Code

Lumin runs a read-only MCP server. Point Claude Code, Cursor, or VS Code at it with one command, then ask about production in the editor you already have open. Ten tools cover logs, metrics, uptime checks, alerts, infrastructure, and browser errors.

```sh
claude mcp add --transport http lumin \
  https://api.getlumin.dev/v1/mcp \
  --header "Authorization: Bearer lmn_read_..."
```

The key reads one project and writes nothing. Lumin sends nothing to a model provider. Your agent asks, and Lumin answers with your own data. Setup for every client is at https://docs.getlumin.dev/mcp/.

## Pricing

Flat tiers. No per-GB anything. Pick a tier by the number of services you run. That is a number you can count today, so the bill never moves on you. Logs, metrics, sessions from web and mobile, uptime checks, and the MCP server come with every tier.

| Tier | Price | For | Included |
|---|---|---|---|
| Hobby | €0 per month | For side projects and proof-of-concepts. | **1** project, **1** service; Logs, metrics, web and mobile sessions; Uptime checks; MCP server for coding agents; 7-day retention; No alerts |
| Solo | €19 per month | For one person shipping a real product. | **1** project, **5** services; Logs, metrics, web and mobile sessions; Uptime checks; MCP server for coding agents; 30-day retention; Alerts on logs and metrics |
| Team (recommended) | €49 per month | For a small team that runs more than one product. | **3** projects, **15** services; Logs, metrics, web and mobile sessions; Uptime checks; MCP server for coding agents; 90-day retention; Alerts on logs and metrics; Priority support by email |
| Studio | €99 per month | For an agency or a freelance operator who looks after client machines. | **Unlimited** projects, **50** services; Logs, metrics, web and mobile sessions; Uptime checks; MCP server for coding agents; 12-month retention; Alerts on logs and metrics; Priority support by email |

Prices are in euro and exclude VAT. Every account starts on the free Hobby tier, and you can upgrade from the billing screen when you need more. Signing up needs no card. The Terms of Service (https://getlumin.dev/terms/) and the Privacy Policy (https://getlumin.dev/privacy/) apply to every account.