Latenza delle API di viaggio: cosa potete correggere e cosa no

Il ticket dice "la ricerca è lenta". Aprite la trace di un andata e ritorno Milano–Dubai e il vostro codice è una fettina sottile all'inizio e un'altra alla fine. Tutto quello che sta in mezzo è attesa: di un GDS, di due compagnie NDC, di un aggregatore alberghiero che risponde quando gli pare. La latenza delle API di viaggio è l'unico problema di performance in cui il profiler continua a indicare codice che non avete scritto e che non potete deployare. Questo cambia il significato di "correggerla", e la maggior parte dello sforzo che i team ci dedicano finisce sulla metà sbagliata.
Dove va davvero la latenza delle API di viaggio in una ricerca multi-fornitore
Una singola ricerca voli su un booking engine non è una richiesta. È un fan-out. Il motore prende origine, destinazione, date e composizione dei passeggeri, costruisce una richiesta specifica per ogni fonte che è autorizzato a interrogare su quella rotta, le invia tutte insieme, e poi aspetta. Ogni fornitore ha il proprio orologio: una sessione GDS che era calda oppure no, un gateway NDC che sta riprezzando lato compagnia, un bedbank che a sua volta fa fan-out verso i channel manager dietro di sé. La risposta che potete mostrare all'utente ha come limite inferiore il fornitore più lento che avete scelto di aspettare, non la media.
È la prima cosa da interiorizzare. Aggiungere un fornitore non rende mai più veloce una ricerca completa. Aggiunge soltanto un'altra corsia che deve liberarsi prima che l'intero set di risultati sia "finito".
Poi le risposte tornano e comincia il lavoro che possedete davvero: fare il parsing di un payload XML o JSON corposo per fornitore, mappare i loro codici di aeroporto, compagnia e tariffa sui vostri, deduplicare lo stesso itinerario che tre fonti hanno restituito a tre prezzi, applicare le regole di markup del tenant che sta chiedendo, convertire la valuta e ordinare. Su una rotta trafficata questa fase non è gratis, ed è l'unico punto in cui un profiler vi dirà qualcosa su cui agire. Del lato alberghiero abbiamo scritto in come progettare un client di disponibilità alberghiera per fornitori lenti; il lato voli ha la stessa forma con più codici da mappare.
Quindi la scomposizione onesta di una ricerca lenta sono tre contenitori:
- Attesa del fornitore — la singola risposta più lunga. Non la controllate.
- La vostra post-elaborazione — parsing, mappatura, dedup, prezzo, ordinamento. La controllate tutta.
- Consegna — serializzare il risultato unito e portarlo al browser. Di solito piccola, ogni tanto la sorpresa.
La metà che potete correggere, e la metà che dovreste smettere di provare a correggere
Partite dal secondo contenitore, perché è vostro. I reperti abituali, nell'ordine in cui tendono a comparire: un passaggio di mappatura che cerca ogni codice aeroporto nel database uno alla volta invece di caricare la tabella una volta sola; una conversione di valuta che chiama un servizio cambi per tariffa invece che per ricerca; una routine di dedup che confronta ogni itinerario con tutti gli altri; una serializzazione che ripercorre il grafo degli oggetti per ogni tenant. Niente di tutto questo è esotico. Tutto si corregge in uno sprint, e la correzione dura.
La gestione delle connessioni è l'altro punto in cui il guadagno è reale. Un handshake TLS nuovo verso un fornitore a ogni ricerca è puro overhead; un pool di connessioni calde, tenute vive tra una ricerca e l'altra, lo elimina. Le sessioni GDS in particolare sono costose da aprire e economiche da riusare, ed è per questo che in quel mondo la gestione delle sessioni è una funzionalità di prodotto e non un dettaglio implementativo.
Ora la metà da smettere di correggere. Non potete far rispondere più in fretta un fornitore. Potete alzare la voce con il vostro account manager, e a volte una rotta viene spostata su un nodo più veloce, ma il tempo di risposta del sistema di qualcun altro non è una variabile del vostro deployment. I team che lo dimenticano passano trimestri a limare la propria post-elaborazione da una fettina a una fettina più sottile mentre l'attesa del fornitore, che era la maggior parte del totale, non si è mossa. Il profiler era stato onesto con loro. Hanno semplicemente continuato a ottimizzare la parte che diceva andasse bene.
Quello che potete fare con un fornitore lento è decidere quanto siete disposti ad aspettarlo, e cosa vede l'utente nel frattempo. Che è il resto di questo pezzo.
Il rendering progressivo è la risposta onesta
Se il set completo di risultati è limitato dal fornitore più lento, allora l'unico modo per mostrare qualcosa prima all'utente è smettere di aspettare che il set sia completo. Mostrate i risultati del primo fornitore che risponde. Aggiungete quelli del successivo quando arrivano. Lasciate che l'utente cominci a leggere, filtrare e confrontare mentre i ritardatari sono ancora in volo. Questo è il rendering progressivo, e non è un trucco; è una rappresentazione accurata di ciò che sta davvero accadendo sul server.
Ha conseguenze che vale la pena progettare invece di scoprire:
- Stabilità dell'ordinamento. Una lista ordinata per prezzo che si riordina ogni volta che arriva un fornitore sposta la tariffa che l'utente stava per cliccare. Inserite i nuovi risultati al loro posto, o raggruppateli e lasciate che sia l'utente a tirarli dentro, ma non rimescolate sotto il cursore.
- "Il più economico" è provvisorio. Finché l'ultimo fornitore non è arrivato, qualunque affermazione sulla tariffa più bassa riguarda i fornitori che hanno risposto. L'interfaccia dovrebbe rendere visibile quello stato invece di fingere completezza.
- Il passaggio di prenotazione deve ricontrollare. Una tariffa mostrata da una risposta precoce può essere sparita quando l'utente clicca. È vero anche nei design non progressivi, ma il rendering progressivo allarga la finestra. Il pezzo sull'integrazione della prenotazione copre il passaggio di riprezzatura; qui non è opzionale.
- La cache diventa più semplice, non più difficile. I risultati per fornitore possono essere messi in cache con durate per fornitore. Le tariffe statiche di un bedbank possono vivere ore; un'offerta NDC, minuti. Un unico risultato monolitico unito impone a tutto la durata più breve.
La forma di API che supporta tutto questo è una ricerca che restituisce subito un identificativo e lascia che il client faccia polling o si sottoscriva ai risultati man mano che arrivano, con ogni lotto etichettato per fonte e un flag che dice se la ricerca è ancora aperta. Le API voli e hotel della piattaforma sono costruite attorno a quella forma; la pagina delle API di viaggio descrive le superfici, e l'accesso inizia come una conversazione e non come una chiave self-service, quindi portate le domande.
Timeout per fornitore, non per richiesta
Un unico timeout sull'intera ricerca è l'errore più comune in questo livello, ed è sbagliato in entrambe le direzioni contemporaneamente. Impostatelo corto, e un fornitore lento ma prezioso viene tagliato a ogni ricerca e smettete silenziosamente di vendere il suo inventario. Impostatelo lungo, e un fornitore che si blocca tiene in ostaggio ogni risultato, compresi quelli arrivati subito.
| Decisione | Un solo timeout per l'intera ricerca | Un budget per fornitore |
|---|---|---|
| Un fornitore si blocca | Tutti aspettano, poi tutti falliscono o tutti vengono tagliati | Quel fornitore viene escluso da questa ricerca; gli altri vengono mostrati |
| Un fornitore lento con buone tariffe | O sempre escluso o sempre a rallentare la pagina | Riceve un budget più lungo di quelli veloci, e viene renderizzato tardi |
| Ritentare | Si ripete l'intero fan-out, raddoppiando il carico sui fornitori che avevano già risposto | Si ritenta solo quello che ha fallito, se vale la pena ritentare |
| Cosa vede l'utente | Spinner, poi tutto o un errore | Risultati che si riempiono, e uno stato "ricerca in corso" che prima o poi si chiude |
| Cosa vedono le operations | "Ricerca scaduta", senza indicazione di quale fonte l'abbia causato | Un conteggio di timeout per fornitore da mettere accanto al nome di quel fornitore |
| Tararlo | Un numero su cui si discute all'infinito | Un numero per fornitore, fissato dalla storia di quel fornitore |
Il budget per fornitore è anche dove vive la realtà commerciale. Un fornitore le cui tariffe vengono scelte di rado non merita la stessa pazienza di quello che vince la maggior parte delle vostre prenotazioni su una rotta. Le tariffe nette di un consolidatore su una rotta Italia–Golfo possono valere l'attesa; un quarto bedbank che restituisce gli stessi hotel dei primi tre, no. Il budget è una decisione di prodotto espressa come numero, e va fissato per fornitore, per tenant se i tenant differiscono, e rivisto.
Due raffinamenti che si ripagano da soli. Primo, un budget non è solo un massimo; un fornitore che risponde in una frazione del suo budget ma con un set vuoto è un segnale diverso da uno che va in timeout, e i due vanno contati separatamente. Secondo, i tentativi ripetuti appartengono al livello del fornitore e dovrebbero essere rari. Ritentare una ricerca contro un fornitore appena andato in timeout di solito significa due ricerche in coda dalla loro parte, il che rende più lenta anche la successiva, e sui contratti a consumo costa denaro.
Cosa misurare perché il numero significhi qualcosa
Il "tempo medio di ricerca" è il numero che tutti riportano e quello che dice meno. Mescola una ricerca hotel in cache con un fan-out internazionale a sei fornitori, nasconde il fornitore che è la causa, e si muove quando cambia il mix di traffico piuttosto che quando cambia il vostro codice. Sostituitelo con un piccolo insieme di misurazioni che rispondono ciascuna a una domanda.
- Tempo al primo risultato, per ricerca. È ciò che l'utente percepisce come velocità. È limitato dal vostro fornitore più veloce più il vostro overhead, che è la parte che potete davvero migliorare.
- Tempo al completamento, per ricerca, con l'identità del fornitore che l'ha chiusa. Se un fornitore è sempre l'ultimo, quella è una conversazione sul budget, non di ingegneria.
- Tempo di risposta per fornitore, come distribuzione, non come media, ed etichettato per rotta e fascia oraria. Un fornitore che va bene la mattina ed è lento la sera sembra a posto in media e non lo è.
- I timeout come classe di risultato, contati accanto a "ha restituito risultati" e "ha restituito vuoto", per fornitore. Un timeout è un risultato che non avete ottenuto, e appartiene allo stesso grafico di quelli che avete ottenuto.
- Il vostro tempo di post-elaborazione, separatamente. Quando cresce, avete un problema di codice. Quando cresce l'attesa del fornitore, avete una conversazione da fare.
- Ricerche per prenotazione, per fornitore e per tenant. Ogni ricerca che inviate costa capacità al fornitore, e alla maggior parte dei contratti importa il rapporto. Una correzione della latenza che raddoppia il volume di ricerche con i tentativi ripetuti ha peggiorato il numero, non migliorato.
Misurate anche nel punto in cui l'utente lo vede. Un server che riporta ricerche veloci mentre il browser aspetta un passaggio di serializzazione lento sta dicendo la verità e vi sta fuorviando nello stesso momento.
Cosa vi costa sbagliare questo
Il costo ovvio è quello nel ticket: un utente che aspetta, poi se ne va. Quelli meno ovvi sono commerciali. Un unico timeout sull'intera ricerca impostato troppo corto rimuove silenziosamente un fornitore dai vostri risultati a ogni ricerca, e lo scoprite solo quando l'account manager chiede perché le prenotazioni si sono fermate. Ritentare interi fan-out raddoppia le vostre ricerche per prenotazione, e i fornitori che misurano quel rapporto rispondono limitandovi o fatturandovi. Riordinare una lista progressiva sotto il cursore dell'utente produce click sbagliati sulla tariffa sbagliata, che diventano ticket di assistenza e a volte rimborsi. E una dashboard basata sulla media lascia accadere tutte e tre le cose mentre il numero sopra resta verde.
Nessuna di queste si risolve rendendo più veloce il vostro codice. Si risolvono decidendo, per fornitore, quanto aspetterete, mostrando all'utente ciò che avete mentre aspettate, e misurando la cosa che si è davvero mossa. Le ottimizzazioni del codice valgono la pena. Semplicemente non erano la parte sbagliata.