@use-tusk/drift-node-sdk 0.1.30 → 0.1.31

package/dist/index.cjs

@@ -6214,7 +6214,7 @@ var JsonSchema$Type = class extends import_commonjs$7.MessageType {
 const JsonSchema = new JsonSchema$Type();
 
 //#endregion
-//#region node_modules/@use-tusk/drift-schemas/dist/span-CXrr1reB.js
+//#region node_modules/@use-tusk/drift-schemas/dist/span-Cklxe7uf.js
 var import_commonjs$6 = /* @__PURE__ */ __toESM(require_commonjs$2(), 1);
 /**
 * Package type classification enum
@@ -6572,6 +6572,13 @@ var Span$Type = class extends import_commonjs$6.MessageType {
 				kind: "scalar",
 				opt: true,
 				T: 9
+			},
+			{
+				no: 25,
+				name: "id",
+				kind: "scalar",
+				opt: true,
+				T: 9
 			}
 		]);
 	}
@@ -6672,6 +6679,9 @@ var Span$Type = class extends import_commonjs$6.MessageType {
 				case 24:
 					message.environment = reader.string();
 					break;
+				case 25:
+					message.id = reader.string();
+					break;
 				default:
 					let u = options.readUnknownField;
 					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
@@ -6706,6 +6716,7 @@ var Span$Type = class extends import_commonjs$6.MessageType {
 		if (message.isRootSpan !== false) writer.tag(22, import_commonjs$6.WireType.Varint).bool(message.isRootSpan);
 		if (message.metadata) Struct.internalBinaryWrite(message.metadata, writer.tag(23, import_commonjs$6.WireType.LengthDelimited).fork(), options).join();
 		if (message.environment !== void 0) writer.tag(24, import_commonjs$6.WireType.LengthDelimited).string(message.environment);
+		if (message.id !== void 0) writer.tag(25, import_commonjs$6.WireType.LengthDelimited).string(message.id);
 		let u = options.writeUnknownFields;
 		if (u !== false) (u == true ? import_commonjs$6.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
 		return writer;
@@ -10236,7 +10247,7 @@ var require_commonjs$1 = /* @__PURE__ */ __commonJS({ "node_modules/@protobuf-ts
 }) });
 
 //#endregion
-//#region node_modules/@use-tusk/drift-schemas/dist/span_export_service-RmRqNxn1.js
+//#region node_modules/@use-tusk/drift-schemas/dist/span_export_service-BjPTFjCJ.js
 var import_commonjs$4 = /* @__PURE__ */ __toESM(require_commonjs$1(), 1);
 var import_commonjs$5 = /* @__PURE__ */ __toESM(require_commonjs$2(), 1);
 var ExportSpansRequest$Type = class extends import_commonjs$5.MessageType {
@@ -15775,7 +15786,7 @@ var TdMysql2ConnectionMock = class extends events.EventEmitter {
 	}
 	query(...args) {
 		logger.debug(`[TdMysql2ConnectionMock] Mock connection query intercepted in REPLAY mode`);
-		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock"]);
+		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock", "Mysql2Instrumentation"]);
 		const queryConfig = this.mysql2Instrumentation.parseQueryArgs(args);
 		if (!queryConfig || !queryConfig.sql) {
 			logger.debug(`[TdMysql2ConnectionMock] Could not parse mock connection query, returning empty result`);
@@ -15790,16 +15801,16 @@ var TdMysql2ConnectionMock = class extends events.EventEmitter {
 			return Promise.resolve([emptyResult.rows, emptyResult.fields]);
 		}
 		const inputValue = createMockInputValue({
-			sql: queryConfig.sql,
+			sql: this.mysql2Instrumentation.normalizeSqlForMockMatching(queryConfig.sql),
 			values: queryConfig.values || [],
 			clientType: this.clientType
 		});
-		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, "query", stackTrace);
 		else return this.mysql2Instrumentation.handleNoOpReplayQuery(queryConfig);
 	}
 	execute(...args) {
 		logger.debug(`[TdMysql2ConnectionMock] Mock connection execute intercepted in REPLAY mode`);
-		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock"]);
+		const stackTrace = captureStackTrace(["TdMysql2ConnectionMock", "Mysql2Instrumentation"]);
 		const queryConfig = this.mysql2Instrumentation.parseQueryArgs(args);
 		if (!queryConfig || !queryConfig.sql) {
 			logger.debug(`[TdMysql2ConnectionMock] Could not parse mock connection execute, returning empty result`);
@@ -15814,11 +15825,11 @@ var TdMysql2ConnectionMock = class extends events.EventEmitter {
 			return Promise.resolve([emptyResult.rows, emptyResult.fields]);
 		}
 		const inputValue = createMockInputValue({
-			sql: queryConfig.sql,
+			sql: this.mysql2Instrumentation.normalizeSqlForMockMatching(queryConfig.sql),
 			values: queryConfig.values || [],
 			clientType: this.clientType
 		});
-		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, stackTrace);
+		if (this.spanInfo) return this.mysql2Instrumentation.handleReplayQuery(queryConfig, inputValue, this.spanInfo, "execute", stackTrace);
 		else return this.mysql2Instrumentation.handleNoOpReplayQuery(queryConfig);
 	}
 	release() {
@@ -16153,6 +16164,8 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 	constructor(config = {}) {
 		super("mysql2", config);
 		this.INSTRUMENTATION_NAME = "Mysql2Instrumentation";
+		this.CONTEXT_BOUND_CONNECTION = Symbol("mysql2-context-bound-connection");
+		this.CONTEXT_BOUND_PARENT_CONTEXT = Symbol("mysql2-bound-parent-context");
 		this.mode = config.mode || TuskDriftMode.DISABLED;
 		this.queryMock = new TdMysql2QueryMock();
 	}
@@ -16382,7 +16395,7 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					return originalQuery.apply(this, args);
 				}
 				const inputValue = {
-					sql: queryConfig.sql,
+					sql: self.normalizeSqlForMockMatching(queryConfig.sql),
 					values: queryConfig.values || [],
 					clientType
 				};
@@ -16449,7 +16462,7 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					return originalExecute.apply(this, args);
 				}
 				const inputValue = {
-					sql: queryConfig.sql,
+					sql: self.normalizeSqlForMockMatching(queryConfig.sql),
 					values: queryConfig.values || [],
 					clientType
 				};
@@ -17045,6 +17058,14 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		}
 		return null;
 	}
+	normalizeSqlForMockMatching(sql) {
+		if (!sql) return sql;
+		const trimmed = sql.trim();
+		if (/^savepoint\s+trx\d+\s*;?$/i.test(trimmed)) return trimmed.replace(/^(savepoint\s+)trx\d+(\s*;?)$/i, "$1trx$2");
+		if (/^release\s+savepoint\s+trx\d+\s*;?$/i.test(trimmed)) return trimmed.replace(/^(release\s+savepoint\s+)trx\d+(\s*;?)$/i, "$1trx$2");
+		if (/^rollback\s+to\s+savepoint\s+trx\d+\s*;?$/i.test(trimmed)) return trimmed.replace(/^(rollback\s+to\s+savepoint\s+)trx\d+(\s*;?)$/i, "$1trx$2");
+		return sql;
+	}
 	_handleRecordQueryInSpan(spanInfo, originalQuery, queryConfig, args, context$6) {
 		const hasCallback = !!queryConfig.callback;
 		const invokeOriginal = (invokeArgs) => {
@@ -17128,8 +17149,10 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 		return this.queryMock.handleNoOpReplayQuery(queryConfig);
 	}
 	_handleRecordPoolGetConnectionInSpan(spanInfo, originalGetConnection, callback, context$6) {
+		const parentContext = import_src$22.context.active();
 		if (callback) {
 			const wrappedCallback = (error, connection) => {
+				const scopedConnection = connection ? this._bindConnectionMethodsToContext(connection, parentContext) : connection;
 				if (error) {
 					logger.debug(`[Mysql2Instrumentation] MySQL2 Pool getConnection error: ${error.message} (${SpanUtils.getTraceInfo()})`);
 					try {
@@ -17145,44 +17168,71 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 					try {
 						SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
 							connected: true,
-							hasConnection: !!connection
+							hasConnection: !!scopedConnection
 						} });
 						SpanUtils.endSpan(spanInfo.span, { code: import_src$22.SpanStatusCode.OK });
 					} catch (error$1) {
 						logger.error(`[Mysql2Instrumentation] error processing getConnection response:`, error$1);
 					}
 				}
-				return callback(error, connection);
+				return import_src$22.context.with(parentContext, () => callback(error, scopedConnection));
 			};
-			return originalGetConnection.call(context$6, wrappedCallback);
-		} else return originalGetConnection.call(context$6).then((connection) => {
-			logger.debug(`[Mysql2Instrumentation] MySQL2 Pool getConnection completed successfully (${SpanUtils.getTraceInfo()})`);
-			try {
-				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
-					connected: true,
-					hasConnection: !!connection
-				} });
-				SpanUtils.endSpan(spanInfo.span, { code: import_src$22.SpanStatusCode.OK });
-			} catch (error) {
-				logger.error(`[Mysql2Instrumentation] error processing getConnection response:`, error);
-			}
-			return connection;
+			return import_src$22.context.with(parentContext, () => originalGetConnection.call(context$6, wrappedCallback));
+		} else return import_src$22.context.with(parentContext, () => originalGetConnection.call(context$6)).then((connection) => {
+			const scopedConnection = this._bindConnectionMethodsToContext(connection, parentContext);
+			return import_src$22.context.with(parentContext, () => {
+				logger.debug(`[Mysql2Instrumentation] MySQL2 Pool getConnection completed successfully (${SpanUtils.getTraceInfo()})`);
+				try {
+					SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
+						connected: true,
+						hasConnection: !!scopedConnection
+					} });
+					SpanUtils.endSpan(spanInfo.span, { code: import_src$22.SpanStatusCode.OK });
+				} catch (error) {
+					logger.error(`[Mysql2Instrumentation] error processing getConnection response:`, error);
+				}
+				return scopedConnection;
+			});
 		}).catch((error) => {
-			logger.debug(`[Mysql2Instrumentation] MySQL2 Pool getConnection error: ${error.message} (${SpanUtils.getTraceInfo()})`);
-			try {
-				SpanUtils.endSpan(spanInfo.span, {
-					code: import_src$22.SpanStatusCode.ERROR,
-					message: error.message
-				});
-			} catch (error$1) {
-				logger.error(`[Mysql2Instrumentation] error ending span:`, error$1);
-			}
-			throw error;
+			return import_src$22.context.with(parentContext, () => {
+				logger.debug(`[Mysql2Instrumentation] MySQL2 Pool getConnection error: ${error.message} (${SpanUtils.getTraceInfo()})`);
+				try {
+					SpanUtils.endSpan(spanInfo.span, {
+						code: import_src$22.SpanStatusCode.ERROR,
+						message: error.message
+					});
+				} catch (error$1) {
+					logger.error(`[Mysql2Instrumentation] error ending span:`, error$1);
+				}
+				throw error;
+			});
 		});
 	}
+	_bindConnectionMethodsToContext(connection, parentContext) {
+		const conn = connection;
+		if (!conn) return connection;
+		conn[this.CONTEXT_BOUND_PARENT_CONTEXT] = parentContext;
+		if (conn[this.CONTEXT_BOUND_CONNECTION]) return connection;
+		for (const method of [
+			"query",
+			"execute",
+			"beginTransaction",
+			"commit",
+			"rollback"
+		]) {
+			const original = conn[method];
+			if (typeof original !== "function") continue;
+			conn[method] = (...args) => {
+				const boundContext = conn[this.CONTEXT_BOUND_PARENT_CONTEXT] ?? import_src$22.context.active();
+				return import_src$22.context.with(boundContext, () => original.apply(conn, args));
+			};
+		}
+		conn[this.CONTEXT_BOUND_CONNECTION] = true;
+		return connection;
+	}
 	handleNoOpReplayGetConnection(callback) {
 		logger.debug(`[Mysql2Instrumentation] Background getConnection detected, returning mock connection`);
-		const mockConnection = new TdMysql2ConnectionMock(this, "pool");
+		const mockConnection = new TdMysql2ConnectionMock(this, "connection");
 		if (callback) {
 			process.nextTick(() => callback(null, mockConnection));
 			return;
@@ -17191,7 +17241,7 @@ var Mysql2Instrumentation = class extends TdInstrumentationBase {
 	}
 	_handleReplayPoolGetConnection(spanInfo, callback) {
 		logger.debug(`[Mysql2Instrumentation] Replaying MySQL2 Pool getConnection`);
-		const mockConnection = new TdMysql2ConnectionMock(this, "pool", spanInfo);
+		const mockConnection = new TdMysql2ConnectionMock(this, "connection", spanInfo);
 		if (callback) {
 			process.nextTick(() => callback(null, mockConnection));
 			return;
@@ -25905,13 +25955,188 @@ var require_src$6 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/co
 }) });
 
 //#endregion
-//#region src/core/tracing/SpanTransformer.ts
+//#region src/core/rustCoreBinding.ts
 var import_src$10 = /* @__PURE__ */ __toESM(require_src$6(), 1);
+let bindingLoadAttempted = false;
+let binding = null;
+let bindingLoadError = null;
+function getRustCoreEnvDecision() {
+	const raw = process.env.TUSK_USE_RUST_CORE;
+	if (!raw) return {
+		enabled: true,
+		reason: "default_on",
+		rawEnv: null
+	};
+	const normalized = raw.trim().toLowerCase();
+	if ([
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(normalized)) return {
+		enabled: true,
+		reason: "env_enabled",
+		rawEnv: raw
+	};
+	if ([
+		"0",
+		"false",
+		"no",
+		"off"
+	].includes(normalized)) return {
+		enabled: false,
+		reason: "env_disabled",
+		rawEnv: raw
+	};
+	return {
+		enabled: true,
+		reason: "invalid_env_value_defaulted",
+		rawEnv: raw
+	};
+}
+function loadBinding() {
+	if (bindingLoadAttempted) return binding;
+	bindingLoadAttempted = true;
+	if (!getRustCoreEnvDecision().enabled) return null;
+	try {
+		binding = require("@use-tusk/drift-core-node");
+		bindingLoadError = null;
+	} catch (error) {
+		binding = null;
+		bindingLoadError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+	}
+	return binding;
+}
+function getRustCoreStartupStatus() {
+	const decision = getRustCoreEnvDecision();
+	const loaded = decision.enabled ? loadBinding() : null;
+	return {
+		enabled: decision.enabled,
+		reason: decision.reason,
+		rawEnv: decision.rawEnv,
+		bindingLoaded: loaded !== null,
+		bindingError: bindingLoadError
+	};
+}
+function toRustSchemaMerges(schemaMerges) {
+	if (!schemaMerges) return;
+	const out = {};
+	for (const [key, value] of Object.entries(schemaMerges)) out[key] = {
+		...value.encoding !== void 0 ? { encoding: value.encoding } : {},
+		...value.decodedType !== void 0 ? { decoded_type: value.decodedType } : {},
+		...value.matchImportance !== void 0 ? { match_importance: value.matchImportance } : {}
+	};
+	return out;
+}
+function normalizeSchemaKeys(value) {
+	if (Array.isArray(value)) return value.map(normalizeSchemaKeys);
+	if (!value || typeof value !== "object") return value;
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (k === "decoded_type") out.decodedType = normalizeSchemaKeys(v);
+	else if (k === "match_importance") out.matchImportance = normalizeSchemaKeys(v);
+	else out[k] = normalizeSchemaKeys(v);
+	return out;
+}
+function denormalizeSchemaKeys(value) {
+	if (Array.isArray(value)) return value.map(denormalizeSchemaKeys);
+	if (!value || typeof value !== "object") return value;
+	const out = {};
+	for (const [k, v] of Object.entries(value)) if (k === "decodedType") out.decoded_type = denormalizeSchemaKeys(v);
+	else if (k === "matchImportance") out.match_importance = denormalizeSchemaKeys(v);
+	else out[k] = denormalizeSchemaKeys(v);
+	return out;
+}
+function processExportPayloadJsonable(payload, schemaMerges) {
+	const loaded = loadBinding();
+	if (!loaded) return null;
+	try {
+		const payloadJson = JSON.stringify(payload);
+		const rustSchemaMerges = toRustSchemaMerges(schemaMerges);
+		const schemaMergesJson = rustSchemaMerges ? JSON.stringify(rustSchemaMerges) : void 0;
+		const result = loaded.processExportPayload(payloadJson, schemaMergesJson);
+		return {
+			normalizedValue: JSON.parse(result.normalizedJson),
+			decodedValueHash: result.decodedValueHash,
+			decodedSchema: normalizeSchemaKeys(JSON.parse(result.decodedSchemaJson)),
+			decodedSchemaHash: result.decodedSchemaHash
+		};
+	} catch {
+		return null;
+	}
+}
+function buildSpanProtoBytes(input) {
+	const loaded = loadBinding();
+	if (!loaded) return null;
+	try {
+		const rustInput = {
+			traceId: input.traceId,
+			spanId: input.spanId,
+			parentSpanId: input.parentSpanId,
+			name: input.name,
+			packageName: input.packageName,
+			instrumentationName: input.instrumentationName,
+			submoduleName: input.submoduleName,
+			packageType: input.packageType,
+			environment: input.environment,
+			kind: input.kind,
+			inputSchemaJson: JSON.stringify(denormalizeSchemaKeys(input.inputSchema)),
+			outputSchemaJson: JSON.stringify(denormalizeSchemaKeys(input.outputSchema)),
+			inputSchemaHash: input.inputSchemaHash,
+			outputSchemaHash: input.outputSchemaHash,
+			inputValueHash: input.inputValueHash,
+			outputValueHash: input.outputValueHash,
+			statusCode: input.statusCode,
+			statusMessage: input.statusMessage,
+			isPreAppStart: input.isPreAppStart,
+			isRootSpan: input.isRootSpan,
+			timestampSeconds: input.timestampSeconds,
+			timestampNanos: input.timestampNanos,
+			durationSeconds: input.durationSeconds,
+			durationNanos: input.durationNanos,
+			metadataJson: input.metadata === void 0 ? void 0 : JSON.stringify(input.metadata),
+			inputValueJson: input.inputValue === void 0 ? void 0 : JSON.stringify(input.inputValue),
+			outputValueJson: input.outputValue === void 0 ? void 0 : JSON.stringify(input.outputValue),
+			inputValueProtoStructBytes: input.inputValueProtoStructBytes,
+			outputValueProtoStructBytes: input.outputValueProtoStructBytes
+		};
+		return loaded.buildSpanProtoBytes(rustInput);
+	} catch {
+		return null;
+	}
+}
+function buildExportSpansRequestBytes(observableServiceId, environment, sdkVersion, sdkInstanceId, spanProtoBytesList) {
+	const loaded = loadBinding();
+	if (!loaded) return null;
+	try {
+		return loaded.buildExportSpansRequestBytes(observableServiceId, environment, sdkVersion, sdkInstanceId, spanProtoBytesList);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/core/tracing/SpanTransformer.ts
 var import_src$11 = /* @__PURE__ */ __toESM(require_src$7(), 1);
 /**
 * Utility class for transforming OpenTelemetry spans to CleanSpanData
 */
 var SpanTransformer = class SpanTransformer {
+	static processPayload(data, schemaMerges) {
+		const rustResult = processExportPayloadJsonable(data, schemaMerges);
+		if (rustResult) return {
+			normalizedValue: rustResult.normalizedValue,
+			schema: rustResult.decodedSchema,
+			decodedValueHash: rustResult.decodedValueHash,
+			decodedSchemaHash: rustResult.decodedSchemaHash
+		};
+		const { schema, decodedValueHash, decodedSchemaHash } = JsonSchemaHelper.generateSchemaAndHash(data, schemaMerges);
+		return {
+			normalizedValue: data,
+			schema,
+			decodedValueHash,
+			decodedSchemaHash
+		};
+	}
 	/**
 	* Transform OpenTelemetry span to clean JSON format with compile-time type safety
 	* Return type is derived from protobuf schema but uses clean JSON.
@@ -25927,7 +26152,7 @@ var SpanTransformer = class SpanTransformer {
 		const inputData = JSON.parse(inputValueString);
 		const inputSchemaMergesString = attributes[TdSpanAttributes.INPUT_SCHEMA_MERGES];
 		const inputSchemaMerges = inputSchemaMergesString ? JSON.parse(inputSchemaMergesString) : void 0;
-		const { schema: inputSchema, decodedValueHash: inputValueHash, decodedSchemaHash: inputSchemaHash } = JsonSchemaHelper.generateSchemaAndHash(inputData, inputSchemaMerges);
+		const { normalizedValue: normalizedInputData, schema: inputSchema, decodedValueHash: inputValueHash, decodedSchemaHash: inputSchemaHash } = SpanTransformer.processPayload(inputData, inputSchemaMerges);
 		let outputData = {};
 		let outputSchema = {
 			type: JsonSchemaType.OBJECT,
@@ -25940,8 +26165,8 @@ var SpanTransformer = class SpanTransformer {
 			outputData = JSON.parse(outputValueString);
 			const outputSchemaMergesString = attributes[TdSpanAttributes.OUTPUT_SCHEMA_MERGES];
 			const outputSchemaMerges = outputSchemaMergesString ? JSON.parse(outputSchemaMergesString) : void 0;
-			({schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = JsonSchemaHelper.generateSchemaAndHash(outputData, outputSchemaMerges));
-		} else ({schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = JsonSchemaHelper.generateSchemaAndHash(outputData));
+			({normalizedValue: outputData, schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = SpanTransformer.processPayload(outputData, outputSchemaMerges));
+		} else ({normalizedValue: outputData, schema: outputSchema, decodedValueHash: outputValueHash, decodedSchemaHash: outputSchemaHash} = SpanTransformer.processPayload(outputData));
 		let metadata = void 0;
 		if (attributes[TdSpanAttributes.METADATA]) metadata = JSON.parse(attributes[TdSpanAttributes.METADATA]);
 		let transformMetadata;
@@ -25951,6 +26176,35 @@ var SpanTransformer = class SpanTransformer {
 		} catch (error) {
 			logger.warn("[SpanTransformer] Failed to parse transform metadata", error);
 		}
+		const protoSpanBytes = buildSpanProtoBytes({
+			traceId: span.spanContext().traceId,
+			spanId: span.spanContext().spanId,
+			parentSpanId: span.parentSpanId || "",
+			name: attributes[TdSpanAttributes.NAME] || "",
+			packageName,
+			instrumentationName,
+			submoduleName: submoduleName || "",
+			packageType: attributes[TdSpanAttributes.PACKAGE_TYPE] || PackageType.UNSPECIFIED,
+			environment,
+			kind: span.kind,
+			inputSchema,
+			outputSchema,
+			inputSchemaHash,
+			outputSchemaHash,
+			inputValueHash,
+			outputValueHash,
+			statusCode: span.status.code === 1 ? StatusCode.OK : StatusCode.ERROR,
+			statusMessage: span.status.message || "",
+			isPreAppStart: attributes[TdSpanAttributes.IS_PRE_APP_START] === true,
+			isRootSpan,
+			timestampSeconds: span.startTime[0],
+			timestampNanos: span.startTime[1],
+			durationSeconds: span.duration[0],
+			durationNanos: span.duration[1],
+			metadata,
+			inputValue: normalizedInputData,
+			outputValue: outputData
+		});
 		return {
 			traceId: span.spanContext().traceId,
 			spanId: span.spanContext().spanId,
@@ -25961,7 +26215,7 @@ var SpanTransformer = class SpanTransformer {
 			submoduleName: submoduleName || "",
 			packageType: attributes[TdSpanAttributes.PACKAGE_TYPE] ?? void 0,
 			environment,
-			inputValue: inputData,
+			inputValue: normalizedInputData,
 			outputValue: outputData,
 			inputSchema,
 			outputSchema,
@@ -25985,7 +26239,8 @@ var SpanTransformer = class SpanTransformer {
 			},
 			isRootSpan,
 			metadata,
-			transformMetadata
+			transformMetadata,
+			protoSpanBytes: protoSpanBytes ?? void 0
 		};
 	}
 	/**
@@ -26409,6 +26664,8 @@ const DRIFT_API_PATH = "/api/drift";
 var ApiSpanAdapter = class {
 	constructor(config) {
 		this.name = "api";
+		this.apiKey = config.apiKey;
+		this.tuskBackendBaseUrl = config.tuskBackendBaseUrl;
 		this.observableServiceId = config.observableServiceId;
 		this.environment = config.environment;
 		this.sdkVersion = config.sdkVersion;
@@ -26424,6 +26681,24 @@ var ApiSpanAdapter = class {
 	}
 	async exportSpans(spans) {
 		try {
+			const rustRequestBytes = buildExportSpansRequestBytes(this.observableServiceId, this.environment || "", this.sdkVersion, this.sdkInstanceId, spans.map((s) => s.protoSpanBytes).filter((s) => Buffer.isBuffer(s)));
+			if (spans.length > 0 && spans.every((s) => Buffer.isBuffer(s.protoSpanBytes)) && rustRequestBytes) {
+				const response$1 = await fetch(`${this.tuskBackendBaseUrl}${DRIFT_API_PATH}/tusk.drift.backend.v1.SpanExportService/ExportSpans`, {
+					method: "POST",
+					headers: {
+						"x-api-key": this.apiKey,
+						"x-td-skip-instrumentation": "true",
+						"Content-Type": "application/protobuf"
+					},
+					body: new Uint8Array(rustRequestBytes)
+				});
+				if (!response$1.ok) throw new Error(`Remote export failed with status ${response$1.status}`);
+				const responseBytes = new Uint8Array(await response$1.arrayBuffer());
+				const parsed = ExportSpansResponse.fromBinary(responseBytes);
+				if (!parsed.success) throw new Error(`Remote export failed: ${parsed.message}`);
+				logger.debug(`Successfully exported ${spans.length} spans to remote endpoint (rust binary path)`);
+				return { code: import_src$8.ExportResultCode.SUCCESS };
+			}
 			const protoSpans = spans.map((span) => this.transformSpanToProtobuf(span));
 			const request = {
 				observableServiceId: this.observableServiceId,
@@ -33735,7 +34010,7 @@ var require_src = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/sdk-
 //#endregion
 //#region package.json
 var import_src$1 = /* @__PURE__ */ __toESM(require_src(), 1);
-var version = "0.1.30";
+var version = "0.1.31";
 
 //#endregion
 //#region src/version.ts
@@ -33743,7 +34018,7 @@ const SDK_VERSION = version;
 const MIN_CLI_VERSION = "0.1.0";
 
 //#endregion
-//#region node_modules/@use-tusk/drift-schemas/dist/communication-GAvDDkJW.js
+//#region node_modules/@use-tusk/drift-schemas/dist/communication-DR7GLSjb.js
 var import_commonjs = /* @__PURE__ */ __toESM(require_commonjs$1(), 1);
 var import_commonjs$1 = /* @__PURE__ */ __toESM(require_commonjs$2(), 1);
 /**
@@ -35624,6 +35899,20 @@ var TuskDriftCore = class TuskDriftCore {
 			default: return TuskDriftMode.DISABLED;
 		}
 	}
+	logRustCoreStartupStatus() {
+		const status = getRustCoreStartupStatus();
+		const envDisplay = status.rawEnv ?? "<unset>";
+		if (status.reason === "invalid_env_value_defaulted") logger.warn(`Invalid TUSK_USE_RUST_CORE value '${envDisplay}'; defaulting to enabled rust core path.`);
+		if (!status.enabled) {
+			logger.info(`Rust core path disabled at startup (env=${envDisplay}, reason=${status.reason}).`);
+			return;
+		}
+		if (status.bindingLoaded) {
+			logger.info(`Rust core path enabled at startup (env=${envDisplay}, reason=${status.reason}).`);
+			return;
+		}
+		logger.warn(`Rust core path requested but binding unavailable; falling back to JavaScript path (env=${envDisplay}, reason=${status.reason}, error=${status.bindingError}).`);
+	}
 	validateSamplingRate(value, source) {
 		if (typeof value !== "number" || isNaN(value)) {
 			logger.warn(`Invalid sampling rate from ${source}: not a number. Ignoring.`);
@@ -35806,6 +36095,7 @@ var TuskDriftCore = class TuskDriftCore {
 			logger.debug("SDK disabled via environment variable");
 			return;
 		}
+		this.logRustCoreStartupStatus();
 		logger.debug(`Initializing in ${this.mode} mode`);
 		if (!this.initParams.env) {
 			const nodeEnv = OriginalGlobalUtils.getOriginalProcessEnvVar("NODE_ENV") || "development";