@parsrun/core 0.1.0

package/dist/transports/index.js

@@ -0,0 +1,657 @@
+// src/runtime.ts
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) {
+    return "bun";
+  }
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) {
+    return "deno";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.caches !== "undefined" && typeof globalThis.process === "undefined") {
+    return "cloudflare";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.EdgeRuntime !== "undefined") {
+    return "edge";
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined") {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  return "unknown";
+}
+var runtime = detectRuntime();
+var runtimeInfo = {
+  runtime,
+  isNode: runtime === "node",
+  isDeno: runtime === "deno",
+  isBun: runtime === "bun",
+  isCloudflare: runtime === "cloudflare",
+  isEdge: runtime === "cloudflare" || runtime === "edge" || runtime === "deno",
+  isBrowser: runtime === "browser",
+  isServer: runtime !== "browser",
+  supportsWebCrypto: typeof globalThis.crypto?.subtle !== "undefined",
+  supportsStreams: typeof globalThis.ReadableStream !== "undefined"
+};
+
+// src/env.ts
+var edgeEnvStore = {};
+function getEnv(key, defaultValue) {
+  if (runtime === "cloudflare" || runtime === "edge") {
+    return edgeEnvStore[key] ?? defaultValue;
+  }
+  if (runtime === "deno") {
+    try {
+      return globalThis.Deno.env.get(key) ?? defaultValue;
+    } catch {
+      return defaultValue;
+    }
+  }
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key] ?? defaultValue;
+  }
+  if (runtime === "browser" && typeof globalThis.__ENV__ !== "undefined") {
+    return globalThis.__ENV__[key] ?? defaultValue;
+  }
+  return defaultValue;
+}
+function isDevelopment() {
+  const env = getEnv("NODE_ENV");
+  return env === "development" || env === void 0;
+}
+
+// src/transports/console.ts
+var ConsoleTransport = class {
+  name = "console";
+  pretty;
+  colors;
+  constructor(options = {}) {
+    this.pretty = options.pretty ?? isDevelopment();
+    this.colors = options.colors ?? (runtime === "node" || runtime === "bun");
+  }
+  log(entry) {
+    if (this.pretty) {
+      this.logPretty(entry);
+    } else {
+      this.logJson(entry);
+    }
+  }
+  logJson(entry) {
+    const { level, message, timestamp, context, error } = entry;
+    const output = {
+      level,
+      time: timestamp,
+      msg: message
+    };
+    if (context && Object.keys(context).length > 0) {
+      Object.assign(output, context);
+    }
+    if (error) {
+      output["err"] = error;
+    }
+    console.log(JSON.stringify(output));
+  }
+  logPretty(entry) {
+    const { level, message, timestamp, context, error } = entry;
+    const levelColors = {
+      TRACE: "\x1B[90m",
+      // Gray
+      DEBUG: "\x1B[36m",
+      // Cyan
+      INFO: "\x1B[32m",
+      // Green
+      WARN: "\x1B[33m",
+      // Yellow
+      ERROR: "\x1B[31m",
+      // Red
+      FATAL: "\x1B[35m",
+      // Magenta
+      SILENT: ""
+    };
+    const reset = "\x1B[0m";
+    const color = this.colors ? levelColors[level] : "";
+    const resetCode = this.colors ? reset : "";
+    const timePart = timestamp.split("T")[1];
+    const time = timePart ? timePart.slice(0, 8) : timestamp;
+    let output = `${color}[${time}] ${level.padEnd(5)}${resetCode} ${message}`;
+    if (context && Object.keys(context).length > 0) {
+      output += ` ${JSON.stringify(context)}`;
+    }
+    if (level === "ERROR" || level === "FATAL") {
+      console.error(output);
+      if (error?.stack) {
+        console.error(error.stack);
+      }
+    } else if (level === "WARN") {
+      console.warn(output);
+    } else if (level === "DEBUG" || level === "TRACE") {
+      console.debug(output);
+    } else {
+      console.log(output);
+    }
+  }
+};
+
+// src/transports/axiom.ts
+var AxiomTransport = class {
+  name = "axiom";
+  buffer = [];
+  flushTimer = null;
+  isFlushing = false;
+  options;
+  constructor(options) {
+    this.options = {
+      batchSize: 100,
+      flushInterval: 5e3,
+      apiUrl: "https://api.axiom.co",
+      ...options
+    };
+    if (this.options.flushInterval > 0) {
+      this.flushTimer = setInterval(
+        () => this.flush(),
+        this.options.flushInterval
+      );
+    }
+  }
+  log(entry) {
+    if (this.options.enabled === false) return;
+    const event = {
+      _time: entry.timestamp,
+      level: entry.level,
+      message: entry.message
+    };
+    if (entry.context) {
+      Object.assign(event, entry.context);
+    }
+    if (entry.error) {
+      event["error.name"] = entry.error.name;
+      event["error.message"] = entry.error.message;
+      event["error.stack"] = entry.error.stack;
+    }
+    this.buffer.push(event);
+    if (this.buffer.length >= this.options.batchSize) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.isFlushing || this.buffer.length === 0) return;
+    this.isFlushing = true;
+    const events = this.buffer;
+    this.buffer = [];
+    try {
+      const response = await fetch(
+        `${this.options.apiUrl}/v1/datasets/${this.options.dataset}/ingest`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.options.token}`,
+            "Content-Type": "application/json",
+            ...this.options.orgId && {
+              "X-Axiom-Org-Id": this.options.orgId
+            }
+          },
+          body: JSON.stringify(events)
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Axiom ingest failed: ${response.status} ${errorText}`);
+      }
+    } catch (error) {
+      if (this.options.onError) {
+        this.options.onError(
+          error instanceof Error ? error : new Error(String(error)),
+          events.length
+        );
+      } else {
+        console.error("[Axiom] Failed to send logs:", error);
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  async close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+function createAxiomTransport(options) {
+  return new AxiomTransport(options);
+}
+
+// src/transports/sentry.ts
+var SentryTransport = class {
+  name = "sentry";
+  client;
+  dsn;
+  options;
+  user = null;
+  contexts = /* @__PURE__ */ new Map();
+  breadcrumbs = [];
+  maxBreadcrumbs = 100;
+  constructor(options) {
+    this.options = {
+      sampleRate: 1,
+      ...options
+    };
+    if (options.client) {
+      this.client = options.client;
+    } else if (options.dsn) {
+      this.dsn = this.parseDSN(options.dsn);
+    } else {
+      throw new Error("SentryTransport requires either 'dsn' or 'client' option");
+    }
+  }
+  /**
+   * Parse Sentry DSN
+   */
+  parseDSN(dsn) {
+    const match = dsn.match(/^(https?):\/\/([^@]+)@([^/]+)\/(.+)$/);
+    if (!match || !match[1] || !match[2] || !match[3] || !match[4]) {
+      throw new Error(`Invalid Sentry DSN: ${dsn}`);
+    }
+    return {
+      protocol: match[1],
+      publicKey: match[2],
+      host: match[3],
+      projectId: match[4]
+    };
+  }
+  /**
+   * LogTransport implementation
+   * Only sends ERROR and FATAL level logs
+   */
+  log(entry) {
+    if (this.options.enabled === false) return;
+    if (entry.levelValue < 50) return;
+    if (entry.error) {
+      const error = new Error(entry.error.message);
+      error.name = entry.error.name;
+      if (entry.error.stack) {
+        error.stack = entry.error.stack;
+      }
+      this.captureException(
+        error,
+        entry.context ? { extra: entry.context } : void 0
+      );
+    } else {
+      this.captureMessage(
+        entry.message,
+        entry.level === "FATAL" ? "error" : "warning",
+        entry.context ? { extra: entry.context } : void 0
+      );
+    }
+  }
+  /**
+   * Capture an exception
+   */
+  captureException(error, context) {
+    if (this.options.enabled === false) return;
+    if (!this.shouldSample()) return;
+    if (this.client) {
+      this.captureWithSdk(error, context);
+    } else {
+      this.captureWithHttp(error, context);
+    }
+  }
+  /**
+   * Capture a message
+   */
+  captureMessage(message, level, context) {
+    if (this.options.enabled === false) return;
+    if (!this.shouldSample()) return;
+    if (this.client) {
+      this.client.withScope((scope) => {
+        this.applyContext(scope, context);
+        scope.setLevel(level);
+        this.client.captureMessage(message, level);
+      });
+    } else {
+      this.sendHttpEvent({
+        level: level === "warning" ? "warning" : level === "info" ? "info" : "error",
+        message: { formatted: message },
+        ...this.buildEventContext(context)
+      });
+    }
+  }
+  /**
+   * Set user context
+   */
+  setUser(user) {
+    this.user = user;
+  }
+  /**
+   * Set custom context
+   */
+  setContext(name, context) {
+    this.contexts.set(name, context);
+  }
+  /**
+   * Add breadcrumb
+   */
+  addBreadcrumb(breadcrumb) {
+    this.breadcrumbs.push({
+      ...breadcrumb,
+      timestamp: breadcrumb.timestamp ?? Date.now() / 1e3
+    });
+    if (this.breadcrumbs.length > this.maxBreadcrumbs) {
+      this.breadcrumbs = this.breadcrumbs.slice(-this.maxBreadcrumbs);
+    }
+  }
+  /**
+   * Flush pending events
+   */
+  async flush() {
+    if (this.client?.flush) {
+      await this.client.flush(2e3);
+    }
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  shouldSample() {
+    const rate = this.options.sampleRate ?? 1;
+    return Math.random() < rate;
+  }
+  /**
+   * Capture with SDK (BYOS mode)
+   */
+  captureWithSdk(error, context) {
+    this.client.withScope((scope) => {
+      this.applyContext(scope, context);
+      this.client.captureException(error);
+    });
+  }
+  /**
+   * Apply context to SDK scope
+   */
+  applyContext(scope, context) {
+    if (this.user) {
+      scope.setUser(this.user);
+    } else if (context?.userId) {
+      scope.setUser({ id: context.userId });
+    }
+    if (this.options.tags) {
+      for (const [key, value] of Object.entries(this.options.tags)) {
+        scope.setTag(key, value);
+      }
+    }
+    if (context?.tags) {
+      for (const [key, value] of Object.entries(context.tags)) {
+        scope.setTag(key, value);
+      }
+    }
+    if (context?.requestId) {
+      scope.setTag("requestId", context.requestId);
+    }
+    if (context?.tenantId) {
+      scope.setTag("tenantId", context.tenantId);
+    }
+    if (context?.extra) {
+      scope.setExtras(context.extra);
+    }
+    for (const bc of this.breadcrumbs) {
+      scope.addBreadcrumb(bc);
+    }
+  }
+  /**
+   * Capture with HTTP API (default mode)
+   */
+  captureWithHttp(error, context) {
+    const stacktrace = this.parseStackTrace(error.stack);
+    const exceptionValue = {
+      type: error.name,
+      value: error.message
+    };
+    if (stacktrace) {
+      exceptionValue.stacktrace = stacktrace;
+    }
+    const event = {
+      level: "error",
+      exception: {
+        values: [exceptionValue]
+      },
+      ...this.buildEventContext(context)
+    };
+    this.sendHttpEvent(event);
+  }
+  /**
+   * Build event context for HTTP API
+   */
+  buildEventContext(context) {
+    const event = {};
+    if (this.options.environment) {
+      event.environment = this.options.environment;
+    }
+    if (this.options.release) {
+      event.release = this.options.release;
+    }
+    if (this.options.serverName) {
+      event.server_name = this.options.serverName;
+    }
+    const tags = { ...this.options.tags };
+    if (context?.tags) {
+      Object.assign(tags, context.tags);
+    }
+    if (context?.requestId) {
+      tags["requestId"] = context.requestId;
+    }
+    if (context?.tenantId) {
+      tags["tenantId"] = context.tenantId;
+    }
+    if (Object.keys(tags).length > 0) {
+      event.tags = tags;
+    }
+    if (context?.extra) {
+      event.extra = context.extra;
+    }
+    if (this.user) {
+      event.user = this.user;
+    } else if (context?.userId) {
+      event.user = { id: context.userId };
+    }
+    if (this.breadcrumbs.length > 0) {
+      event.breadcrumbs = this.breadcrumbs.map((bc) => {
+        const crumb = {};
+        if (bc.type) crumb.type = bc.type;
+        if (bc.category) crumb.category = bc.category;
+        if (bc.message) crumb.message = bc.message;
+        if (bc.data) crumb.data = bc.data;
+        if (bc.level) crumb.level = bc.level;
+        if (bc.timestamp !== void 0) crumb.timestamp = bc.timestamp;
+        return crumb;
+      });
+    }
+    if (this.contexts.size > 0) {
+      event.contexts = Object.fromEntries(this.contexts);
+    }
+    return event;
+  }
+  /**
+   * Parse error stack trace into Sentry format
+   */
+  parseStackTrace(stack) {
+    if (!stack) return void 0;
+    const lines = stack.split("\n").slice(1);
+    const frames = [];
+    for (const line of lines) {
+      const match = line.match(/^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+      if (match && match[3] && match[4]) {
+        const frame = {
+          function: match[1] || "<anonymous>",
+          lineno: parseInt(match[3], 10),
+          colno: parseInt(match[4], 10)
+        };
+        if (match[2]) {
+          frame.filename = match[2];
+        }
+        frames.push(frame);
+      }
+    }
+    frames.reverse();
+    return frames.length > 0 ? { frames } : void 0;
+  }
+  /**
+   * Generate event ID
+   */
+  generateEventId() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Send event via HTTP API
+   */
+  async sendHttpEvent(eventData) {
+    if (!this.dsn) return;
+    const event = {
+      event_id: this.generateEventId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      platform: "javascript",
+      level: "error",
+      ...eventData
+    };
+    if (this.options.beforeSend) {
+      const result = this.options.beforeSend(event);
+      if (result === null) return;
+    }
+    const url = `${this.dsn.protocol}://${this.dsn.host}/api/${this.dsn.projectId}/store/`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Sentry-Auth": [
+            "Sentry sentry_version=7",
+            `sentry_client=pars-sentry/1.0.0`,
+            `sentry_key=${this.dsn.publicKey}`
+          ].join(", ")
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        throw new Error(`Sentry API error: ${response.status}`);
+      }
+    } catch (error) {
+      if (this.options.onError) {
+        this.options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+};
+function createSentryTransport(options) {
+  return new SentryTransport(options);
+}
+
+// src/transports/logtape.ts
+var FallbackLogger = class {
+  constructor(category) {
+    this.category = category;
+  }
+  log(level, message, properties) {
+    const entry = {
+      level,
+      category: this.category,
+      msg: message,
+      time: (/* @__PURE__ */ new Date()).toISOString(),
+      ...properties
+    };
+    console.log(JSON.stringify(entry));
+  }
+  debug(message, properties) {
+    this.log("debug", message, properties);
+  }
+  info(message, properties) {
+    this.log("info", message, properties);
+  }
+  warn(message, properties) {
+    this.log("warn", message, properties);
+  }
+  warning(message, properties) {
+    this.log("warning", message, properties);
+  }
+  error(message, properties) {
+    this.log("error", message, properties);
+  }
+  fatal(message, properties) {
+    this.log("fatal", message, properties);
+  }
+};
+var LogtapeTransport = class {
+  name = "logtape";
+  logger;
+  includeTimestamp;
+  includeLevelValue;
+  enabled;
+  constructor(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.includeTimestamp = options.includeTimestamp !== false;
+    this.includeLevelValue = options.includeLevelValue ?? false;
+    if (options.logger) {
+      this.logger = options.logger;
+    } else {
+      this.logger = new FallbackLogger(options.category ?? "pars");
+    }
+  }
+  log(entry) {
+    if (!this.enabled) return;
+    const level = this.mapLevel(entry.level);
+    const properties = this.buildProperties(entry);
+    this.logger[level](entry.message, properties);
+  }
+  /**
+   * Map Pars log level to Logtape level
+   */
+  mapLevel(level) {
+    const mapping = {
+      TRACE: "debug",
+      DEBUG: "debug",
+      INFO: "info",
+      WARN: "warning",
+      ERROR: "error",
+      FATAL: "fatal",
+      SILENT: "debug"
+      // Should never be logged
+    };
+    return mapping[level];
+  }
+  /**
+   * Build properties object for Logtape
+   */
+  buildProperties(entry) {
+    const properties = {};
+    if (this.includeTimestamp) {
+      properties["timestamp"] = entry.timestamp;
+    }
+    if (this.includeLevelValue) {
+      properties["levelValue"] = entry.levelValue;
+    }
+    if (entry.context) {
+      Object.assign(properties, entry.context);
+    }
+    if (entry.error) {
+      properties["error"] = {
+        name: entry.error.name,
+        message: entry.error.message,
+        stack: entry.error.stack
+      };
+    }
+    return properties;
+  }
+};
+function createLogtapeTransport(options) {
+  return new LogtapeTransport(options);
+}
+export {
+  AxiomTransport,
+  ConsoleTransport,
+  LogtapeTransport,
+  SentryTransport,
+  createAxiomTransport,
+  createLogtapeTransport,
+  createSentryTransport
+};
+//# sourceMappingURL=index.js.map