Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Upravljanje sesijama WebSocket

Lekcija 11 od 14 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Savladaj životni ciklus sesije
  2. Životni ciklus sesije
  3. Automatsko ponovno povezivanje
  4. Upravljanje vijekom trajanja sesije
  5. Skup sesija (Session Pool)
  6. Metrike za praćenje
  7. Ključne točke

Ažurirano 3. studenoga 2026., na temelju stranice xAI Text to Speech, koja spominje „sesijsku dozvolu“ od 600 sekundi i vezu bez vremenskog ograničenja. Strategija obnove u nastavku je mjera opreza. Izvor: Text to Speech.

Savladaj životni ciklus sesije

U produkcijskom okruženju, pouzdano upravljanje sesijama WebSocket ono je što razlikuje prototip od stabilnog proizvoda. Sesije TTS-a imaju specifična ograničenja (vijek trajanja, ograničenja istovremenosti) koja tvoja aplikacija mora ispravno obrađivati.

Životni ciklus sesije

WebSocket sesija TTS-a prolazi kroz ovaj ciklus:

  1. Otvaranje: povezivanje na wss://api.x.ai/v1/tts s parametrima
  2. Aktivno: razmjena poruka text.delta/audio.delta
  3. Normalno zatvaranje: klijent ili poslužitelj zatvara vezu
  4. Neočekivano zatvaranje: greška, održavanje ili istek sesijske dozvole od 600 sekundi koju spominje dokumentacija

Detekcija zatvaranja

Poslužitelj može zatvoriti vezu u bilo kojem trenutku (interna greška, održavanje, kraj sesijske dozvole). Tvoja aplikacija uvijek treba obrađivati događaj zatvaranja:

async def managed_session(api_key, language="en", voice="eve"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        async with websockets.connect(uri, additional_headers=headers) as ws:
            yield ws
    except websockets.ConnectionClosed as e:
        print(f"Connection closed: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Connection lost unexpectedly")

Automatsko ponovno povezivanje

Za aplikacije koje rade dulje vrijeme, implementiraj ponovno povezivanje s eksponencijalnim kašnjenjem (exponential backoff):

import asyncio
import random

class TTSSessionManager:
    def __init__(self, api_key, language="en", voice="eve"):
        self.api_key = api_key
        self.language = language
        self.voice = voice
        self.ws = None
        self.max_retries = 5

    async def connect(self):
        uri = f"wss://api.x.ai/v1/tts?language={self.language}&voice={self.voice}"
        headers = {"Authorization": f"Bearer {self.api_key}"}

        for attempt in range(self.max_retries):
            try:
                self.ws = await websockets.connect(uri, additional_headers=headers)
                print(f"Connected (attempt {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Connection failed: {e}. Retrying in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Could not connect after 5 attempts")

    async def ensure_connected(self):
        if self.ws is None or self.ws.closed:
            await self.connect()

    async def synthesize(self, text):
        await self.ensure_connected()

        try:
            await self.ws.send(json.dumps({
                "type": "text.delta",
                "delta": text
            }))
            await self.ws.send(json.dumps({"type": "text.done"}))

            audio_chunks = []
            async for msg in self.ws:
                data = json.loads(msg)
                if data["type"] == "audio.delta":
                    audio_chunks.append(base64.b64decode(data["delta"]))
                elif data["type"] == "audio.done":
                    break
                elif data["type"] == "error":
                    raise Exception(data["message"])

            return b"".join(audio_chunks)

        except websockets.ConnectionClosed:
            # Ponovno povezivanje i ponovni pokušaj
            await self.connect()
            return await self.synthesize(text)

Upravljanje vijekom trajanja sesije

Stranica xAI Text to Speech spominje „sesijsku dozvolu“ od 600 sekundi, ali ne navodi kada počinje niti što se događa kada završi, a zasebno navodi da veza nema vremensko ograničenje. Najoprezniji pristup je brojanje od trenutka povezivanja i obnova sesije prije tog roka:

import time

class TTLAwareSession:
    TTL = 600  # sekundi
    REFRESH_MARGIN = 60  # ponovno povezivanje 60 s prije isteka

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... povezivanje ...
        self.connected_at = time.time()

    def should_refresh(self):
        if self.connected_at is None:
            return True
        elapsed = time.time() - self.connected_at
        return elapsed >= (self.TTL - self.REFRESH_MARGIN)

    async def synthesize(self, text):
        if self.should_refresh():
            await self.connect()  # Nova sesija
        # ... slanje teksta ...

Ponovno povezivanje 60 sekundi prije isteka sprječava prekidanje usred sinteze.

Skup sesija (Session Pool)

Za aplikacije s velikim prometom, održavaj skup ponovno upotrebljivih sesija:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maksimum 50 po timu
        self.available = asyncio.Queue()
        self.active_count = 0

    async def acquire(self):
        if not self.available.empty():
            session = await self.available.get()
            if not session.should_refresh():
                return session

        if self.active_count < self.pool_size:
            session = TTSSessionManager(self.api_key)
            await session.connect()
            self.active_count += 1
            return session

        # Čekaj da se sesija oslobodi
        return await self.available.get()

    async def release(self, session):
        await self.available.put(session)

Veličinu skupa drži na djeliću ograničenja od 50 sesija kako bi ostavio prostora za druge servise tvoje aplikacije.

Metrike za praćenje

Kako bi sesije ostale zdrave u produkciji, prati:

  • Broj aktivnih sesija: ne smije prijeći 50
  • Stopa ponovnog povezivanja: visoka stopa ukazuje na problem s mrežom ili vijekom trajanja
  • Latencija prvog audio.delta: mjeri koliko je servis responzivan
  • Greške WebSocketa: abnormalni kodovi zatvaranja (1006, 1011)
class MetricsCollector:
    def __init__(self):
        self.connections = 0
        self.reconnections = 0
        self.errors = 0
        self.first_audio_latencies = []

    def record_connection(self):
        self.connections += 1

    def record_reconnection(self):
        self.reconnections += 1

    def record_first_audio(self, latency_ms):
        self.first_audio_latencies.append(latency_ms)

Ključne točke

  • Dokumentacija spominje sesijsku dozvolu od 600 sekundi: radi sigurnosti, broji je od trenutka povezivanja
  • Implementiraj automatsko ponovno povezivanje s eksponencijalnim kašnjenjem
  • Obnovi sesiju prije tog roka (s marginom od 60 sekundi)
  • Koristi skup sesija za aplikacije s velikim prometom
  • Ostani unutar ograničenja od 50 istovremenih sesija po timu
  • Prati metrike povezivanja u produkciji