The short answer

App monitoring and alerts on Unbroker are four signals: the build log, the runtime log, resource metrics, and deployment history. A few alerts on top of those signals help you notice a failure sooner. They do not guarantee you will see every outage before a user does.

Platform alerts are not error tracking. A healthy check is not a proof that every request worked.

Four signals, four questions

SignalQuestion it answers
Build logWhy a source revision did or did not build
Runtime logWhat the running application is reporting
MetricsCPU, memory, restarts, unhealthy instances, and readiness
Deployment historyWhat changed, and which revision is live

Reading the wrong one hides the cause. A failed deploy is in Debug a failed deployment. Which push became that deploy is Deploy on git push. The reference is Logs, metrics, and monitoring.

The Logs tab is stdout and stderr. Lines are collected about every 30 seconds and kept for 7 days. Search runs on the server for the range you pick. You can filter by errors, warnings, info, or debug. Download saves the lines that match.

A line gets a level only from an explicit marker: a JSON level or severity field, level=warn, [ERROR], a leading WARN:, or the nginx and PostgreSQL formats. A line without one is shown with no level. The product does not guess.

If a service writes more than 5,000 lines, or 2 MiB, in one 30-second window, the oldest lines in that window are not stored. Unbroker adds a line that says how many were dropped.

Build output is a different record. It stays with that deployment. A very large build log keeps its beginning and its most recent output. Build output older than 90 days is removed, except for the deployment the service is currently running.

Do not paste a secret into a log you share. Set the value as a variable. How those variables are scoped is Environment variables and secrets.

Metrics: CPU, memory, restarts, readiness

The Resources tab charts CPU, memory, network traffic, and replicas. Preset ranges are 15 minutes, 1 hour, 6 hours, 24 hours, 7 days, and 30 days. A custom window stays inside the last 30 days.

Samples are collected every minute. Charts average them into buckets. Per-minute samples are kept for 7 days. Hourly averages are kept for 90 days, so a range past a week is hourly. CPU and memory are summed across replicas. The dashed line is the ceiling at that moment: the per-replica limit times the replicas that are running. A thin line on the CPU and memory charts is the per-bucket peak, over the average, so a short spike is still visible.

A gap in a line means no sample was collected. It is not drawn as zero. Availability is the share of desired replicas that were ready. Restarts is container restarts per bucket, and the series appears only when there were some. Network traffic appears where the cluster exposes per-replica counters.

Resource metrics are part of Pro. How replica count changes from CPU or memory is a separate control, in Replica autoscaling.

Example alerts, not a required set

The monitoring page uses these as examples. They are not a universal recommendation.

MetricDocs example
CPUAbove 800 millicores over 5 minutes. 1000 millicores is 1 vCPU. CPU is summed across replicas.
MemoryAbove 1536 MiB over 10 minutes in the table. The CLI page uses another example: above 768 MiB over 5 minutes.
RestartsAbove 3 over 5 minutes.
Unhealthy podsAbove 0 over 5 minutes.
Ready replicasBelow 100 percent of the desired count, over 5 minutes.

An HTTPS uptime check requests a public URL and is healthy on any 2xx. The URL must be the service’s own address or an active custom domain. The CLI example is https://api.example.com/health. A custom domain is Custom domain and HTTPS.

A metric window is 1 to 1440 minutes. The default is 5. Rules are evaluated every minute. Status is Healthy, Alerting, or Unknown when there is no data yet or the check could not run. Creating and editing rules requires the organization settings permission.

Metric alerts require Pro. The monitoring docs do not state a plan requirement for creating an HTTPS uptime check. This page does not add one.

Where an alert is delivered

A rule notifies when it starts alerting and again when it recovers. Every alert appears in the notification bell.

On Pro, the same alert can also go to the project channels: email to the organization owner, and a Slack-compatible webhook. That happens when Health alerts is on, under Project settings → Deploy notifications. Deploy notifications are not on Free. They are email and a Slack webhook on Pro.

Two notices need no rule. While Enable alerts is on for the organization, Unbroker alerts when a service goes down or starts crash-looping. Those built-in alerts use the bell, and on Pro they use the project channels when Health alerts is on.

What these alerts do not cover

They do not replace application-level telemetry or error tracking. The monitoring docs say that directly. An uptime check that returns 2xx does not show a slow query, a failed checkout, or a stack trace inside a 200 response.

Beacon is not this alert system. It is realtime pub/sub with at-most-once delivery, and it is not a durable queue. The note is Beacon reliability. A database symptom you then find in Postgres is Postgres in production.

How this works on Unbroker

Open Logs for stdout and stderr. Open Resources for the charts and the Alerts card. From the card you can pause, resume, run Check now, or delete a rule. New alert adds a resource metric or an uptime check.

From the terminal, the documented commands are:

ubctl monitoring ls
ubctl monitoring alert-create \
  --name high-memory \
  --service svc_123 \
  --metric memory \
  --compare above \
  --value 768 \
  --window 5
ubctl monitoring uptime-create --name public-api --url https://api.example.com/health
ubctl monitoring check mon_123
ubctl monitoring rm mon_123

768 and the name high-memory are the CLI page’s example. Metric names are cpu, memory, restarts, unhealthy, and ready_percent. The command reference is Monitoring commands. The HTTP routes are the monitoring API. Other ubctl commands are in Operate with ubctl.

A coding agent can run those commands only with a token that is allowed to. What that token must not see is Letting a coding agent deploy safely. The agent pages start at Coding agents.

Pro is $25 per month with $25 of usage credit. The credit does not roll over. If usage stays under the credit, the charge is still $25. Plan rows are on pricing and in Plans.

Checklist

  1. Read the build log, the runtime log, and the deployment that is actually live before you change capacity.
  2. Log a level with an explicit marker if you want the level filter to see it.
  3. Treat a gap in a metric line as missing data, not as zero.
  4. Turn on Enable alerts so the built-in down and crash-loop notices are active.
  5. Add an HTTPS uptime check only for a URL the service owns, including an active custom domain.
  6. If you add a metric rule, copy a documented example only as a starting label, then set the threshold for this service.
  7. On Pro, turn on Health alerts if email or a Slack-compatible webhook should fire.
  8. Keep error tracking for request failures. Do not treat a 2xx uptime check as that tracker.
  9. Use Pro for resource metrics and metric alerts. Runtime logs are also on Free.

FAQ

What should you monitor first on a new production service?

Start with the four signals: the build log, the runtime log, resource metrics, and deployment history. The monitoring docs' example rules are an HTTPS uptime check, container restarts above 3 over 5 minutes, and ready replicas below 100 over 5 minutes. Those numbers are examples, not a required set. Built-in down and crash-loop alerts need no rule while Enable alerts is on.

How long are runtime logs kept on Unbroker?

Runtime logs are kept for 7 days. Lines are collected about every 30 seconds. If one 30-second window has more than 5,000 lines or 2 MiB, the oldest lines in that window are dropped. Build output is kept with each deployment. Build output older than 90 days is removed, except for the deployment the service is currently running.

How do you get an alert when an app goes down?

Turn on Enable alerts. Unbroker then alerts when a service goes down or starts crash-looping, with no extra rule. An HTTPS uptime check is a separate rule: it requests a public HTTPS URL and is healthy on any 2xx. Every alert shows in the notification bell. Email and a Slack-compatible webhook are Pro channels, and only when Health alerts is on.

Can alerts go to Slack?

On Pro, yes, as a Slack-compatible webhook, when Health alerts is turned on under Project settings, Deploy notifications. The same switch covers email to the organization owner. The notification bell does not depend on that switch. Deploy notifications are not on Free.

Does Unbroker alert if a service crash-loops without a rule?

Yes, while Enable alerts is on for the organization. The down and crash-loop notices are built in. They use the bell, and on Pro they also use the project channels when Health alerts is on. A restarts rule is optional and is a metric alert, which requires Pro.

Are resource metrics and metric alerts on Free?

No. Resource metrics are part of Pro. Metric alerts require Pro. Runtime logs are available on Free and on Pro. The plans table lists deploy notifications, which carry email and the Slack webhook, as not available on Free.

What is the difference between an uptime check and a metric alert?

An uptime check requests a public HTTPS URL and is healthy on any 2xx. The URL has to be that service's address or an active custom domain. A metric alert compares CPU, memory, restarts, unhealthy pods, or ready replicas with a threshold over a window of 1 to 1440 minutes. The docs require Pro for metric alerts. They do not state a plan requirement for creating an uptime check.

Do platform alerts replace error tracking?

No. The monitoring docs say alerts help you notice a problem and do not replace application-level telemetry or error tracking. A 200 from /health does not prove a later request succeeded. Per-request errors, latency, and traces stay in the tracker you run.

How do you create an alert from the terminal?

ubctl monitoring ls lists rules. ubctl monitoring alert-create adds a metric rule. ubctl monitoring uptime-create adds an HTTPS check. ubctl monitoring check evaluates one now. ubctl monitoring rm removes one. The memory value 768 in the CLI page is that page's example, not a limit you must use. Managing rules requires the organization settings permission.