@safaricom-mxl/web-sdk 0.0.11 → 0.0.13

package/dist/packages/otlp-transformer/dist/index.js

@@ -1,228 +1,532 @@
 //#region packages/otlp-transformer/dist/index.js
-function createResource(e, t) {
-	let r = {
-		attributes: toAttributes(e.attributes, t),
+const VERSION = "1.9.1";
+const re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+/**
+* Create a function to test an API version to see if it is compatible with the provided ownVersion.
+*
+* The returned function has the following semantics:
+* - Exact match is always compatible
+* - Major versions must match exactly
+*    - 1.x package cannot use global 2.x package
+*    - 2.x package cannot use global 1.x package
+* - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+*    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+*    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+* - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+* - Patch and build tag differences are not considered at this time
+*
+* @param ownVersion version which should be checked against
+*/
+function _makeCompatibilityCheck(ownVersion) {
+	const acceptedVersions = new Set([ownVersion]);
+	const rejectedVersions = /* @__PURE__ */ new Set();
+	const myVersionMatch = ownVersion.match(re);
+	if (!myVersionMatch) return () => false;
+	const ownVersionParsed = {
+		major: +myVersionMatch[1],
+		minor: +myVersionMatch[2],
+		patch: +myVersionMatch[3],
+		prerelease: myVersionMatch[4]
+	};
+	if (ownVersionParsed.prerelease != null) return function isExactmatch(globalVersion) {
+		return globalVersion === ownVersion;
+	};
+	function _reject(v) {
+		rejectedVersions.add(v);
+		return false;
+	}
+	function _accept(v) {
+		acceptedVersions.add(v);
+		return true;
+	}
+	return function isCompatible(globalVersion) {
+		if (acceptedVersions.has(globalVersion)) return true;
+		if (rejectedVersions.has(globalVersion)) return false;
+		const globalVersionMatch = globalVersion.match(re);
+		if (!globalVersionMatch) return _reject(globalVersion);
+		const globalVersionParsed = {
+			major: +globalVersionMatch[1],
+			minor: +globalVersionMatch[2],
+			patch: +globalVersionMatch[3],
+			prerelease: globalVersionMatch[4]
+		};
+		if (globalVersionParsed.prerelease != null) return _reject(globalVersion);
+		if (ownVersionParsed.major !== globalVersionParsed.major) return _reject(globalVersion);
+		if (ownVersionParsed.major === 0) {
+			if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) return _accept(globalVersion);
+			return _reject(globalVersion);
+		}
+		if (ownVersionParsed.minor <= globalVersionParsed.minor) return _accept(globalVersion);
+		return _reject(globalVersion);
+	};
+}
+/**
+* Test an API version to see if it is compatible with this API.
+*
+* - Exact match is always compatible
+* - Major versions must match exactly
+*    - 1.x package cannot use global 2.x package
+*    - 2.x package cannot use global 1.x package
+* - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+*    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+*    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+* - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+* - Patch and build tag differences are not considered at this time
+*
+* @param version version of the API requesting an instance of the global API
+*/
+const isCompatible = _makeCompatibilityCheck(VERSION);
+const major = VERSION.split(".")[0];
+const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+const _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag, allowOverride = false) {
+	var _a;
+	const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : { version: VERSION };
+	if (!allowOverride && api[type]) {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+		diag.error(err.stack || err.message);
+		return false;
+	}
+	if (api.version !== "1.9.1") {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+		diag.error(err.stack || err.message);
+		return false;
+	}
+	api[type] = instance;
+	diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+	return true;
+}
+function getGlobal(type) {
+	var _a, _b;
+	const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+	if (!globalVersion || !isCompatible(globalVersion)) return;
+	return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+}
+function unregisterGlobal(type, diag) {
+	diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+	const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+	if (api) delete api[type];
+}
+/**
+* Component Logger which is meant to be used as part of any component which
+* will add automatically additional namespace in front of the log message.
+* It will then forward all message to global diag logger
+* @example
+* const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
+* cLogger.debug('test');
+* // @opentelemetry/instrumentation-http test
+*/
+var DiagComponentLogger = class {
+	constructor(props) {
+		this._namespace = props.namespace || "DiagComponentLogger";
+	}
+	debug(...args) {
+		return logProxy("debug", this._namespace, args);
+	}
+	error(...args) {
+		return logProxy("error", this._namespace, args);
+	}
+	info(...args) {
+		return logProxy("info", this._namespace, args);
+	}
+	warn(...args) {
+		return logProxy("warn", this._namespace, args);
+	}
+	verbose(...args) {
+		return logProxy("verbose", this._namespace, args);
+	}
+};
+function logProxy(funcName, namespace, args) {
+	const logger = getGlobal("diag");
+	if (!logger) return;
+	return logger[funcName](namespace, ...args);
+}
+/**
+* Defines the available internal logging levels for the diagnostic logger, the numeric values
+* of the levels are defined to match the original values from the initial LogLevel to avoid
+* compatibility/migration issues for any implementation that assume the numeric ordering.
+*/
+var DiagLogLevel;
+(function(DiagLogLevel) {
+	/** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+	DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE";
+	/** Identifies an error scenario */
+	DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR";
+	/** Identifies a warning scenario */
+	DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN";
+	/** General informational log message */
+	DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO";
+	/** General debug log message */
+	DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG";
+	/**
+	* Detailed trace level logging should only be used for development, should only be set
+	* in a development environment.
+	*/
+	DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE";
+	/** Used to set the logging level to include all logging */
+	DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+function createLogLevelDiagLogger(maxLevel, logger) {
+	if (maxLevel < DiagLogLevel.NONE) maxLevel = DiagLogLevel.NONE;
+	else if (maxLevel > DiagLogLevel.ALL) maxLevel = DiagLogLevel.ALL;
+	logger = logger || {};
+	function _filterFunc(funcName, theLevel) {
+		const theFunc = logger[funcName];
+		if (typeof theFunc === "function" && maxLevel >= theLevel) return theFunc.bind(logger);
+		return function() {};
+	}
+	return {
+		error: _filterFunc("error", DiagLogLevel.ERROR),
+		warn: _filterFunc("warn", DiagLogLevel.WARN),
+		info: _filterFunc("info", DiagLogLevel.INFO),
+		debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+		verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+	};
+}
+const API_NAME = "diag";
+/**
+* Entrypoint for Diag API.
+* Defines Diagnostic handler used for internal diagnostic logging operations.
+* The default provides a Noop DiagLogger implementation which may be changed via the
+* diag.setLogger(logger: DiagLogger) function.
+*
+* @since 1.0.0
+*/
+const diag = class DiagAPI {
+	/** Get the singleton instance of the DiagAPI API */
+	static instance() {
+		if (!this._instance) this._instance = new DiagAPI();
+		return this._instance;
+	}
+	/**
+	* Private internal constructor
+	* @private
+	*/
+	constructor() {
+		function _logProxy(funcName) {
+			return function(...args) {
+				const logger = getGlobal("diag");
+				if (!logger) return;
+				return logger[funcName](...args);
+			};
+		}
+		const self = this;
+		const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+			var _a, _b, _c;
+			if (logger === self) {
+				const err = /* @__PURE__ */ new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+				self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+				return false;
+			}
+			if (typeof optionsOrLogLevel === "number") optionsOrLogLevel = { logLevel: optionsOrLogLevel };
+			const oldLogger = getGlobal("diag");
+			const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+			if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+				const stack = (_c = (/* @__PURE__ */ new Error()).stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+				oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+				newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+			}
+			return registerGlobal("diag", newLogger, self, true);
+		};
+		self.setLogger = setLogger;
+		self.disable = () => {
+			unregisterGlobal(API_NAME, self);
+		};
+		self.createComponentLogger = (options) => {
+			return new DiagComponentLogger(options);
+		};
+		self.verbose = _logProxy("verbose");
+		self.debug = _logProxy("debug");
+		self.info = _logProxy("info");
+		self.warn = _logProxy("warn");
+		self.error = _logProxy("error");
+	}
+}.instance();
+const SECOND_TO_NANOSECONDS = Math.pow(10, 9);
+/**
+* Convert hrTime to nanoseconds.
+* @param time
+*/
+function hrTimeToNanoseconds(time) {
+	return time[0] * SECOND_TO_NANOSECONDS + time[1];
+}
+function createResource(resource, encoder) {
+	const result = {
+		attributes: toAttributes(resource.attributes, encoder),
 		droppedAttributesCount: 0
-	}, i = e.schemaUrl;
-	return i && i !== `` && (r.schemaUrl = i), r;
+	};
+	const schemaUrl = resource.schemaUrl;
+	if (schemaUrl && schemaUrl !== "") result.schemaUrl = schemaUrl;
+	return result;
 }
-function createInstrumentationScope(e) {
+function createInstrumentationScope(scope) {
 	return {
-		name: e.name,
-		version: e.version
+		name: scope.name,
+		version: scope.version
 	};
 }
-function toAttributes(e, t) {
-	return Object.keys(e).map((n) => toKeyValue(n, e[n], t));
+function toAttributes(attributes, encoder) {
+	return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
 }
-function toKeyValue(e, t, n) {
+function toKeyValue(key, value, encoder) {
 	return {
-		key: e,
-		value: toAnyValue(t, n)
+		key,
+		value: toAnyValue(value, encoder)
 	};
 }
-function toAnyValue(e, t) {
-	let n = typeof e;
-	if (n === `string`) return { stringValue: e };
-	if (n === `number`) return Number.isInteger(e) ? { intValue: e } : { doubleValue: e };
-	if (n === `boolean`) return { boolValue: e };
-	if (e instanceof Uint8Array) return { bytesValue: t.encodeUint8Array(e) };
-	if (Array.isArray(e)) {
-		let n = Array(e.length);
-		for (let r = 0; r < e.length; r++) n[r] = toAnyValue(e[r], t);
-		return { arrayValue: { values: n } };
-	}
-	if (n === `object` && e != null) {
-		let n = Object.keys(e), r = Array(n.length);
-		for (let a = 0; a < n.length; a++) r[a] = {
-			key: n[a],
-			value: toAnyValue(e[n[a]], t)
+function toAnyValue(value, encoder) {
+	const t = typeof value;
+	if (t === "string") return { stringValue: value };
+	if (t === "number") {
+		if (!Number.isInteger(value)) return { doubleValue: value };
+		return { intValue: value };
+	}
+	if (t === "boolean") return { boolValue: value };
+	if (value instanceof Uint8Array) return { bytesValue: encoder.encodeUint8Array(value) };
+	if (Array.isArray(value)) {
+		const values = new Array(value.length);
+		for (let i = 0; i < value.length; i++) values[i] = toAnyValue(value[i], encoder);
+		return { arrayValue: { values } };
+	}
+	if (t === "object" && value != null) {
+		const keys = Object.keys(value);
+		const values = new Array(keys.length);
+		for (let i = 0; i < keys.length; i++) values[i] = {
+			key: keys[i],
+			value: toAnyValue(value[keys[i]], encoder)
 		};
-		return { kvlistValue: { values: r } };
+		return { kvlistValue: { values } };
 	}
 	return {};
 }
-function createExportLogsServiceRequest(e, t) {
-	return { resourceLogs: logRecordsToResourceLogs(e, t) };
+function hrTimeToNanos(hrTime) {
+	const NANOSECONDS = BigInt(1e9);
+	return BigInt(Math.trunc(hrTime[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime[1]));
+}
+function encodeAsString(hrTime) {
+	return hrTimeToNanos(hrTime).toString();
 }
-function createResourceMap$1(e) {
-	let t = /* @__PURE__ */ new Map();
-	for (let n of e) {
-		let { resource: e, instrumentationScope: { name: r, version: i = ``, schemaUrl: a = `` } } = n, o = t.get(e);
-		o || (o = /* @__PURE__ */ new Map(), t.set(e, o));
-		let s = `${r}@${i}:${a}`, c = o.get(s);
-		c || (c = [], o.set(s, c)), c.push(n);
+const encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
+function identity(value) {
+	return value;
+}
+/**
+* Encoder for JSON format.
+* Uses string timestamps, hex for span/trace IDs, and base64 for Uint8Array.
+*/
+const JSON_ENCODER = {
+	encodeHrTime: encodeTimestamp,
+	encodeSpanContext: identity,
+	encodeOptionalSpanContext: identity,
+	encodeUint8Array: (bytes) => {
+		if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+		const chars = new Array(bytes.length);
+		for (let i = 0; i < bytes.length; i++) chars[i] = String.fromCharCode(bytes[i]);
+		return btoa(chars.join(""));
 	}
-	return t;
+};
+function createExportLogsServiceRequest(logRecords, encoder) {
+	return { resourceLogs: logRecordsToResourceLogs(logRecords, encoder) };
 }
-function logRecordsToResourceLogs(n, r) {
-	let i = createResourceMap$1(n);
-	return Array.from(i, ([n, i]) => {
-		let a = createResource(n, r);
+function createResourceMap$1(logRecords) {
+	const resourceMap = /* @__PURE__ */ new Map();
+	for (const record of logRecords) {
+		const { resource, instrumentationScope: { name, version = "", schemaUrl = "" } } = record;
+		let ismMap = resourceMap.get(resource);
+		if (!ismMap) {
+			ismMap = /* @__PURE__ */ new Map();
+			resourceMap.set(resource, ismMap);
+		}
+		const ismKey = `${name}@${version}:${schemaUrl}`;
+		let records = ismMap.get(ismKey);
+		if (!records) {
+			records = [];
+			ismMap.set(ismKey, records);
+		}
+		records.push(record);
+	}
+	return resourceMap;
+}
+function logRecordsToResourceLogs(logRecords, encoder) {
+	const resourceMap = createResourceMap$1(logRecords);
+	return Array.from(resourceMap, ([resource, ismMap]) => {
+		const processedResource = createResource(resource, encoder);
 		return {
-			resource: a,
-			scopeLogs: Array.from(i, ([, e]) => ({
-				scope: createInstrumentationScope(e[0].instrumentationScope),
-				logRecords: e.map((e) => toLogRecord(e, r)),
-				schemaUrl: e[0].instrumentationScope.schemaUrl
-			})),
-			schemaUrl: a.schemaUrl
+			resource: processedResource,
+			scopeLogs: Array.from(ismMap, ([, scopeLogs]) => {
+				return {
+					scope: createInstrumentationScope(scopeLogs[0].instrumentationScope),
+					logRecords: scopeLogs.map((log) => toLogRecord(log, encoder)),
+					schemaUrl: scopeLogs[0].instrumentationScope.schemaUrl
+				};
+			}),
+			schemaUrl: processedResource.schemaUrl
 		};
 	});
 }
-function toLogRecord(e, t) {
+function toLogRecord(log, encoder) {
 	return {
-		timeUnixNano: t.encodeHrTime(e.hrTime),
-		observedTimeUnixNano: t.encodeHrTime(e.hrTimeObserved),
-		severityNumber: toSeverityNumber(e.severityNumber),
-		severityText: e.severityText,
-		body: toAnyValue(e.body, t),
-		eventName: e.eventName,
-		attributes: toLogAttributes(e.attributes, t),
-		droppedAttributesCount: e.droppedAttributesCount,
-		flags: e.spanContext?.traceFlags,
-		traceId: t.encodeOptionalSpanContext(e.spanContext?.traceId),
-		spanId: t.encodeOptionalSpanContext(e.spanContext?.spanId)
+		timeUnixNano: encoder.encodeHrTime(log.hrTime),
+		observedTimeUnixNano: encoder.encodeHrTime(log.hrTimeObserved),
+		severityNumber: toSeverityNumber(log.severityNumber),
+		severityText: log.severityText,
+		body: toAnyValue(log.body, encoder),
+		eventName: log.eventName,
+		attributes: toLogAttributes(log.attributes, encoder),
+		droppedAttributesCount: log.droppedAttributesCount,
+		flags: log.spanContext?.traceFlags,
+		traceId: encoder.encodeOptionalSpanContext(log.spanContext?.traceId),
+		spanId: encoder.encodeOptionalSpanContext(log.spanContext?.spanId)
 	};
 }
-function toSeverityNumber(e) {
-	return e;
-}
-function toLogAttributes(e, t) {
-	return Object.keys(e).map((n) => toKeyValue(n, e[n], t));
-}
-const SECOND_TO_NANOSECONDS = 10 ** 9;
-function hrTimeToNanoseconds(e) {
-	return e[0] * SECOND_TO_NANOSECONDS + e[1];
-}
-function hrTimeToNanos(e) {
-	let t = BigInt(1e9);
-	return BigInt(Math.trunc(e[0])) * t + BigInt(Math.trunc(e[1]));
-}
-function encodeAsString(e) {
-	return hrTimeToNanos(e).toString();
+function toSeverityNumber(severityNumber) {
+	return severityNumber;
 }
-const encodeTimestamp = typeof BigInt < `u` ? encodeAsString : hrTimeToNanoseconds;
-function identity(e) {
-	return e;
+function toLogAttributes(attributes, encoder) {
+	return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
 }
-const JSON_ENCODER = {
-	encodeHrTime: encodeTimestamp,
-	encodeSpanContext: identity,
-	encodeOptionalSpanContext: identity,
-	encodeUint8Array: (e) => {
-		if (typeof Buffer < `u`) return Buffer.from(e).toString(`base64`);
-		let t = Array(e.length);
-		for (let n = 0; n < e.length; n++) t[n] = String.fromCharCode(e[n]);
-		return btoa(t.join(``));
+const JsonLogsSerializer = {
+	serializeRequest: (arg) => {
+		const request = createExportLogsServiceRequest(arg, JSON_ENCODER);
+		return new TextEncoder().encode(JSON.stringify(request));
+	},
+	deserializeResponse: (arg) => {
+		if (arg.length === 0) return {};
+		const decoder = new TextDecoder();
+		try {
+			return JSON.parse(decoder.decode(arg));
+		} catch (err) {
+			diag.warn(`Failed to parse logs export response: ${err.message}. Returning empty response`);
+			return {};
+		}
 	}
 };
-function buildSpanFlagsFrom(e, t) {
-	let n = e & 255 | 256;
-	return t && (n |= 512), n;
+const SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
+const SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
+/**
+* Builds the 32-bit span flags value combining the low 8-bit W3C TraceFlags
+* with the HAS_IS_REMOTE and IS_REMOTE bits according to the OTLP spec.
+*/
+function buildSpanFlagsFrom(traceFlags, isRemote) {
+	let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK;
+	if (isRemote) flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
+	return flags;
 }
-function sdkSpanToOtlpSpan(e, t) {
-	let r = e.spanContext(), i = e.status, a = e.parentSpanContext?.spanId ? t.encodeSpanContext(e.parentSpanContext?.spanId) : void 0;
+function sdkSpanToOtlpSpan(span, encoder) {
+	const ctx = span.spanContext();
+	const status = span.status;
+	const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0;
 	return {
-		traceId: t.encodeSpanContext(r.traceId),
-		spanId: t.encodeSpanContext(r.spanId),
-		parentSpanId: a,
-		traceState: r.traceState?.serialize(),
-		name: e.name,
-		kind: e.kind == null ? 0 : e.kind + 1,
-		startTimeUnixNano: t.encodeHrTime(e.startTime),
-		endTimeUnixNano: t.encodeHrTime(e.endTime),
-		attributes: toAttributes(e.attributes, t),
-		droppedAttributesCount: e.droppedAttributesCount,
-		events: e.events.map((e) => toOtlpSpanEvent(e, t)),
-		droppedEventsCount: e.droppedEventsCount,
+		traceId: encoder.encodeSpanContext(ctx.traceId),
+		spanId: encoder.encodeSpanContext(ctx.spanId),
+		parentSpanId,
+		traceState: ctx.traceState?.serialize(),
+		name: span.name,
+		kind: span.kind == null ? 0 : span.kind + 1,
+		startTimeUnixNano: encoder.encodeHrTime(span.startTime),
+		endTimeUnixNano: encoder.encodeHrTime(span.endTime),
+		attributes: toAttributes(span.attributes, encoder),
+		droppedAttributesCount: span.droppedAttributesCount,
+		events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
+		droppedEventsCount: span.droppedEventsCount,
 		status: {
-			code: i.code,
-			message: i.message
+			code: status.code,
+			message: status.message
 		},
-		links: e.links.map((e) => toOtlpLink(e, t)),
-		droppedLinksCount: e.droppedLinksCount,
-		flags: buildSpanFlagsFrom(r.traceFlags, e.parentSpanContext?.isRemote)
+		links: span.links.map((link) => toOtlpLink(link, encoder)),
+		droppedLinksCount: span.droppedLinksCount,
+		flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote)
 	};
 }
-function toOtlpLink(e, t) {
+function toOtlpLink(link, encoder) {
 	return {
-		attributes: e.attributes ? toAttributes(e.attributes, t) : [],
-		spanId: t.encodeSpanContext(e.context.spanId),
-		traceId: t.encodeSpanContext(e.context.traceId),
-		traceState: e.context.traceState?.serialize(),
-		droppedAttributesCount: e.droppedAttributesCount || 0,
-		flags: buildSpanFlagsFrom(e.context.traceFlags, e.context.isRemote)
+		attributes: link.attributes ? toAttributes(link.attributes, encoder) : [],
+		spanId: encoder.encodeSpanContext(link.context.spanId),
+		traceId: encoder.encodeSpanContext(link.context.traceId),
+		traceState: link.context.traceState?.serialize(),
+		droppedAttributesCount: link.droppedAttributesCount || 0,
+		flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote)
 	};
 }
-function toOtlpSpanEvent(e, t) {
+function toOtlpSpanEvent(timedEvent, encoder) {
 	return {
-		attributes: e.attributes ? toAttributes(e.attributes, t) : [],
-		name: e.name,
-		timeUnixNano: t.encodeHrTime(e.time),
-		droppedAttributesCount: e.droppedAttributesCount || 0
+		attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes, encoder) : [],
+		name: timedEvent.name,
+		timeUnixNano: encoder.encodeHrTime(timedEvent.time),
+		droppedAttributesCount: timedEvent.droppedAttributesCount || 0
 	};
 }
-function createExportTraceServiceRequest(e, t) {
-	return { resourceSpans: spanRecordsToResourceSpans(e, t) };
-}
-function createResourceMap(e) {
-	let t = /* @__PURE__ */ new Map();
-	for (let n of e) {
-		let e = t.get(n.resource);
-		e || (e = /* @__PURE__ */ new Map(), t.set(n.resource, e));
-		let r = `${n.instrumentationScope.name}@${n.instrumentationScope.version || ``}:${n.instrumentationScope.schemaUrl || ``}`, i = e.get(r);
-		i || (i = [], e.set(r, i)), i.push(n);
-	}
-	return t;
-}
-function spanRecordsToResourceSpans(n, r) {
-	let i = createResourceMap(n), a = [], o = i.entries(), s = o.next();
-	for (; !s.done;) {
-		let [n, i] = s.value, c = [], l = i.values(), u = l.next();
-		for (; !u.done;) {
-			let e = u.value;
-			if (e.length > 0) {
-				let n = e.map((e) => sdkSpanToOtlpSpan(e, r));
-				c.push({
-					scope: createInstrumentationScope(e[0].instrumentationScope),
-					spans: n,
-					schemaUrl: e[0].instrumentationScope.schemaUrl
+function createExportTraceServiceRequest(spans, encoder) {
+	return { resourceSpans: spanRecordsToResourceSpans(spans, encoder) };
+}
+function createResourceMap(readableSpans) {
+	const resourceMap = /* @__PURE__ */ new Map();
+	for (const record of readableSpans) {
+		let ilsMap = resourceMap.get(record.resource);
+		if (!ilsMap) {
+			ilsMap = /* @__PURE__ */ new Map();
+			resourceMap.set(record.resource, ilsMap);
+		}
+		const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
+		let records = ilsMap.get(instrumentationScopeKey);
+		if (!records) {
+			records = [];
+			ilsMap.set(instrumentationScopeKey, records);
+		}
+		records.push(record);
+	}
+	return resourceMap;
+}
+function spanRecordsToResourceSpans(readableSpans, encoder) {
+	const resourceMap = createResourceMap(readableSpans);
+	const out = [];
+	const entryIterator = resourceMap.entries();
+	let entry = entryIterator.next();
+	while (!entry.done) {
+		const [resource, ilmMap] = entry.value;
+		const scopeResourceSpans = [];
+		const ilmIterator = ilmMap.values();
+		let ilmEntry = ilmIterator.next();
+		while (!ilmEntry.done) {
+			const scopeSpans = ilmEntry.value;
+			if (scopeSpans.length > 0) {
+				const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
+				scopeResourceSpans.push({
+					scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
+					spans,
+					schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
 				});
 			}
-			u = l.next();
+			ilmEntry = ilmIterator.next();
 		}
-		let d = createResource(n, r), f = {
-			resource: d,
-			scopeSpans: c,
-			schemaUrl: d.schemaUrl
+		const processedResource = createResource(resource, encoder);
+		const transformedSpans = {
+			resource: processedResource,
+			scopeSpans: scopeResourceSpans,
+			schemaUrl: processedResource.schemaUrl
 		};
-		a.push(f), s = o.next();
+		out.push(transformedSpans);
+		entry = entryIterator.next();
 	}
-	return a;
+	return out;
 }
-const JsonLogsSerializer = {
-	serializeRequest: (e) => {
-		let t = createExportLogsServiceRequest(e, JSON_ENCODER);
-		return new TextEncoder().encode(JSON.stringify(t));
+const JsonTraceSerializer = {
+	serializeRequest: (arg) => {
+		const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
+		return new TextEncoder().encode(JSON.stringify(request));
 	},
-	deserializeResponse: (e) => {
-		if (e.length === 0) return {};
-		let t = new TextDecoder();
-		return JSON.parse(t.decode(e));
-	}
-}, JsonTraceSerializer = {
-	serializeRequest: (e) => {
-		let t = createExportTraceServiceRequest(e, JSON_ENCODER);
-		return new TextEncoder().encode(JSON.stringify(t));
-	},
-	deserializeResponse: (e) => {
-		if (e.length === 0) return {};
-		let t = new TextDecoder();
-		return JSON.parse(t.decode(e));
+	deserializeResponse: (arg) => {
+		if (arg.length === 0) return {};
+		const decoder = new TextDecoder();
+		try {
+			return JSON.parse(decoder.decode(arg));
+		} catch (err) {
+			diag.warn(`Failed to parse trace export response: ${err.message}. Returning empty response`);
+			return {};
+		}
 	}
 };
-
 //#endregion
 export { JsonLogsSerializer, JsonTraceSerializer };
+
 //# sourceMappingURL=index.js.map