logsdx/dist/index.js

log streaming with dx on the 🧠

import {
  DEFAULT_JSON_RULES,
  createRegexLineParser,
  defaultLineParser,
  getParser,
  getParserForOptions,
  getRegisteredParsers,
  loadJsonRules,
  program,
  registerParser,
  shouldRender
} from "./chunk-6XPS6F32.js";
import {
  LogEnhancer
} from "./chunk-GEV5T5GP.js";
import {
  logger
} from "./chunk-4MUAUYPX.js";
import {
  asci_exports
} from "./chunk-GXLLPAYQ.js";
import "./chunk-T6FLUOTW.js";
import "./chunk-PZ5AY32C.js";

// src/parsers/regex/rules.ts
var logParserRules = [
  // Language markers
  {
    match: /^\[json\]/i,
    extract: () => ({ lang: "json" })
  },
  {
    match: /^\[sql\]/i,
    extract: () => ({ lang: "sql" })
  },
  {
    match: /^\[lang:(\w+)\]/i,
    extract: (_line, match) => ({ lang: match[1]?.toLowerCase() })
  },
  // Log levels with various formats
  {
    match: /\[(ERROR|ERR|FATAL|CRITICAL)\]/i,
    extract: () => ({ level: "error" })
  },
  {
    match: /\[(WARN|WARNING|ATTENTION)\]/i,
    extract: () => ({ level: "warn" })
  },
  {
    match: /\[(INFO|INFORMATION)\]/i,
    extract: () => ({ level: "info" })
  },
  {
    match: /\[(DEBUG|TRACE|VERBOSE)\]/i,
    extract: () => ({ level: "debug" })
  },
  {
    match: /\[(SUCCESS|SUCCEEDED|COMPLETED)\]/i,
    extract: () => ({ level: "success" })
  },
  // Common log formats
  {
    match: /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)\s+\[(\w+)\]\s+(.*)$/,
    extract: (_line, match) => ({
      timestamp: match[1],
      level: match[2]?.toLowerCase(),
      message: match[3]
    })
  },
  {
    match: /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s+\[(\w+)\]\s+(.*)$/,
    extract: (_line, match) => ({
      timestamp: match[1],
      level: match[2]?.toLowerCase(),
      message: match[3]
    })
  },
  {
    match: /^\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)\]\s+\[(\w+)\]\s+(.*)$/,
    extract: (_line, match) => ({
      timestamp: match[1],
      level: match[2]?.toLowerCase(),
      message: match[3]
    })
  },
  // Simple level detection (fallback)
  {
    match: /\b(ERROR|ERR|FATAL|CRITICAL)\b/i,
    extract: () => ({ level: "error" })
  },
  {
    match: /\b(WARN|WARNING|ATTENTION)\b/i,
    extract: () => ({ level: "warn" })
  },
  {
    match: /\b(INFO|INFORMATION)\b/i,
    extract: () => ({ level: "info" })
  },
  {
    match: /\b(DEBUG|TRACE|VERBOSE)\b/i,
    extract: () => ({ level: "debug" })
  },
  {
    match: /\b(SUCCESS|SUCCEEDED|COMPLETED)\b/i,
    extract: () => ({ level: "success" })
  }
];

// src/parsers/regex/index.ts
var regexBasedParser = createRegexLineParser(logParserRules);

// src/parsers/custom.ts
function createCustomParser(options) {
  if (options.validate && !options.validate()) {
    throw new Error(`Invalid configuration for parser '${options.name}'`);
  }
  const parser = (line) => {
    if (options.canParse && !options.canParse(line)) {
      return void 0;
    }
    return options.parse(line);
  };
  parser.name = options.name;
  parser.description = options.description || `Custom parser: ${options.name}`;
  return parser;
}
function createParserFactory(options) {
  return async () => {
    return createCustomParser(options);
  };
}
function mapLogLevel(level) {
  const levelMap = {
    // Standard levels
    debug: "debug",
    info: "info",
    warn: "warn",
    warning: "warn",
    error: "error",
    err: "error",
    success: "success",
    trace: "trace",
    // Common variations
    fatal: "error",
    critical: "error",
    notice: "info",
    verbose: "debug",
    silly: "debug",
    // Status-based levels
    fail: "error",
    failed: "error",
    failure: "error",
    pending: "warn",
    in_progress: "info",
    completed: "success"
  };
  const normalizedLevel = level.toLowerCase().trim();
  return levelMap[normalizedLevel] || "info";
}
function createCsvLogParser() {
  return createParserFactory({
    name: "csv-logs",
    description: "Parser for CSV-formatted logs",
    canParse: (line) => line.startsWith("CSV_LOG:"),
    parse: (line) => {
      const csvContent = line.substring(8);
      const parts = csvContent.split(",");
      if (parts.length < 3) {
        return void 0;
      }
      const timestamp = parts[0]?.trim() || "";
      const level = mapLogLevel(parts[1]?.trim() || "");
      const message = parts[2]?.trim() || "";
      const result = {
        timestamp,
        level,
        message,
        format: "csv"
      };
      for (let i = 3; i < parts.length; i++) {
        const part = parts[i];
        if (part) {
          const [key, value] = part.split("=");
          if (key && value) {
            result[key.trim()] = value.trim();
          }
        }
      }
      return result;
    }
  });
}
function createAppLogParser() {
  return createParserFactory({
    name: "app-logs",
    description: "Parser for application-specific logs",
    canParse: (line) => line.startsWith("[APP]"),
    parse: (line) => {
      const appLogRegex = /^\[APP\]\s+(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\s+\[(\w+)\]\s+(.*)$/;
      const appLogMatch = line.match(appLogRegex);
      if (appLogMatch && appLogMatch[1] && appLogMatch[2] && appLogMatch[3]) {
        return {
          timestamp: appLogMatch[1],
          level: mapLogLevel(appLogMatch[2]),
          message: appLogMatch[3],
          service: "app"
        };
      }
      const errorRegex = /^\[APP\]\s+ERROR\s+(.*?):\s+(.*)$/;
      const errorMatch = line.match(errorRegex);
      if (errorMatch && errorMatch[1] && errorMatch[2]) {
        return {
          level: "error",
          message: `${errorMatch[1]}: ${errorMatch[2]}`,
          service: "app"
        };
      }
      return void 0;
    }
  });
}
export {
  DEFAULT_JSON_RULES as DEFAULT_JSON_RULES_DEFAULT,
  LogEnhancer,
  asci_exports as asci,
  createAppLogParser,
  createCsvLogParser,
  createCustomParser,
  createParserFactory,
  createRegexLineParser,
  defaultLineParser,
  getParser,
  getParserForOptions,
  getRegisteredParsers,
  loadJsonRules,
  logParserRules,
  logger,
  mapLogLevel,
  program,
  registerParser,
  shouldRender
};
//# sourceMappingURL=index.js.map