@logbrew/react-native 0.1.39 → 0.1.40

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.
Files changed (96) hide show
  1. package/android-native-diagnostics.d.ts +15 -5
  2. package/android-native-diagnostics.js +170 -94
  3. package/apollo.cjs +435 -226
  4. package/apollo.d.cts +2 -70
  5. package/apollo.d.ts +24 -12
  6. package/apollo.js +438 -221
  7. package/apple-native-diagnostics-config.js +176 -0
  8. package/apple-native-diagnostics-context.js +232 -0
  9. package/apple-native-diagnostics-module.js +229 -0
  10. package/apple-native-diagnostics.d.ts +42 -11
  11. package/apple-native-diagnostics.js +60 -389
  12. package/expo.cjs +29 -16
  13. package/expo.d.ts +10 -9
  14. package/expo.js +4 -3
  15. package/fatal-admission.cjs +113 -0
  16. package/fatal-record.cjs +317 -0
  17. package/fatal-replay.cjs +297 -508
  18. package/global-errors-capture.cjs +369 -0
  19. package/global-errors-event.cjs +174 -0
  20. package/global-errors-support.cjs +128 -0
  21. package/global-errors.cjs +75 -351
  22. package/global-errors.d.cts +29 -278
  23. package/global-errors.d.ts +57 -27
  24. package/global-errors.js +7 -2
  25. package/global-errors.native.js +83 -48
  26. package/index-breadcrumbs.cjs +139 -0
  27. package/index-errors.cjs +167 -0
  28. package/index-events.cjs +365 -0
  29. package/index-navigation.cjs +327 -0
  30. package/index-random.cjs +120 -0
  31. package/index-react.cjs +189 -0
  32. package/index-spans.cjs +190 -0
  33. package/index-trace-fetch.cjs +322 -0
  34. package/index-trace.cjs +335 -0
  35. package/index-transport.cjs +201 -0
  36. package/index-values.cjs +232 -0
  37. package/index.cjs +95 -1243
  38. package/index.d.cts +2 -505
  39. package/index.d.ts +130 -469
  40. package/index.native.d.ts +146 -22
  41. package/index.native.js +184 -159
  42. package/instrumentation-fetch.cjs +113 -0
  43. package/instrumentation-install.cjs +241 -0
  44. package/instrumentation-runtime.cjs +65 -0
  45. package/instrumentation-teardown.cjs +93 -0
  46. package/instrumentation-values.cjs +282 -0
  47. package/instrumentation-xhr-request.cjs +298 -0
  48. package/instrumentation-xhr.cjs +233 -0
  49. package/instrumentation.cjs +110 -599
  50. package/instrumentation.d.cts +2 -84
  51. package/instrumentation.d.ts +22 -8
  52. package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift +1 -1
  53. package/lifecycle.cjs +181 -78
  54. package/lifecycle.d.cts +1 -50
  55. package/lifecycle.d.ts +17 -6
  56. package/metadata.cjs +279 -114
  57. package/metro-debug-id.cjs +296 -0
  58. package/metro-serializer.cjs +219 -0
  59. package/metro.cjs +153 -297
  60. package/metro.d.cts +2 -57
  61. package/metro.d.ts +27 -13
  62. package/metro.js +2 -3
  63. package/native-bridge-async.cjs +165 -0
  64. package/native-bridge-scope.cjs +148 -0
  65. package/native-bridge.cjs +83 -186
  66. package/native-bridge.d.cts +2 -94
  67. package/native-bridge.d.ts +28 -15
  68. package/native-client-bindings.js +230 -0
  69. package/native-diagnostics-values.js +120 -0
  70. package/native-module-lookup.js +31 -0
  71. package/native-null.js +3 -0
  72. package/null-value.cjs +4 -0
  73. package/package.json +43 -1
  74. package/persistent-delivery-store.js +247 -0
  75. package/persistent-delivery.native.js +183 -261
  76. package/promise-rejection-handlers.cjs +368 -0
  77. package/promise-rejections.cjs +169 -361
  78. package/react-native.config.js +3 -1
  79. package/release-artifacts-files.cjs +94 -0
  80. package/release-artifacts-options.cjs +182 -0
  81. package/release-artifacts.cjs +278 -207
  82. package/release-artifacts.d.cts +2 -55
  83. package/release-artifacts.d.ts +18 -7
  84. package/release-artifacts.js +2 -4
  85. package/resource-fetch-graphql.cjs +265 -0
  86. package/resource-fetch-size.cjs +156 -0
  87. package/resource-fetch.cjs +227 -428
  88. package/resource-fetch.d.cts +1 -60
  89. package/resource-fetch.d.ts +17 -6
  90. package/scripts/sync-apple-native-sources.mjs +101 -53
  91. package/types/capture.d.ts +95 -0
  92. package/types/config.d.ts +85 -0
  93. package/types/defaults.d.ts +55 -0
  94. package/types/events.d.ts +203 -0
  95. package/types/provider.d.ts +81 -0
  96. package/types/trace.d.ts +104 -0
@@ -0,0 +1,322 @@
1
+ const { parseTraceparent, SdkError } = require("@logbrew/sdk");
2
+ const { defaultRandomValues } = require("./index-random.cjs");
3
+ const { createReactNativeTraceHeaders, createReactNativeTraceparent, getActiveLogBrewTrace, resolveTraceContext } = require("./index-trace.cjs");
4
+ const { defaultFetch } = require("./index-transport.cjs");
5
+ const { readField, textOf } = require("./index-values.cjs");
6
+
7
+ /**
8
+ * @typedef {(input: unknown, init?: unknown) => unknown} TracedFetchLike
9
+ * @typedef {(context: { readonly init: unknown, readonly input: unknown, readonly url: string }) => unknown} TraceparentFactory
10
+ * @typedef {{
11
+ * readonly fetchImpl?: unknown,
12
+ * readonly randomValues?: unknown,
13
+ * readonly trace?: unknown,
14
+ * readonly traceFlags?: string | undefined,
15
+ * readonly traceparent?: unknown,
16
+ * readonly traceparentFactory?: unknown,
17
+ * readonly tracePropagationTargets?: unknown
18
+ * }} TraceparentFetchConfig
19
+ * @typedef {{
20
+ * readonly init: unknown,
21
+ * readonly input: unknown,
22
+ * readonly randomValues: unknown,
23
+ * readonly trace: unknown,
24
+ * readonly traceFlags: string,
25
+ * readonly traceparent: unknown,
26
+ * readonly traceparentFactory: unknown,
27
+ * readonly url: string
28
+ * }} TraceparentRequest
29
+ */
30
+
31
+ const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/iu;
32
+ const RESET_INDEX = 0;
33
+
34
+ /**
35
+ * @param {unknown} value
36
+ * @returns {value is TracedFetchLike}
37
+ */
38
+ function isTracedFetch(value) {
39
+ return typeof value === "function";
40
+ }
41
+
42
+ /**
43
+ * @param {unknown} value
44
+ * @returns {value is TraceparentFactory}
45
+ */
46
+ function isTraceparentFactory(value) {
47
+ return typeof value === "function";
48
+ }
49
+
50
+ /**
51
+ * @param {unknown} value
52
+ * @returns {value is (url: string) => unknown}
53
+ */
54
+ function isTargetPredicate(value) {
55
+ return typeof value === "function";
56
+ }
57
+
58
+ /**
59
+ * @param {unknown} value
60
+ * @returns {value is readonly unknown[]}
61
+ */
62
+ function isUnknownList(value) {
63
+ return Array.isArray(value);
64
+ }
65
+
66
+ /**
67
+ * @param {unknown} value
68
+ * @returns {value is readonly Iterable<unknown>[]}
69
+ */
70
+ function isEntryList(value) {
71
+ return Array.isArray(value);
72
+ }
73
+
74
+ /**
75
+ * @param {unknown} value
76
+ * @returns {PropertyKey}
77
+ */
78
+ function propertyKey(value) {
79
+ return typeof value === "symbol" ? value : textOf(value);
80
+ }
81
+
82
+ /**
83
+ * @param {string} pathname
84
+ * @returns {string}
85
+ */
86
+ function pathPrefix(pathname) {
87
+ return pathname.endsWith("/") ? pathname : `${pathname}/`;
88
+ }
89
+
90
+ /**
91
+ * @param {string} url
92
+ * @returns {boolean}
93
+ */
94
+ function hasUrlScheme(url) {
95
+ return URL_SCHEME_RE.test(url);
96
+ }
97
+
98
+ /**
99
+ * @param {string} url
100
+ * @param {string} targetText
101
+ * @returns {boolean}
102
+ */
103
+ function matchesUrlTarget(url, targetText) {
104
+ const URLConstructor = globalThis.URL;
105
+ try {
106
+ const targetUrl = new URLConstructor(targetText);
107
+ if (!hasUrlScheme(url)) {
108
+ return false;
109
+ }
110
+ const candidateUrl = new URLConstructor(url, targetUrl.origin);
111
+ const targetPath = targetUrl.pathname || "/";
112
+ return candidateUrl.origin === targetUrl.origin
113
+ && (candidateUrl.pathname === targetPath || candidateUrl.pathname.startsWith(pathPrefix(targetPath)));
114
+ } catch {
115
+ return url.startsWith(targetText);
116
+ }
117
+ }
118
+
119
+ /**
120
+ * @param {string} url
121
+ * @param {string} target
122
+ * @returns {boolean}
123
+ */
124
+ function shouldPropagateToStringTarget(url, target) {
125
+ const targetText = target.trim();
126
+ if (targetText === "") {
127
+ return false;
128
+ }
129
+ if (targetText.startsWith("/")) {
130
+ return url.startsWith(targetText);
131
+ }
132
+ if (typeof readField(globalThis, "URL") === "function") {
133
+ return matchesUrlTarget(url, targetText);
134
+ }
135
+ return url.startsWith(targetText);
136
+ }
137
+
138
+ /**
139
+ * @param {string} url
140
+ * @param {unknown} target
141
+ * @returns {boolean}
142
+ */
143
+ function matchesPropagationTarget(url, target) {
144
+ if (typeof target === "string") {
145
+ return shouldPropagateToStringTarget(url, target);
146
+ }
147
+ if (target instanceof RegExp) {
148
+ target.lastIndex = RESET_INDEX;
149
+ const matched = target.test(url);
150
+ target.lastIndex = RESET_INDEX;
151
+ return matched;
152
+ }
153
+ if (isTargetPredicate(target)) {
154
+ return target(url) === true;
155
+ }
156
+ throw new SdkError("configuration_error", "tracePropagationTargets entries must be strings, RegExp values, or functions");
157
+ }
158
+
159
+ /**
160
+ * @param {string} url
161
+ * @param {unknown} [tracePropagationTargets]
162
+ * @returns {boolean}
163
+ */
164
+ function shouldPropagateTraceparent(url, tracePropagationTargets = []) {
165
+ if (!isUnknownList(tracePropagationTargets)) {
166
+ throw new SdkError("configuration_error", "tracePropagationTargets must be an array");
167
+ }
168
+ return tracePropagationTargets.some(target => matchesPropagationTarget(url, target));
169
+ }
170
+
171
+ /**
172
+ * @param {unknown} input
173
+ * @param {unknown} init
174
+ * @returns {unknown}
175
+ */
176
+ function requestHeaders(input, init) {
177
+ const initHeaders = readField(init, "headers");
178
+ if (Boolean(init) && initHeaders !== undefined) {
179
+ return initHeaders;
180
+ }
181
+ return readField(input, "headers");
182
+ }
183
+
184
+ /**
185
+ * @param {unknown} input
186
+ * @returns {string}
187
+ */
188
+ function requestUrl(input) {
189
+ if (typeof input === "string") {
190
+ return input;
191
+ }
192
+ const URLConstructor = readField(globalThis, "URL");
193
+ if (typeof URLConstructor === "function" && input instanceof URLConstructor) {
194
+ return textOf(input);
195
+ }
196
+ const url = readField(input, "url");
197
+ if (typeof url === "string") {
198
+ return url;
199
+ }
200
+ return textOf(input);
201
+ }
202
+
203
+ /**
204
+ * @param {unknown} value
205
+ * @returns {value is Iterable<Iterable<unknown>>}
206
+ */
207
+ function isIterable(value) {
208
+ return typeof value !== "string" && typeof readField(value, Symbol.iterator) === "function";
209
+ }
210
+
211
+ /**
212
+ * @param {Headers} headers
213
+ * @returns {[string, string][]}
214
+ */
215
+ function platformHeaderEntries(headers) {
216
+ /** @type {[string, string][]} */
217
+ const entries = [];
218
+ for (const [key, value] of headers) {
219
+ entries.push([key, value]);
220
+ }
221
+ return entries;
222
+ }
223
+
224
+ /**
225
+ * @param {unknown} headers
226
+ * @returns {readonly Iterable<unknown>[]}
227
+ */
228
+ function headerEntries(headers) {
229
+ if (headers === undefined || headers === null) {
230
+ return [];
231
+ }
232
+ if (typeof readField(globalThis, "Headers") === "function" && headers instanceof globalThis.Headers) {
233
+ return platformHeaderEntries(headers);
234
+ }
235
+ if (isEntryList(headers)) {
236
+ return headers;
237
+ }
238
+ if (isIterable(headers)) {
239
+ return [...headers];
240
+ }
241
+ return typeof headers === "object" ? Object.entries(headers) : [];
242
+ }
243
+
244
+ /**
245
+ * @param {unknown} headers
246
+ * @param {unknown} traceparent
247
+ * @returns {Record<PropertyKey, unknown>}
248
+ */
249
+ function headersWithTraceparent(headers, traceparent) {
250
+ /** @type {Record<PropertyKey, unknown>} */
251
+ const nextHeaders = {};
252
+ for (const [key, value] of headerEntries(headers)) {
253
+ if (textOf(key).toLowerCase() !== "traceparent") {
254
+ nextHeaders[propertyKey(key)] = value;
255
+ }
256
+ }
257
+ nextHeaders["traceparent"] = traceparent;
258
+ return nextHeaders;
259
+ }
260
+
261
+ /**
262
+ * @param {TraceparentRequest} request
263
+ * @returns {unknown}
264
+ */
265
+ function traceparentForRequest({
266
+ init, input, randomValues, trace, traceFlags, traceparent, traceparentFactory, url
267
+ }) {
268
+ const context = resolveTraceContext(trace) ?? getActiveLogBrewTrace();
269
+ const nextTraceparent = isTraceparentFactory(traceparentFactory)
270
+ ? traceparentFactory({ init, input, url })
271
+ : traceparent ?? (context ? createReactNativeTraceHeaders(context).traceparent : createReactNativeTraceparent({ randomValues, traceFlags }));
272
+ parseTraceparent(typeof nextTraceparent === "string" ? nextTraceparent : "");
273
+ return nextTraceparent;
274
+ }
275
+
276
+ /**
277
+ * @param {TraceparentFetchConfig} [config]
278
+ * @returns {(input: unknown, init?: Readonly<Record<string, unknown>>) => Promise<unknown>}
279
+ */
280
+ function createTraceparentFetch({
281
+ fetchImpl = defaultFetch(),
282
+ randomValues = defaultRandomValues,
283
+ trace,
284
+ traceFlags = "01",
285
+ traceparent,
286
+ traceparentFactory,
287
+ tracePropagationTargets = []
288
+ } = {}) {
289
+ if (!isTracedFetch(fetchImpl)) {
290
+ throw new SdkError("configuration_error", "createTraceparentFetch requires fetch");
291
+ }
292
+ if (!Array.isArray(tracePropagationTargets)) {
293
+ throw new SdkError("configuration_error", "tracePropagationTargets must be an array");
294
+ }
295
+ if (traceparentFactory !== undefined && typeof traceparentFactory !== "function") {
296
+ throw new SdkError("configuration_error", "traceparentFactory must be a function");
297
+ }
298
+ const fetchTarget = fetchImpl;
299
+
300
+ /**
301
+ * @param {unknown} input
302
+ * @param {Readonly<Record<string, unknown>>} [init]
303
+ * @returns {Promise<unknown>}
304
+ */
305
+ async function tracedFetch(input, init) {
306
+ const url = requestUrl(input);
307
+ if (!shouldPropagateTraceparent(url, tracePropagationTargets)) {
308
+ return init === undefined ? fetchTarget(input) : fetchTarget(input, init);
309
+ }
310
+
311
+ const requestInit = init ?? {};
312
+ const nextTraceparent = traceparentForRequest({ init, input, randomValues, trace, traceFlags, traceparent, traceparentFactory, url });
313
+ const nextInit = {
314
+ ...requestInit,
315
+ headers: headersWithTraceparent(requestHeaders(input, requestInit), nextTraceparent)
316
+ };
317
+ return fetchTarget(input, nextInit);
318
+ }
319
+ return tracedFetch;
320
+ }
321
+
322
+ module.exports = { createTraceparentFetch, shouldPropagateTraceparent };
@@ -0,0 +1,335 @@
1
+ const { createTraceparent, parseTraceparent, SdkError } = require("@logbrew/sdk");
2
+ const { defaultRandomValues, randomHex } = require("./index-random.cjs");
3
+ const { compactMetadata, textOf } = require("./index-values.cjs");
4
+
5
+ /**
6
+ * @import { Metadata } from "@logbrew/sdk"
7
+ * @import { LooseRecord, TraceContext } from "./index-values.cjs"
8
+ * @typedef {{
9
+ * readonly randomValues?: unknown,
10
+ * readonly spanId?: string | undefined,
11
+ * readonly traceFlags?: string | undefined,
12
+ * readonly traceId?: string | undefined
13
+ * }} TraceparentConfig
14
+ * @typedef {TraceparentConfig & {
15
+ * readonly parentSpanId?: string | undefined,
16
+ * readonly traceparent?: string | null | undefined
17
+ * }} TraceContextConfig
18
+ * @typedef {{
19
+ * readonly traceId?: unknown,
20
+ * readonly spanId?: unknown,
21
+ * readonly parentSpanId?: string | undefined,
22
+ * readonly traceFlags?: string | undefined,
23
+ * readonly sampled?: unknown
24
+ * }} TraceObjectInput
25
+ * @typedef {{
26
+ * readonly parentSpanId: unknown,
27
+ * readonly sampled: unknown,
28
+ * readonly spanId: unknown,
29
+ * readonly traceFlags: unknown,
30
+ * readonly traceId: unknown
31
+ * }} TraceContextFields
32
+ * @typedef {{
33
+ * readonly durationMs?: unknown,
34
+ * readonly metadata?: LooseRecord | undefined,
35
+ * readonly name?: unknown,
36
+ * readonly spanId?: unknown,
37
+ * readonly status?: unknown,
38
+ * readonly trace?: unknown
39
+ * }} SpanAttributesInput
40
+ * @typedef {{ readonly id: number, readonly trace: TraceContext }} TraceScope
41
+ */
42
+
43
+ const SPAN_ID_BYTES = 8;
44
+ const TRACE_ID_BYTES = 16;
45
+ const HEX_RADIX = 16;
46
+ const SAMPLED_DIVISOR = 2;
47
+ const NOT_SAMPLED = 0;
48
+ const NO_SCOPES = 0;
49
+ const STEP = 1;
50
+ const NOT_FOUND = -1;
51
+ const LAST = -1;
52
+ /** @type {TraceScope[]} */
53
+ const activeTraceScopes = [];
54
+ let nextTraceScopeId = 0;
55
+
56
+ /**
57
+ * @param {TraceContextFields} fields
58
+ * @returns {TraceContext}
59
+ */
60
+ function freezeTraceContext({ parentSpanId, sampled, spanId, traceFlags, traceId }) {
61
+ const normalized = {
62
+ traceId: textOf(traceId).toLowerCase(),
63
+
64
+ spanId: textOf(spanId).toLowerCase(),
65
+
66
+ parentSpanId: parentSpanId === undefined ? undefined : textOf(parentSpanId).toLowerCase(),
67
+ traceFlags: textOf(traceFlags).toLowerCase(),
68
+
69
+ sampled: Boolean(sampled)
70
+ };
71
+ return Object.freeze(normalized);
72
+ }
73
+
74
+ /**
75
+ * @param {string} traceFlags
76
+ * @returns {boolean}
77
+ */
78
+ function sampledFromTraceFlags(traceFlags) {
79
+ const flags = Number.parseInt(traceFlags, HEX_RADIX);
80
+ return Number.isFinite(flags) && flags % SAMPLED_DIVISOR !== NOT_SAMPLED;
81
+ }
82
+
83
+ /**
84
+ * @param {TraceparentConfig} [config]
85
+ * @returns {string}
86
+ */
87
+ function createReactNativeTraceparent({ randomValues = defaultRandomValues, spanId, traceFlags = "01", traceId } = {}) {
88
+ return createTraceparent({
89
+ spanId: spanId ?? randomHex(SPAN_ID_BYTES, randomValues),
90
+ traceFlags,
91
+ traceId: traceId ?? randomHex(TRACE_ID_BYTES, randomValues)
92
+ });
93
+ }
94
+
95
+ /**
96
+ * @param {string} traceparent
97
+ * @param {string | undefined} spanId
98
+ * @param {unknown} randomValues
99
+ * @returns {TraceContext | undefined}
100
+ */
101
+ function traceContextFromTraceparent(traceparent, spanId, randomValues) {
102
+ try {
103
+ const parsed = parseTraceparent(traceparent);
104
+ const localSpanId = spanId ?? randomHex(SPAN_ID_BYTES, randomValues);
105
+ createTraceparent({ spanId: localSpanId, traceFlags: parsed.traceFlags, traceId: parsed.traceId });
106
+ return freezeTraceContext({
107
+ parentSpanId: parsed.parentSpanId,
108
+ sampled: parsed.sampled,
109
+ spanId: localSpanId,
110
+ traceFlags: parsed.traceFlags,
111
+ traceId: parsed.traceId
112
+ });
113
+ } catch {
114
+ return undefined;
115
+ }
116
+ }
117
+
118
+ /**
119
+ * @param {TraceContextConfig} [config]
120
+ * @returns {TraceContext}
121
+ */
122
+ function createReactNativeTraceContext({
123
+ parentSpanId, randomValues = defaultRandomValues, spanId, traceFlags = "01", traceId, traceparent
124
+ } = {}) {
125
+ if (traceparent !== undefined && traceparent !== null && textOf(traceparent).trim() !== "") {
126
+ const propagated = traceContextFromTraceparent(traceparent, spanId, randomValues);
127
+ if (propagated) {
128
+ return propagated;
129
+ }
130
+ }
131
+ const localTraceId = traceId ?? randomHex(TRACE_ID_BYTES, randomValues);
132
+ const localSpanId = spanId ?? randomHex(SPAN_ID_BYTES, randomValues);
133
+ createTraceparent({ spanId: localSpanId, traceFlags, traceId: localTraceId });
134
+ if (parentSpanId !== undefined) {
135
+ createTraceparent({ spanId: parentSpanId, traceFlags, traceId: localTraceId });
136
+ }
137
+ return freezeTraceContext({
138
+ parentSpanId,
139
+ sampled: sampledFromTraceFlags(traceFlags),
140
+ spanId: localSpanId,
141
+ traceFlags,
142
+ traceId: localTraceId
143
+ });
144
+ }
145
+
146
+ /**
147
+ * @param {unknown} value
148
+ * @returns {value is TraceObjectInput}
149
+ */
150
+ function isTraceObject(value) {
151
+ return typeof value === "object";
152
+ }
153
+
154
+ /**
155
+ * @param {TraceObjectInput} trace
156
+ * @returns {TraceContext}
157
+ */
158
+ function resolveTraceObject(trace) {
159
+ const { parentSpanId, sampled, spanId, traceFlags = "01", traceId } = trace;
160
+ if (typeof traceId !== "string" || typeof spanId !== "string") {
161
+ throw new SdkError("validation_error", "trace context requires traceId and spanId");
162
+ }
163
+ createTraceparent({ spanId, traceFlags, traceId });
164
+ if (parentSpanId !== undefined) {
165
+ createTraceparent({ spanId: parentSpanId, traceFlags, traceId });
166
+ }
167
+ return freezeTraceContext({
168
+ parentSpanId,
169
+ sampled: sampled ?? sampledFromTraceFlags(traceFlags),
170
+ spanId,
171
+ traceFlags,
172
+ traceId
173
+ });
174
+ }
175
+
176
+ /**
177
+ * @param {unknown} trace
178
+ * @returns {TraceContext | undefined}
179
+ */
180
+ function resolveTraceContext(trace) {
181
+ if (trace === undefined || trace === null) {
182
+ return undefined;
183
+ }
184
+ if (typeof trace === "string") {
185
+ return createReactNativeTraceContext({ traceparent: trace });
186
+ }
187
+ if (!isTraceObject(trace)) {
188
+ throw new SdkError("validation_error", "trace must be a trace context or traceparent string");
189
+ }
190
+ return resolveTraceObject(trace);
191
+ }
192
+
193
+ /**
194
+ * @returns {TraceContext | undefined}
195
+ */
196
+ function getActiveLogBrewTrace() {
197
+ return activeTraceScopes.length === NO_SCOPES ? undefined : activeTraceScopes.at(LAST)?.trace;
198
+ }
199
+
200
+ /**
201
+ * @param {number} scopeId
202
+ * @returns {void}
203
+ */
204
+ function removeActiveTraceScope(scopeId) {
205
+ const index = activeTraceScopes.findIndex(scope => scope.id === scopeId);
206
+ if (index !== NOT_FOUND) {
207
+ activeTraceScopes.splice(index, STEP);
208
+ }
209
+ }
210
+
211
+ /**
212
+ * @param {unknown} value
213
+ * @returns {value is (...args: readonly unknown[]) => unknown}
214
+ */
215
+ function isCallable(value) {
216
+ return typeof value === "function";
217
+ }
218
+
219
+ /**
220
+ * @param {unknown} trace
221
+ * @param {unknown} scopedFunction
222
+ * @returns {unknown}
223
+ */
224
+ function withLogBrewTrace(trace, scopedFunction) {
225
+ if (!isCallable(scopedFunction)) {
226
+ throw new SdkError("configuration_error", "withLogBrewTrace requires a callback");
227
+ }
228
+ const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
229
+ nextTraceScopeId += STEP;
230
+ const scope = {
231
+ id: nextTraceScopeId,
232
+ trace: context
233
+ };
234
+ activeTraceScopes.push(scope);
235
+ try {
236
+ return scopedFunction(context);
237
+ } finally {
238
+ removeActiveTraceScope(scope.id);
239
+ }
240
+ }
241
+
242
+ /**
243
+ * @param {unknown} trace
244
+ * @param {unknown} scopedFunction
245
+ * @returns {(...args: readonly unknown[]) => unknown}
246
+ */
247
+ function bindLogBrewTrace(trace, scopedFunction) {
248
+ if (!isCallable(scopedFunction)) {
249
+ throw new SdkError("configuration_error", "bindLogBrewTrace requires a callback");
250
+ }
251
+ const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
252
+ const target = scopedFunction;
253
+ /**
254
+ * @param {readonly unknown[]} args
255
+ * @returns {unknown}
256
+ */
257
+ function logBrewTracedCallback(...args) {
258
+ return withLogBrewTrace(context, () => target(...args));
259
+ }
260
+ return logBrewTracedCallback;
261
+ }
262
+
263
+ /**
264
+ * @param {unknown} [trace]
265
+ * @returns {Metadata}
266
+ */
267
+ function getReactNativeTraceMetadata(trace = getActiveLogBrewTrace()) {
268
+ const context = resolveTraceContext(trace);
269
+ if (!context) {
270
+ return {};
271
+ }
272
+ return compactMetadata({
273
+ parentSpanId: context.parentSpanId,
274
+ spanId: context.spanId,
275
+ traceFlags: context.traceFlags,
276
+ traceId: context.traceId,
277
+ traceSampled: context.sampled
278
+ });
279
+ }
280
+
281
+ /**
282
+ * @param {SpanAttributesInput} [input]
283
+ * @returns {Record<string, unknown>}
284
+ */
285
+ function createReactNativeSpanAttributes({
286
+ durationMs,
287
+ metadata = {},
288
+ name,
289
+ spanId,
290
+ status = "ok",
291
+ trace = getActiveLogBrewTrace()
292
+ } = {}) {
293
+ const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
294
+ return {
295
+ name,
296
+ traceId: context.traceId,
297
+
298
+ spanId: spanId ?? context.spanId,
299
+ status,
300
+
301
+ durationMs,
302
+ metadata: compactMetadata({
303
+ ...metadata,
304
+ ...getReactNativeTraceMetadata(context)
305
+ })
306
+ };
307
+ }
308
+
309
+ /**
310
+ * @param {unknown} [trace]
311
+ * @returns {{ traceparent: string }}
312
+ */
313
+ function createReactNativeTraceHeaders(trace = getActiveLogBrewTrace()) {
314
+ const context = resolveTraceContext(trace) ?? createReactNativeTraceContext();
315
+ return {
316
+ traceparent: createTraceparent({
317
+ traceFlags: context.traceFlags,
318
+ traceId: context.traceId,
319
+
320
+ spanId: context.spanId
321
+ })
322
+ };
323
+ }
324
+
325
+ module.exports = {
326
+ bindLogBrewTrace,
327
+ createReactNativeSpanAttributes,
328
+ createReactNativeTraceContext,
329
+ createReactNativeTraceHeaders,
330
+ createReactNativeTraceparent,
331
+ getActiveLogBrewTrace,
332
+ getReactNativeTraceMetadata,
333
+ resolveTraceContext,
334
+ withLogBrewTrace
335
+ };