Vight

Flat-priced OpenTelemetry APM

One investigation surface from spike to root cause.

Vight keeps services, traces, database calls, runtime signals, and deploy context in the same flow so teams can move from symptom to cause without rebuilding dashboards.

Start your workspaceRead docsSee it work

Why Vight

Your incident lives in five tabs.

The error spiked inSentry

The trace is inTempo

The GC pause is inApp Insights

The deploy that caused it is inGitHub

So we built one surface to bring them together — services, traces, database calls, runtime, and deploy context, stitched into one investigation.

So you can see what changed, why it changed, and what to roll back — without tab-hopping at 2am.

What you get

An APM that stops at the cause.

Four product decisions that change how investigation feels. Everything else on this page is downstream of these four.

  • 01

    Investigation, not dashboards.

    Vight opens at the regression and walks you to the cause. You don't build dashboards to find what changed — the product already did.

  • 02

    Runtime signals on the trace.

    GC pauses, worker thread saturation, allocations, and p99 sit on the same screen as the trace that triggered them.

  • 03

    OpenTelemetry-native ingest.

    Send OTLP from any service, any runtime, any collector. No custom agent to install per host, no proprietary schema.

  • 04

    Hosted, ready in minutes.

    Sign up, send telemetry to Vight, and start investigating. Your team ships features instead of running another observability platform.

01 — Service map

See the dependency that broke before the page does.

Every edge carries request rate and error % from OpenTelemetry spans. The slow edge tells you which downstream is owning the spike, not just that there is a spike.

  • Live request rate per edge
  • Error rate and p99 on hover
  • Version-aware so you can blame a deploy
Get started
Services / production
slow pathlive
web-apiv22.1 · p99 510msauth-apiv18.0 · 12k rpmcheckout-apip99 412ms · 0.94%catalog-apiv21.4 · 4.1k rpmbilling-apiv22.1 · p99 740msnotify-workerv9.2 · RabbitMQredis-cache9.1k rpm · 0.4msstripe-apiext · p99 980mspostgres-primarySELECT orderspostgres-replica16k req · -12k req · 0.41%1.1k req · 2.4%1.3k req · 1.2%3.6k req · 1.1%3.6k req · -3.6k req · -0.4k req · -8.2k req · 0.10%1.3k req · -
Trace 4f7d9c · /checkout
2 slow spans5m ago
0ms200ms400ms600ms800ms
dur
  • GET /checkout
    813ms
  • auth.validate
    32ms
  • cart.load
    64ms
  • redis.GET cart:9213
    12ms
  • catalog.priceList
    88ms
  • postgres.SELECT items
    74ms
  • billing.authorize
    +214ms
    410ms
  • stripe.charge
    360ms
  • http.POST api.stripe.com
    320ms
  • order.write
    102ms
  • postgres.INSERT orders
    80ms
  • response.send
    78ms
slow spanstripe.charge+280ms vs baseline · p99 980ms · last 1h
context
Service
billing-api
Version
v2026.05.22.1
Host
billing-7f9c · eu-west-1
Runtime
.NET 9.0.4 · GC gen2
Endpoint
POST /v1/charges
Worker
thread-pool 248/256
Region
eu-west · stripe-eu
Deploy
12m ago · team-payments

02 — Trace waterfall

Open the slow span with its context already attached.

Spans carry version, endpoint, worker, and resource attributes. Click the slow span and the runtime and dependency are already there.

  • Per-span runtime context
  • Highlight regressions vs baseline
  • Jump to the originating service
Get started

03 — .NET runtime

The runtime view your APM forgot to ship.

GC pauses, worker threads, allocations, p99 — all in one panel keyed to the same trace and version. Deep .NET runtime signals today; OTLP metrics for everything else.

  • GC gen0/1/2 pauses correlated to spans
  • Worker thread saturation timeline
  • Allocations per second + LOH spikes
  • p99 latency aligned to deploy markers

GC pauses

gen0gen1gen2
84msmax
3 collections · last 5m
max84ms
aligned to deployv2026.05.22.1last 5m · 10s buckets

Worker threads

usedpool
248/ 256 · 96% saturation
rising · last 60s
aligned to deployv2026.05.22.1last 5m · 10s buckets

Allocations / sec

allocLOH
+38%vs baseline
LOH spike at 02:14
baseline
aligned to deployv2026.05.22.1last 5m · 10s buckets

p99 latency

p99baselinedeploy
510msbaseline 280ms
+82% vs last deploy
280ms baselinedeploy v22.1
aligned to deployv2026.05.22.1last 5m · 10s buckets
Regressions · last 24h
2 high2 medium2 info
  • HIGH
    high severity
    checkoutp99 +214ms
    Latency climb after deploy
    12m agotrace 4f7d9c
  • HIGH
    high severity
    billing-api2.41% error rate
    5xx from stripe.charge
    14m agotrace 0c19aa
  • MED
    medium severity
    catalogallocations +38%
    Hot path allocating per request
    32m agotrace b773ef
  • MED
    medium severity
    authworker saturation
    Pool 248/256 used
    1h agotrace 91a204
  • INFO
    informational
    redis-cachemiss rate +6%
    Cache warming after restart
    2h agotrace 4d8a17
  • INFO
    informational
    postgres-replicalag 220ms
    Replication lag, recovered
    3h agotrace ee0721

04 — Regressions

A feed of what actually changed.

Vight scores p99, error rate, and runtime metrics against baseline and surfaces only regressions worth opening. Each row links to the trace that explains it.

  • Baseline-aware scoring
  • Auto-grouped by service + version
  • One-click into trace context

Integrations

Standards in. Investigation out.

If your services emit OpenTelemetry, Vight reads them. Deeper surfaces light up automatically when the standard runtime attributes are present.

  • OpenTelemetry
  • .NET
  • ASP.NET Core
  • Kestrel
  • PostgreSQL
  • Worker services
  • gRPC
  • HTTP client
  • RabbitMQ
  • SQL Server
  • Entity Framework
  • OTLP collector

Anything OpenTelemetry-compliant works. .NET surfaces are the deepest today.

Setup

Three steps. OTLP in.

Point an OpenTelemetry exporter at Vight, name your service, deploy. No per-host agent, no proprietary schema — live in under five minutes.

New workspace

Service name

checkout-api
Keyvgt_8f2a4c
01

Create a workspace

Sign up and grab an ingest key. No agent to install, no host to provision.

Program.cs
.AddOtlpExporter(o => 
{
    o.Endpoint = new Uri(
        "https://ingest.vight.io");
    o.Headers  = 
        "x-vight-ingestion-key=vgt_8f2a4c";
});
02

Add the OTLP exporter

Point OpenTelemetry at Vight and name your service. .NET surfaces the most — any OTel SDK works.

Services / production
3 services livelast 1m
checkout-api
payments-worker
catalog-api
03

Deploy

Ship it. The service map and traces light up within a minute.

Start your workspace

Your endpoint and key are on the Ingest keys page. Any OpenTelemetry SDK works — .NET runtime signals go deepest.

How it compares

Built for the teams the big tools price out.

Datadog and New Relic are broader and more mature. Vight is for teams who want the investigation flow and a predictable bill — not every integration under the sun.

VightPer-host APMsDatadog, New RelicRoll your ownGrafana + Tempo + Prom
PricingFlat workspace pricing — your bill doesn't move with traffic.Per-host + per-GB. Scales with your worst day.Free software; you pay in infra + time.
SetupPoint OTLP at us. Live in minutes, no per-host agent.Install and maintain an agent on every host.Stand up Tempo / Prometheus / Grafana, then operate it.
InvestigationOpens at the regression and walks you to the cause.Powerful — but a lot to assemble and tune.Build the dashboards before you can find anything.
.NET runtimeGC pauses, threads, allocations sit on the trace.Deep, at a price. App Insights is shallower.Wire up runtime metrics yourself.
Who operates itWe run ingest and storage.They host it.You host the thing that watches your other things.

Everything

Everything in every workspace.

One surface, one bill — no add-ons, no higher tier to unlock.

Investigation & flow

  • Live service map
  • Trace waterfall
  • Regression feed
  • Baseline-aware scoring
  • Deploy-aware edges
  • One-click trace context
  • Slow-span drilldown
  • Error rate + p99 on hover
  • Blame a deploy by version

.NET runtime

  • GC gen0 / 1 / 2 pauses
  • Thread-pool saturation
  • Allocations + LOH spikes
  • p99 aligned to deploys
  • Runtime on the trace
  • Worker-thread timeline
  • Per-span runtime context
  • Endpoint + worker attributes

Telemetry & ingest

  • OTLP over HTTP + gRPC
  • Any OpenTelemetry SDK
  • No per-host agent
  • Collector-friendly
  • ASP.NET Core & Kestrel
  • EF Core & PostgreSQL
  • gRPC & HTTP client
  • RabbitMQ & SQL Server

Platform & pricing

  • Hosted & managed
  • Flat workspace pricing
  • Unlimited viewers
  • Included telemetry
  • Raw + rollup retention
  • Multiple projects
  • No bill shock on spikes
  • Dogfooded in production

Pricing

Flat pricing. No per-host math.

Workspace pricing with included telemetry and unlimited viewers. Your bill doesn't jump when traffic spikes.

  • Starter

    $29/mo, flat

    Everything included · up to 25M events / mo

    • 25M events / mo included
    • Unlimited projects
    • Unlimited services
    • 7-day raw retention
    • 90-day rollups
    • Unlimited viewers
    • OTLP-native — no per-host agent
    Start 14-day free trial
  • Most popular · Founding rate

    Growth

    $149/mo, flat

    Everything included · up to 500M events / mo

    • 500M events / mo included
    • Unlimited projects
    • Unlimited services
    • 30-day raw retention
    • 395-day rollups
    • Unlimited viewers
    • OTLP-native — no per-host agent

    Founding workspaces — first 100, 20% off, locked in forever

    35 left at this rate · then full price

    Start 14-day free trialLock the founding rate

  • Scale

    $499/mo, flat

    Everything included · up to 2B events / mo

    • 2B events / mo included
    • Unlimited projects
    • Unlimited services
    • 90-day raw retention
    • 730-day rollups
    • Unlimited viewers
    • OTLP-native — no per-host agent
    Start 14-day free trial

14-day free trial · cancel anytime

Bigger or dedicated? Scale is custom — talk to us.

Pricing Calculator

Vight vs Datadog vs New Relic

Slide to your monthly events, hosts, and team size. Same telemetry, a fraction of the bill.

250M
100k5B
10
150
5 engineers
125

Monthly events: 250M · Hosts: 10 · Team: 5 engineers

  • 🏆 Cheapest

    Vight

    $1,428/yr

    every feature included

  • Datadog APM

    $4,536/yr

    Vight is 69% cheaper

  • New Relic

    $5,621/yr

    Vight is 75% cheaper

At 250M events/mo across 10 hosts, Vight is up to 75% cheaper than the per-host APMs — for the same telemetry.

Start your workspace

14-day trial · every feature on every plan

Estimated from published list pricing — Datadog and New Relic pricing pages, verified 2026-07-01. Assumes ~1 KB/event, ~20% of spans indexed/retained (Datadog retention-filter norm — indexing all spans costs more). New Relic seats at Standard $99/user (teams over 5 users move to Pro at more); Datadog per-host; Vight flat with unlimited users. Datadog APM only (per-host + spans). Your negotiated quote may differ.

FAQ

Questions teams ask first.

The things teams check before sending telemetry to Vight.

Still curious?support@vight.io
Do we have to use a custom agent?

No. Send OTLP straight from your services or via any OpenTelemetry collector. Vight is the receiver and the surface, not an agent you install per host.

Where is Vight hosted?

Vight is a hosted service. Send telemetry to Vight and use the product surface without operating another observability platform.

What about non-.NET services?

They show up in the map, traces, and metrics views immediately. The deeper runtime surface goes deepest for .NET today and will broaden as runtime conventions mature in OpenTelemetry.

What does it cost?

Early access uses flat APM workspace pricing with included telemetry and unlimited viewers. We don't price per host or auto-scale your bill when traffic spikes.

What does setup look like?

Sign up, point your OTLP endpoint at the Vight ingest URL, set a service name, deploy. The service map and traces light up within a minute.

How does this compare to building dashboards in Grafana?

Grafana is good when you already know what to look at. Vight opens at the regression and walks you to the cause without a dashboard-building step.

Open Vight

Inspect the product surface.
Decide from evidence.

The map, the trace, and the runtime — already opened on the things that changed.

Start your workspaceInspect traces
Dogfooded in production

Vight runs on Vight. Our own services are monitored by the product you're looking at — we catch our spikes the way you'll catch yours.