tidewave 0.6.0 → 0.8.0

package/dist/next-js/instrumentation.d.ts

@@ -1,2 +0,0 @@
-export { TidewaveSpanProcessor } from '../logger/tidewave-span-processor';
-export { TidewaveLogRecordProcessor } from '../logger/tidewave-log-record-processor';

package/dist/next-js/instrumentation.js

@@ -1,256 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/logger/tidewave-logger.ts
-import { appendFile, readFile } from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-
-class TidewaveLogger {
-  logFilePath;
-  constructor() {
-    const cwd = process.cwd();
-    const digest = crypto.createHash("md5").update(cwd).digest("hex").slice(0, 16);
-    const tempDir = os.tmpdir();
-    this.logFilePath = path.join(tempDir, `${digest}.tidewave.ndjson`);
-  }
-  async addLog(log) {
-    const line = JSON.stringify(log) + `
-`;
-    try {
-      await appendFile(this.logFilePath, line, "utf8");
-    } catch (error) {
-      console.log("[Tidewave] failed to write to log file, error:", error);
-    }
-  }
-  async getLogs(options) {
-    let logs = await this.getAllLogs();
-    if (options?.level) {
-      const level = options.level.toUpperCase();
-      logs = logs.filter((log) => log.severityText === level);
-    }
-    if (options?.since) {
-      const sinceDate = new Date(options.since);
-      logs = logs.filter((log) => new Date(log.timestamp) >= sinceDate);
-    }
-    if (options?.grep) {
-      const regex = new RegExp(options.grep, "i");
-      logs = logs.filter((log) => regex.test(log.body) || regex.test(JSON.stringify(log.attributes)));
-    }
-    if (options?.tail) {
-      logs = logs.slice(-options.tail);
-    }
-    return logs;
-  }
-  async getAllLogs() {
-    try {
-      const content = await readFile(this.logFilePath, "utf8");
-      return content.split(`
-`).map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
-        }
-      }).filter((log) => log !== null);
-    } catch (error) {
-      console.log("[Tidewave] failed to read from log file, error:", error);
-      return [];
-    }
-  }
-}
-var tidewaveLogger;
-var init_tidewave_logger = __esm(() => {
-  tidewaveLogger = new TidewaveLogger;
-});
-
-// src/logger/console-patch.ts
-var exports_console_patch = {};
-__export(exports_console_patch, {
-  patchConsole: () => patchConsole
-});
-function stripAnsiCodes(text) {
-  return text.replace(ANSI_REGEX, "");
-}
-function patchConsole() {
-  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
-  if (isBrowser) {
-    return;
-  }
-  if (globalThis.__TIDEWAVE_CONSOLE_PATCHED__) {
-    return;
-  }
-  const severityMap = {
-    log: "INFO",
-    info: "INFO",
-    warn: "WARN",
-    error: "ERROR",
-    debug: "DEBUG"
-  };
-  Object.entries(severityMap).forEach(([method, severity]) => {
-    const original = console[method].bind(console);
-    console[method] = (...args) => {
-      try {
-        const body = args.map((arg) => {
-          if (typeof arg === "string")
-            return arg;
-          if (arg instanceof Error) {
-            return String(arg.stack);
-          }
-          if (typeof arg === "object") {
-            try {
-              return JSON.stringify(arg);
-            } catch {
-              return String(arg);
-            }
-          }
-          return String(arg);
-        }).map(stripAnsiCodes).join(" ");
-        const isAllWhitespace = body.match(/^\s+$/);
-        if (!isAllWhitespace) {
-          tidewaveLogger.addLog({
-            timestamp: new Date().toISOString(),
-            severityText: severity,
-            body,
-            attributes: {
-              "log.origin": "console",
-              "log.method": method
-            }
-          });
-        }
-      } catch {}
-      original(...args);
-    };
-  });
-  globalThis.__TIDEWAVE_CONSOLE_PATCHED__ = true;
-}
-var ANSI_REGEX;
-var init_console_patch = __esm(() => {
-  init_tidewave_logger();
-  ANSI_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-});
-
-// src/next-js/instrumentation.ts
-init_console_patch();
-
-// src/logger/tidewave-span-processor.ts
-init_tidewave_logger();
-
-class TidewaveSpanProcessor {
-  onStart(_span, _parentContext) {}
-  onEnd(span) {
-    try {
-      const spanType = span.attributes["next.span_type"];
-      const httpMethod = span.attributes["http.method"];
-      const relevantSpanTypes = [
-        "BaseServer.handleRequest",
-        "AppRender.getBodyResult",
-        "AppRouteRouteHandlers.runHandler"
-      ];
-      if (!spanType || !relevantSpanTypes.includes(spanType)) {
-        return;
-      }
-      const route = span.attributes["next.route"] || span.attributes["http.route"];
-      const httpUrl = span.attributes["http.url"];
-      const httpTarget = span.attributes["http.target"];
-      const httpStatusCode = span.attributes["http.status_code"];
-      const path2 = route || httpTarget || httpUrl || "unknown";
-      if (typeof path2 === "string" && path2.startsWith("/tidewave")) {
-        return;
-      }
-      const durationMs = this.calculateDuration(span);
-      let message = "";
-      let severity = "INFO";
-      if (spanType === "BaseServer.handleRequest") {
-        const method = httpMethod || "UNKNOWN";
-        const status = httpStatusCode || "unknown";
-        message = `${method} ${path2} ${status} ${durationMs.toFixed(2)}ms`;
-        if (typeof httpStatusCode === "number") {
-          if (httpStatusCode >= 500)
-            severity = "ERROR";
-          else if (httpStatusCode >= 400)
-            severity = "WARN";
-        }
-      } else if (spanType === "AppRender.getBodyResult") {
-        message = `Rendered route: ${route || "unknown"} (${durationMs.toFixed(2)}ms)`;
-      } else if (spanType === "AppRouteRouteHandlers.runHandler") {
-        message = `API route: ${route || "unknown"} (${durationMs.toFixed(2)}ms)`;
-      }
-      tidewaveLogger.addLog({
-        timestamp: new Date(span.endTime[0] * 1000 + span.endTime[1] / 1e6).toISOString(),
-        severityText: severity,
-        body: message,
-        attributes: {
-          "log.origin": "opentelemetry-span",
-          "span.name": span.name,
-          "span.kind": span.kind,
-          "span.type": spanType,
-          "http.method": httpMethod,
-          "http.route": route,
-          "http.status_code": httpStatusCode,
-          "duration.ms": durationMs
-        }
-      });
-    } catch (_error) {}
-  }
-  calculateDuration(span) {
-    const startTimeMs = span.startTime[0] * 1000 + span.startTime[1] / 1e6;
-    const endTimeMs = span.endTime[0] * 1000 + span.endTime[1] / 1e6;
-    return endTimeMs - startTimeMs;
-  }
-  async forceFlush() {}
-  async shutdown() {}
-}
-// src/logger/tidewave-log-record-processor.ts
-init_tidewave_logger();
-
-class TidewaveLogRecordProcessor {
-  onEmit(logRecord, _context) {
-    try {
-      const body = String(logRecord.body || "");
-      tidewaveLogger.addLog({
-        timestamp: new Date(logRecord.hrTime[0] * 1000 + logRecord.hrTime[1] / 1e6).toISOString(),
-        severityText: logRecord.severityText || "INFO",
-        body,
-        attributes: logRecord.attributes
-      });
-    } catch (_error) {}
-  }
-  async forceFlush() {}
-  async shutdown() {}
-}
-
-// src/next-js/instrumentation.ts
-patchConsole();
-export {
-  TidewaveSpanProcessor,
-  TidewaveLogRecordProcessor
-};