# 2 — GlobalChat Realtime Messaging Service

**Rank 2 of 28** · Tier S · `app/GlobalChatService`
**Stack:** Go 1.25, Cassandra 4.1.3 (gocql + gocqlx), Redis, Kafka (IBM/sarama), gorilla/websocket, chi, Prometheus, APNs, AWS S3
**Status:** Deployed under systemd on the origin host. Schema migrates on boot. Runbook written.

> **Why this ranks here.** It is the other half of the systems-design canon:
> a stateful realtime service. Connection lifecycle, presence, ordering,
> delivery, backpressure, fan-out, and a storage layer whose partition design
> you have to defend. 26K lines of Go with 29 test files including benchmarks
> and dedicated race tests.

---

## What it is

A single Go service carrying every messaging surface of a multi-mode consumer
platform: 1:1 chat, groups, communities, channels, presence, typing, reactions,
edits/deletes, view-once media, live location, voice transcription, link
previews, push, and WebRTC call signaling.

## Architecture

```
Clients (iOS · Web · Android)
   │  wss://…/ws                      HTTPS
   ▼                                    ▼
WSSServer (gorilla/websocket)      HTTPServer (chi + CORS)
   │                                    │
   └──────────────┬─────────────────────┘
                  ▼
         event_router · session_manager
                  │
     ┌────────────┼───────────────┬──────────────┐
     ▼            ▼               ▼              ▼
 Cassandra      Redis           Kafka          S3
 (messages,   (presence,     (push consumer,  (media)
  history)     sessions)      cross-service)
                  │
                  ▼
            APNs / push sender
```

## The engineering that matters

### Connection and session layer
`wss.go`, `session_manager.go`, `presence.go` — connection registry, presence
TTL, session adoption. The WebSocket hub is benchmarked (`wss_bench_test.go`)
and batch-tested (`wss_batch_test.go`), not just unit-tested.

### Storage layer
`cass.go` builds the Cassandra session with TLS and x509 trust, wrapped in
`gocqlx`. Conversation identity is its own module (`conversationid.go`) with
its own test — because a conversation id that is derived inconsistently across
services silently splits a chat in half.

### Contract discipline
`api/openapi.yaml` + `api/asyncapi.yaml` with shared component schemas, and an
**`asyncapi_coverage_test.go`** that fails the build when the implementation
and the async contract drift. That test is the artifact to point at when a bank
asks how you keep services honest.

### Concurrency correctness
Named, dedicated tests: `calling_race_test.go`, `typing_test.go`,
`edit_delete_test.go`, `integration_loop_test.go`,
`integration_cassandra_test.go`. Race conditions in this service were treated
as first-class defects with reproductions, not as flakes.

### Observability
`metrics.go` + `metrics_render_test.go` + `pprof.go`. Prometheus surface, and a
test that the rendering itself is correct.

## Scope

| Metric | Value |
|---|---|
| Go source | 26,176 lines, 77 files |
| Test files | 29, including benchmarks and race tests |
| Feature modules | ~40 (`service/*.go`) |
| Datastores | Cassandra, Redis, Kafka, S3 |
| Contracts | OpenAPI + AsyncAPI, CI-checked for coverage |
| Deployment | systemd unit + docker-compose local bring-up + `RUNBOOK.md` |

## Interview surface this opens

- WebSocket connection lifecycle at scale: heartbeats, half-open detection, reconnection with resume
- Presence: TTL vs heartbeat vs Redis keyspace notifications, and the cost of each
- Message ordering and idempotency across reconnects
- Cassandra partition design for chat history — the classic "wide partition" trap
- Fan-out to N devices per user, and push as the fallback path
- Backpressure: what happens when a slow client cannot drain its channel