Performance delivery improvements

Author: cwbeck

edge/src/main/java/com/scale8/AppEntity.java

@@ -1,5 +1,7 @@
 package com.scale8;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
@@ -14,8 +16,6 @@
 import com.scale8.extended.types.Tuple;
 import com.scale8.ingest.Ingestor;
 import com.scale8.util.HashUtil;
-import io.micronaut.cache.annotation.CacheConfig;
-import io.micronaut.cache.annotation.Cacheable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import javax.inject.Inject;
@@ -29,14 +29,20 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import static io.micronaut.http.HttpHeaders.ACCEPT;
 import static io.micronaut.http.MediaType.APPLICATION_JSON;
 
 @Singleton
-@CacheConfig("app")
 public class AppEntity {
 
+  private final Cache<String, String> configCache =
+      Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).maximumSize(100).build();
+
+  private final Cache<String, String> assetCache =
+          Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).maximumSize(100).build();
+
   private final String PUBLIC_PATH = "http://127.0.0.1:3123";
 
   private static final Logger LOG = LoggerFactory.getLogger(AppEntity.class);
@@ -55,12 +61,19 @@ public AppSettings getConfig(ExtendedRequest request) throws Exception {
     return new Gson().fromJson(getRawConfig(request), AppSettings.class);
   }
 
-  @Cacheable()
   protected String getRawConfig(ExtendedRequest request) throws IOException, InterruptedException {
     String previewId = request.getRevisionPreviewId();
     if (previewId == null) {
-      // fetch the config from GCS against the incoming host...
-      return storage.get(env.CONFIG_BUCKET, "tag-domain/" + request.getHost() + ".json");
+      String uri = "tag-domain/" + request.getHost() + ".json";
+      String config = configCache.getIfPresent(uri);
+      if(config == null){
+        LOG.info("Going back to " + env.CONFIG_BUCKET + " to fetch " + uri + ", not present in cache");
+        String fetchedConfig = storage.get(env.CONFIG_BUCKET, uri);
+        configCache.put(uri, fetchedConfig);
+        return fetchedConfig;
+      } else {
+        return config;
+      }
     } else {
       return HttpClient.newHttpClient()
           .send(
@@ -111,15 +124,26 @@ private String publicPath(ExtendedRequest extendedRequest, String platformId, St
     }
   }
 
+  private String getJsAsset(String uri) throws IOException {
+    String jsAsset = assetCache.getIfPresent(uri);
+    if(jsAsset == null){
+      LOG.info("Going back to " + env.ASSETS_BUCKET + " to fetch " + uri + ", not present in cache");
+      String freshJsAsset = storage.get(env.ASSETS_BUCKET, uri);
+      assetCache.put(uri, freshJsAsset);
+      return freshJsAsset;
+    } else {
+      return jsAsset;
+    }
+  }
+
   public String fetchJSAsset(ExtendedRequest request, String platformId, String asset)
       throws Exception {
     AppSettings appSettings = getConfig(request);
     String ngp = request.getRequest().getParameters().get("ngp");
     if (appSettings.getCorePlatformId().equals(platformId) && ngp != null) {
       return doJsProxyRequest("http://" + ngp + ".ngrok.io/" + asset);
     } else {
-      return storage.get(
-          env.ASSETS_BUCKET, appSettings.getAllAssetsMap().get(platformId + "-" + asset));
+      return getJsAsset(appSettings.getAllAssetsMap().get(platformId + "-" + asset));
     }
   }
 
@@ -133,7 +157,7 @@ public String getPrimaryJsAsset(ExtendedRequest request, String platformId) thro
       String js =
           env.PROXY_FOR.equals(platformId)
               ? doJsProxyRequest(env.PROXY_LOCATION)
-              : storage.get(env.ASSETS_BUCKET, primaryAssetUri);
+              : getJsAsset(primaryAssetUri);
 
       return js.replace(
               PUBLIC_PATH, publicPath(request, platformId, request.getRevisionPreviewId()))

edge/src/main/java/com/scale8/IngestEntity.java

@@ -1,5 +1,7 @@
 package com.scale8;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonPrimitive;
@@ -9,20 +11,21 @@
 import com.scale8.config.structures.IngestSettings;
 import com.scale8.extended.ExtendedRequest;
 import com.scale8.ingest.Ingestor;
-import io.micronaut.cache.annotation.CacheConfig;
-import io.micronaut.cache.annotation.Cacheable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 @Singleton
-@CacheConfig("ingest")
 public class IngestEntity {
 
+  private final Cache<String, IngestSettings> cache =
+      Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES).maximumSize(100).build();
+
   private static final Logger LOG = LoggerFactory.getLogger(IngestEntity.class);
 
   @Inject Env env;
@@ -33,10 +36,17 @@ public class IngestEntity {
 
   @Inject Payload payload;
 
-  @Cacheable()
   protected IngestSettings getConfig(String uri) throws IOException {
-    String data = storage.get(env.CONFIG_BUCKET, uri);
-    return new Gson().fromJson(data, IngestSettings.class);
+    IngestSettings ingestSettings = cache.getIfPresent(uri);
+    if (ingestSettings == null) {
+      LOG.info("Going back to " + env.CONFIG_BUCKET + " to fetch " + uri + ", not present in cache");
+      IngestSettings freshIngestSettings =
+          new Gson().fromJson(storage.get(env.CONFIG_BUCKET, uri), IngestSettings.class);
+      cache.put(uri, freshIngestSettings);
+      return freshIngestSettings;
+    } else {
+      return ingestSettings;
+    }
   }
 
   public IngestSettings getConfigByHost(String host) throws IOException {
@@ -86,7 +96,8 @@ protected void trackUsage(
   }
 
   protected List<String> offerToIngestor(
-      ExtendedRequest extendedRequest, JsonObject jsonObject, IngestSettings ingestSettings) throws IOException {
+      ExtendedRequest extendedRequest, JsonObject jsonObject, IngestSettings ingestSettings)
+      throws IOException {
     JsonObject data =
         payload.applyDefaultValues(
             jsonObject,
@@ -97,8 +108,9 @@ protected List<String> offerToIngestor(
         payload.validateSchemaAgainstPayload(data, ingestSettings.getSchemaAsMap());
 
     if (issues.isEmpty()) {
-      if(!ingestSettings.getUsageIngestEnvId().isEmpty() && ingestSettings.getIsAnalyticsEnabled()){
-        //we need to track usage...
+      if (!ingestSettings.getUsageIngestEnvId().isEmpty()
+          && ingestSettings.getIsAnalyticsEnabled()) {
+        // we need to track usage...
         ingestor.add(data, ingestSettings, getConfigById(ingestSettings.getUsageIngestEnvId()));
       } else {
         ingestor.add(data, ingestSettings);
@@ -109,7 +121,8 @@ protected List<String> offerToIngestor(
   }
 
   public List<String> add(
-      ExtendedRequest extendedRequest, IngestSettings ingestSettings, JsonObject jsonObject) throws IOException {
+      ExtendedRequest extendedRequest, IngestSettings ingestSettings, JsonObject jsonObject)
+      throws IOException {
     return offerToIngestor(extendedRequest, jsonObject, ingestSettings);
   }
 

edge/src/main/java/com/scale8/extended/ExtendedRequest.java

@@ -1,5 +1,7 @@
 package com.scale8.extended;
 
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import com.google.gson.Gson;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
@@ -10,14 +12,14 @@
 import com.scale8.util.HashUtil;
 import io.micronaut.http.HttpHeaders;
 import io.micronaut.http.HttpRequest;
-import ua_parser.Client;
 import ua_parser.Parser;
 import java.security.NoSuchAlgorithmException;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.Map;
 import java.util.Optional;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
 import static java.lang.Math.abs;
@@ -31,6 +33,9 @@ public class ExtendedRequest {
   final Map<String, String> allParameters;
   final String id;
 
+  private final Cache<String, ua_parser.Client> uaCache =
+          Caffeine.newBuilder().expireAfterAccess(10, TimeUnit.MINUTES).maximumSize(1000).build();
+
   public ExtendedRequest(HttpRequest<String> request, Env env, Geo geo, String id) {
     this.env = env;
     this.geo = geo;
@@ -167,8 +172,23 @@ public String getRevisionPreviewId() {
     return getAllParameters().get("preview");
   }
 
-  public Client getUserAgent() {
-    return new Parser().parse(request.getHeaders().get(HttpHeaders.USER_AGENT));
+  public ua_parser.Client getUserAgent() {
+    String uaHeader = request.getHeaders().get(HttpHeaders.USER_AGENT);
+    String ua = uaHeader == null? "" : uaHeader;
+    String uaHash;
+    try {
+      uaHash = HashUtil.createHash(ua);
+    } catch (NoSuchAlgorithmException noSuchAlgorithmException) {
+      uaHash = "--";
+    }
+    ua_parser.Client client = uaCache.getIfPresent(uaHash);
+    if(client == null){
+      ua_parser.Client freshClient = new Parser().parse(ua);
+      uaCache.put(uaHash, freshClient);
+      return freshClient;
+    } else {
+      return client;
+    }
   }
 
   public String getUserAgentAsString() {

edge/src/main/java/com/scale8/mmdb/Geo.java

@@ -1,22 +1,25 @@
 package com.scale8.mmdb;
 
 import com.fasterxml.jackson.databind.JsonNode;
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 import com.maxmind.db.Reader;
 import com.scale8.Env;
-import io.micronaut.cache.annotation.CacheConfig;
-import io.micronaut.cache.annotation.Cacheable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import javax.inject.Singleton;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.URL;
+import java.util.concurrent.TimeUnit;
 
 @Singleton
-@CacheConfig("geo")
 public class Geo {
 
+  private final Cache<String, GeoData> cache =
+      Caffeine.newBuilder().expireAfterAccess(10, TimeUnit.MINUTES).maximumSize(1000).build();
+
   private static final Logger LOG = LoggerFactory.getLogger(Geo.class);
 
   Reader GEO_DB;
@@ -45,33 +48,40 @@ private JsonNode getLookUp(String host) {
     }
   }
 
-  @Cacheable()
   public GeoData getGeoData(String host) {
-    String countryCode = null;
-    String region = null;
-    String city = null;
-    JsonNode lookup = getLookUp(host);
-    if (lookup != null) {
-      JsonNode countryNode = lookup.findValue("country");
-      if (countryNode != null) {
-        countryCode = countryNode.findValue("iso_code").asText();
-      }
-      JsonNode subdivisionsNode = lookup.findValue("subdivisions");
-      if(subdivisionsNode != null && subdivisionsNode.isArray() && subdivisionsNode.has(0)){
-        JsonNode first = subdivisionsNode.get(0);
-        JsonNode name = first.findValue("names");
-        if(name != null){
-          region = name.findValue("en").asText();
+    GeoData geoData = cache.getIfPresent(host);
+    if (geoData == null) {
+      LOG.info("Going back to " + GEO_DB + " to fetch " + host + ", not present in cache");
+      String countryCode = null;
+      String region = null;
+      String city = null;
+      JsonNode lookup = getLookUp(host);
+      if (lookup != null) {
+        JsonNode countryNode = lookup.findValue("country");
+        if (countryNode != null) {
+          countryCode = countryNode.findValue("iso_code").asText();
         }
-      }
-      JsonNode cityNode = lookup.findValue("city");
-      if(cityNode != null){
-        JsonNode name = cityNode.findValue("names");
-        if(name != null){
-          city = name.findValue("en").asText();
+        JsonNode subdivisionsNode = lookup.findValue("subdivisions");
+        if (subdivisionsNode != null && subdivisionsNode.isArray() && subdivisionsNode.has(0)) {
+          JsonNode first = subdivisionsNode.get(0);
+          JsonNode name = first.findValue("names");
+          if (name != null) {
+            region = name.findValue("en").asText();
+          }
+        }
+        JsonNode cityNode = lookup.findValue("city");
+        if (cityNode != null) {
+          JsonNode name = cityNode.findValue("names");
+          if (name != null) {
+            city = name.findValue("en").asText();
+          }
         }
       }
+      GeoData freshGeoData = new GeoData(countryCode, region, city);
+      cache.put(host, freshGeoData);
+      return freshGeoData;
+    } else {
+      return geoData;
     }
-    return new GeoData(countryCode, region, city);
   }
 }