@statly/observe 1.0.0 → 1.2.0

package/dist/index.mjs

@@ -5,6 +5,7 @@ import {
   captureException,
   captureMessage,
   captureNextJsError,
+  captureSpan,
   close,
   createRequestCapture,
   expressErrorHandler,
@@ -15,33 +16,93 @@ import {
   setTag,
   setTags,
   setUser,
+  startSpan,
   statlyFastifyPlugin,
   statlyPlugin,
+  trace as trace2,
   withStatly,
   withStatlyGetServerSideProps,
   withStatlyGetStaticProps,
   withStatlyPagesApi,
   withStatlyServerAction
-} from "./chunk-UNDSALI5.mjs";
+} from "./chunk-SJ7C46AP.mjs";
+import {
+  AIFeatures,
+  ConsoleDestination,
+  DEFAULT_LEVELS,
+  EXTENDED_LEVELS,
+  FileDestination,
+  LOG_LEVELS,
+  Logger,
+  ObserveDestination,
+  REDACTED,
+  SCRUB_PATTERNS,
+  SENSITIVE_KEYS,
+  Scrubber,
+  audit,
+  debug,
+  error,
+  fatal,
+  formatJson,
+  formatJsonPretty,
+  formatPretty,
+  getConsoleMethod,
+  getDefaultLogger,
+  info,
+  isSensitiveKey,
+  setDefaultLogger,
+  trace,
+  warn
+} from "./chunk-7AITSJLP.mjs";
+import "./chunk-J5AHUFP2.mjs";
 export {
+  AIFeatures,
+  ConsoleDestination,
+  DEFAULT_LEVELS,
+  EXTENDED_LEVELS,
+  FileDestination,
+  LOG_LEVELS,
+  Logger,
+  ObserveDestination,
+  REDACTED,
+  SCRUB_PATTERNS,
+  SENSITIVE_KEYS,
+  Scrubber,
   Statly,
   StatlyClient,
   addBreadcrumb,
   captureException,
   captureMessage,
   captureNextJsError,
+  captureSpan,
   close,
   createRequestCapture,
   expressErrorHandler,
   flush,
+  formatJson,
+  formatJsonPretty,
+  formatPretty,
   getClient,
+  getConsoleMethod,
+  getDefaultLogger,
   init,
+  isSensitiveKey,
+  audit as logAudit,
+  debug as logDebug,
+  error as logError,
+  fatal as logFatal,
+  info as logInfo,
+  trace as logTrace,
+  warn as logWarn,
   requestHandler,
+  setDefaultLogger,
   setTag,
   setTags,
   setUser,
+  startSpan,
   statlyFastifyPlugin,
   statlyPlugin,
+  trace2 as trace,
   withStatly,
   withStatlyGetServerSideProps,
   withStatlyGetStaticProps,

package/dist/integrations/express.js

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,6 +20,155 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/span.ts
+var Span, TraceContext;
+var init_span = __esm({
+  "src/span.ts"() {
+    "use strict";
+    Span = class {
+      constructor(name, context, tags) {
+        this._status = "ok" /* OK */;
+        this._tags = {};
+        this._metadata = {};
+        this._finished = false;
+        this.name = name;
+        this.context = context;
+        this.startTime = Date.now();
+        if (tags) this._tags = { ...tags };
+      }
+      /**
+       * Finish the span and calculate duration
+       */
+      finish(endTime) {
+        if (this._finished) return;
+        this._endTime = endTime || Date.now();
+        this._durationMs = this._endTime - this.startTime;
+        this._finished = true;
+      }
+      setTag(key, value) {
+        this._tags[key] = value;
+        return this;
+      }
+      setMetadata(key, value) {
+        this._metadata[key] = value;
+        return this;
+      }
+      setStatus(status) {
+        this._status = status;
+        return this;
+      }
+      get status() {
+        return this._status;
+      }
+      get tags() {
+        return { ...this._tags };
+      }
+      get durationMs() {
+        return this._durationMs;
+      }
+      toDict() {
+        return {
+          name: this.name,
+          traceId: this.context.traceId,
+          spanId: this.context.spanId,
+          parentId: this.context.parentId,
+          startTime: this.startTime,
+          endTime: this._endTime,
+          durationMs: this._durationMs,
+          status: this._status,
+          tags: this._tags,
+          metadata: this._metadata
+        };
+      }
+    };
+    TraceContext = class {
+      static getActiveSpan() {
+        return this.currentSpan;
+      }
+      static setActiveSpan(span) {
+        this.currentSpan = span;
+      }
+    };
+    TraceContext.currentSpan = null;
+  }
+});
+
+// src/telemetry.ts
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  TelemetryProvider: () => TelemetryProvider,
+  trace: () => trace
+});
+async function trace(name, operation, tags) {
+  const provider = TelemetryProvider.getInstance();
+  const span = provider.startSpan(name, tags);
+  try {
+    const result = await operation(span);
+    return result;
+  } catch (error2) {
+    span.setStatus("error" /* ERROR */);
+    span.setTag("error", "true");
+    if (error2 instanceof Error) {
+      span.setTag("exception.type", error2.name);
+      span.setTag("exception.message", error2.message);
+    }
+    throw error2;
+  } finally {
+    provider.finishSpan(span);
+  }
+}
+var TelemetryProvider;
+var init_telemetry = __esm({
+  "src/telemetry.ts"() {
+    "use strict";
+    init_span();
+    TelemetryProvider = class _TelemetryProvider {
+      constructor() {
+        this.client = null;
+      }
+      static getInstance() {
+        if (!_TelemetryProvider.instance) {
+          _TelemetryProvider.instance = new _TelemetryProvider();
+        }
+        return _TelemetryProvider.instance;
+      }
+      setClient(client2) {
+        this.client = client2;
+      }
+      /**
+       * Start a new span
+       */
+      startSpan(name, tags) {
+        const parent = TraceContext.getActiveSpan();
+        const traceId = parent ? parent.context.traceId : this.generateId();
+        const parentId = parent ? parent.context.spanId : null;
+        const span = new Span(name, {
+          traceId,
+          spanId: this.generateId(),
+          parentId
+        }, tags);
+        TraceContext.setActiveSpan(span);
+        return span;
+      }
+      /**
+       * Finish and report a span
+       */
+      finishSpan(span) {
+        span.finish();
+        if (TraceContext.getActiveSpan() === span) {
+          TraceContext.setActiveSpan(null);
+        }
+        if (this.client) {
+          this.client.captureSpan(span);
+        }
+      }
+      generateId() {
+        return Math.random().toString(16).substring(2, 18);
+      }
+    };
+  }
+});
+
 // src/integrations/express.ts
 var express_exports = {};
 __export(express_exports, {
@@ -85,10 +237,10 @@ var Transport = class {
     this.queue = [];
     try {
       await this.sendBatch(events);
-    } catch (error) {
+    } catch (error2) {
       this.queue = [...events, ...this.queue].slice(0, this.maxQueueSize);
       if (this.debug) {
-        console.error("[Statly] Failed to send events:", error);
+        console.error("[Statly] Failed to send events:", error2);
       }
     } finally {
       this.isSending = false;
@@ -128,13 +280,13 @@ var Transport = class {
         console.log(`[Statly] Sent ${events.length} event(s)`);
       }
       return { success: true, status: response.status };
-    } catch (error) {
+    } catch (error2) {
       if (this.debug) {
-        console.error("[Statly] Network error:", error);
+        console.error("[Statly] Network error:", error2);
       }
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Network error"
+        error: error2 instanceof Error ? error2.message : "Network error"
       };
     }
   }
@@ -201,16 +353,16 @@ var GlobalHandlers = class {
       if (!this.errorCallback) {
         return;
       }
-      let error;
+      let error2;
       if (event.reason instanceof Error) {
-        error = event.reason;
+        error2 = event.reason;
       } else if (typeof event.reason === "string") {
-        error = new Error(event.reason);
+        error2 = new Error(event.reason);
       } else {
-        error = new Error("Unhandled Promise Rejection");
-        error.reason = event.reason;
+        error2 = new Error("Unhandled Promise Rejection");
+        error2.reason = event.reason;
       }
-      this.errorCallback(error, {
+      this.errorCallback(error2, {
         mechanism: { type: "onunhandledrejection", handled: false }
       });
     };
@@ -253,13 +405,13 @@ var GlobalHandlers = class {
   }
   installOnError() {
     this.originalOnError = window.onerror;
-    window.onerror = (message, source, lineno, colno, error) => {
+    window.onerror = (message, source, lineno, colno, error2) => {
       if (this.originalOnError) {
-        this.originalOnError.call(window, message, source, lineno, colno, error);
+        this.originalOnError.call(window, message, source, lineno, colno, error2);
       }
       if (this.errorCallback) {
-        const errorObj = error || new Error(String(message));
-        if (!error && source) {
+        const errorObj = error2 || new Error(String(message));
+        if (!error2 && source) {
           errorObj.filename = source;
           errorObj.lineno = lineno;
           errorObj.colno = colno;
@@ -369,6 +521,7 @@ var ConsoleIntegration = class {
 };
 
 // src/client.ts
+init_telemetry();
 var SDK_NAME = "@statly/observe-sdk";
 var SDK_VERSION = "0.1.0";
 var StatlyClient = class {
@@ -383,6 +536,7 @@ var StatlyClient = class {
     this.breadcrumbs = new BreadcrumbManager(this.options.maxBreadcrumbs);
     this.globalHandlers = new GlobalHandlers();
     this.consoleIntegration = new ConsoleIntegration();
+    TelemetryProvider.getInstance().setClient(this);
   }
   mergeOptions(options) {
     return {
@@ -422,8 +576,8 @@ var StatlyClient = class {
     }
     this.initialized = true;
     if (this.options.autoCapture) {
-      this.globalHandlers.install((error, context) => {
-        this.captureError(error, context);
+      this.globalHandlers.install((error2, context) => {
+        this.captureError(error2, context);
       });
     }
     if (this.options.captureConsole) {
@@ -446,15 +600,15 @@ var StatlyClient = class {
   /**
    * Capture an exception/error
    */
-  captureException(error, context) {
+  captureException(error2, context) {
     let errorObj;
-    if (error instanceof Error) {
-      errorObj = error;
-    } else if (typeof error === "string") {
-      errorObj = new Error(error);
+    if (error2 instanceof Error) {
+      errorObj = error2;
+    } else if (typeof error2 === "string") {
+      errorObj = new Error(error2);
     } else {
       errorObj = new Error("Unknown error");
-      errorObj.originalError = error;
+      errorObj.originalError = error2;
     }
     return this.captureError(errorObj, context);
   }
@@ -468,21 +622,45 @@ var StatlyClient = class {
     });
     return this.sendEvent(event);
   }
+  /**
+   * Capture a completed span
+   */
+  captureSpan(span) {
+    const event = this.buildEvent({
+      message: `Span: ${span.name}`,
+      level: "span",
+      span: span.toDict()
+    });
+    return this.sendEvent(event);
+  }
+  /**
+   * Start a new tracing span
+   */
+  startSpan(name, tags) {
+    return TelemetryProvider.getInstance().startSpan(name, tags);
+  }
+  /**
+   * Execute a function within a trace span
+   */
+  async trace(name, operation, tags) {
+    const { trace: traceFn } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
+    return traceFn(name, operation, tags);
+  }
   /**
    * Internal method to capture an error
    */
-  captureError(error, context) {
+  captureError(error2, context) {
     if (Math.random() > this.options.sampleRate) {
       return "";
     }
     const event = this.buildEvent({
-      message: error.message,
+      message: error2.message,
       level: "error",
-      stack: error.stack,
+      stack: error2.stack,
       exception: {
-        type: error.name,
-        value: error.message,
-        stacktrace: this.parseStackTrace(error.stack)
+        type: error2.name,
+        value: error2.message,
+        stacktrace: this.parseStackTrace(error2.stack)
       },
       extra: context
     });
@@ -676,6 +854,35 @@ var StatlyClient = class {
   }
 };
 
+// src/logger/formatters/console.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+var LEVEL_COLORS = {
+  trace: COLORS.gray,
+  debug: COLORS.cyan,
+  info: COLORS.green,
+  warn: COLORS.yellow,
+  error: COLORS.red,
+  fatal: `${COLORS.bgRed}${COLORS.white}`,
+  audit: COLORS.magenta
+};
+
 // src/index.ts
 var client = null;
 function loadDsnFromEnv() {
@@ -710,12 +917,12 @@ function init(options) {
   client = new StatlyClient(finalOptions);
   client.init();
 }
-function captureException(error, context) {
+function captureException(error2, context) {
   if (!client) {
     console.warn("[Statly] SDK not initialized. Call Statly.init() first.");
     return "";
   }
-  return client.captureException(error, context);
+  return client.captureException(error2, context);
 }
 function captureMessage(message, level = "info") {
   if (!client) {
@@ -768,6 +975,20 @@ async function close() {
 function getClient() {
   return client;
 }
+async function trace3(name, operation, tags) {
+  if (!client) {
+    return operation(null);
+  }
+  return client.trace(name, operation, tags);
+}
+function startSpan(name, tags) {
+  if (!client) return null;
+  return client.startSpan(name, tags);
+}
+function captureSpan(span) {
+  if (!client) return "";
+  return client.captureSpan(span);
+}
 var Statly = {
   init,
   captureException,
@@ -778,7 +999,10 @@ var Statly = {
   addBreadcrumb,
   flush,
   close,
-  getClient
+  getClient,
+  trace: trace3,
+  startSpan,
+  captureSpan
 };
 
 // src/integrations/express.ts
@@ -820,8 +1044,8 @@ function requestHandler() {
 }
 function expressErrorHandler(options = {}) {
   return (err, req, res, next) => {
-    const error = err instanceof Error ? err : new Error(String(err));
-    if (options.shouldHandleError && !options.shouldHandleError(error)) {
+    const error2 = err instanceof Error ? err : new Error(String(err));
+    if (options.shouldHandleError && !options.shouldHandleError(error2)) {
       return next(err);
     }
     const context = {
@@ -845,7 +1069,7 @@ function expressErrorHandler(options = {}) {
     if (req.statlyContext?.transactionName) {
       Statly.setTag("transaction", req.statlyContext.transactionName);
     }
-    Statly.captureException(error, context);
+    Statly.captureException(error2, context);
     next(err);
   };
 }

package/dist/integrations/express.mjs

@@ -1,7 +1,9 @@
 import {
   expressErrorHandler,
   requestHandler
-} from "../chunk-UNDSALI5.mjs";
+} from "../chunk-SJ7C46AP.mjs";
+import "../chunk-7AITSJLP.mjs";
+import "../chunk-J5AHUFP2.mjs";
 export {
   expressErrorHandler,
   requestHandler