Skip to content

Logs · Errors · Traces

Logs, errors and traces. Live, in one place.

Pulsar streams every log to your browser the moment it is stored, groups errors automatically and draws each request as a waterfall across your services. Add one line to a Node.js, Next.js, pino or .NET app and watch it arrive.

Use our cloud, or run it yourself: one Node.js process and one SQLite file.

  • Free plan: 50,000 logs a day
  • No credit card
SDKs for
  • Node.js
  • Next.js
  • pino
  • .NET
or any HTTP client

Product

Everything production is telling you, in one tab.

Logs, error groups, traces, dashboards and alerts share one data model, so every view leads to the next: the alert opens the log, the log opens its trace, the trace shows where it failed.

Live tail

A live tail that keeps up.

New logs reach every open dashboard over Server-Sent Events as soon as they are stored, interleaved with your deploy markers. Filter by level, service and text, pause, page back in time or pick a range.

  • Keyboard first: / searches, j and k move, Enter opens
  • Each log opens with its request, stack trace, metadata and the lines around it
  • Deploy markers from CI line an error spike up with the release that caused it
The Pulsar Live Stream: KPI sparklines, filters and rows of logs from several services, each with its trace ID The Pulsar Live Stream: KPI sparklines, filters and rows of logs from several services, each with its trace ID

Error grouping

A hundred stack traces, one error group.

Errors are grouped by service and normalised message, with numbers and UUIDs stripped, and show a count, first and last seen, the latest stack trace and recent occurrences. Resolve or ignore a group to triage.

  • Your own frames stand out; library and Node.js frames fold away
  • Alert on one group, or on any error string such as ECONNREFUSED
The Pulsar Errors page: grouped errors with their services, and the detail panel of a database connection error The Pulsar Errors page: grouped errors with their services, and the detail panel of a database connection error

Distributed traces

Follow one request through every service.

Every trace gets its own page: the service path, where it failed, where the time went, and a waterfall of server, client, internal and queue spans. The SDKs continue W3C traceparent headers, so a checkout that crosses five services is one trace.

A Pulsar trace of a failed checkout: summary, service path, where it failed, where the time went, and the span waterfall across five services A Pulsar trace of a failed checkout: summary, service path, where it failed, where the time went, and the span waterfall across five services
The same trace waterfall on a phone
  • Where it failed

    The first error, its service and its offset, one click from the entry.

  • Where the time went

    The slowest span and its share of the trace. Long idle gaps are compressed so the work stays readable.

  • Made to share

    A /trace/<id> link, search inside the trace, an errors-only view and a JSON download.

Dashboards

Charts from your own fields.

Number, time-series and top-list widgets, each with its own filter: level, service, text or any metadata field.

A Pulsar dashboard with request count, error rate, p95 latency, request volume and error rate by service A Pulsar dashboard with request count, error rate, p95 latency, request volume and error rate by service

Alerts

Alerts that link straight to the log.

Slack, Discord, ntfy or any webhook, when logs match a level, cross a count in a time window or belong to an error group. Rules are throttled, testable from the UI, and every delivery is recorded.

The Pulsar alert rule editor: a count-over-window rule on checkout-api errors, posting to a webhook The Pulsar alert rule editor: a count-over-window rule on checkout-api errors, posting to a webhook

Also in the box

  • Service health: volume, error rate, p95 and p99
  • Command palette: Ctrl K, or ⌘K on macOS
  • Light and dark themes
  • Layouts that work down to a 375 px phone

Setup

Ready in three steps.

No agent, no sidecar, no collector to run. The SDKs batch, retry and never block your app.

  1. Install the SDK

    One package from npm, NuGet for .NET, or nothing at all with curl.

  2. Add one line

    Point it at Pulsar with your API key. You get one when you sign up.

  3. See logs live

    Open the Live Stream and watch them arrive, each request with its own trace ID.

Full SDK reference on npm:

Install

shell
npm install @fabbahiense/pulsar-node

Configure

server.ts
import { Pulsar } from '@fabbahiense/pulsar-node'

Pulsar.init({
  url: process.env.PULSAR_URL!,
  apiKey: process.env.PULSAR_API_KEY!,
  serviceName: 'checkout-api',
  interceptConsole: true,
})

app.use(Pulsar.middleware({ autoLog: true })) // one trace per request

console.log('Order received') // sent with the request's trace ID

Express-compatible middleware. console.log, console.warn and console.error are captured with the trace ID of the request they ran in.

Pricing

Start free. Upgrade when it matters.

Live tail, error groups, traces and dashboards are on every plan. Pro lifts the limits and opens every alert channel.

Free

For side projects and for trying Pulsar

R$0/month

Start free

Every feature, with:

  • 50,000 logs per day
  • Retention: 1 day for info and below, 3 days for warn, and 5 days for error and fatal
  • 1 alert rule, webhook only
  • 1 workspace

No credit card

For production

Pro

For teams running production

On request

Talk to us

Everything in Free, plus:

  • No daily log cap
  • 30-day retention for every level
  • Unlimited alert rules on Slack, Discord, ntfy, and webhooks
  • Unlimited workspaces

Billing in reais via Pix: coming soon.

Hosting

Our cloud or your server. Same Pulsar.

The dashboard, the SDKs and the API are the same wherever Pulsar runs.

Pulsar Cloud

We run it for you. Sign up, copy your API key and start sending logs: the SDK is the only thing you install.

  • Live in minutes
  • Free plan, no card
  • Pro limits when you need them
Start free

Self-hosted

One Node.js process and one SQLite file on your own machine: no queue, no cache server, no external database. Your logs stay on your network.

  • Node.js 20 or newer, behind an HTTPS reverse proxy
  • A CSP-ready build: script-src 'self' works as is
  • Backups with one sqlite3 command

Self-hosting is licensed separately.

Talk to us

Security and reliability

Careful by default.

Anyone holding an ingest key controls what a log says, so Pulsar treats log data as untrusted from the SDK to the screen.

  • SSRF-hardened webhooks

    Alert targets must be public addresses. That is checked when a rule is saved, then again on the connection itself, after DNS resolution and on every redirect, so DNS rebinding cannot reach your network.

  • Redaction by default

    Passwords, tokens, API keys, cookies and Authorization headers are redacted from captured headers and bodies, at any depth, by every SDK middleware. Add your own keys with redactKeys.

  • Tenant isolation

    Every query is scoped to the workspace of the API key or session, and another workspace’s IDs answer 404. API keys are stored as SHA-256 hashes and shown once.

  • Retries without loss

    The SDKs retry 429s, 5xx and timeouts with backoff, honour Retry-After and resend the exact same batch, up to 10 times by default. The server deduplicates by entry ID, so a retry never stores a log twice. Buffers are bounded, and anything finally dropped is counted and reported, never silent.

FAQ

Questions, answered.

What counts toward the daily log limit?

Each stored entry counts once: a logger call, a console line, a request entry or a JSON object. A batch of 200 entries is 200 logs. Duplicates from retries and rejected entries do not count, and the counter resets at 00:00 UTC.

What happens when the Free plan’s limit is reached?

Ingest answers 429 until the counter resets at 00:00 UTC. The SDKs retry, then drop and report what they could not deliver. Logs already stored are untouched.

Do I have to change my logging code?

Usually not. Node.js apps can keep calling console.log, pino gets a transport, .NET plugs into ILogger, and anything else can POST JSON. Pulsar understands pino, pino-http and most structured-logger field names.

Is it OpenTelemetry?

No. Pulsar’s SDKs propagate W3C traceparent, so traces flow across your services and an upstream sampling decision is passed on untouched, but Pulsar does not accept OTLP data.

Where is my data kept, and for how long?

On Pulsar Cloud, on our servers, for your plan’s retention (up to 5 days on Free, 30 days on Pro), after which a daily job deletes it. Self-hosted, in one SQLite file on your own server.

How does billing work?

The Free plan needs no card. For Pro, talk to us. Billing in reais via Pix is coming soon.

Are the SDKs open source?

Yes, under the MIT license. The JavaScript SDKs are on npm; the .NET packages are built and tested in CI but not on nuget.org yet. The Pulsar server itself is proprietary.

Can I run Pulsar on my own server?

Yes: Node.js 20 or newer, one SQLite file and an HTTPS reverse proxy, with no other infrastructure. Self-hosting is licensed separately; talk to us.

Your next incident, already traced.

Create a workspace, copy your API key and send a first log. It takes a couple of minutes.