Design Log Storage System - Practice Coding Problems

Design Log Storage System - Problem

Design Log Storage System

You're tasked with building a sophisticated log storage and retrieval system that can efficiently store timestamped log entries and query them based on flexible time ranges.

Each log entry contains a unique ID (integer) and a timestamp in the format Year:Month:Day:Hour:Minute:Second (e.g., 2017:01:01:23:59:59). All components are zero-padded decimal numbers.

Your system must support:
• Storing logs: Add new log entries with their timestamps
• Flexible retrieval: Query logs within a time range with configurable precision (granularity)

The key challenge is handling granularity - when granularity is set to "Day", you ignore Hour:Minute:Second components and match entire days. For example, with granularity "Day" from 2017:01:01:23:59:59 to 2017:01:02:00:00:01, you'd find all logs from Jan 1st through Jan 2nd, regardless of specific times.

Example scenario: A server logging system where you need to quickly find all error logs from "last Tuesday" (Day granularity) or "between 2-3 PM yesterday" (Hour granularity).

Input & Output

basic_operations.py — Python

$ Input: LogSystem ls = new LogSystem(); ls.put(1, "2017:01:01:23:59:59"); ls.put(2, "2017:01:02:10:30:00"); ls.put(3, "2017:01:03:00:00:00"); ls.retrieve("2017:01:01:00:00:00", "2017:01:02:23:59:59", "Day");

› Output: [1, 2]

💡 Note: With 'Day' granularity, we ignore Hour:Minute:Second components. Log 1 (2017:01:01) and Log 2 (2017:01:02) both fall within the range from 2017:01:01 to 2017:01:02, while Log 3 (2017:01:03) is outside the range.

hour_granularity.py — Python

$ Input: LogSystem ls = new LogSystem(); ls.put(1, "2017:01:01:14:30:00"); ls.put(2, "2017:01:01:15:45:00"); ls.put(3, "2017:01:01:16:00:00"); ls.retrieve("2017:01:01:14:00:00", "2017:01:01:15:59:59", "Hour");

› Output: [1, 2]

💡 Note: With 'Hour' granularity, we consider Year:Month:Day:Hour but ignore Minute:Second. Log 1 (hour 14) and Log 2 (hour 15) are within the range 14-15, while Log 3 (hour 16) is outside.

year_granularity.py — Python

$ Input: LogSystem ls = new LogSystem(); ls.put(1, "2016:12:31:23:59:59"); ls.put(2, "2017:01:01:00:00:00"); ls.put(3, "2017:12:31:23:59:59"); ls.retrieve("2017:01:01:00:00:00", "2017:12:31:23:59:59", "Year");

› Output: [2, 3]

💡 Note: With 'Year' granularity, we only consider the year component. Both Log 2 and Log 3 are from 2017, matching our query range, while Log 1 from 2016 is outside the range.

Constraints

1 ≤ id ≤ 10⁶
1 ≤ timestamp.length = 19
timestamp format is strictly Year:Month:Day:Hour:Minute:Second
All timestamp components are zero-padded to 2 digits (except year which is 4 digits)
granularity is one of ["Year", "Month", "Day", "Hour", "Minute", "Second"]
At most 300 calls will be made to put and retrieve

Visualization

Tap to expand

Understanding the Visualization

Store Logs

Each log entry is stored with its ID and full timestamp, like cataloging books with detailed publication info

Query with Granularity

Users can search at different precision levels - by year, month, day, hour, etc., like asking for 'all books from 2017' vs 'books published in March 2017'

Smart Truncation

The system truncates timestamps to the requested granularity level before comparison, focusing only on relevant time components

Efficient Comparison

Uses optimized string comparison on truncated timestamps to quickly identify matching logs in the specified range

Key Takeaway

🎯 Key Insight: By using string index-based truncation instead of expensive string parsing, we can efficiently handle different granularity levels while maintaining fast O(n) query performance with optimized string operations.

Asked in

a Amazon 42 G Google 35 ⊞ Microsoft 28 f Meta 22

The optimal approach uses string index-based truncation to efficiently handle different granularity levels. By mapping granularity levels to specific string indices (Year→4, Month→7, Day→10, etc.), we can truncate timestamps using simple substring operations and leverage string comparison for range queries. This avoids expensive string splitting and parsing while maintaining O(n) query time with optimized constants.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search with String Parsing)	O(n * m)	O(n)	Store all logs and parse timestamps for each query
Optimized with Preprocessing (Optimal)	O(n) per query	O(n)	Store logs with pre-computed granularity keys for faster retrieval

Brute Force (Linear Search with String Parsing) — Algorithm Steps

Store logs as (id, timestamp) pairs in a list
For each retrieve query, iterate through all stored logs
Parse each timestamp string into components
Truncate timestamp components based on granularity
Compare truncated timestamps with query range
Collect matching log IDs and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Store All Logs

Keep logs in a simple list structure

Query Comes In

Receive start, end, and granularity parameters

Linear Scan

Check each log one by one against the query range

String Parsing

Parse and truncate timestamps for each comparison

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* ids;
    char** timestamps;
    int count;
    int capacity;
} LogSystem;

LogSystem* logSystemCreate() {
    LogSystem* ls = (LogSystem*)malloc(sizeof(LogSystem));
    ls->capacity = 1000;
    ls->ids = (int*)malloc(ls->capacity * sizeof(int));
    ls->timestamps = (char**)malloc(ls->capacity * sizeof(char*));
    ls->count = 0;
    return ls;
}

void logSystemPut(LogSystem* obj, int id, char* timestamp) {
    if (obj->count >= obj->capacity) {
        obj->capacity *= 2;
        obj->ids = (int*)realloc(obj->ids, obj->capacity * sizeof(int));
        obj->timestamps = (char**)realloc(obj->timestamps, obj->capacity * sizeof(char*));
    }
    obj->ids[obj->count] = id;
    obj->timestamps[obj->count] = strdup(timestamp);
    obj->count++;
}

char* truncateTimestamp(char* timestamp, int level) {
    char* result = (char*)malloc(20 * sizeof(char));
    strcpy(result, timestamp);
    int colonCount = 0;
    for (int i = 0; result[i]; i++) {
        if (result[i] == ':') {
            colonCount++;
            if (colonCount > level) {
                result[i] = '\0';
                break;
            }
        }
    }
    return result;
}

int* logSystemRetrieve(LogSystem* obj, char* start, char* end, char* granularity, int* returnSize) {
    int level = 0;
    if (strcmp(granularity, "Month") == 0) level = 1;
    else if (strcmp(granularity, "Day") == 0) level = 2;
    else if (strcmp(granularity, "Hour") == 0) level = 3;
    else if (strcmp(granularity, "Minute") == 0) level = 4;
    else if (strcmp(granularity, "Second") == 0) level = 5;
    
    char* truncatedStart = truncateTimestamp(start, level);
    char* truncatedEnd = truncateTimestamp(end, level);
    
    int* result = (int*)malloc(obj->count * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < obj->count; i++) {
        char* truncatedTs = truncateTimestamp(obj->timestamps[i], level);
        if (strcmp(truncatedStart, truncatedTs) <= 0 && strcmp(truncatedTs, truncatedEnd) <= 0) {
            result[(*returnSize)++] = obj->ids[i];
        }
        free(truncatedTs);
    }
    
    free(truncatedStart);
    free(truncatedEnd);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n logs × m queries, with string parsing overhead for each comparison

✓ Linear Growth

Space Complexity

O(n)

Store n log entries as (id, timestamp) pairs

⚡ Linearithmic Space

68.2K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search with String Parsing) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler