Bot Kripto: Menangani Reconnect WebSocket dan Gap Data

Masalah: Koneksi WebSocket yang Tidak Stabil

WebSocket adalah tulang punggung bot kripto modern yang membutuhkan data pasar real-time. Namun, koneksi WebSocket tidak selalu stabil. Jaringan bisa terputus, server bisa mengalami masalah, atau bursa mungkin menerapkan batasan koneksi. Kegagalan menangani masalah ini dapat menyebabkan:

• Kehilangan data: Bot mungkin kehilangan pembaruan harga penting, yang mengarah pada keputusan trading yang salah.
• Perilaku tak terduga: Tanpa data yang benar, bot mungkin melakukan tindakan yang tidak diinginkan.
• Kerugian finansial: Keputusan trading yang buruk dapat mengakibatkan kerugian.

Desain: Arsitektur yang Tangguh

Untuk mengatasi masalah ini, kita memerlukan arsitektur yang tangguh yang mencakup:

• Reconnect otomatis: Bot harus secara otomatis mencoba menyambung kembali ke WebSocket jika koneksi terputus.
• Penanganan kesalahan: Bot harus menangani kesalahan koneksi dengan baik dan mencegah crash.
• Gap data: Bot harus mendeteksi dan mengisi gap data yang mungkin terjadi selama pemutusan koneksi.

Trade-off utama di sini adalah antara latensi dan reliability. Reconnect yang lebih agresif dapat mengurangi gap data tetapi dapat meningkatkan latensi. Sebaliknya, reconnect yang lebih lambat dapat mengurangi latensi tetapi dapat menyebabkan gap data yang lebih besar.

Langkah Implementasi

1. Gunakan Library Reconnect WebSocket

Library seperti reconnecting-websocket (JavaScript) menyediakan fungsionalitas reconnect otomatis. Contoh:

const ReconnectingWebSocket = require('reconnecting-websocket');

const ws = new ReconnectingWebSocket('wss://api.coingecko.com/ws/v3');

ws.onopen = () => {
  console.log('Connected to WebSocket');
};

ws.onmessage = (event) => {
  console.log('Received:', event.data);
};

ws.onclose = () => {
  console.log('Disconnected from WebSocket');
};

ws.onerror = (error) => {
  console.error('WebSocket error:', error);
};

2. Implementasikan Logika Reconnect

Jika library tidak mencukupi, implementasikan logika reconnect sendiri. Gunakan exponential backoff untuk menghindari membebani server.

import asyncio
import websockets
import time

async def connect():
    uri = "wss://api.example.com/ws"
    backoff_delay = 1  # Detik
    max_delay = 60      # Detik

    while True:
        try:
            async with websockets.connect(uri) as websocket:
                print("Terhubung ke WebSocket")
                backoff_delay = 1  # Reset backoff saat terhubung
                while True:
                    try:
                        message = await websocket.recv()
                        print(f"Menerima: {message}")
                        # Proses pesan di sini
                    except websockets.exceptions.ConnectionClosedError as e:
                        print(f"Koneksi tertutup: {e}")
                        break
                    except Exception as e:
                        print(f"Error saat menerima pesan: {e}")
                        break

        except websockets.exceptions.ConnectionRefusedError:
            print("Koneksi ditolak. Mencoba lagi...")
        except Exception as e:
            print(f"Error koneksi: {e}")

        print(f"Mencoba reconnect dalam {backoff_delay} detik...")
        await asyncio.sleep(backoff_delay)
        backoff_delay = min(backoff_delay * 2, max_delay)

asyncio.run(connect())

3. Tangani Gap Data

Saat reconnect, data mungkin hilang. Ada beberapa cara untuk menanganinya:

1. Cache data: Simpan data terbaru dan isi gap berdasarkan data yang tersimpan.
2. Minta data historis: Gunakan REST API bursa untuk meminta data yang hilang.
3. Interpolasi: Estimasi data yang hilang menggunakan data sebelum dan sesudah gap (berhati-hatilah dengan metode ini).

Contoh (pseudocode):

On reconnect:
  last_received_timestamp = ... // Timestamp terakhir yang diterima
  current_timestamp = now()

  if (current_timestamp - last_received_timestamp) > threshold:
    // Minta data historis menggunakan REST API
    missing_data = fetch_historical_data(last_received_timestamp, current_timestamp)
    // Gabungkan data historis ke dalam stream data

4. Pertimbangkan Trade-off Latensi vs.

Reliability

Reconnect yang lebih cepat berarti lebih sedikit gap data, tetapi juga lebih banyak overhead. Eksperimen dengan berbagai strategi reconnect untuk menemukan sweet spot untuk bot Anda.

Pitfall Produksi

• Rate limiting: Bursa sering memberlakukan rate limit pada koneksi WebSocket dan REST API. Pastikan bot Anda tidak melampaui batas ini.
• Ketergantungan pihak ketiga: Library dan API pihak ketiga dapat berubah atau menjadi tidak tersedia. Pantau perubahan ini dan rencanakan untuk kemungkinan kegagalan.
• Kondisi balapan: Pastikan logika reconnect Anda aman dari thread dan tidak menyebabkan kondisi balapan.
• Logging dan monitoring: Implementasikan logging dan monitoring yang komprehensif untuk mendeteksi dan mendiagnosis masalah koneksi.

Checklist

• [ ] Gunakan library reconnect WebSocket atau implementasikan logika reconnect sendiri.
• [ ] Terapkan exponential backoff untuk reconnect.
• [ ] Tangani kesalahan koneksi dengan baik.
• [ ] Deteksi dan isi gap data.
• [ ] Pertimbangkan trade-off latensi vs. reliability.
• [ ] Pantau rate limit bursa.
• [ ] Rencanakan untuk kemungkinan kegagalan library dan API pihak ketiga.
• [ ] Pastikan logika reconnect aman dari thread.
• [ ] Implementasikan logging dan monitoring yang komprehensif.
• [ ] Uji bot Anda secara menyeluruh di lingkungan produksi sebelum trading live.

Tips Tambahan

• Gunakan variabel lingkungan (environment variables) untuk menyimpan kredensial API dan konfigurasi lainnya. Ini mencegah informasi sensitif disimpan dalam kode Anda.
• Terapkan logika idempotency untuk memastikan bahwa order trading hanya dieksekusi sekali, bahkan jika ada kesalahan koneksi.
• Selalu uji bot Anda di lingkungan paper trading sebelum menggunakannya dengan uang sungguhan.

FAQ

Bagaimana cara memilih library reconnect WebSocket yang tepat?

Pertimbangkan faktor-faktor seperti ukuran library, dependensi, dokumentasi, dan dukungan komunitas. reconnecting-websocket adalah pilihan yang populer dan terpercaya.

Bagaimana cara menangani rate limit bursa?

Implementasikan logika untuk melacak penggunaan API Anda dan menunda permintaan jika Anda mendekati batas rate limit. Gunakan jitter (penundaan acak) untuk menghindari memicu rate limit secara bersamaan dengan bot lain.