Add an application cache for REST API

hedera-mirror-rest/cache.js

@@ -73,6 +73,23 @@
     return this.redis.flushall();
   }
 
+  async getSingle(key) {
+    if (key === undefined || !this.ready) {
+      return undefined;
+    }
+
+    const value = this.redis.get(key);
+    return value === undefined ? value : JSONParse(value);
+  }
+
+  async setSingle(key, value, expiry) {
+    if (key === undefined || !this.ready) {
+      return undefined;
+    }
+
+    return this.redis.setex(key, expiry, JSONStringify(value));
+  }
+
   async get(keys, loader, keyMapper = (k) => (k ? k.toString() : k)) {
     if (_.isEmpty(keys)) {
       return [];

hedera-mirror-rest/constants.js

@@ -103,6 +103,8 @@ const requestIdLabel = 'requestId';
 const requestPathLabel = 'requestPath';
 const requestStartTime = 'requestStartTime';
 const responseContentType = 'responseContentType';
+const responseBodyLabel = 'responseBody';
+const responseCacheKeyLabel = 'responseCacheKey';
 const responseDataLabel = 'responseData';
 
 const orderFilterValues = {
@@ -250,6 +252,8 @@ export {
   requestIdLabel,
   requestPathLabel,
   requestStartTime,
+  responseBodyLabel,
+  responseCacheKeyLabel,
   responseContentType,
   responseDataLabel,
   tokenTypeFilter,

hedera-mirror-rest/middleware/index.js

@@ -18,4 +18,5 @@ export {handleError} from './httpErrorHandler';
 export * from './metricsHandler';
 export {openApiValidator, serveSwaggerDocs} from './openapiHandler';
 export * from './requestHandler';
+export {responseCacheCheckHandler, responseCacheUpdateHandler} from './responseCacheHandler.js';
 export {default as responseHandler} from './responseHandler';

hedera-mirror-rest/middleware/responseCacheHandler.js

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Cache} from '../cache';
+import CachedApiResponse from '../model/cachedApiResponse.js';
+import {requestStartTime, responseCacheKeyLabel} from '../constants.js';
+
+const cache = new Cache();
+
+const responseCacheCheckHandler = async (req, res, next) => {
+  const responseCacheKey = req.path; // Call Edwin's function here
+  const cachedResponse = await cache.getSingle(responseCacheKey);
+
+  if (cachedResponse === undefined) {
+    logger.debug(`Cache miss: ${responseCacheKey}`);
+    res.locals[responseCacheKeyLabel] = responseCacheKey;
+    next();
+  } else {
+    logger.debug(`Cache hit: ${responseCacheKey}`);
+    // TODO adjust cache-control header and decrement time it's been locally cached.
+    res.set(cachedResponse.headers);
+    res.status(cachedResponse.status);
+    res.send(cachedResponse.body);
+
+    const startTime = res.locals[requestStartTime];
+    const elapsed = startTime ? Date.now() - startTime : 0;
+    logger.info(`Cached - ${req.ip} ${req.method} ${req.originalUrl} in ${elapsed} ms: ${code}`);
+  }
+};
+
+// Response middleware that caches the completed response.
+// Next param is required to ensure express maps to this middleware and can also be used to pass onto future middleware
+const responseCacheUpdateHandler = async (req, res, next) => {
+  const responseCacheKey = res.locals[responseCacheKeyLabel];
+  if (responseCacheKey === undefined) {
+    return; // Response is not to be cached
+  }
+
+  const cachedResponse = new CachedApiResponse(res);
+  const headers = res.getHeaders();
+  const cacheControlHeader = headers['cache-control'];
+  // Grok header value to set expiry below.
+
+  cache.setSingle(responseCacheKey, cachedResponse, 300);
+};
+
+export {responseCacheCheckHandler, responseCacheUpdateHandler};

hedera-mirror-rest/middleware/responseHandler.js

@@ -15,7 +15,13 @@
  */
 
 import config from '../config';
-import {requestPathLabel, requestStartTime, responseContentType, responseDataLabel} from '../constants';
+import {
+  requestPathLabel,
+  requestStartTime,
+  responseBodyLabel,
+  responseContentType,
+  responseDataLabel,
+} from '../constants';
 import {NotFoundError} from '../errors';
 import {JSONStringify} from '../utils';
 
@@ -50,16 +56,15 @@
       res.set(LINK_NEXT_HEADER, linkNextHeaderValue(linksNext));
     }
 
-    if (contentType === APPLICATION_JSON) {
-      res.send(JSONStringify(responseData));
-    } else {
-      res.send(responseData);
-    }
+    res.locals[responseBodyLabel] = contentType === APPLICATION_JSON ? JSONStringify(responseData) : responseData;
+    res.send(res.locals[responseBodyLabel]);
 
     const startTime = res.locals[requestStartTime];
     const elapsed = startTime ? Date.now() - startTime : 0;
     logger.info(`${req.ip} ${req.method} ${req.originalUrl} in ${elapsed} ms: ${code}`);
   }
+
+  next();
 };
 
 export default responseHandler;

hedera-mirror-rest/model/cachedApiResponse.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {responseBodyLabel} from '../constants.js';
+
+/**
+ * API response cached in Redis.
+ */
+class CachedApiResponse {
+  constructor(res) {
+    this.body = res.locals[responseBodyLabel];
+    this.cacheTime = Date.now();
+    this.headers = res.getHeaders();
+    this.status = res.statusCode;
+  }
+}
+
+export default CachedApiResponse;

hedera-mirror-rest/model/index.js

@@ -19,6 +19,7 @@ import AddressBook from './addressBook';
 import AddressBookEntry from './addressBookEntry';
 import AddressBookServiceEndpoint from './addressBookServiceEndpoint';
 import AssessedCustomFee from './assessedCustomFee';
+import CachedApiResponse from './cachedApiResponse';
 import CachedToken from './cachedToken';
 import Contract from './contract';
 import CryptoAllowance from './cryptoAllowance';
@@ -66,6 +67,7 @@ export {
   AddressBookEntry,
   AddressBookServiceEndpoint,
   AssessedCustomFee,
+  CachedApiResponse,
   CachedToken,
   Contract,
   CryptoAllowance,

hedera-mirror-rest/server.js

@@ -45,6 +45,8 @@ import {
   recordIpAndEndpoint,
   requestLogger,
   requestQueryParser,
+  responseCacheCheckHandler,
+  responseCacheUpdateHandler,
   responseHandler,
   serveSwaggerDocs,
 } from './middleware';
@@ -125,6 +127,9 @@ if (config.metrics.enabled) {
   app.use(metricsHandler());
 }
 
+// Check for cached response
+app.use(responseCacheCheckHandler);
+
 // accounts routes
 app.getAsync(`${apiPrefix}/accounts`, accounts.getAccounts);
 app.getAsync(`${apiPrefix}/accounts/:${constants.filterKeys.ID_OR_ALIAS_OR_EVM_ADDRESS}`, accounts.getOneAccount);
@@ -178,6 +183,7 @@ if (config.metrics.ipMetrics) {
 
 // response data handling middleware
 app.useAsync(responseHandler);
+app.useAsync(responseCacheUpdateHandler);
 
 // response error handling middleware
 app.useAsync(handleError);