@oxog/log 1.0.0 → 1.0.1

package/README.md

@@ -214,13 +214,57 @@ const child = log.child({ component: 'Auth' });
 child.info('Checking token');
 ```
 
+## Transport Error Handling
+
+```typescript
+// Listen for transport failures
+log.on('error', ({ transport, error, entry }) => {
+  console.error(`Transport ${transport} failed:`, error.message);
+  // Optionally alert ops team or use fallback
+});
+```
+
+## Sync vs Async Logging
+
+```typescript
+const log = createLogger({
+  // fatal and error are sync by default (written before process exit)
+  sync: {
+    fatal: true,  // default
+    error: true,  // default
+    warn: false,
+    info: false,
+    debug: false,
+    trace: false,
+  }
+});
+
+// Fatal logs are written synchronously - safe before process.exit()
+process.on('uncaughtException', (err) => {
+  log.fatal(err, 'Uncaught exception');
+  process.exit(1); // Log is guaranteed to be written
+});
+```
+
+## Efficient Redaction
+
+```typescript
+import { stringifyWithRedaction } from '@oxog/log';
+
+// More efficient than redactFields + JSON.stringify for large objects
+const json = stringifyWithRedaction(
+  largeObject,
+  ['password', 'token', 'headers.authorization']
+);
+```
+
 ## Graceful Shutdown
 
 ```typescript
 // Flush buffered logs before shutdown
 await log.flush();
 
-// Cleanup and destroy
+// Cleanup and destroy (also flushes buffer)
 await log.close();
 ```
 

package/dist/index.cjs

@@ -272,7 +272,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") {
@@ -436,27 +436,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() {
@@ -779,6 +797,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 = [];
@@ -786,14 +829,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) {
@@ -844,10 +891,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);
       });
     }
   }
@@ -968,9 +1015,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);
           }
         }
       }
@@ -980,6 +1028,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) {
@@ -987,9 +1060,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);
           }
         }
       }
@@ -1145,6 +1219,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) => {
@@ -1794,7 +1898,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 });
         })
       )
     )