@rawnodes/logger 2.5.0 → 2.7.0

package/dist/index.js

@@ -689,6 +689,7 @@ function createFormattedFilterStream(format, level, rules, store, destination) {
 }
 function createStreams(config, store) {
   const streams = [];
+  const transports = [];
   const consoleStream = createFormattedFilterStream(
     config.console.format,
     config.console.level,
@@ -736,6 +737,7 @@ function createStreams(config, store) {
   }
   for (const discordConfig of toArray(config.discord)) {
     const transport = new DiscordTransport(discordConfig);
+    transports.push(transport);
     const discordStream = createHttpTransportStream(transport, discordConfig.level, discordConfig.rules, store);
     streams.push({
       level: "trace",
@@ -744,6 +746,7 @@ function createStreams(config, store) {
   }
   for (const telegramConfig of toArray(config.telegram)) {
     const transport = new TelegramTransport(telegramConfig);
+    transports.push(transport);
     const telegramStream = createHttpTransportStream(transport, telegramConfig.level, telegramConfig.rules, store);
     streams.push({
       level: "trace",
@@ -752,13 +755,17 @@ function createStreams(config, store) {
   }
   for (const cloudwatchConfig of toArray(config.cloudwatch)) {
     const transport = new CloudWatchTransport(cloudwatchConfig, config.hostname);
+    transports.push(transport);
     const cwStream = createHttpTransportStream(transport, cloudwatchConfig.level, cloudwatchConfig.rules, store);
     streams.push({
       level: "trace",
       stream: cwStream
     });
   }
-  return pino__default.default.multistream(streams);
+  return {
+    destination: pino__default.default.multistream(streams),
+    transports
+  };
 }
 function toArray(value) {
   if (!value) return [];
@@ -843,14 +850,14 @@ function createState(config, store) {
     levelOverrides.set(key, rule);
   }
   const { contextIndex, complexRules } = buildIndexes(levelOverrides);
-  const streams = createStreams(config, loggerStore);
+  const { destination, transports } = createStreams(config, loggerStore);
   const options = {
     level: "trace",
     // Accept all, we filter in shouldLog()
     customLevels: CUSTOM_LEVELS,
     base: { hostname: config.hostname ?? os.hostname() }
   };
-  const pinoLogger = pino__default.default(options, streams);
+  const pinoLogger = pino__default.default(options, destination);
   let callerConfig;
   if (config.caller === true) {
     callerConfig = {};
@@ -864,7 +871,8 @@ function createState(config, store) {
     levelOverrides,
     contextIndex,
     complexRules,
-    callerConfig
+    callerConfig,
+    transports
   };
 }
 function rebuildIndexes(state) {
@@ -1010,6 +1018,10 @@ var CallerConfigSchema = zod.z.object({
   depth: zod.z.number().int().nonnegative().optional(),
   fullPath: zod.z.boolean().optional()
 });
+var AutoShutdownConfigSchema = zod.z.object({
+  timeout: zod.z.number().int().positive().optional(),
+  signals: zod.z.array(zod.z.string()).optional()
+});
 var LoggerConfigSchema = zod.z.object({
   level: LevelConfigSchema,
   console: ConsoleConfigSchema,
@@ -1018,7 +1030,8 @@ var LoggerConfigSchema = zod.z.object({
   telegram: zod.z.union([TelegramConfigSchema, zod.z.array(TelegramConfigSchema)]).optional(),
   cloudwatch: zod.z.union([CloudWatchConfigSchema, zod.z.array(CloudWatchConfigSchema)]).optional(),
   caller: zod.z.union([zod.z.boolean(), CallerConfigSchema]).optional(),
-  hostname: zod.z.string().optional()
+  hostname: zod.z.string().optional(),
+  autoShutdown: zod.z.union([zod.z.boolean(), AutoShutdownConfigSchema]).optional()
 });
 function validateConfig(config) {
   return LoggerConfigSchema.parse(config);
@@ -1087,6 +1100,176 @@ function formatCallerInfo(info) {
   return location;
 }
 
+// src/utils/shutdown.ts
+var DEFAULT_OPTIONS2 = {
+  timeout: 5e3,
+  exitCode: 0,
+  signals: ["SIGTERM", "SIGINT"]
+};
+var registered = false;
+function registerShutdown(logger, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const shutdown = async (signal) => {
+    if (signal) {
+      console.error(`[Logger] Received ${signal}, shutting down gracefully...`);
+    }
+    try {
+      if (opts.onShutdown) {
+        await opts.onShutdown();
+      }
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Shutdown timed out after ${opts.timeout}ms`));
+        }, opts.timeout);
+      });
+      await Promise.race([
+        logger.shutdown(),
+        timeoutPromise
+      ]);
+      if (signal) {
+        console.error("[Logger] Graceful shutdown completed");
+        process.exit(opts.exitCode);
+      }
+    } catch (error) {
+      console.error("[Logger] Shutdown error:", error instanceof Error ? error.message : error);
+      if (signal) {
+        process.exit(1);
+      }
+    }
+  };
+  if (!registered) {
+    for (const signal of opts.signals) {
+      process.on(signal, () => void shutdown(signal));
+    }
+    process.on("beforeExit", () => void shutdown());
+    registered = true;
+  }
+  return shutdown;
+}
+
+// src/utils/error.ts
+function isAxiosError(error) {
+  return error !== null && typeof error === "object" && "isAxiosError" in error && error.isAxiosError === true;
+}
+function sanitizeResponseData(data, maxStringLength = 1e4) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return data.length > maxStringLength ? `${data.slice(0, maxStringLength)}...[truncated]` : data;
+  }
+  if (typeof data === "number" || typeof data === "boolean") {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.slice(0, 100).map((item) => sanitizeResponseData(item, maxStringLength));
+  }
+  if (typeof data === "object") {
+    const result = {};
+    const entries = Object.entries(data);
+    for (const [key, value] of entries.slice(0, 50)) {
+      result[key] = sanitizeResponseData(value, maxStringLength);
+    }
+    return result;
+  }
+  return String(data);
+}
+function extractAxiosHttpData(error) {
+  const httpData = {};
+  if (error.code) {
+    httpData.code = error.code;
+  }
+  if (error.response) {
+    httpData.status = error.response.status;
+    httpData.statusText = error.response.statusText;
+    if (error.response.data !== void 0) {
+      httpData.responseData = sanitizeResponseData(error.response.data);
+    }
+  }
+  if (error.config) {
+    const { url, baseURL, method } = error.config;
+    if (url) {
+      httpData.url = baseURL && !url.startsWith("http") ? `${baseURL}${url}` : url;
+    }
+    if (method) {
+      httpData.method = method.toUpperCase();
+    }
+  }
+  return httpData;
+}
+function extractGenericHttpData(error) {
+  const httpData = {};
+  let hasData = false;
+  if (typeof error.code === "string") {
+    httpData.code = error.code;
+    hasData = true;
+  }
+  const response = error.response;
+  if (response && typeof response === "object") {
+    if (typeof response.status === "number") {
+      httpData.status = response.status;
+      hasData = true;
+    }
+    if (typeof response.statusText === "string") {
+      httpData.statusText = response.statusText;
+      hasData = true;
+    }
+    if (response.data !== void 0) {
+      httpData.responseData = sanitizeResponseData(response.data);
+      hasData = true;
+    }
+  }
+  const config = error.config;
+  if (config && typeof config === "object") {
+    const url = config.url;
+    const baseURL = config.baseURL;
+    if (typeof url === "string") {
+      httpData.url = baseURL && !url.startsWith("http") ? `${baseURL}${url}` : url;
+      hasData = true;
+    }
+    if (typeof config.method === "string") {
+      httpData.method = config.method.toUpperCase();
+      hasData = true;
+    }
+  }
+  return hasData ? httpData : void 0;
+}
+function serializeError(error) {
+  if (!(error instanceof Error)) {
+    if (error === null || error === void 0) {
+      return { errorMessage: "Unknown error" };
+    }
+    if (typeof error === "string") {
+      return { errorMessage: error };
+    }
+    const httpData2 = typeof error === "object" ? extractGenericHttpData(error) : void 0;
+    return {
+      errorMessage: String(error),
+      http: httpData2
+    };
+  }
+  const serialized = {
+    errorMessage: error.message,
+    stack: error.stack
+  };
+  if (error.name && error.name !== "Error") {
+    serialized.errorName = error.name;
+  }
+  if (isAxiosError(error)) {
+    serialized.http = extractAxiosHttpData(error);
+    return serialized;
+  }
+  const errWithCode = error;
+  if (typeof errWithCode.code === "string") {
+    serialized.code = errWithCode.code;
+  }
+  const httpData = extractGenericHttpData(error);
+  if (httpData) {
+    serialized.http = httpData;
+  }
+  return serialized;
+}
+
 // src/logger.ts
 var Logger = class _Logger {
   constructor(state, context) {
@@ -1097,7 +1280,12 @@ var Logger = class _Logger {
   static create(config, store) {
     const validatedConfig = validateConfig(config);
     const state = createState(validatedConfig, store);
-    return new _Logger(state, "APP");
+    const logger = new _Logger(state, "APP");
+    if (validatedConfig.autoShutdown) {
+      const shutdownConfig = typeof validatedConfig.autoShutdown === "object" ? validatedConfig.autoShutdown : {};
+      registerShutdown(logger, shutdownConfig);
+    }
+    return logger;
   }
   for(context) {
     return new _Logger(this.state, context);
@@ -1139,6 +1327,15 @@ var Logger = class _Logger {
   getLevelOverrides() {
     return Array.from(this.state.levelOverrides.values());
   }
+  // Shutdown
+  /**
+   * Gracefully shutdown the logger, flushing all pending messages.
+   * Should be called before process exit to ensure no logs are lost.
+   */
+  async shutdown() {
+    const closePromises = this.state.transports.map((transport) => transport.close());
+    await Promise.all(closePromises);
+  }
   // Profiling
   profile(id, meta) {
     const existing = this.profileTimers.get(id);
@@ -1201,11 +1398,19 @@ var Logger = class _Logger {
         logMeta.caller = formatCallerInfo(callerInfo);
       }
     }
-    if (error instanceof Error) {
-      logMeta.errorMessage = error.message;
-      logMeta.stack = error.stack;
-    } else if (error !== void 0) {
-      logMeta.error = error;
+    if (error !== void 0) {
+      const serialized = serializeError(error);
+      logMeta.errorMessage = serialized.errorMessage;
+      logMeta.stack = serialized.stack;
+      if (serialized.errorName) {
+        logMeta.errorName = serialized.errorName;
+      }
+      if (serialized.code) {
+        logMeta.errorCode = serialized.code;
+      }
+      if (serialized.http) {
+        logMeta.http = serialized.http;
+      }
     }
     const pinoMethod = this.getPinoMethod(level);
     pinoMethod.call(this.state.pino, logMeta, message);
@@ -1405,16 +1610,28 @@ function createMasker(options = {}) {
 }
 
 // src/formatters.ts
-function flattenObject(obj, prefix = "") {
+var MAX_FLATTEN_DEPTH = 10;
+var CIRCULAR_REF = "[Circular]";
+function flattenObject(obj, prefix = "", ancestors = /* @__PURE__ */ new WeakSet(), depth = 0) {
   const result = {};
+  if (depth > MAX_FLATTEN_DEPTH) {
+    result[prefix || "value"] = "[Max depth exceeded]";
+    return result;
+  }
+  ancestors.add(obj);
   for (const [key, value] of Object.entries(obj)) {
     const newKey = prefix ? `${prefix}.${key}` : key;
     if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Error)) {
-      Object.assign(result, flattenObject(value, newKey));
+      if (ancestors.has(value)) {
+        result[newKey] = CIRCULAR_REF;
+      } else {
+        Object.assign(result, flattenObject(value, newKey, ancestors, depth + 1));
+      }
     } else {
       result[newKey] = value;
     }
   }
+  ancestors.delete(obj);
   return result;
 }
 function formatLogfmtValue(value) {
@@ -1443,6 +1660,7 @@ function formatLogfmt(data) {
   return Object.entries(flattened).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${formatLogfmtValue(value)}`).join(" ");
 }
 
+exports.AutoShutdownConfigSchema = AutoShutdownConfigSchema;
 exports.BaseHttpTransport = BaseHttpTransport;
 exports.CallerConfigSchema = CallerConfigSchema;
 exports.CloudWatchConfigSchema = CloudWatchConfigSchema;
@@ -1484,7 +1702,9 @@ exports.maskSecrets = maskSecrets;
 exports.matchesContext = matchesContext;
 exports.measureAsync = measureAsync;
 exports.measureSync = measureSync;
+exports.registerShutdown = registerShutdown;
 exports.safeValidateConfig = safeValidateConfig;
+exports.serializeError = serializeError;
 exports.validateConfig = validateConfig;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map