mirror of
https://github.com/pacnpal/thrilltrack-explorer.git
synced 2025-12-20 10:31:13 -05:00
Migrate remaining edge functions to wrapper
Refactor process-expired-bans, detect-location, detect-anomalies, rate-limit-metrics, and collect-metrics to use createEdgeFunction wrapper with standardized error handling, tracing, and reduced boilerplate. Update signatures to receive { supabase, span, requestId } (and user where applicable), replace manual logging with span events, remove per-function boilerplate, and ensure consistent wrapper configuration (cors, auth, rate limits, and tracing).
This commit is contained in:
gpt-engineer-app[bot]
@@ -1,7 +1,7 @@
|
||||
import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
|
||||
import { corsHeadersWithTracing as corsHeaders } from '../_shared/cors.ts';
|
||||
import { edgeLogger, startRequest, endRequest, logSpanToDatabase, startSpan, endSpan } from "../_shared/logger.ts";
|
||||
import { formatEdgeError } from "../_shared/errorFormatter.ts";
|
||||
import { serve } from "https://deno.land/std@0.190.0/http/server.ts";
|
||||
import { createEdgeFunction, type EdgeFunctionContext } from '../_shared/edgeFunctionWrapper.ts';
|
||||
import { corsHeaders } from '../_shared/cors.ts';
|
||||
import { addSpanEvent } from '../_shared/logger.ts';
|
||||
|
||||
interface IPLocationResponse {
|
||||
country: string;
|
||||
@@ -11,86 +11,47 @@ interface IPLocationResponse {
|
||||
|
||||
// Simple in-memory rate limiter
|
||||
const rateLimitMap = new Map<string, { count: number; resetAt: number }>();
|
||||
const RATE_LIMIT_WINDOW = 60000; // 1 minute in milliseconds
|
||||
const RATE_LIMIT_WINDOW = 60000; // 1 minute
|
||||
const MAX_REQUESTS = 10; // 10 requests per minute per IP
|
||||
const MAX_MAP_SIZE = 10000; // Maximum number of IPs to track
|
||||
const MAX_MAP_SIZE = 10000;
|
||||
|
||||
// Cleanup failure tracking to prevent silent failures
|
||||
let cleanupFailureCount = 0;
|
||||
const MAX_CLEANUP_FAILURES = 5; // Threshold before forcing drastic cleanup
|
||||
const CLEANUP_FAILURE_RESET_INTERVAL = 300000; // Reset failure count every 5 minutes
|
||||
const MAX_CLEANUP_FAILURES = 5;
|
||||
const CLEANUP_FAILURE_RESET_INTERVAL = 300000; // 5 minutes
|
||||
|
||||
function cleanupExpiredEntries() {
|
||||
try {
|
||||
const now = Date.now();
|
||||
let deletedCount = 0;
|
||||
const mapSizeBefore = rateLimitMap.size;
|
||||
|
||||
for (const [ip, data] of rateLimitMap.entries()) {
|
||||
if (now > data.resetAt) {
|
||||
rateLimitMap.delete(ip);
|
||||
deletedCount++;
|
||||
}
|
||||
}
|
||||
|
||||
// Cleanup runs silently unless there are issues
|
||||
if (cleanupFailureCount > 0) {
|
||||
cleanupFailureCount = 0;
|
||||
}
|
||||
|
||||
} catch (error: unknown) {
|
||||
// CRITICAL: Increment failure counter and log detailed error information
|
||||
cleanupFailureCount++;
|
||||
|
||||
const errorMessage = formatEdgeError(error);
|
||||
|
||||
edgeLogger.error('Cleanup error', {
|
||||
attempt: cleanupFailureCount,
|
||||
maxAttempts: MAX_CLEANUP_FAILURES,
|
||||
error: errorMessage,
|
||||
mapSize: rateLimitMap.size
|
||||
});
|
||||
|
||||
// FALLBACK MECHANISM: If cleanup fails repeatedly, force clear to prevent memory leak
|
||||
if (cleanupFailureCount >= MAX_CLEANUP_FAILURES) {
|
||||
edgeLogger.error('Cleanup critical - forcing emergency cleanup', {
|
||||
consecutiveFailures: cleanupFailureCount,
|
||||
mapSize: rateLimitMap.size
|
||||
});
|
||||
|
||||
try {
|
||||
// Emergency: Clear oldest 50% of entries to prevent unbounded growth
|
||||
const entriesToClear = Math.floor(rateLimitMap.size * 0.5);
|
||||
const sortedEntries = Array.from(rateLimitMap.entries())
|
||||
.sort((a, b) => a[1].resetAt - b[1].resetAt);
|
||||
|
||||
let clearedCount = 0;
|
||||
for (let i = 0; i < entriesToClear && i < sortedEntries.length; i++) {
|
||||
rateLimitMap.delete(sortedEntries[i][0]);
|
||||
clearedCount++;
|
||||
}
|
||||
|
||||
edgeLogger.warn('Emergency cleanup completed', { clearedCount, newMapSize: rateLimitMap.size });
|
||||
|
||||
// Reset failure count after emergency cleanup
|
||||
cleanupFailureCount = 0;
|
||||
|
||||
} catch (emergencyError) {
|
||||
// Last resort: If even emergency cleanup fails, clear everything
|
||||
const originalSize = rateLimitMap.size;
|
||||
} catch {
|
||||
rateLimitMap.clear();
|
||||
|
||||
edgeLogger.error('Emergency cleanup failed - cleared entire map', {
|
||||
originalSize,
|
||||
error: emergencyError instanceof Error ? emergencyError.message : String(emergencyError)
|
||||
});
|
||||
cleanupFailureCount = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reset cleanup failure count periodically to avoid permanent emergency state
|
||||
setInterval(() => {
|
||||
if (cleanupFailureCount > 0) {
|
||||
cleanupFailureCount = 0;
|
||||
@@ -101,7 +62,6 @@ function checkRateLimit(ip: string): { allowed: boolean; retryAfter?: number } {
|
||||
const now = Date.now();
|
||||
const existing = rateLimitMap.get(ip);
|
||||
|
||||
// Handle existing entries (most common case - early return for performance)
|
||||
if (existing && now <= existing.resetAt) {
|
||||
if (existing.count >= MAX_REQUESTS) {
|
||||
const retryAfter = Math.ceil((existing.resetAt - now) / 1000);
|
||||
@@ -111,213 +71,108 @@ function checkRateLimit(ip: string): { allowed: boolean; retryAfter?: number } {
|
||||
return { allowed: true };
|
||||
}
|
||||
|
||||
// Need to add new entry or reset expired one
|
||||
// Only perform cleanup if we're at capacity AND adding a new IP
|
||||
if (!existing && rateLimitMap.size >= MAX_MAP_SIZE) {
|
||||
// First try cleaning expired entries
|
||||
cleanupExpiredEntries();
|
||||
|
||||
// If still at capacity after cleanup, remove oldest entries (LRU eviction)
|
||||
if (rateLimitMap.size >= MAX_MAP_SIZE) {
|
||||
try {
|
||||
const toDelete = Math.floor(MAX_MAP_SIZE * 0.3); // Remove 30% of entries
|
||||
const toDelete = Math.floor(MAX_MAP_SIZE * 0.3);
|
||||
const sortedEntries = Array.from(rateLimitMap.entries())
|
||||
.sort((a, b) => a[1].resetAt - b[1].resetAt);
|
||||
|
||||
let deletedCount = 0;
|
||||
for (let i = 0; i < toDelete && i < sortedEntries.length; i++) {
|
||||
rateLimitMap.delete(sortedEntries[i][0]);
|
||||
deletedCount++;
|
||||
}
|
||||
|
||||
edgeLogger.warn('Rate limit map at capacity - evicted entries', {
|
||||
maxSize: MAX_MAP_SIZE,
|
||||
deletedCount,
|
||||
newSize: rateLimitMap.size
|
||||
});
|
||||
} catch (evictionError) {
|
||||
// CRITICAL: LRU eviction failed - log error and attempt emergency clear
|
||||
edgeLogger.error('LRU eviction failed', {
|
||||
error: evictionError instanceof Error ? evictionError.message : String(evictionError),
|
||||
mapSize: rateLimitMap.size
|
||||
});
|
||||
|
||||
try {
|
||||
// Emergency: Clear first 30% of entries without sorting
|
||||
const targetSize = Math.floor(MAX_MAP_SIZE * 0.7);
|
||||
const keysToDelete: string[] = [];
|
||||
|
||||
for (const [key] of rateLimitMap.entries()) {
|
||||
if (rateLimitMap.size <= targetSize) break;
|
||||
keysToDelete.push(key);
|
||||
}
|
||||
|
||||
keysToDelete.forEach(key => rateLimitMap.delete(key));
|
||||
|
||||
edgeLogger.warn('Emergency eviction completed', {
|
||||
clearedCount: keysToDelete.length,
|
||||
newSize: rateLimitMap.size
|
||||
});
|
||||
} catch (emergencyError) {
|
||||
edgeLogger.error('Emergency eviction failed - clearing entire map', {
|
||||
error: emergencyError instanceof Error ? emergencyError.message : String(emergencyError)
|
||||
});
|
||||
rateLimitMap.clear();
|
||||
}
|
||||
} catch {
|
||||
rateLimitMap.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Create new entry or reset expired entry
|
||||
rateLimitMap.set(ip, { count: 1, resetAt: now + RATE_LIMIT_WINDOW });
|
||||
return { allowed: true };
|
||||
}
|
||||
|
||||
// Clean up old entries periodically to prevent memory leak
|
||||
// Run cleanup more frequently to catch expired entries sooner
|
||||
setInterval(cleanupExpiredEntries, Math.min(RATE_LIMIT_WINDOW / 2, 30000)); // Every 30 seconds or half the window
|
||||
|
||||
serve(async (req) => {
|
||||
// Handle CORS preflight requests
|
||||
if (req.method === 'OPTIONS') {
|
||||
return new Response(null, { headers: corsHeaders });
|
||||
}
|
||||
|
||||
const tracking = startRequest('detect-location');
|
||||
|
||||
try {
|
||||
// Get the client's IP address
|
||||
const forwarded = req.headers.get('x-forwarded-for');
|
||||
const realIP = req.headers.get('x-real-ip');
|
||||
const clientIP = forwarded?.split(',')[0] || realIP || '8.8.8.8'; // fallback to Google DNS for testing
|
||||
|
||||
// Check rate limit
|
||||
const rateLimit = checkRateLimit(clientIP);
|
||||
if (!rateLimit.allowed) {
|
||||
return new Response(
|
||||
JSON.stringify({
|
||||
error: 'Rate limit exceeded',
|
||||
message: 'Too many requests. Please try again later.',
|
||||
retryAfter: rateLimit.retryAfter
|
||||
}),
|
||||
{
|
||||
status: 429,
|
||||
headers: {
|
||||
...corsHeaders,
|
||||
'Content-Type': 'application/json',
|
||||
'Retry-After': String(rateLimit.retryAfter || 60)
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// PII Note: Do not log full IP addresses in production
|
||||
edgeLogger.info('Detecting location for request', { requestId: tracking.requestId });
|
||||
|
||||
// Use configurable geolocation service with proper error handling
|
||||
// Defaults to ip-api.com if not configured
|
||||
const geoApiUrl = Deno.env.get('GEOLOCATION_API_URL') || 'http://ip-api.com/json';
|
||||
const geoApiFields = Deno.env.get('GEOLOCATION_API_FIELDS') || 'status,country,countryCode';
|
||||
|
||||
let geoResponse;
|
||||
try {
|
||||
geoResponse = await fetch(`${geoApiUrl}/${clientIP}?fields=${geoApiFields}`);
|
||||
} catch (fetchError) {
|
||||
edgeLogger.error('Network error fetching location data', {
|
||||
error: fetchError instanceof Error ? fetchError.message : String(fetchError),
|
||||
requestId: tracking.requestId
|
||||
});
|
||||
throw new Error('Network error: Unable to reach geolocation service');
|
||||
}
|
||||
|
||||
if (!geoResponse.ok) {
|
||||
throw new Error(`Geolocation service returned ${geoResponse.status}: ${geoResponse.statusText}`);
|
||||
}
|
||||
|
||||
let geoData;
|
||||
try {
|
||||
geoData = await geoResponse.json();
|
||||
} catch (parseError) {
|
||||
edgeLogger.error('Failed to parse geolocation response', {
|
||||
error: parseError instanceof Error ? parseError.message : String(parseError),
|
||||
requestId: tracking.requestId
|
||||
});
|
||||
throw new Error('Invalid response format from geolocation service');
|
||||
}
|
||||
|
||||
if (geoData.status !== 'success') {
|
||||
throw new Error(`Geolocation failed: ${geoData.message || 'Invalid location data'}`);
|
||||
}
|
||||
|
||||
// Countries that primarily use imperial system
|
||||
const imperialCountries = ['US', 'LR', 'MM']; // USA, Liberia, Myanmar
|
||||
const measurementSystem = imperialCountries.includes(geoData.countryCode) ? 'imperial' : 'metric';
|
||||
|
||||
const result: IPLocationResponse = {
|
||||
country: geoData.country,
|
||||
countryCode: geoData.countryCode,
|
||||
measurementSystem
|
||||
};
|
||||
|
||||
edgeLogger.info('Location detected', {
|
||||
country: result.country,
|
||||
countryCode: result.countryCode,
|
||||
measurementSystem: result.measurementSystem,
|
||||
requestId: tracking.requestId
|
||||
});
|
||||
|
||||
endRequest(tracking);
|
||||
|
||||
return new Response(
|
||||
JSON.stringify({ ...result, requestId: tracking.requestId }),
|
||||
{
|
||||
headers: {
|
||||
...corsHeaders,
|
||||
'Content-Type': 'application/json',
|
||||
'X-Request-ID': tracking.requestId
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
} catch (error: unknown) {
|
||||
// Enhanced error logging for better visibility and debugging
|
||||
const errorMessage = formatEdgeError(error);
|
||||
|
||||
edgeLogger.error('Location detection error', {
|
||||
error: errorMessage,
|
||||
requestId: tracking.requestId
|
||||
});
|
||||
|
||||
// Persist error to database for monitoring
|
||||
const errorSpan = startSpan('detect-location-error', 'SERVER');
|
||||
endSpan(errorSpan, 'error', error);
|
||||
logSpanToDatabase(errorSpan, tracking.requestId);
|
||||
|
||||
endRequest(tracking);
|
||||
|
||||
// Return default (metric) with 500 status to indicate error occurred
|
||||
// This allows proper error monitoring while still providing fallback data
|
||||
const defaultResult: IPLocationResponse = {
|
||||
country: 'Unknown',
|
||||
countryCode: 'XX',
|
||||
measurementSystem: 'metric'
|
||||
};
|
||||
setInterval(cleanupExpiredEntries, Math.min(RATE_LIMIT_WINDOW / 2, 30000));
|
||||
|
||||
const handler = async (req: Request, { span, requestId }: EdgeFunctionContext) => {
|
||||
// Get client IP
|
||||
const forwarded = req.headers.get('x-forwarded-for');
|
||||
const realIP = req.headers.get('x-real-ip');
|
||||
const clientIP = forwarded?.split(',')[0] || realIP || '8.8.8.8';
|
||||
|
||||
// Check rate limit
|
||||
const rateLimit = checkRateLimit(clientIP);
|
||||
if (!rateLimit.allowed) {
|
||||
addSpanEvent(span, 'rate_limit_exceeded', { clientIP: clientIP.substring(0, 8) + '...' });
|
||||
return new Response(
|
||||
JSON.stringify({
|
||||
...defaultResult,
|
||||
error: errorMessage,
|
||||
fallback: true,
|
||||
requestId: tracking.requestId
|
||||
error: 'Rate limit exceeded',
|
||||
message: 'Too many requests. Please try again later.',
|
||||
retryAfter: rateLimit.retryAfter
|
||||
}),
|
||||
{
|
||||
headers: {
|
||||
...corsHeaders,
|
||||
'Content-Type': 'application/json',
|
||||
'X-Request-ID': tracking.requestId
|
||||
},
|
||||
status: 500
|
||||
{
|
||||
status: 429,
|
||||
headers: {
|
||||
'Retry-After': String(rateLimit.retryAfter || 60)
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
addSpanEvent(span, 'detecting_location', { requestId });
|
||||
|
||||
// Use configurable geolocation service
|
||||
const geoApiUrl = Deno.env.get('GEOLOCATION_API_URL') || 'http://ip-api.com/json';
|
||||
const geoApiFields = Deno.env.get('GEOLOCATION_API_FIELDS') || 'status,country,countryCode';
|
||||
|
||||
let geoResponse;
|
||||
try {
|
||||
geoResponse = await fetch(`${geoApiUrl}/${clientIP}?fields=${geoApiFields}`);
|
||||
} catch (fetchError) {
|
||||
addSpanEvent(span, 'network_error', { error: fetchError instanceof Error ? fetchError.message : String(fetchError) });
|
||||
throw new Error('Network error: Unable to reach geolocation service');
|
||||
}
|
||||
|
||||
if (!geoResponse.ok) {
|
||||
throw new Error(`Geolocation service returned ${geoResponse.status}: ${geoResponse.statusText}`);
|
||||
}
|
||||
|
||||
let geoData;
|
||||
try {
|
||||
geoData = await geoResponse.json();
|
||||
} catch (parseError) {
|
||||
addSpanEvent(span, 'parse_error', { error: parseError instanceof Error ? parseError.message : String(parseError) });
|
||||
throw new Error('Invalid response format from geolocation service');
|
||||
}
|
||||
|
||||
if (geoData.status !== 'success') {
|
||||
throw new Error(`Geolocation failed: ${geoData.message || 'Invalid location data'}`);
|
||||
}
|
||||
|
||||
// Countries that primarily use imperial system
|
||||
const imperialCountries = ['US', 'LR', 'MM'];
|
||||
const measurementSystem = imperialCountries.includes(geoData.countryCode) ? 'imperial' : 'metric';
|
||||
|
||||
const result: IPLocationResponse = {
|
||||
country: geoData.country,
|
||||
countryCode: geoData.countryCode,
|
||||
measurementSystem
|
||||
};
|
||||
|
||||
addSpanEvent(span, 'location_detected', {
|
||||
country: result.country,
|
||||
countryCode: result.countryCode,
|
||||
measurementSystem: result.measurementSystem
|
||||
});
|
||||
|
||||
return result;
|
||||
};
|
||||
|
||||
serve(createEdgeFunction({
|
||||
name: 'detect-location',
|
||||
requireAuth: false,
|
||||
corsHeaders,
|
||||
enableTracing: true,
|
||||
logRequests: true,
|
||||
}, handler));
|
||||
|
||||
Reference in New Issue
Block a user