@logbrew/react-native 0.1.38 → 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.
- package/LogBrewReactNative.podspec +1 -1
- package/README.md +17 -15
- package/android-native-diagnostics.d.ts +15 -5
- package/android-native-diagnostics.js +170 -94
- package/apollo.cjs +435 -226
- package/apollo.d.cts +2 -70
- package/apollo.d.ts +24 -12
- package/apollo.js +438 -221
- package/apple-native-diagnostics-config.js +176 -0
- package/apple-native-diagnostics-context.js +232 -0
- package/apple-native-diagnostics-module.js +229 -0
- package/apple-native-diagnostics.d.ts +42 -11
- package/apple-native-diagnostics.js +60 -389
- package/expo.cjs +29 -16
- package/expo.d.ts +10 -9
- package/expo.js +4 -3
- package/fatal-admission.cjs +113 -0
- package/fatal-record.cjs +317 -0
- package/fatal-replay.cjs +297 -508
- package/global-errors-capture.cjs +369 -0
- package/global-errors-event.cjs +174 -0
- package/global-errors-support.cjs +128 -0
- package/global-errors.cjs +75 -351
- package/global-errors.d.cts +29 -278
- package/global-errors.d.ts +57 -27
- package/global-errors.js +7 -2
- package/global-errors.native.js +83 -48
- package/index-breadcrumbs.cjs +139 -0
- package/index-errors.cjs +167 -0
- package/index-events.cjs +365 -0
- package/index-navigation.cjs +327 -0
- package/index-random.cjs +120 -0
- package/index-react.cjs +189 -0
- package/index-spans.cjs +190 -0
- package/index-trace-fetch.cjs +322 -0
- package/index-trace.cjs +335 -0
- package/index-transport.cjs +201 -0
- package/index-values.cjs +232 -0
- package/index.cjs +95 -1220
- package/index.d.cts +2 -505
- package/index.d.ts +130 -469
- package/index.native.d.ts +146 -22
- package/index.native.js +184 -159
- package/instrumentation-fetch.cjs +113 -0
- package/instrumentation-install.cjs +241 -0
- package/instrumentation-runtime.cjs +65 -0
- package/instrumentation-teardown.cjs +93 -0
- package/instrumentation-values.cjs +282 -0
- package/instrumentation-xhr-request.cjs +298 -0
- package/instrumentation-xhr.cjs +233 -0
- package/instrumentation.cjs +110 -599
- package/instrumentation.d.cts +2 -84
- package/instrumentation.d.ts +22 -8
- package/ios/AppleDiagnostics/LBRNAppleNativeDiagnostics.swift +1 -1
- package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryEngine.swift +7 -1
- package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryEngineAutomatic.swift +36 -4
- package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryEngineQueue.swift +17 -0
- package/ios/GeneratedAppleDiagnostics/LogBrew/DeliveryLifecycle.swift +2 -0
- package/ios/GeneratedAppleDiagnostics/LogBrew/Transport.swift +41 -6
- package/ios/GeneratedAppleDiagnostics/SOURCE-MANIFEST.json +5 -5
- package/lifecycle.cjs +181 -78
- package/lifecycle.d.cts +1 -50
- package/lifecycle.d.ts +17 -6
- package/metadata.cjs +279 -114
- package/metro-debug-id.cjs +296 -0
- package/metro-serializer.cjs +219 -0
- package/metro.cjs +153 -297
- package/metro.d.cts +2 -57
- package/metro.d.ts +27 -13
- package/metro.js +2 -3
- package/native-bridge-async.cjs +165 -0
- package/native-bridge-scope.cjs +148 -0
- package/native-bridge.cjs +83 -186
- package/native-bridge.d.cts +2 -94
- package/native-bridge.d.ts +28 -15
- package/native-client-bindings.js +230 -0
- package/native-diagnostics-values.js +120 -0
- package/native-module-lookup.js +31 -0
- package/native-null.js +3 -0
- package/null-value.cjs +4 -0
- package/package.json +44 -2
- package/persistent-delivery-store.js +247 -0
- package/persistent-delivery.native.js +183 -261
- package/promise-rejection-handlers.cjs +368 -0
- package/promise-rejections.cjs +169 -361
- package/react-native.config.js +3 -1
- package/release-artifacts-files.cjs +94 -0
- package/release-artifacts-options.cjs +182 -0
- package/release-artifacts.cjs +278 -207
- package/release-artifacts.d.cts +2 -55
- package/release-artifacts.d.ts +18 -7
- package/release-artifacts.js +2 -4
- package/resource-fetch-graphql.cjs +265 -0
- package/resource-fetch-size.cjs +156 -0
- package/resource-fetch.cjs +227 -428
- package/resource-fetch.d.cts +1 -60
- package/resource-fetch.d.ts +17 -6
- package/scripts/sync-apple-native-sources.mjs +101 -53
- package/types/capture.d.ts +95 -0
- package/types/config.d.ts +85 -0
- package/types/defaults.d.ts +55 -0
- package/types/events.d.ts +203 -0
- package/types/provider.d.ts +81 -0
- 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 };
|
package/index-trace.cjs
ADDED
|
@@ -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
|
+
};
|