devlogs-node 2.2.7

package/dist/devlogs.esm.js

@@ -0,0 +1,752 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import http from 'node:http';
+import https from 'node:https';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+/**
+ * Parse a devlogs URL and auto-detect mode.
+ *
+ * Detection logic:
+ * - user:pass@ in URL → OpenSearch direct mode
+ * - token@ (no password) or ?token= → Collector mode
+ * - No credentials → Collector mode
+ *
+ * Supports schemes: http://, https://, opensearch://, opensearchs://
+ */
+function parseDevlogsUrl(url, index) {
+    // Normalize opensearch(s):// to http(s)://
+    let normalizedUrl = url;
+    let forceOpenSearch = false;
+    if (url.startsWith('opensearchs://')) {
+        normalizedUrl = 'https://' + url.slice('opensearchs://'.length);
+        forceOpenSearch = true;
+    }
+    else if (url.startsWith('opensearch://')) {
+        normalizedUrl = 'http://' + url.slice('opensearch://'.length);
+        forceOpenSearch = true;
+    }
+    const parsed = new URL(normalizedUrl);
+    const scheme = parsed.protocol.replace(':', '');
+    const host = parsed.hostname || 'localhost';
+    const port = parsed.port
+        ? parseInt(parsed.port, 10)
+        : scheme === 'https'
+            ? 443
+            : 9200;
+    // Extract index from path if present (e.g., /devlogs-myapp)
+    const pathIndex = parsed.pathname && parsed.pathname !== '/'
+        ? parsed.pathname.slice(1).split('/')[0]
+        : undefined;
+    const resolvedIndex = index || pathIndex || 'devlogs-0001';
+    // Determine mode:
+    // 1. opensearch(s):// scheme → always OpenSearch
+    // 2. Both user AND password → OpenSearch
+    // 3. User only (no password) → Collector with token
+    // 4. No credentials → Collector
+    if (forceOpenSearch || (parsed.username && parsed.password)) {
+        return {
+            mode: 'opensearch',
+            scheme,
+            host,
+            port,
+            user: decodeURIComponent(parsed.username || 'admin'),
+            password: decodeURIComponent(parsed.password || 'admin'),
+            index: resolvedIndex,
+        };
+    }
+    // Collector mode: username-only is a token
+    const token = parsed.username ? decodeURIComponent(parsed.username) : null;
+    return {
+        mode: 'collector',
+        scheme,
+        host,
+        port,
+        token,
+        index: resolvedIndex,
+    };
+}
+
+let envLoaded = false;
+/**
+ * Minimal .env file parser. No external dependencies.
+ * Handles KEY=VALUE, KEY="VALUE", KEY='VALUE', and # comments.
+ */
+function parseDotenv(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Search upward from cwd for a file by name.
+ */
+function findFileUpward(filename, startDir) {
+    let dir = process.cwd();
+    const root = resolve('/');
+    while (true) {
+        const candidate = resolve(dir, filename);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = dirname(dir);
+        if (parent === dir || dir === root) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+/**
+ * Load environment variables from .env.devlogs (preferred) or .env file.
+ * Only sets variables that are not already defined in process.env.
+ * Called once automatically on first config load.
+ */
+function loadDotenv() {
+    if (envLoaded)
+        return;
+    envLoaded = true;
+    const dotenvPath = process.env.DOTENV_PATH;
+    let filePath = null;
+    if (dotenvPath) {
+        filePath = dotenvPath;
+    }
+    else {
+        // Prefer .env.devlogs over .env
+        filePath = findFileUpward('.env.devlogs');
+        if (!filePath) {
+            filePath = findFileUpward('.env');
+        }
+    }
+    if (!filePath || !existsSync(filePath))
+        return;
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const vars = parseDotenv(content);
+        for (const [key, value] of Object.entries(vars)) {
+            // Don't override existing env vars
+            if (process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+    }
+    catch {
+        // Silently ignore read errors
+    }
+}
+/**
+ * Load configuration from DEVLOGS_* environment variables.
+ * Automatically loads .env.devlogs on first call.
+ */
+function loadEnvConfig() {
+    loadDotenv();
+    return {
+        url: process.env.DEVLOGS_URL || undefined,
+        index: process.env.DEVLOGS_INDEX || undefined,
+        application: process.env.DEVLOGS_APPLICATION || undefined,
+        component: process.env.DEVLOGS_COMPONENT || undefined,
+        area: process.env.DEVLOGS_AREA || undefined,
+        environment: process.env.DEVLOGS_ENVIRONMENT || undefined,
+        version: process.env.DEVLOGS_VERSION || undefined,
+    };
+}
+
+/**
+ * Time-based circuit breaker with auto-recovery.
+ *
+ * Port of the Go SDK circuit breaker pattern:
+ * - Opens on failure, pauses indexing for `duration` (default 60s)
+ * - Auto-resets after duration expires (time-based)
+ * - Closes immediately on explicit success (RecordSuccess)
+ * - Throttles error output to once per `errorInterval` (default 10s)
+ */
+class CircuitBreaker {
+    /**
+     * @param duration - How long to keep circuit open in ms (default: 60000)
+     * @param errorInterval - Min interval between error prints in ms (default: 10000)
+     * @param stderr - Output function for error messages (default: process.stderr.write)
+     */
+    constructor(duration = 60000, errorInterval = 10000, stderr) {
+        this.isOpen = false;
+        this.openUntil = 0;
+        this.lastErrorPrinted = 0;
+        this.duration = duration;
+        this.errorInterval = errorInterval;
+        this.stderr = stderr ?? ((msg) => process.stderr.write(msg + '\n'));
+    }
+    /**
+     * Check if the circuit breaker is open (should skip indexing).
+     * Auto-resets if duration has expired.
+     */
+    shouldSkip() {
+        if (!this.isOpen)
+            return false;
+        if (Date.now() >= this.openUntil) {
+            this.isOpen = false;
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Record a failure - opens the circuit breaker.
+     */
+    recordFailure(err) {
+        const now = Date.now();
+        this.isOpen = true;
+        this.openUntil = now + this.duration;
+        // Throttle error printing
+        if (now - this.lastErrorPrinted > this.errorInterval) {
+            this.lastErrorPrinted = now;
+            const secs = Math.round(this.duration / 1000);
+            this.stderr(`[devlogs] Failed to index log, pausing indexing for ${secs}s: ${err}`);
+        }
+    }
+    /**
+     * Record a success - closes the circuit breaker.
+     */
+    recordSuccess() {
+        if (this.isOpen) {
+            this.isOpen = false;
+            this.stderr('[devlogs] Connection restored, resuming indexing');
+        }
+    }
+}
+
+/**
+ * Dual-mode HTTP client for sending log documents.
+ *
+ * - OpenSearch mode: POST to /{index}/_doc with Basic auth
+ * - Collector mode: POST to / with optional Bearer token
+ * - Fire-and-forget: does not await response
+ * - Circuit breaker: stops sending on failures, auto-recovers
+ */
+class DevlogsClient {
+    constructor(config, cb) {
+        this.config = config;
+        this.cb = cb ?? new CircuitBreaker();
+    }
+    /**
+     * Send a log document. Fire-and-forget - does not block.
+     */
+    send(doc) {
+        if (this.cb.shouldSkip())
+            return;
+        const body = JSON.stringify(doc);
+        const transport = this.config.scheme === 'https' ? https : http;
+        const headers = {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(body).toString(),
+        };
+        let path;
+        if (this.config.mode === 'opensearch') {
+            path = `/${this.config.index}/_doc`;
+            const credentials = `${this.config.user}:${this.config.password}`;
+            headers['Authorization'] = `Basic ${Buffer.from(credentials).toString('base64')}`;
+        }
+        else {
+            path = '/';
+            if (this.config.token) {
+                headers['Authorization'] = `Bearer ${this.config.token}`;
+            }
+        }
+        const req = transport.request({
+            hostname: this.config.host,
+            port: this.config.port,
+            path,
+            method: 'POST',
+            headers,
+        }, (res) => {
+            // Consume response to free socket
+            res.resume();
+            const status = res.statusCode ?? 0;
+            if (status >= 200 && status < 300) {
+                this.cb.recordSuccess();
+            }
+            else {
+                this.cb.recordFailure(new Error(`HTTP ${status} from ${this.config.mode}`));
+            }
+        });
+        req.on('error', (err) => {
+            this.cb.recordFailure(err);
+        });
+        req.end(body);
+    }
+}
+
+/**
+ * AsyncLocalStorage instance for per-request context isolation.
+ * Each async context (e.g., HTTP request handler) gets its own LogContext.
+ */
+const storage = new AsyncLocalStorage();
+/**
+ * Default context used when no async context is active.
+ */
+let defaultContext = {
+    application: 'unknown',
+    component: 'node',
+    area: null,
+    operationId: null,
+    environment: null,
+    version: null,
+    fields: {},
+};
+/**
+ * Set the default context values (called during init).
+ */
+function setDefaultContext(ctx) {
+    defaultContext = { ...defaultContext, ...ctx };
+}
+/**
+ * Get the current logging context.
+ * Returns the AsyncLocalStorage context if inside withContext/withOperation,
+ * otherwise returns the default (module-level) context.
+ */
+function getContext() {
+    return storage.getStore() ?? { ...defaultContext };
+}
+/**
+ * Set the application area in the current context.
+ */
+function setArea(area) {
+    const store = storage.getStore();
+    if (store) {
+        store.area = area;
+    }
+    else {
+        defaultContext.area = area;
+    }
+}
+/**
+ * Set the operation ID in the current context.
+ */
+function setOperationId(operationId) {
+    const store = storage.getStore();
+    if (store) {
+        store.operationId = operationId;
+    }
+    else {
+        defaultContext.operationId = operationId;
+    }
+}
+/**
+ * Set custom fields in the current context.
+ */
+function setFields(fields) {
+    const store = storage.getStore();
+    if (store) {
+        store.fields = { ...store.fields, ...fields };
+    }
+    else {
+        defaultContext.fields = { ...defaultContext.fields, ...fields };
+    }
+}
+/**
+ * Run a function with a temporary operation ID in an isolated async context.
+ * The operation ID is automatically scoped to the callback and its async children.
+ */
+function withOperation(operationId, fn) {
+    const parent = getContext();
+    const childCtx = {
+        ...parent,
+        operationId,
+        fields: { ...parent.fields },
+    };
+    return storage.run(childCtx, fn);
+}
+/**
+ * Run a function with a fully isolated async context.
+ * Changes made inside the callback don't affect the parent context.
+ */
+function withContext(overrides, fn) {
+    const parent = getContext();
+    const childCtx = {
+        ...parent,
+        ...overrides,
+        fields: { ...parent.fields, ...overrides.fields },
+    };
+    return storage.run(childCtx, fn);
+}
+/**
+ * Reset the default context (for testing/destroy).
+ */
+function resetContext() {
+    defaultContext = {
+        application: 'unknown',
+        component: 'node',
+        area: null,
+        operationId: null,
+        environment: null,
+        version: null,
+        fields: {},
+    };
+}
+
+/**
+ * Normalize console method name to standard log level.
+ */
+function normalizeLevel(method) {
+    if (method === 'warn')
+        return 'warning';
+    if (method === 'log')
+        return 'info';
+    return method;
+}
+/**
+ * Format console arguments into a single message string.
+ */
+function formatMessage(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === 'string')
+            return arg;
+        if (arg instanceof Error)
+            return `${arg.name}: ${arg.message}`;
+        try {
+            return JSON.stringify(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(' ');
+}
+/**
+ * Extract source location from an Error stack trace.
+ * Walks the stack to find the first frame outside of devlogs internals.
+ */
+function extractSourceLocation() {
+    const base = {
+        logger: 'node',
+        pathname: null,
+        lineno: null,
+        funcName: null,
+    };
+    const err = new Error();
+    const stack = err.stack;
+    if (!stack)
+        return base;
+    const lines = stack.split('\n');
+    // Skip frames inside devlogs (interceptor, formatter, index)
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Skip internal devlogs package frames
+        if (line.includes('devlogs.cjs') ||
+            line.includes('devlogs.esm') ||
+            line.includes('node_modules/devlogs-node') ||
+            line.includes('/node/dist/') ||
+            line.includes('/node/src/interceptor.') ||
+            line.includes('/node/src/formatter.') ||
+            line.includes('/node/src/index.')) {
+            continue;
+        }
+        // Parse V8 stack frame: "at funcName (file:line:col)" or "at file:line:col"
+        const withFunc = line.match(/at\s+(.+?)\s+\((.+?):(\d+):\d+\)/);
+        if (withFunc) {
+            return {
+                logger: 'node',
+                pathname: withFunc[2],
+                lineno: parseInt(withFunc[3], 10),
+                funcName: withFunc[1],
+            };
+        }
+        const noFunc = line.match(/at\s+(.+?):(\d+):\d+/);
+        if (noFunc) {
+            return {
+                logger: 'node',
+                pathname: noFunc[1],
+                lineno: parseInt(noFunc[2], 10),
+                funcName: null,
+            };
+        }
+    }
+    return base;
+}
+/**
+ * Extract fields from console arguments if an object is provided.
+ */
+function extractFields(args, contextFields) {
+    const fields = { ...contextFields };
+    // If last argument is a plain object, merge it as fields
+    const lastArg = args[args.length - 1];
+    if (lastArg &&
+        typeof lastArg === 'object' &&
+        !Array.isArray(lastArg) &&
+        !(lastArg instanceof Error)) {
+        Object.assign(fields, lastArg);
+    }
+    return fields;
+}
+/**
+ * Format a log entry into the devlogs v2.0 document schema.
+ */
+function formatLogDocument(method, args, context, source) {
+    const fields = extractFields(args, context.fields);
+    const resolvedSource = source ?? extractSourceLocation();
+    const doc = {
+        doc_type: 'log_entry',
+        application: context.application,
+        component: context.component,
+        timestamp: new Date().toISOString(),
+        message: formatMessage(args),
+        level: normalizeLevel(method),
+        area: context.area,
+        operation_id: context.operationId,
+        source: resolvedSource,
+        process: {
+            id: process.pid,
+            thread: null,
+        },
+    };
+    if (context.environment) {
+        doc.environment = context.environment;
+    }
+    if (context.version) {
+        doc.version = context.version;
+    }
+    if (Object.keys(fields).length > 0) {
+        doc.fields = fields;
+    }
+    return doc;
+}
+
+/**
+ * Store original console methods before interception.
+ * Used for:
+ * 1. Calling the original console so terminal output still works
+ * 2. Avoiding infinite loops from internal logging
+ */
+const originalConsole = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    debug: console.debug.bind(console),
+    info: console.info.bind(console),
+};
+const METHODS = ['log', 'warn', 'error', 'debug', 'info'];
+/**
+ * Intercept console methods to forward logs to OpenSearch/collector.
+ * Original console methods are still called so terminal output works normally.
+ * Reads context from AsyncLocalStorage on each call for per-request isolation.
+ */
+function interceptConsole(client) {
+    METHODS.forEach((method) => {
+        console[method] = (...args) => {
+            // Capture source location before calling original (preserves stack)
+            const source = extractSourceLocation();
+            // Always call the original console method
+            originalConsole[method](...args);
+            // Read context from AsyncLocalStorage (per-request)
+            const context = getContext();
+            // Format and send
+            const doc = formatLogDocument(method, args, context, source);
+            client.send(doc);
+        };
+    });
+}
+/**
+ * Restore original console methods.
+ */
+function restoreConsole() {
+    METHODS.forEach((method) => {
+        console[method] = originalConsole[method];
+    });
+}
+
+/**
+ * Build info helper for devlogs node client.
+ *
+ * Provides a stable build identifier that applications can use to tag
+ * every log entry without requiring git at runtime.
+ */
+/**
+ * Format a Date as compact ISO-like UTC timestamp: YYYYMMDDTHHMMSSZ.
+ */
+function formatTimestamp(date) {
+    const pad = (n) => n.toString().padStart(2, '0');
+    return (date.getUTCFullYear().toString() +
+        pad(date.getUTCMonth() + 1) +
+        pad(date.getUTCDate()) +
+        'T' +
+        pad(date.getUTCHours()) +
+        pad(date.getUTCMinutes()) +
+        pad(date.getUTCSeconds()) +
+        'Z');
+}
+/**
+ * Get environment variable value.
+ */
+function getEnv(name, env) {
+    if (env)
+        return env[name];
+    return process.env[name];
+}
+/**
+ * Resolve build information from data, environment, or generate it.
+ *
+ * Priority order:
+ * 1. Environment variable BUILD_ID (highest precedence)
+ * 2. Provided build info data (from file)
+ * 3. Environment variables for branch/timestamp
+ * 4. Generated values
+ */
+function resolveBuildInfo(options = {}) {
+    const envPrefix = options.envPrefix ?? 'DEVLOGS_';
+    const nowFn = options.nowFn ?? (() => new Date());
+    const env = options.env;
+    const data = options.data;
+    const envBuildId = `${envPrefix}BUILD_ID`;
+    const envBranch = `${envPrefix}BRANCH`;
+    const envTimestamp = `${envPrefix}BUILD_TIMESTAMP_UTC`;
+    // Check for direct BUILD_ID env override (highest precedence)
+    const directBuildId = getEnv(envBuildId, env);
+    if (directBuildId) {
+        const branch = getEnv(envBranch, env) ?? null;
+        const timestamp = getEnv(envTimestamp, env) ?? formatTimestamp(nowFn());
+        return {
+            buildId: directBuildId,
+            branch,
+            timestampUtc: timestamp,
+            source: 'env',
+            path: null,
+        };
+    }
+    // Check provided data (from file loaded at build time)
+    if (data && typeof data === 'object' && data.build_id) {
+        const branch = getEnv(envBranch, env) ?? data.branch ?? null;
+        const timestamp = getEnv(envTimestamp, env) ?? data.timestamp_utc ?? formatTimestamp(nowFn());
+        return {
+            buildId: data.build_id,
+            branch,
+            timestampUtc: timestamp,
+            source: 'file',
+            path: null,
+        };
+    }
+    // Check if env provides branch and/or timestamp
+    const envBranchValue = getEnv(envBranch, env);
+    const envTimestampValue = getEnv(envTimestamp, env);
+    const branch = envBranchValue ?? null;
+    const timestamp = envTimestampValue ?? formatTimestamp(nowFn());
+    const branchForId = branch ?? 'unknown';
+    const buildId = `${branchForId}-${timestamp}`;
+    const source = envBranchValue || envTimestampValue ? 'env' : 'generated';
+    return {
+        buildId,
+        branch,
+        timestampUtc: timestamp,
+        source,
+        path: null,
+    };
+}
+/**
+ * Convenience function that returns only the build_id string.
+ */
+function resolveBuildId(options = {}) {
+    return resolveBuildInfo(options).buildId;
+}
+/**
+ * Create build info data object for writing to .build.json during build.
+ */
+function createBuildInfoData(options = {}) {
+    const nowFn = options.nowFn ?? (() => new Date());
+    const branch = options.branch ?? null;
+    const timestamp = formatTimestamp(nowFn());
+    const branchForId = branch ?? 'unknown';
+    const buildId = `${branchForId}-${timestamp}`;
+    return {
+        build_id: buildId,
+        branch: branch ?? undefined,
+        timestamp_utc: timestamp,
+    };
+}
+
+let initialized = false;
+let client = null;
+/**
+ * Initialize the devlogs node client.
+ *
+ * Auto-loads configuration from DEVLOGS_* environment variables and .env.devlogs
+ * files if options are not explicitly provided.
+ *
+ * @example
+ * ```js
+ * // Auto-load from environment
+ * devlogs.init();
+ *
+ * // Or provide explicit options
+ * devlogs.init({
+ *   url: 'http://admin:admin@localhost:9200',
+ *   application: 'my-api',
+ *   component: 'server',
+ * });
+ * ```
+ */
+function init(options) {
+    if (initialized) {
+        originalConsole.warn('[devlogs] Already initialized');
+        return;
+    }
+    // Merge explicit options with env config
+    const envConfig = loadEnvConfig();
+    const url = options?.url ?? envConfig.url;
+    const application = options?.application ?? envConfig.application;
+    const component = options?.component ?? envConfig.component;
+    if (!url) {
+        originalConsole.warn('[devlogs] No URL configured. Set DEVLOGS_URL or pass url option.');
+        return;
+    }
+    if (!application) {
+        originalConsole.warn('[devlogs] No application configured. Set DEVLOGS_APPLICATION or pass application option.');
+        return;
+    }
+    if (!component) {
+        originalConsole.warn('[devlogs] No component configured. Set DEVLOGS_COMPONENT or pass component option.');
+        return;
+    }
+    const config = parseDevlogsUrl(url, options?.index ?? envConfig.index);
+    client = new DevlogsClient(config);
+    setDefaultContext({
+        application,
+        component,
+        area: options?.area ?? envConfig.area ?? null,
+        operationId: options?.operationId ?? null,
+        environment: options?.environment ?? envConfig.environment ?? null,
+        version: options?.version ?? envConfig.version ?? null,
+        fields: {},
+    });
+    interceptConsole(client);
+    initialized = true;
+}
+/**
+ * Disable devlogs and restore original console methods.
+ */
+function destroy() {
+    if (!initialized)
+        return;
+    restoreConsole();
+    resetContext();
+    client = null;
+    initialized = false;
+}
+/**
+ * Check if devlogs is currently initialized.
+ */
+function isInitialized() {
+    return initialized;
+}
+
+export { createBuildInfoData, destroy, formatTimestamp, init, isInitialized, resolveBuildId, resolveBuildInfo, setArea, setFields, setOperationId, withContext, withOperation };
+//# sourceMappingURL=devlogs.esm.js.map