Latência de API de viagens: o que você corrige e o que não

O ticket diz "a busca está lenta". Você abre o trace de uma ida e volta São Paulo–Dubai e o seu próprio código é uma fatia fina no começo e outra no fim. Tudo no meio é espera: por um GDS, por duas companhias NDC, por um agregador de hotéis que responde quando bem entende. Latência de API de viagens é o único problema de performance em que o profiler insiste em apontar para código que você não escreveu e não pode fazer deploy. Isso muda o que "corrigir" significa, e a maior parte do esforço que os times gastam nisso vai para a metade errada.
Para onde a latência de API de viagens realmente vai numa busca multi-fornecedor
Uma única busca de voo num motor de reservas não é uma requisição. É um fan-out. O motor pega origem, destino, datas e composição de passageiros, monta uma requisição específica para cada fonte que ele tem permissão de consultar naquela rota, dispara todas de uma vez e então espera. Cada fornecedor tem o próprio relógio: uma sessão GDS que estava aquecida ou não, um gateway NDC que está reprecificando do lado da companhia, um bedbank que por sua vez faz fan-out para os channel managers atrás dele. A resposta que você pode mostrar ao usuário tem como piso o fornecedor mais lento que você escolheu esperar, não a média.
Essa é a primeira coisa a internalizar. Adicionar um fornecedor nunca deixa uma busca completa mais rápida. Só adiciona mais uma pista que precisa liberar antes de o conjunto inteiro de resultados estar "pronto".
Então as respostas voltam e começa o trabalho que é seu de verdade: fazer o parse de um payload XML ou JSON grande por fornecedor, mapear os códigos de aeroporto, companhia e tarifa deles para os seus, deduplicar o mesmo itinerário que três fontes devolveram a três preços, aplicar as regras de markup do tenant que está perguntando, converter moeda e ordenar. Numa rota movimentada essa fase não é de graça, e é o único lugar em que um profiler vai te dizer algo acionável. Escrevemos sobre o lado hoteleiro disso em como desenhar um cliente de disponibilidade hoteleira para fornecedores lentos; o lado dos voos tem o mesmo formato com mais códigos para mapear.
Então a decomposição honesta de uma busca lenta são três caixas:
- Espera do fornecedor — a resposta individual mais longa. Você não controla.
- Seu pós-processamento — parse, mapeamento, dedup, preço, ordenação. Você controla tudo.
- Entrega — serializar o resultado consolidado e levá-lo ao navegador. Normalmente pequena, de vez em quando a surpresa.
A metade que você pode corrigir, e a metade que deveria parar de tentar
Comece pela segunda caixa, porque ela é sua. Os achados de sempre, na ordem em que costumam aparecer: uma etapa de mapeamento que consulta cada código de aeroporto no banco um por um em vez de carregar a tabela uma vez; uma conversão de moeda que chama um serviço de câmbio por tarifa em vez de por busca; uma rotina de dedup que compara cada itinerário com todos os outros; uma serialização que percorre de novo o grafo de objetos para cada tenant. Nada disso é exótico. Tudo se corrige em um sprint, e a correção dura.
O tratamento de conexões é o outro lugar onde o ganho é real. Um handshake TLS novo com um fornecedor a cada busca é overhead puro; um pool de conexões aquecidas, mantidas vivas entre buscas, elimina isso. Sessões GDS em particular são caras de abrir e baratas de reutilizar, e é por isso que nesse mundo o gerenciamento de sessão é uma funcionalidade de produto e não um detalhe de implementação.
Agora a metade para parar de corrigir. Você não consegue fazer um fornecedor responder mais rápido. Pode reclamar com o seu gerente de conta, e às vezes uma rota é movida para um nó mais rápido, mas o tempo de resposta do sistema de outra pessoa não é uma variável do seu deploy. Os times que esquecem isso passam trimestres raspando o próprio pós-processamento de uma fatia para uma fatia mais fina enquanto a espera do fornecedor, que era a maior parte do total, não se moveu. O profiler foi honesto com eles. Eles só continuaram otimizando a parte que ele dizia estar bem.
O que você pode fazer sobre um fornecedor lento é decidir quanto tempo está disposto a esperar por ele, e o que o usuário vê enquanto isso. Que é o resto deste texto.
Renderização progressiva é a resposta honesta
Se o conjunto completo de resultados é limitado pelo fornecedor mais lento, então a única forma de mostrar algo ao usuário mais cedo é parar de esperar o conjunto ficar completo. Mostre os resultados do primeiro fornecedor que responder. Adicione os do próximo quando chegarem. Deixe o usuário começar a ler, filtrar e comparar enquanto os retardatários ainda estão em voo. Isso é renderização progressiva, e não é truque; é uma representação precisa do que está realmente acontecendo no servidor.
Ela tem consequências que vale a pena desenhar em vez de descobrir:
- Estabilidade da ordenação. Uma lista ordenada por preço que se reordena cada vez que um fornecedor chega move a tarifa que o usuário estava prestes a clicar. Insira os novos resultados no lugar, ou agrupe-os e deixe o usuário puxá-los, mas não embaralhe debaixo do cursor.
- "Mais barato" é provisório. Até o último fornecedor chegar, qualquer afirmação de menor tarifa é uma afirmação sobre os fornecedores que responderam. A interface deve deixar esse estado visível em vez de fingir completude.
- A etapa de reserva precisa reconferir. Uma tarifa mostrada a partir de uma resposta antecipada pode ter sumido quando o usuário clica. Isso também é verdade em desenhos não progressivos, mas a renderização progressiva amplia a janela. O texto sobre integração de reserva cobre a etapa de reprecificação; aqui ela não é opcional.
- O cache fica mais simples, não mais difícil. Resultados por fornecedor podem ser cacheados com validades por fornecedor. As tarifas estáticas de um bedbank podem viver horas; uma oferta NDC, minutos. Um resultado único consolidado impõe a validade mais curta a tudo.
O formato de API que sustenta isso é uma busca que devolve um identificador imediatamente e deixa o cliente fazer polling ou assinar os resultados à medida que chegam, com cada lote marcado pela fonte e um flag que diz se a busca ainda está aberta. As APIs de voo e hotel da própria plataforma são construídas em torno desse formato; a página de APIs de viagem descreve as superfícies, e o acesso começa como uma conversa e não como uma chave self-service, então traga as perguntas.
Timeouts por fornecedor, não por requisição
Um timeout único para a busca inteira é o erro mais comum nessa camada, e está errado nas duas direções ao mesmo tempo. Deixe curto, e um fornecedor lento mas valioso é cortado em toda busca e você silenciosamente para de vender o inventário dele. Deixe longo, e um fornecedor travado mantém todos os resultados reféns, inclusive os que chegaram na hora.
| Decisão | Timeout único para a busca inteira | Um orçamento por fornecedor |
|---|---|---|
| Um fornecedor trava | Todos esperam, depois todos falham ou todos são cortados | Esse fornecedor sai desta busca; os demais são mostrados |
| Um fornecedor lento com boas tarifas | Ou sempre excluído ou sempre atrasando a página | Recebe um orçamento maior que os rápidos, e é renderizado tarde |
| Repetir | Repete o fan-out inteiro, dobrando a carga nos fornecedores que já responderam | Repete só o que falhou, se é que vale a pena repetir |
| O que o usuário vê | Spinner, depois tudo ou um erro | Resultados preenchendo, e um estado "ainda buscando" que eventualmente fecha |
| O que a operação vê | "Busca expirou", sem indicação de qual fonte causou | Uma contagem de timeouts por fornecedor que pode ficar ao lado do nome dele |
| Ajustar | Um número discutido para sempre | Um número por fornecedor, definido pelo histórico daquele fornecedor |
O orçamento por fornecedor é também onde mora a realidade comercial. Um fornecedor cujas tarifas raramente são escolhidas não merece a mesma paciência daquele que ganha a maioria das suas reservas numa rota. As tarifas net de uma consolidadora numa rota Brasil–Golfo podem valer a espera; um quarto bedbank devolvendo os mesmos hotéis dos três primeiros, não. O orçamento é uma decisão de produto expressa como número, e deve ser definido por fornecedor, por tenant se os tenants diferem, e revisitado.
Dois refinamentos que se pagam. Primeiro, um orçamento não é só um máximo; um fornecedor que retorna numa fração do orçamento mas com conjunto vazio é um sinal diferente de um que expira, e os dois devem ser contados separadamente. Segundo, repetições pertencem ao nível do fornecedor e devem ser raras. Repetir uma busca contra um fornecedor que acabou de expirar geralmente significa duas buscas na fila do lado deles, o que deixa a próxima mais lenta também, e em contratos medidos custa dinheiro.
O que medir para o número significar algo
"Tempo médio de busca" é o número que todo mundo reporta e o que menos diz. Ele mistura uma consulta de hotel em cache com um fan-out internacional de seis fornecedores, esconde o fornecedor que é a causa, e se move quando o mix de tráfego muda em vez de quando o seu código muda. Substitua-o por um conjunto pequeno de medições que respondem, cada uma, a uma pergunta.
- Tempo até o primeiro resultado, por busca. É o que o usuário sente como velocidade. É limitado pelo seu fornecedor mais rápido mais o seu próprio overhead, que é a parte que você realmente pode melhorar.
- Tempo até completar, por busca, com a identidade do fornecedor que a fechou. Se um fornecedor é sempre o último, isso é uma conversa de orçamento, não de engenharia.
- Tempo de resposta por fornecedor, como distribuição, não como média, e marcado por rota e horário. Um fornecedor que vai bem de manhã e fica lento à noite parece bem na média e não está.
- Timeouts como uma classe de resultado, contados ao lado de "retornou resultados" e "retornou vazio", por fornecedor. Um timeout é um resultado que você não obteve, e pertence ao mesmo gráfico dos que obteve.
- Seu próprio tempo de pós-processamento, separadamente. Quando ele cresce, você tem um problema de código. Quando a espera do fornecedor cresce, você tem uma conversa a ter.
- Buscas por reserva, por fornecedor e por tenant. Cada busca que você envia custa capacidade ao fornecedor, e a maioria dos contratos se importa com essa proporção. Uma correção de latência que dobra o volume de buscas por repetições piorou o número, não melhorou.
Meça também no ponto em que o usuário vê. Um servidor que reporta buscas rápidas enquanto o navegador espera numa etapa de serialização lenta está dizendo a verdade e te enganando ao mesmo tempo.
O que custa errar nisso
O custo óbvio é o do ticket: um usuário que espera, depois vai embora. Os menos óbvios são comerciais. Um timeout único para a busca inteira, curto demais, remove silenciosamente um fornecedor dos seus resultados em toda busca, e você só descobre quando o gerente de conta pergunta por que as reservas pararam. Repetir fan-outs inteiros dobra suas buscas por reserva, e fornecedores que medem essa proporção respondem limitando você ou te faturando. Reordenar uma lista progressiva debaixo do cursor do usuário produz cliques errados na tarifa errada, que viram tickets de suporte e às vezes reembolsos. E um dashboard baseado em média deixa as três coisas acontecerem enquanto o número nele continua verde.
Nenhuma delas se resolve deixando o seu código mais rápido. Resolvem-se decidindo, por fornecedor, quanto você vai esperar, mostrando ao usuário o que você tem enquanto espera, e medindo a coisa que realmente se moveu. As acelerações de código valem a pena. Só não eram a parte que estava errada.