Large Scale System Architecture and Evolution Questions

import hashlib
import bisect

class ConsistentHashRing:
    def __init__(self, replicas=100):
        # base replicas per weight unit; total virtual nodes = replicas * weight
        self.replicas = replicas
        self._ring = []               # sorted list of positions (ints)
        self._pos2node = {}          # position -> node_id
        self._nodes = {}             # node_id -> set(positions)

    def _hash(self, key):
        # 128-bit hash mapped to int
        h = hashlib.md5(key.encode('utf-8')).hexdigest()
        return int(h, 16)

    def add_node(self, node_id, weight=1):
        if node_id in self._nodes:
            raise ValueError("node already exists")
        positions = set()
        total = self.replicas * max(1, int(weight))
        for i in range(total):
            vnode_key = f"{node_id}#{i}"
            pos = self._hash(vnode_key)
            # avoid collision (extremely unlikely)
            while pos in self._pos2node:
                vnode_key += "_"
                pos = self._hash(vnode_key)
            bisect.insort(self._ring, pos)
            self._pos2node[pos] = node_id
            positions.add(pos)
        self._nodes[node_id] = positions

    def remove_node(self, node_id):
        if node_id not in self._nodes:
            raise KeyError("node not found")
        for pos in self._nodes[node_id]:
            idx = bisect.bisect_left(self._ring, pos)
            if idx < len(self._ring) and self._ring[idx] == pos:
                self._ring.pop(idx)
                del self._pos2node[pos]
        del self._nodes[node_id]

    def get_node(self, key):
        if not self._ring:
            return None
        pos = self._hash(key)
        idx = bisect.bisect_right(self._ring, pos)
        if idx == len(self._ring):
            idx = 0
        vnode_pos = self._ring[idx]
        return self._pos2node[vnode_pos]

GET /v1/users/{id}/timeline?limit=20&cursor=eyJwIjoiMjAyNS0xMi0wNiIsInNfIjoiMTIzNDUifQ==

{
  "items": [
    {"id":"post_987","created_at":"2025-12-06T12:00:00Z","text":"..."},
    ...
  ],
  "next_cursor":"eyJwIjoiMjAyNS0xMi0wNiIsInNfIjoiMTIzNDUifQ==",
  "has_more": true
}

import time
from collections import deque

class Deduplicator:
    def __init__(self, window_seconds):
        self.window = float(window_seconds)
        self.queue = deque()        # stores (timestamp, request_id)
        self.seen_set = set()       # request_ids currently in window

    def _evict_expired(self, now):
        cutoff = now - self.window
        while self.queue and self.queue[0][0] <= cutoff:
            ts, rid = self.queue.popleft()
            # remove rid if it still maps to this timestamp; simple set removal suffices
            self.seen_set.discard(rid)

    def seen(self, request_id, now=None):
        """
        Returns True if request_id is a duplicate within the sliding window,
        otherwise records it and returns False.
        now: optional float timestamp (seconds). If None, uses time.time().
        """
        if now is None:
            now = time.time()
        self._evict_expired(now)
        if request_id in self.seen_set:
            return True
        # record new id
        self.queue.append((now, request_id))
        self.seen_set.add(request_id)
        return False