External API

import os, time, json, random, requests

API_HOST   = os.environ["ANALYTICS_API_HOST"]
PROJECT_ID = os.environ["ANALYTICS_PROJECT_ID"]
API_KEY    = os.environ["ANALYTICS_API_KEY"]

BASE = f"https://{API_HOST}/external/v1/{PROJECT_ID}"
MAX_EVENTS_PER_REQUEST = 100

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
})


def _sleep(attempt: int) -> None:
    time.sleep(min(2 ** (attempt - 1) * 0.25, 8) * (0.5 + random.random()))


def _post(path: str, payload, max_attempts: int = 5):
    """Back off on 429/5xx. Other 4xx are permanent — don't retry."""
    for attempt in range(1, max_attempts + 1):
        try:
            resp = session.post(f"{BASE}{path}", data=json.dumps(payload), timeout=30)
        except requests.RequestException:
            # Safe to retry: duplicates are removed downstream, gaps are not recoverable.
            if attempt == max_attempts:
                raise
            _sleep(attempt)
            continue

        request_id = resp.headers.get("X-Request-Id", "")
        if resp.status_code == 200:
            return resp.json()
        if resp.status_code == 400:
            raise ValueError(f"rejected (reqId={request_id}): {resp.text}")
        if resp.status_code == 401:
            raise PermissionError(f"bad API key (reqId={request_id})")
        if resp.status_code == 429 or resp.status_code >= 500:
            if attempt == max_attempts:
                raise RuntimeError(f"giving up {resp.status_code} (reqId={request_id})")
            _sleep(attempt)
            continue
        raise RuntimeError(f"unexpected {resp.status_code} (reqId={request_id})")


def send_events(events: list[dict]) -> None:
    for i in range(0, len(events), MAX_EVENTS_PER_REQUEST):
        _post("/events", events[i:i + MAX_EVENTS_PER_REQUEST])


def set_user_properties(user_id: str, properties: dict) -> None:
    _post("/users", {"$user_id": user_id, "$set": properties})


set_user_properties("user_123", {"plan": "premium"})
send_events([{
    "event": "purchase_completed",
    "time": int(time.time() * 1000),
    "user_id": "user_123",
    "properties": {"amount": 1499.5, "order_id": "ord_8891"},
    "source_ip": "183.83.123.75",
}])

const API_HOST   = process.env.ANALYTICS_API_HOST;
const PROJECT_ID = process.env.ANALYTICS_PROJECT_ID;
const API_KEY    = process.env.ANALYTICS_API_KEY;

const BASE = `https://${API_HOST}/external/v1/${PROJECT_ID}`;
const MAX_EVENTS_PER_REQUEST = 100;

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const backoff = (attempt) =>
  Math.min(2 ** (attempt - 1) * 250, 8000) * (0.5 + Math.random());

async function post(path, payload, maxAttempts = 5) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    let res;
    try {
      res = await fetch(`${BASE}${path}`, {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${API_KEY}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(payload),
        signal: AbortSignal.timeout(30_000),
      });
    } catch (err) {
      // Safe to retry: duplicates are removed downstream, gaps are not recoverable.
      if (attempt === maxAttempts) throw err;
      await sleep(backoff(attempt));
      continue;
    }

    const reqId = res.headers.get('x-request-id') ?? '';
    if (res.status === 200) return res.json();
    if (res.status === 400) throw new Error(`rejected (reqId=${reqId}): ${await res.text()}`);
    if (res.status === 401) throw new Error(`bad API key (reqId=${reqId})`);
    if (res.status === 429 || res.status >= 500) {
      if (attempt === maxAttempts) throw new Error(`giving up ${res.status} (reqId=${reqId})`);
      await sleep(backoff(attempt));
      continue;
    }
    throw new Error(`unexpected ${res.status} (reqId=${reqId})`);
  }
}

async function sendEvents(events) {
  for (let i = 0; i < events.length; i += MAX_EVENTS_PER_REQUEST) {
    await post('/events', events.slice(i, i + MAX_EVENTS_PER_REQUEST));
  }
}

async function setUserProperties(userId, properties) {
  await post('/users', { $user_id: userId, $set: properties });
}

await setUserProperties('user_123', { plan: 'premium' });
await sendEvents([{
  event: 'purchase_completed',
  time: Date.now(),
  user_id: 'user_123',
  properties: { amount: 1499.5, order_id: 'ord_8891' },
  source_ip: '183.83.123.75',
}]);

package analytics

import (
	"bytes"
	"encoding/json"
	"fmt"
	"math"
	"math/rand"
	"net/http"
	"time"
)

const maxEventsPerRequest = 100

type Event struct {
	Name     string         `json:"event"`
	Time     int64          `json:"time"`
	UserID   string         `json:"user_id,omitempty"`
	DeviceID string         `json:"device_id,omitempty"`
	Props    map[string]any `json:"properties"`
	SourceIP string         `json:"source_ip"`
}

type Client struct {
	base   string
	apiKey string
	http   *http.Client
}

func New(apiHost, projectID, apiKey string) *Client {
	return &Client{
		base:   fmt.Sprintf("https://%s/external/v1/%s", apiHost, projectID),
		apiKey: apiKey,
		http:   &http.Client{Timeout: 30 * time.Second},
	}
}

func (c *Client) SendEvents(events []Event) error {
	for i := 0; i < len(events); i += maxEventsPerRequest {
		end := min(i+maxEventsPerRequest, len(events))
		if err := c.post("/events", events[i:end]); err != nil {
			return err
		}
	}
	return nil
}

func (c *Client) SetUserProperties(userID string, props map[string]any) error {
	return c.post("/users", map[string]any{"$user_id": userID, "$set": props})
}

func (c *Client) post(path string, payload any) error {
	body, err := json.Marshal(payload)
	if err != nil {
		return err
	}
	const maxAttempts = 5
	for attempt := 1; attempt <= maxAttempts; attempt++ {
		req, err := http.NewRequest(http.MethodPost, c.base+path, bytes.NewReader(body))
		if err != nil {
			return err
		}
		req.Header.Set("Authorization", "Bearer "+c.apiKey)
		req.Header.Set("Content-Type", "application/json")

		resp, err := c.http.Do(req)
		if err != nil {
			// Safe to retry: duplicates are removed downstream, gaps are not recoverable.
			if attempt == maxAttempts {
				return err
			}
			time.Sleep(backoff(attempt))
			continue
		}
		reqID := resp.Header.Get("X-Request-Id")
		buf := new(bytes.Buffer)
		_, _ = buf.ReadFrom(resp.Body)
		resp.Body.Close()

		switch {
		case resp.StatusCode == http.StatusOK:
			return nil
		case resp.StatusCode == http.StatusBadRequest, resp.StatusCode == http.StatusUnauthorized:
			return fmt.Errorf("rejected %d (reqId=%s): %s", resp.StatusCode, reqID, buf)
		case resp.StatusCode == http.StatusTooManyRequests, resp.StatusCode >= 500:
			if attempt == maxAttempts {
				return fmt.Errorf("giving up %d (reqId=%s): %s", resp.StatusCode, reqID, buf)
			}
			time.Sleep(backoff(attempt))
		default:
			return fmt.Errorf("unexpected %d (reqId=%s): %s", resp.StatusCode, reqID, buf)
		}
	}
	return nil
}

func backoff(attempt int) time.Duration {
	base := math.Min(math.Pow(2, float64(attempt-1))*250, 8000)
	return time.Duration(base*(0.5+rand.Float64())) * time.Millisecond
}