feat(): lru memoization for js worker

Author: e11sy

lib/memoize/index.ts

@@ -0,0 +1,84 @@
+import LRUCache from 'lru-cache';
+import Crypto from '../utils/crypto';
+
+/**
+ * Pick the strategy of cache key form
+ * It could be concatenated list of arguments like 'projectId:eventId'
+ * Or it could be hashed json object — blake2b512 algorithn
+ */
+export type MemoizeKeyStrategy = 'concat' | 'hash';
+
+/**
+ * Options of the memoize decorator
+ */
+export interface MemoizeOptions {
+  /**
+   * Max number of values stored in LRU cache at the same time
+   */
+  max?: number;
+
+  /**
+   * TTL in milliseconds
+   */
+  ttl?: number;
+
+  /**
+   * Strategy for key generation
+   */
+  strategy?: MemoizeKeyStrategy;
+}
+
+/**
+ * Async-only, per-method LRU-backed memoization decorator.
+ * Cache persists for the lifetime of the class instance (e.g. worker).
+ */
+export function Memoize(options: MemoizeOptions = {}): MethodDecorator {
+  const {
+    max = 50,
+    ttl = 1000 * 60 * 30,
+    strategy = 'concat',
+  } = options;
+
+  return function (
+    _target,
+    propertyKey,
+    descriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const originalMethod = descriptor.value;
+
+    if (typeof originalMethod !== 'function') {
+      throw new Error('@Memoize can only decorate methods');
+    }
+
+    descriptor.value = async function (...args: unknown[]): Promise<unknown> {
+      /**
+       * Create a cache key for each decorated method
+       */
+      const cacheKey = `memoizeCache:${String(propertyKey)}`;
+
+      /**
+       * Create a new cache if it does not exists yet (for certain function)
+       */
+      const cache: LRUCache<string, any> = this[cacheKey] ??= new LRUCache<string, any>({ max, ttl });
+
+      const key = strategy === 'hash'
+        ? Crypto.hash(args)
+        : args.map(String).join(':');
+
+      if (cache.has(key)) {
+        return cache.get(key);
+      }
+
+      try {
+        const result = await originalMethod.apply(this, args);
+        cache.set(key, result);
+        return result;
+      } catch (err) {
+        cache.delete(key);
+        throw err;
+      }
+    };
+
+    return descriptor;
+  };
+}

lib/utils/crypto.ts

@@ -1,4 +1,4 @@
-import crypto from 'crypto';
+import crypto, { BinaryToTextEncoding } from 'crypto';
 
 /**
  * Crypto helper
@@ -10,11 +10,11 @@ export default class Crypto {
    * @param value — data to be hashed
    * @param algo — type of algorithm to be used for hashing
    */
-  public static hash(value: unknown, algo = 'sha256'): string {
+  public static hash(value: unknown, algo = 'sha256', digest: BinaryToTextEncoding = 'hex'): string {
     const stringifiedValue = JSON.stringify(value);
 
     return crypto.createHash(algo)
       .update(stringifiedValue)
-      .digest('hex');
+      .digest(digest);
   }
 }

tsconfig.json

@@ -58,7 +58,7 @@
         // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
 
         /* Experimental Options */
-        // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+        "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
         // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
 
         /* Advanced Options */

workers/javascript/src/index.ts

@@ -14,6 +14,9 @@ import { beautifyUserAgent } from './utils';
 import { Collection } from 'mongodb';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
+import { Memoize } from '../../../lib/memoize';
+
+const MEMOIZATION_TTL = Number(process.env.MEMOIZATION_TTL ?? 0);
 
 /**
  * Worker for handling Javascript events
@@ -234,9 +237,9 @@ export default class JavascriptEventWorker extends EventWorker {
          */
         lines = this.readSourceLines(consumer, originalLocation);
 
-    //     const originalContent = consumer.sourceContentFor(originalLocation.source);
+        const originalContent = consumer.sourceContentFor(originalLocation.source);
 
-    //     functionContext = this.getFunctionContext(originalContent, originalLocation.line) ?? originalLocation.name;
+        functionContext = this.getFunctionContext(originalContent, originalLocation.line) ?? originalLocation.name;
       } catch(e) {
         HawkCatcher.send(e);
         this.logger.error('Can\'t get function context');
@@ -260,7 +263,8 @@ export default class JavascriptEventWorker extends EventWorker {
    * @param line - number of the line from the stack trace
    * @returns {string | null} - string of the function context or null if it could not be parsed
    */
-  private _getFunctionContext(sourceCode: string, line: number): string | null {
+  @Memoize({ max: 50, ttl: MEMOIZATION_TTL, strategy: 'hash' })
+  private getFunctionContext(sourceCode: string, line: number): string | null {
     let functionName: string | null = null;
     let className: string | null = null;
     let isAsync = false;
@@ -363,11 +367,12 @@ export default class JavascriptEventWorker extends EventWorker {
    *
    * @param map - saved file info without content.
    */
-  private loadSourceMapFile(map: SourceMapDataExtended): Promise<string> {
+  @Memoize({ max: 50, ttl: MEMOIZATION_TTL })
+  private loadSourceMapFile(mapId: SourceMapDataExtended['_id']): Promise<string> {
     return new Promise((resolve, reject) => {
       let buf = Buffer.from('');
 
-      const readstream = this.db.getBucket().openDownloadStream(map._id)
+      const readstream = this.db.getBucket().openDownloadStream(mapId)
         .on('data', (chunk) => {
           buf = Buffer.concat([buf, chunk]);
         })
@@ -450,6 +455,7 @@ export default class JavascriptEventWorker extends EventWorker {
    *
    * @param {string} mapBody - source map content
    */
+  @Memoize({ max: 50, ttl: MEMOIZATION_TTL, strategy: 'hash' })
   private consumeSourceMap(mapBody: string): SourceMapConsumer {
     try {
       const rawSourceMap = JSON.parse(mapBody);