9156641095

Committed 20 May 2024 09:32AM UTC coverage: 32.42% (+0.5%) from 31.92%

Build # 9156641095

Build Type

Pull #9263

github

Committed by

Will-Howard

Commit Message

switch from .then to await syntax

Pull Request Pull Request #9263: Invalidate stale-while-revalidate cache entries on write

Run Details

3473 of 27316 branches covered (12.71%)

Branch coverage included in aggregate %.

37 of 59 new or added lines in 6 files covered. (62.71%)

8 existing lines in 1 file now uncovered.

19453 of 43399 relevant lines covered (44.82%)

262.78 hits per line

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

47.76

/packages/lesswrong/server/cache/swr.ts

import { Posts } from "../../lib/collections/posts";
import { PostsMinimumForGetPageUrl, postGetPageUrl } from "../../lib/collections/posts/helpers";
import { onStartup } from "../../lib/executionEnvironment";
import { loggerConstructor } from "../../lib/utils/logging";
import { serverId } from "../analyticsWriter";
import { DatabaseServerSetting } from "../databaseSettings";
import { getCollectionHooks } from "../mutationCallbacks";

export const swrCachingEnabledSetting = new DatabaseServerSetting<boolean>('swrCaching.enabled', false)
const swrCachingInvalidationIntervalMsSetting = new DatabaseServerSetting<number>('swrCaching.invalidationIntervalMs', 30_000)

const INVALIDATION_USER_AGENT = `ForumMagnumCacheInvalidator/1.0 (Server ID: ${serverId})`;

// Invalidation queue
//
// We invalidate pages that are stored in a CDN by pinging the relevant url, this causes the
// CDN to refetch the page from our servers to use as the cached response. This is relatively expensive
// compared to the operation that triggered it, because it triggers a full SSR on one of our servers.
//
// To limit the rate at which SSRs are triggered, invalidation requests are queued up in the following way:
// - In a given [30s] interval:
//   - For each `swrInvalidatePostRoute` call
//     - If the queue is empty, and no invalidation request has been processed in this interval, ping the url immediately
//     - Else, add the url to the back of the queue, if it is not present in the queue already
//   - Process 1 item from the queue if it is not empty
//
// So a maximum of 2 invalidation requests will be sent per interval, *per worker*. The request may be processed by a different worker.

const invalidationQueue: string[] = [];
const MAX_LENGTH = 30;
let eager = true;

const invalidateUrlFromQueue = async (): Promise<void> => {
  const logger = loggerConstructor(`swr-invalidation-queue`)
  const url = invalidationQueue.shift()
  if (!url) return;

  logger(`Sending invalidation request. URL: ${url}, serverId: ${serverId}`)
  try {
    const response = await fetch(url, {
      headers: {
        'User-Agent': INVALIDATION_USER_AGENT
      }
    });
    if (!response.ok) {
      // eslint-disable-next-line no-console
      console.error(`Invalidation request to URL failed: ${url}`);
    }
  } catch (error) {
    // eslint-disable-next-line no-console
    console.error(`Invalidation request to URL failed: ${url}`, error);
  }
}

const scheduleQueueProcessing = () => {
  // Use setTimeout rather than setInterval to pick up changes to the interval setting without needing to reload the server
  setTimeout(async () => {
    const logger = loggerConstructor(`swr-invalidation-queue`)
    logger(`Running invalidateUrlFromQueue from setTimeout. serverId: ${serverId}`)

    void invalidateUrlFromQueue();
    eager = true;
    scheduleQueueProcessing();
  }, swrCachingInvalidationIntervalMsSetting.get());
};
onStartup(() => {
  scheduleQueueProcessing();
})

/**
 * Invalidate the CDN cache entry for the given post by pinging the URL
 */
export const swrInvalidatePostRoute = async (postId: string) => {
  if (!swrCachingEnabledSetting.get() || invalidationQueue.length > MAX_LENGTH) return;
  const post = await Posts.findOne({_id: postId, swrCachingEnabled: true}, {}, {_id: 1, slug: 1, isEvent: 1, groupId: 1}) as PostsMinimumForGetPageUrl;

  if (!post) return;
  const url = postGetPageUrl(post, true);

  if (invalidationQueue.includes(url)) return;

  invalidationQueue.push(url)
  if (eager) {
    eager = false;
    void invalidateUrlFromQueue();
  }
};

//
// Callbacks for triggering invalidation
//

const postCallback = ({ _id }: { _id: string }) => {
  void swrInvalidatePostRoute(_id);
};

getCollectionHooks("Posts").createAfter.add(postCallback);
getCollectionHooks("Posts").updateAfter.add(postCallback);

const commentCallback = ({ postId }: { postId: string | null }) => {
  if (!postId) return;
  void swrInvalidatePostRoute(postId);
};

getCollectionHooks("Comments").createAfter.add(commentCallback);
getCollectionHooks("Comments").updateAfter.add(commentCallback);

// See packages/lesswrong/server/voteServer.ts for callback on votes

1	import { Posts } from "../../lib/collections/posts";	165✔
2	import { PostsMinimumForGetPageUrl, postGetPageUrl } from "../../lib/collections/posts/helpers";	18✔
3	import { onStartup } from "../../lib/executionEnvironment";	18✔
4	import { loggerConstructor } from "../../lib/utils/logging";	18✔
5	import { serverId } from "../analyticsWriter";	18✔
6	import { DatabaseServerSetting } from "../databaseSettings";	18✔
7	import { getCollectionHooks } from "../mutationCallbacks";	18✔
8
9	export const swrCachingEnabledSetting = new DatabaseServerSetting<boolean>('swrCaching.enabled', false)	18✔
10	const swrCachingInvalidationIntervalMsSetting = new DatabaseServerSetting<number>('swrCaching.invalidationIntervalMs', 30_000)	18✔
11
12	const INVALIDATION_USER_AGENT = `ForumMagnumCacheInvalidator/1.0 (Server ID: ${serverId})`;	18✔
13
14	// Invalidation queue
15	//
16	// We invalidate pages that are stored in a CDN by pinging the relevant url, this causes the
17	// CDN to refetch the page from our servers to use as the cached response. This is relatively expensive
18	// compared to the operation that triggered it, because it triggers a full SSR on one of our servers.
19	//
20	// To limit the rate at which SSRs are triggered, invalidation requests are queued up in the following way:
21	// - In a given [30s] interval:
22	// - For each `swrInvalidatePostRoute` call
23	// - If the queue is empty, and no invalidation request has been processed in this interval, ping the url immediately
24	// - Else, add the url to the back of the queue, if it is not present in the queue already
25	// - Process 1 item from the queue if it is not empty
26	//
27	// So a maximum of 2 invalidation requests will be sent per interval, per worker. The request may be processed by a different worker.
28
29	const invalidationQueue: string[] = [];	18✔
30	const MAX_LENGTH = 30;	18✔
31	let eager = true;	18✔
32
33	const invalidateUrlFromQueue = async (): Promise<void> => {	18✔
NEW 34	const logger = loggerConstructor(`swr-invalidation-queue`)	×
NEW 35	const url = invalidationQueue.shift()	×
NEW 36	if (!url) return;	×
37
NEW 38	logger(`Sending invalidation request. URL: ${url}, serverId: ${serverId}`)	×
NEW 39	try {	×
NEW 40	const response = await fetch(url, {	×
41	headers: {
42	'User-Agent': INVALIDATION_USER_AGENT
43	}
44	});
NEW 45	if (!response.ok) {	×
46	// eslint-disable-next-line no-console
NEW 47	console.error(`Invalidation request to URL failed: ${url}`);	×
48	}
49	} catch (error) {
50	// eslint-disable-next-line no-console
NEW 51	console.error(`Invalidation request to URL failed: ${url}`, error);	×
52	}
53	}
54
55	const scheduleQueueProcessing = () => {	18✔
56	// Use setTimeout rather than setInterval to pick up changes to the interval setting without needing to reload the server
57	setTimeout(async () => {	16✔
NEW 58	const logger = loggerConstructor(`swr-invalidation-queue`)	×
NEW 59	logger(`Running invalidateUrlFromQueue from setTimeout. serverId: ${serverId}`)	×
60
NEW 61	void invalidateUrlFromQueue();	×
NEW 62	eager = true;	×
NEW 63	scheduleQueueProcessing();	×
64	}, swrCachingInvalidationIntervalMsSetting.get());
65	};	18✔
66	onStartup(() => {
67	scheduleQueueProcessing();	16✔
68	})
69
70	/**
71	* Invalidate the CDN cache entry for the given post by pinging the URL
72	*/
73	export const swrInvalidatePostRoute = async (postId: string) => {	18✔
74	if (!swrCachingEnabledSetting.get() \|\| invalidationQueue.length > MAX_LENGTH) return;	250!
NEW 75	const post = await Posts.findOne({_id: postId, swrCachingEnabled: true}, {}, {_id: 1, slug: 1, isEvent: 1, groupId: 1}) as PostsMinimumForGetPageUrl;	×
76
NEW 77	if (!post) return;	×
NEW 78	const url = postGetPageUrl(post, true);	×
79
NEW 80	if (invalidationQueue.includes(url)) return;	×
81
NEW 82	invalidationQueue.push(url)	×
NEW 83	if (eager) {	×
NEW 84	eager = false;	×
NEW 85	void invalidateUrlFromQueue();	×
86	}
87	};
88
89	//
90	// Callbacks for triggering invalidation
91	//
92
93	const postCallback = ({ _id }: { _id: string }) => {	18✔
94	void swrInvalidatePostRoute(_id);	113✔
95	};	18✔
96
97	getCollectionHooks("Posts").createAfter.add(postCallback);	18✔
98	getCollectionHooks("Posts").updateAfter.add(postCallback);
99
100	const commentCallback = ({ postId }: { postId: string \| null }) => {	18✔
101	if (!postId) return;	26!
102	void swrInvalidatePostRoute(postId);	26✔
103	};	18✔
104
105	getCollectionHooks("Comments").createAfter.add(commentCallback);	18✔
106	getCollectionHooks("Comments").updateAfter.add(commentCallback);
107
108	// See packages/lesswrong/server/voteServer.ts for callback on votes

ForumMagnum / ForumMagnum / 9156641095

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