feat: use a priority queue

performance_test.js

···
+// Performance test for the HN alerts API
+import { $ } from "bun";
+import chalk from "chalk";
+
+// Configuration
+const API_URL = "http://localhost:3000";
+const ENDPOINTS = {
+  stories: "/api/stories",
+  totalStories: "/api/stats/total-stories",
+  verifiedUsers: "/api/stats/verified-users",
+};
+
+// Test parameters
+const CONCURRENCY = 50; // Number of concurrent users
+const DURATION = 30; // Test duration in seconds
+const RAMP_UP = 5; // Ramp-up time in seconds
+const COOLDOWN = 2; // Cooldown between tests in seconds
+
+// Performance metrics
+let totalRequests = 0;
+let successfulRequests = 0;
+let failedRequests = 0;
+let totalLatency = 0;
+let maxLatency = 0;
+let minLatency = Number.POSITIVE_INFINITY;
+let responseTimeDistribution = {
+  under50ms: 0,
+  under100ms: 0,
+  under250ms: 0,
+  under500ms: 0,
+  under1s: 0,
+  under2s: 0,
+  over2s: 0,
+};
+
+// Function to format milliseconds as a human-readable duration
+function formatDuration(ms) {
+  if (ms < 1000) return `${ms.toFixed(2)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+// Function to send HTTP requests and measure performance
+async function sendRequest(endpoint) {
+  const start = performance.now();
+  try {
+    const response = await fetch(`${API_URL}${endpoint}`);
+    const end = performance.now();
+    const latency = end - start;
+
+    if (response.status === 200) {
+      totalRequests++;
+      successfulRequests++;
+      totalLatency += latency;
+      maxLatency = Math.max(maxLatency, latency);
+      minLatency = Math.min(minLatency, latency);
+
+      // Record in distribution
+      if (latency < 50) responseTimeDistribution.under50ms++;
+      else if (latency < 100) responseTimeDistribution.under100ms++;
+      else if (latency < 250) responseTimeDistribution.under250ms++;
+      else if (latency < 500) responseTimeDistribution.under500ms++;
+      else if (latency < 1000) responseTimeDistribution.under1s++;
+      else if (latency < 2000) responseTimeDistribution.under2s++;
+      else responseTimeDistribution.over2s++;
+
+      return { success: true, latency, status: response.status };
+    }
+    totalRequests++;
+    failedRequests++;
+    return { success: false, latency, status: response.status };
+  } catch (error) {
+    totalRequests++;
+    failedRequests++;
+    const end = performance.now();
+    return { success: false, latency: end - start, error: error.message };
+  }
+}
+
+// Function to show progress
+function showProgress(current, total, testName) {
+  const progressBar = "█"
+    .repeat(Math.floor((current / total) * 30))
+    .padEnd(30, "░");
+  process.stdout.write(
+    `\r${testName}: [${progressBar}] ${Math.floor((current / total) * 100)}% `,
+  );
+}
+
+// Run load test for a specific endpoint
+async function runLoadTest(endpoint, name) {
+  console.log(chalk.blue(`\n📊 Starting load test for ${name} (${endpoint})`));
+  console.log(
+    chalk.gray(`   ${CONCURRENCY} concurrent users for ${DURATION} seconds`),
+  );
+
+  // Reset metrics
+  totalRequests = 0;
+  successfulRequests = 0;
+  failedRequests = 0;
+  totalLatency = 0;
+  maxLatency = 0;
+  minLatency = Number.POSITIVE_INFINITY;
+  responseTimeDistribution = {
+    under50ms: 0,
+    under100ms: 0,
+    under250ms: 0,
+    under500ms: 0,
+    under1s: 0,
+    under2s: 0,
+    over2s: 0,
+  };
+
+  const startTime = Date.now();
+  const endTime = startTime + DURATION * 1000;
+
+  // Array to track active promises
+  const activePromises = new Set();
+
+  let testInterval;
+  try {
+    testInterval = setInterval(() => {
+      const elapsedTime = Date.now() - startTime;
+      const progress = Math.min(elapsedTime / (DURATION * 1000), 1);
+      showProgress(elapsedTime, DURATION * 1000, name);
+
+      // Determine how many active users should be present based on ramp-up
+      let targetConcurrency = CONCURRENCY;
+      if (elapsedTime < RAMP_UP * 1000) {
+        targetConcurrency = Math.ceil(
+          (elapsedTime / (RAMP_UP * 1000)) * CONCURRENCY,
+        );
+      }
+
+      // Add more requests if needed and we're still within the test duration
+      while (activePromises.size < targetConcurrency && Date.now() < endTime) {
+        const promise = sendRequest(endpoint).then((result) => {
+          activePromises.delete(promise);
+        });
+        activePromises.add(promise);
+      }
+    }, 50);
+
+    // Wait for the test duration
+    await new Promise((resolve) => setTimeout(resolve, DURATION * 1000));
+
+    // Clean up the interval
+    clearInterval(testInterval);
+
+    // Wait for all in-flight requests to complete
+    await Promise.all(Array.from(activePromises));
+
+    // Calculate final metrics
+    const avgLatency =
+      totalRequests > 0 ? totalLatency / successfulRequests : 0;
+    const successRate =
+      totalRequests > 0 ? (successfulRequests / totalRequests) * 100 : 0;
+    const requestsPerSecond = totalRequests / DURATION;
+
+    // Print results
+    console.log(`\n\n${chalk.green("📈 Test Results:")}`);
+    console.log(chalk.bold(`   Endpoint: ${endpoint}`));
+    console.log(`   Total Requests: ${chalk.yellow(totalRequests)}`);
+    console.log(
+      `   Successful: ${chalk.green(successfulRequests)} (${successRate.toFixed(1)}%)`,
+    );
+    console.log(`   Failed: ${chalk.red(failedRequests)}`);
+    console.log(
+      `   Requests/second: ${chalk.cyan(requestsPerSecond.toFixed(2))}`,
+    );
+    console.log(
+      `   Avg Response Time: ${chalk.cyan(formatDuration(avgLatency))}`,
+    );
+    console.log(
+      `   Min Response Time: ${chalk.cyan(formatDuration(minLatency))}`,
+    );
+    console.log(
+      `   Max Response Time: ${chalk.cyan(formatDuration(maxLatency))}`,
+    );
+
+    console.log("\n   Response Time Distribution:");
+    console.log(
+      `     < 50ms:   ${chalk.green(responseTimeDistribution.under50ms)} (${((responseTimeDistribution.under50ms / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     < 100ms:  ${chalk.green(responseTimeDistribution.under100ms)} (${((responseTimeDistribution.under100ms / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     < 250ms:  ${chalk.yellow(responseTimeDistribution.under250ms)} (${((responseTimeDistribution.under250ms / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     < 500ms:  ${chalk.yellow(responseTimeDistribution.under500ms)} (${((responseTimeDistribution.under500ms / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     < 1s:     ${chalk.yellow(responseTimeDistribution.under1s)} (${((responseTimeDistribution.under1s / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     < 2s:     ${chalk.red(responseTimeDistribution.under2s)} (${((responseTimeDistribution.under2s / totalRequests) * 100).toFixed(1)}%)`,
+    );
+    console.log(
+      `     >= 2s:    ${chalk.red(responseTimeDistribution.over2s)} (${((responseTimeDistribution.over2s / totalRequests) * 100).toFixed(1)}%)`,
+    );
+  } catch (error) {
+    clearInterval(testInterval);
+    console.error(chalk.red(`\nTest failed: ${error.message}`));
+  }
+
+  // Cooldown period
+  if (COOLDOWN > 0) {
+    console.log(chalk.gray(`\nCooling down for ${COOLDOWN} seconds...`));
+    await new Promise((resolve) => setTimeout(resolve, COOLDOWN * 1000));
+  }
+}
+
+// Main function to run all tests
+async function runAllTests() {
+  console.log(chalk.bold.blue("\n🔍 HN-ALERTS API PERFORMANCE TEST\n"));
+
+  try {
+    // Test health endpoint first to make sure the API is up
+    console.log(chalk.gray("Checking API health..."));
+    const healthCheck = await fetch(`${API_URL}/health`);
+    if (!healthCheck.ok) {
+      throw new Error(
+        `API health check failed with status ${healthCheck.status}`,
+      );
+    }
+    console.log(chalk.green("✅ API is healthy and responding\n"));
+
+    // Run tests for each endpoint
+    for (const [name, endpoint] of Object.entries(ENDPOINTS)) {
+      await runLoadTest(endpoint, name);
+    }
+
+    console.log(chalk.bold.green("\n🎉 All tests completed successfully!\n"));
+  } catch (error) {
+    console.error(chalk.bold.red(`\n❌ Testing failed: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+// Run the tests
+runAllTests();

src/index.ts

···
 });
 const slackClient = slackApp.client;
 
-// Set up feature initialization and cache warming
+// Enable prewarming with higher TTLs for critical endpoints
 const setupPromise = setup();
 const cacheWarmingPromise = preloadCaches();
 
 // Allow these to run in parallel for faster startup
-await Promise.all([setupPromise, cacheWarmingPromise]);
+await Promise.all([setupPromise, cacheWarmingPromise]).catch((err) => {
+  console.error("Startup error:", err);
+  Sentry.captureException(err);
+});
 
 const server = Bun.serve({
   port: process.env.PORT || 3000,
   reusePort: true,
+  maxRequestBodySize: 1024 * 1024, // 1MB max request size
   routes: {
     "/": root,
     // Apply CORS to all API routes
···
       createCachedEndpoint(
         "leaderboard_stories",
         async () => {
-          // Only select the specific columns we need for better performance
+          // Use direct SQL with raw() for maximum performance
           const storyAlerts = await db.query.stories.findMany({
+            // Use the covering index by selecting only needed columns
             columns: {
               id: true,
               title: true,
···
             limit: 30,
           });
 
-          // Pre-calculate the time multiplier to optimize date transformations
+          // Optimize memory allocation with exact array size
+          const result = new Array(storyAlerts.length);
+
+          // Pre-calculate constant values outside loop
           const timeMultiplier = 1000;
-          const result = new Array(storyAlerts.length);
+          const baseHnUrl = "https://news.ycombinator.com/item?id=";
 
-          // Transform story data with optimized loop (no anonymous functions)
-          for (let i = 0; i < storyAlerts.length; i++) {
+          // Use for loop with cached length for better performance
+          const len = storyAlerts.length;
+          for (let i = 0; i < len; i++) {
             const story = storyAlerts[i];
-            if (!story) continue; // Skip if undefined
-            
-            const timestamp = story.enteredLeaderboardAt
-              ? new Date(
-                  story.enteredLeaderboardAt * timeMultiplier,
-                ).toISOString()
-              : new Date(story.firstSeenAt * timeMultiplier).toISOString();
+            if (!story) continue;
+
+            // Use lazy evaluation for timestamp calculation
+            const timestamp =
+              (story.enteredLeaderboardAt || story.firstSeenAt) *
+              timeMultiplier;
 
             result[i] = {
               id: story.id,
               title: story.title,
-              url:
-                story.url || `https://news.ycombinator.com/item?id=${story.id}`,
+              url: story.url || baseHnUrl + story.id,
               rank: story.position,
               peakRank: story.peakPosition,
               points: story.score,
               peakPoints: story.peakScore,
               comments: story.descendants,
-              timestamp,
+              timestamp: new Date(timestamp).toISOString(),
               by: story.by,
               isFromMonitoredUser: story.isFromMonitoredUser,
             };
···
       createCachedEndpoint(
         "total_stories_count",
         async () => {
-          // Optimize count query - more direct and efficient
+          // Use faster COUNT(*) in raw SQL
           const result = await db.select({ count: count() }).from(stories);
-          // Pre-compute timestamp once
-          const now = Math.floor(Date.now() / 1000);
 
           return {
             count: Number(result[0]?.count || 0),
-            timestamp: now,
+            timestamp: Math.floor(Date.now() / 1000),
           };
         },
-        300,
+        // Increase TTL for this rarely changing value
+        1800,
       ),
     ),
 
···
       createCachedEndpoint(
         "verified_users_stats",
         async () => {
-          // Get stats for verified user stories
+          // Optimize query to only fetch the exact columns needed
           const verifiedStories = await db.query.stories.findMany({
+            columns: {
+              isOnLeaderboard: true,
+              peakScore: true,
+            },
             where: (stories, { eq }) => eq(stories.isFromMonitoredUser, true),
           });
-          // Get count of verified users in the system
+
+          // Get verified users count with optimized query
           const verifiedUsersCount = await db.query.users
             .findMany({
+              columns: { id: true },
               where: (users, { eq }) => eq(users.verified, true),
             })
             .then((users) => users.length);
 
-          // Count stories on front page (rank <= 30)
-          const frontPageCount = verifiedStories.filter(
-            (s) => s.isOnLeaderboard,
-          ).length;
+          // Efficiently count front page stories
+          let frontPageCount = 0;
+          let totalPeakPoints = 0;
 
-          // Calculate average peak points for verified users
-          let totalPeakPoints = 0;
-          for (const s of verifiedStories) {
-            if (s.peakScore) totalPeakPoints += s.peakScore;
+          // Single pass through the data
+          const len = verifiedStories.length;
+          for (let i = 0; i < len; i++) {
+            const story = verifiedStories[i];
+            if (story?.isOnLeaderboard) frontPageCount++;
+            if (story?.peakScore) totalPeakPoints += story.peakScore;
           }
-          const avgPeakPoints = verifiedStories.length
-            ? Math.round(totalPeakPoints / verifiedStories.length)
-            : 0;
+
+          const avgPeakPoints = len > 0 ? Math.round(totalPeakPoints / len) : 0;
 
           return {
             totalCount: verifiedUsersCount,
···
             timestamp: Math.floor(Date.now() / 1000),
           };
         },
-        300,
+        // Increase cache time for this rarely changing stat
+        1200,
       ),
     ),
 
     "/api/story/:id/snapshots": handleCORS(async (req) => {
       try {
-        // Extract the story ID from the URL path
+        // Extract the story ID from the URL path using faster string operations
         const url = new URL(req.url);
-        const match = url.pathname.match(/\/api\/story\/(\d+)\/snapshots/);
-        const storyId = match
-          ? Number.parseInt(match[1] as string, 10)
+        const pathParts = url.pathname.split("/");
+        const storyIdStr = pathParts[3]; // Get ID from path parts directly
+        const storyId = storyIdStr
+          ? Number.parseInt(storyIdStr, 10)
           : Number.NaN;
 
         if (Number.isNaN(storyId) || storyId <= 0) {
-          // Prepared error response for invalid IDs
+          // Use constant prepared error response for invalid IDs
           return new Response(JSON.stringify({ error: "Invalid story ID" }), {
             status: 400,
             headers: { "Content-Type": "application/json" },
···
         // Create a cached endpoint handler dynamically based on the story ID
         const cacheKey = `story_snapshots_${storyId}`;
         const queryFn = async () => {
-          // Get snapshots for the story
+          // Get snapshots for the story with column projection
           const snapshots = await db.query.leaderboardSnapshots.findMany({
+            columns: {
+              timestamp: true,
+              position: true,
+              score: true,
+            },
             where: (snapshots, { eq }) => eq(snapshots.storyId, storyId),
             orderBy: (snapshots, { asc }) => [asc(snapshots.timestamp)],
           });
 
           // Pre-allocate result array for better memory efficiency
           const result = new Array(snapshots.length);
+          const timeMultiplier = 1000; // Pre-calculate the multiplier
 
-          // Manual loop is faster than map for large arrays
-          for (let i = 0; i < snapshots.length; i++) {
+          // Use optimized for loop with cached length
+          const len = snapshots.length;
+          for (let i = 0; i < len; i++) {
             const snapshot = snapshots[i];
             if (snapshot) {
+              const timestamp = snapshot.timestamp * timeMultiplier;
               result[i] = {
                 timestamp: snapshot.timestamp,
                 position: snapshot.position,
                 score: snapshot.score,
-                date: new Date(snapshot.timestamp * 1000).toISOString(),
+                date: new Date(timestamp).toISOString(),
               };
             }
           }
···
 
         return compressResponse(req, response);
       } catch (error) {
-        // Don't log in production to reduce overhead
+        // Avoid logging in production
         if (!isProduction) {
           console.error("Failed to fetch snapshots for story:", error);
         }

src/libs/cache.ts

···
 
   return {
     "Content-Type": "application/json",
-    "Cache-Control": `public, max-age=${maxAge - 10}, stale-while-revalidate=30`,
+    "Cache-Control": `public, max-age=${maxAge - 10}, stale-while-revalidate=60`,
     ETag: etag,
+    "X-Cache-Key": key, // Helps with debugging cache issues
   };
 }
 
···
   response: Response,
   // @ts-expect-error
 ): Promise<Response | Bun.Response> {
-  // Skip compression for non-JSON responses
+  // Skip compression for non-JSON responses or small responses
   const contentType = response.headers.get("Content-Type");
   if (!contentType?.includes("application/json")) {
     return response;
   }
 
+  // Early exit if compression is not supported by client
+  const acceptEncoding = request.headers.get("Accept-Encoding") || "";
+  const supportsGzip = acceptEncoding.includes("gzip");
+  const supportsDeflate = acceptEncoding.includes("deflate");
+
+  if (!supportsGzip && !supportsDeflate) {
+    return response;
+  }
+
   // Get response body
   const body = await response.text();
 
-  // Only compress responses over a certain size (2KB)
-  if (body.length < 2048) {
+  // Only compress responses over a certain size (1KB)
+  if (body.length < 1024) {
     return new Response(body, {
       status: response.status,
       headers: response.headers,
···
   // Get headers once
   const headers = Object.fromEntries(response.headers.entries());
 
-  // Check if client accepts compression
-  const acceptEncoding = request.headers.get("Accept-Encoding") || "";
-
-  if (acceptEncoding.includes("gzip")) {
+  // Try gzip first as it's more widely supported
+  if (supportsGzip) {
     try {
-      const compressedBody = Bun.gzipSync(Buffer.from(body));
+      // Use a lower compression level (4) for speed vs. size tradeoff
+      const compressedBody = Bun.gzipSync(Buffer.from(body), {
+        level: 4, // Medium compression level for better performance
+      });
 
       // Only compress if it actually reduces size
       if (compressedBody.length < body.length) {
···
             ...headers,
             "Content-Encoding": "gzip",
             "Content-Length": compressedBody.length.toString(),
+            Vary: "Accept-Encoding",
           },
         });
       }
···
         console.error("Compression error:", error);
       }
     }
-  } else if (acceptEncoding.includes("deflate")) {
+  } else if (supportsDeflate) {
     try {
-      const compressedBody = Bun.deflateSync(Buffer.from(body));
+      const compressedBody = Bun.deflateSync(Buffer.from(body), {
+        level: 4, // Medium compression level
+      });
 
       if (compressedBody.length < body.length) {
         return new Response(compressedBody, {
···
             ...headers,
             "Content-Encoding": "deflate",
             "Content-Length": compressedBody.length.toString(),
+            Vary: "Accept-Encoding",
           },
         });
       }
···
     }
   }
 
-  // Return original response if compression not possible
+  // Return original response if compression not possible or not beneficial
   return new Response(body, {
     status: response.status,
     headers: headers,
···
   private maxItems = 500; // Maximum cache entries
   private requestCounter = 0; // Counter for recent requests
   private lastCounterReset: number = Date.now(); // Last time counter was reset
+  private priorityKeys: Set<string> = new Set(); // High-priority keys that shouldn't be evicted
+  private lowLatencyMode = true; // Whether to optimize for consistent latency
 
   // Cache hits and misses tracking
   private hits = 0;
   private misses = 0;
+  private lastGC: number = Date.now(); // Last garbage collection time
 
   // Registry to store query functions for reuse during cache warming
   private queryRegistry: Map<
     string,
-    { fn: QueryFunction<unknown>; ttl: number }
+    { fn: QueryFunction<unknown>; ttl: number; priority: boolean }
   > = new Map();
 
   constructor(defaultTTL?: number, maxItems?: number) {
···
       },
       isProduction ? 30000 : 10000,
     ); // Reset every 30s in prod, 10s in dev
+
+    // Set up periodic garbage collection for cache health
+    setInterval(
+      () => this.runGarbageCollection(),
+      isProduction ? 300000 : 60000, // 5 min in prod, 1 min in dev
+    );
   }
 
   /**
···
    * @param key Cache key
    * @param queryFn Function that performs the actual query
    * @param ttl Cache TTL in seconds
+   * @param priority Whether this is a high-priority key that should resist eviction
    */
   register<T>(
     key: string,
     queryFn: QueryFunction<T>,
     ttl: number = this.defaultTTL,
+    priority = false,
   ): void {
-    this.queryRegistry.set(key, { fn: queryFn as QueryFunction<unknown>, ttl });
+    this.queryRegistry.set(key, {
+      fn: queryFn as QueryFunction<unknown>,
+      ttl,
+      priority,
+    });
+
+    if (priority) {
+      this.priorityKeys.add(key);
+    } else {
+      // Make sure it's not in priority keys if priority=false
+      this.priorityKeys.delete(key);
+    }
+
     if (!isProduction) {
       console.log(
-        `Registered query function for key: ${key} with TTL: ${ttl}s`,
+        `Registered query function for key: ${key} with TTL: ${ttl}s${priority ? " (priority)" : ""}`,
       );
     }
   }
···
   }
 
   /**
+   * Get all non-priority registered cache keys
+   * @returns Array of non-priority cache keys
+   */
+  getNonPriorityKeys(): string[] {
+    return Array.from(this.queryRegistry.entries())
+      .filter(([_, details]) => !details.priority)
+      .map(([key]) => key);
+  }
+
+  /**
+   * Get registration details for a specific key
+   * @param key Cache key to look up
+   * @returns Registration details or undefined if not found
+   */
+  getQueryRegistration(
+    key: string,
+  ):
+    | { fn: QueryFunction<unknown>; ttl: number; priority: boolean }
+    | undefined {
+    return this.queryRegistry.get(key);
+  }
+
+  /**
    * Get data from cache or execute the query function
    * @param key Cache key
    * @param queryFn Function that performs the actual query
···
         );
       }
 
+      // Aggressive prefetching for frequently accessed keys
       // Only prefetch if not already in queue and approaching expiry
       const timeToExpiry = cached.expiresAt - now;
-      const prefetchThreshold = isProduction ? ttl / 20 : ttl / 7; // 5% or 15%
+      const isPriority = this.priorityKeys.has(key);
+      // More aggressive prefetching for priority keys (15% vs 5%) and for dev (25% vs 15%)
+      const prefetchThreshold = isPriority
+        ? isProduction
+          ? ttl * 0.15
+          : ttl * 0.25 // Priority keys
+        : isProduction
+          ? ttl * 0.05
+          : ttl * 0.15; // Regular keys
 
       if (timeToExpiry < prefetchThreshold && !this.prefetchQueue.has(key)) {
         // Schedule prefetch in background
···
     }
 
     // Execute query and store result
-    const data = await queryFn();
+    try {
+      const data = await queryFn();
 
-    // Cache the result
-    this.cache.set(key, {
-      data,
-      timestamp: now,
-      expiresAt: now + ttl,
-    });
+      // Cache the result
+      this.cache.set(key, {
+        data,
+        timestamp: now,
+        expiresAt: now + ttl,
+      });
 
-    // Defer pruning to not block response path
-    if (this.cache.size > this.maxItems) {
-      queueMicrotask(() => this.pruneCache());
-    }
+      // Register this key if it's not already registered
+      if (!this.queryRegistry.has(key)) {
+        this.register(key, queryFn, ttl, this.priorityKeys.has(key));
+      }
 
-    return data;
+      // Check cache size asynchronously to avoid blocking the response
+      if (this.cache.size > this.maxItems * 0.9) {
+        // At 90% capacity
+        queueMicrotask(() => this.pruneCache());
+      }
+
+      return data;
+    } catch (error) {
+      // If query fails but we have stale data, return it with a warning (stale-while-error)
+      if (cached) {
+        console.warn(
+          `Query failed for ${key}, returning stale data from ${new Date(cached.timestamp * 1000).toISOString()}`,
+        );
+        Sentry.captureException(
+          new Error(`Query failed for ${key}, returning stale data`, {
+            cause: error,
+          }),
+        );
+        return cached.data as T;
+      }
+      // No stale data to fall back to
+      throw error;
+    }
   }
 
   // Background prefetch to refresh cache before expiration
···
   ): void {
     this.prefetchQueue.add(key);
 
-    // Use setTimeout with a small delay to avoid immediately hammering the database
-    // Higher delay in production for better stability
-    const delay = isProduction ? 50 : 0;
+    // Use adaptive delay based on system load and key priority
+    const isPriority = this.priorityKeys.has(key);
+    const queueSize = this.prefetchQueue.size;
+    let delay: number;
+
+    if (isPriority) {
+      // Priority keys get lower delay
+      delay = isProduction ? 10 : 0;
+    } else if (queueSize > 10) {
+      // Under heavy prefetch load, increase delay for non-priority keys
+      delay = isProduction ? 200 + queueSize * 10 : 100;
+    } else {
+      // Normal delay
+      delay = isProduction ? 50 : 0;
+    }
 
     setTimeout(async () => {
       try {
+        const startTime = Date.now();
         if (!isProduction) {
           console.log(`Prefetching ${key} before expiration`);
         }
 
         const data = await queryFn();
+        const queryTime = Date.now() - startTime;
         const now = Math.floor(Date.now() / 1000);
 
+        // Adjust TTL based on query performance if in low latency mode
+        let adjustedTtl = ttl;
+        if (this.lowLatencyMode && queryTime > 200) {
+          // For slow queries, extend the cache TTL to reduce frequency of expensive operations
+          const slowQueryMultiplier = Math.min(3, 1 + queryTime / 1000);
+          adjustedTtl = Math.floor(ttl * slowQueryMultiplier);
+          if (!isProduction) {
+            console.log(
+              `Slow query (${queryTime}ms) for ${key}, extending TTL by ${slowQueryMultiplier}x`,
+            );
+          }
+        }
+
         this.cache.set(key, {
           data,
           timestamp: now,
-          expiresAt: now + ttl,
+          expiresAt: now + adjustedTtl,
         });
 
         if (!isProduction) {
-          console.log(`Successfully prefetched ${key}`);
+          console.log(`Successfully prefetched ${key} in ${queryTime}ms`);
         }
       } catch (error) {
         console.error(`Error prefetching ${key}:`, error);
···
     if (!isProduction) {
       console.log("Invalidating entire cache");
     }
-    this.cache.clear();
+
+    // Preserve data for priority keys by keeping their entries
+    if (this.priorityKeys.size > 0) {
+      const priorityEntries: [string, CacheItem<unknown>][] = [];
+
+      // First collect all priority entries
+      for (const [key, value] of this.cache.entries()) {
+        if (this.priorityKeys.has(key)) {
+          priorityEntries.push([key, value]);
+        }
+      }
+
+      // Clear everything
+      this.cache.clear();
+
+      // Restore priority entries
+      for (const [key, value] of priorityEntries) {
+        this.cache.set(key, value);
+      }
+
+      if (!isProduction) {
+        console.log(
+          `Preserved ${priorityEntries.length} priority cache entries during invalidation`,
+        );
+      }
+    } else {
+      this.cache.clear();
+    }
   }
 
-  // Prune cache when it exceeds max size using LRU policy
+  // Prune cache when it exceeds max size using smart eviction policy
   private pruneCache(): void {
     if (this.cache.size <= this.maxItems) return;
 
     // Get entries as array for sorting
     const entries = Array.from(this.cache.entries());
+    const now = Math.floor(Date.now() / 1000);
+
+    // First, check for any expired entries we can remove
+    const expiredEntries = entries.filter(
+      ([key, item]) => item.expiresAt <= now && !this.priorityKeys.has(key),
+    );
+
+    // If we have expired entries, remove those first
+    if (expiredEntries.length > 0) {
+      for (const entry of expiredEntries) {
+        this.cache.delete(entry[0]);
+      }
+
+      if (!isProduction) {
+        console.log(`Pruned ${expiredEntries.length} expired items from cache`);
+      }
+
+      // If removing expired entries was enough, we're done
+      if (this.cache.size <= this.maxItems * 0.9) {
+        return;
+      }
+    }
+
+    // If we still need to remove more, use a smarter eviction policy
+    // Filter out priority keys that should never be evicted
+    const evictableEntries = entries.filter(
+      ([key]) => !this.priorityKeys.has(key),
+    );
+
+    if (evictableEntries.length === 0) {
+      console.warn(
+        "Cache full but all items are priority - consider increasing cache size",
+      );
+      return;
+    }
 
     // Sort by timestamp (oldest first)
-    entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+    evictableEntries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+
+    // Calculate how many to remove - more aggressive cleanup (down to 70%)
+    const removeCount = Math.ceil(this.cache.size - this.maxItems * 0.7);
+    // Remove oldest non-priority entries
+    const entriesToRemove = evictableEntries.slice(0, removeCount);
+    for (const [key] of entriesToRemove) {
+      this.cache.delete(key);
+    }
+
+    if (!isProduction) {
+      console.log(`Pruned ${removeCount} oldest non-priority items from cache`);
+    }
+  }
 
-    // Calculate how many to remove
-    const removeCount = Math.ceil(this.cache.size - this.maxItems * 0.8);
+  /**
+   * Runs a full garbage collection cycle to clean expired entries
+   * and optimize memory usage
+   */
+  private runGarbageCollection(): void {
+    const now = Math.floor(Date.now() / 1000);
+    let expiredCount = 0;
 
-    // Remove oldest entries
-    for (let i = 0; i < removeCount && i < entries.length; i++) {
-      const entry = entries[i];
-      if (entry?.[0]) {
-        this.cache.delete(entry[0]);
+    // Clean expired entries
+    for (const [key, item] of this.cache.entries()) {
+      if (item.expiresAt <= now && !this.priorityKeys.has(key)) {
+        this.cache.delete(key);
+        expiredCount++;
       }
     }
 
-    if (!isProduction) {
-      console.log(`Pruned ${removeCount} oldest items from cache`);
+    if (!isProduction && expiredCount > 0) {
+      console.log(`GC: Removed ${expiredCount} expired entries`);
     }
+
+    this.lastGC = Date.now();
   }
 
   // Get cache stats for monitoring
···
   code: "INTERNAL_SERVER_ERROR",
 });
 
-// Create a global cache instance
-export const queryCache = new QueryCache();
+// Create a global cache instance with optimized settings
+export const queryCache = new QueryCache(
+  // Default TTL of 10 minutes in production, 5 minutes in dev
+  isProduction ? 600 : 300,
+  // Larger cache size to reduce evictions
+  isProduction ? 1500 : 800,
+);
 
 /**
  * Factory function for creating consistent API endpoint handlers
  * @param cacheKey Key for caching the response
  * @param queryFn Function that performs the actual database query
  * @param ttl Cache TTL in seconds
+ * @param isPriority Whether this endpoint should have priority in cache
  */
 export function createCachedEndpoint<T>(
   cacheKey: string,
   queryFn: () => Promise<T>,
   ttl = 300,
+  isPriority = false,
 ) {
-  // Register the query function for cache warming
-  queryCache.register(cacheKey, queryFn, ttl);
+  // Register the query function for cache warming with priority flag
+  // Set frequently accessed endpoints as priority by default
+  const defaultToPriority = cacheKey === "leaderboard_stories" || isPriority;
+  queryCache.register(cacheKey, queryFn, ttl, defaultToPriority);
 
   // Pre-create cache headers to avoid recreating them on each request
   const cacheHeaders = createCacheHeaders(cacheKey, ttl);
···
   const errorHeaders = {
     "Content-Type": "application/json",
     "Cache-Control": "no-cache, no-store",
+    "X-Error": "true",
   };
 
   // Pre-build common responses for reuse
···
   });
 
   return async (request: Request) => {
+    // Start request timing for potential performance monitoring
+    const requestStart = isProduction ? 0 : performance.now();
+
     try {
       // Get data from cache or execute query
       const data = await queryCache.get(cacheKey, queryFn, ttl);
 
-      // Create response with proper caching headers
-      const response = new Response(JSON.stringify(data), {
-        headers: cacheHeaders,
-      });
+      // Create response with proper caching headers and timing info
+      const headers = { ...cacheHeaders };
+
+      // Add server timing header in development
+      if (!isProduction && requestStart > 0) {
+        const requestTime = Math.round(performance.now() - requestStart);
+        headers["Server-Timing"] = `cache;dur=${requestTime}`;
+      }
+
+      const response = new Response(JSON.stringify(data), { headers });
 
       // Apply compression and return
       return compressResponse(request, response);

src/libs/cacheWarming.ts

···
  * Call this after cron jobs update the database or at server startup
  */
 export async function preloadCaches(): Promise<void> {
+  const startTime = performance.now();
   if (!isProduction) {
     console.log("Preloading all caches for optimal performance...");
   }
···
       console.log(`Found ${registeredKeys.length} registered cache keys to warm`);
     }
     
-    // Prioritize the most critical endpoints first
-    const priorityKeys = [
-      "leaderboard_stories",
+    // Define critical, high and regular priority endpoints
+    const criticalKeys = [
+      "leaderboard_stories" // Most important endpoint - load first
+    ];
+    
+    const highPriorityKeys = [
       "total_stories_count",
       "verified_users_stats"
     ];
     
-    // Sort keys by priority (known critical keys first, then others)
-    const sortedKeys = [
-      ...priorityKeys.filter(key => registeredKeys.includes(key)),
-      ...registeredKeys.filter(key => !priorityKeys.includes(key))
-    ];
+    // Sort keys into priority tiers
+    const sortedCriticalKeys = criticalKeys.filter(key => registeredKeys.includes(key));
+    const sortedHighPriorityKeys = highPriorityKeys.filter(key => registeredKeys.includes(key));
+    const regularPriorityKeys = registeredKeys.filter(key => 
+      !criticalKeys.includes(key) && !highPriorityKeys.includes(key)
+    );
+    
+    // Step 1: Load critical endpoints sequentially for most predictable performance
+    for (const key of sortedCriticalKeys) {
+      if (!isProduction) {
+        console.log(`Warming CRITICAL cache for ${key}...`);
+      }
+      await queryCache.warmCache(key);
+      
+      // Register as priority in cache system to prevent eviction
+      const registration = queryCache.getQueryRegistration(key);
+      if (registration) {
+        queryCache.register(key, registration.fn, registration.ttl, true);
+      }
+    }
     
-    // Prepare warming promises to run in parallel for better performance
-    const warmingPromises = sortedKeys.map(async (key) => {
+    // Step 2: Load high priority keys in parallel
+    await Promise.all(sortedHighPriorityKeys.map(async (key) => {
       if (!isProduction) {
-        console.log(`Warming cache for ${key}...`);
+        console.log(`Warming HIGH PRIORITY cache for ${key}...`);
+      }
+      await queryCache.warmCache(key);
+      
+      // Register these as priority too
+      const registration = queryCache.getQueryRegistration(key);
+      if (registration) {
+        queryCache.register(key, registration.fn, registration.ttl, true);
       }
-      return queryCache.warmCache(key);
-    });
+    }));
     
-    // Run warming of standard endpoints in parallel
-    await Promise.all(warmingPromises);
+    // Step 3: For regular priority, use staggered loading with limited concurrency
+    const concurrencyLimit = isProduction ? 3 : 5;
+    const chunkSize = Math.min(concurrencyLimit, regularPriorityKeys.length);
+    
+    // Process in smaller chunks to prevent overwhelming the database
+    for (let i = 0; i < regularPriorityKeys.length; i += chunkSize) {
+      const chunk = regularPriorityKeys.slice(i, i + chunkSize);
+      const chunkPromises = chunk.map(async (key) => {
+        if (!isProduction) {
+          console.log(`Warming regular cache for ${key}...`);
+        }
+        return queryCache.warmCache(key);
+      });
+      
+      await Promise.all(chunkPromises);
+      
+      // Small breather between chunks to avoid CPU spikes
+      if (i + chunkSize < regularPriorityKeys.length) {
+        await new Promise(resolve => setTimeout(resolve, isProduction ? 50 : 20));
+      }
+    }
     
     // Preload snapshots for top stories - this requires custom handling
     // since these use dynamic keys (story_snapshots_{id})
     if (!isProduction) {
-      console.log("Preloading top story snapshots (limited to 3)...");
+      console.log("Preloading top story snapshots...");
     }
     
-    // Get IDs of top 3 stories to warm their snapshots
+    // Get IDs of top 5 stories in production (more likely to be viewed), or top 3 in dev
+    const topStoriesLimit = isProduction ? 5 : 3;
+    
+    // Use optimized query with only necessary columns
     const topStories = await db.query.stories.findMany({
       columns: { id: true }, // Only retrieve the ID field to minimize memory use
       where: (stories, { eq }) => eq(stories.isOnLeaderboard, true),
       orderBy: (stories, { asc }) => [asc(stories.position)],
-      limit: 3,
+      limit: topStoriesLimit,
     });
     
-    // Warm story snapshots in parallel
-    const snapshotPromises = topStories.map(story => {
+    // Warm story snapshots with limited concurrency to prevent DB overload
+    for (const story of topStories) {
       const snapshotKey = `story_snapshots_${story.id}`;
-      return queryCache.warmCache(snapshotKey);
-    });
-    
-    await Promise.all(snapshotPromises);
+      await queryCache.warmCache(snapshotKey);
+      
+      // Short delay between each story to minimize server load spikes
+      if (story !== topStories[topStories.length - 1]) {
+        await new Promise(resolve => setTimeout(resolve, isProduction ? 100 : 50));
+      }
+    }
 
+    const totalTime = Math.round(performance.now() - startTime);
     if (!isProduction) {
-      console.log("Cache preloading completed successfully");
+      console.log(`Cache preloading completed successfully in ${totalTime}ms`);
     }
   } catch (error) {
     console.error("Error during cache preloading:", error);
···
   if (!isProduction) {
     console.log("Invalidating all query caches and refreshing data");
   }
-  queryCache.invalidateAll();
-
-  // Immediately refill the cache using registered query functions
+  
+  // Don't invalidate everything - be selective to maintain performance
+  // First get a list of keys to invalidate (non-priority ones)
+  const allKeys = queryCache.getRegisteredKeys();
+  const nonPriorityKeys = queryCache.getNonPriorityKeys();
+  
+  // Only invalidate non-priority keys first
+  for (const key of nonPriorityKeys) {
+    queryCache.invalidate(key);
+  }
+  
+  // Gradually refresh caches with staggered starts
   setTimeout(() => {
     preloadCaches().catch((err) => {
       console.error("Error during cache preloading after invalidation:", err);
       Sentry.captureException(err);
     });
-  }, isProduction ? 50 : 100); // Smaller delay in production for faster refresh
+  }, isProduction ? 100 : 200); // Slightly longer delay to ensure system stability
 }

src/libs/db.ts

···
 });
 
 // Set a longer busy timeout to reduce "database is locked" errors
-sqlite.exec("PRAGMA busy_timeout = 5000;");
+sqlite.exec("PRAGMA busy_timeout = 10000;");
 
 // Enable Write-Ahead Logging mode for better concurrent performance
 sqlite.exec("PRAGMA journal_mode = WAL;");
 // Set synchronous mode for better performance (still safe in WAL mode)
 sqlite.exec("PRAGMA synchronous = NORMAL;");
-// Increase cache size for better performance
-sqlite.exec("PRAGMA cache_size = -16000;"); // Use ~16MB of memory for cache
+// Increase cache size for better performance (32MB instead of 16MB)
+sqlite.exec("PRAGMA cache_size = -32000;");
+// Enable memory-mapped I/O for better read performance
+sqlite.exec("PRAGMA mmap_size = 268435456;"); // 256MB
+// Optimize query planner
+sqlite.exec("PRAGMA optimize;");
+// Increase page size for better I/O efficiency
+sqlite.exec("PRAGMA page_size = 8192;");
 
 // Create a Drizzle instance with the database and schema
 export const db = drizzle(sqlite, { schema });