Redis и Node.js с TypeScript - решения для высоконагруженных систем

// Гибридное использование Redis и SQL базы
async function processPayment(paymentId: string, amount: number): Promise<void> {
  // Сначала проверяем состояние в Redis
  const paymentState = await redisClient.get(`payment:${paymentId}:state`);
  
  if (paymentState === 'processing') {
    throw new Error('Payment already being processed');
  }
  
  // Атомарно устанавливаем состояние и TTL
  await redisClient.multi()
    .set(`payment:${paymentId}:state`, 'processing')
    .expire(`payment:${paymentId}:state`, 300) // Истечет через 5 минут
    .exec();
  
  try {
    // Выполняем тяжелую операцию с основной базой
    await sqlDb.query(
      'INSERT INTO transactions (payment_id, amount, status) VALUES ($1, $2, $3)',
      [paymentId, amount, 'completed']
    );
    
    // Обновляем состояние в Redis
    await redisClient.set(`payment:${paymentId}:state`, 'completed');
  } catch (error) {
    // В случае ошибки отмечаем как неудачную
    await redisClient.set(`payment:${paymentId}:state`, 'failed');
    throw error;
  }
}

save 900 1    # сохранять каждые 15 минут, если изменился хотя бы 1 ключ
save 300 10   # сохранять каждые 5 минут, если изменилось 10 ключей
save 60 10000 # сохранять каждую минуту, если изменилось 10000 ключей

appendonly yes  # включить AOF
appendfsync everysec  # синхронизировать раз в секунду (компромиссный вариант)

# В redis.conf или через команду ACL SETUSER
user default on +@all ~* >mysecretpassword
user restricted on +get ~object:* -@all +@read

import { createClient } from 'redis';
 
interface RedisSecurityConfig {
  password: string;
  username?: string;
  tls?: {
    ca?: string;
    cert?: string;
    key?: string;
  };
}
 
// Безопасная конфигурация клиента
const client = createClient({
  url: 'rediss://redis.example.com:6379', // обратите внимание на rediss:// (с TLS)
  username: 'appuser',
  password: process.env.REDIS_PASSWORD, // всегда берите из переменных окружения!
  socket: {
    tls: true,
    rejectUnauthorized: true, // проверять сертификаты
    ca: fs.readFileSync('./ca.crt', 'utf8'),
  }
});

// Потенциально проблемный код
await client.multi()
  .get('counter')
  .incrBy('counter', 10)
  .exec();

import { createClient, RedisClientType } from 'redis';
 
// Создание типизированного соединения
const client: RedisClientType = createClient({
  url: 'redis://localhost:6379',
  password: process.env.REDIS_PASSWORD // Хорошая практика: использовать переменные окружения
});
 
// Подключение к серверу Redis
async function connectRedis(): Promise<void> {
  await client.connect();
  console.log('Успешно подключились к Redis');
}
 
// Обработка ошибок
client.on('error', (err: Error) => {
  console.error('Ошибка подключения к Redis:', err);
});
 
connectRedis().catch(console.error);

import { createClient, RedisClientType } from 'redis';
 
export class RedisService {
  private static instance: RedisService;
  private client: RedisClientType;
  private isConnected: boolean = false;
 
  private constructor() {
    this.client = createClient({
      url: process.env.REDIS_URL || 'redis://localhost:6379',
      password: process.env.REDIS_PASSWORD
    });
 
    this.client.on('error', this.handleError.bind(this));
    this.client.on('connect', () => { this.isConnected = true; });
    this.client.on('end', () => { this.isConnected = false; });
  }
 
  public static getInstance(): RedisService {
    if (!RedisService.instance) {
      RedisService.instance = new RedisService();
    }
    return RedisService.instance;
  }
 
  private handleError(error: Error): void {
    console.error('Redis error:', error);
    // Здесь можно добавить логику уведомления мониторинговых систем
  }
 
  public async connect(): Promise<void> {
    if (!this.isConnected) {
      await this.client.connect();
    }
  }
 
  public async get<T>(key: string): Promise<T | null> {
    const value = await this.client.get(key);
    if (!value) return null;
    try {
      return JSON.parse(value) as T;
    } catch {
      return value as unknown as T;
    }
  }
 
  public async set<T>(key: string, value: T, ttlSeconds?: number): Promise<void> {
    const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
    if (ttlSeconds) {
      await this.client.set(key, stringValue, { EX: ttlSeconds });
    } else {
      await this.client.set(key, stringValue);
    }
  }
 
  // Другие методы...
}

import { createClient, RedisClientType } from 'redis';
import { createPool, Pool, Factory } from 'generic-pool';
 
export class RedisConnectionPool {
  private pool: Pool<RedisClientType>;
 
  constructor(redisUrl: string, options: { max: number; min: number }) {
    const factory: Factory<RedisClientType> = {
      create: async () => {
        const client = createClient({ url: redisUrl });
        await client.connect();
        return client;
      },
      destroy: async (client) => {
        await client.quit();
      }
    };
 
    this.pool = createPool(factory, options);
  }
 
  async withClient<T>(operation: (client: RedisClientType) => Promise<T>): Promise<T> {
    const client = await this.pool.acquire();
    try {
      return await operation(client);
    } finally {
      await this.pool.release(client);
    }
  }
 
  async shutdown(): Promise<void> {
    await this.pool.drain();
    await this.pool.clear();
  }
}

// Создаем пул с 10 соединениями
const redisPool = new RedisConnectionPool('redis://localhost:6379', {
  max: 10,
  min: 2
});
 
// Используем соединение из пула
const userData = await redisPool.withClient(client => 
  client.get(`user:${userId}`)
);
 
// При завершении работы приложения
process.on('SIGTERM', async () => {
  await redisPool.shutdown();
  process.exit(0);
});

import { createClient } from 'redis';
 
const client = createClient({
  url: 'redis://mymaster', // Имя набора Sentinel
  sentinels: [
    { host: 'sentinel1', port: 26379 },
    { host: 'sentinel2', port: 26379 },
    { host: 'sentinel3', port: 26379 }
  ],
  sentinelUsername: 'sentinel-user',
  sentinelPassword: process.env.SENTINEL_PASSWORD,
  username: 'redis-user',
  password: process.env.REDIS_PASSWORD
});

async function getUserWithCacheAside(userId: string): Promise<User | null> {
  const cacheKey = `user:${userId}`;
  
  // Сначала проверяем кеш
  const cachedUser = await redisClient.get(cacheKey);
  if (cachedUser) {
    console.log('Cache hit');
    return JSON.parse(cachedUser);
  }
  
  console.log('Cache miss');
  // Если в кеше нет, берем из базы данных
  const user = await database.findUserById(userId);
  
  if (user) {
    // Сохраняем в кеш на 1 час
    await redisClient.set(cacheKey, JSON.stringify(user), { EX: 3600 });
  }
  
  return user;
}

async function updateUserWithWriteThrough(
  userId: string, 
  userData: Partial<User>
): Promise<User> {
  // Сначала обновляем базу данных
  const updatedUser = await database.updateUser(userId, userData);
  
  // Затем обновляем кеш
  const cacheKey = `user:${userId}`;
  await redisClient.set(cacheKey, JSON.stringify(updatedUser), { EX: 3600 });
  
  return updatedUser;
}

class UserRepository {
  private redisClient: RedisClientType;
  private database: Database;
  private readonly TTL = 3600; // 1 час
  
  constructor(redisClient: RedisClientType, database: Database) {
    this.redisClient = redisClient;
    this.database = database;
  }
  
  async getUser(userId: string): Promise<User | null> {
    const cacheKey = `user:${userId}`;
    
    // Cache-Aside
    const cachedUser = await this.redisClient.get(cacheKey);
    if (cachedUser) return JSON.parse(cachedUser);
    
    const user = await this.database.findUserById(userId);
    if (user) {
      await this.redisClient.set(cacheKey, JSON.stringify(user), { EX: this.TTL });
    }
    
    return user;
  }
  
  async updateUser(userId: string, userData: Partial<User>): Promise<User> {
    // Write-Through
    const updatedUser = await this.database.updateUser(userId, userData);
    
    const cacheKey = `user:${userId}`;
    await this.redisClient.set(cacheKey, JSON.stringify(updatedUser), { EX: this.TTL });
    
    return updatedUser;
  }
}

class AdaptiveCacheTTL {
  private redisClient: RedisClientType;
  private readonly MIN_TTL = 60; // 1 минута
  private readonly MAX_TTL = 86400; // 24 часа
  
  constructor(redisClient: RedisClientType) {
    this.redisClient = redisClient;
  }
  
  async calculateTTL(key: string): Promise<number> {
    // Ключ для хранения времени последнего изменения
    const lastChangedKey = `${key}:last_changed`;
    // Ключ для хранения предыдущего TTL
    const previousTTLKey = `${key}:previous_ttl`;
    
    const now = Math.floor(Date.now() / 1000);
    const lastChanged = parseInt(await this.redisClient.get(lastChangedKey) || `${now}`);
    const previousTTL = parseInt(await this.redisClient.get(previousTTLKey) || `${this.MIN_TTL}`);
    
    // Вычисляем время с последнего изменения
    const timeSinceChange = now - lastChanged;
    
    // Если прошло больше времени, чем предыдущий TTL, увеличиваем TTL
    let newTTL = previousTTL;
    if (timeSinceChange > previousTTL) {
      newTTL = Math.min(previousTTL * 2, this.MAX_TTL);
    } else {
      // Иначе уменьшаем TTL
      newTTL = Math.max(previousTTL / 2, this.MIN_TTL);
    }
    
    // Сохраняем новый TTL для будущего использования
    await this.redisClient.set(previousTTLKey, newTTL.toString());
    
    return newTTL;
  }
  
  async recordChange(key: string): Promise<void> {
    // Запись времени изменения
    const now = Math.floor(Date.now() / 1000);
    await this.redisClient.set(`${key}:last_changed`, now.toString());
  }
}

import * as msgpack from 'msgpack-lite';
 
class TypedRedisClient<T> {
  private redisClient: RedisClientType;
  private prefix: string;
  
  constructor(redisClient: RedisClientType, prefix: string) {
    this.redisClient = redisClient;
    this.prefix = prefix;
  }
  
  private getKey(id: string): string {
    return `${this.prefix}:${id}`;
  }
  
  async get(id: string): Promise<T | null> {
    const data = await this.redisClient.get(this.getKey(id));
    if (!data) return null;
    
    try {
      // Используем MessagePack для эффективной сериализации
      return msgpack.decode(Buffer.from(data, 'base64')) as T;
    } catch (error) {
      console.error('Ошибка десериализации:', error);
      return null;
    }
  }
  
  async set(id: string, value: T, ttl?: number): Promise<void> {
    const serialized = msgpack.encode(value).toString('base64');
    
    if (ttl) {
      await this.redisClient.set(this.getKey(id), serialized, { EX: ttl });
    } else {
      await this.redisClient.set(this.getKey(id), serialized);
    }
  }
}
 
// Использование с конкретным типом
const userCache = new TypedRedisClient<User>(redisClient, 'user');
await userCache.set('123', { id: '123', name: 'John' }, 3600);
const user = await userCache.get('123'); // Типизировано как User | null

interface GeoPoint {
  lat: number;
  lng: number;
}
 
// Сериализация
function serializeGeoPoint(point: GeoPoint): string {
  return `${point.lat.toFixed(6)},${point.lng.toFixed(6)}`;
}
 
// Десериализация
function deserializeGeoPoint(value: string): GeoPoint {
  const [lat, lng] = value.split(',').map(Number);
  return { lat, lng };
}

async function updateProduct(productId: string, update: ProductUpdate): Promise<void> {
  // Обновляем в основной базе данных
  await database.updateProduct(productId, update);
  
  // Устанавливаем флаг "грязных данных" в Redis
  await redisClient.set(`product:${productId}:dirty`, '1', { EX: 30 });
  
  // Публикуем событие об обновлении для других сервисов
  await redisClient.publish('product:updates', JSON.stringify({
    productId,
    timestamp: Date.now()
  }));
}
 
async function getProduct(productId: string): Promise<Product | null> {
  const cacheKey = `product:${productId}`;
  const dirtyKey = `${cacheKey}:dirty`;
  
  // Проверяем "грязный" флаг
  const isDirty = await redisClient.get(dirtyKey);
  
  if (!isDirty) {
    const cached = await redisClient.get(cacheKey);
    if (cached) return JSON.parse(cached);
  }
  
  // Получаем свежие данные из БД
  const product = await database.getProduct(productId);
  if (product) {
    // Обновляем кеш и снимаем "грязный" флаг
    await redisClient.set(cacheKey, JSON.stringify(product), { EX: 3600 });
    await redisClient.del(dirtyKey);
  }
  
  return product;
}

// Lua-скрипт для атомарного обновления
const updateLuaScript = `
if redis.call('get', KEYS[1]) == ARGV[1] then
  redis.call('set', KEYS[1], ARGV[2])
  return 1
else
  return 0
end
`;
 
async function atomicUpdate(key: string, expectedValue: string, newValue: string): Promise<boolean> {
  const result = await redisClient.eval(
    updateLuaScript,
    {
      keys: [key],
      arguments: [expectedValue, newValue]
    }
  );
  
  return result === 1;
}

// Сервис, который меняет данные
class ProductService {
  async updateProduct(productId: string, data: ProductUpdate): Promise<void> {
    // Обновляем базу данных
    await this.database.updateProduct(productId, data);
    
    // Отправляем событие об изменении
    await this.redisClient.publish('cache:invalidate', JSON.stringify({
      entity: 'product',
      id: productId,
      timestamp: Date.now()
    }));
  }
}
 
// Сервис кеширования, который подписывается на события
class CacheService {
  constructor(redisClient: RedisClientType) {
    // Подписываемся на канал инвалидации
    const subscriber = redisClient.duplicate();
    subscriber.connect().then(() => {
      subscriber.subscribe('cache:invalidate', this.handleInvalidation.bind(this));
    });
  }
  
  private async handleInvalidation(message: string): Promise<void> {
    try {
      const { entity, id, timestamp } = JSON.parse(message);
      // Удаляем устаревшие данные из кеша
      await this.redisClient.del(`${entity}:${id}`);
      console.log(`Кеш инвалидирован: ${entity}:${id}`);
    } catch (error) {
      console.error('Ошибка при инвалидации кеша:', error);
    }
  }
}

async function storeUserProfile(userId: string, profile: UserProfile): Promise<void> {
  // Преобразуем все поля объекта в строки
  const hash: Record<string, string> = {};
  for (const [key, value] of Object.entries(profile)) {
    hash[key] = typeof value === 'string' ? value : JSON.stringify(value);
  }
  
  // Атомарно сохраняем весь профиль
  await redisClient.hSet(`user:${userId}:profile`, hash);
  
  // Устанавливаем время жизни для всего объекта
  await redisClient.expire(`user:${userId}:profile`, 86400);
}
 
// Обновление только одного поля, без загрузки всего объекта
async function updateUserLastLogin(userId: string): Promise<void> {
  await redisClient.hSet(
    [INLINE]user:${userId}:profile[/INLINE],
    'lastLoginAt',
    new Date().toISOString()
  );
}

// Отслеживание IP-адресов, посетивших сайт
async function trackVisitor(ip: string): Promise<void> {
  await redisClient.sAdd('visitors:today', ip);
}
 
// Подсчет уникальных посетителей
async function getUniqueVisitorsCount(): Promise<number> {
  return redisClient.sCard('visitors:today');
}
 
// Проверка, был ли посетитель ранее
async function isReturningVisitor(ip: string): Promise<boolean> {
  return redisClient.sIsMember('visitors:yesterday', ip);
}

// Добавление статьи в рейтинг популярности
async function trackArticleView(articleId: string): Promise<void> {
  // Инкрементируем счетчик просмотров
  await redisClient.zIncrBy('articles:popular', 1, articleId);
  
  // Удаляем старые записи (более 100)
  const totalItems = await redisClient.zCard('articles:popular');
  if (totalItems > 100) {
    await redisClient.zRemRangeByRank('articles:popular', 0, totalItems - 101);
  }
}
 
// Получение топ-10 статей
async function getTopArticles(): Promise<string[]> {
  return redisClient.zRange('articles:popular', -10, -1, { REV: true });
}

// Сохранение местоположения пользователя
async function updateUserLocation(userId: string, lat: number, lng: number): Promise<void> {
  await redisClient.geoAdd('user:locations', {
    longitude: lng,
    latitude: lat,
    member: userId
  });
}
 
// Поиск ближайших пользователей в радиусе 5 км
async function findNearbyUsers(lat: number, lng: number): Promise<string[]> {
  const results = await redisClient.geoRadius('user:locations', {
    longitude: lng,
    latitude: lat,
    radius: 5,
    unit: 'km'
  });
  
  return results.map(item => item.member);
}

// Добавление события в поток
async function logUserAction(userId: string, action: string, metadata: Record<string, string>): Promise<string> {
  // Формируем данные события (все значения должны быть строками)
  const eventData = {
    userId,
    action,
    timestamp: Date.now().toString(),
    ...metadata
  };
  
  // Добавляем в поток, получаем уникальный ID
  return redisClient.xAdd('user:actions', '*', eventData);
}
 
// Чтение последних событий
async function getRecentActions(limit: number = 10): Promise<Array<UserAction>> {
  const events = await redisClient.xRevRange('user:actions', '+', '-', { COUNT: limit });
  
  return events.map(event => {
    // Преобразуем формат Redis в удобный TypeScript объект
    const { id, message } = event;
    return {
      id,
      userId: message.userId,
      action: message.action,
      timestamp: parseInt(message.timestamp),
      metadata: Object.fromEntries(
        Object.entries(message).filter(([key]) => 
          !['userId', 'action', 'timestamp'].includes(key)
        )
      )
    };
  });
}

// Создаем группу потребителей (выполняется один раз)
async function setupConsumerGroup(): Promise<void> {
  try {
    await redisClient.xGroupCreate('orders:new', 'order-processors', '0', {
      MKSTREAM: true // создать поток, если он не существует
    });
  } catch (err: any) {
    // Игнорируем ошибку, если группа уже существует
    if (!err.message.includes('BUSYGROUP')) throw err;
  }
}
 
// Обработчик заказов в отдельном микросервисе
async function processOrders(consumerId: string): Promise<void> {
  while (true) {
    try {
      // Читаем новые сообщения для этого потребителя
      const messages = await redisClient.xReadGroup({
        group: 'order-processors',
        consumer: consumerId,
        streams: {
          'orders:new': '>' // '>' означает "только новые сообщения"
        },
        count: 10,
        block: 5000 // ждем до 5 секунд
      });
      
      if (!messages || messages.length === 0) continue;
      
      for (const message of messages[0].messages) {
        // Обрабатываем заказ
        await processOrder(message.message);
        
        // Подтверждаем обработку
        await redisClient.xAck('orders:new', 'order-processors', message.id);
      }
    } catch (error) {
      console.error('Ошибка обработки заказов:', error);
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}

// Учет просмотра страницы уникальным пользователем
async function trackPageView(pageId: string, userId: string): Promise<void> {
  await redisClient.pfAdd(`pageviews:${pageId}`, userId);
}
 
// Получение приблизительного числа уникальных просмотров
async function getUniqueViewsCount(pageId: string): Promise<number> {
  return redisClient.pfCount(`pageviews:${pageId}`);
}
 
// Объединение статистики по нескольким страницам
async function getCategoryViewsCount(categoryId: string, pageIds: string[]): Promise<number> {
  const keys = pageIds.map(id => `pageviews:${id}`);
  await redisClient.pfMerge(`category:${categoryId}:views`, keys);
  return redisClient.pfCount(`category:${categoryId}:views`);
}

class RedisMetrics {
private metrics: Map<string, { count: number; totalTime: number }> = new Map();
 
async measureRedisOperation<T>(
  operationName: string, 
  operation: () => Promise<T>
): Promise<T> {
  const startTime = process.hrtime.bigint();
  
  try {
    return await operation();
  } finally {
    const endTime = process.hrtime.bigint();
    const duration = Number(endTime - startTime) / 1_000_000; // в миллисекундах
    
    const stats = this.metrics.get(operationName) || { count: 0, totalTime: 0 };
    stats.count++;
    stats.totalTime += duration;
    this.metrics.set(operationName, stats);
  }
}
 
getMetrics(): Record<string, { count: number; avgTime: number }> {
  const result: Record<string, { count: number; avgTime: number }> = {};
  
  for (const [op, stats] of this.metrics.entries()) {
    result[op] = {
      count: stats.count,
      avgTime: stats.totalTime / stats.count
    };
  }
  
  return result;
}
}
 
// Использование
const redisMetrics = new RedisMetrics();
const users = await redisMetrics.measureRedisOperation(
'get_users_by_role',
() => redisClient.lRange('users:admin', 0, -1)
);
 
// Периодический вывод метрик
setInterval(() => {
console.log(redisMetrics.getMetrics());
}, 60000);

// Медленный код - N запросов к Redis
async function getProductPrices(productIds: string[]): Promise<Record<string, number>> {
const result: Record<string, number> = {};
for (const id of productIds) {
  const price = await redisClient.get(`product:${id}:price`);
  if (price) result[id] = parseFloat(price);
}
return result;
}
 
// Оптимизированный код - 1 запрос с pipeline
async function getProductPricesFast(productIds: string[]): Promise<Record<string, number>> {
const pipeline = redisClient.multi();
productIds.forEach(id => {
  pipeline.get(`product:${id}:price`);
});
 
const prices = await pipeline.exec();
const result: Record<string, number> = {};
 
prices.forEach((price, index) => {
  if (price) result[productIds[index]] = parseFloat(price as string);
});
 
return result;
}

async function gatherRedisMetrics(): Promise<Record<string, any>> {
const info = await redisClient.info();
const sections = info.split('#');
  
const metrics: Record<string, any> = {};
  
for (const section of sections) {
  const lines = section.trim().split('\r\n');
  if (lines.length <= 1) continue;
    
  const sectionName = lines[0].replace(/# /, '').toLowerCase();
  metrics[sectionName] = {};
    
  for (let i = 1; i < lines.length; i++) {
    const [key, value] = lines[i].split(':');
    if (key && value !== undefined) {
      // Пробуем преобразовать строковые значения в числа где это возможно
      const numValue = Number(value);
      metrics[sectionName][key] = isNaN(numValue) ? value : numValue;
    }
  }
}
  
return metrics;
}

// Ограничение списка последних уведомлений
async function addNotification(userId: string, notification: Notification): Promise<void> {
const key = `user:${userId}:notifications`;
  
// Добавляем новое уведомление в начало списка
await redisClient.lPush(key, JSON.stringify(notification));
  
// Ограничиваем размер списка 100 элементами
await redisClient.lTrim(key, 0, 99);
  
// Устанавливаем TTL для всего списка, если это новый ключ
await redisClient.expire(key, 604800); // 7 дней
}

async function findBiggestKeys(limit: number = 10): Promise<Array<{ key: string; size: number }>> {
  // Получаем список всех ключей
  const keys = await redisClient.keys('*');
  
  const keySizes = await Promise.all(
    keys.map(async key => ({
      key,
      size: await redisClient.memoryUsage(key)
    }))
  );
  
  // Сортируем по размеру и возвращаем топ N
  return keySizes
    .sort((a, b) => b.size - a.size)
    .slice(0, limit);
}

// Тестирование стратегии кеширования с симуляцией нагрузки
async function benchmarkCacheStrategy(
  strategy: 'write-through' | 'cache-aside' | 'write-behind',
  concurrency: number,
  operations: number
): Promise<{ hits: number; misses: number; avgResponseTime: number }> {
  const start = Date.now();
  let hits = 0, misses = 0;
  
  // Симуляция параллельных запросов
  const tasks = Array.from({ length: operations }).map(async (_, i) => {
    const userId = (i % (concurrency / 2)) + 1; // Повторяющиеся ID для тестирования hit rate
    
    switch (strategy) {
      case 'write-through':
        return userService.getUserWithWriteThrough(userId.toString());
      case 'cache-aside':
        return userService.getUserWithCacheAside(userId.toString());
      case 'write-behind':
        return userService.getUserWithWriteBehind(userId.toString());
    }
  });
  
  // Используем batching для контроля конкурентности
  const batchSize = Math.min(concurrency, 100);
  const results = [];
  
  for (let i = 0; i < operations; i += batchSize) {
    const batch = tasks.slice(i, i + batchSize);
    results.push(...await Promise.all(batch));
  }
  
  // Получаем статистику из сервиса
  const stats = await redisClient.info('stats');
  const matches = stats.match(/keyspace_hits:(\d+)/);
  hits = matches ? parseInt(matches[1]) : 0;
  
  const missMatches = stats.match(/keyspace_misses:(\d+)/);
  misses = missMatches ? parseInt(missMatches[1]) : 0;
  
  return {
    hits,
    misses,
    avgResponseTime: (Date.now() - start) / operations
  };
}

import { trace } from '@opentelemetry/api';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { RedisInstrumentation } from '@opentelemetry/instrumentation-redis';
 
// Регистрация инструментации Redis
registerInstrumentations({
  instrumentations: [
    new RedisInstrumentation({
      // Трассировка только команд, которые выполняются дольше 5мс
      dbStatementSerializer: (cmd, args) => 
        args && args.length > 0 ? `${cmd} ${args[0]}` : cmd
    })
  ]
});
 
// Обертка для трассировки Redis-операций
async function tracedRedisOperation<T>(
  name: string, 
  operation: () => Promise<T>
): Promise<T> {
  const tracer = trace.getTracer('redis-operations');
  
  return tracer.startActiveSpan(name, async (span) => {
    try {
      const result = await operation();
      span.end();
      return result;
    } catch (error) {
      span.recordException(error as Error);
      span.setStatus({ code: SpanStatusCode.ERROR });
      span.end();
      throw error;
    }
  });
}

// src/types/index.ts
export interface Product {
  id: string;
  name: string;
  category: string;
  price: number;
  tags: string[];
}
 
export interface User {
  id: string;
  purchaseHistory: string[]; // идентификаторы купленных товаров
  viewHistory: string[];     // идентификаторы просмотренных товаров
  preferences: {
    categories: Record<string, number>; // категория -> вес предпочтения
    tags: Record<string, number>;       // тег -> вес предпочтения
  };
}
 
export interface RecommendationScore {
  productId: string;
  score: number;
}
 
export interface RecommendationEngine {
  getRecommendations(userId: string, limit?: number): Promise<Product[]>;
  updateUserPreferences(userId: string, product: Product, action: 'view' | 'purchase'): Promise<void>;
}

// src/config/redis.ts
import { createClient, RedisClientType } from 'redis';
 
export class RedisManager {
  private static instance: RedisManager;
  private client: RedisClientType;
  
  private constructor() {
    this.client = createClient({
      url: process.env.REDIS_URL || 'redis://localhost:6379',
      password: process.env.REDIS_PASSWORD,
    });
    
    this.client.on('error', (err) => {
      console.error('Redis error:', err);
    });
  }
  
  public static getInstance(): RedisManager {
    if (!this.instance) {
      this.instance = new RedisManager();
    }
    return this.instance;
  }
  
  public async connect(): Promise<void> {
    await this.client.connect();
  }
  
  public getClient(): RedisClientType {
    return this.client;
  }
  
  public async disconnect(): Promise<void> {
    await this.client.quit();
  }
}

// src/repositories/UserRepository.ts
import { RedisClientType } from 'redis';
import { User, Product } from '../types';
 
export class UserRepository {
  private client: RedisClientType;
  private readonly TTL = 86400; // 24 часа
  
  constructor(redisClient: RedisClientType) {
    this.client = redisClient;
  }
  
  async getUser(userId: string): Promise<User | null> {
    const key = `user:${userId}`;
    const cachedUser = await this.client.get(key);
    
    if (cachedUser) {
      return JSON.parse(cachedUser);
    }
    
    // В реальном проекте здесь был бы запрос к основной БД
    const user = await this.fetchUserFromDatabase(userId);
    
    if (user) {
      await this.client.set(key, JSON.stringify(user), { EX: this.TTL });
    }
    
    return user;
  }
  
  async updateUserPreferences(
    userId: string, 
    product: Product, 
    action: 'view' | 'purchase'
  ): Promise<void> {
    const user = await this.getUser(userId);
    if (!user) return;
    
    // Обновляем историю просмотров/покупок
    if (action === 'view') {
      if (!user.viewHistory.includes(product.id)) {
        user.viewHistory.push(product.id);
      }
    } else {
      if (!user.purchaseHistory.includes(product.id)) {
        user.purchaseHistory.push(product.id);
      }
    }
    
    // Обновляем предпочтения по категориям
    const categoryWeight = action === 'purchase' ? 2 : 1;
    user.preferences.categories[product.category] = 
      (user.preferences.categories[product.category] || 0) + categoryWeight;
    
    // Обновляем предпочтения по тегам
    const tagWeight = action === 'purchase' ? 1.5 : 0.5;
    for (const tag of product.tags) {
      user.preferences.tags[tag] = 
        (user.preferences.tags[tag] || 0) + tagWeight;
    }
    
    // Сохраняем обновленного пользователя в Redis (Write-Through)
    const key = `user:${userId}`;
    await this.client.set(key, JSON.stringify(user), { EX: this.TTL });
    
    // Инвалидируем кеш рекомендаций для этого пользователя
    await this.client.del(`recommendations:${userId}`);
    
    // В реальном проекте здесь также был бы апдейт основной БД
    await this.updateUserInDatabase(user);
  }
  
  // Имитация работы с базой данных
  private async fetchUserFromDatabase(userId: string): Promise<User | null> {
    // В реальном проекте здесь был бы запрос к основной БД
    return {
      id: userId,
      purchaseHistory: [],
      viewHistory: [],
      preferences: {
        categories: {},
        tags: {}
      }
    };
  }
  
  private async updateUserInDatabase(user: User): Promise<void> {
    // В реальном проекте здесь был бы апдейт основной БД
    console.log(`Обновлен пользователь ${user.id} в базе данных`);
  }
}

// src/repositories/ProductRepository.ts
import { RedisClientType } from 'redis';
import { Product } from '../types';
 
export class ProductRepository {
  private client: RedisClientType;
  private readonly TTL = 3600; // 1 час
  
  constructor(redisClient: RedisClientType) {
    this.client = redisClient;
  }
  
  async getProduct(productId: string): Promise<Product | null> {
    const key = `product:${productId}`;
    const cachedProduct = await this.client.get(key);
    
    if (cachedProduct) {
      return JSON.parse(cachedProduct);
    }
    
    // В реальном проекте здесь был бы запрос к основной БД
    const product = await this.fetchProductFromDatabase(productId);
    
    if (product) {
      await this.client.set(key, JSON.stringify(product), { EX: this.TTL });
    }
    
    return product;
  }
  
  async getProductsByIds(productIds: string[]): Promise<Product[]> {
    if (productIds.length === 0) return [];
    
    // Используем pipeline для эффективного получения множества продуктов
    const pipeline = this.client.multi();
    productIds.forEach(id => {
      pipeline.get(`product:${id}`);
    });
    
    const results = await pipeline.exec();
    const products: Product[] = [];
    
    // Собираем найденные в кеше продукты
    const missingIds: string[] = [];
    results.forEach((result, index) => {
      if (result) {
        try {
          products.push(JSON.parse(result as string));
        } catch {
          missingIds.push(productIds[index]);
        }
      } else {
        missingIds.push(productIds[index]);
      }
    });
    
    // Подгружаем отсутствующие продукты из БД
    if (missingIds.length > 0) {
      const missingProducts = await this.fetchProductsFromDatabase(missingIds);
      
      // Кешируем подгруженные продукты
      const cachePipeline = this.client.multi();
      missingProducts.forEach(product => {
        cachePipeline.set(
          [INLINE]product:${product.id}[/INLINE], 
          JSON.stringify(product), 
          { EX: this.TTL }
        );
        products.push(product);
      });
      
      await cachePipeline.exec();
    }
    
    return products;
  }
  
  // Имитация работы с базой данных
  private async fetchProductFromDatabase(productId: string): Promise<Product | null> {
    // В реальном проекте здесь был бы запрос к основной БД
    return {
      id: productId,
      name: [INLINE]Товар ${productId}[/INLINE],
      category: 'default',
      price: 100,
      tags: ['new']
    };
  }
  
  private async fetchProductsFromDatabase(productIds: string[]): Promise<Product[]> {
    return Promise.all(
      productIds.map(id => this.fetchProductFromDatabase(id))
    ).then(results => results.filter(Boolean) as Product[]);
  }
}

// src/services/RecommendationEngine.ts
import { RedisClientType } from 'redis';
import { Product, User, RecommendationScore } from '../types';
import { UserRepository } from '../repositories/UserRepository';
import { ProductRepository } from '../repositories/ProductRepository';
 
export class RedisRecommendationEngine {
private client: RedisClientType;
private userRepo: UserRepository;
private productRepo: ProductRepository;
private readonly RECOMMENDATION_TTL = 1800; // 30 минут
 
constructor(
  redisClient: RedisClientType,
  userRepo: UserRepository,
  productRepo: ProductRepository
) {
  this.client = redisClient;
  this.userRepo = userRepo;
  this.productRepo = productRepo;
}
 
async getRecommendations(userId: string, limit: number = 10): Promise<Product[]> {
  // Проверяем кеш рекомендаций
  const cacheKey = `recommendations:${userId}`;
  const cachedIds = await this.client.zRange(cacheKey, 0, limit - 1, { REV: true });
  
  if (cachedIds.length > 0) {
    // Если есть кешированные рекомендации, возвращаем их
    return this.productRepo.getProductsByIds(cachedIds);
  }
  
  // Если кеша нет, вычисляем рекомендации
  const user = await this.userRepo.getUser(userId);
  if (!user) return [];
  
  // Получаем скоры для рекомендаций
  const scores = await this.calculateRecommendationScores(user);
  
  // Сохраняем скоры в сортированное множество
  if (scores.length > 0) {
    const pipeline = this.client.multi();
    
    // Добавляем все скоры в Redis
    scores.forEach(score => {
      pipeline.zAdd(cacheKey, { score: score.score, value: score.productId });
    });
    
    // Устанавливаем TTL для кеша рекомендаций
    pipeline.expire(cacheKey, this.RECOMMENDATION_TTL);
    
    await pipeline.exec();
    
    // Получаем топ N рекомендаций
    const topProductIds = scores
      .sort((a, b) => b.score - a.score)
      .slice(0, limit)
      .map(s => s.productId);
    
    return this.productRepo.getProductsByIds(topProductIds);
  }
  
  return [];
}
 
private async calculateRecommendationScores(user: User): Promise<RecommendationScore[]> {
  // В реальной системе здесь будет сложная логика вычисления рекомендаций
  // Например, коллаборативная фильтрация или контентно-ориентированные рекомендации
  
  // Для примера реализуем простую систему на основе категорий и тегов
  
  // 1. Получаем все популярные продукты
  const popularProducts = await this.getPopularProducts(100);
  
  // 2. Исключаем продукты, которые пользователь уже купил
  const candidateProducts = popularProducts.filter(
    product => !user.purchaseHistory.includes(product.id)
  );
  
  // 3. Рассчитываем скор для каждого продукта
  return candidateProducts.map(product => {
    let score = 0;
    
    // Базовый скор популярности
    score += 1;
    
    // Добавляем скор на основе предпочтений категорий
    if (user.preferences.categories[product.category]) {
      score += user.preferences.categories[product.category] * 2;
    }
    
    // Добавляем скор на основе предпочтений тегов
    for (const tag of product.tags) {
      if (user.preferences.tags[tag]) {
        score += user.preferences.tags[tag];
      }
    }
    
    // Бонус за просмотр товара, но не покупку (возможно, пользователь заинтересован)
    if (user.viewHistory.includes(product.id) && !user.purchaseHistory.includes(product.id)) {
      score += 3;
    }
    
    return { productId: product.id, score };
  });
}
 
private async getPopularProducts(limit: number): Promise<Product[]> {
  // В реальной системе здесь был бы запрос к аналитической БД
  // Для примера вернем случайные продукты
  const productIds = Array.from({ length: limit }, (_, i) => (i + 1).toString());
  return this.productRepo.getProductsByIds(productIds);
}
 
async updateUserPreferences(
  userId: string, 
  product: Product, 
  action: 'view' | 'purchase'
): Promise<void> {
  // Делегируем обновление предпочтений пользователя в репозиторий
  await this.userRepo.updateUserPreferences(userId, product, action);
  
  // Инвалидируем кеш рекомендаций
  await this.client.del(`recommendations:${userId}`);
}
}

// src/controllers/RecommendationController.ts
import { Request, Response } from 'express';
import { RedisRecommendationEngine } from '../services/RecommendationEngine';
import { ProductRepository } from '../repositories/ProductRepository';
 
export class RecommendationController {
private engine: RedisRecommendationEngine;
private productRepo: ProductRepository;
 
constructor(engine: RedisRecommendationEngine, productRepo: ProductRepository) {
  this.engine = engine;
  this.productRepo = productRepo;
}
 
async getRecommendations(req: Request, res: Response): Promise<void> {
  try {
    const userId = req.params.userId;
    const limit = parseInt(req.query.limit as string) || 10;
    
    const recommendations = await this.engine.getRecommendations(userId, limit);
    
    res.json({ success: true, data: recommendations });
  } catch (error) {
    console.error('Ошибка получения рекомендаций:', error);
    res.status(500).json({ 
      success: false, 
      error: 'Внутренняя ошибка сервера' 
    });
  }
}
 
async trackProductView(req: Request, res: Response): Promise<void> {
  try {
    const { userId, productId } = req.params;
    
    const product = await this.productRepo.getProduct(productId);
    if (!product) {
      res.status(404).json({ success: false, error: 'Товар не найден' });
      return;
    }
    
    await this.engine.updateUserPreferences(userId, product, 'view');
    
    res.json({ success: true });
  } catch (error) {
    console.error('Ошибка при отслеживании просмотра товара:', error);
    res.status(500).json({ 
      success: false, 
      error: 'Внутренняя ошибка сервера' 
    });
  }
}
 
async trackProductPurchase(req: Request, res: Response): Promise<void> {
  try {
    const { userId, productId } = req.params;
    
    const product = await this.productRepo.getProduct(productId);
    if (!product) {
      res.status(404).json({ success: false, error: 'Товар не найден' });
      return;
    }
    
    await this.engine.updateUserPreferences(userId, product, 'purchase');
    
    res.json({ success: true });
  } catch (error) {
    console.error('Ошибка при отслеживании покупки товара:', error);
    res.status(500).json({ 
      success: false, 
      error: 'Внутренняя ошибка сервера' 
    });
  }
}
}

// src/index.ts
import express from 'express';
import { RedisManager } from './config/redis';
import { UserRepository } from './repositories/UserRepository';
import { ProductRepository } from './repositories/ProductRepository';
import { RedisRecommendationEngine } from './services/RecommendationEngine';
import { RecommendationController } from './controllers/RecommendationController';
 
async function bootstrap() {
  // Инициализация Redis
  const redisManager = RedisManager.getInstance();
  await redisManager.connect();
  const redisClient = redisManager.getClient();
  
  // Инициализация репозиториев
  const userRepo = new UserRepository(redisClient);
  const productRepo = new ProductRepository(redisClient);
  
  // Инициализация движка рекомендаций
  const recommendationEngine = new RedisRecommendationEngine(
    redisClient,
    userRepo,
    productRepo
  );
  
  // Инициализация контроллера
  const recommendationController = new RecommendationController(
    recommendationEngine,
    productRepo
  );
  
  // Настройка Express
  const app = express();
  app.use(express.json());
  
  // Маршруты
  app.get(
    '/users/:userId/recommendations', 
    recommendationController.getRecommendations.bind(recommendationController)
  );
  
  app.post(
    '/users/:userId/products/:productId/view',
    recommendationController.trackProductView.bind(recommendationController)
  );
  
  app.post(
    '/users/:userId/products/:productId/purchase',
    recommendationController.trackProductPurchase.bind(recommendationController)
  );
  
  // Запуск сервера
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    console.log(`Сервис рекомендаций запущен на порту ${PORT}`);
  });
  
  // Обработка завершения
  process.on('SIGTERM', async () => {
    console.log('Получен сигнал завершения, закрываем соединения...');
    await redisManager.disconnect();
    process.exit(0);
  });
}
 
bootstrap().catch(err => {
  console.error('Ошибка запуска сервиса:', err);
  process.exit(1);
});