OpenTelemetry

Frontend observability die werkt

99,9% uptime betekent niet dat 99,9% van je gebruikers een goede ervaring had. Een trage checkout-flow voor iOS-gebruikers in Duitsland kost duizenden euro's aan gemiste omzet. Zie precies wat er misgaat, voor wie, en waarom.

Monitoring vertelt je WANNEER. Observability vertelt je WAAROM.

Traditionele monitoring is als een storingslampje. Het vertelt je dat er iets mis is ("Hoog foutpercentage"), maar het vertelt je niet waarom het gebeurt of wie er last van heeft.

Je hebt meer nodig dan rode lampjes. Je moet weten dat de regressie alleen optreedt bij gebruikers op iOS 18 die 3 producten in hun winkelwagen hebben. Dat is het verschil tussen gokken en oplossen. Lees meer over frontend observability.

Monitoring (Het "Wat")
[ERROR] 14:02:05 - API Timeoutstatus: 500 Internal Server Errorpath: /api/checkoutregion: eu-west-1

Het probleem: "Checkout is kapot."
Maar waarom? Is het de database? De payment gateway? Een bug in de code? Je bent 4 uur aan het zoeken.

Observability (Het "Waarom")
Trace ID: 7a92b...span: checkout_payment_processerror: 3rd_party_timeout (Stripe)user_agent: Mobile Safari (iOS 18)

De oplossing: "Stripe geeft timeouts voor iOS 18-gebruikers."
Je weet precies waar je moet kijken. Je escaleert naar de partner-API of deployt een fallback binnen minuten.

Problemen die observability blootlegt

Issues die onzichtbaar zijn voor traditionele monitoring, maar echte omzet kosten.

Verborgen
10%
"Shop the Look" faalt
1 op 10 gebruikers, specifiek apparaat
Geblokkeerd
3,2s
Apple Pay-knop vertraagd
SDK-probleem blokkeerde checkout
Stil
800ms
Vertraging zoekinteractie
Alleen tablets, engagement kelderde
Wisselvallig
iOS 18
Betaalgateway-fouten
Versie + provider-combinatie

Deze problemen raken kleine gebruikerssegmenten, maar hebben een buitenproportionele impact op je omzet. Traditionele monitoring toont gezonde gemiddelden terwijl deze problemen stilletjes duizenden euro's per maand kosten.

Productie-klare observability in dagen, niet maanden

Wij nemen de complexiteit uit handen. Jij krijgt een beproefde pipeline die privacy respecteert, meeschaalt met verkeer en vanaf dag één inzichten levert. Nieuw met observability?

01

Zie wat gebruikers echt ervaren

Weet welke checkout-flows traag zijn, welke knoppen niet reageren en welke fouten conversies blokkeren -- met volledige apparaat-, browser- en netwerkcontext.

  • Core Web Vitals herleid tot specifieke bronnen
  • Gefaalde API-calls met volledige requestdetails
  • JavaScript-fouten met context van de gebruikersreis
02

Volg requests van begin tot eind

Volg een enkele gebruikersactie van browserklik door je volledige backend-stack. Zie precies waar tijd wordt besteed en waar fouten optreden.

  • Frontend → API → database → response in een overzicht
  • Vind trage queries die gebruikersinteracties blokkeren
  • Identificeer welke third-party scripts vertragingen veroorzaken
03

Stel elke vraag over je data

Geen vooraf berekende dashboards. Query op elke combinatie: apparaat + regio + winkelwagenwaarde + feature flag + gebruikerssegment. Vind de speld in de hooiberg.

  • "Toon trage checkouts voor iOS-gebruikers in Frankrijk"
  • "Welke browsers hebben hoge foutpercentages?"
  • "Correleert LCP met conversieratio?"
04

Productie-klaar vanaf dag één

Wij configureren privacycontroles, samplingstrategieën en retentiebeleid op basis van jouw eisen. AVG-compliant en klaar voor Europese klanten.

  • Persoonsgegevens automatisch verwijderd uit traces
  • Adaptieve sampling om kosten te beheersen
  • EU-dataresidentie beschikbaar

⚡ Performance-impact

Onze instrumentatie is ontworpen voor productieomgevingen:

  • Minimale overhead - draait asynchroon
  • Niet-blokkerend - vertraagt nooit gebruikersinteracties
  • Adaptieve sampling - schaalt mee met verkeer
Frontend observability trace met gebruikersinteracties en performancelagen

Waarom OpenTelemetry-gebaseerde observability?

Niet alle observability-oplossingen zijn gebouwd voor moderne frontend-uitdagingen. Zo verhouden verschillende aanpakken zich tot elkaar.

OpenTelemetry-gebaseerd
Traditionele APM
GA4 + Sentry
High-cardinality queries
Query op elke dimensie
~ Vaak vooraf geaggregeerd
~ GA4: Beperkt
Sentry: Goed voor errors
Frontend-naar-backend traces
Native ondersteuning
~ Verschilt per leverancier
Losse systemen
Instrumentatiestandaard
OpenTelemetry (leverancier-neutraal)
~ Vaak proprietary
~ Mix van standaarden
Uniform datamodel
Performance + fouten + businesscontext
~ Gericht op technische metrics
GA4: marketing
Sentry: alleen errors
Implementatie-aanpak
Wij richten het in en configureren
~ Self-service of consulting
Snelle self-service setup
Vendor lock-in
Geen - vrij wisselen van backend
Proprietary agents
~ Platformafhankelijk
AI-gestuurde analyse
Via backend (Honeycomb, Grafana Machine Learning)
Ingebouwd (Dynatrace Davis AI)
~ Beperkt tot error-groepering
Het beste voor
Omzetkritische apps die diepe debugging nodig hebben
Backend-zware architecturen
Marketinganalytics + basis error tracking

Eenvoudige integratie, krachtige inzichten

Werkt met React, Next.js, Vue en elk modern JavaScript-framework. Zo ziet de implementatie eruit.

Next.js / React
// app/layout.tsx or _app.tsx
import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
import { getWebAutoInstrumentations } from '@opentelemetry/auto-instrumentations-web';
import { registerInstrumentations } from '@opentelemetry/instrumentation';

const provider = new WebTracerProvider();
provider.register();

registerInstrumentations({
  instrumentations: [
    getWebAutoInstrumentations({
      '@opentelemetry/instrumentation-fetch': {},
      '@opentelemetry/instrumentation-xml-http-request': {},
    }),
  ],
});

export default function App({ Component, pageProps }) {
  return <Component {...pageProps} />
}
Custom events tracken
// Checkout-flow performance tracken
import { trace } from '@opentelemetry/api';

function CheckoutButton() {
  const handleCheckout = async () => {
    const tracer = trace.getTracer('checkout');
    const span = tracer.startSpan('checkout.initiated');

    span.setAttribute('cart.items', cartItems.length);
    span.setAttribute('cart.value', totalValue);
    span.setAttribute('user.segment', userSegment);

    try {
      await processPayment();
      span.setStatus({ code: SpanStatusCode.OK });
    } catch (error) {
      span.recordException(error);
      span.setStatus({ code: SpanStatusCode.ERROR });
    } finally {
      span.end();
    }
  };

  return <button onClick={handleCheckout}>Betalen</button>;
}

Dat is alles. Je ziet nu elke checkout-poging met volledige context: welke producten, welke waarde, welk gebruikerssegment, en of het gelukt is of niet. Query op elke combinatie in je observability-platform.

Wat engineering teams zeggen

"Voordat we observability implementeerden, waren we dagenlang bezig om logs uit 6 verschillende tools te correleren. Nu zien we de volledige gebruikersreis in een enkele trace. De tijd om bugs op te lossen ging van dagen naar uren."

Senior Engineer, Reisboekingenplatform

"We ontdekten een payment gateway-timeout die alleen Samsung-apparaten op traag 3G trof. Onze oude APM liet '99,8% succesvol' zien en we hadden nooit geweten dat we maandelijks €40K aan omzet misliepen."

CTO, Fashion E-commerce

"Het Iron/Out-team heeft niet alleen de tooling opgezet. Ze leerden ons welke metrics echt belangrijk zijn voor ons bedrijf. Nu is ons frontend-team eigenaar van performance, net zoals het backend-team eigenaar is van uptime."

VP Engineering, B2B SaaS

Veelgestelde vragen

Stop met blind varen.
Begin met zien wat er echt gebeurt.

Laten we het hebben over de blinde vlekken in je frontend. We laten je precies zien welke gebruikerservaringen je omzet kosten en hoe je ze oplost.