@putkoff/abstract-logger 0.0.65 → 0.0.73

package/dist/cjs/index.js

@@ -194,6 +194,17 @@ const IS_BROWSER = typeof window !== "undefined" &&
     typeof window.document !== "undefined";
 const IS_NODE = typeof process !== "undefined" &&
     process.release?.name === "node";
+const INTERNAL_FUNCTIONS = new Set([
+    "logit",
+    "logEvent",
+    "shouldLog",
+    "recordBenchSnapshot",
+]);
+const INTERNAL_FILES = [
+    "abstract-logger",
+    "loggerBench",
+    "blocker",
+];
 /* ------------------------------------------------------------------ */
 /* Stack inspection                                                    */
 /* ------------------------------------------------------------------ */
@@ -212,17 +223,29 @@ function extractFile(frame) {
         return bareMatch[1];
     return "unknown";
 }
-function getCallerInfo(func) {
+function getCallerInfo(skipExternal = 0) {
     if (!IS_NODE) {
         return { functionName: "browser", file: "browser" };
     }
     const obj = {};
-    Error.captureStackTrace(obj, func);
-    const stack = obj.stack?.split("\n") ?? [];
-    const frame = stack
-        .slice(1)
-        .find((line) => !line.includes("node:internal") &&
-        !line.includes("processTicksAndRejections"));
+    Error.captureStackTrace(obj, getCallerInfo);
+    const stack = obj.stack?.split("\n").slice(1) ?? [];
+    const externalFrames = stack.filter((line) => {
+        if (line.includes("node:internal"))
+            return false;
+        if (line.includes("processTicksAndRejections"))
+            return false;
+        for (const fn of INTERNAL_FUNCTIONS) {
+            if (line.includes(` ${fn} `) || line.includes(`.${fn}`))
+                return false;
+        }
+        for (const file of INTERNAL_FILES) {
+            if (line.includes(file))
+                return false;
+        }
+        return true;
+    });
+    const frame = externalFrames[skipExternal];
     if (!frame) {
         return { functionName: "unknown", file: "unknown" };
     }
@@ -235,6 +258,59 @@ function getCallerInfo(func) {
         file: extractFile(frame),
     };
 }
+function getCheapCallerHint$1(opts) {
+    return {
+        functionName: opts.function_name ?? null,
+        file: opts.file_location ?? null,
+    };
+}
+
+exports.LogMode = void 0;
+(function (LogMode) {
+    LogMode["FULL"] = "full";
+    LogMode["CONSOLE"] = "console";
+    LogMode["COUNT"] = "count";
+    LogMode["OFF"] = "off";
+})(exports.LogMode || (exports.LogMode = {}));
+let mode = exports.LogMode.COUNT; // 🔒 DEFAULT FASTEST
+let locked = false;
+const LATENCY_BUCKETS = [1000n, 10000n, 100000n, 1000000n];
+const stats = {
+    calls: 0,
+    totalNs: 0n,
+    byMode: {},
+    byType: {},
+    byFunction: {},
+    latency: {
+        buckets: LATENCY_BUCKETS.map(Number),
+        counts: new Array(LATENCY_BUCKETS.length + 1).fill(0),
+    },
+};
+function inc(map, key) {
+    if (!key)
+        return;
+    map[key] = (map[key] ?? 0) + 1;
+}
+function recordLatency(ns) {
+    let i = 0;
+    while (i < LATENCY_BUCKETS.length && ns > LATENCY_BUCKETS[i])
+        i++;
+    stats.latency.counts[i]++;
+}
+/* ---------------------------------- */
+/* Mode control (LOCKED)               */
+/* ---------------------------------- */
+function setLogMode(next) {
+    if (locked)
+        return;
+    mode = next;
+}
+function lockLogMode() {
+    locked = true;
+}
+function getLogMode() {
+    return mode;
+}
 
 const activityEmojiMap = {
     emitting: "📤",
@@ -14864,14 +14940,6 @@ function formatLogLine({ emoji, timestamp, functionName, message, details, file,
     return line;
 }
 
-var LogMode;
-(function (LogMode) {
-    LogMode["FULL"] = "full";
-    LogMode["CONSOLE"] = "console";
-    LogMode["COUNT"] = "count";
-    LogMode["OFF"] = "off";
-})(LogMode || (LogMode = {}));
-
 const seen = new Map();
 function hash(str) {
     let h = 0;
@@ -14939,6 +15007,13 @@ function shouldLog(opts, caller) {
     return true;
 }
 
+// Object-style call
+function getCheapCallerHint(opts) {
+    return {
+        functionName: opts.function_name ?? null,
+        file: opts.file_location ?? null,
+    };
+}
 function logit(messageOrOptions, logType = null, details = null, function_name = null, file_location = null, consumerLogger = null) {
     /* -------------------------------------------------- */
     /* Normalize inputs                                   */
@@ -14957,7 +15032,18 @@ function logit(messageOrOptions, logType = null, details = null, function_name =
     /* -------------------------------------------------- */
     /* Caller info                                        */
     /* -------------------------------------------------- */
-    const caller = getCallerInfo(logit);
+    if (getLogMode() === exports.LogMode.OFF)
+        return "";
+    // 🔹 Phase 1: cheap decision
+    const cheapCaller = getCheapCallerHint(opts);
+    if (!shouldLog(opts, cheapCaller)) {
+        return "";
+    }
+    // 🔹 Phase 2: expensive caller inspection (ONLY NOW)
+    const caller = getCallerInfo();
+    // 🔹 Phase 3: finalize names
+    resolvedFunctionName = resolveValue(resolvedFunctionName, caller.functionName);
+    resolvedFileLocation = resolveValue(resolvedFileLocation, caller.file);
     /* -------------------------------------------------- */
     /* 🔒 Single source of truth for logType               */
     /* -------------------------------------------------- */
@@ -15007,39 +15093,6 @@ function logit(messageOrOptions, logType = null, details = null, function_name =
     }), finalLogType, resolvedLoggerInput);
 }
 
-let mode = LogMode.COUNT; // 🔒 DEFAULT FASTEST
-const LATENCY_BUCKETS = [1000n, 10000n, 100000n, 1000000n];
-const stats = {
-    calls: 0,
-    totalNs: 0n,
-    byMode: {},
-    byType: {},
-    byFunction: {},
-    latency: {
-        buckets: LATENCY_BUCKETS.map(Number),
-        counts: new Array(LATENCY_BUCKETS.length + 1).fill(0),
-    },
-};
-function inc(map, key) {
-    if (!key)
-        return;
-    map[key] = (map[key] ?? 0) + 1;
-}
-function recordLatency(ns) {
-    let i = 0;
-    while (i < LATENCY_BUCKETS.length && ns > LATENCY_BUCKETS[i])
-        i++;
-    stats.latency.counts[i]++;
-}
-/* ---------------------------------- */
-/* Mode control (LOCKED)               */
-/* ---------------------------------- */
-function setLogMode(next) {
-    mode = next;
-}
-function getLogMode() {
-    return mode;
-}
 /* ---------------------------------- */
 /* Stats                               */
 /* ---------------------------------- */
@@ -15068,21 +15121,22 @@ function resetLogStats() {
 /* ---------------------------------- */
 function logEvent(props) {
     stats.calls++;
+    let mode = getLogMode();
     // 🔥 OFF = absolute fastest
-    if (mode === LogMode.OFF)
+    if (mode === exports.LogMode.OFF)
         return;
     const type = typeof props?.logType === "string" ? props.logType : "info";
     inc(stats.byMode, mode);
     inc(stats.byType, type);
     inc(stats.byFunction, props?.function_name);
     // ⚡ COUNT = no timers, no I/O
-    if (mode === LogMode.COUNT)
+    if (mode === exports.LogMode.COUNT)
         return;
     const start = process.hrtime.bigint();
-    if (mode === LogMode.FULL) {
+    if (mode === exports.LogMode.FULL) {
         logit(props);
     }
-    else if (mode === LogMode.CONSOLE) {
+    else if (mode === exports.LogMode.CONSOLE) {
         console.log(props);
     }
     const elapsed = process.hrtime.bigint() - start;
@@ -15091,25 +15145,25 @@ function logEvent(props) {
 }
 function setLogs(mode = null, interval = false, window_ms = null) {
     const modes = [
-        LogMode.FULL,
-        LogMode.CONSOLE,
-        LogMode.COUNT,
-        LogMode.OFF,
+        exports.LogMode.FULL,
+        exports.LogMode.CONSOLE,
+        exports.LogMode.COUNT,
+        exports.LogMode.OFF,
     ];
     if (window_ms != false) {
         if (window_ms === true || window_ms == null) {
-            window_ms = 30000;
+            window_ms = 30_000;
         }
     }
     if (interval != true) {
-        mode = mode || 3;
+        mode = mode ?? 3;
         setLogMode(modes[mode]);
         resetLogStats();
     }
     else {
         let i = 0;
         setInterval(() => {
-            window_ms || (window_ms = 30000);
+            window_ms ||= 30_000;
             recordBenchSnapshot(window_ms);
             resetLogStats();
             setLogMode(modes[++i % modes.length]);
@@ -15140,6 +15194,7 @@ function recordBenchSnapshot(windowMs) {
 exports.COLS = COLS;
 exports.IS_BROWSER = IS_BROWSER;
 exports.IS_NODE = IS_NODE;
+exports.LATENCY_BUCKETS = LATENCY_BUCKETS;
 exports.activityEmojiMap = activityEmojiMap;
 exports.createLogger = winston.createLogger;
 exports.debugLogConfig = debugLogConfig;
@@ -15147,19 +15202,26 @@ exports.extractFile = extractFile;
 exports.format = winston.format;
 exports.formatLogLine = formatLogLine;
 exports.getCallerInfo = getCallerInfo;
+exports.getCheapCallerHint = getCheapCallerHint$1;
 exports.getFinalLine = getFinalLine;
 exports.getLogConfig = getLogConfig;
+exports.getLogMode = getLogMode;
 exports.getLogString = logEvent;
 exports.getNodeLogger = getNodeLogger;
+exports.inc = inc;
+exports.lockLogMode = lockLogMode;
 exports.logger = logger;
 exports.padLeft = padLeft;
 exports.padRight = padRight;
 exports.parseList = parseList;
+exports.recordLatency = recordLatency;
 exports.resolveLogger = resolveLogger;
 exports.resolveValue = resolveValue;
 exports.serializeDetails = serializeDetails;
+exports.setLogMode = setLogMode;
 exports.setLogs = setLogs;
 exports.shouldCondense = shouldCondense;
 exports.shouldShowDetails = shouldShowDetails;
+exports.stats = stats;
 exports.transports = winston.transports;
 //# sourceMappingURL=index.js.map