@buoy-gg/shared-ui 1.7.2

package/lib/commonjs/logger/index-sentry.js

@@ -0,0 +1,245 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "LogLevel", {
+  enumerable: true,
+  get: function () {
+    return _types.LogLevel;
+  }
+});
+Object.defineProperty(exports, "LogType", {
+  enumerable: true,
+  get: function () {
+    return _types.LogType;
+  }
+});
+exports.sentryLogger = exports.SentryLogger = void 0;
+var _logDump = require("./logDump.js");
+var _types = require("./types.js");
+// Simple ID generator to replace nanoid
+const generateId = () => `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+/**
+ * SentryLogger - Captures Sentry events for display in admin modal
+ *
+ * This logger is specifically designed to capture Sentry events before they are sent
+ * and store them in memory for display in the admin modal. It maintains up to 500 events.
+ *
+ * Usage:
+ * ```ts
+ * // In your Sentry.init():
+ * const logger = new SentryLogger();
+ *
+ * Sentry.init({
+ *   beforeSendTransaction: logger.captureTransaction,
+ *   beforeSendSpan: logger.captureSpan,
+ *   beforeSend: logger.captureEvent,
+ *   beforeBreadcrumb: logger.captureBreadcrumb,
+ *   // ... other config
+ * });
+ * ```
+ */
+class SentryLogger {
+  /**
+   * Capture a Sentry transaction before it's sent
+   */
+  captureTransaction = event => {
+    this.logSentryEvent("transaction", event);
+    return event;
+  };
+
+  /**
+   * Capture a Sentry span before it's sent
+   */
+  captureSpan = span => {
+    this.logSentryEvent("span", span);
+    return span;
+  };
+
+  /**
+   * Capture a Sentry event before it's sent
+   */
+  captureEvent = event => {
+    this.logSentryEvent("event", event);
+    return event;
+  };
+
+  /**
+   * Capture a Sentry log before it's sent
+   */
+  captureLog = log => {
+    this.logSentryEvent("console", {
+      message: log.message || "Log entry",
+      level: log.level,
+      category: "console",
+      timestamp: log.timestamp,
+      ...log.attributes
+    });
+    return log;
+  };
+
+  /**
+   * Capture a Sentry breadcrumb before it's added
+   */
+  captureBreadcrumb = breadcrumb => {
+    // Get current pathname from global tracker if available
+    let pathname = "unknown";
+    try {
+      // Try to get the pathname from the global function if it exists
+      const getCurrentPathname = globalThis.getCurrentPathname;
+      if (getCurrentPathname) {
+        pathname = getCurrentPathname();
+      }
+    } catch {
+      // Ignore errors - use default pathname
+    }
+
+    // Type assertion for the category
+    const category = breadcrumb.category;
+
+    // Filter out breadcrumbs with "ignore" in the message (for admin components)
+    if (breadcrumb.message?.toLowerCase().includes("ignore")) {
+      return null;
+    }
+
+    // Replace touch event message if present
+    if (breadcrumb.message?.includes("Touch event within element:")) {
+      breadcrumb.message = breadcrumb.message.replace("Touch event within element:", "");
+    }
+
+    // Replace navigation message if present
+    if (category === "navigation" && breadcrumb.data?.from && breadcrumb.data?.to) {
+      breadcrumb.message = `From ${breadcrumb.data.from} To ${breadcrumb.data.to}`;
+    }
+
+    // Handle touch events specially
+    if (category === "touch" && breadcrumb.data?.path) {
+      // Clean up message if it starts with a space
+      if (breadcrumb.message) {
+        breadcrumb.message = breadcrumb.message.trim();
+      }
+
+      // Create enriched data structure
+      const enrichedData = {
+        ...breadcrumb.data,
+        category,
+        message: breadcrumb.message,
+        route: pathname,
+        timestamp: new Date().toISOString(),
+        path: breadcrumb.message ? [{
+          label: breadcrumb.message
+        }] : breadcrumb.data?.path
+      };
+
+      // Update breadcrumb data
+      breadcrumb.data = enrichedData;
+    }
+    this.logSentryEvent("breadcrumb", breadcrumb);
+    return breadcrumb;
+  };
+
+  /**
+   * Internal method to log Sentry events to memory
+   */
+  logSentryEvent(type, data) {
+    // Determine log type based on Sentry category
+    let logType = _types.LogType.Generic;
+    const category = data.category;
+    if (category) {
+      switch (category) {
+        case "touch":
+          logType = _types.LogType.Touch;
+          break;
+        case "xhr":
+        case "fetch":
+        case "http":
+          logType = _types.LogType.HTTPRequest;
+          break;
+        case "navigation":
+          logType = _types.LogType.Navigation;
+          break;
+        case "auth":
+          logType = _types.LogType.Auth;
+          break;
+        case "console":
+          logType = _types.LogType.System;
+          break;
+        case "debug":
+          logType = _types.LogType.Debug;
+          break;
+        default:
+          if (category.startsWith("ui.")) {
+            logType = _types.LogType.UserAction;
+          } else if (category.startsWith("replay.")) {
+            logType = _types.LogType.Replay;
+          } else if (category.includes("redux") || category.includes("state")) {
+            logType = _types.LogType.State;
+          } else {
+            logType = _types.LogType.Custom;
+          }
+      }
+    }
+
+    // Create log entry
+    const entry = {
+      id: generateId(),
+      timestamp: Date.now(),
+      level: this.getSentryLevel(data),
+      message: this.getSentryMessage(data),
+      metadata: this.getSentryMetadata(data),
+      type: logType
+    };
+
+    // Add to memory store
+    (0, _logDump.add)(entry);
+  }
+
+  /**
+   * Get appropriate log level from Sentry data
+   */
+  getSentryLevel(data) {
+    const level = data.level;
+    switch (level) {
+      case "fatal":
+      case "error":
+        return _types.LogLevel.Error;
+      case "warning":
+        return _types.LogLevel.Warn;
+      case "info":
+        return _types.LogLevel.Info;
+      case "debug":
+        return _types.LogLevel.Debug;
+      default:
+        return _types.LogLevel.Log;
+    }
+  }
+
+  /**
+   * Extract message from Sentry data
+   */
+  getSentryMessage(data) {
+    const message = data.message;
+    if (typeof message === "string") {
+      return message;
+    }
+    return `${data.type || "Unknown"} Event`;
+  }
+
+  /**
+   * Extract metadata from Sentry data
+   */
+  getSentryMetadata(data) {
+    const {
+      message,
+      level,
+      type,
+      ...metadata
+    } = data;
+    return metadata;
+  }
+}
+
+// Export a default instance for convenience
+exports.SentryLogger = SentryLogger;
+const sentryLogger = exports.sentryLogger = new SentryLogger();

package/lib/commonjs/logger/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "LogLevel", {
+  enumerable: true,
+  get: function () {
+    return _indexSentry.LogLevel;
+  }
+});
+Object.defineProperty(exports, "LogLevelEnum", {
+  enumerable: true,
+  get: function () {
+    return _types.LogLevel;
+  }
+});
+Object.defineProperty(exports, "LogType", {
+  enumerable: true,
+  get: function () {
+    return _indexSentry.LogType;
+  }
+});
+Object.defineProperty(exports, "LogTypeEnum", {
+  enumerable: true,
+  get: function () {
+    return _types.LogType;
+  }
+});
+Object.defineProperty(exports, "SentryLogger", {
+  enumerable: true,
+  get: function () {
+    return _indexSentry.SentryLogger;
+  }
+});
+Object.defineProperty(exports, "add", {
+  enumerable: true,
+  get: function () {
+    return _logDump.add;
+  }
+});
+Object.defineProperty(exports, "clearEntries", {
+  enumerable: true,
+  get: function () {
+    return _logDump.clearEntries;
+  }
+});
+Object.defineProperty(exports, "getEntries", {
+  enumerable: true,
+  get: function () {
+    return _logDump.getEntries;
+  }
+});
+Object.defineProperty(exports, "sentryLogger", {
+  enumerable: true,
+  get: function () {
+    return _indexSentry.sentryLogger;
+  }
+});
+var _indexSentry = require("./index-sentry.js");
+var _logDump = require("./logDump.js");
+var _types = require("./types.js");

package/lib/commonjs/logger/logDump.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.add = add;
+exports.clearEntries = clearEntries;
+exports.getEntries = getEntries;
+let entries = [];
+function add(entry) {
+  entries.unshift(entry);
+  entries = entries.slice(0, 500);
+}
+function getEntries() {
+  return entries;
+}
+function clearEntries() {
+  entries = [];
+}

package/lib/commonjs/logger/types.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogType = exports.LogLevel = void 0;
+let LogLevel = exports.LogLevel = /*#__PURE__*/function (LogLevel) {
+  LogLevel["Debug"] = "debug";
+  LogLevel["Info"] = "info";
+  LogLevel["Log"] = "log";
+  LogLevel["Warn"] = "warn";
+  LogLevel["Error"] = "error";
+  return LogLevel;
+}({});
+let LogType = exports.LogType = /*#__PURE__*/function (LogType) {
+  LogType["Auth"] = "Auth";
+  LogType["Custom"] = "Custom";
+  LogType["Debug"] = "Debug";
+  LogType["Error"] = "Error";
+  LogType["Generic"] = "Generic";
+  LogType["HTTPRequest"] = "HTTP Request";
+  LogType["Navigation"] = "Navigation";
+  LogType["Replay"] = "Replay";
+  LogType["State"] = "State";
+  LogType["System"] = "System";
+  LogType["Touch"] = "Touch";
+  LogType["UserAction"] = "User Action";
+  return LogType;
+}({});
+/**
+ * Event object structure that matches Sentry Event format
+ */
+/**
+ * Breadcrumb object structure that matches Sentry Breadcrumb format
+ */
+/**
+ * Metadata type that encompasses breadcrumb properties and capture context
+ */

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}