@wix/cli
Version:
CLI tool for building Wix sites and applications
1,483 lines (1,448 loc) • 706 kB
JavaScript
import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
require_index_node,
require_src
} from "./chunk-CCOOZLEQ.js";
import {
I18nProvider,
Trans,
useTranslation
} from "./chunk-75K4NCRA.js";
import {
Alert,
Box_default,
ConfirmInput,
ErrorDetails,
Link,
Newline,
Notification,
Text,
TextInput,
UnorderedList,
render,
renderErrorSync,
renderSync
} from "./chunk-OAVLQEAG.js";
import {
require_react
} from "./chunk-5A5B2WR4.js";
import {
DiagLogLevel,
SEMATTRS_HTTP_ROUTE,
SEMRESATTRS_PROCESS_RUNTIME_NAME,
SEMRESATTRS_TELEMETRY_SDK_LANGUAGE,
SEMRESATTRS_TELEMETRY_SDK_NAME,
SEMRESATTRS_TELEMETRY_SDK_VERSION,
SamplingDecision,
TELEMETRYSDKLANGUAGEVALUES_NODEJS,
TraceFlags,
baggageEntryMetadataFromString,
context,
createContextKey,
diag,
esm_exports,
esm_exports2,
init_esm,
init_esm2,
isSpanContextValid,
isValidTraceId,
metrics,
propagation,
trace
} from "./chunk-Z4MHKCET.js";
import {
LRUMap,
SDK_VERSION,
SEMANTIC_ATTRIBUTE_CACHE_HIT,
SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE,
SEMANTIC_ATTRIBUTE_CACHE_KEY,
SEMANTIC_ATTRIBUTE_SENTRY_OP,
SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
Scope,
ServerRuntimeClient,
_nullishCoalesce,
_optionalChain,
addBreadcrumb,
addConsoleInstrumentationHandler,
applySdkMetadata,
baggageHeaderToDynamicSamplingContext,
captureException,
consoleSandbox,
createStackParser,
createTransport,
defineIntegration,
dirname,
dynamicSamplingContextToSentryBaggageHeader,
flatten,
functionToStringIntegration,
getCapturedScopesOnSpan,
getClient,
getCurrentScope,
getDefaultIsolationScope,
getDynamicSamplingContextFromSpan,
getIsolationScope,
getRootSpan,
getSanitizedUrlString,
hasTracingEnabled,
inboundFiltersIntegration,
isSentryRequestUrl,
linkedErrorsIntegration,
logger,
nodeStackLineParser,
parseSemver,
parseUrl,
requestDataIntegration,
setCapturedScopesOnSpan,
severityLevelFromString,
snipLine,
spanToJSON,
stripUrlQueryAndFragment,
suppressTracing,
truncate
} from "./chunk-C4SUTB4O.js";
import {
getTestOverrides
} from "./chunk-WYHHEOWO.js";
import {
pathExists,
readJson,
writeJson
} from "./chunk-P4ZPHTFX.js";
import {
z
} from "./chunk-ZXYGJZOO.js";
import {
CliError,
CliErrorCode,
CliSystemErrorCode,
isCliError,
isCliSystemError,
normalizeError,
require_lib,
require_verror
} from "./chunk-D5VYILRO.js";
import {
__commonJS,
__esm,
__export,
__require,
__toCommonJS,
__toESM,
init_esm_shims
} from "./chunk-4EFJZ3GQ.js";
// ../../node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
function suppressTracing2(context2) {
return context2.setValue(SUPPRESS_TRACING_KEY, true);
}
function unsuppressTracing(context2) {
return context2.deleteValue(SUPPRESS_TRACING_KEY);
}
function isTracingSuppressed(context2) {
return context2.getValue(SUPPRESS_TRACING_KEY) === true;
}
var SUPPRESS_TRACING_KEY;
var init_suppress_tracing = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js"() {
"use strict";
init_esm_shims();
init_esm();
SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
}
});
// ../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js
var BAGGAGE_KEY_PAIR_SEPARATOR, BAGGAGE_PROPERTIES_SEPARATOR, BAGGAGE_ITEMS_SEPARATOR, BAGGAGE_HEADER, BAGGAGE_MAX_NAME_VALUE_PAIRS, BAGGAGE_MAX_PER_NAME_VALUE_PAIRS, BAGGAGE_MAX_TOTAL_LENGTH;
var init_constants = __esm({
"../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js"() {
"use strict";
init_esm_shims();
BAGGAGE_KEY_PAIR_SEPARATOR = "=";
BAGGAGE_PROPERTIES_SEPARATOR = ";";
BAGGAGE_ITEMS_SEPARATOR = ",";
BAGGAGE_HEADER = "baggage";
BAGGAGE_MAX_NAME_VALUE_PAIRS = 180;
BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = 4096;
BAGGAGE_MAX_TOTAL_LENGTH = 8192;
}
});
// ../../node_modules/@opentelemetry/core/build/esm/baggage/utils.js
var utils_exports = {};
__export(utils_exports, {
getKeyPairs: () => getKeyPairs,
parseKeyPairsIntoRecord: () => parseKeyPairsIntoRecord,
parsePairKeyValue: () => parsePairKeyValue,
serializeKeyPairs: () => serializeKeyPairs
});
function serializeKeyPairs(keyPairs) {
return keyPairs.reduce(function(hValue, current) {
var value = "" + hValue + (hValue !== "" ? BAGGAGE_ITEMS_SEPARATOR : "") + current;
return value.length > BAGGAGE_MAX_TOTAL_LENGTH ? hValue : value;
}, "");
}
function getKeyPairs(baggage) {
return baggage.getAllEntries().map(function(_a2) {
var _b = __read(_a2, 2), key = _b[0], value = _b[1];
var entry = encodeURIComponent(key) + "=" + encodeURIComponent(value.value);
if (value.metadata !== void 0) {
entry += BAGGAGE_PROPERTIES_SEPARATOR + value.metadata.toString();
}
return entry;
});
}
function parsePairKeyValue(entry) {
var valueProps = entry.split(BAGGAGE_PROPERTIES_SEPARATOR);
if (valueProps.length <= 0)
return;
var keyPairPart = valueProps.shift();
if (!keyPairPart)
return;
var separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
if (separatorIndex <= 0)
return;
var key = decodeURIComponent(keyPairPart.substring(0, separatorIndex).trim());
var value = decodeURIComponent(keyPairPart.substring(separatorIndex + 1).trim());
var metadata;
if (valueProps.length > 0) {
metadata = baggageEntryMetadataFromString(valueProps.join(BAGGAGE_PROPERTIES_SEPARATOR));
}
return { key, value, metadata };
}
function parseKeyPairsIntoRecord(value) {
if (typeof value !== "string" || value.length === 0)
return {};
return value.split(BAGGAGE_ITEMS_SEPARATOR).map(function(entry) {
return parsePairKeyValue(entry);
}).filter(function(keyPair) {
return keyPair !== void 0 && keyPair.value.length > 0;
}).reduce(function(headers, keyPair) {
headers[keyPair.key] = keyPair.value;
return headers;
}, {});
}
var __read;
var init_utils = __esm({
"../../node_modules/@opentelemetry/core/build/esm/baggage/utils.js"() {
"use strict";
init_esm_shims();
init_esm();
init_constants();
__read = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
};
}
});
// ../../node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js
var W3CBaggagePropagator;
var init_W3CBaggagePropagator = __esm({
"../../node_modules/@opentelemetry/core/build/esm/baggage/propagation/W3CBaggagePropagator.js"() {
"use strict";
init_esm_shims();
init_esm();
init_suppress_tracing();
init_constants();
init_utils();
W3CBaggagePropagator = /** @class */
function() {
function W3CBaggagePropagator2() {
}
W3CBaggagePropagator2.prototype.inject = function(context2, carrier, setter) {
var baggage = propagation.getBaggage(context2);
if (!baggage || isTracingSuppressed(context2))
return;
var keyPairs = getKeyPairs(baggage).filter(function(pair) {
return pair.length <= BAGGAGE_MAX_PER_NAME_VALUE_PAIRS;
}).slice(0, BAGGAGE_MAX_NAME_VALUE_PAIRS);
var headerValue = serializeKeyPairs(keyPairs);
if (headerValue.length > 0) {
setter.set(carrier, BAGGAGE_HEADER, headerValue);
}
};
W3CBaggagePropagator2.prototype.extract = function(context2, carrier, getter) {
var headerValue = getter.get(carrier, BAGGAGE_HEADER);
var baggageString = Array.isArray(headerValue) ? headerValue.join(BAGGAGE_ITEMS_SEPARATOR) : headerValue;
if (!baggageString)
return context2;
var baggage = {};
if (baggageString.length === 0) {
return context2;
}
var pairs = baggageString.split(BAGGAGE_ITEMS_SEPARATOR);
pairs.forEach(function(entry) {
var keyPair = parsePairKeyValue(entry);
if (keyPair) {
var baggageEntry = { value: keyPair.value };
if (keyPair.metadata) {
baggageEntry.metadata = keyPair.metadata;
}
baggage[keyPair.key] = baggageEntry;
}
});
if (Object.entries(baggage).length === 0) {
return context2;
}
return propagation.setBaggage(context2, propagation.createBaggage(baggage));
};
W3CBaggagePropagator2.prototype.fields = function() {
return [BAGGAGE_HEADER];
};
return W3CBaggagePropagator2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js
var AnchoredClock;
var init_anchored_clock = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/anchored-clock.js"() {
"use strict";
init_esm_shims();
AnchoredClock = /** @class */
function() {
function AnchoredClock2(systemClock, monotonicClock) {
this._monotonicClock = monotonicClock;
this._epochMillis = systemClock.now();
this._performanceMillis = monotonicClock.now();
}
AnchoredClock2.prototype.now = function() {
var delta = this._monotonicClock.now() - this._performanceMillis;
return this._epochMillis + delta;
};
return AnchoredClock2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/attributes.js
function sanitizeAttributes(attributes) {
var e_1, _a2;
var out = {};
if (typeof attributes !== "object" || attributes == null) {
return out;
}
try {
for (var _b = __values(Object.entries(attributes)), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read2(_c.value, 2), key = _d[0], val = _d[1];
if (!isAttributeKey(key)) {
diag.warn("Invalid attribute key: " + key);
continue;
}
if (!isAttributeValue(val)) {
diag.warn("Invalid attribute value set for key: " + key);
continue;
}
if (Array.isArray(val)) {
out[key] = val.slice();
} else {
out[key] = val;
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
} finally {
if (e_1) throw e_1.error;
}
}
return out;
}
function isAttributeKey(key) {
return typeof key === "string" && key.length > 0;
}
function isAttributeValue(val) {
if (val == null) {
return true;
}
if (Array.isArray(val)) {
return isHomogeneousAttributeValueArray(val);
}
return isValidPrimitiveAttributeValue(val);
}
function isHomogeneousAttributeValueArray(arr) {
var e_2, _a2;
var type;
try {
for (var arr_1 = __values(arr), arr_1_1 = arr_1.next(); !arr_1_1.done; arr_1_1 = arr_1.next()) {
var element = arr_1_1.value;
if (element == null)
continue;
if (!type) {
if (isValidPrimitiveAttributeValue(element)) {
type = typeof element;
continue;
}
return false;
}
if (typeof element === type) {
continue;
}
return false;
}
} catch (e_2_1) {
e_2 = { error: e_2_1 };
} finally {
try {
if (arr_1_1 && !arr_1_1.done && (_a2 = arr_1.return)) _a2.call(arr_1);
} finally {
if (e_2) throw e_2.error;
}
}
return true;
}
function isValidPrimitiveAttributeValue(val) {
switch (typeof val) {
case "number":
case "boolean":
case "string":
return true;
}
return false;
}
var __values, __read2;
var init_attributes = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/attributes.js"() {
"use strict";
init_esm_shims();
init_esm();
__values = function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function() {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
__read2 = function(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
} catch (error) {
e = { error };
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
};
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
function loggingErrorHandler() {
return function(ex) {
diag.error(stringifyException(ex));
};
}
function stringifyException(ex) {
if (typeof ex === "string") {
return ex;
} else {
return JSON.stringify(flattenException(ex));
}
}
function flattenException(ex) {
var result = {};
var current = ex;
while (current !== null) {
Object.getOwnPropertyNames(current).forEach(function(propertyName) {
if (result[propertyName])
return;
var value = current[propertyName];
if (value) {
result[propertyName] = String(value);
}
});
current = Object.getPrototypeOf(current);
}
return result;
}
var init_logging_error_handler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js"() {
"use strict";
init_esm_shims();
init_esm();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
function setGlobalErrorHandler(handler) {
delegateHandler = handler;
}
function globalErrorHandler(ex) {
try {
delegateHandler(ex);
} catch (_a2) {
}
}
var delegateHandler;
var init_global_error_handler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js"() {
"use strict";
init_esm_shims();
init_logging_error_handler();
delegateHandler = loggingErrorHandler();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/utils/sampling.js
var TracesSamplerValues;
var init_sampling = __esm({
"../../node_modules/@opentelemetry/core/build/esm/utils/sampling.js"() {
"use strict";
init_esm_shims();
(function(TracesSamplerValues2) {
TracesSamplerValues2["AlwaysOff"] = "always_off";
TracesSamplerValues2["AlwaysOn"] = "always_on";
TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off";
TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on";
TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
TracesSamplerValues2["TraceIdRatio"] = "traceidratio";
})(TracesSamplerValues || (TracesSamplerValues = {}));
}
});
// ../../node_modules/@opentelemetry/core/build/esm/utils/environment.js
function isEnvVarABoolean(key) {
return ENVIRONMENT_BOOLEAN_KEYS.indexOf(key) > -1;
}
function isEnvVarANumber(key) {
return ENVIRONMENT_NUMBERS_KEYS.indexOf(key) > -1;
}
function isEnvVarAList(key) {
return ENVIRONMENT_LISTS_KEYS.indexOf(key) > -1;
}
function parseBoolean(key, environment, values) {
if (typeof values[key] === "undefined") {
return;
}
var value = String(values[key]);
environment[key] = value.toLowerCase() === "true";
}
function parseNumber(name, environment, values, min, max) {
if (min === void 0) {
min = -Infinity;
}
if (max === void 0) {
max = Infinity;
}
if (typeof values[name] !== "undefined") {
var value = Number(values[name]);
if (!isNaN(value)) {
if (value < min) {
environment[name] = min;
} else if (value > max) {
environment[name] = max;
} else {
environment[name] = value;
}
}
}
}
function parseStringList(name, output, input, separator) {
if (separator === void 0) {
separator = DEFAULT_LIST_SEPARATOR;
}
var givenValue = input[name];
if (typeof givenValue === "string") {
output[name] = givenValue.split(separator).map(function(v) {
return v.trim();
});
}
}
function setLogLevelFromEnv(key, environment, values) {
var value = values[key];
if (typeof value === "string") {
var theLevel = logLevelMap[value.toUpperCase()];
if (theLevel != null) {
environment[key] = theLevel;
}
}
}
function parseEnvironment(values) {
var environment = {};
for (var env in DEFAULT_ENVIRONMENT) {
var key = env;
switch (key) {
case "OTEL_LOG_LEVEL":
setLogLevelFromEnv(key, environment, values);
break;
default:
if (isEnvVarABoolean(key)) {
parseBoolean(key, environment, values);
} else if (isEnvVarANumber(key)) {
parseNumber(key, environment, values);
} else if (isEnvVarAList(key)) {
parseStringList(key, environment, values);
} else {
var value = values[key];
if (typeof value !== "undefined" && value !== null) {
environment[key] = String(value);
}
}
}
}
return environment;
}
var DEFAULT_LIST_SEPARATOR, ENVIRONMENT_BOOLEAN_KEYS, ENVIRONMENT_NUMBERS_KEYS, ENVIRONMENT_LISTS_KEYS, DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT, DEFAULT_ATTRIBUTE_COUNT_LIMIT, DEFAULT_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT, DEFAULT_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT, DEFAULT_ENVIRONMENT, logLevelMap;
var init_environment = __esm({
"../../node_modules/@opentelemetry/core/build/esm/utils/environment.js"() {
"use strict";
init_esm_shims();
init_esm();
init_sampling();
DEFAULT_LIST_SEPARATOR = ",";
ENVIRONMENT_BOOLEAN_KEYS = ["OTEL_SDK_DISABLED"];
ENVIRONMENT_NUMBERS_KEYS = [
"OTEL_BSP_EXPORT_TIMEOUT",
"OTEL_BSP_MAX_EXPORT_BATCH_SIZE",
"OTEL_BSP_MAX_QUEUE_SIZE",
"OTEL_BSP_SCHEDULE_DELAY",
"OTEL_BLRP_EXPORT_TIMEOUT",
"OTEL_BLRP_MAX_EXPORT_BATCH_SIZE",
"OTEL_BLRP_MAX_QUEUE_SIZE",
"OTEL_BLRP_SCHEDULE_DELAY",
"OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT",
"OTEL_ATTRIBUTE_COUNT_LIMIT",
"OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT",
"OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT",
"OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT",
"OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT",
"OTEL_SPAN_EVENT_COUNT_LIMIT",
"OTEL_SPAN_LINK_COUNT_LIMIT",
"OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT",
"OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT",
"OTEL_EXPORTER_OTLP_TIMEOUT",
"OTEL_EXPORTER_OTLP_TRACES_TIMEOUT",
"OTEL_EXPORTER_OTLP_METRICS_TIMEOUT",
"OTEL_EXPORTER_OTLP_LOGS_TIMEOUT",
"OTEL_EXPORTER_JAEGER_AGENT_PORT"
];
ENVIRONMENT_LISTS_KEYS = [
"OTEL_NO_PATCH_MODULES",
"OTEL_PROPAGATORS"
];
DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
DEFAULT_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 128;
DEFAULT_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 128;
DEFAULT_ENVIRONMENT = {
OTEL_SDK_DISABLED: false,
CONTAINER_NAME: "",
ECS_CONTAINER_METADATA_URI_V4: "",
ECS_CONTAINER_METADATA_URI: "",
HOSTNAME: "",
KUBERNETES_SERVICE_HOST: "",
NAMESPACE: "",
OTEL_BSP_EXPORT_TIMEOUT: 3e4,
OTEL_BSP_MAX_EXPORT_BATCH_SIZE: 512,
OTEL_BSP_MAX_QUEUE_SIZE: 2048,
OTEL_BSP_SCHEDULE_DELAY: 5e3,
OTEL_BLRP_EXPORT_TIMEOUT: 3e4,
OTEL_BLRP_MAX_EXPORT_BATCH_SIZE: 512,
OTEL_BLRP_MAX_QUEUE_SIZE: 2048,
OTEL_BLRP_SCHEDULE_DELAY: 5e3,
OTEL_EXPORTER_JAEGER_AGENT_HOST: "",
OTEL_EXPORTER_JAEGER_AGENT_PORT: 6832,
OTEL_EXPORTER_JAEGER_ENDPOINT: "",
OTEL_EXPORTER_JAEGER_PASSWORD: "",
OTEL_EXPORTER_JAEGER_USER: "",
OTEL_EXPORTER_OTLP_ENDPOINT: "",
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: "",
OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: "",
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: "",
OTEL_EXPORTER_OTLP_HEADERS: "",
OTEL_EXPORTER_OTLP_TRACES_HEADERS: "",
OTEL_EXPORTER_OTLP_METRICS_HEADERS: "",
OTEL_EXPORTER_OTLP_LOGS_HEADERS: "",
OTEL_EXPORTER_OTLP_TIMEOUT: 1e4,
OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: 1e4,
OTEL_EXPORTER_OTLP_METRICS_TIMEOUT: 1e4,
OTEL_EXPORTER_OTLP_LOGS_TIMEOUT: 1e4,
OTEL_EXPORTER_ZIPKIN_ENDPOINT: "http://localhost:9411/api/v2/spans",
OTEL_LOG_LEVEL: DiagLogLevel.INFO,
OTEL_NO_PATCH_MODULES: [],
OTEL_PROPAGATORS: ["tracecontext", "baggage"],
OTEL_RESOURCE_ATTRIBUTES: "",
OTEL_SERVICE_NAME: "",
OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
OTEL_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT: DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT,
OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT: DEFAULT_ATTRIBUTE_COUNT_LIMIT,
OTEL_SPAN_EVENT_COUNT_LIMIT: 128,
OTEL_SPAN_LINK_COUNT_LIMIT: 128,
OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT: DEFAULT_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT: DEFAULT_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT,
OTEL_TRACES_EXPORTER: "",
OTEL_TRACES_SAMPLER: TracesSamplerValues.ParentBasedAlwaysOn,
OTEL_TRACES_SAMPLER_ARG: "",
OTEL_LOGS_EXPORTER: "",
OTEL_EXPORTER_OTLP_INSECURE: "",
OTEL_EXPORTER_OTLP_TRACES_INSECURE: "",
OTEL_EXPORTER_OTLP_METRICS_INSECURE: "",
OTEL_EXPORTER_OTLP_LOGS_INSECURE: "",
OTEL_EXPORTER_OTLP_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_COMPRESSION: "",
OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: "",
OTEL_EXPORTER_OTLP_METRICS_COMPRESSION: "",
OTEL_EXPORTER_OTLP_LOGS_COMPRESSION: "",
OTEL_EXPORTER_OTLP_CLIENT_KEY: "",
OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY: "",
OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY: "",
OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY: "",
OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE: "",
OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf",
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL: "http/protobuf",
OTEL_EXPORTER_OTLP_METRICS_PROTOCOL: "http/protobuf",
OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: "http/protobuf",
OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE: "cumulative"
};
logLevelMap = {
ALL: DiagLogLevel.ALL,
VERBOSE: DiagLogLevel.VERBOSE,
DEBUG: DiagLogLevel.DEBUG,
INFO: DiagLogLevel.INFO,
WARN: DiagLogLevel.WARN,
ERROR: DiagLogLevel.ERROR,
NONE: DiagLogLevel.NONE
};
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
function getEnv() {
var processEnv = parseEnvironment(process.env);
return Object.assign({}, DEFAULT_ENVIRONMENT, processEnv);
}
function getEnvWithoutDefaults() {
return parseEnvironment(process.env);
}
var init_environment2 = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/environment.js"() {
"use strict";
init_esm_shims();
init_environment();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/globalThis.js
var _globalThis;
var init_globalThis = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/globalThis.js"() {
"use strict";
init_esm_shims();
_globalThis = typeof globalThis === "object" ? globalThis : global;
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/hex-to-binary.js
function intValue(charCode) {
if (charCode >= 48 && charCode <= 57) {
return charCode - 48;
}
if (charCode >= 97 && charCode <= 102) {
return charCode - 87;
}
return charCode - 55;
}
function hexToBinary(hexStr) {
var buf = new Uint8Array(hexStr.length / 2);
var offset = 0;
for (var i = 0; i < hexStr.length; i += 2) {
var hi = intValue(hexStr.charCodeAt(i));
var lo = intValue(hexStr.charCodeAt(i + 1));
buf[offset++] = hi << 4 | lo;
}
return buf;
}
var init_hex_to_binary = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/hex-to-binary.js"() {
"use strict";
init_esm_shims();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/hex-to-base64.js
function hexToBase64(hexStr) {
return Buffer.from(hexToBinary(hexStr)).toString("base64");
}
var init_hex_to_base64 = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/hex-to-base64.js"() {
"use strict";
init_esm_shims();
init_hex_to_binary();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/RandomIdGenerator.js
function getIdGenerator(bytes) {
return function generateId() {
for (var i = 0; i < bytes / 4; i++) {
SHARED_BUFFER.writeUInt32BE(Math.random() * Math.pow(2, 32) >>> 0, i * 4);
}
for (var i = 0; i < bytes; i++) {
if (SHARED_BUFFER[i] > 0) {
break;
} else if (i === bytes - 1) {
SHARED_BUFFER[bytes - 1] = 1;
}
}
return SHARED_BUFFER.toString("hex", 0, bytes);
};
}
var SPAN_ID_BYTES, TRACE_ID_BYTES, RandomIdGenerator, SHARED_BUFFER;
var init_RandomIdGenerator = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/RandomIdGenerator.js"() {
"use strict";
init_esm_shims();
SPAN_ID_BYTES = 8;
TRACE_ID_BYTES = 16;
RandomIdGenerator = /** @class */
/* @__PURE__ */ function() {
function RandomIdGenerator2() {
this.generateTraceId = getIdGenerator(TRACE_ID_BYTES);
this.generateSpanId = getIdGenerator(SPAN_ID_BYTES);
}
return RandomIdGenerator2;
}();
SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/performance.js
import { performance } from "perf_hooks";
var otperformance;
var init_performance = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/performance.js"() {
"use strict";
init_esm_shims();
otperformance = performance;
}
});
// ../../node_modules/@opentelemetry/core/build/esm/version.js
var VERSION;
var init_version = __esm({
"../../node_modules/@opentelemetry/core/build/esm/version.js"() {
"use strict";
init_esm_shims();
VERSION = "1.25.1";
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
var _a, SDK_INFO;
var init_sdk_info = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js"() {
"use strict";
init_esm_shims();
init_version();
init_esm2();
SDK_INFO = (_a = {}, _a[SEMRESATTRS_TELEMETRY_SDK_NAME] = "opentelemetry", _a[SEMRESATTRS_PROCESS_RUNTIME_NAME] = "node", _a[SEMRESATTRS_TELEMETRY_SDK_LANGUAGE] = TELEMETRYSDKLANGUAGEVALUES_NODEJS, _a[SEMRESATTRS_TELEMETRY_SDK_VERSION] = VERSION, _a);
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js
function unrefTimer(timer) {
timer.unref();
}
var init_timer_util = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/timer-util.js"() {
"use strict";
init_esm_shims();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js
var init_node = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js"() {
"use strict";
init_esm_shims();
init_environment2();
init_globalThis();
init_hex_to_base64();
init_RandomIdGenerator();
init_performance();
init_sdk_info();
init_timer_util();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/platform/index.js
var init_platform = __esm({
"../../node_modules/@opentelemetry/core/build/esm/platform/index.js"() {
"use strict";
init_esm_shims();
init_node();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/time.js
function millisToHrTime(epochMillis) {
var epochSeconds = epochMillis / 1e3;
var seconds = Math.trunc(epochSeconds);
var nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
return [seconds, nanos];
}
function getTimeOrigin() {
var timeOrigin = otperformance.timeOrigin;
if (typeof timeOrigin !== "number") {
var perf = otperformance;
timeOrigin = perf.timing && perf.timing.fetchStart;
}
return timeOrigin;
}
function hrTime(performanceNow) {
var timeOrigin = millisToHrTime(getTimeOrigin());
var now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
return addHrTimes(timeOrigin, now);
}
function timeInputToHrTime(time) {
if (isTimeInputHrTime(time)) {
return time;
} else if (typeof time === "number") {
if (time < getTimeOrigin()) {
return hrTime(time);
} else {
return millisToHrTime(time);
}
} else if (time instanceof Date) {
return millisToHrTime(time.getTime());
} else {
throw TypeError("Invalid input type");
}
}
function hrTimeDuration(startTime, endTime) {
var seconds = endTime[0] - startTime[0];
var nanos = endTime[1] - startTime[1];
if (nanos < 0) {
seconds -= 1;
nanos += SECOND_TO_NANOSECONDS;
}
return [seconds, nanos];
}
function hrTimeToTimeStamp(time) {
var precision = NANOSECOND_DIGITS;
var tmp = "" + "0".repeat(precision) + time[1] + "Z";
var nanoString = tmp.substr(tmp.length - precision - 1);
var date = new Date(time[0] * 1e3).toISOString();
return date.replace("000Z", nanoString);
}
function hrTimeToNanoseconds(time) {
return time[0] * SECOND_TO_NANOSECONDS + time[1];
}
function hrTimeToMilliseconds(time) {
return time[0] * 1e3 + time[1] / 1e6;
}
function hrTimeToMicroseconds(time) {
return time[0] * 1e6 + time[1] / 1e3;
}
function isTimeInputHrTime(value) {
return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
}
function isTimeInput(value) {
return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
}
function addHrTimes(time1, time2) {
var out = [time1[0] + time2[0], time1[1] + time2[1]];
if (out[1] >= SECOND_TO_NANOSECONDS) {
out[1] -= SECOND_TO_NANOSECONDS;
out[0] += 1;
}
return out;
}
var NANOSECOND_DIGITS, NANOSECOND_DIGITS_IN_MILLIS, MILLISECONDS_TO_NANOSECONDS, SECOND_TO_NANOSECONDS;
var init_time = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/time.js"() {
"use strict";
init_esm_shims();
init_platform();
NANOSECOND_DIGITS = 9;
NANOSECOND_DIGITS_IN_MILLIS = 6;
MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
}
});
// ../../node_modules/@opentelemetry/core/build/esm/common/types.js
var init_types = __esm({
"../../node_modules/@opentelemetry/core/build/esm/common/types.js"() {
"use strict";
init_esm_shims();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/ExportResult.js
var ExportResultCode;
var init_ExportResult = __esm({
"../../node_modules/@opentelemetry/core/build/esm/ExportResult.js"() {
"use strict";
init_esm_shims();
(function(ExportResultCode2) {
ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
})(ExportResultCode || (ExportResultCode = {}));
}
});
// ../../node_modules/@opentelemetry/core/build/esm/propagation/composite.js
var __values2, CompositePropagator;
var init_composite = __esm({
"../../node_modules/@opentelemetry/core/build/esm/propagation/composite.js"() {
"use strict";
init_esm_shims();
init_esm();
__values2 = function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function() {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
CompositePropagator = /** @class */
function() {
function CompositePropagator2(config) {
if (config === void 0) {
config = {};
}
var _a2;
this._propagators = (_a2 = config.propagators) !== null && _a2 !== void 0 ? _a2 : [];
this._fields = Array.from(new Set(this._propagators.map(function(p) {
return typeof p.fields === "function" ? p.fields() : [];
}).reduce(function(x, y) {
return x.concat(y);
}, [])));
}
CompositePropagator2.prototype.inject = function(context2, carrier, setter) {
var e_1, _a2;
try {
for (var _b = __values2(this._propagators), _c = _b.next(); !_c.done; _c = _b.next()) {
var propagator = _c.value;
try {
propagator.inject(context2, carrier, setter);
} catch (err) {
diag.warn("Failed to inject with " + propagator.constructor.name + ". Err: " + err.message);
}
}
} catch (e_1_1) {
e_1 = { error: e_1_1 };
} finally {
try {
if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
} finally {
if (e_1) throw e_1.error;
}
}
};
CompositePropagator2.prototype.extract = function(context2, carrier, getter) {
return this._propagators.reduce(function(ctx, propagator) {
try {
return propagator.extract(ctx, carrier, getter);
} catch (err) {
diag.warn("Failed to inject with " + propagator.constructor.name + ". Err: " + err.message);
}
return ctx;
}, context2);
};
CompositePropagator2.prototype.fields = function() {
return this._fields.slice();
};
return CompositePropagator2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/internal/validators.js
function validateKey(key) {
return VALID_KEY_REGEX.test(key);
}
function validateValue(value) {
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
}
var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
var init_validators = __esm({
"../../node_modules/@opentelemetry/core/build/esm/internal/validators.js"() {
"use strict";
init_esm_shims();
VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
VALID_KEY = "[a-z]" + VALID_KEY_CHAR_RANGE + "{0,255}";
VALID_VENDOR_KEY = "[a-z0-9]" + VALID_KEY_CHAR_RANGE + "{0,240}@[a-z]" + VALID_KEY_CHAR_RANGE + "{0,13}";
VALID_KEY_REGEX = new RegExp("^(?:" + VALID_KEY + "|" + VALID_VENDOR_KEY + ")$");
VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/TraceState.js
var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, TraceState;
var init_TraceState = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/TraceState.js"() {
"use strict";
init_esm_shims();
init_validators();
MAX_TRACE_STATE_ITEMS = 32;
MAX_TRACE_STATE_LEN = 512;
LIST_MEMBERS_SEPARATOR = ",";
LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
TraceState = /** @class */
function() {
function TraceState2(rawTraceState) {
this._internalState = /* @__PURE__ */ new Map();
if (rawTraceState)
this._parse(rawTraceState);
}
TraceState2.prototype.set = function(key, value) {
var traceState = this._clone();
if (traceState._internalState.has(key)) {
traceState._internalState.delete(key);
}
traceState._internalState.set(key, value);
return traceState;
};
TraceState2.prototype.unset = function(key) {
var traceState = this._clone();
traceState._internalState.delete(key);
return traceState;
};
TraceState2.prototype.get = function(key) {
return this._internalState.get(key);
};
TraceState2.prototype.serialize = function() {
var _this = this;
return this._keys().reduce(function(agg, key) {
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + _this.get(key));
return agg;
}, []).join(LIST_MEMBERS_SEPARATOR);
};
TraceState2.prototype._parse = function(rawTraceState) {
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
return;
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reverse().reduce(function(agg, part) {
var listMember = part.trim();
var i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
if (i !== -1) {
var key = listMember.slice(0, i);
var value = listMember.slice(i + 1, part.length);
if (validateKey(key) && validateValue(value)) {
agg.set(key, value);
} else {
}
}
return agg;
}, /* @__PURE__ */ new Map());
if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
}
};
TraceState2.prototype._keys = function() {
return Array.from(this._internalState.keys()).reverse();
};
TraceState2.prototype._clone = function() {
var traceState = new TraceState2();
traceState._internalState = new Map(this._internalState);
return traceState;
};
return TraceState2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js
function parseTraceParent(traceParent) {
var match2 = TRACE_PARENT_REGEX.exec(traceParent);
if (!match2)
return null;
if (match2[1] === "00" && match2[5])
return null;
return {
traceId: match2[2],
spanId: match2[3],
traceFlags: parseInt(match2[4], 16)
};
}
var TRACE_PARENT_HEADER, TRACE_STATE_HEADER, VERSION2, VERSION_PART, TRACE_ID_PART, PARENT_ID_PART, FLAGS_PART, TRACE_PARENT_REGEX, W3CTraceContextPropagator;
var init_W3CTraceContextPropagator = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/W3CTraceContextPropagator.js"() {
"use strict";
init_esm_shims();
init_esm();
init_suppress_tracing();
init_TraceState();
TRACE_PARENT_HEADER = "traceparent";
TRACE_STATE_HEADER = "tracestate";
VERSION2 = "00";
VERSION_PART = "(?!ff)[\\da-f]{2}";
TRACE_ID_PART = "(?![0]{32})[\\da-f]{32}";
PARENT_ID_PART = "(?![0]{16})[\\da-f]{16}";
FLAGS_PART = "[\\da-f]{2}";
TRACE_PARENT_REGEX = new RegExp("^\\s?(" + VERSION_PART + ")-(" + TRACE_ID_PART + ")-(" + PARENT_ID_PART + ")-(" + FLAGS_PART + ")(-.*)?\\s?$");
W3CTraceContextPropagator = /** @class */
function() {
function W3CTraceContextPropagator2() {
}
W3CTraceContextPropagator2.prototype.inject = function(context2, carrier, setter) {
var spanContext = trace.getSpanContext(context2);
if (!spanContext || isTracingSuppressed(context2) || !isSpanContextValid(spanContext))
return;
var traceParent = VERSION2 + "-" + spanContext.traceId + "-" + spanContext.spanId + "-0" + Number(spanContext.traceFlags || TraceFlags.NONE).toString(16);
setter.set(carrier, TRACE_PARENT_HEADER, traceParent);
if (spanContext.traceState) {
setter.set(carrier, TRACE_STATE_HEADER, spanContext.traceState.serialize());
}
};
W3CTraceContextPropagator2.prototype.extract = function(context2, carrier, getter) {
var traceParentHeader = getter.get(carrier, TRACE_PARENT_HEADER);
if (!traceParentHeader)
return context2;
var traceParent = Array.isArray(traceParentHeader) ? traceParentHeader[0] : traceParentHeader;
if (typeof traceParent !== "string")
return context2;
var spanContext = parseTraceParent(traceParent);
if (!spanContext)
return context2;
spanContext.isRemote = true;
var traceStateHeader = getter.get(carrier, TRACE_STATE_HEADER);
if (traceStateHeader) {
var state = Array.isArray(traceStateHeader) ? traceStateHeader.join(",") : traceStateHeader;
spanContext.traceState = new TraceState(typeof state === "string" ? state : void 0);
}
return trace.setSpanContext(context2, spanContext);
};
W3CTraceContextPropagator2.prototype.fields = function() {
return [TRACE_PARENT_HEADER, TRACE_STATE_HEADER];
};
return W3CTraceContextPropagator2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/IdGenerator.js
var init_IdGenerator = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/IdGenerator.js"() {
"use strict";
init_esm_shims();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js
function setRPCMetadata(context2, meta) {
return context2.setValue(RPC_METADATA_KEY, meta);
}
function deleteRPCMetadata(context2) {
return context2.deleteValue(RPC_METADATA_KEY);
}
function getRPCMetadata(context2) {
return context2.getValue(RPC_METADATA_KEY);
}
var RPC_METADATA_KEY, RPCType;
var init_rpc_metadata = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/rpc-metadata.js"() {
"use strict";
init_esm_shims();
init_esm();
RPC_METADATA_KEY = createContextKey("OpenTelemetry SDK Context Key RPC_METADATA");
(function(RPCType2) {
RPCType2["HTTP"] = "http";
})(RPCType || (RPCType = {}));
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/sampler/AlwaysOffSampler.js
var AlwaysOffSampler;
var init_AlwaysOffSampler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/sampler/AlwaysOffSampler.js"() {
"use strict";
init_esm_shims();
init_esm();
AlwaysOffSampler = /** @class */
function() {
function AlwaysOffSampler2() {
}
AlwaysOffSampler2.prototype.shouldSample = function() {
return {
decision: SamplingDecision.NOT_RECORD
};
};
AlwaysOffSampler2.prototype.toString = function() {
return "AlwaysOffSampler";
};
return AlwaysOffSampler2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/sampler/AlwaysOnSampler.js
var AlwaysOnSampler;
var init_AlwaysOnSampler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/sampler/AlwaysOnSampler.js"() {
"use strict";
init_esm_shims();
init_esm();
AlwaysOnSampler = /** @class */
function() {
function AlwaysOnSampler2() {
}
AlwaysOnSampler2.prototype.shouldSample = function() {
return {
decision: SamplingDecision.RECORD_AND_SAMPLED
};
};
AlwaysOnSampler2.prototype.toString = function() {
return "AlwaysOnSampler";
};
return AlwaysOnSampler2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/sampler/ParentBasedSampler.js
var ParentBasedSampler;
var init_ParentBasedSampler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/sampler/ParentBasedSampler.js"() {
"use strict";
init_esm_shims();
init_esm();
init_global_error_handler();
init_AlwaysOffSampler();
init_AlwaysOnSampler();
ParentBasedSampler = /** @class */
function() {
function ParentBasedSampler2(config) {
var _a2, _b, _c, _d;
this._root = config.root;
if (!this._root) {
globalErrorHandler(new Error("ParentBasedSampler must have a root sampler configured"));
this._root = new AlwaysOnSampler();
}
this._remoteParentSampled = (_a2 = config.remoteParentSampled) !== null && _a2 !== void 0 ? _a2 : new AlwaysOnSampler();
this._remoteParentNotSampled = (_b = config.remoteParentNotSampled) !== null && _b !== void 0 ? _b : new AlwaysOffSampler();
this._localParentSampled = (_c = config.localParentSampled) !== null && _c !== void 0 ? _c : new AlwaysOnSampler();
this._localParentNotSampled = (_d = config.localParentNotSampled) !== null && _d !== void 0 ? _d : new AlwaysOffSampler();
}
ParentBasedSampler2.prototype.shouldSample = function(context2, traceId, spanName, spanKind, attributes, links) {
var parentContext = trace.getSpanContext(context2);
if (!parentContext || !isSpanContextValid(parentContext)) {
return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
}
if (parentContext.isRemote) {
if (parentContext.traceFlags & TraceFlags.SAMPLED) {
return this._remoteParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
}
return this._remoteParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
}
if (parentContext.traceFlags & TraceFlags.SAMPLED) {
return this._localParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
}
return this._localParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
};
ParentBasedSampler2.prototype.toString = function() {
return "ParentBased{root=" + this._root.toString() + ", remoteParentSampled=" + this._remoteParentSampled.toString() + ", remoteParentNotSampled=" + this._remoteParentNotSampled.toString() + ", localParentSampled=" + this._localParentSampled.toString() + ", localParentNotSampled=" + this._localParentNotSampled.toString() + "}";
};
return ParentBasedSampler2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/trace/sampler/TraceIdRatioBasedSampler.js
var TraceIdRatioBasedSampler;
var init_TraceIdRatioBasedSampler = __esm({
"../../node_modules/@opentelemetry/core/build/esm/trace/sampler/TraceIdRatioBasedSampler.js"() {
"use strict";
init_esm_shims();
init_esm();
TraceIdRatioBasedSampler = /** @class */
function() {
function TraceIdRatioBasedSampler2(_ratio) {
if (_ratio === void 0) {
_ratio = 0;
}
this._ratio = _ratio;
this._ratio = this._normalize(_ratio);
this._upperBound = Math.floor(this._ratio * 4294967295);
}
TraceIdRatioBasedSampler2.prototype.shouldSample = function(context2, traceId) {
return {
decision: isValidTraceId(traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision.RECORD_AND_SAMPLED : SamplingDecision.NOT_RECORD
};
};
TraceIdRatioBasedSampler2.prototype.toString = function() {
return "TraceIdRatioBased{" + this._ratio + "}";
};
TraceIdRatioBasedSampler2.prototype._normalize = function(ratio) {
if (typeof ratio !== "number" || isNaN(ratio))
return 0;
return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
};
TraceIdRatioBasedSampler2.prototype._accumulate = function(traceId) {
var accumulation = 0;
for (var i = 0; i < traceId.length / 8; i++) {
var pos = i * 8;
var part = parseInt(traceId.slice(pos, pos + 8), 16);
accumulation = (accumulation ^ part) >>> 0;
}
return accumulation;
};
return TraceIdRatioBasedSampler2;
}();
}
});
// ../../node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
function isPlainObject(value) {
if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
return false;
}
var proto = getPrototype(value);
if (proto === null) {
return true;
}
var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
}
function isObjectLike(value) {
return value != null && typeof value == "object";
}
function baseGetTag(value) {
if (value == null) {
return value === void 0 ? undefinedTag : nullTag;
}
return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
}
function getRawTag(value) {
var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
var unmasked = false;
try {
value[symToStringTag] = void 0;
unmasked = true;
} catch (e) {
}
var result = nativeObjectToString.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag] = tag;
} else {
delete value[symToStringTag];
}
}
return result;
}
function objectToString(value) {
return nativeObjectToString.call(value);
}
var objectTag, nullTag, undefinedTag, funcProto, funcToString, objectCtorString, getPrototype, objectProto, hasOwnProperty, symToStringTag, nativeObjectToString;
var init_lodash_merge = __esm({
"../../node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js"() {
"use strict";
init_esm_shims();
objectTag = "[object Object]";
nullTag = "[object Null]";
undefinedTag = "[object Undefined]";
funcProto = Function.prototyp