Add Redis TS helper and integrate chart data retrieval

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hawk.api",
-  "version": "1.2.22",
+  "version": "1.2.23",
   "main": "index.ts",
   "license": "BUSL-1.1",
   "scripts": {
@@ -28,6 +28,7 @@
     "jest": "^26.2.2",
     "mongodb-memory-server": "^6.6.1",
     "nodemon": "^2.0.2",
+    "redis-mock": "^0.56.3",
     "ts-jest": "^26.1.4",
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4"
@@ -82,6 +83,7 @@
     "mongodb": "^3.7.3",
     "morgan": "^1.10.1",
     "prom-client": "^15.1.3",
+    "redis": "^4.7.0",
     "safe-regex": "^2.1.0",
     "ts-node-dev": "^2.0.0",
     "uuid": "^8.3.2"

src/index.ts

@@ -29,6 +29,7 @@ import { graphqlUploadExpress } from 'graphql-upload';
 import { metricsMiddleware, createMetricsServer, graphqlMetricsPlugin } from './metrics';
 import { requestLogger } from './utils/logger';
 import ReleasesFactory from './models/releasesFactory';
+import RedisHelper from './redisHelper';
 
 /**
  * Option to enable playground
@@ -148,6 +149,7 @@ class HawkAPI {
   /**
    * Creates factories to work with models
    * @param dataLoaders - dataLoaders for fetching data form database
+   * @returns factories object
    */
   private static setupFactories(dataLoaders: DataLoaders): ContextFactories {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -212,23 +214,9 @@ class HawkAPI {
 
     /**
      * Initializing accounting SDK
-     */
-    let tlsVerify;
-
-    /**
      * Checking env variables
      * If at least one path is not transmitted, the variable tlsVerify is undefined
      */
-    if (
-      ![process.env.TLS_CA_CERT, process.env.TLS_CERT, process.env.TLS_KEY].some(value => value === undefined || value.length === 0)
-    ) {
-      tlsVerify = {
-        tlsCaCertPath: `${process.env.TLS_CA_CERT}`,
-        tlsCertPath: `${process.env.TLS_CERT}`,
-        tlsKeyPath: `${process.env.TLS_KEY}`,
-      };
-    }
-
     /*
      * const accounting = new Accounting({
      *   baseURL: `${process.env.CODEX_ACCOUNTING_URL}`,
@@ -252,6 +240,12 @@ class HawkAPI {
   public async start(): Promise<void> {
     await mongo.setupConnections();
     await rabbitmq.setupConnections();
+
+    // Initialize Redis singleton with auto-reconnect
+    const redis = RedisHelper.getInstance();
+
+    await redis.initialize();
+
     await this.server.start();
     this.app.use(graphqlUploadExpress());
     this.server.applyMiddleware({ app: this.app });

src/models/eventsFactory.js

@@ -1,6 +1,8 @@
 import { getMidnightWithTimezoneOffset, getUTCMidnight } from '../utils/dates';
 import safe from 'safe-regex';
 import { createProjectEventsByIdLoader } from '../dataLoaders';
+import RedisHelper from '../redisHelper';
+import ChartDataService from '../services/chartDataService';
 
 const Factory = require('./modelFactory');
 const mongo = require('../mongo');
@@ -85,11 +87,21 @@ class EventsFactory extends Factory {
 
   /**
    * Creates Event instance
-   * @param {ObjectId} projectId - project ID
+   * @param {ObjectId} projectId
    */
   constructor(projectId) {
     super();
 
+    /**
+     * Redis helper instance (singleton)
+     */
+    this.redis = RedisHelper.getInstance();
+
+    /**
+     * Chart data service for fetching data from Redis TimeSeries
+     */
+    this.chartDataService = new ChartDataService(this.redis);
+
     if (!projectId) {
       throw new Error('Can not construct Event model, because projectId is not provided');
     }
@@ -414,6 +426,57 @@ class EventsFactory extends Factory {
     };
   }
 
+  /**
+   * Get project chart data from Redis or fallback to MongoDB
+   *
+   * @param {string} projectId - project ID
+   * @param {string} startDate - start date (ISO string)
+   * @param {string} endDate - end date (ISO string)
+   * @param {number} groupBy - grouping interval in minutes (1=minute, 60=hour, 1440=day)
+   * @param {number} timezoneOffset - user's local timezone offset in minutes
+   * @returns {Promise<Array>}
+   */
+  async getProjectChartData(projectId, startDate, endDate, groupBy = 60, timezoneOffset = 0) {
+    // Calculate days for MongoDB fallback
+    const start = new Date(startDate).getTime();
+    const end = new Date(endDate).getTime();
+    const days = Math.ceil((end - start) / (24 * 60 * 60 * 1000));
+
+    try {
+      const redisData = await this.chartDataService.getProjectChartData(
+        projectId,
+        startDate,
+        endDate,
+        groupBy,
+        timezoneOffset
+      );
+
+      if (redisData && redisData.length > 0) {
+        return redisData;
+      }
+
+      // Fallback to Mongo (empty groupHash for project-level data)
+      return this.findChartData(days, timezoneOffset, '');
+    } catch (err) {
+      console.error('[EventsFactory] getProjectChartData error:', err);
+
+      // Fallback to Mongo on error (empty groupHash for project-level data)
+      return this.findChartData(days, timezoneOffset, '');
+    }
+  }
+
+  /**
+   * Get event daily chart data from MongoDB only
+   *
+   * @param {string} groupHash - event's group hash
+   * @param {number} days - how many days to fetch
+   * @param {number} timezoneOffset - user's local timezone offset in minutes
+   * @returns {Promise<Array>}
+   */
+  async getEventDailyChart(groupHash, days, timezoneOffset = 0) {
+    return this.findChartData(days, timezoneOffset, groupHash);
+  }
+
   /**
    * Fetch timestamps and total count of errors (or target error) for each day since
    *

src/redisHelper.ts

@@ -0,0 +1,168 @@
+import HawkCatcher from '@hawk.so/nodejs';
+import { createClient, RedisClientType } from 'redis';
+
+// eslint call error: 0:0  error  Parsing error: Cannot read properties of undefined (reading 'map')
+// export type TsRangeResult = [timestamp: string, value: string];
+export type TsRangeResult = any;
+
+/**
+ * Helper class for working with Redis
+ */
+export default class RedisHelper {
+  /**
+   * TTL for lock records in Redis (in seconds)
+   */
+  private static readonly LOCK_TTL = 10;
+
+  /**
+   * Singleton instance
+   */
+  private static instance: RedisHelper | null = null;
+
+  /**
+   * Redis client instance
+   */
+  private redisClient: RedisClientType | null = null;
+
+  /**
+   * Flag to track if we're currently reconnecting
+   */
+  private isReconnecting = false;
+
+  /**
+   * Constructor
+   * Initializes the Redis client and sets up error handling with auto-reconnect
+   */
+  constructor() {
+    if (!process.env.REDIS_URL) {
+      console.warn('[Redis] REDIS_URL not set, Redis features will be disabled');
+      return;
+    }
+
+    try {
+      this.redisClient = createClient({
+        url: process.env.REDIS_URL,
+        socket: {
+          reconnectStrategy: (retries) => {
+            /*
+             * Exponential backoff: wait longer between each retry
+             * Max wait time: 30 seconds
+             */
+            const delay = Math.min(retries * 1000, 30000);
+            console.log(`[Redis] Reconnecting... attempt ${retries}, waiting ${delay}ms`);
+            return delay;
+          },
+        },
+      });
+
+      // Handle connection errors
+      this.redisClient.on('error', (error) => {
+        console.error('[Redis] Client error:', error);
+        if (error) {
+          HawkCatcher.send(error);
+        }
+      });
+
+      // Handle successful reconnection
+      this.redisClient.on('ready', () => {
+        console.log('[Redis] Client ready');
+        this.isReconnecting = false;
+      });
+
+      // Handle reconnecting event
+      this.redisClient.on('reconnecting', () => {
+        console.log('[Redis] Client reconnecting...');
+        this.isReconnecting = true;
+      });
+
+      // Handle connection end
+      this.redisClient.on('end', () => {
+        console.log('[Redis] Connection ended');
+      });
+    } catch (error) {
+      console.error('[Redis] Error creating client:', error);
+      HawkCatcher.send(error as Error);
+      this.redisClient = null;
+    }
+  }
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): RedisHelper {
+    if (!RedisHelper.instance) {
+      RedisHelper.instance = new RedisHelper();
+    }
+    return RedisHelper.instance;
+  }
+
+  /**
+   * Connect to Redis
+   */
+  public async initialize(): Promise<void> {
+    if (!this.redisClient) {
+      console.warn('[Redis] Client not initialized, skipping connection');
+      return;
+    }
+
+    try {
+      if (!this.redisClient.isOpen && !this.isReconnecting) {
+        await this.redisClient.connect();
+        console.log('[Redis] Connected successfully');
+      }
+    } catch (error) {
+      console.error('[Redis] Connection failed:', error);
+      HawkCatcher.send(error as Error);
+      // Don't throw - let reconnectStrategy handle it
+    }
+  }
+
+  /**
+   * Close Redis client
+   */
+  public async close(): Promise<void> {
+    if (this.redisClient?.isOpen) {
+      await this.redisClient.quit();
+      console.log('[Redis] Connection closed');
+    }
+  }
+
+  /**
+   * Check if Redis is connected
+   */
+  public isConnected(): boolean {
+    return Boolean(this.redisClient?.isOpen);
+  }
+
+  /**
+   * Execute TS.RANGE command with aggregation
+   *
+   * @param key - Redis TimeSeries key
+   * @param start - start timestamp in milliseconds
+   * @param end - end timestamp in milliseconds
+   * @param aggregationType - aggregation type (sum, avg, min, max, etc.)
+   * @param bucketMs - bucket size in milliseconds
+   * @returns Array of [timestamp, value] tuples
+   */
+  public async tsRange(
+    key: string,
+    start: string,
+    end: string,
+    aggregationType: string,
+    bucketMs: string
+  ): Promise<TsRangeResult[]> {
+    if (!this.redisClient) {
+      throw new Error('Redis client not initialized');
+    }
+
+    return (await this.redisClient.sendCommand([
+      'TS.RANGE',
+      key,
+      start,
+      end,
+      'AGGREGATION',
+      aggregationType,
+      bucketMs,
+    ])) as TsRangeResult[];
+  }
+}

src/resolvers/event.js

@@ -86,7 +86,7 @@ module.exports = {
     async chartData({ projectId, groupHash }, { days, timezoneOffset }, context) {
       const factory = getEventsFactory(context, projectId);
 
-      return factory.findChartData(days, timezoneOffset, groupHash);
+      return factory.getEventDailyChart(groupHash, days, timezoneOffset);
     },
 
     /**

src/resolvers/project.js

@@ -493,10 +493,10 @@ module.exports = {
      *
      * @return {Promise<ProjectChartItem[]>}
      */
-    async chartData(project, { days, timezoneOffset }, context) {
+    async chartData(project, { startDate, endDate, groupBy, timezoneOffset }, context) {
       const factory = getEventsFactory(context, project._id);
 
-      return factory.findChartData(days, timezoneOffset);
+      return factory.getProjectChartData(project._id, startDate, endDate, groupBy, timezoneOffset);
     },
 
     /**