@northlight-systems/cloud-sentry 0.0.0-stage → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,377 @@
1
+ Copyright (c) 2026 Northlight Systems.
2
+
3
+ This package is licensed under the Mozilla Public License, version 2.0 (below).
4
+
5
+ Mozilla Public License Version 2.0
6
+ ==================================
7
+
8
+ 1. Definitions
9
+ --------------
10
+
11
+ 1.1. "Contributor"
12
+ means each individual or legal entity that creates, contributes to
13
+ the creation of, or owns Covered Software.
14
+
15
+ 1.2. "Contributor Version"
16
+ means the combination of the Contributions of others (if any) used
17
+ by a Contributor and that particular Contributor's Contribution.
18
+
19
+ 1.3. "Contribution"
20
+ means Covered Software of a particular Contributor.
21
+
22
+ 1.4. "Covered Software"
23
+ means Source Code Form to which the initial Contributor has attached
24
+ the notice in Exhibit A, the Executable Form of such Source Code
25
+ Form, and Modifications of such Source Code Form, in each case
26
+ including portions thereof.
27
+
28
+ 1.5. "Incompatible With Secondary Licenses"
29
+ means
30
+
31
+ (a) that the initial Contributor has attached the notice described
32
+ in Exhibit B to the Covered Software; or
33
+
34
+ (b) that the Covered Software was made available under the terms of
35
+ version 1.1 or earlier of the License, but not also under the
36
+ terms of a Secondary License.
37
+
38
+ 1.6. "Executable Form"
39
+ means any form of the work other than Source Code Form.
40
+
41
+ 1.7. "Larger Work"
42
+ means a work that combines Covered Software with other material, in
43
+ a separate file or files, that is not Covered Software.
44
+
45
+ 1.8. "License"
46
+ means this document.
47
+
48
+ 1.9. "Licensable"
49
+ means having the right to grant, to the maximum extent possible,
50
+ whether at the time of the initial grant or subsequently, any and
51
+ all of the rights conveyed by this License.
52
+
53
+ 1.10. "Modifications"
54
+ means any of the following:
55
+
56
+ (a) any file in Source Code Form that results from an addition to,
57
+ deletion from, or modification of the contents of Covered
58
+ Software; or
59
+
60
+ (b) any new file in Source Code Form that contains any Covered
61
+ Software.
62
+
63
+ 1.11. "Patent Claims" of a Contributor
64
+ means any patent claim(s), including without limitation, method,
65
+ process, and apparatus claims, in any patent Licensable by such
66
+ Contributor that would be infringed, but for the grant of the
67
+ License, by the making, using, selling, offering for sale, having
68
+ made, import, or transfer of either its Contributions or its
69
+ Contributor Version.
70
+
71
+ 1.12. "Secondary License"
72
+ means either the GNU General Public License, Version 2.0, the GNU
73
+ Lesser General Public License, Version 2.1, the GNU Affero General
74
+ Public License, Version 3.0, or any later versions of those
75
+ licenses.
76
+
77
+ 1.13. "Source Code Form"
78
+ means the form of the work preferred for making modifications.
79
+
80
+ 1.14. "You" (or "Your")
81
+ means an individual or a legal entity exercising rights under this
82
+ License. For legal entities, "You" includes any entity that
83
+ controls, is controlled by, or is under common control with You. For
84
+ purposes of this definition, "control" means (a) the power, direct
85
+ or indirect, to cause the direction or management of such entity,
86
+ whether by contract or otherwise, or (b) ownership of more than
87
+ fifty percent (50%) of the outstanding shares or beneficial
88
+ ownership of such entity.
89
+
90
+ 2. License Grants and Conditions
91
+ --------------------------------
92
+
93
+ 2.1. Grants
94
+
95
+ Each Contributor hereby grants You a world-wide, royalty-free,
96
+ non-exclusive license:
97
+
98
+ (a) under intellectual property rights (other than patent or trademark)
99
+ Licensable by such Contributor to use, reproduce, make available,
100
+ modify, display, perform, distribute, and otherwise exploit its
101
+ Contributions, either on an unmodified basis, with Modifications, or
102
+ as part of a Larger Work; and
103
+
104
+ (b) under Patent Claims of such Contributor to make, use, sell, offer
105
+ for sale, have made, import, and otherwise transfer either its
106
+ Contributions or its Contributor Version.
107
+
108
+ 2.2. Effective Date
109
+
110
+ The licenses granted in Section 2.1 with respect to any Contribution
111
+ become effective for each Contribution on the date the Contributor first
112
+ distributes such Contribution.
113
+
114
+ 2.3. Limitations on Grant Scope
115
+
116
+ The licenses granted in this Section 2 are the only rights granted under
117
+ this License. No additional rights or licenses will be implied from the
118
+ distribution or licensing of Covered Software under this License.
119
+ Notwithstanding Section 2.1(b) above, no patent license is granted by a
120
+ Contributor:
121
+
122
+ (a) for any code that a Contributor has removed from Covered Software;
123
+ or
124
+
125
+ (b) for infringements caused by: (i) Your and any other third party's
126
+ modifications of Covered Software, or (ii) the combination of its
127
+ Contributions with other software (except as part of its Contributor
128
+ Version); or
129
+
130
+ (c) under Patent Claims infringed by Covered Software in the absence of
131
+ its Contributions.
132
+
133
+ This License does not grant any rights in the trademarks, service marks,
134
+ or logos of any Contributor (except as may be necessary to comply with
135
+ the notice requirements in Section 3.4).
136
+
137
+ 2.4. Subsequent Licenses
138
+
139
+ No Contributor makes additional grants as a result of Your choice to
140
+ distribute the Covered Software under a subsequent version of this
141
+ License (see Section 10.2) or under the terms of a Secondary License (if
142
+ permitted under the terms of Section 3.3).
143
+
144
+ 2.5. Representation
145
+
146
+ Each Contributor represents that the Contributor believes its
147
+ Contributions are its original creation(s) or it has sufficient rights
148
+ to grant the rights to its Contributions conveyed by this License.
149
+
150
+ 2.6. Fair Use
151
+
152
+ This License is not intended to limit any rights You have under
153
+ applicable copyright doctrines of fair use, fair dealing, or other
154
+ equivalents.
155
+
156
+ 2.7. Conditions
157
+
158
+ Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
159
+ in Section 2.1.
160
+
161
+ 3. Responsibilities
162
+ -------------------
163
+
164
+ 3.1. Distribution of Source Form
165
+
166
+ All distribution of Covered Software in Source Code Form, including any
167
+ Modifications that You create or to which You contribute, must be under
168
+ the terms of this License. You must inform recipients that the Source
169
+ Code Form of the Covered Software is governed by the terms of this
170
+ License, and how they can obtain a copy of this License. You may not
171
+ attempt to alter or restrict the recipients' rights in the Source Code
172
+ Form.
173
+
174
+ 3.2. Distribution of Executable Form
175
+
176
+ If You distribute Covered Software in Executable Form then:
177
+
178
+ (a) such Covered Software must also be made available in Source Code
179
+ Form, as described in Section 3.1, and You must inform recipients of
180
+ the Executable Form how they can obtain a copy of such Source Code
181
+ Form by reasonable means in a timely manner, at a charge no more
182
+ than the cost of distribution to the recipient; and
183
+
184
+ (b) You may distribute such Executable Form under the terms of this
185
+ License, or sublicense it under different terms, provided that the
186
+ license for the Executable Form does not attempt to limit or alter
187
+ the recipients' rights in the Source Code Form under this License.
188
+
189
+ 3.3. Distribution of a Larger Work
190
+
191
+ You may create and distribute a Larger Work under terms of Your choice,
192
+ provided that You also comply with the requirements of this License for
193
+ the Covered Software. If the Larger Work is a combination of Covered
194
+ Software with a work governed by one or more Secondary Licenses, and the
195
+ Covered Software is not Incompatible With Secondary Licenses, this
196
+ License permits You to additionally distribute such Covered Software
197
+ under the terms of such Secondary License(s), so that the recipient of
198
+ the Larger Work may, at their option, further distribute the Covered
199
+ Software under the terms of either this License or such Secondary
200
+ License(s).
201
+
202
+ 3.4. Notices
203
+
204
+ You may not remove or alter the substance of any license notices
205
+ (including copyright notices, patent notices, disclaimers of warranty,
206
+ or limitations of liability) contained within the Source Code Form of
207
+ the Covered Software, except that You may alter any license notices to
208
+ the extent required to remedy known factual inaccuracies.
209
+
210
+ 3.5. Application of Additional Terms
211
+
212
+ You may choose to offer, and to charge a fee for, warranty, support,
213
+ indemnity or liability obligations to one or more recipients of Covered
214
+ Software. However, You may do so only on Your own behalf, and not on
215
+ behalf of any Contributor. You must make it absolutely clear that any
216
+ such warranty, support, indemnity, or liability obligation is offered by
217
+ You alone, and You hereby agree to indemnify every Contributor for any
218
+ liability incurred by such Contributor as a result of warranty, support,
219
+ indemnity or liability terms You offer. You may include additional
220
+ disclaimers of warranty and limitations of liability specific to any
221
+ jurisdiction.
222
+
223
+ 4. Inability to Comply Due to Statute or Regulation
224
+ ---------------------------------------------------
225
+
226
+ If it is impossible for You to comply with any of the terms of this
227
+ License with respect to some or all of the Covered Software due to
228
+ statute, judicial order, or regulation then You must: (a) comply with
229
+ the terms of this License to the maximum extent possible; and (b)
230
+ describe the limitations and the code they affect. Such description must
231
+ be placed in a text file included with all distributions of the Covered
232
+ Software under this License. Except to the extent prohibited by statute
233
+ or regulation, such description must be sufficiently detailed for a
234
+ recipient of ordinary skill to be able to understand it.
235
+
236
+ 5. Termination
237
+ --------------
238
+
239
+ 5.1. The rights granted under this License will terminate automatically
240
+ if You fail to comply with any of its terms. However, if You become
241
+ compliant, then the rights granted under this License from a particular
242
+ Contributor are reinstated (a) provisionally, unless and until such
243
+ Contributor explicitly and finally terminates Your grants, and (b) on an
244
+ ongoing basis, if such Contributor fails to notify You of the
245
+ non-compliance by some reasonable means prior to 60 days after You have
246
+ come back into compliance. Moreover, Your grants from a particular
247
+ Contributor are reinstated on an ongoing basis if such Contributor
248
+ notifies You of the non-compliance by some reasonable means, this is the
249
+ first time You have received notice of non-compliance with this License
250
+ from such Contributor, and You become compliant prior to 30 days after
251
+ Your receipt of the notice.
252
+
253
+ 5.2. If You initiate litigation against any entity by asserting a patent
254
+ infringement claim (excluding declaratory judgment actions,
255
+ counter-claims, and cross-claims) alleging that a Contributor Version
256
+ directly or indirectly infringes any patent, then the rights granted to
257
+ You by any and all Contributors for the Covered Software under Section
258
+ 2.1 of this License shall terminate.
259
+
260
+ 5.3. In the event of termination under Sections 5.1 or 5.2 above, all
261
+ end user license agreements (excluding distributors and resellers) which
262
+ have been validly granted by You or Your distributors under this License
263
+ prior to termination shall survive termination.
264
+
265
+ ************************************************************************
266
+ * *
267
+ * 6. Disclaimer of Warranty *
268
+ * ------------------------- *
269
+ * *
270
+ * Covered Software is provided under this License on an "as is" *
271
+ * basis, without warranty of any kind, either expressed, implied, or *
272
+ * statutory, including, without limitation, warranties that the *
273
+ * Covered Software is free of defects, merchantable, fit for a *
274
+ * particular purpose or non-infringing. The entire risk as to the *
275
+ * quality and performance of the Covered Software is with You. *
276
+ * Should any Covered Software prove defective in any respect, You *
277
+ * (not any Contributor) assume the cost of any necessary servicing, *
278
+ * repair, or correction. This disclaimer of warranty constitutes an *
279
+ * essential part of this License. No use of any Covered Software is *
280
+ * authorized under this License except under this disclaimer. *
281
+ * *
282
+ ************************************************************************
283
+
284
+ ************************************************************************
285
+ * *
286
+ * 7. Limitation of Liability *
287
+ * -------------------------- *
288
+ * *
289
+ * Under no circumstances and under no legal theory, whether tort *
290
+ * (including negligence), contract, or otherwise, shall any *
291
+ * Contributor, or anyone who distributes Covered Software as *
292
+ * permitted above, be liable to You for any direct, indirect, *
293
+ * special, incidental, or consequential damages of any character *
294
+ * including, without limitation, damages for lost profits, loss of *
295
+ * goodwill, work stoppage, computer failure or malfunction, or any *
296
+ * and all other commercial damages or losses, even if such party *
297
+ * shall have been informed of the possibility of such damages. This *
298
+ * limitation of liability shall not apply to liability for death or *
299
+ * personal injury resulting from such party's negligence to the *
300
+ * extent applicable law prohibits such limitation. Some *
301
+ * jurisdictions do not allow the exclusion or limitation of *
302
+ * incidental or consequential damages, so this exclusion and *
303
+ * limitation may not apply to You. *
304
+ * *
305
+ ************************************************************************
306
+
307
+ 8. Litigation
308
+ -------------
309
+
310
+ Any litigation relating to this License may be brought only in the
311
+ courts of a jurisdiction where the defendant maintains its principal
312
+ place of business and such litigation shall be governed by laws of that
313
+ jurisdiction, without reference to its conflict-of-law provisions.
314
+ Nothing in this Section shall prevent a party's ability to bring
315
+ cross-claims or counter-claims.
316
+
317
+ 9. Miscellaneous
318
+ ----------------
319
+
320
+ This License represents the complete agreement concerning the subject
321
+ matter hereof. If any provision of this License is held to be
322
+ unenforceable, such provision shall be reformed only to the extent
323
+ necessary to make it enforceable. Any law or regulation which provides
324
+ that the language of a contract shall be construed against the drafter
325
+ shall not be used to construe this License against a Contributor.
326
+
327
+ 10. Versions of the License
328
+ ---------------------------
329
+
330
+ 10.1. New Versions
331
+
332
+ Mozilla Foundation is the license steward. Except as provided in Section
333
+ 10.3, no one other than the license steward has the right to modify or
334
+ publish new versions of this License. Each version will be given a
335
+ distinguishing version number.
336
+
337
+ 10.2. Effect of New Versions
338
+
339
+ You may distribute the Covered Software under the terms of the version
340
+ of the License under which You originally received the Covered Software,
341
+ or under the terms of any subsequent version published by the license
342
+ steward.
343
+
344
+ 10.3. Modified Versions
345
+
346
+ If you create software not governed by this License, and you want to
347
+ create a new license for such software, you may create and use a
348
+ modified version of this License if you rename the license and remove
349
+ any references to the name of the license steward (except to note that
350
+ such modified license differs from this License).
351
+
352
+ 10.4. Distributing Source Code Form that is Incompatible With Secondary
353
+ Licenses
354
+
355
+ If You choose to distribute Source Code Form that is Incompatible With
356
+ Secondary Licenses under the terms of this version of the License, the
357
+ notice described in Exhibit B of this License must be attached.
358
+
359
+ Exhibit A - Source Code Form License Notice
360
+ -------------------------------------------
361
+
362
+ This Source Code Form is subject to the terms of the Mozilla Public
363
+ License, v. 2.0. If a copy of the MPL was not distributed with this
364
+ file, You can obtain one at https://mozilla.org/MPL/2.0/.
365
+
366
+ If it is not possible or desirable to put the notice in a particular
367
+ file, then You may include the notice in a location (such as a LICENSE
368
+ file in a relevant directory) where a recipient would be likely to look
369
+ for such a notice.
370
+
371
+ You may add additional accurate notices of copyright ownership.
372
+
373
+ Exhibit B - "Incompatible With Secondary Licenses" Notice
374
+ ---------------------------------------------------------
375
+
376
+ This Source Code Form is "Incompatible With Secondary Licenses", as
377
+ defined by the Mozilla Public License, v. 2.0.
@@ -0,0 +1,81 @@
1
+ import type { BrowserSentryConfig } from "./config.js";
2
+ import type { LimiterEvent, RepeatLimiterOptions } from "./limiter.js";
3
+ import type { MaskPath, ScrubbableBreadcrumb, ScrubbableEvent } from "./scrub.js";
4
+ /**
5
+ * The same-origin path every browser bundle posts its Sentry envelopes to. A Cloudflare Worker
6
+ * answers it on every `*.northlight.ai` host and forwards to Sentry, so tracker blockers that drop
7
+ * `*.ingest.us.sentry.io` (Arc's built-in blocker) cannot eat browser errors. The path avoids
8
+ * words that blocker lists match ("sentry", "tunnel", "log", "track", "report").
9
+ */
10
+ export declare const BROWSER_ERRORS_PATH = "/_nl/errors";
11
+ export interface BrowserSentryOptionsInput {
12
+ /** The app name: the `service` tag. */
13
+ service: string;
14
+ /** Rewrites a URL path that carries a secret. */
15
+ maskPath?: MaskPath;
16
+ /** The limiter's clock (epoch milliseconds), for tests. Default `Date.now`. */
17
+ now?: RepeatLimiterOptions["now"];
18
+ }
19
+ declare global {
20
+ interface Window {
21
+ __NL_SENTRY__?: BrowserSentryConfig | null;
22
+ }
23
+ }
24
+ /** Options for a browser `Sentry.init` (`@sentry/react`, or `@sentry/nextjs`'s client init). */
25
+ export interface BrowserSentryOptions {
26
+ dsn: string;
27
+ environment?: string;
28
+ release?: string;
29
+ /** Always {@link BROWSER_ERRORS_PATH}: envelopes go to the page's own origin, not Sentry's ingest host. */
30
+ tunnel: typeof BROWSER_ERRORS_PATH;
31
+ sampleRate: 1;
32
+ tracesSampleRate: 0;
33
+ propagateTraceparent: true;
34
+ sendDefaultPii: false;
35
+ allowUrls: RegExp[];
36
+ ignoreErrors: RegExp[];
37
+ initialScope: {
38
+ tags: {
39
+ service: string;
40
+ runtime: "browser";
41
+ };
42
+ };
43
+ beforeSend: <E extends ScrubbableEvent & LimiterEvent>(event: E) => E | null;
44
+ beforeBreadcrumb: <B extends ScrubbableBreadcrumb>(breadcrumb: B) => B;
45
+ }
46
+ /**
47
+ * Browser init options with the DSN, environment and release from `window.__NL_SENTRY__`.
48
+ * Returns `null` when the config script is absent or reports no DSN: no browser Sentry, page works.
49
+ * Each call creates its own repeat limiter (one per tab and `init`). `tracePropagationTargets` is
50
+ * left unset, so the SDK sends trace headers to the page's own origin only. `tunnel` is always
51
+ * {@link BROWSER_ERRORS_PATH}: on a host no errors Worker answers (local dev with a DSN) the POST gets
52
+ * the app's own 404 and the event is lost.
53
+ */
54
+ export declare function browserSentryOptions({ service, maskPath, now, }: BrowserSentryOptionsInput): BrowserSentryOptions | null;
55
+ /** The `errorInfo` React passes to its root error callbacks (React's `ErrorInfo` is assignable to it). */
56
+ interface RootErrorInfo {
57
+ componentStack?: string | null | undefined;
58
+ digest?: string | null | undefined;
59
+ }
60
+ type RootErrorHandler = (error: unknown, errorInfo: RootErrorInfo) => void;
61
+ /** Error callbacks for React 19's `createRoot` and `hydrateRoot` options. */
62
+ export interface ReactErrorHandlers {
63
+ onCaughtError: RootErrorHandler;
64
+ onUncaughtError: RootErrorHandler;
65
+ onRecoverableError: RootErrorHandler;
66
+ }
67
+ /**
68
+ * When the page URL's fragment is `#sentry-probe`, throws `Error("sentry probe")` from a timer, so
69
+ * production verification gets a minified frame to symbolicate. `initBrowserSentry` calls it; call
70
+ * it yourself right after init in an app that spreads `browserSentryOptions` into another SDK
71
+ * (growth's `@sentry/nextjs`).
72
+ */
73
+ export declare function runSentryProbe(): void;
74
+ /**
75
+ * Initialises `@sentry/react` from `browserSentryOptions` plus `browserTracingIntegration()` (no
76
+ * transactions are sent at rate 0), without console breadcrumbs, and returns
77
+ * the error callbacks for `createRoot`/`hydrateRoot`. With no config nothing is initialised and
78
+ * the callbacks capture nothing. Runs `runSentryProbe()` after init.
79
+ */
80
+ export declare function initBrowserSentry(input: BrowserSentryOptionsInput): ReactErrorHandlers;
81
+ export {};
@@ -0,0 +1,109 @@
1
+ // No Node or Nest imports: this entry point is bundled into browsers. `@sentry/react` is an
2
+ // optional peer, needed only by `initBrowserSentry`.
3
+ import * as Sentry from "@sentry/react";
4
+ import { createRepeatLimiter } from "./limiter.js";
5
+ import { scrubBreadcrumb, scrubEvent } from "./scrub.js";
6
+ /**
7
+ * The same-origin path every browser bundle posts its Sentry envelopes to. A Cloudflare Worker
8
+ * answers it on every `*.northlight.ai` host and forwards to Sentry, so tracker blockers that drop
9
+ * `*.ingest.us.sentry.io` (Arc's built-in blocker) cannot eat browser errors. The path avoids
10
+ * words that blocker lists match ("sentry", "tunnel", "log", "track", "report").
11
+ */
12
+ export const BROWSER_ERRORS_PATH = "/_nl/errors";
13
+ /**
14
+ * Browser errors that are not ours, dropped before they become Postflight problems. Each pattern is
15
+ * anchored so that only the exact known message matches; the SDK tests it against the event message
16
+ * and against `Type: value` of its exception.
17
+ * - Microsoft Outlook SafeLinks scans the links in an email by running the page in its own script
18
+ * host, which rejects with a plain string (not an Error) from a method that host lacks.
19
+ * - `TypeError: Failed to fetch` is Chromium's message for a request that never got a response
20
+ * (offline, navigation away, blocker): a network blip on the visitor's side.
21
+ */
22
+ const IGNORED_BROWSER_ERRORS = [
23
+ /^Non-Error promise rejection captured with value: Object Not Found Matching Id:\d+, MethodName:update, ParamCount:\d+$/,
24
+ /^TypeError: Failed to fetch$/,
25
+ ];
26
+ const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
27
+ /**
28
+ * Browser init options with the DSN, environment and release from `window.__NL_SENTRY__`.
29
+ * Returns `null` when the config script is absent or reports no DSN: no browser Sentry, page works.
30
+ * Each call creates its own repeat limiter (one per tab and `init`). `tracePropagationTargets` is
31
+ * left unset, so the SDK sends trace headers to the page's own origin only. `tunnel` is always
32
+ * {@link BROWSER_ERRORS_PATH}: on a host no errors Worker answers (local dev with a DSN) the POST gets
33
+ * the app's own 404 and the event is lost.
34
+ */
35
+ export function browserSentryOptions({ service, maskPath, now, }) {
36
+ // oxlint-disable-next-line no-underscore-dangle -- the name the config script assigns
37
+ const config = window.__NL_SENTRY__;
38
+ if (!config?.dsn)
39
+ return null;
40
+ const limit = createRepeatLimiter(now ? { now } : {});
41
+ return {
42
+ dsn: config.dsn,
43
+ ...(config.environment ? { environment: config.environment } : {}),
44
+ ...(config.release ? { release: config.release } : {}),
45
+ tunnel: BROWSER_ERRORS_PATH,
46
+ sampleRate: 1,
47
+ tracesSampleRate: 0,
48
+ propagateTraceparent: true,
49
+ sendDefaultPii: false,
50
+ allowUrls: [new RegExp(`^${escapeRegExp(window.location.origin)}/`)],
51
+ ignoreErrors: IGNORED_BROWSER_ERRORS,
52
+ initialScope: { tags: { service, runtime: "browser" } },
53
+ beforeSend: (event) => {
54
+ scrubEvent(event, maskPath, true);
55
+ return limit(event);
56
+ },
57
+ beforeBreadcrumb: (breadcrumb) => {
58
+ scrubBreadcrumb(breadcrumb, maskPath);
59
+ return breadcrumb;
60
+ },
61
+ };
62
+ }
63
+ // Sentry types its `errorInfo` without `undefined`, which React's own `ErrorInfo` rejects under
64
+ // `exactOptionalPropertyTypes`; the wrapper accepts either and passes Sentry only what is set.
65
+ function rootErrorHandler() {
66
+ const capture = Sentry.reactErrorHandler();
67
+ return (error, errorInfo) => capture(error, errorInfo.componentStack == null
68
+ ? {}
69
+ : { componentStack: errorInfo.componentStack });
70
+ }
71
+ /**
72
+ * When the page URL's fragment is `#sentry-probe`, throws `Error("sentry probe")` from a timer, so
73
+ * production verification gets a minified frame to symbolicate. `initBrowserSentry` calls it; call
74
+ * it yourself right after init in an app that spreads `browserSentryOptions` into another SDK
75
+ * (growth's `@sentry/nextjs`).
76
+ */
77
+ export function runSentryProbe() {
78
+ if (window.location.hash !== "#sentry-probe")
79
+ return;
80
+ setTimeout(() => {
81
+ throw new Error("sentry probe");
82
+ }, 0);
83
+ }
84
+ /**
85
+ * Initialises `@sentry/react` from `browserSentryOptions` plus `browserTracingIntegration()` (no
86
+ * transactions are sent at rate 0), without console breadcrumbs, and returns
87
+ * the error callbacks for `createRoot`/`hydrateRoot`. With no config nothing is initialised and
88
+ * the callbacks capture nothing. Runs `runSentryProbe()` after init.
89
+ */
90
+ export function initBrowserSentry(input) {
91
+ const options = browserSentryOptions(input);
92
+ if (options) {
93
+ Sentry.init({
94
+ ...options,
95
+ // The 11.x breadcrumbs integration has no console switch; console breadcrumbs come from
96
+ // the default `Console` integration, so the defaults are kept without it.
97
+ integrations: (defaults) => [
98
+ ...defaults.filter((integration) => integration.name !== "Console"),
99
+ Sentry.browserTracingIntegration(),
100
+ ],
101
+ });
102
+ runSentryProbe();
103
+ }
104
+ return {
105
+ onCaughtError: rootErrorHandler(),
106
+ onUncaughtError: rootErrorHandler(),
107
+ onRecoverableError: rootErrorHandler(),
108
+ };
109
+ }
@@ -0,0 +1,32 @@
1
+ /** The environment variables the script reads. `process.env` satisfies it. */
2
+ export interface SentryConfigEnv {
3
+ SENTRY_DSN?: string | undefined;
4
+ SENTRY_ENVIRONMENT?: string | undefined;
5
+ SENTRY_RELEASE?: string | undefined;
6
+ }
7
+ /** The value the script assigns to `window.__NL_SENTRY__`; `null` when the service has no DSN. */
8
+ export interface BrowserSentryConfig {
9
+ dsn: string;
10
+ environment?: string;
11
+ release?: string;
12
+ }
13
+ /**
14
+ * `window.__NL_SENTRY__ = {"dsn":…,"environment":…,"release":…};`, or `= null;` with no DSN.
15
+ * Unset environment and release are left out. `<` is escaped so the body cannot close a script tag.
16
+ */
17
+ export declare function sentryConfigScript(env: SentryConfigEnv): string;
18
+ interface ConfigRequest {
19
+ method?: string | undefined;
20
+ }
21
+ interface ConfigResponse {
22
+ statusCode: number;
23
+ setHeader(name: string, value: string): unknown;
24
+ end(body?: string): unknown;
25
+ }
26
+ /**
27
+ * Answers `GET /sentry-config.js` (mount it with `app.use("/sentry-config.js", sentryConfigHandler)`)
28
+ * with the script from `process.env`, `Content-Type: text/javascript`, `Cache-Control: no-cache`.
29
+ * `HEAD` gets the headers only; any other method gets 405.
30
+ */
31
+ export declare function sentryConfigHandler(req: ConfigRequest, res: ConfigResponse): void;
32
+ export {};
package/dist/config.js ADDED
@@ -0,0 +1,33 @@
1
+ // Serves the browser Sentry config as a classic script. Dependency-free.
2
+ /**
3
+ * `window.__NL_SENTRY__ = {"dsn":…,"environment":…,"release":…};`, or `= null;` with no DSN.
4
+ * Unset environment and release are left out. `<` is escaped so the body cannot close a script tag.
5
+ */
6
+ export function sentryConfigScript(env) {
7
+ const dsn = env.SENTRY_DSN;
8
+ if (!dsn)
9
+ return "window.__NL_SENTRY__ = null;";
10
+ const config = { dsn };
11
+ if (env.SENTRY_ENVIRONMENT)
12
+ config.environment = env.SENTRY_ENVIRONMENT;
13
+ if (env.SENTRY_RELEASE)
14
+ config.release = env.SENTRY_RELEASE;
15
+ return `window.__NL_SENTRY__ = ${JSON.stringify(config).replaceAll("<", "\\u003c")};`;
16
+ }
17
+ /**
18
+ * Answers `GET /sentry-config.js` (mount it with `app.use("/sentry-config.js", sentryConfigHandler)`)
19
+ * with the script from `process.env`, `Content-Type: text/javascript`, `Cache-Control: no-cache`.
20
+ * `HEAD` gets the headers only; any other method gets 405.
21
+ */
22
+ export function sentryConfigHandler(req, res) {
23
+ if (req.method !== "GET" && req.method !== "HEAD") {
24
+ res.statusCode = 405;
25
+ res.setHeader("Allow", "GET, HEAD");
26
+ res.end();
27
+ return;
28
+ }
29
+ res.statusCode = 200;
30
+ res.setHeader("Content-Type", "text/javascript; charset=utf-8");
31
+ res.setHeader("Cache-Control", "no-cache");
32
+ res.end(req.method === "HEAD" ? undefined : sentryConfigScript(process.env));
33
+ }
@@ -0,0 +1,43 @@
1
+ /** The parts of a Sentry error event the limiter reads and writes. Any SDK's event satisfies it. */
2
+ export interface LimiterEvent {
3
+ fingerprint?: string[] | undefined;
4
+ message?: string | undefined;
5
+ logentry?: {
6
+ message?: string | undefined;
7
+ } | undefined;
8
+ exception?: {
9
+ values?: {
10
+ type?: string | undefined;
11
+ value?: string | undefined;
12
+ stacktrace?: {
13
+ frames?: {
14
+ in_app?: boolean | undefined;
15
+ module?: string | undefined;
16
+ filename?: string | undefined;
17
+ abs_path?: string | undefined;
18
+ function?: string | undefined;
19
+ }[] | undefined;
20
+ } | undefined;
21
+ }[] | undefined;
22
+ } | undefined;
23
+ tags?: {
24
+ [key: string]: unknown;
25
+ } | undefined;
26
+ extra?: {
27
+ [key: string]: unknown;
28
+ } | undefined;
29
+ }
30
+ export interface RepeatLimiterOptions {
31
+ /** Epoch milliseconds. Defaults to `Date.now()`, read at every event. */
32
+ now?: () => number;
33
+ }
34
+ /**
35
+ * Returns the event (counted), the event carrying `dropped_repeats` as tag and extra (counted; the
36
+ * first one sent since drops began), or `null` (dropped and counted). Safe as a `beforeSend` step.
37
+ */
38
+ export type RepeatLimiter = <E extends LimiterEvent>(event: E) => E | null;
39
+ /**
40
+ * One limiter per `Sentry.init`: its state lives in the returned function. Budget per key: 3
41
+ * events per clock hour and 10 per UTC day; at most 500 keys, least recently seen evicted.
42
+ */
43
+ export declare function createRepeatLimiter(options?: RepeatLimiterOptions): RepeatLimiter;
@@ -0,0 +1,91 @@
1
+ // The per-error repeat limiter. Dependency-free (no Node, Nest or Sentry SDK imports): it runs in a
2
+ // Node service, a browser tab and a Cloudflare Worker, called from any SDK's `beforeSend`.
3
+ const HOUR_MS = 3_600_000;
4
+ const DAY_MS = 86_400_000;
5
+ const MAX_PER_HOUR = 3;
6
+ const MAX_PER_DAY = 10;
7
+ const MAX_KEYS = 500;
8
+ const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
9
+ const HEX_RUN = /\b[0-9a-f]{8,}\b/gi;
10
+ const DIGIT_RUN = /\d+/g;
11
+ const normalizeMessage = (message) => message.replace(UUID, "#").replace(HEX_RUN, "#").replace(DIGIT_RUN, "#");
12
+ /**
13
+ * Approximates the issue an event will group into, before Sentry's server-side grouping runs.
14
+ * With a stack: the top exception's type plus its top in-app frame (module, or filename without
15
+ * query, and function). Without one: the type plus the message with ids and numbers replaced by
16
+ * `#`. An app-set fingerprint is the key; one holding `{{ default }}` also keeps the computed key.
17
+ */
18
+ function limiterKey(event) {
19
+ // Sentry orders exception values oldest first; the last one is the thrown (top) exception.
20
+ const top = event.exception?.values?.at(-1);
21
+ let computed;
22
+ if (top) {
23
+ // Frames are oldest call first; the top frame is the last one.
24
+ const frames = top.stacktrace?.frames ?? [];
25
+ const frame = frames.findLast((f) => f.in_app) ?? frames.at(-1);
26
+ if (frame) {
27
+ const file = frame.module ??
28
+ (frame.filename ?? frame.abs_path)?.split(/[?#]/, 1)[0] ??
29
+ "";
30
+ computed = `${top.type ?? "Error"}|${file}|${frame.function ?? ""}`;
31
+ }
32
+ else {
33
+ computed = `${top.type ?? "Error"}|${normalizeMessage(top.value ?? "")}`;
34
+ }
35
+ }
36
+ else {
37
+ computed = `|${normalizeMessage(event.message ?? event.logentry?.message ?? "")}`;
38
+ }
39
+ const fingerprint = event.fingerprint;
40
+ if (!fingerprint?.length)
41
+ return computed;
42
+ const set = fingerprint.join("\u001f");
43
+ return fingerprint.includes("{{ default }}")
44
+ ? `${set}\u001e${computed}`
45
+ : set;
46
+ }
47
+ /**
48
+ * One limiter per `Sentry.init`: its state lives in the returned function. Budget per key: 3
49
+ * events per clock hour and 10 per UTC day; at most 500 keys, least recently seen evicted.
50
+ */
51
+ export function createRepeatLimiter(options = {}) {
52
+ const now = options.now ?? (() => Date.now());
53
+ const states = new Map();
54
+ return (event) => {
55
+ const at = now();
56
+ const hour = Math.floor(at / HOUR_MS);
57
+ const day = Math.floor(at / DAY_MS);
58
+ const key = limiterKey(event);
59
+ let state = states.get(key);
60
+ if (state)
61
+ states.delete(key);
62
+ else
63
+ state = { hour, hourCount: 0, day, dayCount: 0, dropped: 0 };
64
+ states.set(key, state);
65
+ if (states.size > MAX_KEYS) {
66
+ const oldest = states.keys().next();
67
+ if (!oldest.done)
68
+ states.delete(oldest.value);
69
+ }
70
+ if (state.hour !== hour) {
71
+ state.hour = hour;
72
+ state.hourCount = 0;
73
+ }
74
+ if (state.day !== day) {
75
+ state.day = day;
76
+ state.dayCount = 0;
77
+ }
78
+ if (state.hourCount >= MAX_PER_HOUR || state.dayCount >= MAX_PER_DAY) {
79
+ state.dropped += 1;
80
+ return null;
81
+ }
82
+ state.hourCount += 1;
83
+ state.dayCount += 1;
84
+ if (state.dropped > 0) {
85
+ event.tags = { ...event.tags, dropped_repeats: state.dropped };
86
+ event.extra = { ...event.extra, dropped_repeats: state.dropped };
87
+ state.dropped = 0;
88
+ }
89
+ return event;
90
+ };
91
+ }
@@ -0,0 +1,32 @@
1
+ export type MaskPath = (path: string) => string;
2
+ interface ScrubbableRequest {
3
+ method?: string | undefined;
4
+ url?: string | undefined;
5
+ headers?: {
6
+ [key: string]: string;
7
+ } | undefined;
8
+ }
9
+ export interface ScrubbableEvent {
10
+ request?: ScrubbableRequest | undefined;
11
+ transaction?: string | undefined;
12
+ }
13
+ export interface ScrubbableBreadcrumb {
14
+ data?: {
15
+ [key: string]: unknown;
16
+ } | undefined;
17
+ }
18
+ /** Drops query and fragment, then masks the path (not the origin) with the app's `maskPath`. */
19
+ export declare function scrubUrl(url: string, maskPath: MaskPath | undefined): string;
20
+ /**
21
+ * The SDK attaches the active request's URL, query string, headers, cookies and body to events.
22
+ * Keep the method and the scrubbed URL, plus the scrubbed `Referer` when `keepReferer` is set;
23
+ * mask `event.transaction`.
24
+ */
25
+ export declare function scrubEvent(event: ScrubbableEvent, maskPath: MaskPath | undefined, keepReferer: boolean): void;
26
+ /**
27
+ * The SDK reports the query and fragment of outgoing HTTP requests as their own keys,
28
+ * independent of the URL. Remove them, and scrub every URL a breadcrumb carries (`url`,
29
+ * navigation `from` and `to`).
30
+ */
31
+ export declare function scrubBreadcrumb(breadcrumb: ScrubbableBreadcrumb, maskPath: MaskPath | undefined): void;
32
+ export {};
package/dist/scrub.js ADDED
@@ -0,0 +1,59 @@
1
+ // Scrubbing shared by the server and browser options. Dependency-free.
2
+ const URL_ORIGIN_AND_PATH = /^((?:[a-z][a-z0-9+.-]*:)?\/\/[^/]*)?([^]*)$/i;
3
+ /** Drops query and fragment, then masks the path (not the origin) with the app's `maskPath`. */
4
+ export function scrubUrl(url, maskPath) {
5
+ const bare = url.split(/[?#]/, 1)[0] ?? "";
6
+ if (!maskPath)
7
+ return bare;
8
+ const [, origin = "", path = ""] = URL_ORIGIN_AND_PATH.exec(bare) ?? [];
9
+ return origin + maskPath(path);
10
+ }
11
+ /** A transaction name is a path, or `METHOD path`. */
12
+ function scrubTransaction(name, maskPath) {
13
+ if (!maskPath)
14
+ return name;
15
+ const [, method = "", path = ""] = /^([A-Z]+ )?(\/[^]*)$/.exec(name) ?? [];
16
+ return path ? method + maskPath(path) : name;
17
+ }
18
+ /**
19
+ * The SDK attaches the active request's URL, query string, headers, cookies and body to events.
20
+ * Keep the method and the scrubbed URL, plus the scrubbed `Referer` when `keepReferer` is set;
21
+ * mask `event.transaction`.
22
+ */
23
+ export function scrubEvent(event, maskPath, keepReferer) {
24
+ const request = event.request;
25
+ if (request) {
26
+ const { method, url, headers } = request;
27
+ const referer = keepReferer && headers
28
+ ? Object.entries(headers).find(([name]) => name.toLowerCase() === "referer")?.[1]
29
+ : undefined;
30
+ event.request = {
31
+ ...(method ? { method } : {}),
32
+ ...(url ? { url: scrubUrl(url, maskPath) } : {}),
33
+ ...(referer ? { headers: { Referer: scrubUrl(referer, maskPath) } } : {}),
34
+ };
35
+ }
36
+ if (event.transaction)
37
+ event.transaction = scrubTransaction(event.transaction, maskPath);
38
+ }
39
+ const URL_KEYS = ["url", "url.full", "from", "to"];
40
+ const QUERY_KEYS = ["url.query", "url.fragment", "http.query", "http.fragment"];
41
+ /**
42
+ * The SDK reports the query and fragment of outgoing HTTP requests as their own keys,
43
+ * independent of the URL. Remove them, and scrub every URL a breadcrumb carries (`url`,
44
+ * navigation `from` and `to`).
45
+ */
46
+ export function scrubBreadcrumb(breadcrumb, maskPath) {
47
+ const data = breadcrumb.data;
48
+ if (!data)
49
+ return;
50
+ const rest = { ...data };
51
+ for (const key of QUERY_KEYS)
52
+ delete rest[key];
53
+ for (const key of URL_KEYS) {
54
+ const value = rest[key];
55
+ if (typeof value === "string")
56
+ rest[key] = scrubUrl(value, maskPath);
57
+ }
58
+ breadcrumb.data = rest;
59
+ }
@@ -0,0 +1,60 @@
1
+ import type { IncomingMessage, ServerResponse } from "node:http";
2
+ import type { NodeOptions } from "@sentry/nestjs";
3
+ import type { RepeatLimiterOptions } from "./limiter.js";
4
+ import type { MaskPath } from "./scrub.js";
5
+ export interface ServerSentryOptionsInput {
6
+ /** The app name: the `service` tag. */
7
+ service: string;
8
+ /** Rewrites a URL path that carries a secret; the same function the request log uses. */
9
+ maskPath?: MaskPath;
10
+ /** The limiter's clock (epoch milliseconds), for a service's tests. Default `Date.now`. */
11
+ now?: RepeatLimiterOptions["now"];
12
+ }
13
+ /**
14
+ * The options every Nest `Sentry.init` spreads after `dsn` and `environment`. Each call creates its
15
+ * own repeat limiter, so one `Sentry.init` has one limiter.
16
+ */
17
+ export declare function serverSentryOptions({ service, maskPath, now, }: ServerSentryOptionsInput): NodeOptions;
18
+ /** Request headers as Node's `IncomingMessage.headers` or a fetch-style lowercase record. */
19
+ export type TraceHeaders = {
20
+ [name: string]: string | string[] | undefined;
21
+ };
22
+ /**
23
+ * Starts the trace of one inbound request and returns its trace id.
24
+ *
25
+ * A valid `traceparent` (version `00`, 32 lowercase hex trace id and 16 hex parent id, neither all
26
+ * zeros, 2 hex flags) is continued; anything else is ignored. With a Sentry client the id is put on
27
+ * the current scope, so the SDK uses it for events and for outbound `traceparent`; without a client
28
+ * (no `SENTRY_DSN`) Sentry state is not touched and the returned id is the header's or a new one.
29
+ * Call it on the request's own async context (a middleware before the app's, never wrapping
30
+ * `next()` in `continueTrace`).
31
+ */
32
+ export declare function beginRequestTrace(headers: TraceHeaders): string;
33
+ /** A request `traceMiddleware` has run on. */
34
+ export interface TracedRequest {
35
+ headers: TraceHeaders;
36
+ traceId?: string;
37
+ }
38
+ /** Express middleware: `req.traceId = beginRequestTrace(req.headers)`. Register before module middleware. */
39
+ export declare function traceMiddleware(req: TracedRequest, _res: unknown, next: (error?: unknown) => void): void;
40
+ type CustomProps = (req: IncomingMessage, res: ServerResponse) => object;
41
+ /**
42
+ * Adds `trace_id` (from `req.traceId`) to every log line of the request. Pass the options given to
43
+ * `LoggerModule.forRoot({ pinoHttp })` (or `pinoHttp(...)`); an existing `customProps` is kept.
44
+ *
45
+ * pino-http calls `customProps` when the request starts and binds the result on the request logger,
46
+ * then calls it again when the response finishes and binds that result too unless it is identical.
47
+ * When the second result differs (a caller known only after a guard ran), `trace_id` would be
48
+ * written twice, so it is returned once per request: the request logger already carries it.
49
+ */
50
+ export declare function withTraceLogProps<T extends object & {
51
+ customProps?: CustomProps | undefined;
52
+ }>(options: T): Omit<T, "customProps"> & {
53
+ customProps: CustomProps;
54
+ };
55
+ /**
56
+ * Runs `fn` in a new trace (a job, a schedule tick, an outbox drain) and passes it the trace id.
57
+ * Without a Sentry client the id is only generated, for the caller to log.
58
+ */
59
+ export declare function withNewTrace<T>(fn: (traceId: string) => T): T;
60
+ export {};
package/dist/server.js ADDED
@@ -0,0 +1,112 @@
1
+ import { randomBytes } from "node:crypto";
2
+ import * as Sentry from "@sentry/nestjs";
3
+ import { createRepeatLimiter } from "./limiter.js";
4
+ import { scrubBreadcrumb, scrubEvent } from "./scrub.js";
5
+ import { TRACE_PROPAGATION_TARGETS } from "./targets.js";
6
+ /**
7
+ * The options every Nest `Sentry.init` spreads after `dsn` and `environment`. Each call creates its
8
+ * own repeat limiter, so one `Sentry.init` has one limiter.
9
+ */
10
+ export function serverSentryOptions({ service, maskPath, now, }) {
11
+ const limit = createRepeatLimiter(now ? { now } : {});
12
+ return {
13
+ tracesSampleRate: 0,
14
+ propagateTraceparent: true,
15
+ tracePropagationTargets: [...TRACE_PROPAGATION_TARGETS],
16
+ // Without server spans the SDK keeps the trace id `beginRequestTrace` set on the current scope.
17
+ integrations: [Sentry.httpIntegration({ spans: false })],
18
+ initialScope: { tags: { service, runtime: "server" } },
19
+ beforeSend: (event) => {
20
+ scrubEvent(event, maskPath, false);
21
+ return limit(event);
22
+ },
23
+ beforeBreadcrumb: (breadcrumb) => {
24
+ scrubBreadcrumb(breadcrumb, maskPath);
25
+ return breadcrumb;
26
+ },
27
+ };
28
+ }
29
+ const TRACEPARENT = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/;
30
+ const ALL_ZEROS = /^0+$/;
31
+ const generateTraceId = () => randomBytes(16).toString("hex");
32
+ function parseTraceparent(headers) {
33
+ const value = headers["traceparent"];
34
+ if (typeof value !== "string")
35
+ return undefined;
36
+ const match = TRACEPARENT.exec(value);
37
+ const traceId = match?.[1];
38
+ const parentId = match?.[2];
39
+ if (!traceId || !parentId)
40
+ return undefined;
41
+ if (ALL_ZEROS.test(traceId) || ALL_ZEROS.test(parentId))
42
+ return undefined;
43
+ return { traceId, parentId };
44
+ }
45
+ /**
46
+ * Starts the trace of one inbound request and returns its trace id.
47
+ *
48
+ * A valid `traceparent` (version `00`, 32 lowercase hex trace id and 16 hex parent id, neither all
49
+ * zeros, 2 hex flags) is continued; anything else is ignored. With a Sentry client the id is put on
50
+ * the current scope, so the SDK uses it for events and for outbound `traceparent`; without a client
51
+ * (no `SENTRY_DSN`) Sentry state is not touched and the returned id is the header's or a new one.
52
+ * Call it on the request's own async context (a middleware before the app's, never wrapping
53
+ * `next()` in `continueTrace`).
54
+ */
55
+ export function beginRequestTrace(headers) {
56
+ const inbound = parseTraceparent(headers);
57
+ if (!Sentry.getClient())
58
+ return inbound?.traceId ?? generateTraceId();
59
+ const scope = Sentry.getCurrentScope();
60
+ if (!inbound)
61
+ return scope.getPropagationContext().traceId;
62
+ let continued;
63
+ Sentry.continueTrace({
64
+ sentryTrace: `${inbound.traceId}-${inbound.parentId}-0`,
65
+ baggage: undefined,
66
+ }, () => {
67
+ continued = Sentry.getCurrentScope().getPropagationContext();
68
+ });
69
+ if (!continued)
70
+ throw new Error("continueTrace did not run its callback");
71
+ scope.setPropagationContext(continued);
72
+ return inbound.traceId;
73
+ }
74
+ /** Express middleware: `req.traceId = beginRequestTrace(req.headers)`. Register before module middleware. */
75
+ export function traceMiddleware(req, _res, next) {
76
+ req.traceId = beginRequestTrace(req.headers);
77
+ next();
78
+ }
79
+ const traceIdOf = (req) => "traceId" in req && typeof req.traceId === "string" ? req.traceId : undefined;
80
+ /**
81
+ * Adds `trace_id` (from `req.traceId`) to every log line of the request. Pass the options given to
82
+ * `LoggerModule.forRoot({ pinoHttp })` (or `pinoHttp(...)`); an existing `customProps` is kept.
83
+ *
84
+ * pino-http calls `customProps` when the request starts and binds the result on the request logger,
85
+ * then calls it again when the response finishes and binds that result too unless it is identical.
86
+ * When the second result differs (a caller known only after a guard ran), `trace_id` would be
87
+ * written twice, so it is returned once per request: the request logger already carries it.
88
+ */
89
+ export function withTraceLogProps(options) {
90
+ const existing = options.customProps;
91
+ const bound = new WeakSet();
92
+ return {
93
+ ...options,
94
+ customProps: (req, res) => {
95
+ const props = existing?.(req, res);
96
+ const trace_id = bound.has(req) ? undefined : traceIdOf(req);
97
+ if (trace_id === undefined)
98
+ return { ...props };
99
+ bound.add(req);
100
+ return { ...props, trace_id };
101
+ },
102
+ };
103
+ }
104
+ /**
105
+ * Runs `fn` in a new trace (a job, a schedule tick, an outbox drain) and passes it the trace id.
106
+ * Without a Sentry client the id is only generated, for the caller to log.
107
+ */
108
+ export function withNewTrace(fn) {
109
+ if (!Sentry.getClient())
110
+ return fn(generateTraceId());
111
+ return Sentry.startNewTrace(() => fn(Sentry.getCurrentScope().getPropagationContext().traceId));
112
+ }
@@ -0,0 +1 @@
1
+ export declare const TRACE_PROPAGATION_TARGETS: readonly RegExp[];
@@ -0,0 +1,10 @@
1
+ // Outbound hosts that receive trace headers. Anchored: an SDK string target is a substring match,
2
+ // so plain strings would not bound the host. Vendors receive nothing.
3
+ export const TRACE_PROPAGATION_TARGETS = [
4
+ // any https host ending in .northlight.ai, optional port
5
+ /^https:\/\/[^/?#@:]+\.northlight\.ai(?::\d+)?(?:[/?#]|$)/i,
6
+ // any http host ending in .svc.cluster.local, optional port
7
+ /^http:\/\/[^/?#@:]+\.svc\.cluster\.local(?::\d+)?(?:[/?#]|$)/i,
8
+ // http localhost, 127.0.0.1 or any *.localhost host, optional port
9
+ /^http:\/\/(?:(?:[^/?#@:]+\.)?localhost|127\.0\.0\.1)(?::\d+)?(?:[/?#]|$)/i,
10
+ ];
package/package.json CHANGED
@@ -1,6 +1,56 @@
1
1
  {
2
2
  "name": "@northlight-systems/cloud-sentry",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "0.2.1",
4
+ "description": "W3C trace id handling, Sentry init options with scrubbing, the per-error repeat limiter and the browser config script for Northlight services and frontends.",
5
+ "license": "MPL-2.0",
6
+ "repository": "https://github.com/Northlight-Systems/shared.git",
7
+ "files": [
8
+ "dist"
9
+ ],
10
+ "type": "module",
11
+ "sideEffects": false,
12
+ "exports": {
13
+ "./server": {
14
+ "types": "./dist/server.d.ts",
15
+ "default": "./dist/server.js"
16
+ },
17
+ "./browser": {
18
+ "types": "./dist/browser.d.ts",
19
+ "default": "./dist/browser.js"
20
+ },
21
+ "./config": {
22
+ "types": "./dist/config.d.ts",
23
+ "default": "./dist/config.js"
24
+ },
25
+ "./limiter": {
26
+ "types": "./dist/limiter.d.ts",
27
+ "default": "./dist/limiter.js"
28
+ }
29
+ },
30
+ "publishConfig": {
31
+ "access": "restricted",
32
+ "registry": "https://npm.pkg.github.com"
33
+ },
34
+ "scripts": {
35
+ "build": "tsc -p tsconfig.build.json",
36
+ "typecheck": "tsc -p tsconfig.json"
37
+ },
38
+ "devDependencies": {
39
+ "@sentry/nestjs": "11.9.0",
40
+ "@sentry/react": "11.9.0",
41
+ "@types/node": "26.6.2",
42
+ "react": "19.3.0"
43
+ },
44
+ "peerDependencies": {
45
+ "@sentry/nestjs": ">=11.9.0 <12",
46
+ "@sentry/react": ">=11.9.0 <12"
47
+ },
48
+ "peerDependenciesMeta": {
49
+ "@sentry/nestjs": {
50
+ "optional": true
51
+ },
52
+ "@sentry/react": {
53
+ "optional": true
54
+ }
55
+ }
56
+ }
package/README.md DELETED
@@ -1,3 +0,0 @@
1
- # Temporary Holding Version
2
-
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.