Belangrijkste punten
- Volledige end-to-end tracing is in gedistribueerde systemen zelden haalbaar: factoren zoals verschillende programmeertalen, externe API’s, legacycomponenten en kortlevende services veroorzaken gaten die niet altijd te dichten zijn.
- Ontbrekende tracegegevens stapelen zich op tot grotere problemen: onvolledig inzicht verlengt de oplostijd en vermindert het vertrouwen in monitoringgegevens.
- Gedeeltelijk inzicht is nog steeds nuttig: door te standaardiseren wat wél meetbaar is en dat te correleren met logs kunnen teams de gaten opvullen via gevolgtrekking.
- Externe afhankelijkheden vragen om een andere aanpak: volg bij componenten buiten uw controle de trace zo ver als mogelijk en leid vervolgens uit de gecorreleerde gegevens af wat er gebeurt.
End-to-end tracing wordt steeds belangrijker voor tech- en DevOps-teams die zowel interne tools als publieke apps beheren, maar is lastig in systemen die op gedistribueerde microservices draaien.
Deze gids legt uit wat er kan gebeuren wanneer end-to-end tracing hapert (of niet mogelijk is) in gedistribueerde systemen en wat u daaraan kunt doen.
Wat is end-to-end tracing?
End-to-end tracing is het volledig volgen van een request of transactie, van het eerste verzoek tot de afhandeling ervan, door elk component van een systeem heen. Het wordt veel gebruikt om appcode te debuggen, prestaties te benchmarken en bottlenecks op te sporen en weg te nemen.
End-to-end tracing is cruciaal in gedistribueerde systemen op basis van microservices, waar het hele pad van een request over meerdere modulaire services moet worden gevolgd in plaats van alleen activiteit vanuit één draaiende codebase te loggen.
Een voorbeeld: wanneer een gebruiker in een e-commerce-app op basis van microservices zijn winkelwagen afrekent, start er een request zodra hij op de knop ‘Nu betalen’ klikt. Dat request gaat naar de webserver, die een betaalverwerkingsservice aanroept, die bij succes weer een e-mailservice aanroept om een orderbevestiging te versturen. Dat verloopt niet per se lineair of op volgorde: als ook een sms-bevestiging wordt gevraagd, kunnen afzonderlijke e-mail- en sms-services tegelijk worden aangeroepen. Zo’n request volgen is complexer dan in één monolithische codebase, waar alles op één plek in een vaste volgorde gebeurt.
Waarom end-to-end tracing lastig is in gedistribueerde systemen
De zaak wordt nog complexer in gedistribueerde systemen die bestaan uit componenten met verschillende talen, libraries en platforms. Ook het vluchtige karakter van het opschalen van microservices vormt een uitdaging, omdat nodes worden aangemaakt en weer vernietigd om aan de vraag te voldoen (sommige bestaan alleen lang genoeg om één request af te handelen). Wordt een node verwijderd, dan verdwijnen ook alle tracegegevens die nog niet buiten die node zijn vastgelegd.
Andere veelvoorkomende problemen die end-to-end tracing bemoeilijken:
- Systemen die tracing helemaal niet ondersteunen
- Externe services (zoals communicatie-API’s) zonder inzicht
- Legacycomponenten
- Inconsistente dataformaten
Databases vormen een bijzondere uitdaging. Ze geven voorrang aan prestaties en voeren query’s parallel uit om lees- en schrijfacties te optimaliseren. Daardoor is bij hoge activiteit moeilijk vast te stellen welk specifiek request een prestatieprobleem veroorzaakt.
Probleem: gedistribueerde systemen creëren gaten in de observability
Volledige end-to-end tracing vereist inzicht in elk component. In gedistribueerde systemen kan dat een mix zijn van zaken als:
- Eigen code die in containers draait en waarvan de activiteit tot in detail te monitoren is
- Cloud-native services zoals serverless workers, die mogelijk maar beperkt inzicht bieden
- API’s van derden die geen enkele observability bieden
Deze kunnen op dezelfde host draaien – of gedistribueerd zijn – afhankelijk van uw app. Zelfs componenten in dezelfde omgeving integreren niet altijd rechtstreeks: ze gebruiken verschillende talen en besturingssystemen en vragen om verschillende libraries om activiteit te monitoren. Zelfs gedistribueerde systemen die met observability in gedachten zijn ontworpen, krijgen na verloop van tijd gaten naarmate ze evolueren.
Oplossing: meer inzicht zonder volledige tracing
Gooi end-to-end tracing niet overboord omdat u niet alles volledig kunt volgen. Volledige tracing is voor sommige systemen misschien niet haalbaar, maar u kunt er wel voor zorgen dat u consequent alle beschikbare gegevens verzamelt – werk met wat u hebt.
Dat betekent dat wat meetbaar is, op een gestandaardiseerde manier wordt gemeten, zodat het geanalyseerd kan worden en niet verloren gaat. Breid daar waar u wél controle hebt de integratie en instrumentatie uit om zoveel mogelijk diagnostische informatie te verzamelen.
Probleem: de impact van ontbrekende tracegegevens
Onvolledige gegevens leveren op hun beurt eigen problemen op, zoals:
- Moeite met het achterhalen van de oorzaak
- Langere doorlooptijd om incidenten op te lossen
- Verkeerde interpretatie van systeemgedrag
- Minder vertrouwen in monitoringgegevens
Dat kan de waarde ondermijnen van de hoogwaardige gegevens die u wél kunt verzamelen.
Oplossing: werken met gedeeltelijk inzicht
Gaten kunnen worden opgevuld met gevolgtrekking. Zo levert application performance monitoring informatie waarmee u kunt afleiden wat er binnen ‘black box’-componenten gebeurt en kunnen databasequery’s afzonderlijk worden geprofileerd in testomgevingen, als het niet praktisch is om activiteit in productie te isoleren.
Deze gegevens kunt u correleren met trace- en loggegevens, zodat u patronen herkent en de gaten invult.
Probleem: systeemgrenzen en externe afhankelijkheden
Externe afhankelijkheden zoals API’s, systemen die in afwijkende omgevingen draaien en legacysystemen die niet van tracingfunctionaliteit kunnen worden voorzien, maken het lastig om een request gedurende de volledige lifecycle te volgen.
Oplossing: de rol van context bij distributed tracing
Volg met tracingtools zoveel en zo ver als u kunt en vul de gaten op door statistieken te correleren zoals hierboven beschreven. Dat kan alleen als u het systeem dat u monitort volledig doorgrondt, zodat u zich op de juiste informatie richt en niet achter spoken aan gaat jagen om problemen op te lossen die buiten uw controle liggen.
Observability verbeteren voor end-to-end tracing in gedistribueerde systemen
Apps bestaan niet in een vacuüm: ze ondersteunen echte gebruikers bij hun dagelijkse werk – gebruikers die afwijkend gedrag vaak snel opmerken. U kunt end-to-end tracing ondersteunen door te kiezen voor infrastructuurmonitoring die ook gegevens uit andere monitoringbronnen kan inlezen en verwerken en notificaties verstuurt zodra er afwijkingen worden gedetecteerd. In combinatie met een helpdesk kunnen zowel geautomatiseerde maatregelen als eindgebruikers applicatieproblemen melden en direct een onderzoek in gang zetten, waardoor de kans groter wordt dat relevante gegevens worden vastgelegd.
