@oxog/log 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/logger.ts
 import { createKernel } from "@oxog/plugin";
 import { createEmitter } from "@oxog/emitter";
@@ -163,7 +170,7 @@ function getCwd() {
 
 // src/utils/format.ts
 function formatJson(entry) {
-  return JSON.stringify(entry, jsonReplacer);
+  return safeStringify(entry);
 }
 function jsonReplacer(_key, value) {
   if (typeof value === "bigint") {
@@ -327,27 +334,45 @@ function consoleTransport(options = {}) {
   } = options;
   const mergedColors = { ...DEFAULT_LEVEL_COLORS, ...levelColors };
   let pigment2;
+  function formatEntry(entry) {
+    if (colors && pigment2) {
+      return formatPretty(entry, pigment2, { timestamp, source: true });
+    } else if (colors) {
+      return formatWithAnsi(entry, mergedColors, timestamp);
+    } else {
+      return formatJson(entry);
+    }
+  }
   return {
     name: "console",
     write(entry) {
-      let output;
       if (isBrowser()) {
         writeToBrowserConsole(entry, colors);
         return;
       }
-      if (colors && pigment2) {
-        output = formatPretty(entry, pigment2, { timestamp, source: true });
-      } else if (colors) {
-        output = formatWithAnsi(entry, mergedColors, timestamp);
-      } else {
-        output = formatJson(entry);
-      }
+      const output = formatEntry(entry);
       if (entry.level >= 50) {
         process.stderr.write(output + "\n");
       } else {
         process.stdout.write(output + "\n");
       }
     },
+    writeSync(entry) {
+      if (isBrowser()) {
+        writeToBrowserConsole(entry, colors);
+        return;
+      }
+      const output = formatEntry(entry) + "\n";
+      const fd = entry.level >= 50 ? 2 : 1;
+      try {
+        if (entry.level >= 50) {
+          process.stderr.write(output);
+        } else {
+          process.stdout.write(output);
+        }
+      } catch {
+      }
+    },
     flush() {
     },
     close() {
@@ -670,6 +695,31 @@ function createLogger(options = {}) {
     kernel.use(plugin);
   }
   let closed = false;
+  function emitTransportError(transportName, error, entry) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    emitter.emit("error", { transport: transportName, error: err, entry });
+    if (isNode()) {
+      process.stderr.write(`[LOG TRANSPORT ERROR] ${transportName}: ${err.message}
+`);
+    }
+  }
+  function writeToTransportsSync(entry) {
+    if (closed) return;
+    for (const transport of activeTransports) {
+      try {
+        if (transport.writeSync) {
+          transport.writeSync(entry);
+        } else {
+          const result = transport.write(entry);
+          if (result instanceof Promise) {
+            result.catch((err) => emitTransportError(transport.name, err, entry));
+          }
+        }
+      } catch (err) {
+        emitTransportError(transport.name, err, entry);
+      }
+    }
+  }
   async function writeToTransports(entry) {
     if (closed) return;
     const promises = [];
@@ -677,14 +727,18 @@ function createLogger(options = {}) {
       try {
         const result = transport.write(entry);
         if (result instanceof Promise) {
-          promises.push(result);
+          promises.push(
+            result.catch((err) => {
+              emitTransportError(transport.name, err, entry);
+            })
+          );
         }
       } catch (err) {
+        emitTransportError(transport.name, err, entry);
       }
     }
     if (promises.length > 0) {
-      await Promise.all(promises).catch(() => {
-      });
+      await Promise.all(promises);
     }
   }
   function createEntry(levelNum, levelName, msg, data, error) {
@@ -735,10 +789,10 @@ function createLogger(options = {}) {
     emitter.emit("log", entry);
     emitter.emit(`log:${levelName}`, entry);
     if (shouldSync(levelName)) {
-      writeToTransports(entry).catch(() => {
-      });
+      writeToTransportsSync(entry);
     } else {
-      writeToTransports(entry).catch(() => {
+      writeToTransports(entry).catch((err) => {
+        emitTransportError("logger", err, entry);
       });
     }
   }
@@ -859,9 +913,10 @@ function createLogger(options = {}) {
           try {
             const result = transport.flush();
             if (result instanceof Promise) {
-              promises.push(result);
+              promises.push(result.catch((err) => emitTransportError(transport.name, err)));
             }
-          } catch {
+          } catch (err) {
+            emitTransportError(transport.name, err);
           }
         }
       }
@@ -871,6 +926,31 @@ function createLogger(options = {}) {
     async close() {
       if (closed) return;
       closed = true;
+      const ctx = kernel.getContext();
+      if (ctx.flushTimerId) {
+        clearInterval(ctx.flushTimerId);
+        ctx.flushTimerId = void 0;
+      }
+      if (ctx.buffer && ctx.buffer.length > 0) {
+        const bufferedEntries = ctx.buffer;
+        ctx.buffer = [];
+        for (const entry of bufferedEntries) {
+          for (const transport of activeTransports) {
+            try {
+              if (transport.writeSync) {
+                transport.writeSync(entry);
+              } else {
+                const result = transport.write(entry);
+                if (result instanceof Promise) {
+                  await result.catch((err) => emitTransportError(transport.name, err, entry));
+                }
+              }
+            } catch (err) {
+              emitTransportError(transport.name, err, entry);
+            }
+          }
+        }
+      }
       await logger.flush();
       const promises = [];
       for (const transport of activeTransports) {
@@ -878,9 +958,10 @@ function createLogger(options = {}) {
           try {
             const result = transport.close();
             if (result instanceof Promise) {
-              promises.push(result);
+              promises.push(result.catch((err) => emitTransportError(transport.name, err)));
             }
-          } catch {
+          } catch (err) {
+            emitTransportError(transport.name, err);
           }
         }
       }
@@ -1036,6 +1117,36 @@ function fileTransport(options) {
         });
       });
     },
+    writeSync(entry) {
+      if (!fs) {
+        try {
+          const fsSync = __require("fs");
+          const pathSync = __require("path");
+          const dir = pathSync.dirname(filePath);
+          if (!fsSync.existsSync(dir)) {
+            fsSync.mkdirSync(dir, { recursive: true });
+          }
+          const line = formatJson(entry) + "\n";
+          fsSync.appendFileSync(filePath, line, "utf8");
+          currentSize += Buffer.byteLength(line, "utf8");
+        } catch {
+          process.stderr.write(formatJson(entry) + "\n");
+        }
+        return;
+      }
+      try {
+        const line = formatJson(entry) + "\n";
+        fs.appendFileSync(filePath, line, "utf8");
+        currentSize += Buffer.byteLength(line, "utf8");
+      } catch (err) {
+        process.stderr.write(formatJson(entry) + "\n");
+        throw new TransportError(
+          `Failed to write sync to file: ${err instanceof Error ? err.message : String(err)}`,
+          "file",
+          err instanceof Error ? err : void 0
+        );
+      }
+    },
     async flush() {
       if (writeStream && "flush" in writeStream) {
         return new Promise((resolve) => {
@@ -1685,7 +1796,9 @@ async function flushBuffer(ctx) {
   await Promise.all(
     entries.flatMap(
       (entry) => ctx.transports.map(
-        (transport) => Promise.resolve(transport.write(entry)).catch(() => {
+        (transport) => Promise.resolve(transport.write(entry)).catch((err) => {
+          const error = err instanceof Error ? err : new Error(String(err));
+          ctx.emitter.emit("error", { transport: transport.name, error, entry });
         })
       )
     )