Spis treści

Przegląd Strategie buforowania Pula połączeń Operacje zbiorcze Optymalizacja zapytań Kompresja Wzorce asynchroniczne Metryki wydajności Testy porównawcze Rekomendacje optymalizacyjne

Dokumentacja API

Optymalizacja wydajności API i redukcja opóźnień

Osiągnij czas odpowiedzi poniżej 100 ms dzięki Smart Money API. Wykorzystaj buforowanie, pulę połączeń, operacje zbiorcze i optymalizację zapytań dla maksymalnej przepustowości.

Opublikowano 21 marca 2026 • 17 min czytania • Wydajność

Przegląd wydajności

Smart Money API jest zoptymalizowany pod kątem niskich opóźnień i wysokiej przepustowości. Osiągnij maksymalną wydajność, wdrażając zalecane wzorce po swojej stronie integracji.

Warstwy optymalizacji wydajności:

Buforowanie — Buforowanie lokalne i CDN redukuje zapytania do źródła
Pula połączeń — Ponowne wykorzystanie połączeń, redukcja narzutu
Operacje zbiorcze — Łączenie wielu zapytań w jedno
Optymalizacja zapytań — Żądaj tylko potrzebnych danych
Asynchroniczność/Równoległość — Przetwarzaj wiele zapytań jednocześnie

Cel wydajnościowy: Opóźnienie P95 <100 ms, P99 <500 ms, dostępność 99,9% z współczynnikiem błędów <0,1%.

Strategie buforowania

Buforowanie odpowiedzi

Pamięć podręczna lokalna
// Respektuj nagłówki Cache-Control
const cache = new Map();
async function cachedFetch(url) {
  const cached = cache.get(url);
  if (cached && !cached.isExpired) {
    return cached.data;
  }
  const response = await fetch(url);
  const ttl = parseCacheControl(response.headers);
  cache.set(url, { data: response, expiry: ttl });
  return response;
}

Unieważnianie pamięci podręcznej

Dane akumulacji wielorybów: TTL 5 minut
Stopy finansowania: TTL 1 minuta
Dane OHLCV: TTL 1 godzina
Dane historyczne: TTL 24 godziny

Funding i otwarte zainteresowanie na żywo — darmowe API

Funding, otwarte zainteresowanie i proporcje long/short na giełdach, które obejmujemy, na żywo w naszym screenerze.

Zobacz funding na żywo →

Pula połączeń

Ponowne wykorzystanie połączeń HTTP

Pula połączeń
// Agent HTTP Node.js z pulą
const http = require('http');
const https = require('https');
const httpAgent = new http.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
const httpsAgent = new https.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
// Użyj agentów w zapytaniach
fetch(url, { agent: httpsAgent });

Ustawienia połączenia

Parametr	Rekomendowane	Uzasadnienie
maxSockets	50-100	Zrównoważ współbieżność z użyciem zasobów
maxFreeSockets	10-20	Zachowaj bezczynne połączenia do ponownego użycia
keepAliveTimeout	60000ms	Dopasuj do limitu czasu serwera

Operacje zbiorcze

Łączenie zapytań

Zapytanie zbiorcze
// Zamiast wielu zapytań
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// Użyj jednego zapytania zbiorczego
GET /v1/whales?asset=BTC,ETH,SOL
// ~200 ms zaoszczędzone w porównaniu do 3 sekwencyjnych zapytań

Limity zbiorcze

Maksymalna liczba symboli na zapytanie: 100
Maksymalny zakres czasowy: 365 dni
Maksymalna liczba wyników: 10 000 wierszy

Optymalizacja zapytań

Optymalizacja żądań

Określ pola — Żądaj tylko potrzebnych pól
Użyj filtrów — Zmniejsz rozmiar odpowiedzi za pomocą filtrów
Stronicowanie — Użyj parametru limit, a nie offset
Ram czasowe — Żądaj tylko potrzebnych danych

Zoptymalizowane zapytanie
// Mniej efektywne: Dużo danych
GET /v1/whales?lookback=90d&limit=10000
// Bardziej efektywne: Konkretne dane
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

Kompresja odpowiedzi

Kompresja Gzip

Kompresja żądań
// Włącz kompresję w żądaniach
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API automatycznie kompresuje dane, jeśli jest to obsługiwane
// Typowa kompresja: redukcja rozmiaru o 70-80%

Oszczędności dzięki kompresji

Typ danych	Nieskompresowane	Skompresowane	Oszczędności
Odpowiedzi JSON	500KB	85KB	83%
Duże tabele	2MB	350KB	82%

Wzorce Async/Parallel

Równoczesne żądania

Równoległe żądania
// Niewydajne: Sekwencyjne
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// Całkowity czas: ~300ms
// Wydajne: Równoległe
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// Całkowity czas: ~100ms (3x szybciej!)

Metryki wydajności

Kluczowe metryki

Metryka	Cel	Pomiar
Opóźnienie P50	<50ms	Mediana czasu odpowiedzi
Opóźnienie P95	<100ms	95 percentyl
Opóźnienie P99	<500ms	99 percentyl
Przepustowość	>1000 req/s	Żądania na sekundę

Monitorowanie wydajności

Monitorowanie wydajności
// Śledź czas odpowiedzi
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// Zaloguj do analizy
console.log(`Żądanie zajęło ${duration}ms`);

Testowanie wydajności

Testowanie obciążenia

Przetestuj swoją integrację, aby zidentyfikować wąskie gardła:

Narzędzia: Apache Bench, wrk lub Locust
Testuj z realistycznym poziomem równoczesności
Mierz rozkład opóźnień, nie tylko średnią
Testuj z ciepłym i zimnym cache

Rekomendacje optymalizacji

Szybkie poprawki

Włącz pulę połączeń HTTP (1-5x poprawa)
Zaimplementuj lokalne buforowanie (10-50x dla powtarzających się żądań)
Używaj operacji zbiorczych (2-5x redukcja żądań)
Włącz kompresję gzip (3-5x redukcja pasma)

Zaawansowane optymalizacje

Zaimplementuj buforowanie CDN dla danych historycznych
Używaj pul połączeń bazodanowych do lokalnego buforowania
Zaimplementuj wzorzec wyłącznika awaryjnego
Używaj strumieniowych odpowiedzi dla dużych zbiorów danych

Osiągnij maksymalną wydajność

Smart Money API jest zbudowane dla szybkości. Zaimplementuj te strategie optymalizacji dla opóźnień poniżej 100ms i maksymalnej przepustowości.

Zobacz poziomy wydajności

Plany Pro i Enterprise obejmują zaawansowane funkcje buforowania i wydajności.