41a0237a87
Automated scanners probing for WordPress paths (/blog/wp/v2/posts/*, POST /) generate a React Router 404 or 405 on every hit, and handleError forwarded all of them to Sentry, exhausting the quota. The existing defence was a list of ignoreErrors regexes that needed a new entry for each scanner pattern. Filter on what the error is instead: shouldReportServerError drops 4xx responses React Router generated itself (internal: true) for requests that matched nothing. Responses the app throws deliberately still report, as do all 5xx and real exceptions. A request carrying a same-origin Referer is still reported, so a broken internal link remains visible in Sentry -- only cold scanner hits are dropped. No HTTP response changes; every URL returns the status and page it did before. Also adds /blog to the Express bot-probe filter so the highest-volume path 404s without an SSR render, and removes the now-redundant route-404 ignoreErrors entries. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01ESrxBMZMx2BD9rcKTCgLe4
96 lines
No EOL
3.4 KiB
TypeScript
96 lines
No EOL
3.4 KiB
TypeScript
import * as Sentry from "@sentry/react-router";
|
|
import { PassThrough } from "node:stream";
|
|
import { logger } from "~/lib/logger";
|
|
import { shouldReportServerError } from "~/lib/error-reporting";
|
|
|
|
import type { AppLoadContext, EntryContext, HandleErrorFunction } from "react-router";
|
|
import { createReadableStreamFromReadable } from "@react-router/node";
|
|
import { ServerRouter } from "react-router";
|
|
import { isbot } from "isbot";
|
|
import type { RenderToPipeableStreamOptions } from "react-dom/server";
|
|
import { renderToPipeableStream } from "react-dom/server";
|
|
|
|
const sentryHandleError = Sentry.createSentryHandleError({
|
|
logErrors: true,
|
|
});
|
|
|
|
export const handleError: HandleErrorFunction = (error, args) => {
|
|
// Unrecognised URLs and methods are bot scans, not bugs. Skipping early also
|
|
// keeps them out of the `logErrors` console output; morgan still logs the request.
|
|
if (!shouldReportServerError(error, args.request)) return;
|
|
return sentryHandleError(error, args);
|
|
};
|
|
|
|
export const streamTimeout = 5_000;
|
|
|
|
async function handleRequest(
|
|
request: Request,
|
|
responseStatusCode: number,
|
|
responseHeaders: Headers,
|
|
routerContext: EntryContext,
|
|
// If you have middleware enabled:
|
|
// loadContext: RouterContextProvider
|
|
_loadContext: AppLoadContext
|
|
) {
|
|
return new Promise((resolve, reject) => {
|
|
let shellRendered = false;
|
|
const userAgent = request.headers.get("user-agent");
|
|
|
|
// Ensure requests from bots and SPA Mode renders wait for all content to load before responding
|
|
// https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
|
|
const readyOption: keyof RenderToPipeableStreamOptions =
|
|
(userAgent && isbot(userAgent)) || routerContext.isSpaMode
|
|
? "onAllReady"
|
|
: "onShellReady";
|
|
|
|
// Abort the rendering stream after the `streamTimeout` so it has time to
|
|
// flush down the rejected boundaries
|
|
let timeoutId: ReturnType<typeof setTimeout> | undefined = setTimeout(
|
|
() => abort(),
|
|
streamTimeout + 1000,
|
|
);
|
|
|
|
const { pipe, abort } = renderToPipeableStream(
|
|
<ServerRouter context={routerContext} url={request.url} />,
|
|
{
|
|
[readyOption]() {
|
|
shellRendered = true;
|
|
const body = new PassThrough({
|
|
final(callback) {
|
|
// Clear the timeout to prevent retaining the closure and memory leak
|
|
clearTimeout(timeoutId);
|
|
timeoutId = undefined;
|
|
callback();
|
|
},
|
|
});
|
|
const stream = createReadableStreamFromReadable(body);
|
|
|
|
responseHeaders.set("Content-Type", "text/html");
|
|
|
|
pipe(Sentry.getMetaTagTransformer(body));
|
|
|
|
resolve(
|
|
new Response(stream, {
|
|
headers: responseHeaders,
|
|
status: responseStatusCode,
|
|
}),
|
|
);
|
|
},
|
|
onShellError(error: unknown) {
|
|
reject(error);
|
|
},
|
|
onError(error: unknown) {
|
|
responseStatusCode = 500;
|
|
// Log streaming rendering errors from inside the shell. Don't log
|
|
// errors encountered during initial shell rendering since they'll
|
|
// reject and get logged in handleDocumentRequest.
|
|
if (shellRendered) {
|
|
logger.error(error);
|
|
}
|
|
},
|
|
},
|
|
);
|
|
});
|
|
}
|
|
|
|
export default Sentry.wrapSentryHandleRequest(handleRequest); |