Skip to content
logmast
Request access
ProductPricingSecuritySign inRequest access

Every log collected. Every failure understood.

Logmast gathers logs from all your services, turns the noise into grouped failures you can actually read, and tells you when a service stops being healthy. No observability platform to run.

Request pilot accessSee how it works
p95 from send to a committed receipt
18 ms
p95 from send to a committed receipt
p95 until a new event is searchable
80 ms
p95 until a new event is searchable
events queried on a 2 CPU, 2 GiB instance
12M
events queried on a 2 CPU, 2 GiB instance
events lost across 13,200 sent under load
0
events lost across 13,200 sent under load

From raw lines to a clear answer

Three jobs, done in one place, in the order your data actually moves.

  1. 1. Collect

    Send logs the way you already write them

    Drop in the Rust layer or post JSON batches over HTTPS. Every batch is committed to disk before we say yes, and retries never double count.

  2. 2. Process

    Turn thousands of lines into a few real problems

    Events are redacted, grouped by error code, cause or stack, and indexed for search. Each group explains exactly why its events belong together.

  3. 3. Monitor

    Know when a service is unwell

    HTTP checks and job heartbeats sit beside your failures, and alerts arrive once, with context, instead of flooding your inbox.

See your whole system, not one app at a time

Browse by workspace, project and service. The portfolio view puts what needs attention first, with an hourly histogram so a spike is obvious before you open a single log.

Filters live in the URL, so the view you are looking at is the link you paste into the incident channel.

Grouping you can check

Most tools group errors behind a black box. Logmast shows its reasoning: fingerprint, rule, error code and cause, stack, then message, and which one decided.

Add namespaced codes like BILLING.INVOICE.PERSIST_FAILED as you go. Uncoded failures still group well from day one.

Quiet the noise without losing it

Mute a known issue with a reason and an expiry date. Before you confirm, Logmast replays the mute against recent history and shows exactly what would go quiet.

Muted events are still collected and searchable. Acknowledging a problem and silencing it are kept as separate decisions.

Alerts with a budget

Get an email on the first occurrence of something new, or when a group crosses ten events in five minutes. Cooldowns stop repeats, and a workspace budget caps email per hour.

When the budget runs out, the last message is a summary of everything held back, so a bad hour stays one readable email.

Health checks that sit next to the evidence

Point Logmast at an endpoint or give a cron job a heartbeat URL. When a check fails, the alert links straight to the failures that service logged in the same minutes.

Ten minutes to your first alert

Instrument one service, send an event, and receive a test alert before your coffee cools.

  1. 1

    Create a service token

    Ingest-only, scoped to one service, revocable any time.

  2. 2

    Add the layer or call the API

    Rust gets a tracing layer with a bounded background queue. Everything else speaks HTTPS and JSON.

  3. 3

    Send a test failure

    It appears, grouped and searchable, within a second, and your alert rule fires.

let config = logmast_reporting::Config::from_env()?.expect("LOGMAST_* set");
let (layer, _guard) = logmast_reporting::start(config)?;

tracing_subscriber::registry()
    .with(tracing_subscriber::fmt::layer())
    .with(layer)               // batches, redacts and ships in the background
    .init();

// Anything you already log at warn or above is collected.
tracing::error!(code = "BILLING.INVOICE.PERSIST_FAILED", invoice_id, "could not persist invoice");

// Or report a typed error with its cause chain and a correlation id.
logmast_reporting::report_error(&err, Some("BILLING.INVOICE.PERSIST_FAILED"), None, "invoice.persist", Some(&request_id));

200 OK in 18 ms, committed to disk

{ "receipt_id": "0192f3…", "new_events": 1, "duplicates": 0 }

Built to be trusted with production data

Logs carry customer details, secrets that slipped through, and the shape of your business. We treat them that way.

How we protect your data
Isolated by workspace
Every read and write runs inside a transaction scoped to one workspace, enforced by PostgreSQL row-level security, not by application code alone.
Redacted before storage
Sensitive fields are stripped on arrival. What is never written can never leak from a backup.
Narrow credentials
Services get ingest-only tokens. People sign in with a password and TOTP. Tokens rotate and revoke without redeploys.
Safe to retry
Duplicate deliveries are recognised for 14 days, so a producer can resend after a timeout without double counting.

A bill you can predict

Plans include an event allowance and a clear retention period. No charge per seat or per service. A spend cap is on by default, and we tell you well before you reach it.

Compare plans

  • Starter

    $19/mo

    500k / month events

    14 days retention

  • Team

    $79/mo

    5M / month events

    30 days retention

  • Scale

    $299/mo

    25M+ / month events

    90 days retention

Send your first logs this week

We are onboarding a small number of teams by hand. Tell us what you run and we will help you instrument the first service.

Request pilot accessSign in