10566812868

Committed 26 Aug 2024 08:30PM UTC coverage: 32.193% (+0.001%) from 32.192%

Build # 10566812868

Build Type

Pull #9618

github

Committed by

ben-pace

Commit Message

keep deprecated comments view

Pull Request Pull Request #9618: Comment sort author page

Run Details

5015 of 40337 branches covered (12.43%)

Branch coverage included in aggregate %.

15 of 36 new or added lines in 4 files covered. (41.67%)

229 existing lines in 5 files now uncovered.

28995 of 65308 relevant lines covered (44.4%)

190.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.27

/packages/lesswrong/server/vulcan-lib/apollo-ssr/pageCache.ts

import LRU from 'lru-cache';
import type { RenderResult } from './renderPage';
import { CompleteTestGroupAllocation, RelevantTestGroupAllocation, getABTestsMetadata } from '../../../lib/abTestImpl';
import { Globals } from '../../../lib/vulcan-lib';
import type { Request } from 'express';
import { getCookieFromReq, getPathFromReq } from '../../utils/httpUtil';
import { isValidSerializedThemeOptions, getDefaultThemeOptions } from '../../../themes/themeNames';
import sumBy from 'lodash/sumBy';
import { dogstatsd } from '../../datadog/tracer';
import { healthCheckUserAgentSetting } from './renderUtil';
import PageCacheRepo, { maxCacheAgeMs } from '../../repos/PageCacheRepo';
import { DatabaseServerSetting } from '../../databaseSettings';
import { isDatadogEnabled } from '../../../lib/instanceSettings';
import stringify from 'json-stringify-deterministic';

// Page cache. This applies only to logged-out requests, and exists primarily
// to handle the baseload of traffic going to the front page and to pages that
// have gotten linked from high-traffic places.
//
// Complexity here is driven by three things:
//   1. Users that don't share a time zone can't share a page cache, because
//      dates that appear on the page differ;
//   2. Two visitors in different A/B test groups can't share a cache entry,
//      but we don't know which A/B tests were relevant to a page until after
//      we've rendered it; and
//   3. When a page that is getting a lot of traffic expires from the page
//      cache, we don't want to start many rerenders of it in parallel

const dbPageCacheEnabledSetting = new DatabaseServerSetting<boolean>("dbPageCacheEnabled", true);

const maxPageCacheSizeBytes = 32*1024*1024; //32MB

const pageCache = new LRU<string,RenderResult>({
  max: maxPageCacheSizeBytes,
  length: (page,key) => JSON.stringify(page).length + JSON.stringify(key).length,
  maxAge: maxCacheAgeMs,
  updateAgeOnGet: false,
  dispose: (key: string, page) => {
    const parsedKey: {cacheKey: string, abTestGroups: RelevantTestGroupAllocation} = JSON.parse(key);
    const { cacheKey, abTestGroups } = parsedKey;
    keysToCheckForExpiredEntries.push(cacheKey);
  },
});

const jsonSerializableEstimateSize = (obj: any) => {
  if (typeof obj === "object") {
    let result = 0;
    for (let key of Object.keys(obj)) {
      result += jsonSerializableEstimateSize(key);
      result += jsonSerializableEstimateSize(obj[key]);
    }
    return result;
  } else if (typeof obj === "string") {
    return obj.length;
  } else {
    return 8;
  }
}

// FIXME: This doesn't get updated correctly. Previous iteration had entries
// removed when they should still be in cachedABtestsIndex; current iteration
// has duplicate entries accumulate over time.
const cachedABtestsIndex: Record<string,Array<RelevantTestGroupAllocation>> = {};
let keysToCheckForExpiredEntries: Array<string> = [];

export const cacheKeyFromReq = (req: Request): string => {
  const timezoneCookie = getCookieFromReq(req, "timezone");
  const themeCookie = getCookieFromReq(req, "theme");
  const themeOptions = themeCookie && isValidSerializedThemeOptions(themeCookie) ? themeCookie : stringify(getDefaultThemeOptions());
  const path = getPathFromReq(req);
  
  if (timezoneCookie)
    return `${path}&theme=${themeOptions}&timezone=${timezoneCookie}`;
  else
    return path;
}

type InProgressRender = {
  cacheKey: string
  abTestGroups: CompleteTestGroupAllocation
  renderPromise: Promise<RenderResult>
};

const inProgressRenders: Record<string,Array<InProgressRender>> = {};

function filterLoggedOutActiveAbTestGroups(abTestGroups: CompleteTestGroupAllocation): RelevantTestGroupAllocation {
  const abTests = getABTestsMetadata();
  let result: RelevantTestGroupAllocation = {};
  for (const name of Object.keys(abTestGroups)) {
    const abTest = abTests[name];
    if (abTest.active && abTest.affectsLoggedOut)
      result[name] = abTestGroups[name];
    
  }
  return result;
}

// Serve a page from cache, or render it if necessary. Takes a set of A/B test
// groups for this request, which covers *all* A/B tests (including ones that
// may not be relevant to the request).
export const cachedPageRender = async (req: Request, abTestGroups: CompleteTestGroupAllocation, userAgent: string|undefined, renderFn: (req: Request) => Promise<RenderResult>) => {
  const path = getPathFromReq(req);
  const cacheKey = cacheKeyFromReq(req);
  const cacheAffectingAbTestGroups = filterLoggedOutActiveAbTestGroups(abTestGroups);
  const cached = await cacheLookup(cacheKey, cacheAffectingAbTestGroups);
  
  // If already cached, return the cached version
  if (cached) {
    recordCacheHit({path, userAgent: userAgent ?? ''});
    //eslint-disable-next-line no-console
    console.log(`Serving ${path} from cache; hit rate=${getCacheHitRate()}`);
    return {
      ...cached,
      cached: true
    };
  }
  
  if (cacheKey in inProgressRenders) {
    for (let inProgressRender of inProgressRenders[cacheKey]) {
      if (objIsSubset(cacheAffectingAbTestGroups, inProgressRender.abTestGroups)) {
        //eslint-disable-next-line no-console
        console.log(`Merging request for ${path} into in-progress render`);
        const result = await inProgressRender.renderPromise;
        return {
          ...result,
          cached: true,
        };
      }
    }
    //eslint-disable-next-line no-console
    console.log(`In progress render merge of ${cacheKey} missed: mismatched A/B test groups (requested: ${JSON.stringify(cacheAffectingAbTestGroups)}, available: ${JSON.stringify(inProgressRenders[cacheKey].map(r=>r.abTestGroups))})`);
  }
  
  recordCacheMiss({path, userAgent: userAgent ?? ''});
  //eslint-disable-next-line no-console
  console.log(`Rendering ${path} (not in cache; hit rate=${getCacheHitRate()})`);
  
  const renderPromise = renderFn(req);
  
  const inProgressRender = {
    cacheKey,
    abTestGroups: cacheAffectingAbTestGroups,
    renderPromise
  };
  if (cacheKey in inProgressRenders) {
    inProgressRenders[cacheKey].push(inProgressRender);
  } else {
    inProgressRenders[cacheKey] = [inProgressRender];
  }
  
  const rendered = await renderPromise;
  if (!rendered.aborted) {
    // eslint-disable-next-line no-console
    console.log(`Completed render with A/B test groups: ${JSON.stringify(rendered.relevantAbTestGroups)}`);
    cacheStore(cacheKey, rendered.relevantAbTestGroups, rendered);
  }
  
  inProgressRenders[cacheKey] = inProgressRenders[cacheKey].filter(r => r!==inProgressRender);
  if (!inProgressRenders[cacheKey].length)
    delete inProgressRenders[cacheKey];

  // This just clears expired entries from cachedABtestsIndex, the actual page cache is an LRU() so it's cleared automatically
  clearExpiredCacheEntries();
  
  return {
    ...rendered,
    cached: false
  };
}

const cacheLookupLocal = (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): RenderResult|null|undefined => {
  if (!(cacheKey in cachedABtestsIndex)) {
    // eslint-disable-next-line no-console
    console.log(`Local cache miss for cacheKey ${cacheKey}: no cached page for any A/B test group combination`);
    return null;
  }
  const abTestCombinations: Array<RelevantTestGroupAllocation> = cachedABtestsIndex[cacheKey];
  for (let i=0; i<abTestCombinations.length; i++) {
    if (objIsSubset(abTestCombinations[i], abTestGroups)) {
      const lookupResult = pageCache.get(JSON.stringify({
        cacheKey: cacheKey,
        abTestGroups: abTestCombinations[i]
      }));
      if (lookupResult) {
        // eslint-disable-next-line no-console
        console.log(`Local cache hit for cacheKey ${cacheKey}`);
        return lookupResult;
      }
    }
  }

  // eslint-disable-next-line no-console
  console.log(`Local cache miss for cacheKey ${cacheKey}: wrong A/B test groups: wanted ${JSON.stringify(abTestGroups)}, had available ${JSON.stringify(cachedABtestsIndex[cacheKey])}`);
  return null;
}

const cacheLookupDB = async (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): Promise<RenderResult|null|undefined> => {
  const cacheResult = await (new PageCacheRepo().lookupCacheEntry({path: cacheKey, completeAbTestGroups: abTestGroups}));

  if (!cacheResult?.renderResult) {
    // eslint-disable-next-line no-console
    console.log(`DB cache miss for cacheKey ${cacheKey}: no cached page with this cacheKey and a valid A/B test group combination`);
    return null;
  }

  // eslint-disable-next-line no-console
  console.log(`DB cache hit for cacheKey ${cacheKey}`);
  return {
    ...cacheResult?.renderResult,
    aborted: false
  };
}

const cacheLookup = async (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): Promise<RenderResult|null|undefined> => {
  const localResult = cacheLookupLocal(cacheKey, abTestGroups);
  if (localResult) {
    return localResult;
  }

  if (dbPageCacheEnabledSetting.get()) {
    const dbResult = await cacheLookupDB(cacheKey, abTestGroups);
    return dbResult;
  }

  return null;
}

const objIsSubset = <A extends Record<string, any>, B extends Record<string, any>>(subset: A, superset: B): boolean => {
  for (let key in subset) {
    if (!(key in superset) || subset[key] !== superset[key as AnyBecauseHard])
      return false;
  }
  return true;
}

const cacheStoreLocal = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {
  pageCache.set(JSON.stringify({
    cacheKey: cacheKey,
    abTestGroups: abTestGroups
  }), rendered);
  
  if (cacheKey in cachedABtestsIndex)
    cachedABtestsIndex[cacheKey].push(abTestGroups);
  else
    cachedABtestsIndex[cacheKey] = [abTestGroups];
}

const cacheStoreDB = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {
  void new PageCacheRepo().upsertPageCacheEntry(cacheKey, abTestGroups, rendered);
}

const cacheStore = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {
  cacheStoreLocal(cacheKey, abTestGroups, rendered);
  cacheStoreDB(cacheKey, abTestGroups, rendered);
}

const clearExpiredCacheEntries = (): void => {
  for (let cacheKey of keysToCheckForExpiredEntries) {
    const remainingEntries: Record<string,boolean> = {}
    if (cachedABtestsIndex[cacheKey]) {
      for (let abTestGroups of cachedABtestsIndex[cacheKey]) {
        if (pageCache.get(JSON.stringify({ cacheKey, abTestGroups }))) {
          remainingEntries[JSON.stringify(abTestGroups)] = true;
        }
      }
    }
    
    const remainingEntriesArray = Object.keys(remainingEntries).map(groups=>JSON.parse(groups));
    if (remainingEntriesArray.length > 0)
      cachedABtestsIndex[cacheKey] = remainingEntriesArray;
    else
      delete cachedABtestsIndex[cacheKey];
  }
  keysToCheckForExpiredEntries = [];
}

let cacheHits = 0;
let cacheQueriesTotal = 0;

export function recordDatadogCacheEvent(cacheEvent: {path: string, userAgent: string, type: "hit"|"miss"|"bypass"}) {
  // Bots are _mostly_ already redirected by botRedirect.ts, so assume every request that is not a health check is a real user
  const userType = cacheEvent.userAgent === healthCheckUserAgentSetting.get() ? "health_check" : "likely_real_user";

  const expandedCacheEvent = {...cacheEvent, userType};
  if (isDatadogEnabled && dogstatsd) {
    dogstatsd.increment("cache_event", expandedCacheEvent)
  }
}

export function recordCacheHit(cacheEvent: {path: string, userAgent: string}) {
  // recordDatadogCacheEvent({...cacheEvent, type: "hit"}); // Useful for debugging, but expensive to track all the time
  cacheHits++;
  cacheQueriesTotal++;
}
export function recordCacheMiss(cacheEvent: {path: string, userAgent: string}) {
  // recordDatadogCacheEvent({...cacheEvent, type: "miss"}); // Useful for debugging, but expensive to track all the time
  cacheQueriesTotal++;
}
export function recordCacheBypass(cacheEvent: {path: string, userAgent: string}) {
  // recordDatadogCacheEvent({...cacheEvent, type: "bypass"}); // Useful for debugging, but expensive to track all the time
  cacheQueriesTotal++;
}
export function getCacheHitRate() {
  return cacheHits / cacheQueriesTotal;
}

function printCacheState(options: any={}) {
  const {pruneCache=false} = options;
  // eslint-disable-next-line no-console
  const log = console.log;
  
  log('cachedABtestsIndex = {');
  for (let cacheKey of Object.keys(cachedABtestsIndex)) {
    log(`    ${cacheKey}: [`);
    for (let abTestGroup of cachedABtestsIndex[cacheKey]) {
      log(`        ${JSON.stringify(abTestGroup)}`);
    }
    log(`    ],`);
  }
  log("}");
  
  if (pruneCache)
    pageCache.prune();
  log(`pageCache (length=${pageCache.length}) = {`);
  
  let directlyCalculatedLength = 0;
  pageCache.forEach((value,key,cache) => {
    log(`    ${key} => ...`);
    directlyCalculatedLength += JSON.stringify(value).length + JSON.stringify(key).length;
  });
  log("}");
  if (pageCache.length !== directlyCalculatedLength) {
    log("===============");
    log("LENGTH MISMATCH");
    log(`Expected: ${pageCache.length}, found: ${directlyCalculatedLength}`);
    log("===============");
  }
  
  log("inProgressRenders = {");
  for (let cacheKey of Object.keys(inProgressRenders)) {
    log(`    ${cacheKey}: [`);
    for (let inProgressRender of inProgressRenders[cacheKey]) {
      log(`        ${JSON.stringify(inProgressRender.abTestGroups)}`);
    }
    log("    ]");
  }
  log("}");
}
Globals.printCacheState = printCacheState;


export function checkForMemoryLeaks() {
  if (Object.keys(cachedABtestsIndex).length > 5000) {
    // eslint-disable-next-line no-console
    console.log(`Possible memory leak: cachedABtestsIndex has ${Object.keys(cachedABtestsIndex).length} entries`);
  }
  if (keysToCheckForExpiredEntries.length > 5000) {
    // eslint-disable-next-line no-console
    console.log(`Possible memory leak: keysToCheckForExpiredEntries has ${keysToCheckForExpiredEntries} entries`);
  }
  
  const cachedABtestsIndexArrayElements = sumBy(Object.keys(cachedABtestsIndex), key=>cachedABtestsIndex[key]?.length||0);
  if (cachedABtestsIndexArrayElements > 5000) {
    // eslint-disable-next-line no-console
    console.log(`Possible memory leak: cachedABtestsIndexArrayElements=${cachedABtestsIndexArrayElements}`);
  }
  
  const inProgressRenderCount = sumBy(Object.keys(inProgressRenders), key=>inProgressRenders[key]?.length||0);
  if (inProgressRenderCount > 100) {
    // eslint-disable-next-line no-console
    console.log(`Possible memory leak: inProgressRenderCount=${inProgressRenderCount}`);
  }
  
  const pageCacheContentsBytes = sumBy(pageCache.values(), v=>JSON.stringify(v).length);
  if (pageCacheContentsBytes > 2*maxPageCacheSizeBytes) {
    // eslint-disable-next-line no-console
    console.log(`Possible memory leak: pageCacheContentsBytes=${pageCacheContentsBytes}`);
  }
}

export function printInFlightRequests() {
  let inProgressRenderKeys: string[] = [];
  for (let cacheKey of Object.keys(inProgressRenders)) {
    for (let render of inProgressRenders[cacheKey]) {
      inProgressRenderKeys.push(render.cacheKey);
    }
  }
  if (inProgressRenderKeys.length > 0) {
    // eslint-disable-next-line no-console
    console.log(`In progress: ${inProgressRenderKeys.join(", ")}`);
  }
}

1	import LRU from 'lru-cache';	54✔
2	import type { RenderResult } from './renderPage';
3	import { CompleteTestGroupAllocation, RelevantTestGroupAllocation, getABTestsMetadata } from '../../../lib/abTestImpl';	18✔
4	import { Globals } from '../../../lib/vulcan-lib';	18✔
5	import type { Request } from 'express';
6	import { getCookieFromReq, getPathFromReq } from '../../utils/httpUtil';	18✔
7	import { isValidSerializedThemeOptions, getDefaultThemeOptions } from '../../../themes/themeNames';	18✔
8	import sumBy from 'lodash/sumBy';	18✔
9	import { dogstatsd } from '../../datadog/tracer';	18✔
10	import { healthCheckUserAgentSetting } from './renderUtil';	18✔
11	import PageCacheRepo, { maxCacheAgeMs } from '../../repos/PageCacheRepo';	18✔
12	import { DatabaseServerSetting } from '../../databaseSettings';	18✔
13	import { isDatadogEnabled } from '../../../lib/instanceSettings';	18✔
14	import stringify from 'json-stringify-deterministic';	18✔
15
16	// Page cache. This applies only to logged-out requests, and exists primarily
17	// to handle the baseload of traffic going to the front page and to pages that
18	// have gotten linked from high-traffic places.
19	//
20	// Complexity here is driven by three things:
21	// 1. Users that don't share a time zone can't share a page cache, because
22	// dates that appear on the page differ;
23	// 2. Two visitors in different A/B test groups can't share a cache entry,
24	// but we don't know which A/B tests were relevant to a page until after
25	// we've rendered it; and
26	// 3. When a page that is getting a lot of traffic expires from the page
27	// cache, we don't want to start many rerenders of it in parallel
28
29	const dbPageCacheEnabledSetting = new DatabaseServerSetting<boolean>("dbPageCacheEnabled", true);	18✔
30
31	const maxPageCacheSizeBytes = 3210241024; //32MB	18✔
32
33	const pageCache = new LRU<string,RenderResult>({	18✔
34	max: maxPageCacheSizeBytes,
35	length: (page,key) => JSON.stringify(page).length + JSON.stringify(key).length,	×
36	maxAge: maxCacheAgeMs,
37	updateAgeOnGet: false,
38	dispose: (key: string, page) => {
39	const parsedKey: {cacheKey: string, abTestGroups: RelevantTestGroupAllocation} = JSON.parse(key);	×
40	const { cacheKey, abTestGroups } = parsedKey;	×
41	keysToCheckForExpiredEntries.push(cacheKey);	×
42	},
43	});
44
45	const jsonSerializableEstimateSize = (obj: any) => {	18✔
46	if (typeof obj === "object") {	×
47	let result = 0;	×
48	for (let key of Object.keys(obj)) {	×
49	result += jsonSerializableEstimateSize(key);	×
50	result += jsonSerializableEstimateSize(obj[key]);	×
51	}
52	return result;	×
53	} else if (typeof obj === "string") {	×
54	return obj.length;	×
55	} else {
56	return 8;	×
57	}
58	}
59
60	// FIXME: This doesn't get updated correctly. Previous iteration had entries
61	// removed when they should still be in cachedABtestsIndex; current iteration
62	// has duplicate entries accumulate over time.
63	const cachedABtestsIndex: Record<string,Array<RelevantTestGroupAllocation>> = {};	18✔
64	let keysToCheckForExpiredEntries: Array<string> = [];	18✔
65
66	export const cacheKeyFromReq = (req: Request): string => {	18✔
67	const timezoneCookie = getCookieFromReq(req, "timezone");	×
68	const themeCookie = getCookieFromReq(req, "theme");	×
69	const themeOptions = themeCookie && isValidSerializedThemeOptions(themeCookie) ? themeCookie : stringify(getDefaultThemeOptions());	×
70	const path = getPathFromReq(req);	×
71
72	if (timezoneCookie)	×
73	return `${path}&theme=${themeOptions}&timezone=${timezoneCookie}`;	×
74	else
75	return path;	×
76	}
77
78	type InProgressRender = {
79	cacheKey: string
80	abTestGroups: CompleteTestGroupAllocation
81	renderPromise: Promise<RenderResult>
82	};
83
84	const inProgressRenders: Record<string,Array<InProgressRender>> = {};	18✔
85
86	function filterLoggedOutActiveAbTestGroups(abTestGroups: CompleteTestGroupAllocation): RelevantTestGroupAllocation {
87	const abTests = getABTestsMetadata();	×
88	let result: RelevantTestGroupAllocation = {};	×
89	for (const name of Object.keys(abTestGroups)) {	×
90	const abTest = abTests[name];	×
91	if (abTest.active && abTest.affectsLoggedOut)	×
92	result[name] = abTestGroups[name];	×
93
94	}
95	return result;	×
96	}
97
98	// Serve a page from cache, or render it if necessary. Takes a set of A/B test
99	// groups for this request, which covers all A/B tests (including ones that
100	// may not be relevant to the request).
101	export const cachedPageRender = async (req: Request, abTestGroups: CompleteTestGroupAllocation, userAgent: string\|undefined, renderFn: (req: Request) => Promise<RenderResult>) => {	18✔
102	const path = getPathFromReq(req);	×
103	const cacheKey = cacheKeyFromReq(req);	×
104	const cacheAffectingAbTestGroups = filterLoggedOutActiveAbTestGroups(abTestGroups);	×
105	const cached = await cacheLookup(cacheKey, cacheAffectingAbTestGroups);	×
106
107	// If already cached, return the cached version
108	if (cached) {	×
109	recordCacheHit({path, userAgent: userAgent ?? ''});	×
110	//eslint-disable-next-line no-console
111	console.log(`Serving ${path} from cache; hit rate=${getCacheHitRate()}`);	×
112	return {	×
113	...cached,
114	cached: true
115	};
116	}
117
118	if (cacheKey in inProgressRenders) {	×
119	for (let inProgressRender of inProgressRenders[cacheKey]) {	×
120	if (objIsSubset(cacheAffectingAbTestGroups, inProgressRender.abTestGroups)) {	×
121	//eslint-disable-next-line no-console
122	console.log(`Merging request for ${path} into in-progress render`);	×
123	const result = await inProgressRender.renderPromise;	×
124	return {	×
125	...result,
126	cached: true,
127	};
128	}
129	}
130	//eslint-disable-next-line no-console
131	console.log(`In progress render merge of ${cacheKey} missed: mismatched A/B test groups (requested: ${JSON.stringify(cacheAffectingAbTestGroups)}, available: ${JSON.stringify(inProgressRenders[cacheKey].map(r=>r.abTestGroups))})`);	×
132	}
133
134	recordCacheMiss({path, userAgent: userAgent ?? ''});	×
135	//eslint-disable-next-line no-console
136	console.log(`Rendering ${path} (not in cache; hit rate=${getCacheHitRate()})`);	×
137
138	const renderPromise = renderFn(req);	×
139
140	const inProgressRender = {	×
141	cacheKey,
142	abTestGroups: cacheAffectingAbTestGroups,
143	renderPromise
144	};
145	if (cacheKey in inProgressRenders) {	×
146	inProgressRenders[cacheKey].push(inProgressRender);	×
147	} else {
148	inProgressRenders[cacheKey] = [inProgressRender];	×
149	}
150
UNCOV 151	const rendered = await renderPromise;	×
152	if (!rendered.aborted) {	×
153	// eslint-disable-next-line no-console
154	console.log(`Completed render with A/B test groups: ${JSON.stringify(rendered.relevantAbTestGroups)}`);	×
UNCOV 155	cacheStore(cacheKey, rendered.relevantAbTestGroups, rendered);	×
156	}
157
UNCOV 158	inProgressRenders[cacheKey] = inProgressRenders[cacheKey].filter(r => r!==inProgressRender);	×
UNCOV 159	if (!inProgressRenders[cacheKey].length)	×
160	delete inProgressRenders[cacheKey];	×
161
162	// This just clears expired entries from cachedABtestsIndex, the actual page cache is an LRU() so it's cleared automatically
UNCOV 163	clearExpiredCacheEntries();	×
164
165	return {	×
166	...rendered,
167	cached: false
168	};
169	}
170
171	const cacheLookupLocal = (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): RenderResult\|null\|undefined => {	18✔
UNCOV 172	if (!(cacheKey in cachedABtestsIndex)) {	×
173	// eslint-disable-next-line no-console
UNCOV 174	console.log(`Local cache miss for cacheKey ${cacheKey}: no cached page for any A/B test group combination`);	×
175	return null;	×
176	}
177	const abTestCombinations: Array<RelevantTestGroupAllocation> = cachedABtestsIndex[cacheKey];	×
178	for (let i=0; i<abTestCombinations.length; i++) {	×
UNCOV 179	if (objIsSubset(abTestCombinations[i], abTestGroups)) {	×
180	const lookupResult = pageCache.get(JSON.stringify({	×
181	cacheKey: cacheKey,
182	abTestGroups: abTestCombinations[i]
183	}));
UNCOV 184	if (lookupResult) {	×
185	// eslint-disable-next-line no-console
UNCOV 186	console.log(`Local cache hit for cacheKey ${cacheKey}`);	×
187	return lookupResult;	×
188	}
189	}
190	}
191
192	// eslint-disable-next-line no-console
UNCOV 193	console.log(`Local cache miss for cacheKey ${cacheKey}: wrong A/B test groups: wanted ${JSON.stringify(abTestGroups)}, had available ${JSON.stringify(cachedABtestsIndex[cacheKey])}`);	×
UNCOV 194	return null;	×
195	}
196
197	const cacheLookupDB = async (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): Promise<RenderResult\|null\|undefined> => {	18✔
UNCOV 198	const cacheResult = await (new PageCacheRepo().lookupCacheEntry({path: cacheKey, completeAbTestGroups: abTestGroups}));	×
199
UNCOV 200	if (!cacheResult?.renderResult) {	×
201	// eslint-disable-next-line no-console
UNCOV 202	console.log(`DB cache miss for cacheKey ${cacheKey}: no cached page with this cacheKey and a valid A/B test group combination`);	×
203	return null;	×
204	}
205
206	// eslint-disable-next-line no-console
UNCOV 207	console.log(`DB cache hit for cacheKey ${cacheKey}`);	×
UNCOV 208	return {	×
209	...cacheResult?.renderResult,	×
210	aborted: false
211	};
212	}
213
214	const cacheLookup = async (cacheKey: string, abTestGroups: CompleteTestGroupAllocation): Promise<RenderResult\|null\|undefined> => {	18✔
UNCOV 215	const localResult = cacheLookupLocal(cacheKey, abTestGroups);	×
UNCOV 216	if (localResult) {	×
UNCOV 217	return localResult;	×
218	}
219
220	if (dbPageCacheEnabledSetting.get()) {	×
UNCOV 221	const dbResult = await cacheLookupDB(cacheKey, abTestGroups);	×
UNCOV 222	return dbResult;	×
223	}
224
225	return null;	×
226	}
227
228	const objIsSubset = <A extends Record<string, any>, B extends Record<string, any>>(subset: A, superset: B): boolean => {	18✔
UNCOV 229	for (let key in subset) {	×
UNCOV 230	if (!(key in superset) \|\| subset[key] !== superset[key as AnyBecauseHard])	×
UNCOV 231	return false;	×
232	}
233	return true;	×
234	}
235
236	const cacheStoreLocal = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {	18✔
UNCOV 237	pageCache.set(JSON.stringify({	×
238	cacheKey: cacheKey,
239	abTestGroups: abTestGroups
240	}), rendered);
241
UNCOV 242	if (cacheKey in cachedABtestsIndex)	×
UNCOV 243	cachedABtestsIndex[cacheKey].push(abTestGroups);	×
244	else
245	cachedABtestsIndex[cacheKey] = [abTestGroups];	×
246	}
247
248	const cacheStoreDB = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {	18✔
UNCOV 249	void new PageCacheRepo().upsertPageCacheEntry(cacheKey, abTestGroups, rendered);	×
250	}
251
252	const cacheStore = (cacheKey: string, abTestGroups: RelevantTestGroupAllocation, rendered: RenderResult): void => {	18✔
UNCOV 253	cacheStoreLocal(cacheKey, abTestGroups, rendered);	×
UNCOV 254	cacheStoreDB(cacheKey, abTestGroups, rendered);	×
255	}
256
257	const clearExpiredCacheEntries = (): void => {	18✔
UNCOV 258	for (let cacheKey of keysToCheckForExpiredEntries) {	×
UNCOV 259	const remainingEntries: Record<string,boolean> = {}	×
UNCOV 260	if (cachedABtestsIndex[cacheKey]) {	×
261	for (let abTestGroups of cachedABtestsIndex[cacheKey]) {	×
262	if (pageCache.get(JSON.stringify({ cacheKey, abTestGroups }))) {	×
263	remainingEntries[JSON.stringify(abTestGroups)] = true;	×
264	}
265	}
266	}
267
UNCOV 268	const remainingEntriesArray = Object.keys(remainingEntries).map(groups=>JSON.parse(groups));	×
UNCOV 269	if (remainingEntriesArray.length > 0)	×
UNCOV 270	cachedABtestsIndex[cacheKey] = remainingEntriesArray;	×
271	else
272	delete cachedABtestsIndex[cacheKey];	×
273	}
UNCOV 274	keysToCheckForExpiredEntries = [];	×
275	}
276
277	let cacheHits = 0;	18✔
278	let cacheQueriesTotal = 0;	18✔
279
280	export function recordDatadogCacheEvent(cacheEvent: {path: string, userAgent: string, type: "hit"\|"miss"\|"bypass"}) {
281	// Bots are _mostly_ already redirected by botRedirect.ts, so assume every request that is not a health check is a real user
UNCOV 282	const userType = cacheEvent.userAgent === healthCheckUserAgentSetting.get() ? "health_check" : "likely_real_user";	×
283
UNCOV 284	const expandedCacheEvent = {...cacheEvent, userType};	×
285	if (isDatadogEnabled && dogstatsd) {	×
UNCOV 286	dogstatsd.increment("cache_event", expandedCacheEvent)	×
287	}
288	}
289
290	export function recordCacheHit(cacheEvent: {path: string, userAgent: string}) {
291	// recordDatadogCacheEvent({...cacheEvent, type: "hit"}); // Useful for debugging, but expensive to track all the time
UNCOV 292	cacheHits++;	×
UNCOV 293	cacheQueriesTotal++;	×
294	}
295	export function recordCacheMiss(cacheEvent: {path: string, userAgent: string}) {
296	// recordDatadogCacheEvent({...cacheEvent, type: "miss"}); // Useful for debugging, but expensive to track all the time
UNCOV 297	cacheQueriesTotal++;	×
298	}
299	export function recordCacheBypass(cacheEvent: {path: string, userAgent: string}) {
300	// recordDatadogCacheEvent({...cacheEvent, type: "bypass"}); // Useful for debugging, but expensive to track all the time
UNCOV 301	cacheQueriesTotal++;	×
302	}
303	export function getCacheHitRate() {
304	return cacheHits / cacheQueriesTotal;	×
305	}
306
307	function printCacheState(options: any={}) {	×
UNCOV 308	const {pruneCache=false} = options;	×
309	// eslint-disable-next-line no-console
UNCOV 310	const log = console.log;	×
311
UNCOV 312	log('cachedABtestsIndex = {');	×
313	for (let cacheKey of Object.keys(cachedABtestsIndex)) {	×
UNCOV 314	log(` ${cacheKey}: [`);	×
315	for (let abTestGroup of cachedABtestsIndex[cacheKey]) {	×
316	log(` ${JSON.stringify(abTestGroup)}`);	×
317	}
318	log(` ],`);	×
319	}
UNCOV 320	log("}");	×
321
UNCOV 322	if (pruneCache)	×
323	pageCache.prune();	×
UNCOV 324	log(`pageCache (length=${pageCache.length}) = {`);	×
325
326	let directlyCalculatedLength = 0;	×
327	pageCache.forEach((value,key,cache) => {	×
UNCOV 328	log(` ${key} => ...`);	×
329	directlyCalculatedLength += JSON.stringify(value).length + JSON.stringify(key).length;	×
330	});
331	log("}");	×
332	if (pageCache.length !== directlyCalculatedLength) {	×
UNCOV 333	log("===============");	×
334	log("LENGTH MISMATCH");	×
335	log(`Expected: ${pageCache.length}, found: ${directlyCalculatedLength}`);	×
336	log("===============");	×
337	}
338
339	log("inProgressRenders = {");	×
UNCOV 340	for (let cacheKey of Object.keys(inProgressRenders)) {	×
UNCOV 341	log(` ${cacheKey}: [`);	×
342	for (let inProgressRender of inProgressRenders[cacheKey]) {	×
343	log(` ${JSON.stringify(inProgressRender.abTestGroups)}`);	×
344	}
345	log(" ]");	×
346	}
UNCOV 347	log("}");	×
348	}
349	Globals.printCacheState = printCacheState;	18✔
350
351
352	export function checkForMemoryLeaks() {
UNCOV 353	if (Object.keys(cachedABtestsIndex).length > 5000) {	×
354	// eslint-disable-next-line no-console
UNCOV 355	console.log(`Possible memory leak: cachedABtestsIndex has ${Object.keys(cachedABtestsIndex).length} entries`);	×
356	}
UNCOV 357	if (keysToCheckForExpiredEntries.length > 5000) {	×
358	// eslint-disable-next-line no-console
UNCOV 359	console.log(`Possible memory leak: keysToCheckForExpiredEntries has ${keysToCheckForExpiredEntries} entries`);	×
360	}
361
362	const cachedABtestsIndexArrayElements = sumBy(Object.keys(cachedABtestsIndex), key=>cachedABtestsIndex[key]?.length\|\|0);	×
UNCOV 363	if (cachedABtestsIndexArrayElements > 5000) {	×
364	// eslint-disable-next-line no-console
365	console.log(`Possible memory leak: cachedABtestsIndexArrayElements=${cachedABtestsIndexArrayElements}`);	×
366	}
367
368	const inProgressRenderCount = sumBy(Object.keys(inProgressRenders), key=>inProgressRenders[key]?.length\|\|0);	×
UNCOV 369	if (inProgressRenderCount > 100) {	×
370	// eslint-disable-next-line no-console
371	console.log(`Possible memory leak: inProgressRenderCount=${inProgressRenderCount}`);	×
372	}
373
374	const pageCacheContentsBytes = sumBy(pageCache.values(), v=>JSON.stringify(v).length);	×
UNCOV 375	if (pageCacheContentsBytes > 2*maxPageCacheSizeBytes) {	×
376	// eslint-disable-next-line no-console
377	console.log(`Possible memory leak: pageCacheContentsBytes=${pageCacheContentsBytes}`);	×
378	}
379	}
380
381	export function printInFlightRequests() {
UNCOV 382	let inProgressRenderKeys: string[] = [];	×
UNCOV 383	for (let cacheKey of Object.keys(inProgressRenders)) {	×
UNCOV 384	for (let render of inProgressRenders[cacheKey]) {	×
385	inProgressRenderKeys.push(render.cacheKey);	×
386	}
387	}
388	if (inProgressRenderKeys.length > 0) {	×
389	// eslint-disable-next-line no-console
UNCOV 390	console.log(`In progress: ${inProgressRenderKeys.join(", ")}`);	×
391	}
392	}

ForumMagnum / ForumMagnum / 10566812868

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous