Reis-API-latency: wat je kunt oplossen en wat niet

Het ticket zegt "zoeken is traag". Je opent de trace van een retour Amsterdam–Dubai en je eigen code is een dun reepje aan het begin en nog een aan het eind. Alles daartussen is wachten: op een GDS, op twee NDC-maatschappijen, op een hotelaggregator die antwoordt wanneer het hem uitkomt. Reis-API-latency is het enige performanceprobleem waarbij de profiler steeds wijst naar code die je niet hebt geschreven en niet kunt deployen. Dat verandert wat "oplossen" betekent, en het grootste deel van de moeite die teams erin steken gaat naar de verkeerde helft.
Waar reis-API-latency werkelijk heen gaat bij zoeken over meerdere leveranciers
Eén vluchtzoekopdracht op een booking engine is niet één request. Het is een fan-out. De engine neemt vertrekpunt, bestemming, data en passagierssamenstelling, bouwt voor elke bron die hij op die route mag bevragen een leverancierspecifiek verzoek, stuurt ze allemaal tegelijk en wacht dan. Elke leverancier heeft zijn eigen klok: een GDS-sessie die warm was of niet, een NDC-gateway die aan de kant van de maatschappij opnieuw prijst, een bedbank die zelf weer uitwaaiert naar de channel managers erachter. Het antwoord dat je de gebruiker kunt tonen wordt van onderen begrensd door de traagste leverancier waarop je besloot te wachten, niet door het gemiddelde.
Dat is het eerste om te verinnerlijken. Een leverancier toevoegen maakt een complete zoekopdracht nooit sneller. Het voegt alleen een rijstrook toe die vrij moet zijn voordat de hele resultaatset "klaar" is.
Dan komen de antwoorden terug en begint het werk dat wél van jou is: per leverancier een grote XML- of JSON-payload parsen, hun luchthaven-, maatschappij- en tariefcodes op de jouwe mappen, dezelfde reisroute ontdubbelen die drie bronnen tegen drie prijzen terugstuurden, de opslagregels toepassen van de tenant die vraagt, valuta omrekenen en sorteren. Op een drukke route is die fase niet gratis, en het is de enige plek waar een profiler je iets bruikbaars vertelt. Over de hotelkant hiervan schreven we in een hotelbeschikbaarheidsclient ontwerpen voor trage leveranciers; de vluchtkant heeft dezelfde vorm met meer codes om te mappen.
De eerlijke opdeling van een trage zoekopdracht is dus drie bakken:
- Wachten op de leverancier — de langste afzonderlijke leveranciersrespons. Daar heb je geen controle over.
- Jouw nabewerking — parsen, mappen, ontdubbelen, prijzen, sorteren. Daar heb je volledige controle over.
- Aflevering — het samengevoegde resultaat serialiseren en naar de browser krijgen. Meestal klein, af en toe de verrassing.
De helft die je kunt oplossen, en de helft waar je mee moet ophouden
Begin met de tweede bak, want die is van jou. De gebruikelijke bevindingen, in de volgorde waarin ze meestal opduiken: een mappingstap die elke luchthavencode één voor één in de database opzoekt in plaats van de tabel één keer te laden; een valutaomrekening die per tarief een koersdienst aanroept in plaats van per zoekopdracht; een ontdubbelroutine die elke reisroute met elke andere vergelijkt; serialisatie die voor elke tenant de objectgraaf opnieuw doorloopt. Niets hiervan is exotisch. Alles is in één sprint op te lossen, en de oplossing blijft staan.
Verbindingsbeheer is de andere plek waar de winst echt is. Een verse TLS-handshake naar een leverancier bij elke zoekopdracht is pure overhead; een pool van warme verbindingen, in leven gehouden tussen zoekopdrachten, haalt die weg. Vooral GDS-sessies zijn duur om te openen en goedkoop om te hergebruiken, en daarom is sessiebeheer in die wereld een productfunctie en geen implementatiedetail.
Nu de helft waar je mee moet ophouden. Je kunt een leverancier niet sneller laten antwoorden. Je kunt je accountmanager toeroepen, en soms wordt een route naar een snellere node verplaatst, maar de responstijd van andermans systeem is geen variabele in jouw deployment. Teams die dat vergeten besteden kwartalen aan het afschaven van hun eigen nabewerking van een reepje naar een dunner reepje, terwijl het wachten op de leverancier, dat het grootste deel van het totaal was, niet is bewogen. De profiler was eerlijk tegen ze. Ze bleven alleen het deel optimaliseren waarvan hij zei dat het in orde was.
Wat je wél kunt doen aan een trage leverancier is beslissen hoe lang je bereid bent erop te wachten, en wat de gebruiker ondertussen ziet. Daar gaat de rest van dit stuk over.
Progressief renderen is het eerlijke antwoord
Als de complete resultaatset wordt begrensd door de traagste leverancier, dan is de enige manier om de gebruiker eerder iets te laten zien: stoppen met wachten tot de set compleet is. Toon resultaten van de eerste leverancier die antwoordt. Voeg de resultaten van de volgende toe zodra ze binnen zijn. Laat de gebruiker beginnen met lezen, filteren en vergelijken terwijl de achterblijvers nog onderweg zijn. Dit is progressief renderen, en het is geen truc; het is een accurate weergave van wat er werkelijk op de server gebeurt.
Het heeft gevolgen die je beter ontwerpt dan ontdekt:
- Sorteerstabiliteit. Een lijst op prijs die opnieuw sorteert telkens als een leverancier binnenkomt, verschuift het tarief dat de gebruiker net wilde aanklikken. Voeg nieuwe resultaten op hun plek in, of bundel ze en laat de gebruiker ze zelf ophalen, maar schud niet onder een cursor.
- "Goedkoopste" is voorlopig. Tot de laatste leverancier binnen is, is elke claim over het laagste tarief een claim over de leveranciers die hebben geantwoord. De interface hoort die toestand zichtbaar te maken in plaats van volledigheid voor te wenden.
- De boekingsstap moet opnieuw controleren. Een tarief uit een vroeg antwoord kan weg zijn tegen de tijd dat de gebruiker klikt. Dat geldt ook voor niet-progressieve ontwerpen, maar progressief renderen maakt het venster groter. Het stuk over boekingsintegratie behandelt de herprijsstap; hier is die niet optioneel.
- Caching wordt eenvoudiger, niet moeilijker. Resultaten per leverancier kunnen worden gecachet met een levensduur per leverancier. De statische tarieven van een bedbank kunnen uren leven; een NDC-aanbod minuten. Eén monolithisch samengevoegd resultaat dwingt de kortste levensduur op alles af.
De API-vorm die dit ondersteunt is een zoekopdracht die direct een identifier teruggeeft en de client laat pollen of abonneren op resultaten zodra ze binnenkomen, met elke batch gelabeld per bron en een vlag die zegt of de zoekopdracht nog open is. De eigen vlucht- en hotel-API's van het platform zijn rond die vorm gebouwd; de pagina over reis-API's beschrijft de oppervlakken, en toegang begint als een gesprek in plaats van een self-service sleutel, dus neem je vragen mee.
Time-outs per leverancier, niet per request
Eén time-out op de hele zoekopdracht is de meest voorkomende fout in deze laag, en hij is in beide richtingen tegelijk fout. Zet hem kort, en een trage maar waardevolle leverancier wordt bij elke zoekopdracht afgekapt en je stopt stilletjes met het verkopen van zijn inventaris. Zet hem lang, en één hangende leverancier houdt elk resultaat gegijzeld, ook de resultaten die meteen binnen waren.
| Beslissing | Eén time-out voor de hele zoekopdracht | Een budget per leverancier |
|---|---|---|
| Eén leverancier hangt | Iedereen wacht, dan faalt iedereen of wordt iedereen afgekapt | Die leverancier valt uit deze zoekopdracht; de rest wordt getoond |
| Een trage leverancier met goede tarieven | Of altijd uitgesloten, of altijd de pagina vertragend | Krijgt een langer budget dan de snelle, en wordt laat gerenderd |
| Opnieuw proberen | De hele fan-out opnieuw, met dubbele belasting voor leveranciers die al antwoordden | Alleen degene die faalde opnieuw, als het al de moeite is |
| Wat de gebruiker ziet | Spinner, dan alles of een foutmelding | Resultaten die binnenlopen, en een "nog aan het zoeken"-status die uiteindelijk sluit |
| Wat operations ziet | "Zoekopdracht verlopen", zonder aanwijzing welke bron de oorzaak was | Een time-outteller per leverancier die naast de naam van die leverancier kan staan |
| Afstellen | Eén getal waar eindeloos over wordt gediscussieerd | Eén getal per leverancier, afgeleid van de eigen historie van die leverancier |
Het budget per leverancier is ook waar de commerciële werkelijkheid woont. Een leverancier wiens tarieven zelden worden gekozen verdient niet hetzelfde geduld als degene die op een route de meeste van je boekingen wint. De nettotarieven van een consolidator op een route Benelux–Golf kunnen het wachten waard zijn; een vierde bedbank die dezelfde hotels teruggeeft als de eerste drie niet. Het budget is een productbeslissing uitgedrukt als getal, en het hoort per leverancier te worden gezet, per tenant als tenants verschillen, en opnieuw bekeken.
Twee verfijningen die zichzelf terugverdienen. Ten eerste is een budget niet alleen een maximum; een leverancier die binnen een fractie van zijn budget terugkomt maar met een lege set is een ander signaal dan een die verloopt, en die twee moeten apart worden geteld. Ten tweede horen herhalingen op leveranciersniveau en moeten ze zeldzaam zijn. Een zoekopdracht herhalen bij een leverancier die net is verlopen betekent meestal twee zoekopdrachten in de wachtrij aan hun kant, wat de volgende ook trager maakt, en bij contracten op verbruik kost het geld.
Wat je meet zodat het getal iets betekent
"Gemiddelde zoektijd" is het getal dat iedereen rapporteert en dat je het minst vertelt. Het mengt een gecachete hotelopzoeking met een internationale fan-out over zes leveranciers, verbergt de leverancier die de oorzaak is, en beweegt wanneer de verkeersmix verandert in plaats van wanneer je code verandert. Vervang het door een kleine set metingen die elk één vraag beantwoorden.
- Tijd tot het eerste resultaat, per zoekopdracht. Dit is wat de gebruiker als snelheid ervaart. Het wordt begrensd door je snelste leverancier plus je eigen overhead, en dat is het deel dat je werkelijk kunt verbeteren.
- Tijd tot compleet, per zoekopdracht, met de identiteit van de leverancier die hem sloot. Als één leverancier altijd de laatste is, is dat een budgetgesprek, geen engineeringkwestie.
- Responstijd per leverancier, als verdeling, niet als gemiddelde, en gelabeld per route en tijdstip. Een leverancier die 's ochtends prima is en 's avonds traag, ziet er gemiddeld prima uit en is dat niet.
- Time-outs als resultaatklasse, geteld naast "resultaten teruggegeven" en "leeg teruggegeven", per leverancier. Een time-out is een resultaat dat je niet kreeg, en hoort in dezelfde grafiek als de resultaten die je wel kreeg.
- Je eigen nabewerkingstijd, apart. Als die groeit, heb je een codeprobleem. Als het wachten op de leverancier groeit, heb je een gesprek te voeren.
- Zoekopdrachten per boeking, per leverancier en per tenant. Elke zoekopdracht die je stuurt kost de leverancier capaciteit, en de meeste contracten letten op die verhouding. Een latencyfix die je zoekvolume via herhalingen verdubbelt, heeft het getal slechter gemaakt, niet beter.
Meet ook op het punt waar de gebruiker het ziet. Een server die snelle zoekopdrachten rapporteert terwijl de browser wacht op een trage serialisatiestap, spreekt de waarheid en zet je tegelijk op het verkeerde been.
Wat het je kost als je dit fout doet
De voor de hand liggende kostenpost staat in het ticket: een gebruiker die wacht en dan vertrekt. De minder voor de hand liggende zijn commercieel. Eén te korte time-out op de hele zoekopdracht haalt bij elke zoekopdracht stilletjes een leverancier uit je resultaten, en je ontdekt het pas als de accountmanager vraagt waarom de boekingen zijn gestopt. Hele fan-outs herhalen verdubbelt je zoekopdrachten per boeking, en leveranciers die die verhouding meten reageren door je af te knijpen of te factureren. Een progressieve lijst opnieuw sorteren onder de cursor van de gebruiker levert misklikken op het verkeerde tarief op, die supporttickets en soms terugbetalingen worden. En een dashboard op basis van gemiddelden laat alle drie gebeuren terwijl het getal erop groen blijft.
Geen van deze wordt opgelost door je code sneller te maken. Ze worden opgelost door per leverancier te beslissen hoe lang je wacht, de gebruiker te tonen wat je hebt terwijl je wacht, en te meten wat werkelijk bewoog. De codeversnellingen zijn de moeite waard. Ze waren alleen niet het deel dat fout zat.