@od-oneapp/observability 2026.1.1301

package/dist/plugin-CLFwRERa.mjs

@@ -0,0 +1,593 @@
+import { logDebug, logError, logWarn } from "@od-oneapp/shared/logs";
+import { SentryPlugin } from "@integrations/sentry/observability-plugin/plugin";
+
+//#region src/plugins/sentry-microfrontend/multiplexed-transport.ts
+/**
+* @fileoverview Multiplexed transport utilities for Sentry Micro Frontend Plugin
+* Multiplexed transport utilities for Sentry Micro Frontend Plugin
+*/
+/**
+* Create a multiplexed transport that routes events to different Sentry projects.
+*
+* Creates a Sentry transport that routes events to different DSNs based on the
+* backstageApp information in the event. Supports edge runtime environments.
+*
+* @param backstage - Array of backstage app configurations with DSNs
+* @param fallbackDsn - Optional fallback DSN if no backstageApp match is found
+* @param sentryClient - Optional Sentry client instance (defaults to global Sentry)
+* @returns Multiplexed transport instance, or undefined if Sentry is not available
+*/
+function createMultiplexedTransport(backstage, fallbackDsn, sentryClient) {
+	const Sentry = sentryClient !== void 0 ? sentryClient : typeof globalThis !== "undefined" ? globalThis.Sentry : null;
+	if (!Sentry?.makeMultiplexedTransport || !Sentry.makeFetchTransport) {
+		logWarn("Sentry multiplexed transport not available");
+		return;
+	}
+	return Sentry.makeMultiplexedTransport(Sentry.makeFetchTransport, (args) => {
+		const event = args.getEvent();
+		if (!event) return [];
+		const backstageApp = event.tags?.backstageApp ?? event.extra?.backstageApp ?? event.contexts?.microFrontend?.backstageApp;
+		if (backstageApp) {
+			const backstageAppConfig = backstage.find((z) => z.name === backstageApp);
+			if (backstageAppConfig?.dsn) {
+				const envelope = [{
+					dsn: backstageAppConfig.dsn,
+					release: backstageAppConfig.release ?? event.release
+				}];
+				if (backstageAppConfig.tags && event.tags) Object.assign(event.tags, backstageAppConfig.tags);
+				return envelope;
+			}
+		}
+		if (fallbackDsn) return [{ dsn: fallbackDsn }];
+		return [];
+	});
+}
+/**
+* Enhance an event with Backstage app information before sending.
+*
+* Adds backstageApp tags, context, and extra data to a Sentry event.
+* This ensures events are properly tagged for micro frontend routing.
+*
+* @param event - Sentry event to enhance
+* @param backstageApp - Name of the backstage app
+* @param additionalContext - Optional additional context to add
+* @returns Enhanced event with backstageApp information
+*/
+function enhanceEventWithBackstageApp(event, backstageApp, additionalContext) {
+	event.tags ??= {};
+	event.tags.backstageApp = backstageApp;
+	event.tags.microFrontend = true;
+	event.contexts ??= {};
+	event.contexts.microFrontend = {
+		backstageApp,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...additionalContext
+	};
+	event.extra ??= {};
+	event.extra.backstageApp = backstageApp;
+	return event;
+}
+/**
+* Create a beforeSend hook that adds backstageApp information.
+*
+* Creates a Sentry beforeSend hook that enhances events with backstageApp information
+* before they are sent. Can wrap an existing beforeSend hook.
+*
+* @param backstageApp - Name of the backstage app
+* @param originalBeforeSend - Optional original beforeSend hook to wrap
+* @returns beforeSend hook function
+*/
+function createBackstageBeforeSend(backstageApp, originalBeforeSend) {
+	return (event, hint) => {
+		enhanceEventWithBackstageApp(event, backstageApp);
+		if (originalBeforeSend) return originalBeforeSend(event, hint);
+		return event;
+	};
+}
+
+//#endregion
+//#region src/plugins/sentry-microfrontend/sentry-types.ts
+/**
+* Map LogLevel to Sentry Severity.
+*
+* Converts the observability package's LogLevel to Sentry's SeverityLevel format.
+*
+* @param level - Log level from observability package
+* @returns Corresponding Sentry severity level
+*/
+function mapLogLevelToSentrySeverity(level) {
+	switch (level) {
+		case "error": return "error";
+		case "warning": return "warning";
+		case "info": return "info";
+		case "debug": return "debug";
+		default: return "info";
+	}
+}
+
+//#endregion
+//#region src/plugins/sentry-microfrontend/utils.ts
+/**
+* @fileoverview Utility functions for Sentry Micro Frontend Plugin
+* Utility functions for Sentry Micro Frontend Plugin
+*/
+/**
+* Detect the current micro frontend backstageApp based on URL path.
+*
+* Analyzes the current URL pathname to determine which micro frontend application
+* is active. Supports custom path patterns and falls back to default patterns.
+*
+* @param customPatterns - Optional array of custom backstage app configurations with path patterns
+* @returns Detected backstage app name, or undefined if not detected
+*
+* @example
+* ```typescript
+* const app = detectCurrentBackstageApp([
+*   { name: 'admin', pathPatterns: ['/admin', '/manage'] },
+*   { name: 'dashboard', pathPatterns: [/^\/dashboard/] }
+* ]);
+* // Returns: 'admin' if pathname starts with '/admin' or '/manage'
+* ```
+*/
+function detectCurrentBackstageApp(customPatterns) {
+	if (typeof globalThis === "undefined" || !globalThis.location) {
+		if (typeof process !== "undefined" && process.env?.NEXT_PUBLIC_BASE_PATH) return process.env.NEXT_PUBLIC_BASE_PATH.replace("/", "");
+		return;
+	}
+	const path = globalThis.location?.pathname;
+	if (!path) return;
+	if (customPatterns) {
+		for (const config of customPatterns) if (config.pathPatterns) {
+			for (const pattern of config.pathPatterns) if (typeof pattern === "string" && path.startsWith(pattern)) return config.name;
+			else if (pattern instanceof RegExp && pattern.test(path)) return config.name;
+		}
+	}
+	if (path.startsWith("/admin")) return "admin";
+	if (path.startsWith("/dashboard")) return "dashboard";
+	if (path.startsWith("/settings")) return "settings";
+	if (globalThis.__SENTRY_MICRO_FRONTEND_APP__) return globalThis.__SENTRY_MICRO_FRONTEND_APP__;
+	if (globalThis.__SENTRY_MICRO_FRONTEND_ZONE__) return globalThis.__SENTRY_MICRO_FRONTEND_ZONE__;
+	return "main";
+}
+/**
+* Check if running in a host environment.
+*
+* Determines whether the current application is acting as a host for micro frontends
+* or as a child micro frontend. Checks for explicit host markers and Sentry initialization state.
+*
+* @returns True if running as host, false if child or standalone
+*/
+function isHostEnvironment() {
+	if (typeof globalThis === "undefined") return false;
+	if (globalThis.__SENTRY_MICRO_FRONTEND_HOST__) return true;
+	if (globalThis.Sentry && typeof globalThis.Sentry.getCurrentHub === "function") return false;
+	return false;
+}
+/**
+* Create a Sentry scope with backstageApp-specific context.
+*
+* Creates a new Sentry scope configured with micro frontend tags and context.
+* Includes backstageApp tag, microFrontend context, and any additional tags provided.
+*
+* @param backstageApp - Name of the backstage app
+* @param additionalTags - Optional additional tags to set on the scope
+* @returns Sentry scope instance, or null if Sentry is not available
+*/
+function createBackstageScope(backstageApp, additionalTags) {
+	if (typeof globalThis === "undefined" || !globalThis.Sentry) return null;
+	const { Sentry } = globalThis;
+	if (!Sentry.Scope || typeof Sentry.Scope !== "function") return null;
+	try {
+		const scope = new Sentry.Scope();
+		scope.setTag("backstageApp", backstageApp);
+		scope.setTag("microFrontend", true);
+		scope.setContext("microFrontend", {
+			backstageApp,
+			isHost: globalThis.__SENTRY_MICRO_FRONTEND_HOST__ ?? false,
+			url: globalThis.location?.href ?? void 0
+		});
+		if (additionalTags) Object.entries(additionalTags).forEach(([key, value]) => {
+			scope.setTag(key, value);
+		});
+		return scope;
+	} catch (error) {
+		logError("[SentryMicroFrontendPlugin] Failed to create Backstage scope", { error });
+		return null;
+	}
+}
+/**
+* Check if Sentry is already initialized by a parent application.
+*
+* Verifies whether a parent Sentry instance exists in the global scope.
+* Used to determine if the current micro frontend should use the parent's Sentry
+* or initialize its own instance.
+*
+* @returns True if parent Sentry is available, false otherwise
+*/
+function hasParentSentry() {
+	if (typeof globalThis === "undefined") return false;
+	const { Sentry } = globalThis;
+	if (!Sentry) return false;
+	return [
+		"captureException",
+		"captureMessage",
+		"withScope"
+	].every((method) => typeof Sentry[method] === "function");
+}
+/**
+* Get the parent Sentry instance if available.
+*
+* Returns the global Sentry instance if it exists and has been initialized
+* by a parent application. Returns null if no parent Sentry is available.
+*
+* @returns Parent Sentry SDK instance, or null if not available
+*/
+function getParentSentry() {
+	if (hasParentSentry()) return globalThis.Sentry;
+	return null;
+}
+/**
+* Mark the current environment as a host.
+*
+* Sets global flags indicating that this application is acting as a host
+* for micro frontends. This affects how Sentry events are routed and tagged.
+*
+* @param backstageApp - Optional backstage app name to set
+*/
+function markAsHost(backstageApp) {
+	if (typeof globalThis !== "undefined") {
+		globalThis.__SENTRY_MICRO_FRONTEND_HOST__ = true;
+		if (backstageApp) {
+			globalThis.__SENTRY_MICRO_FRONTEND_APP__ = backstageApp;
+			globalThis.__SENTRY_MICRO_FRONTEND_ZONE__ = backstageApp;
+		}
+	}
+}
+/**
+* Ensure only one Sentry initialization happens (thread-safe).
+*
+* Prevents multiple Sentry initializations using global state tracking.
+* Uses timestamps and unique IDs to detect concurrent initialization attempts.
+* Throws an error if Sentry is already initialized or if concurrent initialization is detected.
+*
+* @throws Error if Sentry is already initialized or concurrent initialization detected
+*/
+function ensureSingleInit() {
+	const initKey = "__SENTRY_INIT_STATE__";
+	const now = Date.now();
+	if (typeof globalThis !== "undefined") {
+		const globalState = globalThis[initKey];
+		if (globalState) {
+			const { status, timestamp, id } = globalState;
+			if (status === "initialized") throw new Error("Sentry has already been initialized! Use hasParentSentry() to check before initializing.");
+			if (status === "initializing" && now - timestamp < 5e3) throw new Error(`Sentry initialization already in progress (started ${now - timestamp}ms ago by ${id})`);
+		}
+		const initId = `${now}-${Math.random().toString(36).substr(2, 9)}`;
+		globalThis[initKey] = {
+			status: "initializing",
+			timestamp: now,
+			id: initId
+		};
+		if (globalThis[initKey].id !== initId) throw new Error("Concurrent Sentry initialization detected");
+		globalThis[initKey] = {
+			status: "initialized",
+			timestamp: now,
+			id: initId
+		};
+		globalThis.__SENTRY_INITIALIZED__ = true;
+	}
+}
+
+//#endregion
+//#region src/plugins/sentry-microfrontend/plugin.ts
+/**
+* @fileoverview Sentry Micro Frontend Plugin
+* Sentry Micro Frontend Plugin
+*
+* Extends the base Sentry plugin with micro frontend-specific functionality
+*/
+/**
+* Sentry plugin optimized for micro frontend architectures
+*/
+/**
+* Sentry plugin optimized for micro frontend architectures.
+*
+* Extends SentryPlugin with micro frontend-specific features:
+* - Host/child/standalone mode detection
+* - Multiplexed transport for routing events to different Sentry projects
+* - Backstage app context management
+* - Parent Sentry instance detection and reuse
+*/
+var SentryMicroFrontendPlugin = class SentryMicroFrontendPlugin extends SentryPlugin {
+	mode;
+	backstageApp;
+	parentSentry;
+	backstageScope;
+	microFrontendConfig;
+	eventProcessorCleanup;
+	/**
+	* Create a new SentryMicroFrontendPlugin instance.
+	*
+	* @param config - Sentry micro frontend plugin configuration
+	*/
+	constructor(config = {}) {
+		const mode = SentryMicroFrontendPlugin.determineMode(config);
+		const baseConfig = SentryMicroFrontendPlugin.prepareConfig(config, mode);
+		super(baseConfig);
+		this.mode = mode;
+		this.microFrontendConfig = config;
+		this.backstageApp = config.backstageApp ?? detectCurrentBackstageApp(config.backstageApps);
+		if (this.mode === "child") {
+			const parent = getParentSentry();
+			if (parent) {
+				this.parentSentry = parent;
+				this.enabled = true;
+				if (this.backstageApp && this.parentSentry.Scope) this.backstageScope = createBackstageScope(this.backstageApp, config.globalTags);
+			}
+		}
+		if (this.mode === "host") markAsHost(this.backstageApp);
+	}
+	/**
+	* Determine the operation mode based on configuration and environment.
+	*
+	* @param config - Plugin configuration
+	* @returns Operation mode ('host', 'child', or 'standalone')
+	*/
+	static determineMode(config) {
+		if (config.isHost) return "host";
+		if (config.detectParent !== false && hasParentSentry()) return "child";
+		return "standalone";
+	}
+	/**
+	* Prepare configuration based on operation mode.
+	*
+	* Adjusts configuration settings based on whether running as host, child, or standalone.
+	*
+	* @param config - Original plugin configuration
+	* @param mode - Determined operation mode
+	* @returns Prepared configuration object
+	*/
+	static prepareConfig(config, mode) {
+		const preparedConfig = { ...config };
+		if (mode === "child") preparedConfig.enabled = false;
+		else if (mode === "host" && config.backstageApps && config.useMultiplexedTransport !== false) {}
+		return preparedConfig;
+	}
+	/**
+	* Initialize the plugin
+	*/
+	async initialize(config) {
+		const mergedConfig = {
+			...this.microFrontendConfig,
+			...config
+		};
+		if (this.mode === "child") {
+			if (this.parentSentry) {
+				this.client = this.parentSentry;
+				this.initialized = true;
+				if (this.backstageApp && mergedConfig.addBackstageContext !== false) this.configureParentSentry();
+			}
+			return;
+		}
+		if (mergedConfig.preventDuplicateInit !== false) try {
+			ensureSingleInit();
+		} catch (error) {
+			logError("Sentry initialization prevented", { error });
+			this.enabled = false;
+			return;
+		}
+		await super.initialize(mergedConfig);
+		if (this.mode === "host" && this.client && mergedConfig.backstageApps) this.setupHostMode(mergedConfig);
+	}
+	/**
+	* Configure parent Sentry instance for child mode
+	*/
+	configureParentSentry() {
+		if (!this.parentSentry || !this.backstageApp) {
+			logWarn("[SentryMicroFrontendPlugin] Cannot configure parent Sentry: missing parentSentry or backstageApp");
+			return;
+		}
+		try {
+			const processor = (event) => {
+				try {
+					if (this.shouldProcessEvent(event)) enhanceEventWithBackstageApp(event, this.backstageApp ?? "", {
+						mode: this.mode,
+						plugin: "SentryMicroFrontendPlugin"
+					});
+				} catch (error) {
+					logError("[SentryMicroFrontendPlugin] Error processing event", {
+						error,
+						event
+					});
+				}
+				return event;
+			};
+			if (typeof this.parentSentry.addEventProcessor === "function") {
+				this.parentSentry.addEventProcessor(processor);
+				this.eventProcessorCleanup = () => {};
+			} else logWarn("[SentryMicroFrontendPlugin] Parent Sentry does not support addEventProcessor");
+		} catch (error) {
+			logError("[SentryMicroFrontendPlugin] Failed to configure parent Sentry", { error });
+		}
+	}
+	/**
+	* Set up host mode with multiplexed transport
+	*/
+	setupHostMode(config) {
+		if (!config.backstageApps || !this.client) {
+			logWarn("[SentryMicroFrontendPlugin] Cannot setup host mode: missing backstageApps or client");
+			return;
+		}
+		try {
+			const transport = createMultiplexedTransport(config.backstageApps, config.fallbackDsn ?? config.dsn, this.client);
+			if (transport && typeof this.client.init === "function") {
+				const currentOptions = typeof this.client.getOptions === "function" ? this.client.getOptions() : {};
+				this.client.init({
+					...currentOptions,
+					transport,
+					beforeSend: createBackstageBeforeSend(this.backstageApp ?? "main", config.beforeSend)
+				});
+			} else logWarn("[SentryMicroFrontendPlugin] Client does not support init method or transport creation failed");
+		} catch (error) {
+			logError("[SentryMicroFrontendPlugin] Failed to setup host mode", { error });
+		}
+	}
+	/**
+	* Check if we should process this event
+	*/
+	shouldProcessEvent(event) {
+		if (event.tags?.microFrontendProcessed) return false;
+		if (this.backstageApp && event.tags?.backstageApp && event.tags.backstageApp !== this.backstageApp) return false;
+		return true;
+	}
+	/**
+	* Capture an exception with backstageApp context
+	*/
+	captureException(error, context) {
+		if (!this.enabled) return;
+		try {
+			if (this.mode === "child" && this.parentSentry && this.backstageScope) if (typeof this.parentSentry.withScope === "function") this.parentSentry.withScope((scope) => {
+				try {
+					if (this.backstageScope && typeof scope.setTag === "function") {
+						scope.setTag("backstageApp", this.backstageApp ?? "unknown");
+						scope.setTag("microFrontend", true);
+						scope.setContext("microFrontend", {
+							backstageApp: this.backstageApp,
+							mode: this.mode
+						});
+					}
+					if (context && typeof scope.setContext === "function") scope.setContext("additional", context);
+					if (this.parentSentry && typeof this.parentSentry.captureException === "function") this.parentSentry.captureException(error);
+				} catch (scopeError) {
+					logError("[SentryMicroFrontendPlugin] Error in scope callback", { error: scopeError });
+				}
+			});
+			else logWarn("[SentryMicroFrontendPlugin] Parent Sentry does not support withScope");
+			else {
+				const enhancedContext = {
+					...context,
+					microFrontend: {
+						backstageApp: this.backstageApp,
+						mode: this.mode
+					}
+				};
+				super.captureException(error, enhancedContext);
+			}
+		} catch (captureError) {
+			logError("[SentryMicroFrontendPlugin] Failed to capture exception", { error: captureError });
+		}
+	}
+	/**
+	* Capture a message with backstageApp context
+	*/
+	captureMessage(message, level = "info", context) {
+		if (!this.enabled) return;
+		try {
+			const sentryLevel = mapLogLevelToSentrySeverity(level);
+			if (this.mode === "child" && this.parentSentry && this.backstageScope) if (typeof this.parentSentry.withScope === "function") this.parentSentry.withScope((scope) => {
+				try {
+					if (this.backstageScope && typeof scope.setTag === "function") {
+						scope.setTag("backstageApp", this.backstageApp ?? "unknown");
+						scope.setTag("microFrontend", true);
+						if (typeof scope.setContext === "function") scope.setContext("microFrontend", {
+							backstageApp: this.backstageApp,
+							mode: this.mode
+						});
+					}
+					if (context && typeof scope.setContext === "function") scope.setContext("additional", context);
+					if (this.parentSentry && typeof this.parentSentry.captureMessage === "function") this.parentSentry.captureMessage(message, sentryLevel);
+				} catch (scopeError) {
+					logError("[SentryMicroFrontendPlugin] Error in scope callback", { error: scopeError });
+				}
+			});
+			else logWarn("[SentryMicroFrontendPlugin] Parent Sentry does not support withScope");
+			else super.captureMessage(message, level, context);
+		} catch (captureError) {
+			logError("[SentryMicroFrontendPlugin] Failed to capture message", { error: captureError });
+		}
+	}
+	/**
+	* Get the current operation mode
+	*/
+	getMode() {
+		return this.mode;
+	}
+	/**
+	* Get the current Backstage app identifier
+	*/
+	getBackstageApp() {
+		return this.backstageApp;
+	}
+	/**
+	* @deprecated Use getBackstageApp instead.
+	*/
+	getZone() {
+		return this.getBackstageApp();
+	}
+	/**
+	* Get debug information about the plugin state
+	*/
+	getDebugInfo() {
+		return {
+			mode: this.mode,
+			backstageApp: this.backstageApp,
+			enabled: this.enabled,
+			initialized: this.initialized,
+			hasParentSentry: this.mode === "child" && Boolean(this.parentSentry),
+			clientType: this.client ? this.client.constructor.name : "none"
+		};
+	}
+	/**
+	* Clean up the plugin and release resources
+	*/
+	async cleanup() {
+		try {
+			if (this.eventProcessorCleanup) {
+				this.eventProcessorCleanup();
+				this.eventProcessorCleanup = void 0;
+			}
+			if (this.backstageScope && typeof this.backstageScope.clear === "function") this.backstageScope.clear();
+			this.backstageScope = void 0;
+			this.parentSentry = void 0;
+			await super.cleanup();
+			this.initialized = false;
+			this.enabled = false;
+			logDebug("[SentryMicroFrontendPlugin] Cleanup completed");
+		} catch (error) {
+			logError("[SentryMicroFrontendPlugin] Error during cleanup", { error });
+		}
+	}
+	/**
+	* Destroy the plugin (alias for cleanup)
+	*/
+	async destroy() {
+		await this.cleanup();
+	}
+};
+/**
+* Factory function to create a Sentry Micro Frontend plugin.
+*
+* Creates a configured SentryMicroFrontendPlugin instance with micro frontend-specific
+* features like multiplexed transport and backstage app routing.
+*
+* @param config - Optional Sentry micro frontend plugin configuration
+* @returns SentryMicroFrontendPlugin instance
+*
+* @example
+* ```typescript
+* const sentry = createSentryMicroFrontendPlugin({
+*   dsn: 'https://...',
+*   backstage: [
+*     { name: 'admin', dsn: 'https://admin-dsn...' },
+*     { name: 'dashboard', dsn: 'https://dashboard-dsn...' },
+*   ],
+* });
+* ```
+*/
+const createSentryMicroFrontendPlugin = (config) => {
+	return new SentryMicroFrontendPlugin(config);
+};
+
+//#endregion
+export { isHostEnvironment as a, detectCurrentBackstageApp as i, createSentryMicroFrontendPlugin as n, createMultiplexedTransport as o, createBackstageScope as r, SentryMicroFrontendPlugin as t };
+//# sourceMappingURL=plugin-CLFwRERa.mjs.map