Meteor APM, done right

The modern APM built for Meteor 2 & 3

Methods, publications, MongoDB, jobs, outbound HTTP, app logs — and the only APM that surfaces your LiveQuery driver mix and observer leaks in real time. Drop in one Atmosphere package and watch the slowest method on your app appear in 30 seconds.

Method P95 — last 24h
users.signIn184 ms
Publication latency — projects

DDP messages, observers, and ready time.

Built natively for Meteor

Method timings

Avg, P95, P99, error rate, and call-volume per method — searchable, sortable, and grouped by route.

Publications & subscriptions

Time to ready, error rate, and — on Meteor 3.6 — how long clients stay subscribed to each publication, including this.error() failures.

Reactive observabilityNew

Live LiveQuery driver mix per collection — change_stream vs oplog vs polling — with reactive efficiency scoring no other Meteor APM surfaces.

Observer leak detectionNew

Catch growing observer counts, stale subscriptions, and orphaned multiplexers — the quiet killer of long-running Meteor servers.

Mongo + connection pool

Per-collection P95, slow-query fingerprints, and live connection-pool tracking with wait-queue alerts. Without enabling the profiler.

Background jobsNew

sjobs and compatible queues auto-instrumented. Job latency, error rates, and per-name trends in the same UI as your methods.

Outbound HTTPNew

Every fetch() and HTTP.call instrumented automatically. Find the slow third-party API in seconds — no manual spans.

App logs in one placeNew

console.*, Meteor Log, and a structured addLog() API — searchable, level-filtered, and correlated with your traces.

End-to-end traces

Method → Mongo → external API spans, including Fibers and async/await. Find the slow span in seconds.

Event loop lag

If your event loop stalls, every method is slow. We surface lag spikes alongside method timings so the cause is obvious.

Built-in uptime

Multi-region HTTP(s) checks. No second tool, no extra invoice — alerts share the same channels as your APM.

Hosted status pages

Branded incident pages with auto-updates, custom domains, and subscriber notifications.

Meteor 3.6 InstrumentationNew

Built on Meteor 3.6’s official instrumentation package: live DDP connections, methods in flight, hung-method detection, and one trace ID across logs and outbound HTTP.

Drop it into your app. Ship.

One Atmosphere package, three lines of config — that's it.

Two keys, two scopes. The uc_srv_ server key stays on the server. The uc_pub_ public key is safe to ship to browsers — it only accepts RUM events from origins you allow-list.

1. Install
meteor add uptimeclarity:agent
2. settings.json
settings.json
{
  "private": {
    "uptimeClarity": {
      "serverKey": "uc_srv_xxxxxxxxxxxxxxxx"
    }
  },
  "public": {
    "uptimeClarity": {
      "clientKey": "uc_pub_xxxxxxxxxxxx",
      "appName": "my-app"
    }
  }
}
3. Server init
server/main.js
// server/main.js
import { Meteor } from 'meteor/meteor';
import { UptimeClarity } from 'meteor/uptimeclarity:agent';

Meteor.startup(() => {
  UptimeClarity.start({
    // private settings — never reach the browser
    apiKey: Meteor.settings.private.uptimeClarity.serverKey,
    appName: Meteor.settings.public.uptimeClarity.appName,
  });
});
4. Client init (RUM)
client/main.js
// client/main.js
import { Meteor } from 'meteor/meteor';
import { UptimeClarity } from 'meteor/uptimeclarity:agent';

Meteor.startup(() => {
  UptimeClarity.start({
    // public settings — safe to ship to the browser
    clientKey: Meteor.settings.public.uptimeClarity.clientKey,
    rum: {
      pageTiming:    true, // navigation + paint timing (LCP, FCP, TTFB)
      longTasks:     true, // > 50ms main-thread blocks
      blazeRender:   true, // Blaze template render + layout timing
      methods:       true, // Meteor.call latency & errors
      subscriptions: true, // pub/sub ready time + payload size
    },
  });
});
5. Run with settings
meteor run --settings settings.json
Migrating from Monti APM (Kadira)?

Same mental model, modern foundations

Methods, publications, traces — every concept maps cleanly. Plus uptime monitoring, status pages, and Meteor 3 async support out of the box.

See comparison

Pricing for Meteor teams

Start free. Most teams land on Pro for MongoDB insights and longer retention.

Free
$0
forever
  • 25K events / day
  • 7 day retention
  • 5 uptime monitors (5-min checks)
  • 1 status page
  • Up to 100 email alerts / month
  • Up to 100 webhook alerts / month
  • No credit card required
Start Free
Starter
$19
/month
  • 250K events / day
  • 14 day retention
  • 25 uptime monitors (1-min checks)
  • 5 status pages
  • 1,000 email + 1,000 webhook alerts / month
  • Slack alerts included
  • Up to 3 team members
Start 14-day Trial

Meteor APM FAQ

Do you support Meteor 3.6’s instrumentation package?
Yes. Add it with `meteor add instrumentation` and agent 1.7.0+ picks it up automatically: subscription lifetimes, this.error() publication errors, hung methods, DDP connection lifetimes, and trace IDs across logs and outbound HTTP. We never change your capture settings, so arguments, results, and client IPs stay off unless you turn them on. Live connection and subscription counts work on every Meteor version.
Do you support Meteor 3?
Yes — Meteor 3 was a fundamental rewrite (Fibers → native async). UptimeClarity was built from day one to instrument the new async runtime correctly. Meteor 2.x is fully supported alongside it.
What does “reactive observability” actually mean?
We sample your LiveQuery state every 30 seconds and report which driver each observer is using (change_stream, oplog, or polling) per collection — plus a reactive efficiency score. We also detect leaking observers (growing counts, stale subscriptions, orphaned multiplexers) and your MongoDB connection-pool health, all on one page. As far as we know, no other Meteor APM does this.
Will it work with Galaxy?
Yes. The agent runs as part of your Meteor app, so any host (Galaxy, Cloud Run, Fly, your own Kubernetes) works the same.
How is this different from Monti APM (Kadira)?
Monti APM is a respected tool that has powered Meteor monitoring for years. UptimeClarity is built for Meteor 3’s native async runtime and adds reactive observability, observer leak detection, MongoDB pool tracking, background-job timing, outbound HTTP instrumentation, app logs, custom metrics, uptime, and hosted status pages — in the same dashboard. See the side-by-side comparison for details.
What is the performance overhead?
Under 1% CPU in typical Meteor workloads. The agent batches and samples internally, never blocks your event loop, and ships data over a non-blocking HTTPS channel.
Do I need to instrument my app manually?
No. Adding the package automatically wraps Meteor methods, publications, the DDP layer, MongoDB, fetch / HTTP.call, sjobs, and console / Meteor Log. You can opt out per category in config. A one-line `UptimeClarity.metric()` API is also available for custom timings.
Can I self-host the data?
Not today — UptimeClarity is a fully managed SaaS so we can move quickly on Meteor-internals changes. If self-hosting is a hard requirement, contact sales.

The Meteor APM your team deserves.

Join developers who ship with confidence. Free forever plan, no credit card required, set up in under a minute.