@use-tusk/drift-node-sdk 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -91,7 +91,7 @@ var TdInstrumentationAbstract = class {
 
 //#endregion
 //#region package.json
-var version = "0.1.2";
+var version = "0.1.4";
 
 //#endregion
 //#region src/version.ts
@@ -1579,10 +1579,11 @@ async function findMockResponseAsync({ mockRequestData, tuskDrift, inputValueSch
 
 //#endregion
 //#region src/instrumentation/libraries/http/mocks/TdMockClientRequest.ts
+let ClientRequest;
 /**
 * Mock ClientRequest implementation for Tusk Drift HTTP replay
 */
-var TdMockClientRequest = class extends events.EventEmitter {
+var TdMockClientRequest = class TdMockClientRequest extends events.EventEmitter {
 	constructor(options, spanInfo, callback) {
 		super();
 		this.INSTRUMENTATION_NAME = "HttpInstrumentation";
@@ -1591,6 +1592,7 @@ var TdMockClientRequest = class extends events.EventEmitter {
 		this.playbackStarted = false;
 		this.readyToStartPlaybackOnSocketEvent = false;
 		this.headers = {};
+		TdMockClientRequest._setupPrototype();
 		this.tuskDrift = TuskDriftCore.getInstance();
 		this.spanInfo = spanInfo;
 		if (!options || Object.keys(options).length === 0) throw new Error("Making a request with empty `options` is not supported in TdMockClientRequest");
@@ -1831,8 +1833,16 @@ var TdMockClientRequest = class extends events.EventEmitter {
 		this.socket.destroy();
 		return this;
 	}
+	static _setupPrototype() {
+		if (!ClientRequest) {
+			ClientRequest = require("http").ClientRequest;
+			Object.setPrototypeOf(TdMockClientRequest.prototype, ClientRequest.prototype);
+		}
+	}
+	static initialize() {
+		TdMockClientRequest._setupPrototype();
+	}
 };
-Object.setPrototypeOf(TdMockClientRequest.prototype, http.ClientRequest.prototype);
 
 //#endregion
 //#region src/instrumentation/libraries/http/HttpReplayHooks.ts
@@ -2103,7 +2113,19 @@ var HttpTransformEngine = class {
 			const target = span[selector];
 			if (!target) return false;
 			try {
-				return jsonpath.default.apply(target.body, jsonPath, actionFunction).length > 0;
+				const body = target.body;
+				if (!body) return false;
+				let bodyObj;
+				if (typeof body === "string") try {
+					const decoded = Buffer.from(body, "base64").toString("utf8");
+					bodyObj = JSON.parse(decoded);
+				} catch (e) {
+					return false;
+				}
+				else bodyObj = body;
+				const nodes = jsonpath.default.apply(bodyObj, jsonPath, actionFunction);
+				if (typeof body === "string" && nodes.length > 0) target.body = Buffer.from(JSON.stringify(bodyObj)).toString("base64");
+				return nodes.length > 0;
 			} catch (error) {
 				return false;
 			}
@@ -2111,9 +2133,8 @@ var HttpTransformEngine = class {
 	}
 	compileHeaderAction(headerName, actionFunction, direction) {
 		const lowerHeader = headerName.toLowerCase();
-		const selector = direction === "inbound" ? "inputValue" : "outputValue";
 		return (span) => {
-			const target = span[selector];
+			const target = span.inputValue;
 			if (!target?.headers) return false;
 			let applied = false;
 			for (const key of Object.keys(target.headers)) if (key.toLowerCase() === lowerHeader) {
@@ -2134,7 +2155,15 @@ var HttpTransformEngine = class {
 		return (span) => {
 			const target = span[selector];
 			if (!target || target.body === void 0) return false;
-			target.body = actionFunction(typeof target.body === "string" ? target.body : JSON.stringify(target.body));
+			if (direction === "outbound") if (typeof target.body === "string") try {
+				const decoded = Buffer.from(target.body, "base64").toString("utf8");
+				const transformed = actionFunction(decoded);
+				target.body = Buffer.from(transformed).toString("base64");
+			} catch (error) {
+				target.body = Buffer.from(actionFunction(target.body)).toString("base64");
+			}
+			else target.body = Buffer.from(actionFunction(JSON.stringify(target.body))).toString("base64");
+			else target.body = actionFunction(typeof target.body === "string" ? target.body : JSON.stringify(target.body));
 			return true;
 		};
 	}
@@ -4960,7 +4989,7 @@ var JwksRsaInstrumentation = class extends TdInstrumentationBase {
 			const originalExpressJwtSecret = jwksModule.expressJwtSecret;
 			jwksModule.expressJwtSecret = function(options) {
 				logger.debug(`[JwksRsaInstrumentation] expressJwtSecret called with options:`, options);
-				let modifiedOptions = { ...options };
+				const modifiedOptions = { ...options };
 				if (self$1.tuskDrift.getMode() === TuskDriftMode.REPLAY) {
 					logger.debug(`[JwksRsaInstrumentation] REPLAY MODE - Disabling rate limiting for expressJwtSecret`);
 					modifiedOptions.rateLimit = false;
@@ -6105,9 +6134,9 @@ var require_types$3 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/
 var require_ExportResult = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/core/build/src/ExportResult.js": ((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.ExportResultCode = void 0;
-	(function(ExportResultCode$1) {
-		ExportResultCode$1[ExportResultCode$1["SUCCESS"] = 0] = "SUCCESS";
-		ExportResultCode$1[ExportResultCode$1["FAILED"] = 1] = "FAILED";
+	(function(ExportResultCode$3) {
+		ExportResultCode$3[ExportResultCode$3["SUCCESS"] = 0] = "SUCCESS";
+		ExportResultCode$3[ExportResultCode$3["FAILED"] = 1] = "FAILED";
 	})(exports.ExportResultCode || (exports.ExportResultCode = {}));
 }) });
 
@@ -6949,122 +6978,23 @@ var require_src$6 = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/co
 }) });
 
 //#endregion
-//#region src/core/tracing/TdSpanExporter.ts
-var import_src$1 = /* @__PURE__ */ __toESM(require_src$6(), 1);
-const DRIFT_API_PATH = "/api/drift";
+//#region src/core/tracing/SpanTransformer.ts
+var import_src$3 = /* @__PURE__ */ __toESM(require_src$6(), 1);
 /**
-* If useRemoteExport is true, TdTraceExporter exports spans to a remote endpoint via protobuf.
-* If useRemoteExport is false, TdTraceExporter stores spans organized by trace ID in separate files.
-*  - Each trace gets its own JSONL file: `{baseDirectory}/{timestamp}_trace_{traceId}.jsonl`.
+* Utility class for transforming OpenTelemetry spans to CleanSpanData
 */
-var TdSpanExporter = class {
-	constructor(config) {
-		this.traceFileMap = /* @__PURE__ */ new Map();
-		this.baseDirectory = config.baseDirectory;
-		this.mode = config.mode;
-		this.useRemoteExport = config.useRemoteExport;
-		this.observableServiceId = config.observableServiceId;
-		this.apiKey = config.apiKey;
-		this.tuskBackendBaseUrl = config.tuskBackendBaseUrl;
-		this.environment = config.environment;
-		this.sdkVersion = config.sdkVersion;
-		this.sdkInstanceId = config.sdkInstanceId;
-		if (!fs.existsSync(this.baseDirectory)) fs.mkdirSync(this.baseDirectory, { recursive: true });
-		if (this.useRemoteExport && this.apiKey) {
-			const transport = new __protobuf_ts_twirp_transport.TwirpFetchTransport({
-				baseUrl: `${this.tuskBackendBaseUrl}${DRIFT_API_PATH}`,
-				meta: {
-					"x-api-key": this.apiKey,
-					"x-td-skip-instrumentation": "true"
-				}
-			});
-			this.spanExportClient = new __use_tusk_drift_schemas_backend_span_export_service_client.SpanExportServiceClient(transport);
-		}
-		logger.debug(`TdTraceExporter initialized - ${this.useRemoteExport ? "remote export enabled" : "local file export only"}`);
-	}
-	/**
-	* Export spans to trace-specific files and optionally to remote endpoint
-	*/
-	export(spans, resultCallback) {
-		logger.debug(`TdTraceExporter.export() called with ${spans.length} span(s)`);
-		if (this.mode !== TuskDriftMode.RECORD) {
-			logger.debug(`Not recording spans in tuskDriftMode: ${this.mode}`);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-			return;
-		}
-		if (this.useRemoteExport) if (this.spanExportClient) this.exportToRemote(spans).then(() => {
-			logger.debug(`Successfully exported ${spans.length} spans to remote endpoint`);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-		}).catch((error) => {
-			logger.error(`Failed to export spans to remote:`, error);
-			resultCallback({
-				code: import_src$1.ExportResultCode.FAILED,
-				error: error instanceof Error ? error : /* @__PURE__ */ new Error("Remote export failed")
-			});
-		});
-		else {
-			logger.error("Remote export client not initialized, likely because apiKey is not provided");
-			resultCallback({
-				code: import_src$1.ExportResultCode.FAILED,
-				error: /* @__PURE__ */ new Error("Remote export client not initialized, likely because apiKey is not provided")
-			});
-		}
-		else {
-			this.exportToLocalFiles(spans);
-			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
-		}
-	}
-	/**
-	* Export spans to remote endpoint via protobuf
-	*/
-	async exportToRemote(spans) {
-		if (!this.spanExportClient) throw new Error("Remote export client not initialized");
-		if (!this.observableServiceId) throw new Error("Observable service ID not provided in config");
-		const protoSpans = spans.map((span) => this.transformSpanToProtobuf(span));
-		const request = {
-			observableServiceId: this.observableServiceId,
-			environment: this.environment,
-			sdkVersion: this.sdkVersion,
-			sdkInstanceId: this.sdkInstanceId,
-			spans: protoSpans
-		};
-		const response = await this.spanExportClient.exportSpans(request);
-		if (!response.response.success) throw new Error(`Remote export failed: ${response.response.message}`);
-	}
-	/**
-	* Export spans to local files
-	*/
-	exportToLocalFiles(spans) {
-		try {
-			for (const span of spans) {
-				const traceId = span.spanContext().traceId;
-				const spanData = this.transformSpanToCleanJSON(span);
-				let filePath = this.traceFileMap.get(traceId);
-				if (!filePath) {
-					const isoTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-					filePath = path.join(this.baseDirectory, `${isoTimestamp}_trace_${traceId}.jsonl`);
-					this.traceFileMap.set(traceId, filePath);
-				}
-				const jsonLine = JSON.stringify(spanData) + "\n";
-				fs.appendFileSync(filePath, jsonLine, "utf8");
-			}
-			logger.debug(`Exported ${spans.length} span(s) to trace-specific files in ${this.baseDirectory}`);
-		} catch (error) {
-			logger.error(`Failed to export spans to local files:`, error);
-			throw error;
-		}
-	}
+var SpanTransformer = class SpanTransformer {
 	/**
 	* Transform OpenTelemetry span to clean JSON format with compile-time type safety
 	* Return type is derived from protobuf schema but uses clean JSON.
 	* We use JSON because serialized protobuf is extremely verbose and not readable.
 	*/
-	transformSpanToCleanJSON(span) {
+	static transformSpanToCleanJSON(span) {
 		const isRootSpan = !span.parentSpanId || span.kind === __opentelemetry_api.SpanKind.SERVER;
 		const attributes = span.attributes;
-		const packageName = this.extractPackageName(attributes);
-		const instrumentationName = this.extractInstrumentationName(span, attributes);
-		const submoduleName = this.extractSubmoduleName(attributes);
+		const packageName = SpanTransformer.extractPackageName(attributes);
+		const instrumentationName = SpanTransformer.extractInstrumentationName(span, attributes);
+		const submoduleName = SpanTransformer.extractSubmoduleName(attributes);
 		const inputValueString = attributes[TdSpanAttributes.INPUT_VALUE];
 		const inputData = JSON.parse(inputValueString);
 		const inputSchemaMergesString = attributes[TdSpanAttributes.INPUT_SCHEMA_MERGES];
@@ -7130,10 +7060,115 @@ var TdSpanExporter = class {
 		};
 	}
 	/**
-	* Transform OpenTelemetry span to protobuf format
+	* Extract package name from attributes or instrumentation library
 	*/
-	transformSpanToProtobuf(span) {
-		const cleanSpan = this.transformSpanToCleanJSON(span);
+	static extractPackageName(attributes) {
+		if (attributes[TdSpanAttributes.PACKAGE_NAME]) return attributes[TdSpanAttributes.PACKAGE_NAME];
+		return "unknown";
+	}
+	/**
+	* Extract instrumentation name from span data
+	*/
+	static extractInstrumentationName(span, attributes) {
+		if (attributes[TdSpanAttributes.INSTRUMENTATION_NAME]) return attributes[TdSpanAttributes.INSTRUMENTATION_NAME];
+		if (span.instrumentationLibrary?.name) return `tusk-instrumentation-${span.instrumentationLibrary.name}`;
+		return `tusk-instrumentation-${SpanTransformer.extractPackageName(attributes)}`;
+	}
+	/**
+	* Extract submodule name from attributes
+	*/
+	static extractSubmoduleName(attributes) {
+		if (attributes[TdSpanAttributes.SUBMODULE_NAME]) return attributes[TdSpanAttributes.SUBMODULE_NAME];
+	}
+};
+
+//#endregion
+//#region src/core/tracing/adapters/FilesystemSpanAdapter.ts
+/**
+* Exports spans to local JSONL files organized by trace ID
+*/
+var FilesystemSpanAdapter = class {
+	constructor(config) {
+		this.name = "filesystem";
+		this.traceFileMap = /* @__PURE__ */ new Map();
+		this.baseDirectory = config.baseDirectory;
+		if (!fs.existsSync(this.baseDirectory)) fs.mkdirSync(this.baseDirectory, { recursive: true });
+	}
+	async exportSpans(spans) {
+		try {
+			for (const span of spans) {
+				const traceId = span.traceId;
+				let filePath = this.traceFileMap.get(traceId);
+				if (!filePath) {
+					const isoTimestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+					filePath = path.join(this.baseDirectory, `${isoTimestamp}_trace_${traceId}.jsonl`);
+					this.traceFileMap.set(traceId, filePath);
+				}
+				const jsonLine = JSON.stringify(span) + "\n";
+				fs.appendFileSync(filePath, jsonLine, "utf8");
+			}
+			logger.debug(`Exported ${spans.length} span(s) to trace-specific files in ${this.baseDirectory}`);
+			return { code: import_src$3.ExportResultCode.SUCCESS };
+		} catch (error) {
+			logger.error(`Failed to export spans to local files:`, error);
+			return {
+				code: import_src$3.ExportResultCode.FAILED,
+				error: error instanceof Error ? error : /* @__PURE__ */ new Error("Filesystem export failed")
+			};
+		}
+	}
+	async shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/tracing/adapters/ApiSpanAdapter.ts
+var import_src$2 = /* @__PURE__ */ __toESM(require_src$6(), 1);
+const DRIFT_API_PATH = "/api/drift";
+/**
+* Exports spans to Tusk backend API via protobuf
+*/
+var ApiSpanAdapter = class {
+	constructor(config) {
+		this.name = "api";
+		this.observableServiceId = config.observableServiceId;
+		this.environment = config.environment;
+		this.sdkVersion = config.sdkVersion;
+		this.sdkInstanceId = config.sdkInstanceId;
+		const transport = new __protobuf_ts_twirp_transport.TwirpFetchTransport({
+			baseUrl: `${config.tuskBackendBaseUrl}${DRIFT_API_PATH}`,
+			meta: {
+				"x-api-key": config.apiKey,
+				"x-td-skip-instrumentation": "true"
+			}
+		});
+		this.spanExportClient = new __use_tusk_drift_schemas_backend_span_export_service_client.SpanExportServiceClient(transport);
+		logger.debug("ApiSpanAdapter initialized");
+	}
+	async exportSpans(spans) {
+		try {
+			const protoSpans = spans.map((span) => this.transformSpanToProtobuf(span));
+			const request = {
+				observableServiceId: this.observableServiceId,
+				environment: this.environment,
+				sdkVersion: this.sdkVersion,
+				sdkInstanceId: this.sdkInstanceId,
+				spans: protoSpans
+			};
+			const response = await this.spanExportClient.exportSpans(request);
+			if (!response.response.success) throw new Error(`Remote export failed: ${response.response.message}`);
+			logger.debug(`Successfully exported ${spans.length} spans to remote endpoint`);
+			return { code: import_src$2.ExportResultCode.SUCCESS };
+		} catch (error) {
+			logger.error(`Failed to export spans to remote:`, error);
+			return {
+				code: import_src$2.ExportResultCode.FAILED,
+				error: error instanceof Error ? error : /* @__PURE__ */ new Error("API export failed")
+			};
+		}
+	}
+	transformSpanToProtobuf(cleanSpan) {
 		return {
 			traceId: cleanSpan.traceId,
 			spanId: cleanSpan.spanId,
@@ -7151,7 +7186,7 @@ var TdSpanExporter = class {
 			outputSchemaHash: cleanSpan.outputSchemaHash || "",
 			inputValueHash: cleanSpan.inputValueHash || "",
 			outputValueHash: cleanSpan.outputValueHash || "",
-			kind: mapOtToPb(span.kind),
+			kind: this.mapSpanKind(cleanSpan.kind),
 			status: cleanSpan.status,
 			isPreAppStart: cleanSpan.isPreAppStart,
 			timestamp: {
@@ -7166,32 +7201,111 @@ var TdSpanExporter = class {
 			metadata: toStruct(cleanSpan.metadata)
 		};
 	}
+	mapSpanKind(kind) {
+		switch (kind) {
+			case __opentelemetry_api.SpanKind.CLIENT: return __use_tusk_drift_schemas_core_span.SpanKind.CLIENT;
+			case __opentelemetry_api.SpanKind.SERVER: return __use_tusk_drift_schemas_core_span.SpanKind.SERVER;
+			case __opentelemetry_api.SpanKind.PRODUCER: return __use_tusk_drift_schemas_core_span.SpanKind.PRODUCER;
+			case __opentelemetry_api.SpanKind.CONSUMER: return __use_tusk_drift_schemas_core_span.SpanKind.CONSUMER;
+			case __opentelemetry_api.SpanKind.INTERNAL: return __use_tusk_drift_schemas_core_span.SpanKind.INTERNAL;
+			default: return __use_tusk_drift_schemas_core_span.SpanKind.UNSPECIFIED;
+		}
+	}
+	async shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/core/tracing/TdSpanExporter.ts
+var import_src$1 = /* @__PURE__ */ __toESM(require_src$6(), 1);
+var TdSpanExporter = class {
+	constructor(config) {
+		this.adapters = [];
+		this.mode = config.mode;
+		this.setupDefaultAdapters(config);
+		logger.debug(`TdSpanExporter initialized with ${this.adapters.length} adapter(s)`);
+	}
+	setupDefaultAdapters(config) {
+		if (config.useRemoteExport && config.apiKey && config.observableServiceId) {
+			logger.debug("TdSpanExporter using API adapter");
+			this.addAdapter(new ApiSpanAdapter({
+				apiKey: config.apiKey,
+				tuskBackendBaseUrl: config.tuskBackendBaseUrl,
+				observableServiceId: config.observableServiceId,
+				environment: config.environment,
+				sdkVersion: config.sdkVersion,
+				sdkInstanceId: config.sdkInstanceId
+			}));
+		} else {
+			logger.debug("TdSpanExporter falling back to filesystem adapter");
+			this.addAdapter(new FilesystemSpanAdapter({ baseDirectory: config.baseDirectory }));
+		}
+	}
+	getAdapters() {
+		return this.adapters;
+	}
 	/**
-	* Extract package name from attributes or instrumentation library
+	* Add a custom export adapter
 	*/
-	extractPackageName(attributes) {
-		if (attributes[TdSpanAttributes.PACKAGE_NAME]) return attributes[TdSpanAttributes.PACKAGE_NAME];
-		return "unknown";
+	addAdapter(adapter) {
+		this.adapters.push(adapter);
+		logger.debug(`Added ${adapter.name} adapter. Total adapters: ${this.adapters.length}`);
 	}
 	/**
-	* Extract instrumentation name from span data
+	* Remove a specific adapter
 	*/
-	extractInstrumentationName(span, attributes) {
-		if (attributes[TdSpanAttributes.INSTRUMENTATION_NAME]) return attributes[TdSpanAttributes.INSTRUMENTATION_NAME];
-		if (span.instrumentationLibrary?.name) return `tusk-instrumentation-${span.instrumentationLibrary.name}`;
-		return `tusk-instrumentation-${this.extractPackageName(attributes)}`;
+	removeAdapter(adapter) {
+		const index = this.adapters.indexOf(adapter);
+		if (index > -1) {
+			this.adapters.splice(index, 1);
+			logger.debug(`Removed ${adapter.name} adapter. Total adapters: ${this.adapters.length}`);
+		}
 	}
 	/**
-	* Extract submodule name from attributes
+	* Clear all adapters
 	*/
-	extractSubmoduleName(attributes) {
-		if (attributes[TdSpanAttributes.SUBMODULE_NAME]) return attributes[TdSpanAttributes.SUBMODULE_NAME];
+	clearAdapters() {
+		this.adapters = [];
+		logger.debug("All adapters cleared");
 	}
 	/**
-	* Shutdown the exporter
+	* Set the mode for determining which adapters to run
+	*/
+	setMode(mode) {
+		this.mode = mode;
+	}
+	/**
+	* Export spans using all configured adapters
+	*/
+	export(spans, resultCallback) {
+		logger.debug(`TdSpanExporter.export() called with ${spans.length} span(s)`);
+		const cleanSpans = spans.map((span) => SpanTransformer.transformSpanToCleanJSON(span));
+		if (this.adapters.length === 0) {
+			logger.debug("No adapters configured");
+			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
+			return;
+		}
+		const activeAdapters = this.getActiveAdapters();
+		if (activeAdapters.length === 0) {
+			logger.debug(`No active adapters for mode: ${this.mode}`);
+			resultCallback({ code: import_src$1.ExportResultCode.SUCCESS });
+			return;
+		}
+		Promise.all(activeAdapters.map((adapter) => adapter.exportSpans(cleanSpans))).then(() => resultCallback({ code: import_src$1.ExportResultCode.SUCCESS })).catch((error) => resultCallback({
+			code: import_src$1.ExportResultCode.FAILED,
+			error
+		}));
+	}
+	getActiveAdapters() {
+		if (this.mode !== TuskDriftMode.RECORD) return this.adapters.filter((adapter) => adapter.name === "in-memory" || adapter.name === "callback");
+		return this.adapters;
+	}
+	/**
+	* Shutdown all adapters
 	*/
 	async shutdown() {
-		return Promise.resolve();
+		await Promise.all(this.adapters.map((adapter) => adapter.shutdown()));
 	}
 	/**
 	* Force flush any pending spans
@@ -10493,12 +10607,6 @@ var TuskDriftCore = class TuskDriftCore {
 			default: return TuskDriftMode.DISABLED;
 		}
 	}
-	initializeMemoryStore({ baseDirectory }) {
-		if (this.isRunningIntegrationTest()) {
-			logger.debug(`Initializing memory store with base directory: ${baseDirectory}`);
-			this.memoryStore.initialize(baseDirectory);
-		} else logger.debug("Not running integration test, skipping memory store initialization");
-	}
 	registerDefaultInstrumentations() {
 		const transforms = this.config.transforms ?? this.initParams.transforms;
 		new HttpInstrumentation({
@@ -10546,20 +10654,20 @@ var TuskDriftCore = class TuskDriftCore {
 	initializeTracing({ baseDirectory }) {
 		const serviceName = this.config.service?.name || "unknown";
 		logger.debug(`Initializing OpenTelemetry tracing for service: ${serviceName}`);
-		const traceExporter = new TdSpanExporter({
+		this.spanExporter = new TdSpanExporter({
 			baseDirectory,
 			mode: this.mode,
 			useRemoteExport: this.config.recording?.export_spans || false,
 			observableServiceId: this.config.service?.id,
 			apiKey: this.initParams.apiKey,
 			tuskBackendBaseUrl: this.config.tusk_api?.url || "https://api.usetusk.ai",
-			environment: this.initParams.env,
+			environment: this.initParams.env || "unknown",
 			sdkVersion: SDK_VERSION,
 			sdkInstanceId: this.generateSdkInstanceId()
 		});
 		this.sdk = new __opentelemetry_sdk_node.NodeSDK({
 			serviceName,
-			spanProcessor: new import_src.BatchSpanProcessor(traceExporter, {
+			spanProcessor: new import_src.BatchSpanProcessor(this.spanExporter, {
 				maxQueueSize: 2048,
 				maxExportBatchSize: 512,
 				scheduledDelayMillis: 2e3,
@@ -10576,6 +10684,11 @@ var TuskDriftCore = class TuskDriftCore {
 	initialize(initParams) {
 		this.samplingRate = this.config.recording?.sampling_rate ?? 1;
 		this.initParams = initParams;
+		if (!this.initParams.env) {
+			const nodeEnv = OriginalGlobalUtils.getOriginalProcessEnvVar("NODE_ENV") || "unknown";
+			logger.warn(`Environment not provided in initialization parameters. Using '${nodeEnv}' as the environment.`);
+			this.initParams.env = nodeEnv;
+		}
 		initializeGlobalLogger({
 			logLevel: initParams.logLevel || "info",
 			prefix: "TuskDrift"
@@ -10588,10 +10701,6 @@ var TuskDriftCore = class TuskDriftCore {
 			logger.error("In record mode and export_spans is true, but API key not provided. API key is required to export spans to Tusk backend. Please provide an API key in the initialization parameters.");
 			return;
 		}
-		if (!this.initParams.env) {
-			logger.error("Environment not provided. Please provide an environment in the initialization parameters.");
-			return;
-		}
 		if (this.config.recording?.export_spans && !this.config.service?.id) {
 			logger.error("Observable service ID not provided. Please provide an observable service ID in the configuration file.");
 			return;
@@ -10633,9 +10742,7 @@ var TuskDriftCore = class TuskDriftCore {
 		const baseDirectory = this.config.traces?.dir || path.default.join(process.cwd(), ".tusk/traces");
 		logger.debug(`Config: ${JSON.stringify(this.config)}`);
 		logger.debug(`Base directory: ${baseDirectory}`);
-		this.config.transforms ?? this.initParams.transforms;
 		this.initializeTracing({ baseDirectory });
-		this.initializeMemoryStore({ baseDirectory });
 		this.registerDefaultInstrumentations();
 		this.initialized = true;
 		logger.info("SDK initialized successfully");
@@ -10807,6 +10914,9 @@ var TuskDriftSDK = class {
 	markAppAsReady() {
 		return this.tuskDrift.markAppAsReady();
 	}
+	isAppReady() {
+		return this.tuskDrift.isAppReady();
+	}
 };
 const TuskDrift = new TuskDriftSDK();