@statly/observe 0.1.2 → 1.1.0

package/dist/integrations/nextjs.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 (error) {
+    span.setStatus("error" /* ERROR */);
+    span.setTag("error", "true");
+    if (error instanceof Error) {
+      span.setTag("exception.type", error.name);
+      span.setTag("exception.message", error.message);
+    }
+    throw error;
+  } 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/nextjs.ts
 var nextjs_exports = {};
 __export(nextjs_exports, {
@@ -373,6 +525,7 @@ var ConsoleIntegration = class {
 };
 
 // src/client.ts
+init_telemetry();
 var SDK_NAME = "@statly/observe-sdk";
 var SDK_VERSION = "0.1.0";
 var StatlyClient = class {
@@ -387,6 +540,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 {
@@ -472,6 +626,30 @@ 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
    */
@@ -772,6 +950,20 @@ async function close() {
 function getClient() {
   return client;
 }
+async function trace2(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,
@@ -782,72 +974,90 @@ var Statly = {
   addBreadcrumb,
   flush,
   close,
-  getClient
+  getClient,
+  trace: trace2,
+  startSpan,
+  captureSpan
 };
 
 // src/integrations/nextjs.ts
 function withStatlyPagesApi(handler) {
   return async (req, res) => {
-    Statly.addBreadcrumb({
-      category: "http",
-      message: `${req.method} ${req.url}`,
-      level: "info",
-      data: {
-        method: req.method,
-        url: req.url
-      }
-    });
-    try {
-      return await handler(req, res);
-    } catch (error) {
-      const context = {
-        request: {
+    return Statly.trace(`${req.method} ${req.url}`, async (span) => {
+      span.setTag("component", "nextjs-pages-api");
+      span.setTag("http.method", req.method || "GET");
+      span.setTag("http.url", req.url || "unknown");
+      Statly.addBreadcrumb({
+        category: "http",
+        message: `${req.method} ${req.url}`,
+        level: "info",
+        data: {
           method: req.method,
-          url: req.url,
-          headers: sanitizeHeaders(req.headers),
-          query: req.query
+          url: req.url
         }
-      };
-      Statly.captureException(error, context);
-      throw error;
-    }
+      });
+      try {
+        const result = await handler(req, res);
+        return result;
+      } catch (error) {
+        const context = {
+          request: {
+            method: req.method,
+            url: req.url,
+            headers: sanitizeHeaders(req.headers),
+            query: req.query
+          }
+        };
+        Statly.captureException(error, context);
+        throw error;
+      }
+    });
   };
 }
 function withStatly(handler) {
   const wrappedHandler = async (request, context) => {
-    Statly.addBreadcrumb({
-      category: "http",
-      message: `${request.method} ${request.nextUrl?.pathname || request.url}`,
-      level: "info",
-      data: {
-        method: request.method,
-        url: request.nextUrl?.pathname || request.url
-      }
-    });
-    try {
-      return await handler(request, context);
-    } catch (error) {
-      const headers = {};
-      request.headers.forEach((value, key) => {
-        headers[key] = value;
-      });
-      const errorContext = {
-        request: {
+    return Statly.trace(`${request.method} ${request.nextUrl?.pathname || request.url}`, async (span) => {
+      span.setTag("component", "nextjs-app-router");
+      span.setTag("http.method", request.method);
+      span.setTag("http.url", request.nextUrl?.pathname || request.url);
+      Statly.addBreadcrumb({
+        category: "http",
+        message: `${request.method} ${request.nextUrl?.pathname || request.url}`,
+        level: "info",
+        data: {
           method: request.method,
-          url: request.nextUrl?.pathname || request.url,
-          headers: sanitizeHeaders(headers),
-          searchParams: request.nextUrl?.searchParams?.toString()
+          url: request.nextUrl?.pathname || request.url
         }
-      };
-      if (context?.params) {
-        try {
-          errorContext.params = await context.params;
-        } catch {
+      });
+      try {
+        const result = await handler(request, context);
+        if (result instanceof Response) {
+          span.setTag("http.status_code", result.status.toString());
         }
+        return result;
+      } catch (error) {
+        const headers = {};
+        request.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        const errorContext = {
+          request: {
+            method: request.method,
+            url: request.nextUrl?.pathname || request.url,
+            headers: sanitizeHeaders(headers),
+            searchParams: request.nextUrl?.searchParams?.toString()
+          }
+        };
+        if (context?.params) {
+          try {
+            errorContext.params = await context.params;
+          } catch {
+          }
+        }
+        Statly.captureException(error, errorContext);
+        throw error;
       }
-      Statly.captureException(error, errorContext);
-      throw error;
-    }
+    });
   };
   return wrappedHandler;
 }
@@ -886,20 +1096,24 @@ function withStatlyGetStaticProps(handler) {
 }
 function withStatlyServerAction(action, actionName) {
   return async (...args) => {
-    Statly.addBreadcrumb({
-      category: "action",
-      message: `Server action: ${actionName || "unknown"}`,
-      level: "info"
-    });
-    try {
-      return await action(...args);
-    } catch (error) {
-      Statly.captureException(error, {
-        source: "server-action",
-        actionName
+    return Statly.trace(`Action: ${actionName || "unknown"}`, async (span) => {
+      span.setTag("component", "nextjs-server-action");
+      span.setTag("action.name", actionName || "unknown");
+      Statly.addBreadcrumb({
+        category: "action",
+        message: `Server action: ${actionName || "unknown"}`,
+        level: "info"
       });
-      throw error;
-    }
+      try {
+        return await action(...args);
+      } catch (error) {
+        Statly.captureException(error, {
+          source: "server-action",
+          actionName
+        });
+        throw error;
+      }
+    });
   };
 }
 function sanitizeHeaders(headers) {

package/dist/integrations/nextjs.mjs

@@ -5,7 +5,8 @@ import {
   withStatlyGetStaticProps,
   withStatlyPagesApi,
   withStatlyServerAction
-} from "../chunk-UNDSALI5.mjs";
+} from "../chunk-HYFH22G6.mjs";
+import "../chunk-J5AHUFP2.mjs";
 export {
   captureNextJsError,
   withStatly,

package/dist/telemetry-CXHOTW3Y.mjs

@@ -0,0 +1,8 @@
+import {
+  TelemetryProvider,
+  trace
+} from "./chunk-J5AHUFP2.mjs";
+export {
+  TelemetryProvider,
+  trace
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statly/observe",
-  "version": "0.1.2",
+  "version": "1.1.0",
   "description": "JavaScript SDK for Statly Observe - Error tracking and monitoring",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -76,4 +76,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}