176 lines
5 KiB
Markdown
176 lines
5 KiB
Markdown
# Simplified Cache Library Usage
|
|
|
|
The cache library has been simplified to only use Redis/Dragonfly with a connection manager for better performance and easier management.
|
|
|
|
## Quick Start
|
|
|
|
```typescript
|
|
import { createCache, createTradingCache, createMarketDataCache, RedisConnectionManager } from '@stock-bot/cache';
|
|
|
|
// Create different cache instances
|
|
const generalCache = createCache({ keyPrefix: 'app:' });
|
|
const tradingCache = createTradingCache(); // Uses 'trading:' prefix
|
|
const marketCache = createMarketDataCache(); // Uses 'market:' prefix with 5min TTL
|
|
|
|
// All cache instances share connections by default for better performance
|
|
```
|
|
|
|
## Connection Management
|
|
|
|
The library now uses a connection manager that allows you to control whether services share connections or get unique ones:
|
|
|
|
```typescript
|
|
import { RedisConnectionManager } from '@stock-bot/cache';
|
|
|
|
const connectionManager = RedisConnectionManager.getInstance();
|
|
|
|
// For shared connections (recommended for most cases)
|
|
const sharedRedis = connectionManager.getConnection({
|
|
name: 'BATCH-PROCESSOR',
|
|
singleton: true // All instances share this connection
|
|
});
|
|
|
|
// For unique connections (when you need isolation)
|
|
const uniqueRedis = connectionManager.getConnection({
|
|
name: 'DATA-FETCHER',
|
|
singleton: false // Each instance gets its own connection
|
|
});
|
|
```
|
|
|
|
## Cache Usage Examples
|
|
|
|
### Basic Operations
|
|
|
|
```typescript
|
|
import { createCache } from '@stock-bot/cache';
|
|
|
|
const cache = createCache({ keyPrefix: 'myapp:' });
|
|
|
|
// Set data with default TTL (1 hour)
|
|
await cache.set('user:123', { name: 'John', email: 'john@example.com' });
|
|
|
|
// Set data with custom TTL (5 minutes)
|
|
await cache.set('session:abc', sessionData, 300);
|
|
|
|
// Get data
|
|
const user = await cache.get('user:123');
|
|
|
|
// Check if key exists
|
|
const exists = await cache.exists('user:123');
|
|
|
|
// Delete data
|
|
await cache.del('user:123');
|
|
|
|
// Clear all data with this prefix
|
|
await cache.clear();
|
|
```
|
|
|
|
### Trading-Specific Caches
|
|
|
|
```typescript
|
|
import { createTradingCache, createMarketDataCache, createIndicatorCache } from '@stock-bot/cache';
|
|
|
|
// Trading cache (1 hour TTL)
|
|
const tradingCache = createTradingCache();
|
|
await tradingCache.set('position:AAPL', { shares: 100, price: 150.00 });
|
|
|
|
// Market data cache (5 minute TTL)
|
|
const marketCache = createMarketDataCache();
|
|
await marketCache.set('quote:AAPL', { price: 151.25, volume: 1000000 });
|
|
|
|
// Indicator cache (30 minute TTL)
|
|
const indicatorCache = createIndicatorCache();
|
|
await indicatorCache.set('sma:AAPL:20', [150.1, 150.3, 150.8, 151.2]);
|
|
```
|
|
|
|
## Connection Names in Redis
|
|
|
|
When you create cache instances, they will appear in Redis with clean, identifiable names:
|
|
|
|
- `TRADING-SERVICE` - For trading cache
|
|
- `MARKET-SERVICE` - For market data cache
|
|
- `INDICATORS-SERVICE` - For indicator cache
|
|
- `CACHE-SERVICE` - For general cache
|
|
|
|
You can monitor all connections using:
|
|
|
|
```bash
|
|
# TypeScript version (more detailed)
|
|
bun run scripts/get-redis-connections.ts
|
|
|
|
# Bash version (quick check)
|
|
./scripts/get-redis-connections.sh
|
|
```
|
|
|
|
## Health Monitoring
|
|
|
|
```typescript
|
|
// Check if cache is ready
|
|
if (cache.isReady()) {
|
|
console.log('Cache is ready for operations');
|
|
}
|
|
|
|
// Wait for cache to be ready
|
|
await cache.waitForReady(5000); // Wait up to 5 seconds
|
|
|
|
// Health check
|
|
const isHealthy = await cache.health();
|
|
|
|
// Get performance statistics
|
|
const stats = cache.getStats();
|
|
console.log(`Hit rate: ${stats.hitRate}%, Total operations: ${stats.total}`);
|
|
```
|
|
|
|
## Batch Processor Example
|
|
|
|
Here's how to set up a batch processor with a shared connection:
|
|
|
|
```typescript
|
|
import { RedisConnectionManager } from '@stock-bot/cache';
|
|
import Redis from 'ioredis';
|
|
|
|
export class BatchProcessor {
|
|
private redis: Redis;
|
|
|
|
constructor() {
|
|
const connectionManager = RedisConnectionManager.getInstance();
|
|
|
|
// All batch processor instances share this connection
|
|
this.redis = connectionManager.getConnection({
|
|
name: 'BATCH-PROCESSOR',
|
|
singleton: true
|
|
});
|
|
}
|
|
|
|
async processItems(items: any[]): Promise<void> {
|
|
await this.redis.set('batch:status', 'processing');
|
|
|
|
for (const item of items) {
|
|
await this.redis.lpush('batch:queue', JSON.stringify(item));
|
|
}
|
|
|
|
await this.redis.set('batch:status', 'completed');
|
|
}
|
|
|
|
async getBatchStatus(): Promise<string> {
|
|
return await this.redis.get('batch:status') || 'idle';
|
|
}
|
|
}
|
|
```
|
|
|
|
## Key Benefits
|
|
|
|
✅ **Simplified**: Only Redis-based caching, no complex hybrid logic
|
|
✅ **Connection Management**: Shared connections for better performance
|
|
✅ **Clean Monitoring**: Easy to identify connections in Redis
|
|
✅ **Trading Optimized**: Pre-configured caches for different data types
|
|
✅ **Type Safe**: Full TypeScript support
|
|
✅ **Error Handling**: Graceful fallbacks and comprehensive logging
|
|
|
|
## Removed Features
|
|
|
|
❌ **Memory Cache**: Removed to avoid consistency issues
|
|
❌ **Hybrid Cache**: Removed unnecessary complexity
|
|
❌ **Auto-detection**: Always uses Redis/Dragonfly now
|
|
|
|
This simplified approach provides better performance, easier debugging, and more predictable behavior for your trading application.
|