repo sync

Author: Octomerger

lib/redis-accessor.js

@@ -0,0 +1,123 @@
+const Redis = require('ioredis')
+const InMemoryRedis = require('ioredis-mock')
+
+const { CI, NODE_ENV, REDIS_URL, REDIS_MAX_DB } = process.env
+
+// Do not use real a Redis client for CI, tests, or if the REDIS_URL is not provided
+const useRealRedis = !CI && NODE_ENV !== 'test' && !!REDIS_URL
+
+// By default, every Redis instance supports database numbers 0 - 15
+const redisMaxDb = REDIS_MAX_DB || 15
+
+// Enable better stack traces in non-production environments
+const redisOptions = {
+  showFriendlyErrorStack: NODE_ENV !== 'production'
+}
+
+class RedisAccessor {
+  constructor ({ databaseNumber = 0, prefix = null, allowSetFailures = false } = {}) {
+    if (!Number.isInteger(databaseNumber) || databaseNumber < 0 || databaseNumber > redisMaxDb) {
+      throw new TypeError(
+        `Redis database number must be an integer between 0 and ${redisMaxDb} but was: ${JSON.stringify(databaseNumber)}`
+      )
+    }
+
+    const redisUrl = `${REDIS_URL}/${databaseNumber}`
+    const redisClient = useRealRedis ? new Redis(redisUrl, redisOptions) : new InMemoryRedis()
+    this._client = redisClient
+
+    this._prefix = prefix ? prefix.replace(/:+$/, '') + ':' : ''
+
+    // Allow for graceful failures if a Redis SET operation fails?
+    this._allowSetFailures = allowSetFailures === true
+  }
+
+  /** @private */
+  prefix (key) {
+    if (typeof key !== 'string' || !key) {
+      throw new TypeError(`Key must be a non-empty string but was: ${JSON.stringify(key)}`)
+    }
+
+    return this._prefix + key
+  }
+
+  static translateSetArguments (options = {}) {
+    const setArgs = []
+
+    const defaults = {
+      newOnly: false,
+      existingOnly: false,
+      expireIn: null, // No expiration
+      rollingExpiration: true
+    }
+    const opts = { ...defaults, ...options }
+
+    if (opts.newOnly === true) {
+      if (opts.existingOnly === true) {
+        throw new TypeError('Misconfiguration: entry cannot be both new and existing')
+      }
+      setArgs.push('NX')
+    } else if (opts.existingOnly === true) {
+      setArgs.push('XX')
+    }
+
+    if (Number.isFinite(opts.expireIn)) {
+      const ttl = Math.round(opts.expireIn)
+      if (ttl < 1) {
+        throw new TypeError('Misconfiguration: cannot set a TTL of less than 1 millisecond')
+      }
+      setArgs.push('PX')
+      setArgs.push(ttl)
+    }
+    // otherwise there is no expiration
+
+    if (opts.rollingExpiration === false) {
+      if (opts.newOnly === true) {
+        throw new TypeError('Misconfiguration: cannot keep an existing TTL on a new entry')
+      }
+      setArgs.push('KEEPTTL')
+    }
+
+    return setArgs
+  }
+
+  async set (key, value, options = {}) {
+    const fullKey = this.prefix(key)
+
+    if (typeof value !== 'string' || !value) {
+      throw new TypeError(`Value must be a non-empty string but was: ${JSON.stringify(value)}`)
+    }
+
+    // Handle optional arguments
+    const setArgs = this.constructor.translateSetArguments(options)
+
+    try {
+      const result = await this._client.set(fullKey, value, ...setArgs)
+      return result === 'OK'
+    } catch (err) {
+      const errorText = `Failed to set value in Redis.
+Key: ${fullKey}
+Error: ${err.message}`
+
+      if (this._allowSetFailures === true) {
+        // Allow for graceful failure
+        console.error(errorText)
+        return false
+      }
+
+      throw new Error(errorText)
+    }
+  }
+
+  async get (key) {
+    const value = await this._client.get(this.prefix(key))
+    return value
+  }
+
+  async exists (key) {
+    const result = await this._client.exists(this.prefix(key))
+    return result === 1
+  }
+}
+
+module.exports = RedisAccessor

middleware/rate-limit.js

@@ -1,8 +1,11 @@
 const rateLimit = require('express-rate-limit')
 const RedisStore = require('rate-limit-redis')
+const Redis = require('ioredis')
 
 const isProduction = process.env.NODE_ENV === 'production'
-const REDIS_URL = process.env.REDIS_URL
+const { REDIS_URL } = process.env
+const rateLimitDatabaseNumber = 0
+const redisUrl = `${REDIS_URL}/${rateLimitDatabaseNumber}`
 
 module.exports = rateLimit({
   // 1 minute (or practically unlimited outside of production)
@@ -13,5 +16,5 @@ module.exports = rateLimit({
   // Or anything with a status code less than 400
   skipSuccessfulRequests: true,
   // When available, use Redis
-  store: REDIS_URL && new RedisStore({ redisURL: REDIS_URL })
+  store: REDIS_URL && new RedisStore({ client: new Redis(redisUrl) })
 })

middleware/render-page.js

@@ -5,21 +5,32 @@ const layouts = require('../lib/layouts')
 const getMiniTocItems = require('../lib/get-mini-toc-items')
 const Page = require('../lib/page')
 const statsd = require('../lib/statsd')
+const RedisAccessor = require('../lib/redis-accessor')
 
-// We've got lots of memory, let's use it
-// We can eventually throw this into redis
-const pageCache = {}
+const { HEROKU_RELEASE_VERSION } = process.env
+const pageCacheDatabaseNumber = 1
+const pageCacheExpiration = 24 * 60 * 60 * 1000 // 24 hours
+
+const pageCache = new RedisAccessor({
+  databaseNumber: pageCacheDatabaseNumber,
+  prefix: (HEROKU_RELEASE_VERSION ? HEROKU_RELEASE_VERSION + ':' : '') + 'rp',
+  // Allow for graceful failures if a Redis SET operation fails
+  allowSetFailures: true
+})
 
 module.exports = async function renderPage (req, res, next) {
   const page = req.context.page
   const originalUrl = req.originalUrl
 
   // Serve from the cache if possible (skip during tests)
-  if (!process.env.CI && process.env.NODE_ENV !== 'test') {
-    if (req.method === 'GET' && pageCache[originalUrl]) {
+  const isCacheable = !process.env.CI && process.env.NODE_ENV !== 'test' && req.method === 'GET'
+
+  if (isCacheable) {
+    const cachedHtml = await pageCache.get(originalUrl)
+    if (cachedHtml) {
       console.log(`Serving from cached version of ${originalUrl}`)
       statsd.increment('page.sent_from_cache')
-      return res.send(pageCache[originalUrl])
+      return res.send(cachedHtml)
     }
   }
 
@@ -88,13 +99,11 @@ module.exports = async function renderPage (req, res, next) {
 
   const output = await liquid.parseAndRender(layout, context)
 
-  // Save output to cache for the next time around
-  if (!process.env.CI) {
-    if (req.method === 'GET') {
-      pageCache[originalUrl] = output
-    }
-  }
+  // First, send the response so the user isn't waiting
+  res.send(output)
 
-  // send response
-  return res.send(output)
+  // Finally, save output to cache for the next time around
+  if (isCacheable) {
+    await pageCache.set(originalUrl, output, { expireIn: pageCacheExpiration })
+  }
 }