241 lines
16 KiB
JavaScript
241 lines
16 KiB
JavaScript
import { logger } from '../../logger.js';
|
|
/**
|
|
* Rate limiter using token bucket algorithm
|
|
* Provides more sophisticated rate limiting with burst handling
|
|
*/
|
|
export class RateLimiter {
|
|
/** Rate limit configuration */
|
|
config;
|
|
/** Token buckets per key */
|
|
buckets = new Map();
|
|
/** Global bucket for non-keyed rate limiting */
|
|
globalBucket;
|
|
/**
|
|
* Create a new rate limiter
|
|
* @param config Rate limiter configuration
|
|
*/
|
|
constructor(config) {
|
|
// Set defaults
|
|
this.config = {
|
|
maxPerPeriod: config.maxPerPeriod,
|
|
periodMs: config.periodMs,
|
|
perKey: config.perKey ?? true,
|
|
initialTokens: config.initialTokens ?? config.maxPerPeriod,
|
|
burstTokens: config.burstTokens ?? 0,
|
|
useGlobalLimit: config.useGlobalLimit ?? false
|
|
};
|
|
// Initialize global bucket
|
|
this.globalBucket = {
|
|
tokens: this.config.initialTokens,
|
|
lastRefill: Date.now(),
|
|
allowed: 0,
|
|
denied: 0,
|
|
errors: 0,
|
|
firstErrorTime: 0
|
|
};
|
|
// Log initialization
|
|
logger.log('info', `Rate limiter initialized: ${this.config.maxPerPeriod} per ${this.config.periodMs}ms${this.config.perKey ? ' per key' : ''}`);
|
|
}
|
|
/**
|
|
* Check if a request is allowed under rate limits
|
|
* @param key Key to check rate limit for (e.g. domain, user, IP)
|
|
* @param cost Token cost (defaults to 1)
|
|
* @returns Whether the request is allowed
|
|
*/
|
|
isAllowed(key = 'global', cost = 1) {
|
|
// If using global bucket directly, just check that
|
|
if (key === 'global' || !this.config.perKey) {
|
|
return this.checkBucket(this.globalBucket, cost);
|
|
}
|
|
// Get the key-specific bucket
|
|
const bucket = this.getBucket(key);
|
|
// If we also need to check global limit
|
|
if (this.config.useGlobalLimit) {
|
|
// Both key bucket and global bucket must have tokens
|
|
return this.checkBucket(bucket, cost) && this.checkBucket(this.globalBucket, cost);
|
|
}
|
|
else {
|
|
// Only need to check the key-specific bucket
|
|
return this.checkBucket(bucket, cost);
|
|
}
|
|
}
|
|
/**
|
|
* Check if a bucket has enough tokens and consume them
|
|
* @param bucket The token bucket to check
|
|
* @param cost Token cost
|
|
* @returns Whether tokens were consumed
|
|
*/
|
|
checkBucket(bucket, cost) {
|
|
// Refill tokens based on elapsed time
|
|
this.refillBucket(bucket);
|
|
// Check if we have enough tokens
|
|
if (bucket.tokens >= cost) {
|
|
// Use tokens
|
|
bucket.tokens -= cost;
|
|
bucket.allowed++;
|
|
return true;
|
|
}
|
|
else {
|
|
// Rate limit exceeded
|
|
bucket.denied++;
|
|
return false;
|
|
}
|
|
}
|
|
/**
|
|
* Consume tokens for a request (if available)
|
|
* @param key Key to consume tokens for
|
|
* @param cost Token cost (defaults to 1)
|
|
* @returns Whether tokens were consumed
|
|
*/
|
|
consume(key = 'global', cost = 1) {
|
|
const isAllowed = this.isAllowed(key, cost);
|
|
return isAllowed;
|
|
}
|
|
/**
|
|
* Get the remaining tokens for a key
|
|
* @param key Key to check
|
|
* @returns Number of remaining tokens
|
|
*/
|
|
getRemainingTokens(key = 'global') {
|
|
const bucket = this.getBucket(key);
|
|
this.refillBucket(bucket);
|
|
return bucket.tokens;
|
|
}
|
|
/**
|
|
* Get stats for a specific key
|
|
* @param key Key to get stats for
|
|
* @returns Rate limit statistics
|
|
*/
|
|
getStats(key = 'global') {
|
|
const bucket = this.getBucket(key);
|
|
this.refillBucket(bucket);
|
|
// Calculate time until next token
|
|
const resetIn = bucket.tokens < this.config.maxPerPeriod ?
|
|
Math.ceil(this.config.periodMs / this.config.maxPerPeriod) :
|
|
0;
|
|
return {
|
|
remaining: bucket.tokens,
|
|
limit: this.config.maxPerPeriod,
|
|
resetIn,
|
|
allowed: bucket.allowed,
|
|
denied: bucket.denied
|
|
};
|
|
}
|
|
/**
|
|
* Get or create a token bucket for a key
|
|
* @param key The rate limit key
|
|
* @returns Token bucket
|
|
*/
|
|
getBucket(key) {
|
|
if (!this.config.perKey || key === 'global') {
|
|
return this.globalBucket;
|
|
}
|
|
if (!this.buckets.has(key)) {
|
|
// Create new bucket
|
|
this.buckets.set(key, {
|
|
tokens: this.config.initialTokens,
|
|
lastRefill: Date.now(),
|
|
allowed: 0,
|
|
denied: 0,
|
|
errors: 0,
|
|
firstErrorTime: 0
|
|
});
|
|
}
|
|
return this.buckets.get(key);
|
|
}
|
|
/**
|
|
* Refill tokens in a bucket based on elapsed time
|
|
* @param bucket Token bucket to refill
|
|
*/
|
|
refillBucket(bucket) {
|
|
const now = Date.now();
|
|
const elapsedMs = now - bucket.lastRefill;
|
|
// Calculate how many tokens to add
|
|
const rate = this.config.maxPerPeriod / this.config.periodMs;
|
|
const tokensToAdd = elapsedMs * rate;
|
|
if (tokensToAdd >= 0.1) { // Allow for partial token refills
|
|
// Add tokens, but don't exceed the normal maximum (without burst)
|
|
// This ensures burst tokens are only used for bursts and don't refill
|
|
const normalMax = this.config.maxPerPeriod;
|
|
bucket.tokens = Math.min(
|
|
// Don't exceed max + burst
|
|
this.config.maxPerPeriod + (this.config.burstTokens || 0),
|
|
// Don't exceed normal max when refilling
|
|
Math.min(normalMax, bucket.tokens + tokensToAdd));
|
|
// Update last refill time
|
|
bucket.lastRefill = now;
|
|
}
|
|
}
|
|
/**
|
|
* Reset rate limits for a specific key
|
|
* @param key Key to reset
|
|
*/
|
|
reset(key = 'global') {
|
|
if (key === 'global' || !this.config.perKey) {
|
|
this.globalBucket.tokens = this.config.initialTokens;
|
|
this.globalBucket.lastRefill = Date.now();
|
|
}
|
|
else if (this.buckets.has(key)) {
|
|
const bucket = this.buckets.get(key);
|
|
bucket.tokens = this.config.initialTokens;
|
|
bucket.lastRefill = Date.now();
|
|
}
|
|
}
|
|
/**
|
|
* Reset all rate limiters
|
|
*/
|
|
resetAll() {
|
|
this.globalBucket.tokens = this.config.initialTokens;
|
|
this.globalBucket.lastRefill = Date.now();
|
|
for (const bucket of this.buckets.values()) {
|
|
bucket.tokens = this.config.initialTokens;
|
|
bucket.lastRefill = Date.now();
|
|
}
|
|
}
|
|
/**
|
|
* Cleanup old buckets to prevent memory leaks
|
|
* @param maxAge Maximum age in milliseconds
|
|
*/
|
|
cleanup(maxAge = 24 * 60 * 60 * 1000) {
|
|
const now = Date.now();
|
|
let removed = 0;
|
|
for (const [key, bucket] of this.buckets.entries()) {
|
|
if (now - bucket.lastRefill > maxAge) {
|
|
this.buckets.delete(key);
|
|
removed++;
|
|
}
|
|
}
|
|
if (removed > 0) {
|
|
logger.log('debug', `Cleaned up ${removed} stale rate limit buckets`);
|
|
}
|
|
}
|
|
/**
|
|
* Record an error for a key (e.g., IP address) and determine if blocking is needed
|
|
* RFC 5321 Section 4.5.4.1 suggests limiting errors to prevent abuse
|
|
*
|
|
* @param key Key to record error for (typically an IP address)
|
|
* @param errorWindow Time window for error tracking in ms (default: 5 minutes)
|
|
* @param errorThreshold Maximum errors before blocking (default: 10)
|
|
* @returns true if the key should be blocked due to excessive errors
|
|
*/
|
|
recordError(key, errorWindow = 5 * 60 * 1000, errorThreshold = 10) {
|
|
const bucket = this.getBucket(key);
|
|
const now = Date.now();
|
|
// Reset error count if the time window has expired
|
|
if (bucket.firstErrorTime === 0 || now - bucket.firstErrorTime > errorWindow) {
|
|
bucket.errors = 0;
|
|
bucket.firstErrorTime = now;
|
|
}
|
|
// Increment error count
|
|
bucket.errors++;
|
|
// Log error tracking
|
|
logger.log('debug', `Error recorded for ${key}: ${bucket.errors}/${errorThreshold} in window`);
|
|
// Check if threshold exceeded
|
|
if (bucket.errors >= errorThreshold) {
|
|
logger.log('warn', `Error threshold exceeded for ${key}: ${bucket.errors} errors`);
|
|
return true; // Should block
|
|
}
|
|
return false; // Continue allowing
|
|
}
|
|
}
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ratelimiter.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.ratelimiter.ts"],"names":[],"mappings":"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"}
|