@lowdefy/server 5.6.0 → 6.1.0

package/lib/server/log/redactUrlQuery.js

@@ -0,0 +1,75 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// Query parameters that carry a credential rather than a filter: the
+// magic-link and reset tokens, the OAuth authorization code and signed state,
+// signed-URL signatures, one-time passcodes. Matched case-insensitively.
+const secretParamNames = new Set([
+  'code',
+  'state',
+  'sig',
+  'otp',
+  'nonce',
+  'auth',
+  'apikey',
+  'api_key',
+  'api-key',
+  'session',
+  'sessionid',
+  'session_id',
+]);
+
+// Names that contain one of these are credentials whatever the prefix or
+// suffix - access_token, X-Amz-Signature, client_secret, X-Amz-Credential.
+const secretParamFragments = ['token', 'secret', 'password', 'signature', 'credential'];
+
+function isSecretParam(name) {
+  const lower = name.toLowerCase();
+  if (secretParamNames.has(lower)) {
+    return true;
+  }
+  return secretParamFragments.some((fragment) => lower.includes(fragment));
+}
+
+// A URL fit for an access log. The query string stays - it is often what
+// distinguishes one page view from the next - but the value of every
+// credential-like parameter is replaced with "[redacted]". The browser echoes
+// the page's full URL back as the Referer of every fetch that page makes, so
+// the magic-link verify page or the OAuth consent page would otherwise write
+// its token or signed state into the log store on each request. The fragment
+// is dropped: a browser never sends it in a Referer, and implicit-flow tokens
+// travel there. Returns undefined for a missing value. Works on relative URLs
+// too, so a malformed or path-only header is still visible.
+function redactUrlQuery(url) {
+  if (typeof url !== 'string' || url === '') {
+    return undefined;
+  }
+  const withoutFragment = url.split('#')[0];
+  const queryStart = withoutFragment.indexOf('?');
+  if (queryStart === -1) {
+    return withoutFragment;
+  }
+  const base = withoutFragment.slice(0, queryStart);
+  const params = new URLSearchParams(withoutFragment.slice(queryStart + 1));
+  for (const name of params.keys()) {
+    if (isSecretParam(name)) {
+      params.set(name, '[redacted]');
+    }
+  }
+  return `${base}?${params.toString()}`;
+}
+
+export default redactUrlQuery;

package/lib/server/log/redactUrlQuery.test.mjs

@@ -0,0 +1,73 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import redactUrlQuery from './redactUrlQuery.js';
+
+test('redactUrlQuery redacts the magic-link token and keeps the other parameters', () => {
+  expect(
+    redactUrlQuery(
+      'https://app.example.com/api/auth/magic-link/verify?token=abc123&callbackURL=%2Fhome'
+    )
+  ).toEqual(
+    'https://app.example.com/api/auth/magic-link/verify?token=%5Bredacted%5D&callbackURL=%2Fhome'
+  );
+});
+
+test('redactUrlQuery redacts the signed OAuth state, sig and code', () => {
+  expect(
+    redactUrlQuery('https://app.example.com/oauth-consent?client_id=app&state=xyz&sig=abc&code=q')
+  ).toEqual(
+    'https://app.example.com/oauth-consent?client_id=app&state=%5Bredacted%5D&sig=%5Bredacted%5D&code=%5Bredacted%5D'
+  );
+});
+
+test('redactUrlQuery matches credential names case-insensitively and by fragment', () => {
+  expect(
+    redactUrlQuery(
+      'https://bucket.s3.amazonaws.com/uploads/file.pdf?X-Amz-Credential=AKIA&X-Amz-Signature=deadbeef&X-Amz-Expires=300&access_token=t&client_secret=s'
+    )
+  ).toEqual(
+    'https://bucket.s3.amazonaws.com/uploads/file.pdf?X-Amz-Credential=%5Bredacted%5D&X-Amz-Signature=%5Bredacted%5D&X-Amz-Expires=300&access_token=%5Bredacted%5D&client_secret=%5Bredacted%5D'
+  );
+});
+
+test('redactUrlQuery leaves an ordinary page query untouched', () => {
+  expect(redactUrlQuery('https://app.example.com/orders?status=open&page=2')).toEqual(
+    'https://app.example.com/orders?status=open&page=2'
+  );
+  expect(redactUrlQuery('https://app.example.com/orders')).toEqual(
+    'https://app.example.com/orders'
+  );
+});
+
+test('redactUrlQuery drops the fragment', () => {
+  expect(redactUrlQuery('https://app.example.com/callback?page=1#access_token=abc')).toEqual(
+    'https://app.example.com/callback?page=1'
+  );
+});
+
+test('redactUrlQuery returns undefined for a missing header', () => {
+  expect(redactUrlQuery(undefined)).toBeUndefined();
+  expect(redactUrlQuery(null)).toBeUndefined();
+  expect(redactUrlQuery('')).toBeUndefined();
+});
+
+test('redactUrlQuery redacts a value that is not an absolute URL', () => {
+  expect(redactUrlQuery('/oauth-select-organization?state=xyz&sig=abc&org=acme')).toEqual(
+    '/oauth-select-organization?state=%5Bredacted%5D&sig=%5Bredacted%5D&org=acme'
+  );
+  expect(redactUrlQuery('not a url')).toEqual('not a url');
+});

package/lib/server/{auth/getServerSession.js → log/serializeErrorForLog.js}

@@ -14,15 +14,12 @@
   limitations under the License.
 */
 
-import { getServerSession as getNextAuthServerSession } from 'next-auth/next';
+import { serializer } from '@lowdefy/helpers';
 
-import authJson from '../../build/auth.js';
+import projectErrorForLog from './projectErrorForLog.js';
 
-function getServerSession({ authOptions, req, res }) {
-  if (authJson.configured === true) {
-    return getNextAuthServerSession(req, res, authOptions);
-  }
-  return undefined;
+function serializeErrorForLog(error) {
+  return serializer.serialize(error, { projectError: projectErrorForLog })?.['~e'] ?? error;
 }
 
-export default getServerSession;
+export default serializeErrorForLog;

package/lib/server/log/serializeErrorForLog.test.mjs

@@ -0,0 +1,325 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { OperatorError, RequestError, UserError } from '@lowdefy/errors';
+
+import maskCredentialKeys from './maskCredentialKeys.js';
+import projectErrorForLog from './projectErrorForLog.js';
+import serializeErrorForLog from './serializeErrorForLog.js';
+
+const allowedErrorKeys = new Set([
+  'name',
+  'message',
+  'stack',
+  'code',
+  'statusCode',
+  'cause',
+  'configKey',
+  'source',
+  'config',
+  'handled',
+  'isLowdefyError',
+  'received',
+  'typeName',
+  'location',
+  'service',
+  'hint',
+  'methodName',
+  'metaData',
+  'blockId',
+  'pageId',
+  'isReject',
+]);
+
+// Every serialized error node carries `stack`; free-form values under
+// `received` in these fixtures never do.
+function collectErrorNodes(value, nodes = []) {
+  if (value === null || typeof value !== 'object') return nodes;
+  if (!Array.isArray(value) && Object.hasOwn(value, 'stack')) nodes.push(value);
+  Object.values(value).forEach((item) => collectErrorNodes(item, nodes));
+  return nodes;
+}
+
+function createAxiosError() {
+  const error = new Error('Request failed with status code 401');
+  error.name = 'AxiosError';
+  error.code = 'ERR_BAD_REQUEST';
+  error.config = {
+    auth: { username: 'svc-user', password: 'planted-config-password' },
+    params: { api_key: 'planted-config-param' },
+    headers: { Authorization: 'Bearer planted-config-header' },
+    baseURL: 'https://api.example.com',
+  };
+  error.request = { path: '/v1/items' };
+  error.response = { status: 401, data: { detail: 'planted-response-body' } };
+  return error;
+}
+
+test('serializeErrorForLog drops axios config, request and response and keeps code and statusCode', () => {
+  const serialized = serializeErrorForLog(createAxiosError());
+  expect(serialized).toEqual({
+    name: 'AxiosError',
+    message: 'Request failed with status code 401',
+    stack: expect.any(String),
+    code: 'ERR_BAD_REQUEST',
+    statusCode: 401,
+  });
+  expect(JSON.stringify(serialized)).not.toMatch(/planted/);
+});
+
+test('serializeErrorForLog drops axios fields on the cause of a RequestError', () => {
+  const error = new RequestError(undefined, {
+    cause: createAxiosError(),
+    typeName: 'AxiosHttp',
+    configKey: 'key-1',
+  });
+  const serialized = serializeErrorForLog(error);
+  expect(serialized.code).toEqual('ERR_BAD_REQUEST');
+  expect(serialized.statusCode).toEqual(401);
+  expect(serialized.typeName).toEqual('AxiosHttp');
+  expect(serialized.configKey).toEqual('key-1');
+  expect(serialized.cause).toEqual({
+    name: 'AxiosError',
+    message: 'Request failed with status code 401',
+    stack: expect.any(String),
+    code: 'ERR_BAD_REQUEST',
+    statusCode: 401,
+  });
+  expect(JSON.stringify(serialized)).not.toMatch(/planted/);
+});
+
+test('serializeErrorForLog keeps a pg error code and drops detail, schema, table and constraint', () => {
+  const error = new Error('duplicate key value violates unique constraint "users_email_key"');
+  error.code = '23505';
+  error.detail = 'Key (email)=(planted@example.com) already exists.';
+  error.schema = 'public';
+  error.table = 'users';
+  error.constraint = 'users_email_key';
+  const serialized = serializeErrorForLog(error);
+  expect(serialized).toEqual({
+    name: 'Error',
+    message: 'duplicate key value violates unique constraint "users_email_key"',
+    stack: expect.any(String),
+    code: '23505',
+  });
+});
+
+// Built by hand in Node's shape: a TypeError thrown by `new URL` comes from
+// the main realm, which is not `instanceof Error` inside Jest's VM context.
+test('serializeErrorForLog drops input from a Node ERR_INVALID_URL error', () => {
+  const error = new TypeError('Invalid URL');
+  error.code = 'ERR_INVALID_URL';
+  error.input = 'https://user:planted@example';
+  const serialized = serializeErrorForLog(error);
+  expect(serialized.code).toEqual('ERR_INVALID_URL');
+  expect(Object.keys(serialized)).not.toContain('input');
+});
+
+test('serializeErrorForLog masks credential keys in received and keeps the other received properties', () => {
+  const received = {
+    url: 'https://api.example.com/items',
+    method: 'get',
+    headers: { Authorization: 'Bearer runtime-token-1', Accept: 'application/json' },
+    params: { access_token: 'runtime-token-2', page: 2 },
+    'x-api-key': 'runtime-token-3',
+  };
+  const error = new RequestError('Upstream failed.', {
+    typeName: 'AxiosHttp',
+    received,
+    cause: new OperatorError('Inner failed.', { typeName: '_step', received }),
+  });
+  const expectedReceived = {
+    url: 'https://api.example.com/items',
+    method: 'get',
+    headers: { Authorization: '[REDACTED]', Accept: 'application/json' },
+    params: { access_token: '[REDACTED]', page: 2 },
+    'x-api-key': '[REDACTED]',
+  };
+  const serialized = serializeErrorForLog(error);
+  expect(serialized.received).toEqual(expectedReceived);
+  expect(serialized.cause.received).toEqual(expectedReceived);
+  expect(JSON.stringify(serialized)).not.toMatch(/runtime-token/);
+});
+
+test('serializeErrorForLog does not mutate the received it masks', () => {
+  const received = { headers: { Authorization: 'Bearer runtime-token' } };
+  serializeErrorForLog(new RequestError('Upstream failed.', { received }));
+  expect(received).toEqual({ headers: { Authorization: 'Bearer runtime-token' } });
+});
+
+test('serializeErrorForLog projects an Error nested seven levels deep inside a cause property', () => {
+  let nested = createAxiosError();
+  for (let level = 7; level >= 1; level -= 1) {
+    nested = new RequestError(`Level ${level}.`, { received: nested });
+  }
+  // An explicit received, so the top node does not inherit the cause's.
+  const error = new RequestError('Top.', {
+    received: { page: 1 },
+    cause: new OperatorError('Cause.', { received: nested }),
+  });
+  const serialized = serializeErrorForLog(error);
+
+  let node = serialized.cause.received;
+  for (let level = 1; level <= 7; level += 1) {
+    expect(node.message).toEqual(`Level ${level}.`);
+    node = node.received;
+  }
+  expect(node.name).toEqual('AxiosError');
+  expect(node.statusCode).toEqual(401);
+
+  const errorNodes = collectErrorNodes(serialized);
+  expect(errorNodes).toHaveLength(10);
+  errorNodes.forEach((errorNode) => {
+    Object.keys(errorNode).forEach((key) => {
+      expect(allowedErrorKeys.has(key)).toBe(true);
+    });
+  });
+  expect(JSON.stringify(serialized)).not.toMatch(/planted/);
+});
+
+test('serializeErrorForLog keeps UserError metaData, blockId, pageId and isReject', () => {
+  const error = new UserError('Please fill in the form.', {
+    blockId: 'submit_button',
+    pageId: 'orders',
+    isReject: true,
+    metaData: { step: 'validate' },
+  });
+  const serialized = serializeErrorForLog(error);
+  expect(serialized).toEqual({
+    name: 'UserError',
+    message: 'Please fill in the form.',
+    stack: expect.any(String),
+    isLowdefyError: true,
+    blockId: 'submit_button',
+    pageId: 'orders',
+    isReject: true,
+    metaData: { step: 'validate' },
+  });
+});
+
+test('serializeErrorForLog keeps Lowdefy fields on an error that has a Lowdefy class name but not the class', () => {
+  const error = new Error('Not allowed.');
+  error.name = 'AuthorizationError';
+  error.configKey = 'key-2';
+  error.isLowdefyError = true;
+  error.internalState = 'dropped';
+  const serialized = serializeErrorForLog(error);
+  expect(serialized).toEqual({
+    name: 'AuthorizationError',
+    message: 'Not allowed.',
+    stack: expect.any(String),
+    configKey: 'key-2',
+    isLowdefyError: true,
+  });
+});
+
+test('projectErrorForLog drops Lowdefy field names from a non-Lowdefy error', () => {
+  const error = new Error('Library failure.');
+  error.received = { password: 'planted' };
+  error.source = 'library-internal';
+  error.location = 'somewhere';
+  const projected = projectErrorForLog(error);
+  expect(projected.received).toBeUndefined();
+  expect(projected.source).toBeUndefined();
+  expect(projected.location).toBeUndefined();
+});
+
+test('projectErrorForLog reads statusCode from the node and passes the cause through for the walk', () => {
+  const cause = new Error('Inner.');
+  const error = new Error('Outer.', { cause });
+  error.status = 503;
+  const projected = projectErrorForLog(error);
+  expect(projected.statusCode).toEqual(503);
+  expect(projected.cause).toBe(cause);
+});
+
+test('maskCredentialKeys masks keys containing each credential word after lower-casing and removing - and _', () => {
+  expect(
+    maskCredentialKeys({
+      Authorization: 'a',
+      access_token: 'b',
+      'x-api-key': 'c',
+      client_secret: 'd',
+      Password: 'e',
+      Cookie: 'f',
+      API_KEY: 'g',
+      tokenCount: 3,
+      name: 'kept',
+    })
+  ).toEqual({
+    Authorization: '[REDACTED]',
+    access_token: '[REDACTED]',
+    'x-api-key': '[REDACTED]',
+    client_secret: '[REDACTED]',
+    Password: '[REDACTED]',
+    Cookie: '[REDACTED]',
+    API_KEY: '[REDACTED]',
+    tokenCount: '[REDACTED]',
+    name: 'kept',
+  });
+});
+
+test('maskCredentialKeys replaces a whole object value under a credential key', () => {
+  expect(maskCredentialKeys({ tokens: { access: 'a', refresh: 'b' } })).toEqual({
+    tokens: '[REDACTED]',
+  });
+});
+
+test('maskCredentialKeys recurses into arrays and nested objects', () => {
+  expect(
+    maskCredentialKeys({ items: [{ secret: 'a', id: 1 }, [{ cookie: 'b' }], 'plain'] })
+  ).toEqual({ items: [{ secret: '[REDACTED]', id: 1 }, [{ cookie: '[REDACTED]' }], 'plain'] });
+});
+
+test('maskCredentialKeys returns primitives, Dates, Errors and class instances unchanged', () => {
+  class Client {
+    constructor() {
+      this.password = 'internal';
+    }
+  }
+  const date = new Date(0);
+  const error = new Error('x');
+  const client = new Client();
+  expect(maskCredentialKeys('text')).toEqual('text');
+  expect(maskCredentialKeys(undefined)).toBeUndefined();
+  expect(maskCredentialKeys(date)).toBe(date);
+  expect(maskCredentialKeys(error)).toBe(error);
+  expect(maskCredentialKeys(client)).toBe(client);
+});
+
+test('serializeErrorForLog marks a class instance in received by type name only', () => {
+  class Client {
+    constructor() {
+      this.password = 'planted';
+    }
+  }
+  const serialized = serializeErrorForLog(
+    new RequestError('Failed.', { received: { client: new Client() } })
+  );
+  expect(serialized.received).toEqual({ client: '[Object: Client]' });
+});
+
+test('serializeErrorForLog marks a cycle in received as circular', () => {
+  const received = { name: 'loop' };
+  received.self = received;
+  const serialized = serializeErrorForLog(new RequestError('Failed.', { received }));
+  expect(serialized.received).toEqual({ name: 'loop', self: '[Circular]' });
+});
+
+test('serializeErrorForLog returns a non-Error value unchanged', () => {
+  expect(serializeErrorForLog('plain string')).toEqual('plain string');
+  expect(serializeErrorForLog({ message: 'object' })).toEqual({ message: 'object' });
+});

package/lib/server/scrubSecrets.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { createSecretScrubber, getSecretsFromEnv } from '@lowdefy/node-utils';
+
+const scrubSecrets = createSecretScrubber({ secrets: getSecretsFromEnv() });
+
+export default scrubSecrets;

package/lib/server/sentry/captureSentryError.js

@@ -14,7 +14,10 @@
   limitations under the License.
 */
 
-import * as Sentry from '@sentry/nextjs';
+import * as Sentry from '@sentry/node';
+import { type } from '@lowdefy/helpers';
+
+import serializeErrorForLog from '../log/serializeErrorForLog.js';
 
 function captureSentryError({ error, context, configLocation }) {
   // No-op if Sentry not initialized (DSN not set)
@@ -30,6 +33,10 @@ function captureSentryError({ error, context, configLocation }) {
     tags.pageId = context.pageId;
   }
 
+  if (!type.isNone(context?.rid)) {
+    tags.requestId = context.rid;
+  }
+
   if (error?.blockId) {
     tags.blockId = error.blockId;
   }
@@ -48,6 +55,11 @@ function captureSentryError({ error, context, configLocation }) {
     extra.configKey = error.configKey;
   }
 
+  // Sentry's own serialization of the exception carries only names, messages and stacks, so
+  // the log's projection is what gives Sentry the error's other fields - the same ones the log
+  // keeps, with the library fields it drops left out.
+  extra.error = serializeErrorForLog(error);
+
   Sentry.captureException(error, {
     tags,
     extra,

package/lib/server/sentry/captureSentryError.test.mjs

@@ -0,0 +1,104 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { jest } from '@jest/globals';
+import { RequestError } from '@lowdefy/errors';
+
+const captureException = jest.fn();
+
+jest.unstable_mockModule('@sentry/node', () => ({ captureException }));
+
+process.env.SENTRY_DSN = 'https://public@o0.ingest.sentry.io/1';
+
+const { default: captureSentryError } = await import('./captureSentryError.js');
+
+function createAxiosError() {
+  const error = new Error('Request failed with status code 401');
+  error.name = 'AxiosError';
+  error.code = 'ERR_BAD_REQUEST';
+  error.config = {
+    auth: { username: 'svc-user', password: 'planted-config-password' },
+    params: { api_key: 'planted-config-param' },
+    headers: { Authorization: 'Bearer planted-config-header' },
+    baseURL: 'https://api.example.com',
+  };
+  error.response = { status: 401, data: { detail: 'planted-response-body' } };
+  return error;
+}
+
+function createRequestError() {
+  return new RequestError(undefined, {
+    cause: createAxiosError(),
+    typeName: 'AxiosHttp',
+    configKey: 'key-1',
+    received: {
+      url: 'https://api.example.com/items',
+      headers: { Authorization: 'Bearer runtime-token', Accept: 'application/json' },
+    },
+  });
+}
+
+test('captureSentryError sends the log projection as extra.error, without axios config and with received credential keys masked', () => {
+  const error = createRequestError();
+  captureSentryError({ error, context: { rid: 'req-1', pageId: 'orders' } });
+  expect(captureException).toHaveBeenCalledTimes(1);
+  const [captured, { extra }] = captureException.mock.calls[0];
+  expect(captured).toBe(error);
+  expect(extra.error.typeName).toEqual('AxiosHttp');
+  expect(extra.error.statusCode).toEqual(401);
+  expect(extra.error.received).toEqual({
+    url: 'https://api.example.com/items',
+    headers: { Authorization: '[REDACTED]', Accept: 'application/json' },
+  });
+  expect(extra.error.cause).toEqual({
+    name: 'AxiosError',
+    message: 'Request failed with status code 401',
+    stack: expect.any(String),
+    code: 'ERR_BAD_REQUEST',
+    statusCode: 401,
+  });
+  expect(JSON.stringify(extra)).not.toMatch(/planted|runtime-token/);
+});
+
+test('captureSentryError tags the request id and keeps configKey and configLocation in extra', () => {
+  const configLocation = { source: 'pages/orders.yaml:12', config: 'root.pages[0]' };
+  captureSentryError({
+    error: createRequestError(),
+    context: { rid: 'req-1', pageId: 'orders' },
+    configLocation,
+  });
+  const [, { tags, extra }] = captureException.mock.calls[0];
+  expect(tags).toEqual({ pageId: 'orders', requestId: 'req-1' });
+  expect(extra.configKey).toEqual('key-1');
+  expect(extra.configLocation).toEqual(configLocation);
+});
+
+test('captureSentryError leaves out the requestId tag when the context has no request id', () => {
+  captureSentryError({ error: new Error('Failed.'), context: {} });
+  const [, { tags }] = captureException.mock.calls[0];
+  expect(Object.keys(tags)).not.toContain('requestId');
+});
+
+test('captureSentryError does nothing when SENTRY_DSN is not set', () => {
+  const dsn = process.env.SENTRY_DSN;
+  delete process.env.SENTRY_DSN;
+  try {
+    captureSentryError({ error: new Error('Failed.'), context: { rid: 'req-1' } });
+  } finally {
+    process.env.SENTRY_DSN = dsn;
+  }
+  expect(captureException).not.toHaveBeenCalled();
+});