Analytics Engine is a microservice designed to capture and analyze user events in real-time using Redis. It aggregates and provides insights into daily, weekly, and monthly usage, offering both global and command-specific statistics.

When building applications that require real-time insights, several challenges often arise:

1. Scalability:

   • Traditional analytics solutions can struggle with large volumes of data, leading to bottlenecks. Analytics Engine scales horizontally, efficiently handling increasing loads.

2. Data Persistence:

   • Ensuring that usage data is stored and retrievable after server restarts or crashes is crucial. By leveraging Redis, Analytics Engine provides reliable persistence for your analytics data.

3. Resource Efficiency:

   • Analytics systems can consume significant resources if not optimized. Analytics Engine efficiently manages and stores only the necessary data, reducing overhead.

4. Ease of Integration:

   • Integrating analytics into an application should be straightforward. Analytics Engine offers a simple API, making it easy to send and retrieve event data without additional complexity.

5. Real-time Insights:

   • Many systems struggle with delivering real-time analytics. Analytics Engine provides immediate access to usage data, enabling you to make informed decisions quickly.

By using Analytics Engine, you gain:

• Scalability: Efficiently handles large volumes of events across distributed instances.
• Reliability: Persistent data storage ensures that your analytics are accurate and durable.
• Simplicity: A clean, easy-to-use API for tracking and aggregating event data.
• Flexibility: Aggregate data by the day, week, or month, and get detailed insights into each command.

• Features
• Requirements
• Environment Variables
• Running with Docker
• Running with Docker Compose
• API Usage
• Contributing
• License

• Track and store user events with timestamps.
• Aggregate event data into daily, weekly, and monthly summaries.
• Retrieve global usage statistics as well as per-command insights.
• Easy deployment with Docker and Docker Compose.

• Docker installed on your server or local machine.
• Docker Compose (optional, but recommended).

Set the following environment variables before running the service:

• REDIS_URL: URL of the Redis server (e.g., redis://localhost:6379).
• REDIS_KEY: Redis key prefix for storing event data (default is analyticsEngine).
• PORT: Port on which the service will run (default is 8080).
• API_AUTH: API key for securing the service.
• MAX_AGE: Maximum retention time for event data in days (e.g., 30).

You can easily run Analytics Engine using Docker. Follow these steps:

docker pull ghcr.io/digital39999/analytics-engine:latest

docker run -d \
  -e REDIS_URL="redis://your-redis-url:6379" \
  -e PORT=8080 \
  -e MAX_AGE=30 \
  -e API_AUTH="your-api-key" \
  -p 8080:8080 \
  ghcr.io/digital39999/redis-analytics-engine:latest

If you prefer to use Docker Compose, follow these steps:

version: '3.8'

services:
  analytics-engine:
    image: ghcr.io/digital39999/analytics-engine:latest
    environment:
      REDIS_URL: "redis://redis:6379"
      PORT: 8080
      API_AUTH: "your-api-key"
      MAX_AGE: 365
    ports:
      - "8080:8080"
    depends_on:
      - redis

  redis:
    image: redis:latest
    ports:
      - "6379:6379"

docker-compose up -d

curl -X POST http://localhost:8080/event \
-H "Content-Type: application/json" \
-H "Authorization: your-api-key" \
-d '{
  "name": "login",
  "uniqueId": "user123",
  "createdAt": 1632960000000,
  "type": "auth"
}'

curl -X GET http://localhost:8080/analytics

curl -X GET http://localhost:8080/stats

curl -X DELETE http://localhost:8080/analytics

const apiUrl = 'http://localhost:8080/event';

async function recordEvent() {
  try {
    const response = await fetch(apiUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'your-api-key'
      },
      body: JSON.stringify({
        name: 'login',
        uniqueId: 'user123',
        createdAt: Date.now()
        type: 'auth'
      })
    }).then(res => res.json());

    if (response.error) throw new Error(response.error);
    console.log('Event recorded successfully:', response.data);
  } catch (error) {
    console.error('Error recording event:', error.message);
  }
}

recordEvent();

import requests
import time

api_url = 'http://localhost:8080/event'

def record_event():
    data = {
        'name': 'login',
        'uniqueId': 'user123',
        'createdAt': int(time.time() * 1000)  # milliseconds
        'type': 'auth'
    }
    
    headers = {
        'Authorization': 'your-api-key',
        'Content-Type': 'application/json'
    }
    
    response = requests.post(api_url, json=data, headers=headers)
    if response.status_code == 200:
        print('Event recorded successfully:', response.json())
    else:
        print('Error recording event:', response.text)

record_event()

If you'd like to contribute to this project, feel free to open a pull request or submit an issue on the GitHub repository.

This project is licensed under the MIT License. See the LICENSE file for more details.