weavebot-core
Version:
Generic content processing framework for web scraping and AI extraction
232 lines • 6.44 kB
JavaScript
// src/utils/index.ts
var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
return LogLevel2;
})(LogLevel || {});
var Logger = class {
logLevel;
constructor(level = "info") {
this.logLevel = this.parseLogLevel(level);
if (process.env.NODE_ENV === "production") {
this.setupProductionLogging();
}
}
parseLogLevel(level) {
switch (level.toLowerCase()) {
case "debug":
return 0 /* DEBUG */;
case "info":
return 1 /* INFO */;
case "warn":
return 2 /* WARN */;
case "error":
return 3 /* ERROR */;
default:
return 1 /* INFO */;
}
}
setupProductionLogging() {
const originalLog = console.log;
const originalWarn = console.warn;
const originalError = console.error;
console.log = (...args) => {
if (typeof args[0] === "object" && args[0].level !== void 0) {
originalLog(JSON.stringify(args[0]));
} else {
originalLog(...args);
}
};
console.warn = (...args) => {
if (typeof args[0] === "object" && args[0].level !== void 0) {
originalWarn(JSON.stringify(args[0]));
} else {
originalWarn(...args);
}
};
console.error = (...args) => {
if (typeof args[0] === "object" && args[0].level !== void 0) {
originalError(JSON.stringify(args[0]));
} else {
originalError(...args);
}
};
}
shouldLog(level) {
return level >= this.logLevel;
}
createLogEntry(level, message, context, error) {
return {
timestamp: (/* @__PURE__ */ new Date()).toISOString(),
level,
message,
context: context ? this.sanitizeContext(context) : void 0,
error: error ? {
name: error.name,
message: error.message,
stack: error.stack
} : void 0
};
}
sanitizeContext(context) {
const sanitized = { ...context };
const sensitiveKeys = ["password", "token", "key", "secret", "apikey"];
Object.keys(sanitized).forEach((key) => {
if (sensitiveKeys.some((sensitive) => key.toLowerCase().includes(sensitive))) {
sanitized[key] = "[REDACTED]";
}
});
return sanitized;
}
formatLogEntry(entry) {
const levelNames = {
[0 /* DEBUG */]: "DEBUG",
[1 /* INFO */]: "INFO",
[2 /* WARN */]: "WARN",
[3 /* ERROR */]: "ERROR"
};
let formatted = `[${entry.timestamp}] ${levelNames[entry.level]}: ${entry.message}`;
if (entry.context && Object.keys(entry.context).length > 0) {
formatted += ` | Context: ${JSON.stringify(entry.context)}`;
}
if (entry.error) {
formatted += ` | Error: ${entry.error.message}`;
if (entry.error.stack && this.logLevel === 0 /* DEBUG */) {
formatted += `
Stack: ${entry.error.stack}`;
}
}
return formatted;
}
output(entry) {
if (process.env.NODE_ENV === "production") {
const structuredLog = {
timestamp: entry.timestamp,
level: entry.level,
message: entry.message,
...entry.context,
error: entry.error
};
switch (entry.level) {
case 3 /* ERROR */:
console.error(structuredLog);
break;
case 2 /* WARN */:
console.warn(structuredLog);
break;
default:
console.log(structuredLog);
}
} else {
const formatted = this.formatLogEntry(entry);
switch (entry.level) {
case 3 /* ERROR */:
console.error(`\x1B[31m${formatted}\x1B[0m`);
break;
case 2 /* WARN */:
console.warn(`\x1B[33m${formatted}\x1B[0m`);
break;
case 1 /* INFO */:
console.log(`\x1B[36m${formatted}\x1B[0m`);
break;
case 0 /* DEBUG */:
console.log(`\x1B[90m${formatted}\x1B[0m`);
break;
}
}
}
debug(message, context) {
if (this.shouldLog(0 /* DEBUG */)) {
const entry = this.createLogEntry(0 /* DEBUG */, message, context);
this.output(entry);
}
}
info(message, context) {
if (this.shouldLog(1 /* INFO */)) {
const entry = this.createLogEntry(1 /* INFO */, message, context);
this.output(entry);
}
}
warn(message, context) {
if (this.shouldLog(2 /* WARN */)) {
const entry = this.createLogEntry(2 /* WARN */, message, context);
this.output(entry);
}
}
error(message, contextOrError, error) {
if (this.shouldLog(3 /* ERROR */)) {
let context;
let actualError;
if (contextOrError instanceof Error) {
actualError = contextOrError;
} else {
context = contextOrError;
actualError = error;
}
const entry = this.createLogEntry(3 /* ERROR */, message, context, actualError);
this.output(entry);
}
}
// Performance logging utility
time(label, context) {
const startTime = Date.now();
this.debug(`Timer started: ${label}`, context);
return () => {
const duration = Date.now() - startTime;
this.info(`Timer ended: ${label}`, { ...context, duration });
};
}
};
var createLogger = (level) => {
return new Logger(level || process.env.LOG_LEVEL || "info");
};
var defaultLogger = createLogger();
var isValidUrl = (string) => {
try {
new URL(string);
return true;
} catch (_) {
return false;
}
};
var sanitizeInput = (input) => {
return input.replace(/[<>]/g, "").replace(/javascript:/gi, "").trim();
};
var sleep = (ms) => {
return new Promise((resolve) => setTimeout(resolve, ms));
};
var retry = async (fn, retries = 3, delay = 1e3) => {
try {
return await fn();
} catch (error) {
if (retries > 0) {
await sleep(delay);
return retry(fn, retries - 1, delay * 2);
}
throw error;
}
};
var formatDuration = (ms) => {
if (ms < 1e3) return `${ms}ms`;
if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
return `${(ms / 6e4).toFixed(1)}m`;
};
var truncateText = (text, maxLength = 100) => {
if (text.length <= maxLength) return text;
return text.substring(0, maxLength - 3) + "...";
};
export {
LogLevel,
Logger,
createLogger,
defaultLogger,
formatDuration,
isValidUrl,
retry,
sanitizeInput,
sleep,
truncateText
};
//# sourceMappingURL=utils.mjs.map