System requirements

Functional:

Status Tracking: The service must track and update user statuses including online, idle, and offline.
Real-time Updates: Status updates must be reflected in real-time across the platform.
Scalability: The service must be able to handle a high number of concurrent users updating their status.
API Integration: Provide APIs for querying and updating user status.

Non-Functional:

Performance: The service should handle status updates with minimal latency.
Reliability: The service should be highly available and fault-tolerant.
Scalability: Should scale dynamically based on user load.
Security: Ensure secure handling and transmission of user status data.
Maintainability: Code and system architecture should be easy to maintain and extend.

Capacity estimation

Assumptions

Total Number of Users: Assume the system needs to support 10 million active users.
Concurrency Level: Assume at any given time, 10% of users might be active or change their status.
Status Update Frequency: On average, an active user changes their status once every 5 minutes.
Read-to-Write Ratio: Assume there are 5 reads for every write, reflecting the querying of status updates versus posting status changes.

Calculations

Write Operations: Each user updates their status once every 5 minutes. For 10 million users, that's (10,000,000 users×1 update)/5 minutes=2,000,000 updates/hour
Read Operations: Assuming a 5:1 read-to-write ratio, the read operations would be 2,000,000×5=10,000,000 reads/hour.

Resource Estimation

Data Storage: Each user's status might need about 100 bytes (accounting for user ID, status, timestamp, etc.). For 10 million users, that's roughly 1 GB of data.
Network Bandwidth: With frequent status updates and high concurrency, substantial bandwidth will be needed, especially for service synchronization across different regions if the service is globally distributed.
Memory and CPU: To ensure real-time performance, a significant portion of operations should be handled in-memory. High CPU resources will be required to process the continuous flow of reads and writes.

Considerations

Database Choices: Given the high write and read requirements, a NoSQL database like Cassandra or Redis, which can handle high throughput and horizontal scaling, might be appropriate.
Caching: Implementing caching mechanisms to reduce database load, using solutions like Redis to cache frequent queries or active user statuses.
Load Balancers: To manage traffic and ensure even distribution of requests across servers.

API design

API Endpoints

1. Update User Status

Endpoint: POST /status
Description: This API updates the status of a user. It is called whenever a user's status changes.

Payload:
{
  "userId": "string",
  "status": "string" // Values: "online", "idle", "offline"
}

Response:
{
  "success": true,
  "message": "Status updated successfully."
}

2. Get User Status

Endpoint: GET /status/{userId}
Parameters: userId is the identifier of the user.
Description: Retrieves the current status of a user.

Response:
{
  "userId": "string",
  "status": "string",
  "lastUpdated": "timestamp"
}

3. Batch Get Statuses

Endpoint: POST /statuses
Description: Retrieves the statuses for a batch of users, useful for applications needing to update multiple user statuses in one go.

Payload:
{
  "userIds": ["string"]
}

Response:
{
  "statuses": [
    {
      "userId": "string",
      "status": "string",
      "lastUpdated": "timestamp"
    }
  ]
}

Database design

Given the requirements, we'll consider a combination of NoSQL for primary real-time status data and possibly another database for logging and analytical purposes. Below is a detailed schema using Cassandra and an auxiliary system like PostgreSQL for detailed logs and analytics.

Main Tables in Cassandra

UserStatus Table

userId (Partition Key): String that uniquely identifies a user.
status: String indicating the current status (e.g., "online", "idle", "offline").
lastUpdated: Timestamp of the last status update.
This table serves the high-throughput, low-latency requirements for real-time updates and retrievals.

UserActivity Table

userId (Partition Key)
activityId (Clustering Column): UUID for each activity event.
timestamp: Timestamp when the activity was logged.
eventType: Type of event (e.g., "login", "logout", "status_change").
This table tracks detailed user activities, supporting audit and historical status analysis.

Auxiliary Tables in PostgreSQL

UserDetails Table

userId: Primary Key, foreign key linked to UserStatus.userId.
username: The user's name or username.
email: User's email address.
creationDate: Account creation date.
This relational table stores more static user information, not required for real-time operations but useful for management and analysis.

erDiagram
    USER_STATUS ||--o{ USER_ACTIVITY : logs
    USER_STATUS {
        string userId PK "Primary Key"
        string status "Current status"
        datetime lastUpdated "Last update timestamp"
    }
    USER_ACTIVITY {
        string userId PK "Primary Key"
        uuid activityId "Activity Identifier"
        datetime timestamp "Event Timestamp"
        string eventType "Type of Activity"
    }
    USER_DETAILS ||--o{ USER_STATUS : "Has Status"
    USER_DETAILS {
        string userId PK "Primary Key"
        string username "Username"
        string email "Email"
        datetime creationDate "Account Creation Date"
    }

High-level design

Key Components

Web Servers

Handle incoming API requests (e.g., status updates, status queries).
Interface with both the in-memory cache and the databases for data retrieval and update.

Load Balancer

Distributes incoming traffic and requests evenly across web servers.
Enhances the system's reliability and availability.

Cache Layer

Provides quick access to frequently read data, such as current user statuses.
Reduces latency and load on the primary database.

Database Layer

NoSQL database (e.g., Cassandra) stores current statuses and handles high write and read throughput.
SQL database (e.g., PostgreSQL) for storing user details and logging historical data.

Message Queue

Handles asynchronous processing of status updates.
Decouples the receipt of a status change from its processing, enhancing system scalability and reliability.

Notification Service

Sends real-time updates to subscribed clients when user statuses change.
Utilizes WebSockets or similar technology for push notifications.

Description of the Diagram

Load Balancer (LB) receives all client requests and distributes them across available Web Servers (WS), which handle all business logic and data processing.
Web Servers (WS) interact directly with the Cache Layer (CL) for fast retrieval of user statuses and write through to the Database Layer (DB) for persistence.
Message Queue (MQ) buffers status updates, which are processed by the Notification Service (NS) to notify other online users or services of the change.
Database Layer (DB) consists of different databases suited to their specific tasks—Cassandra for real-time operations and PostgreSQL for analytics and detailed logs.
Cache Layer (CL) also receives updates from the database to keep the cached data fresh.

graph TB
    LB[Load Balancer] --> WS[Web Servers]
    WS --> CL[Cache Layer]
    WS --> DB[Database Layer]
    WS --> MQ[Message Queue]
    MQ --> NS[Notification Service]
    DB --> CL
    NS -.-> |Subscribe to updates| CL

    subgraph Databases
        DB[Database Layer]
        CL[Cache Layer]
    end
    subgraph Processing
        WS[Web Servers]
        MQ[Message Queue]
        NS[Notification Service]
    end

Request flows

We'll examine two main scenarios:

Updating a User Status
Retrieving a User Status

1. Updating a User Status

This flow describes what happens when a user changes their status (e.g., from "online" to "idle").

Sequence of Events:

Client Request: A client application sends a status update request to the Load Balancer.
Load Balancer: Distributes the request to one of the available Web Servers.
Web Server: Receives the request and sends the new status to the Message Queue for asynchronous processing.
Message Queue: Temporarily stores the update until processed by the Notification Service.
Notification Service: Processes the update, persists the new status in the Database, and updates the Cache.
Cache: Updates the current status in the cache for quick access.
Notification Service: Sends notifications to other clients about the status change (if subscribed).

2. Retrieving a User Status

This flow covers how a user’s current status is fetched.

Sequence of Events:

Client Request: A client requests the status of a user via the Load Balancer.
Load Balancer: Forwards the request to a Web Server.
Web Server: Checks the Cache for the user’s current status.
Cache Miss (if any): If the status is not in the cache, the Web Server queries the Database, updates the cache with the latest status, and then returns the status to the client.
Cache Hit: If the status is in the cache, it is immediately returned to the client.

sequenceDiagram
    participant C as Client
    participant LB as Load Balancer
    participant WS as Web Server
    participant MQ as Message Queue
    participant NS as Notification Service
    participant DB as Database
    participant Cache as Cache

    alt Updating User Status
        C->>+LB: POST /status (update)
        LB->>+WS: Route request
        WS->>+MQ: Send status update
        MQ->>+NS: Process update
        NS->>+DB: Update status
        NS->>+Cache: Update cache
        Cache-->>-NS: Cache updated
        NS-->>-C: Notification of status update
    end

    alt Retrieving User Status
        C->>+LB: GET /status/{userId}
        LB->>+WS: Route request
        WS->>+Cache: Check status
        alt Cache Hit

            WS-->>-C: Status response
        else Cache Miss
            WS->>+DB: Query status
            DB-->>-WS: Status data
            WS->>Cache: Update cache
            Cache-->>-WS: Cache updated
            WS-->>-C: Status response
        end
    end

Detailed component design

1. Web Server

Purpose: The Web Server handles all incoming API requests for updating and retrieving user statuses.

Key Responsibilities:

Request Routing: Distributes incoming requests to appropriate handlers.
Status Update Handling: Interacts with the Message Queue to manage asynchronous status updates.
Status Retrieval: Queries the Cache Layer directly for status retrievals and updates the cache if necessary.

Scalability:

Load Balancing: Utilizes a load balancer to distribute incoming traffic evenly across multiple instances, ensuring no single point of overload.
Statelessness: Maintains no local state, allowing any request to be served by any instance, facilitating easy scaling.

Technologies:

Language/Framework: Could use Node.js for its non-blocking I/O model, well-suited for handling a large number of simultaneous connections.
Integration: Connects with Redis for caching and RabbitMQ for message queuing to handle high throughput and asynchronous processing.

2. Cache Layer

Purpose: The Cache Layer provides fast access to frequently accessed data, such as user statuses, to reduce latency and database load.

Key Responsibilities:

Data Storage: Temporarily stores user statuses for quick retrieval.
Cache Invalidation: Ensures that data in the cache is up-to-date with the latest changes from the database.

Scalability:

Horizontal Scaling: Supports scaling out by adding more cache nodes. Data partitioning can be applied to distribute the load evenly across nodes.
Consistency: Implements eventual consistency mechanisms to handle synchronization between cache nodes and the primary database.

Technologies:

Redis: Ideal for this role due to its performance and features like publish/subscribe, which are useful for invalidating cache entries when data changes.

3. Notification Service

Purpose: Manages the distribution of real-time status updates to other clients and services.

Key Responsibilities:

Message Processing: Processes messages from the Message Queue regarding status updates.
Client Notification: Notifies relevant clients of status changes, using efficient communication protocols.

Scalability:

Asynchronous Processing: Handles incoming messages asynchronously, allowing for high throughput without blocking.
Scalable Distribution: Can scale horizontally by adding more instances as the number of notifications or the complexity of the routing logic increases.

Technologies:

WebSocket: For real-time, bidirectional communication between clients and the server.
RabbitMQ: Used for decoupling the receipt of status updates from their processing and distribution.

graph TD
    LB[Load Balancer] --> WS[Web Server]
    WS --> MQ[Message Queue]
    MQ --> NS[Notification Service]
    WS --> Cache[Cache Layer]
    NS --> DB[Database]
    NS --> Cache
    Cache -.-> WS
    DB -.-> Cache
    NS -.-> |WebSocket| Clients[Clients]

    subgraph Core Components
        WS
        MQ
        NS
        Cache
        DB
    end

Trade offs/Tech choices

1. NoSQL vs. SQL Databases

Trade-off:

Scalability and Performance: Chose NoSQL (Cassandra) for user statuses to leverage its fast writes and reads, which are essential for real-time applications.
Complexity and Feature Richness: Sacrificed some of the advanced querying capabilities and transactional integrity offered by SQL databases.

Technology Choice: Cassandra for real-time operations due to its superior performance in handling large volumes of data with high write and read throughput. PostgreSQL was chosen for detailed logs and analytics where complex queries are more common.

2. Stateless Web Servers

Trade-off:

Scalability: By making web servers stateless, they can easily handle increases in traffic by simply adding more servers.
Resource Utilization: Stateless servers might lead to more frequent cache misses and database hits, which could increase latency and load.

Technology Choice: Using stateless architecture facilitated by a load balancer (like NGINX or AWS ELB) to ensure requests can be served by any server, enhancing reliability and ease of scaling.

3. Cache Usage (Redis)

Trade-off:

Performance vs. Cost: Implementing a caching layer improves read performance drastically but adds additional complexity and cost in terms of maintaining another layer in the infrastructure.
Data Consistency: Caching can lead to situations where stale data is served unless proper invalidation strategies are employed.

Technology Choice: Redis, known for its quick data access speeds and robustness, fitting the requirement for a high-performance, in-memory data store that supports rapid read and write operations.

4. Asynchronous Processing with Message Queues

Trade-off:

Complexity vs. Responsiveness: Introducing message queues (RabbitMQ) increases system complexity but allows for decoupling components, leading to a more resilient and scalable architecture.
Latency vs. Throughput: Asynchronous processing might introduce slight delays in processing but significantly increases throughput and system resilience.

Technology Choice: RabbitMQ offers reliable messaging with strong delivery guarantees and is widely used in systems requiring high levels of decoupling and scalability.

5. Real-Time Notification with WebSockets

Trade-off:

Resource Utilization vs. User Experience: WebSockets maintain a persistent connection between the client and server, which consumes more server resources but provides a real-time user experience.
Complexity vs. Functionality: Implementing WebSockets adds complexity to the system but is essential for delivering instant status updates to users.

Technology Choice: Chose WebSockets for real-time bidirectional communication to ensure that users receive status updates without any perceptible delay.

Failure scenarios/bottlenecks

Failure Scenarios

Database Failure

Scenario: A failure in the Cassandra cluster could prevent new statuses from being written or existing statuses from being read.
Mitigation: Use Cassandra’s built-in replication features to replicate data across multiple nodes in different data centers. Employ a failover strategy that automatically switches to a healthy replica in case of a node failure.

Cache Failure

Scenario: If Redis experiences an outage, the system would face high latency as all requests would need to go to the database.
Mitigation: Implement redundant caching layers and use a master-slave Redis configuration. On cache failure, switch to a slave until the master is restored. Additionally, ensure that cache misses are gracefully handled by fetching data from the database.

Message Queue Overload

Scenario: The message queue getting overloaded could delay the processing of status updates.
Mitigation: Monitor the queue length and scale the number of worker processes dynamically based on the workload. Also, consider implementing priority queuing where critical updates are processed first.

Web Server Downtime

Scenario: Downtime or high latency in the web server layer due to traffic spikes or DDoS attacks.
Mitigation: Use auto-scaling groups for web servers behind a load balancer to handle sudden increases in load. Implement rate limiting and DDoS protection strategies to mitigate abusive traffic patterns.

Network Issues

Scenario: Network latency or partitioning can delay or prevent data synchronization across the distributed components.
Mitigation: Design the network for redundancy, with multiple connectivity paths to prevent single points of failure. Use health checks and automatic rerouting to handle network partitioning.

Bottlenecks

Cache Hotspots

Bottleneck: Over-reliance on certain cache nodes due to uneven data distribution can lead to hotspots.
Mitigation: Use consistent hashing for cache distribution to evenly distribute load across cache nodes. Regularly analyze access patterns and adjust the caching strategy as needed.

Database Write Throughput

Bottleneck: High write throughput demands on the database during peak times could lead to performance degradation.
Mitigation: Use database sharding to distribute writes across multiple database instances. Consider write-behind caching to batch and asynchronously write updates to the database.

Real-Time Notification Delays

Bottleneck: Delays in notifying clients about status updates due to WebSocket performance limits under high load.
Mitigation: Optimize WebSocket servers and increase their scalability by using a more efficient connection handling model or by offloading tasks to dedicated services.

Future improvements

1. Adaptive Caching Strategies

Improvement: Implement machine learning algorithms to predict user activity patterns and adjust the caching strategy dynamically. This can help optimize cache hit rates and reduce latency.
Benefit: By adapting to user behavior, the system can ensure that resources are allocated more efficiently, improving overall performance.

2. Service Decomposition

Improvement: Break down the service into more granular microservices. For example, separate services for handling status updates, user activity logging, and notifications.
Benefit: This approach enhances scalability by allowing individual components to scale independently based on demand. It also improves maintainability and makes it easier to deploy updates without affecting the entire system.

3. Geographic Data Distribution

Improvement: Implement geographic distribution of data and services to reduce latency for globally dispersed users. Use edge computing principles to bring data processing closer to the end users.
Benefit: Reduces latency significantly and improves user experience, particularly in regions far from the central data center.

4. Enhanced Security Measures

Improvement: Introduce more robust security protocols for data transmission and storage, including advanced encryption methods and continuous security audits.
Benefit: Enhances the security of user data, reducing the risk of data breaches and building trust with the users.

5. Real-Time Analytics and Monitoring

Improvement: Develop a real-time analytics engine that can process and visualize user status data as it happens, providing insights into user behavior and system performance.
Benefit: Allows for immediate response to any critical incidents and better decision-making based on user activity trends.

6. API Gateway Implementation

Improvement: Introduce an API Gateway to manage API requests, enforce throttling policies, and provide an additional layer of security.
Benefit: Streamlines API management, enhances security, and improves the ability to handle large volumes of requests by offloading authentication, caching, and rate limiting to the gateway.

Solutions

nectar4678 - 05/14/2024

3