10586316739

Committed 27 Aug 2024 09:42PM UTC coverage: 32.012% (-0.003%) from 32.015%

Build # 10586316739

Build Type

Pull #9642

github

Committed by

web-flow

Commit Message

Merge 47d10a26f into d74c3ae3b

Pull Request Pull Request #9642: Accumulated small changes from my git stash

Run Details

5020 of 40804 branches covered (12.3%)

Branch coverage included in aggregate %.

6 of 15 new or added lines in 11 files covered. (40.0%)

1 existing line in 1 file now uncovered.

29217 of 66146 relevant lines covered (44.17%)

189.3 hits per line

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

16.08

/packages/lesswrong/server/vulcan-lib/apollo-ssr/renderPage.tsx

/**
 * Render the page server side
 * @see https://github.com/szomolanyi/MeteorApolloStarter/blob/master/imports/startup/server/ssr.js
 * @see https://github.com/apollographql/GitHunt-React/blob/master/src/server.js
 * @see https://www.apollographql.com/docs/react/features/server-side-rendering.html#renderToStringWithData
 */
import React from 'react';
import ReactDOM from 'react-dom/server';
import { renderToStringWithData } from '@apollo/client/react/ssr';
import { computeContextFromUser, configureSentryScope } from '../apollo-server/context';

import { wrapWithMuiTheme } from '../../material-ui/themeProvider';
import { Vulcan } from '../../../lib/vulcan-lib/config';
import { createClient } from './apolloClient';
import { cachedPageRender, recordCacheBypass} from './pageCache';
import { getAllUserABTestGroups, CompleteTestGroupAllocation, RelevantTestGroupAllocation } from '../../../lib/abTestImpl';
import Head from './components/Head';
import { embedAsGlobalVar, healthCheckUserAgentSetting } from './renderUtil';
import AppGenerator from './components/AppGenerator';
import { captureException } from '@sentry/core';
import { ServerRequestStatusContextType } from '../../../lib/vulcan-core/appContext';
import { getCookieFromReq, getPathFromReq } from '../../utils/httpUtil';
import { getThemeOptions, AbstractThemeOptions } from '../../../themes/themeNames';
import { renderJssSheetImports } from '../../utils/renderJssSheetImports';
import { DatabaseServerSetting } from '../../databaseSettings';
import type { Request, Response } from 'express';
import { DEFAULT_TIMEZONE } from '../../../lib/utils/timeUtil';
import { getIpFromRequest } from '../../datadog/datadogMiddleware';
import { addStartRenderTimeToPerfMetric, asyncLocalStorage, closePerfMetric, closeRequestPerfMetric, openPerfMetric, setAsyncStoreValue } from '../../perfMetrics';
import { maxRenderQueueSize } from '../../../lib/publicSettings';
import { performanceMetricLoggingEnabled } from '../../../lib/instanceSettings';
import { getClientIP } from '@/server/utils/getClientIP';
import PriorityBucketQueue, { RequestData } from '../../../lib/requestPriorityQueue';
import { isAnyTest, isProduction } from '../../../lib/executionEnvironment';
import { LAST_VISITED_FRONTPAGE_COOKIE } from '../../../lib/cookies/cookies';
import { visitorGetsDynamicFrontpage } from '../../../lib/betas';
import { responseIsCacheable } from '../../cacheControlMiddleware';

const slowSSRWarnThresholdSetting = new DatabaseServerSetting<number>("slowSSRWarnThreshold", 3000);

type RenderTimings = {
  totalTime: number
  prerenderTime: number
  renderTime: number
}

export type RenderResult = {
  ssrBody: string
  headers: Array<string>
  serializedApolloState: string
  serializedForeignApolloState: string
  jssSheets: string
  status: number|undefined,
  redirectUrl: string|undefined
  relevantAbTestGroups: RelevantTestGroupAllocation
  allAbTestGroups: CompleteTestGroupAllocation
  themeOptions: AbstractThemeOptions,
  renderedAt: Date,
  cacheFriendly: boolean,
  timezone: string,
  timings: RenderTimings,
  aborted: false,
} | {
  aborted: true
}

interface RenderRequestParams {
  req: Request,
  user: DbUser|null,
  startTime: Date,
  res: Response,
  clientId?: string,
  userAgent?: string,
}

interface RenderPriorityQueueSlot extends RequestData {
  callback: () => Promise<void>;
  renderRequestParams: RenderRequestParams;
}

export const renderWithCache = async (req: Request, res: Response, user: DbUser|null, tabId: string | null) => {
  const startTime = new Date();
  
  const ip = getIpFromRequest(req)
  const userAgent = req.headers["user-agent"];
  
  const url = getPathFromReq(req);
  
  const clientId = getCookieFromReq(req, "clientId");
  
  const ssrEventParams = {
    url: url,
    clientId, tabId,
    userAgent: userAgent,
  };

  const isHealthCheck = userAgent === healthCheckUserAgentSetting.get();
  const abTestGroups = getAllUserABTestGroups(user ? {user} : {clientId});
  
  // Skip the page-cache if the user-agent is Slackbot's link-preview fetcher
  // because we need to render that page with a different value for the
  // twitter:card meta tag (see also: HeadTags.tsx, Head.tsx).
  const isSlackBot = userAgent && userAgent.startsWith("Slackbot-LinkExpanding");
  
  const userDescription = user?.username ?? `logged out ${ip} (${userAgent})`;
  
  const lastVisitedFrontpage = getCookieFromReq(req, LAST_VISITED_FRONTPAGE_COOKIE);
  // For LW, skip the cache on users who have visited the frontpage before, including logged out. 
  // Doing this so we can show dynamic latest posts list with varying HN decay parameters based on visit frequency (see useractivities/cron.ts).
  const showDynamicFrontpage = !!lastVisitedFrontpage && visitorGetsDynamicFrontpage(user) && url === "/";
  
  if ((!isHealthCheck && (user || isExcludedFromPageCache(url))) || isSlackBot || showDynamicFrontpage) {
    // When logged in, don't use the page cache (logged-in pages have notifications and stuff)
    recordCacheBypass({path: getPathFromReq(req), userAgent: userAgent ?? ''});
    
    if (performanceMetricLoggingEnabled.get()) {
      const perfMetric = openPerfMetric({
        op_type: "ssr",
        op_name: "skipCache",
        client_path: req.originalUrl,
        //we compute ip via two different methods in the codebase, using this one to be consistent with other perf_metrics
        ip: getClientIP(req),
        user_agent: userAgent,
        user_id: user?._id
      }, startTime);

      setAsyncStoreValue('requestPerfMetric', perfMetric);
    }

    const rendered = await queueRenderRequest({
      req, user, startTime, res, clientId, userAgent,
    });

    if (performanceMetricLoggingEnabled.get()) {
      closeRequestPerfMetric();
    }
    
    if (rendered.aborted) {
      return rendered;
    }

    if (shouldRecordSsrAnalytics(ssrEventParams.userAgent)) {
      // Capture an analytics event at the conclusion of the render
      Vulcan.captureEvent("ssr", {
        ...ssrEventParams,
        userId: user?._id,
        timings: rendered.timings,
        cached: false,
        abTestGroups: rendered.allAbTestGroups,
        ip
      });
    }

    // eslint-disable-next-line no-console
    console.log(`Finished SSR of ${url} for ${userDescription} (${formatTimings(rendered.timings)}, tab ${tabId})`);
    
    return {
      ...rendered,
      headers: [...rendered.headers],
    };
  } else {
    if (performanceMetricLoggingEnabled.get()) {
      const perfMetric = openPerfMetric({
        op_type: "ssr",
        op_name: "unknown",
        client_path: req.originalUrl,
        //we compute ip via two different methods in the codebase, using this one to be consistent with other perf_metrics
        ip: getClientIP(req),
        user_agent: userAgent
      }, startTime);

      setAsyncStoreValue('requestPerfMetric', perfMetric);
    }

    const rendered = await cachedPageRender(req, abTestGroups, userAgent, (req: Request) => queueRenderRequest({
      req, user: null, startTime, res, clientId, userAgent
    }));
    
    if (rendered.aborted) {
      return rendered;
    }

    if (rendered.cached) {
      // eslint-disable-next-line no-console
      console.log(`Served ${url} from cache for ${userDescription}`);
    } else {
      // eslint-disable-next-line no-console
      console.log(`Finished SSR of ${url} for ${userDescription}: (${formatTimings(rendered.timings)}, tab ${tabId})`);
    }

    if (performanceMetricLoggingEnabled.get()) {
      setAsyncStoreValue('requestPerfMetric', (incompletePerfMetric) => {
        if (!incompletePerfMetric) return;
        return {
          ...incompletePerfMetric,
          op_name: rendered.cached ? "cacheHit" : "cacheMiss"
        }
      });

      closeRequestPerfMetric();
    }

    if (shouldRecordSsrAnalytics(ssrEventParams.userAgent)) {
      Vulcan.captureEvent("ssr", {
        ...ssrEventParams,
        userId: null,
        timings: {
          totalTime: new Date().valueOf()-startTime.valueOf(),
        },
        abTestGroups: rendered.allAbTestGroups,
        cached: rendered.cached,
        ip
      });
    }
    
    return {
      ...rendered,
      headers: [...rendered.headers],
    };
  }
};

let inFlightRenderCount = 0;
const requestPriorityQueue = new PriorityBucketQueue<RenderPriorityQueueSlot>();

/**
 * We (maybe) have a problem where too many concurrently rendering requests cause our servers to fall over
 * To solve this, we introduce a queue for incoming requests, such that we have a maximum number of requests being rendered at the same time
 * See {@link maybeStartQueuedRequests} for the part that kicks off requests when appropriate
 */
function queueRenderRequest(params: RenderRequestParams): Promise<RenderResult> {
  return new Promise((resolve) => {
    requestPriorityQueue.enqueue({
      ip: getClientIP(params.req) ?? "unknown",
      userAgent: params.userAgent ?? 'sus-missing-user-agent',
      userId: params.user?._id,
      callback: async () => {
        let result: RenderResult;
        addStartRenderTimeToPerfMetric();
        try {
          result = await renderRequest(params);
        } finally {
          inFlightRenderCount--;
        }
        resolve(result);
        maybeStartQueuedRequests();
      },
      renderRequestParams: params,
    });

    maybeStartQueuedRequests();
  });
}

function maybeStartQueuedRequests() {
  while (inFlightRenderCount < maxRenderQueueSize.get() && requestPriorityQueue.size() > 0) {
    let requestToStartRendering = requestPriorityQueue.dequeue();
    if (requestToStartRendering.request) {
      const { preOpPriority, request } = requestToStartRendering;

      // If the request that we're kicking off is coming from the queue, we want to track this in the perf metrics
      setAsyncStoreValue('requestPerfMetric', (incompletePerfMetric) => {
        if (!incompletePerfMetric) return;
        return {
          ...incompletePerfMetric,
          queue_priority: preOpPriority
        }
      });

      inFlightRenderCount++;
      void request.callback();
    }
  }
}

export function initRenderQueueLogging() {
  if (!isAnyTest && performanceMetricLoggingEnabled.get()) {
    setInterval(logRenderQueueState, 5000)
  }
}

function logRenderQueueState() {
  if (requestPriorityQueue.size() > 0) {
    const queueState = requestPriorityQueue.getQueueState().map(([{ renderRequestParams }, priority]) => {
      return {
        userId: renderRequestParams.user?._id,
        ip: getIpFromRequest(renderRequestParams.req),
        userAgent: renderRequestParams.userAgent,
        url: getPathFromReq(renderRequestParams.req),
        startTime: renderRequestParams.startTime,
        priority
      }
    })

    Vulcan.captureEvent("renderQueueState", {
      queueState
    });
  }
}

function isExcludedFromPageCache(path: string): boolean {
  if (path.startsWith("/collaborateOnPost") || path.startsWith("/editPost")) return true;
  return false
}

const userAgentExclusions = [
  'health',
  'bot',
  'spider',
  'crawler',
  'curl',
  'node',
  'python'
];

function shouldRecordSsrAnalytics(userAgent?: string) {
  if (!userAgent) {
    return true;
  }

  return !userAgentExclusions.some(excludedAgent => userAgent.toLowerCase().includes(excludedAgent));
}

export const getThemeOptionsFromReq = (req: Request, user: DbUser|null): AbstractThemeOptions => {
  const themeCookie = getCookieFromReq(req, "theme");
  return getThemeOptions(themeCookie, user);
}

const buildSSRBody = (htmlContent: string, userAgent?: string) => {
  // When the theme name is "auto", we load the correct style by combining @import url()
  // with prefers-color-scheme (see `renderJssSheetImports`). There's a long-standing
  // Firefox bug where this can cause a flash of unstyled content. For reasons that
  // aren't entirely obvious to me, this can be fixed by adding <script>0</script> as the
  // first child of <body> which forces the browser to load the CSS before rendering.
  // See https://bugzilla.mozilla.org/show_bug.cgi?id=1404468
  const prefix = userAgent?.match(/.*firefox.*/i) ? "<script>0</script>" : "";
  // TODO: there should be a cleaner way to set this wrapper
  // id must always match the client side start.jsx file
  return `${prefix}<div id="react-app">${htmlContent}</div>`;
}

const renderRequest = async ({req, user, startTime, res, clientId, userAgent}: RenderRequestParams): Promise<RenderResult> => {
  const cacheFriendly = responseIsCacheable(res);
  const timezone = getCookieFromReq(req, "timezone") ?? DEFAULT_TIMEZONE;

  const requestContext = await computeContextFromUser({user, req, res, isSSR: true});
  if (req.closed) {
    // eslint-disable-next-line no-console
    console.log(`Request for ${req.url} from ${user?._id ?? getIpFromRequest(req)} was closed before render started`);
    return {
      aborted: true,
    };
  }
  configureSentryScope(requestContext);
  if (performanceMetricLoggingEnabled.get()) {
    setAsyncStoreValue('resolverContext', requestContext);
  }
  
  // according to the Apollo doc, client needs to be recreated on every request
  // this avoids caching server side
  const client = await createClient(requestContext);
  const foreignClient = await createClient(requestContext, true);

  // Used by callbacks to handle side effects
  // E.g storing the stylesheet generated by styled-components
  const context: any = {};

  // Allows components to set statuscodes and redirects that will get executed on the server
  let serverRequestStatus: ServerRequestStatusContextType = {}

  // TODO: req object does not seem to have been processed by the Express
  // middlewares at this point
  // @see https://github.com/meteor/meteor-feature-requests/issues/174#issuecomment-441047495

  // abTestGroups will be given as context for the render, which will modify it
  // (side effects) by filling in any A/B test groups that turned out to be
  // used for the rendering. (Any A/B test group that was *not* relevant to
  // the render will be omitted, which is the point.)
  let abTestGroupsUsed: RelevantTestGroupAllocation = {};
  
  const now = new Date();
  const App = <AppGenerator
    req={req}
    apolloClient={client}
    foreignApolloClient={foreignClient}
    serverRequestStatus={serverRequestStatus}
    abTestGroupsUsed={abTestGroupsUsed}
    ssrMetadata={{renderedAt: now.toISOString(), timezone, cacheFriendly}}
  />;
  
  const themeOptions = getThemeOptionsFromReq(req, user);

  const WrappedApp = wrapWithMuiTheme(App, context, themeOptions);
  
  let htmlContent = '';
  try {
    htmlContent = await renderToStringWithData(WrappedApp);
  } catch(err) {
    console.error(`Error while fetching Apollo Data. date: ${new Date().toString()} url: ${JSON.stringify(getPathFromReq(req))}`); // eslint-disable-line no-console
    console.error(err); // eslint-disable-line no-console
  }
  const afterPrerenderTime = new Date();

  const ssrBody = buildSSRBody(htmlContent, userAgent);

  // add headers using helmet
  const head = ReactDOM.renderToString(<Head userAgent={userAgent}/>);

  // add Apollo state, the client will then parse the string
  const initialState = client.extract();
  const serializedApolloState = embedAsGlobalVar("__APOLLO_STATE__", initialState);
  const serializedForeignApolloState = embedAsGlobalVar("__APOLLO_FOREIGN_STATE__", foreignClient.extract());

  const jssSheets = renderJssSheetImports(themeOptions);

  const finishedTime = new Date();
  const timings: RenderTimings = {
    prerenderTime: afterPrerenderTime.valueOf() - startTime.valueOf(),
    renderTime: finishedTime.valueOf() - afterPrerenderTime.valueOf(),
    totalTime: finishedTime.valueOf() - startTime.valueOf()
  };
  
  // eslint-disable-next-line no-console
  const slowSSRWarnThreshold = slowSSRWarnThresholdSetting.get();
  if (timings.totalTime > slowSSRWarnThreshold) {
    captureException(new Error(`SSR time above ${slowSSRWarnThreshold}ms`), {
      extra: {
        url: getPathFromReq(req),
        ssrTime: timings.totalTime,
      }
    });
  }
  
  client.stop();

  if (cacheFriendly && Object.keys(abTestGroupsUsed).length) {
    const message = `A/B tests used during a render that may be cached externally: ${Object.keys(abTestGroupsUsed).join(", ")}. Defer the A/B test until after SSR or disable caching on this route (\`swrCaching\`)`;
    const url = getPathFromReq(req);
    // eslint-disable-next-line no-console
    console.error(message, {url})
    captureException(new Error(message), {
      extra: { url }
    });
    if (!isProduction) {
      return {aborted: true};
    }
  }

  return {
    ssrBody,
    headers: [head],
    serializedApolloState,
    serializedForeignApolloState,
    jssSheets,
    status: serverRequestStatus.status,
    redirectUrl: serverRequestStatus.redirectUrl,
    relevantAbTestGroups: abTestGroupsUsed,
    allAbTestGroups: getAllUserABTestGroups(user ? {user} : {clientId}),
    themeOptions,
    renderedAt: now,
    cacheFriendly,
    timezone,
    timings,
    aborted: false,
  };
}

const formatTimings = (timings: RenderTimings): string => {
  return `${timings.totalTime}ms`;
}

1	/**	70✔
2	* Render the page server side
3	* @see https://github.com/szomolanyi/MeteorApolloStarter/blob/master/imports/startup/server/ssr.js
4	* @see https://github.com/apollographql/GitHunt-React/blob/master/src/server.js
5	* @see https://www.apollographql.com/docs/react/features/server-side-rendering.html#renderToStringWithData
6	*/
7	import React from 'react';	18✔
8	import ReactDOM from 'react-dom/server';	18✔
9	import { renderToStringWithData } from '@apollo/client/react/ssr';	18✔
10	import { computeContextFromUser, configureSentryScope } from '../apollo-server/context';	18✔
11
12	import { wrapWithMuiTheme } from '../../material-ui/themeProvider';	18✔
13	import { Vulcan } from '../../../lib/vulcan-lib/config';	18✔
14	import { createClient } from './apolloClient';	18✔
15	import { cachedPageRender, recordCacheBypass} from './pageCache';	18✔
16	import { getAllUserABTestGroups, CompleteTestGroupAllocation, RelevantTestGroupAllocation } from '../../../lib/abTestImpl';	18✔
17	import Head from './components/Head';	18✔
18	import { embedAsGlobalVar, healthCheckUserAgentSetting } from './renderUtil';	18✔
19	import AppGenerator from './components/AppGenerator';	18✔
20	import { captureException } from '@sentry/core';	18✔
21	import { ServerRequestStatusContextType } from '../../../lib/vulcan-core/appContext';
22	import { getCookieFromReq, getPathFromReq } from '../../utils/httpUtil';	18✔
23	import { getThemeOptions, AbstractThemeOptions } from '../../../themes/themeNames';	18✔
24	import { renderJssSheetImports } from '../../utils/renderJssSheetImports';	18✔
25	import { DatabaseServerSetting } from '../../databaseSettings';	18✔
26	import type { Request, Response } from 'express';
27	import { DEFAULT_TIMEZONE } from '../../../lib/utils/timeUtil';	18✔
28	import { getIpFromRequest } from '../../datadog/datadogMiddleware';	18✔
29	import { addStartRenderTimeToPerfMetric, asyncLocalStorage, closePerfMetric, closeRequestPerfMetric, openPerfMetric, setAsyncStoreValue } from '../../perfMetrics';	18✔
30	import { maxRenderQueueSize } from '../../../lib/publicSettings';	18✔
31	import { performanceMetricLoggingEnabled } from '../../../lib/instanceSettings';	18✔
32	import { getClientIP } from '@/server/utils/getClientIP';	18✔
33	import PriorityBucketQueue, { RequestData } from '../../../lib/requestPriorityQueue';	18✔
34	import { isAnyTest, isProduction } from '../../../lib/executionEnvironment';	18✔
35	import { LAST_VISITED_FRONTPAGE_COOKIE } from '../../../lib/cookies/cookies';	18✔
36	import { visitorGetsDynamicFrontpage } from '../../../lib/betas';	18✔
37	import { responseIsCacheable } from '../../cacheControlMiddleware';	18✔
38
39	const slowSSRWarnThresholdSetting = new DatabaseServerSetting<number>("slowSSRWarnThreshold", 3000);	18✔
40
41	type RenderTimings = {
42	totalTime: number
43	prerenderTime: number
44	renderTime: number
45	}
46
47	export type RenderResult = {
48	ssrBody: string
49	headers: Array<string>
50	serializedApolloState: string
51	serializedForeignApolloState: string
52	jssSheets: string
53	status: number\|undefined,
54	redirectUrl: string\|undefined
55	relevantAbTestGroups: RelevantTestGroupAllocation
56	allAbTestGroups: CompleteTestGroupAllocation
57	themeOptions: AbstractThemeOptions,
58	renderedAt: Date,
59	cacheFriendly: boolean,
60	timezone: string,
61	timings: RenderTimings,
62	aborted: false,
63	} \| {
64	aborted: true
65	}
66
67	interface RenderRequestParams {
68	req: Request,
69	user: DbUser\|null,
70	startTime: Date,
71	res: Response,
72	clientId?: string,
73	userAgent?: string,
74	}
75
76	interface RenderPriorityQueueSlot extends RequestData {
77	callback: () => Promise<void>;
78	renderRequestParams: RenderRequestParams;
79	}
80
81	export const renderWithCache = async (req: Request, res: Response, user: DbUser\|null, tabId: string \| null) => {	18✔
82	const startTime = new Date();	×
83
84	const ip = getIpFromRequest(req)	×
85	const userAgent = req.headers["user-agent"];	×
86
87	const url = getPathFromReq(req);	×
88
89	const clientId = getCookieFromReq(req, "clientId");	×
90
91	const ssrEventParams = {	×
92	url: url,
93	clientId, tabId,
94	userAgent: userAgent,
95	};
96
97	const isHealthCheck = userAgent === healthCheckUserAgentSetting.get();	×
98	const abTestGroups = getAllUserABTestGroups(user ? {user} : {clientId});	×
99
100	// Skip the page-cache if the user-agent is Slackbot's link-preview fetcher
101	// because we need to render that page with a different value for the
102	// twitter:card meta tag (see also: HeadTags.tsx, Head.tsx).
103	const isSlackBot = userAgent && userAgent.startsWith("Slackbot-LinkExpanding");	×
104
105	const userDescription = user?.username ?? `logged out ${ip} (${userAgent})`;	×
106
107	const lastVisitedFrontpage = getCookieFromReq(req, LAST_VISITED_FRONTPAGE_COOKIE);	×
108	// For LW, skip the cache on users who have visited the frontpage before, including logged out.
109	// Doing this so we can show dynamic latest posts list with varying HN decay parameters based on visit frequency (see useractivities/cron.ts).
110	const showDynamicFrontpage = !!lastVisitedFrontpage && visitorGetsDynamicFrontpage(user) && url === "/";	×
111
112	if ((!isHealthCheck && (user \|\| isExcludedFromPageCache(url))) \|\| isSlackBot \|\| showDynamicFrontpage) {	×
113	// When logged in, don't use the page cache (logged-in pages have notifications and stuff)
114	recordCacheBypass({path: getPathFromReq(req), userAgent: userAgent ?? ''});	×
115
116	if (performanceMetricLoggingEnabled.get()) {	×
117	const perfMetric = openPerfMetric({	×
118	op_type: "ssr",
119	op_name: "skipCache",
120	client_path: req.originalUrl,
121	//we compute ip via two different methods in the codebase, using this one to be consistent with other perf_metrics
122	ip: getClientIP(req),
123	user_agent: userAgent,
124	user_id: user?._id	×
125	}, startTime);
126
127	setAsyncStoreValue('requestPerfMetric', perfMetric);	×
128	}
129
130	const rendered = await queueRenderRequest({	×
131	req, user, startTime, res, clientId, userAgent,
132	});
133
134	if (performanceMetricLoggingEnabled.get()) {	×
135	closeRequestPerfMetric();	×
136	}
137
138	if (rendered.aborted) {	×
139	return rendered;	×
140	}
141
142	if (shouldRecordSsrAnalytics(ssrEventParams.userAgent)) {	×
143	// Capture an analytics event at the conclusion of the render
144	Vulcan.captureEvent("ssr", {	×
145	...ssrEventParams,
146	userId: user?._id,	×
147	timings: rendered.timings,
148	cached: false,
149	abTestGroups: rendered.allAbTestGroups,
150	ip
151	});
152	}
153
154	// eslint-disable-next-line no-console
155	console.log(`Finished SSR of ${url} for ${userDescription} (${formatTimings(rendered.timings)}, tab ${tabId})`);	×
156
157	return {	×
158	...rendered,
159	headers: [...rendered.headers],
160	};
161	} else {
162	if (performanceMetricLoggingEnabled.get()) {	×
163	const perfMetric = openPerfMetric({	×
164	op_type: "ssr",
165	op_name: "unknown",
166	client_path: req.originalUrl,
167	//we compute ip via two different methods in the codebase, using this one to be consistent with other perf_metrics
168	ip: getClientIP(req),
169	user_agent: userAgent
170	}, startTime);
171
172	setAsyncStoreValue('requestPerfMetric', perfMetric);	×
173	}
174
175	const rendered = await cachedPageRender(req, abTestGroups, userAgent, (req: Request) => queueRenderRequest({	×
176	req, user: null, startTime, res, clientId, userAgent
177	}));
178
179	if (rendered.aborted) {	×
180	return rendered;	×
181	}
182
183	if (rendered.cached) {	×
184	// eslint-disable-next-line no-console
185	console.log(`Served ${url} from cache for ${userDescription}`);	×
186	} else {
187	// eslint-disable-next-line no-console
188	console.log(`Finished SSR of ${url} for ${userDescription}: (${formatTimings(rendered.timings)}, tab ${tabId})`);	×
189	}
190
191	if (performanceMetricLoggingEnabled.get()) {	×
192	setAsyncStoreValue('requestPerfMetric', (incompletePerfMetric) => {	×
193	if (!incompletePerfMetric) return;	×
194	return {	×
195	...incompletePerfMetric,
196	op_name: rendered.cached ? "cacheHit" : "cacheMiss"	×
197	}
198	});
199
200	closeRequestPerfMetric();	×
201	}
202
203	if (shouldRecordSsrAnalytics(ssrEventParams.userAgent)) {	×
204	Vulcan.captureEvent("ssr", {	×
205	...ssrEventParams,
206	userId: null,
207	timings: {
208	totalTime: new Date().valueOf()-startTime.valueOf(),
209	},
210	abTestGroups: rendered.allAbTestGroups,
211	cached: rendered.cached,
212	ip
213	});
214	}
215
216	return {	×
217	...rendered,
218	headers: [...rendered.headers],
219	};
220	}
221	};
222
223	let inFlightRenderCount = 0;	18✔
224	const requestPriorityQueue = new PriorityBucketQueue<RenderPriorityQueueSlot>();	18✔
225
226	/**
227	* We (maybe) have a problem where too many concurrently rendering requests cause our servers to fall over
228	* To solve this, we introduce a queue for incoming requests, such that we have a maximum number of requests being rendered at the same time
229	* See {@link maybeStartQueuedRequests} for the part that kicks off requests when appropriate
230	*/
231	function queueRenderRequest(params: RenderRequestParams): Promise<RenderResult> {
232	return new Promise((resolve) => {	×
233	requestPriorityQueue.enqueue({	×
234	ip: getClientIP(params.req) ?? "unknown",	×
235	userAgent: params.userAgent ?? 'sus-missing-user-agent',	×
236	userId: params.user?._id,	×
237	callback: async () => {
238	let result: RenderResult;
239	addStartRenderTimeToPerfMetric();	×
240	try {	×
241	result = await renderRequest(params);	×
242	} finally {
243	inFlightRenderCount--;	×
244	}
245	resolve(result);	×
246	maybeStartQueuedRequests();	×
247	},
248	renderRequestParams: params,
249	});
250
251	maybeStartQueuedRequests();	×
252	});
253	}
254
255	function maybeStartQueuedRequests() {
256	while (inFlightRenderCount < maxRenderQueueSize.get() && requestPriorityQueue.size() > 0) {	×
257	let requestToStartRendering = requestPriorityQueue.dequeue();	×
258	if (requestToStartRendering.request) {	×
259	const { preOpPriority, request } = requestToStartRendering;	×
260
261	// If the request that we're kicking off is coming from the queue, we want to track this in the perf metrics
262	setAsyncStoreValue('requestPerfMetric', (incompletePerfMetric) => {	×
263	if (!incompletePerfMetric) return;	×
264	return {	×
265	...incompletePerfMetric,
266	queue_priority: preOpPriority
267	}
268	});
269
270	inFlightRenderCount++;	×
271	void request.callback();	×
272	}
273	}
274	}
275
276	export function initRenderQueueLogging() {
277	if (!isAnyTest && performanceMetricLoggingEnabled.get()) {	16!
278	setInterval(logRenderQueueState, 5000)	×
279	}
280	}
281
282	function logRenderQueueState() {
283	if (requestPriorityQueue.size() > 0) {	×
284	const queueState = requestPriorityQueue.getQueueState().map(([{ renderRequestParams }, priority]) => {	×
285	return {	×
286	userId: renderRequestParams.user?._id,	×
287	ip: getIpFromRequest(renderRequestParams.req),
288	userAgent: renderRequestParams.userAgent,
289	url: getPathFromReq(renderRequestParams.req),
290	startTime: renderRequestParams.startTime,
291	priority
292	}
293	})
294
295	Vulcan.captureEvent("renderQueueState", {	×
296	queueState
297	});
298	}
299	}
300
301	function isExcludedFromPageCache(path: string): boolean {
302	if (path.startsWith("/collaborateOnPost") \|\| path.startsWith("/editPost")) return true;	×
303	return false	×
304	}
305
306	const userAgentExclusions = [	18✔
307	'health',
308	'bot',
309	'spider',
310	'crawler',
311	'curl',
312	'node',
313	'python'
314	];
315
316	function shouldRecordSsrAnalytics(userAgent?: string) {
317	if (!userAgent) {	×
318	return true;	×
319	}
320
321	return !userAgentExclusions.some(excludedAgent => userAgent.toLowerCase().includes(excludedAgent));	×
322	}
323
324	export const getThemeOptionsFromReq = (req: Request, user: DbUser\|null): AbstractThemeOptions => {	18✔
325	const themeCookie = getCookieFromReq(req, "theme");	×
326	return getThemeOptions(themeCookie, user);	×
327	}
328
329	const buildSSRBody = (htmlContent: string, userAgent?: string) => {	18✔
330	// When the theme name is "auto", we load the correct style by combining @import url()
331	// with prefers-color-scheme (see `renderJssSheetImports`). There's a long-standing
332	// Firefox bug where this can cause a flash of unstyled content. For reasons that
333	// aren't entirely obvious to me, this can be fixed by adding <script>0</script> as the
334	// first child of <body> which forces the browser to load the CSS before rendering.
335	// See https://bugzilla.mozilla.org/show_bug.cgi?id=1404468
336	const prefix = userAgent?.match(/.firefox./i) ? "<script>0</script>" : "";	×
337	// TODO: there should be a cleaner way to set this wrapper
338	// id must always match the client side start.jsx file
339	return `${prefix}<div id="react-app">${htmlContent}</div>`;	×
340	}
341
342	const renderRequest = async ({req, user, startTime, res, clientId, userAgent}: RenderRequestParams): Promise<RenderResult> => {	18✔
343	const cacheFriendly = responseIsCacheable(res);	×
344	const timezone = getCookieFromReq(req, "timezone") ?? DEFAULT_TIMEZONE;	×
345
NEW 346	const requestContext = await computeContextFromUser({user, req, res, isSSR: true});	×
347	if (req.closed) {	×
348	// eslint-disable-next-line no-console
349	console.log(`Request for ${req.url} from ${user?._id ?? getIpFromRequest(req)} was closed before render started`);	×
350	return {	×
351	aborted: true,
352	};
353	}
354	configureSentryScope(requestContext);	×
355	if (performanceMetricLoggingEnabled.get()) {	×
356	setAsyncStoreValue('resolverContext', requestContext);	×
357	}
358
359	// according to the Apollo doc, client needs to be recreated on every request
360	// this avoids caching server side
361	const client = await createClient(requestContext);	×
362	const foreignClient = await createClient(requestContext, true);	×
363
364	// Used by callbacks to handle side effects
365	// E.g storing the stylesheet generated by styled-components
366	const context: any = {};	×
367
368	// Allows components to set statuscodes and redirects that will get executed on the server
369	let serverRequestStatus: ServerRequestStatusContextType = {}	×
370
371	// TODO: req object does not seem to have been processed by the Express
372	// middlewares at this point
373	// @see https://github.com/meteor/meteor-feature-requests/issues/174#issuecomment-441047495
374
375	// abTestGroups will be given as context for the render, which will modify it
376	// (side effects) by filling in any A/B test groups that turned out to be
377	// used for the rendering. (Any A/B test group that was not relevant to
378	// the render will be omitted, which is the point.)
379	let abTestGroupsUsed: RelevantTestGroupAllocation = {};	×
380
381	const now = new Date();	×
382	const App = <AppGenerator	×
383	req={req}
384	apolloClient={client}
385	foreignApolloClient={foreignClient}
386	serverRequestStatus={serverRequestStatus}
387	abTestGroupsUsed={abTestGroupsUsed}
388	ssrMetadata={{renderedAt: now.toISOString(), timezone, cacheFriendly}}
389	/>;
390
391	const themeOptions = getThemeOptionsFromReq(req, user);	×
392
393	const WrappedApp = wrapWithMuiTheme(App, context, themeOptions);	×
394
395	let htmlContent = '';	×
396	try {	×
397	htmlContent = await renderToStringWithData(WrappedApp);	×
398	} catch(err) {
399	console.error(`Error while fetching Apollo Data. date: ${new Date().toString()} url: ${JSON.stringify(getPathFromReq(req))}`); // eslint-disable-line no-console	×
400	console.error(err); // eslint-disable-line no-console	×
401	}
402	const afterPrerenderTime = new Date();	×
403
404	const ssrBody = buildSSRBody(htmlContent, userAgent);	×
405
406	// add headers using helmet
407	const head = ReactDOM.renderToString(<Head userAgent={userAgent}/>);	×
408
409	// add Apollo state, the client will then parse the string
410	const initialState = client.extract();	×
411	const serializedApolloState = embedAsGlobalVar("__APOLLO_STATE__", initialState);	×
412	const serializedForeignApolloState = embedAsGlobalVar("__APOLLO_FOREIGN_STATE__", foreignClient.extract());	×
413
414	const jssSheets = renderJssSheetImports(themeOptions);	×
415
416	const finishedTime = new Date();	×
417	const timings: RenderTimings = {	×
418	prerenderTime: afterPrerenderTime.valueOf() - startTime.valueOf(),
419	renderTime: finishedTime.valueOf() - afterPrerenderTime.valueOf(),
420	totalTime: finishedTime.valueOf() - startTime.valueOf()
421	};
422
423	// eslint-disable-next-line no-console
424	const slowSSRWarnThreshold = slowSSRWarnThresholdSetting.get();	×
425	if (timings.totalTime > slowSSRWarnThreshold) {	×
426	captureException(new Error(`SSR time above ${slowSSRWarnThreshold}ms`), {	×
427	extra: {
428	url: getPathFromReq(req),
429	ssrTime: timings.totalTime,
430	}
431	});
432	}
433
434	client.stop();	×
435
436	if (cacheFriendly && Object.keys(abTestGroupsUsed).length) {	×
437	const message = `A/B tests used during a render that may be cached externally: ${Object.keys(abTestGroupsUsed).join(", ")}. Defer the A/B test until after SSR or disable caching on this route (\`swrCaching\`)`;	×
438	const url = getPathFromReq(req);	×
439	// eslint-disable-next-line no-console
440	console.error(message, {url})	×
441	captureException(new Error(message), {	×
442	extra: { url }
443	});
444	if (!isProduction) {	×
445	return {aborted: true};	×
446	}
447	}
448
449	return {	×
450	ssrBody,
451	headers: [head],
452	serializedApolloState,
453	serializedForeignApolloState,
454	jssSheets,
455	status: serverRequestStatus.status,
456	redirectUrl: serverRequestStatus.redirectUrl,
457	relevantAbTestGroups: abTestGroupsUsed,
458	allAbTestGroups: getAllUserABTestGroups(user ? {user} : {clientId}),	×
459	themeOptions,
460	renderedAt: now,
461	cacheFriendly,
462	timezone,
463	timings,
464	aborted: false,
465	};
466	}
467
468	const formatTimings = (timings: RenderTimings): string => {	18✔
469	return `${timings.totalTime}ms`;	×
470	}

ForumMagnum / ForumMagnum / 10586316739

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