@parsrun/core 0.1.0

package/dist/transports/index.d.ts

@@ -0,0 +1,347 @@
+import { h as LogTransport, p as BatchTransportOptions, g as LogEntry, E as ErrorTransport, o as BaseTransportOptions, k as ErrorContext, n as ErrorUser, B as Breadcrumb } from '../logger-aEibH9Mv.js';
+export { j as CombinedTransport, C as ConsoleTransport, q as ConsoleTransportOptions } from '../logger-aEibH9Mv.js';
+
+/**
+ * @parsrun/core - Axiom Transport
+ * Log ingestion transport for Axiom (axiom.co)
+ * Uses native fetch - works on all runtimes (Node, Deno, Bun, Workers)
+ */
+
+/**
+ * Axiom transport options
+ */
+interface AxiomTransportOptions extends BatchTransportOptions {
+    /** Axiom API token */
+    token: string;
+    /** Dataset name to ingest logs into */
+    dataset: string;
+    /** Organization ID (optional, for personal tokens) */
+    orgId?: string;
+    /** Custom Axiom API URL (default: https://api.axiom.co) */
+    apiUrl?: string;
+    /** Callback for errors during ingestion */
+    onError?: (error: Error, droppedCount: number) => void;
+}
+/**
+ * Axiom Transport
+ * Batches logs and sends them to Axiom's ingest API
+ */
+declare class AxiomTransport implements LogTransport {
+    readonly name = "axiom";
+    private buffer;
+    private flushTimer;
+    private isFlushing;
+    private readonly options;
+    constructor(options: AxiomTransportOptions);
+    log(entry: LogEntry): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Create Axiom transport
+ */
+declare function createAxiomTransport(options: AxiomTransportOptions): AxiomTransport;
+
+/**
+ * @parsrun/core - Sentry Transport
+ * Error tracking transport for Sentry
+ *
+ * Supports two modes:
+ * 1. HTTP API mode (default) - Zero dependency, works on all runtimes
+ * 2. SDK mode (BYOS) - Full features with user-provided Sentry SDK
+ *
+ * @example HTTP API mode (simple, universal)
+ * ```typescript
+ * const sentry = new SentryTransport({
+ *   dsn: 'https://xxx@sentry.io/123',
+ *   environment: 'production',
+ * });
+ * ```
+ *
+ * @example SDK mode (full features)
+ * ```typescript
+ * import * as Sentry from '@sentry/cloudflare'; // or @sentry/node
+ *
+ * Sentry.init({ dsn: '...' });
+ *
+ * const sentry = new SentryTransport({
+ *   client: Sentry,
+ * });
+ * ```
+ */
+
+/**
+ * Sentry SDK interface (minimal interface for BYOS)
+ * Compatible with @sentry/node, @sentry/cloudflare, @sentry/browser, etc.
+ */
+interface SentryClient {
+    captureException(error: Error, hint?: unknown): string;
+    captureMessage(message: string, level?: string): string;
+    withScope(callback: (scope: SentryScope) => void): void;
+    flush?(timeout?: number): Promise<boolean>;
+}
+interface SentryScope {
+    setTag(key: string, value: string): void;
+    setUser(user: {
+        id: string;
+        email?: string;
+        [key: string]: unknown;
+    } | null): void;
+    setExtra(key: string, value: unknown): void;
+    setExtras(extras: Record<string, unknown>): void;
+    setLevel(level: string): void;
+    addBreadcrumb(breadcrumb: unknown): void;
+}
+/**
+ * Sentry transport options
+ */
+interface SentryTransportOptions extends BaseTransportOptions {
+    /**
+     * Sentry DSN (required for HTTP mode)
+     * Format: https://{publicKey}@{host}/{projectId}
+     */
+    dsn?: string;
+    /**
+     * Sentry SDK client (for BYOS mode)
+     * Pass your initialized Sentry client for full SDK features
+     */
+    client?: SentryClient;
+    /** Environment name (e.g., 'production', 'staging') */
+    environment?: string;
+    /** Release version */
+    release?: string;
+    /** Server name */
+    serverName?: string;
+    /** Sample rate for error events (0.0 to 1.0) */
+    sampleRate?: number;
+    /** Additional tags to add to all events */
+    tags?: Record<string, string>;
+    /** Callback before sending (return null to drop event) */
+    beforeSend?: (event: SentryEvent) => SentryEvent | null;
+    /** Callback for transport errors */
+    onError?: (error: Error) => void;
+}
+/**
+ * Sentry event structure (simplified)
+ */
+interface SentryEvent {
+    event_id: string;
+    timestamp: string;
+    platform: string;
+    level: "fatal" | "error" | "warning" | "info" | "debug";
+    logger?: string;
+    transaction?: string;
+    server_name?: string;
+    release?: string;
+    environment?: string;
+    message?: {
+        formatted: string;
+    };
+    exception?: {
+        values: Array<{
+            type: string;
+            value: string;
+            stacktrace?: {
+                frames: Array<{
+                    filename?: string;
+                    function?: string;
+                    lineno?: number;
+                    colno?: number;
+                    in_app?: boolean;
+                }>;
+            };
+        }>;
+    };
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+    user?: {
+        id?: string;
+        email?: string;
+        username?: string;
+        [key: string]: unknown;
+    };
+    breadcrumbs?: Array<{
+        type?: string;
+        category?: string;
+        message?: string;
+        data?: Record<string, unknown>;
+        level?: string;
+        timestamp?: number;
+    }>;
+    contexts?: Record<string, Record<string, unknown>>;
+}
+/**
+ * Sentry Transport
+ * Implements both LogTransport and ErrorTransport
+ */
+declare class SentryTransport implements LogTransport, ErrorTransport {
+    readonly name = "sentry";
+    private readonly client?;
+    private readonly dsn?;
+    private readonly options;
+    private user;
+    private contexts;
+    private breadcrumbs;
+    private readonly maxBreadcrumbs;
+    constructor(options: SentryTransportOptions);
+    /**
+     * Parse Sentry DSN
+     */
+    private parseDSN;
+    /**
+     * LogTransport implementation
+     * Only sends ERROR and FATAL level logs
+     */
+    log(entry: LogEntry): void;
+    /**
+     * Capture an exception
+     */
+    captureException(error: Error, context?: ErrorContext): void;
+    /**
+     * Capture a message
+     */
+    captureMessage(message: string, level: "info" | "warning" | "error", context?: ErrorContext): void;
+    /**
+     * Set user context
+     */
+    setUser(user: ErrorUser | null): void;
+    /**
+     * Set custom context
+     */
+    setContext(name: string, context: Record<string, unknown>): void;
+    /**
+     * Add breadcrumb
+     */
+    addBreadcrumb(breadcrumb: Breadcrumb): void;
+    /**
+     * Flush pending events
+     */
+    flush(): Promise<void>;
+    private shouldSample;
+    /**
+     * Capture with SDK (BYOS mode)
+     */
+    private captureWithSdk;
+    /**
+     * Apply context to SDK scope
+     */
+    private applyContext;
+    /**
+     * Capture with HTTP API (default mode)
+     */
+    private captureWithHttp;
+    /**
+     * Build event context for HTTP API
+     */
+    private buildEventContext;
+    /**
+     * Parse error stack trace into Sentry format
+     */
+    private parseStackTrace;
+    /**
+     * Generate event ID
+     */
+    private generateEventId;
+    /**
+     * Send event via HTTP API
+     */
+    private sendHttpEvent;
+}
+/**
+ * Create Sentry transport
+ */
+declare function createSentryTransport(options: SentryTransportOptions): SentryTransport;
+
+/**
+ * @parsrun/core - Logtape Transport
+ * Structured logging transport for Logtape (@logtape/logtape)
+ *
+ * Logtape is a TypeScript-first structured logging library.
+ * This transport bridges Pars Logger to Logtape for advanced logging scenarios.
+ *
+ * @example BYOS (Bring Your Own SDK)
+ * ```typescript
+ * import { getLogger, configure } from '@logtape/logtape';
+ *
+ * // Configure Logtape
+ * await configure({
+ *   sinks: { console: consoleSink() },
+ *   loggers: [{ category: 'pars', sinks: ['console'], level: 'info' }],
+ * });
+ *
+ * const logtapeLogger = getLogger('pars');
+ * const transport = new LogtapeTransport({ logger: logtapeLogger });
+ * ```
+ *
+ * @example Simple mode (creates internal logger)
+ * ```typescript
+ * const transport = new LogtapeTransport({
+ *   category: 'my-app',
+ * });
+ * ```
+ */
+
+/**
+ * Logtape Logger interface (minimal interface for BYOS)
+ * Compatible with @logtape/logtape getLogger() return type
+ */
+interface LogtapeLogger {
+    debug(message: string, properties?: Record<string, unknown>): void;
+    info(message: string, properties?: Record<string, unknown>): void;
+    warn(message: string, properties?: Record<string, unknown>): void;
+    warning(message: string, properties?: Record<string, unknown>): void;
+    error(message: string, properties?: Record<string, unknown>): void;
+    fatal(message: string, properties?: Record<string, unknown>): void;
+}
+/**
+ * Logtape transport options
+ */
+interface LogtapeTransportOptions extends BaseTransportOptions {
+    /**
+     * Logtape logger instance (for BYOS mode)
+     * Get this from @logtape/logtape's getLogger()
+     */
+    logger?: LogtapeLogger;
+    /**
+     * Category name for the logger
+     * Only used if logger is not provided (creates a simple fallback logger)
+     */
+    category?: string;
+    /**
+     * Include timestamp in properties
+     * @default true
+     */
+    includeTimestamp?: boolean;
+    /**
+     * Include level value in properties
+     * @default false
+     */
+    includeLevelValue?: boolean;
+}
+/**
+ * Logtape Transport
+ * Bridges Pars Logger to Logtape
+ */
+declare class LogtapeTransport implements LogTransport {
+    readonly name = "logtape";
+    private readonly logger;
+    private readonly includeTimestamp;
+    private readonly includeLevelValue;
+    private readonly enabled;
+    constructor(options?: LogtapeTransportOptions);
+    log(entry: LogEntry): void;
+    /**
+     * Map Pars log level to Logtape level
+     */
+    private mapLevel;
+    /**
+     * Build properties object for Logtape
+     */
+    private buildProperties;
+}
+/**
+ * Create Logtape transport
+ */
+declare function createLogtapeTransport(options?: LogtapeTransportOptions): LogtapeTransport;
+
+export { AxiomTransport, type AxiomTransportOptions, BaseTransportOptions, BatchTransportOptions, Breadcrumb, ErrorContext, ErrorTransport, ErrorUser, LogTransport, type LogtapeLogger, LogtapeTransport, type LogtapeTransportOptions, type SentryClient, type SentryEvent, type SentryScope, SentryTransport, type SentryTransportOptions, createAxiomTransport, createLogtapeTransport, createSentryTransport };