@rawnodes/logger 2.4.0 → 2.6.0

package/dist/index.mjs

@@ -6,9 +6,9 @@ import { mkdir } from 'fs/promises';
 import { createStream } from 'rotating-file-stream';
 import { EventEmitter } from 'events';
 import { CloudWatchLogsClient, PutLogEventsCommand, CreateLogGroupCommand, CreateLogStreamCommand, DescribeLogStreamsCommand } from '@aws-sdk/client-cloudwatch-logs';
+import { randomUUID } from 'crypto';
 import { z } from 'zod';
 import { relative, basename } from 'path';
-import { randomUUID } from 'crypto';
 
 // src/state.ts
 var LoggerStore = class {
@@ -416,13 +416,50 @@ var TelegramTransport = class extends BaseHttpTransport {
     return text.replace(/[&<>"']/g, (c) => entities[c] || c);
   }
 };
+var instanceUuid = randomUUID().slice(0, 8);
+function formatDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function formatDateTime() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[T:]/g, "-");
+}
+function resolveLogStreamName(config, configHostname) {
+  const hostname$1 = configHostname || process.env.HOSTNAME || hostname();
+  if (!config) {
+    return hostname$1;
+  }
+  if (typeof config === "string") {
+    return config;
+  }
+  if ("pattern" in config) {
+    switch (config.pattern) {
+      case "hostname":
+        return hostname$1;
+      case "hostname-date":
+        return `${hostname$1}/${formatDate()}`;
+      case "hostname-uuid":
+        return `${hostname$1}-${instanceUuid}`;
+      case "date":
+        return formatDate();
+      case "uuid":
+        return randomUUID();
+      default:
+        return hostname$1;
+    }
+  }
+  if ("template" in config) {
+    return config.template.replace(/\{hostname\}/g, hostname$1).replace(/\{date\}/g, formatDate()).replace(/\{datetime\}/g, formatDateTime()).replace(/\{uuid\}/g, instanceUuid).replace(/\{pid\}/g, String(process.pid)).replace(/\{env\}/g, process.env.NODE_ENV || "development");
+  }
+  return hostname$1;
+}
 var CloudWatchTransport = class extends BaseHttpTransport {
   config;
   client;
   sequenceToken;
   initialized = false;
   initPromise = null;
-  constructor(config) {
+  resolvedLogStreamName;
+  constructor(config, configHostname) {
     super({
       batchSize: config.batchSize ?? 100,
       flushInterval: config.flushInterval ?? 1e3,
@@ -430,6 +467,7 @@ var CloudWatchTransport = class extends BaseHttpTransport {
       retryDelay: config.retryDelay
     });
     this.config = config;
+    this.resolvedLogStreamName = resolveLogStreamName(config.logStreamName, configHostname);
     this.client = new CloudWatchLogsClient({
       region: config.region,
       credentials: {
@@ -452,7 +490,7 @@ var CloudWatchTransport = class extends BaseHttpTransport {
     logEvents.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
     const command = new PutLogEventsCommand({
       logGroupName: this.config.logGroupName,
-      logStreamName: this.config.logStreamName,
+      logStreamName: this.resolvedLogStreamName,
       logEvents,
       sequenceToken: this.sequenceToken
     });
@@ -464,7 +502,7 @@ var CloudWatchTransport = class extends BaseHttpTransport {
         await this.fetchSequenceToken();
         const retryCommand = new PutLogEventsCommand({
           logGroupName: this.config.logGroupName,
-          logStreamName: this.config.logStreamName,
+          logStreamName: this.resolvedLogStreamName,
           logEvents,
           sequenceToken: this.sequenceToken
         });
@@ -510,7 +548,7 @@ var CloudWatchTransport = class extends BaseHttpTransport {
       await this.client.send(
         new CreateLogStreamCommand({
           logGroupName: this.config.logGroupName,
-          logStreamName: this.config.logStreamName
+          logStreamName: this.resolvedLogStreamName
         })
       );
     } catch (error) {
@@ -523,11 +561,11 @@ var CloudWatchTransport = class extends BaseHttpTransport {
     const response = await this.client.send(
       new DescribeLogStreamsCommand({
         logGroupName: this.config.logGroupName,
-        logStreamNamePrefix: this.config.logStreamName,
+        logStreamNamePrefix: this.resolvedLogStreamName,
         limit: 1
       })
     );
-    const stream = response.logStreams?.find((s) => s.logStreamName === this.config.logStreamName);
+    const stream = response.logStreams?.find((s) => s.logStreamName === this.resolvedLogStreamName);
     this.sequenceToken = stream?.uploadSequenceToken;
   }
   isResourceAlreadyExistsError(error) {
@@ -645,6 +683,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,
@@ -692,6 +731,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",
@@ -700,6 +740,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",
@@ -707,14 +748,18 @@ function createStreams(config, store) {
     });
   }
   for (const cloudwatchConfig of toArray(config.cloudwatch)) {
-    const transport = new CloudWatchTransport(cloudwatchConfig);
+    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.multistream(streams);
+  return {
+    destination: pino.multistream(streams),
+    transports
+  };
 }
 function toArray(value) {
   if (!value) return [];
@@ -799,14 +844,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 ?? hostname() }
   };
-  const pinoLogger = pino(options, streams);
+  const pinoLogger = pino(options, destination);
   let callerConfig;
   if (config.caller === true) {
     callerConfig = {};
@@ -820,7 +865,8 @@ function createState(config, store) {
     levelOverrides,
     contextIndex,
     complexRules,
-    callerConfig
+    callerConfig,
+    transports
   };
 }
 function rebuildIndexes(state) {
@@ -921,6 +967,24 @@ var TelegramConfigSchema = z.object({
   threadId: z.number().int().optional(),
   replyToMessageId: z.number().int().optional()
 });
+var LogStreamPatternSchema = z.enum([
+  "hostname",
+  "hostname-date",
+  "hostname-uuid",
+  "date",
+  "uuid"
+]);
+var LogStreamPatternConfigSchema = z.object({
+  pattern: LogStreamPatternSchema
+});
+var LogStreamTemplateConfigSchema = z.object({
+  template: z.string().min(1, "template is required")
+});
+var LogStreamNameSchema = z.union([
+  z.string().min(1, "logStreamName string must not be empty"),
+  LogStreamPatternConfigSchema,
+  LogStreamTemplateConfigSchema
+]);
 var CloudWatchConfigSchema = z.object({
   level: LogLevelSchema.optional(),
   rules: z.array(LevelRuleSchema).optional(),
@@ -929,7 +993,7 @@ var CloudWatchConfigSchema = z.object({
   maxRetries: z.number().int().nonnegative().optional(),
   retryDelay: z.number().int().positive().optional(),
   logGroupName: z.string().min(1, "logGroupName is required"),
-  logStreamName: z.string().min(1, "logStreamName is required"),
+  logStreamName: LogStreamNameSchema.optional(),
   region: z.string().min(1, "region is required"),
   accessKeyId: z.string().min(1, "accessKeyId is required"),
   secretAccessKey: z.string().min(1, "secretAccessKey is required"),
@@ -948,6 +1012,10 @@ var CallerConfigSchema = z.object({
   depth: z.number().int().nonnegative().optional(),
   fullPath: z.boolean().optional()
 });
+var AutoShutdownConfigSchema = z.object({
+  timeout: z.number().int().positive().optional(),
+  signals: z.array(z.string()).optional()
+});
 var LoggerConfigSchema = z.object({
   level: LevelConfigSchema,
   console: ConsoleConfigSchema,
@@ -956,7 +1024,8 @@ var LoggerConfigSchema = z.object({
   telegram: z.union([TelegramConfigSchema, z.array(TelegramConfigSchema)]).optional(),
   cloudwatch: z.union([CloudWatchConfigSchema, z.array(CloudWatchConfigSchema)]).optional(),
   caller: z.union([z.boolean(), CallerConfigSchema]).optional(),
-  hostname: z.string().optional()
+  hostname: z.string().optional(),
+  autoShutdown: z.union([z.boolean(), AutoShutdownConfigSchema]).optional()
 });
 function validateConfig(config) {
   return LoggerConfigSchema.parse(config);
@@ -1025,6 +1094,53 @@ 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/logger.ts
 var Logger = class _Logger {
   constructor(state, context) {
@@ -1035,7 +1151,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);
@@ -1077,6 +1198,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);
@@ -1343,16 +1473,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) {
@@ -1381,6 +1523,6 @@ function formatLogfmt(data) {
   return Object.entries(flattened).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${formatLogfmtValue(value)}`).join(" ");
 }
 
-export { BaseHttpTransport, CallerConfigSchema, CloudWatchConfigSchema, CloudWatchTransport, ConsoleConfigSchema, DiscordConfigSchema, DiscordTransport, FileConfigSchema, HttpTransportBaseConfigSchema, LOG_LEVELS, LevelConfigObjectSchema, LevelConfigSchema, LevelRuleSchema, LogFormatSchema, LogLevelSchema, Logger, LoggerConfigSchema, LoggerStore, MessageBuffer, TelegramConfigSchema, TelegramTransport, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatCallerInfo, formatLogfmt, formatLogfmtValue, generateRequestId, getCallerInfo, getOrGenerateRequestId, isValidLogLevel, maskSecrets, matchesContext, measureAsync, measureSync, safeValidateConfig, validateConfig };
+export { AutoShutdownConfigSchema, BaseHttpTransport, CallerConfigSchema, CloudWatchConfigSchema, CloudWatchTransport, ConsoleConfigSchema, DiscordConfigSchema, DiscordTransport, FileConfigSchema, HttpTransportBaseConfigSchema, LOG_LEVELS, LevelConfigObjectSchema, LevelConfigSchema, LevelRuleSchema, LogFormatSchema, LogLevelSchema, LogStreamNameSchema, LogStreamPatternConfigSchema, LogStreamPatternSchema, LogStreamTemplateConfigSchema, Logger, LoggerConfigSchema, LoggerStore, MessageBuffer, TelegramConfigSchema, TelegramTransport, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatCallerInfo, formatLogfmt, formatLogfmtValue, generateRequestId, getCallerInfo, getOrGenerateRequestId, isValidLogLevel, maskSecrets, matchesContext, measureAsync, measureSync, registerShutdown, safeValidateConfig, validateConfig };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map