@rawnodes/logger 2.11.0 → 2.12.1

package/README.md

@@ -316,6 +316,8 @@ telegram: {
 }
 ```
 
+File open, write, and rotation errors disable only the affected file destination. Console and remote transports continue logging. By default, a single diagnostic with the error code is written to stderr. Set `file.onError` to handle the error yourself; the callback receives the original `Error`.
+
 ### CloudWatch
 
 Send logs to AWS CloudWatch Logs:
@@ -871,6 +873,7 @@ interface LoggerConfig {
     maxFiles?: string;
     maxSize?: string;
     zippedArchive?: boolean;
+    onError?: (error: Error) => void;
   };
 }
 

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { L as LoggerContext, a as LoggerConfig, b as LevelOverrideMatch, c as LogLevel, d as LevelOverride, M as Meta, D as DiscordConfig, T as TelegramConfig, C as CloudWatchConfig, e as MaskReplacer, Z as ZohoCliqConfig, f as CallerConfig, g as CallerInfo, h as LogFormat, i as LevelRule, j as ConsoleConfig, F as FileConfig, H as HttpTransportBaseConfig, k as LevelConfigObject, l as LevelConfig, R as RelayConfig, A as AutoShutdownConfig, m as LogStreamPattern, n as LogStreamPatternConfig, o as LogStreamTemplateConfig, p as LogStreamName } from './types-lfJLhC8J.mjs';
-export { q as LOG_LEVELS, x as MaskSecretsOptions, t as ZohoCliqBotConfig, s as assertLogLevel, v as createMasker, r as isValidLogLevel, w as maskReplacer, u as maskSecrets } from './types-lfJLhC8J.mjs';
+import { L as LoggerContext, a as LoggerConfig, b as LevelOverrideMatch, c as LogLevel, d as LevelOverride, M as Meta, D as DiscordConfig, T as TelegramConfig, C as CloudWatchConfig, e as MaskReplacer, Z as ZohoCliqConfig, f as CallerConfig, g as CallerInfo, h as LogFormat, i as LevelRule, j as ConsoleConfig, F as FileConfig, H as HttpTransportBaseConfig, k as LevelConfigObject, l as LevelConfig, R as RelayConfig, A as AutoShutdownConfig, m as LogStreamPattern, n as LogStreamPatternConfig, o as LogStreamTemplateConfig, p as LogStreamName } from './types-CD5hHXR4.mjs';
+export { q as LOG_LEVELS, x as MaskSecretsOptions, t as ZohoCliqBotConfig, s as assertLogLevel, v as createMasker, r as isValidLogLevel, w as maskReplacer, u as maskSecrets } from './types-CD5hHXR4.mjs';
 import { z } from 'zod';
 
 declare class LoggerStore<TContext extends LoggerContext = LoggerContext> {
@@ -218,20 +218,24 @@ declare class TelegramTransport extends BaseHttpTransport {
 declare class CloudWatchTransport extends BaseHttpTransport {
     private config;
     private client;
-    private sequenceToken;
     private initialized;
     private initPromise;
+    private initFailures;
+    private nextInitAttempt;
     private resolvedLogStreamName;
     private maskReplacer;
+    private static readonly INIT_BACKOFF_BASE_MS;
+    private static readonly INIT_BACKOFF_MAX_MS;
     constructor(config: CloudWatchConfig, configHostname?: string, maskReplacerFn?: MaskReplacer);
     protected sendBatch(messages: BufferedMessage[]): Promise<void>;
+    private putLogEvents;
     private ensureInitialized;
     private initialize;
     private createLogGroupIfNotExists;
     private createLogStreamIfNotExists;
-    private fetchSequenceToken;
     private isResourceAlreadyExistsError;
-    private isInvalidSequenceTokenError;
+    private isResourceNotFoundError;
+    private isAwsErrorNamed;
 }
 
 declare class ZohoCliqTransport extends BaseHttpTransport {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { L as LoggerContext, a as LoggerConfig, b as LevelOverrideMatch, c as LogLevel, d as LevelOverride, M as Meta, D as DiscordConfig, T as TelegramConfig, C as CloudWatchConfig, e as MaskReplacer, Z as ZohoCliqConfig, f as CallerConfig, g as CallerInfo, h as LogFormat, i as LevelRule, j as ConsoleConfig, F as FileConfig, H as HttpTransportBaseConfig, k as LevelConfigObject, l as LevelConfig, R as RelayConfig, A as AutoShutdownConfig, m as LogStreamPattern, n as LogStreamPatternConfig, o as LogStreamTemplateConfig, p as LogStreamName } from './types-lfJLhC8J.js';
-export { q as LOG_LEVELS, x as MaskSecretsOptions, t as ZohoCliqBotConfig, s as assertLogLevel, v as createMasker, r as isValidLogLevel, w as maskReplacer, u as maskSecrets } from './types-lfJLhC8J.js';
+import { L as LoggerContext, a as LoggerConfig, b as LevelOverrideMatch, c as LogLevel, d as LevelOverride, M as Meta, D as DiscordConfig, T as TelegramConfig, C as CloudWatchConfig, e as MaskReplacer, Z as ZohoCliqConfig, f as CallerConfig, g as CallerInfo, h as LogFormat, i as LevelRule, j as ConsoleConfig, F as FileConfig, H as HttpTransportBaseConfig, k as LevelConfigObject, l as LevelConfig, R as RelayConfig, A as AutoShutdownConfig, m as LogStreamPattern, n as LogStreamPatternConfig, o as LogStreamTemplateConfig, p as LogStreamName } from './types-CD5hHXR4.js';
+export { q as LOG_LEVELS, x as MaskSecretsOptions, t as ZohoCliqBotConfig, s as assertLogLevel, v as createMasker, r as isValidLogLevel, w as maskReplacer, u as maskSecrets } from './types-CD5hHXR4.js';
 import { z } from 'zod';
 
 declare class LoggerStore<TContext extends LoggerContext = LoggerContext> {
@@ -218,20 +218,24 @@ declare class TelegramTransport extends BaseHttpTransport {
 declare class CloudWatchTransport extends BaseHttpTransport {
     private config;
     private client;
-    private sequenceToken;
     private initialized;
     private initPromise;
+    private initFailures;
+    private nextInitAttempt;
     private resolvedLogStreamName;
     private maskReplacer;
+    private static readonly INIT_BACKOFF_BASE_MS;
+    private static readonly INIT_BACKOFF_MAX_MS;
     constructor(config: CloudWatchConfig, configHostname?: string, maskReplacerFn?: MaskReplacer);
     protected sendBatch(messages: BufferedMessage[]): Promise<void>;
+    private putLogEvents;
     private ensureInitialized;
     private initialize;
     private createLogGroupIfNotExists;
     private createLogStreamIfNotExists;
-    private fetchSequenceToken;
     private isResourceAlreadyExistsError;
-    private isInvalidSequenceTokenError;
+    private isResourceNotFoundError;
+    private isAwsErrorNamed;
 }
 
 declare class ZohoCliqTransport extends BaseHttpTransport {

package/dist/index.js

@@ -4,7 +4,6 @@ var os = require('os');
 var pino = require('pino');
 var async_hooks = require('async_hooks');
 var stream = require('stream');
-var promises = require('fs/promises');
 var rotatingFileStream = require('rotating-file-stream');
 var clientCloudwatchLogs = require('@aws-sdk/client-cloudwatch-logs');
 var crypto = require('crypto');
@@ -45,6 +44,89 @@ function assertLogLevel(level) {
     throw new Error(`Invalid log level: "${level}". Valid levels: ${Object.keys(LOG_LEVELS).join(", ")}`);
   }
 }
+function reportFileFailure(error) {
+  const code = "code" in error && typeof error.code === "string" ? error.code : error.name;
+  process.stderr.write(
+    `[Logger] File logging stopped (${code}); other transports remain active.
+`
+  );
+}
+function createFileDestination(config) {
+  let failed = false;
+  let rotatingStream;
+  const fail = (error) => {
+    if (failed) return;
+    failed = true;
+    if (config.onError) {
+      try {
+        config.onError(error);
+      } catch {
+        reportFileFailure(error);
+      }
+    } else {
+      reportFileFailure(error);
+    }
+  };
+  try {
+    rotatingStream = rotatingFileStream.createStream(
+      (time, index) => {
+        const date = time instanceof Date ? time : /* @__PURE__ */ new Date();
+        const dateStr = date.toISOString().split("T")[0];
+        const base = config.filename.replace(".log", "");
+        return `${base}-${dateStr}${index ? `.${index}` : ""}.log`;
+      },
+      {
+        path: config.dirname,
+        size: (config.maxSize || "20M").replace(
+          /([kmg])$/i,
+          (unit) => unit.toUpperCase()
+        ),
+        interval: config.interval || (config.datePattern === "YYYY-MM-DD-HH" ? "1h" : "1d"),
+        compress: config.zippedArchive ? "gzip" : false,
+        maxFiles: parseInt(config.maxFiles?.replace("d", "") || "14")
+      }
+    );
+    rotatingStream.on("error", fail);
+  } catch (error) {
+    fail(error instanceof Error ? error : new Error(String(error)));
+  }
+  return new stream.Writable({
+    write(chunk, encoding, callback) {
+      if (failed || !rotatingStream) {
+        callback();
+        return;
+      }
+      try {
+        rotatingStream.write(chunk, encoding, (error) => {
+          if (error) fail(error);
+          callback();
+        });
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)));
+        callback();
+      }
+    },
+    final(callback) {
+      if (!rotatingStream || rotatingStream.destroyed) {
+        callback();
+        return;
+      }
+      try {
+        rotatingStream.end((error) => {
+          if (error) fail(error);
+          callback();
+        });
+      } catch (error) {
+        fail(error instanceof Error ? error : new Error(String(error)));
+        callback();
+      }
+    },
+    destroy(_error, callback) {
+      rotatingStream?.destroy();
+      callback();
+    }
+  });
+}
 
 // src/transports/buffer.ts
 var MessageBuffer = class {
@@ -651,14 +733,21 @@ function resolveLogStreamName(config, configHostname) {
   }
   return hostname;
 }
-var CloudWatchTransport = class extends BaseHttpTransport {
+var CloudWatchTransport = class _CloudWatchTransport extends BaseHttpTransport {
   config;
   client;
-  sequenceToken;
   initialized = false;
   initPromise = null;
+  initFailures = 0;
+  nextInitAttempt = 0;
   resolvedLogStreamName;
   maskReplacer;
+  // Backoff bounds for repeated init failures (e.g. IAM not yet propagated,
+  // throttling). Without this, a sustained outage makes every flush re-run
+  // initialize() back-to-back and hammer the CloudWatch control-plane APIs,
+  // which only deepens the throttling.
+  static INIT_BACKOFF_BASE_MS = 1e3;
+  static INIT_BACKOFF_MAX_MS = 3e4;
   constructor(config, configHostname, maskReplacerFn) {
     super({
       batchSize: config.batchSize ?? 100,
@@ -694,36 +783,46 @@ var CloudWatchTransport = class extends BaseHttpTransport {
       }, replacer)
     }));
     logEvents.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
-    const command = new clientCloudwatchLogs.PutLogEventsCommand({
-      logGroupName: this.config.logGroupName,
-      logStreamName: this.resolvedLogStreamName,
-      logEvents,
-      sequenceToken: this.sequenceToken
-    });
     try {
-      const response = await this.client.send(command);
-      this.sequenceToken = response.nextSequenceToken;
+      await this.putLogEvents(logEvents);
     } catch (error) {
-      if (this.isInvalidSequenceTokenError(error)) {
-        await this.fetchSequenceToken();
-        const retryCommand = new clientCloudwatchLogs.PutLogEventsCommand({
-          logGroupName: this.config.logGroupName,
-          logStreamName: this.resolvedLogStreamName,
-          logEvents,
-          sequenceToken: this.sequenceToken
-        });
-        const response = await this.client.send(retryCommand);
-        this.sequenceToken = response.nextSequenceToken;
+      if (this.isResourceNotFoundError(error)) {
+        this.initialized = false;
+        this.initPromise = null;
+        await this.ensureInitialized();
+        await this.putLogEvents(logEvents);
       } else {
         throw error;
       }
     }
   }
+  // PutLogEvents no longer requires a sequence token: since 2023 CloudWatch
+  // Logs ignores the `sequenceToken` field for sequential writes, so we omit it
+  // entirely. This also removes the need for DescribeLogStreams (and the
+  // logs:DescribeLogStreams IAM permission) on the hot path.
+  async putLogEvents(logEvents) {
+    await this.client.send(
+      new clientCloudwatchLogs.PutLogEventsCommand({
+        logGroupName: this.config.logGroupName,
+        logStreamName: this.resolvedLogStreamName,
+        logEvents
+      })
+    );
+  }
   async ensureInitialized() {
     if (this.initialized) return;
+    if (!this.initPromise && Date.now() < this.nextInitAttempt) {
+      throw new Error("CloudWatch transport initialization is backing off");
+    }
     if (!this.initPromise) {
       this.initPromise = this.initialize().catch((err) => {
         this.initPromise = null;
+        this.initFailures += 1;
+        const delay = Math.min(
+          _CloudWatchTransport.INIT_BACKOFF_MAX_MS,
+          _CloudWatchTransport.INIT_BACKOFF_BASE_MS * 2 ** (this.initFailures - 1)
+        );
+        this.nextInitAttempt = Date.now() + delay;
         throw err;
       });
     }
@@ -736,8 +835,9 @@ var CloudWatchTransport = class extends BaseHttpTransport {
     if (this.config.createLogStream !== false) {
       await this.createLogStreamIfNotExists();
     }
-    await this.fetchSequenceToken();
     this.initialized = true;
+    this.initFailures = 0;
+    this.nextInitAttempt = 0;
   }
   async createLogGroupIfNotExists() {
     try {
@@ -766,22 +866,16 @@ var CloudWatchTransport = class extends BaseHttpTransport {
       }
     }
   }
-  async fetchSequenceToken() {
-    const response = await this.client.send(
-      new clientCloudwatchLogs.DescribeLogStreamsCommand({
-        logGroupName: this.config.logGroupName,
-        logStreamNamePrefix: this.resolvedLogStreamName,
-        limit: 1
-      })
-    );
-    const stream = response.logStreams?.find((s) => s.logStreamName === this.resolvedLogStreamName);
-    this.sequenceToken = stream?.uploadSequenceToken;
-  }
   isResourceAlreadyExistsError(error) {
-    return typeof error === "object" && error !== null && "name" in error && error.name === "ResourceAlreadyExistsException";
+    return this.isAwsErrorNamed(error, "ResourceAlreadyExistsException");
+  }
+  isResourceNotFoundError(error) {
+    return this.isAwsErrorNamed(error, "ResourceNotFoundException");
   }
-  isInvalidSequenceTokenError(error) {
-    return typeof error === "object" && error !== null && "name" in error && error.name === "InvalidSequenceTokenException";
+  isAwsErrorNamed(error, name) {
+    if (typeof error !== "object" || error === null) return false;
+    if ("name" in error && error.name === name) return true;
+    return "__type" in error && typeof error.__type === "string" && error.__type.split("#").at(-1) === name;
   }
 };
 
@@ -943,26 +1037,7 @@ function createStreams(config, state) {
   });
   if (config.file) {
     const fileConfig = config.file;
-    promises.mkdir(fileConfig.dirname, { recursive: true }).catch(() => {
-    });
-    const normalizeSize = (size) => {
-      return size.replace(/([kmg])$/i, (match) => match.toUpperCase());
-    };
-    const rotatingStream = rotatingFileStream.createStream(
-      (time, index) => {
-        const date = time instanceof Date ? time : /* @__PURE__ */ new Date();
-        const dateStr = date.toISOString().split("T")[0];
-        const base = fileConfig.filename.replace(".log", "");
-        return `${base}-${dateStr}${index ? `.${index}` : ""}.log`;
-      },
-      {
-        path: fileConfig.dirname,
-        size: normalizeSize(fileConfig.maxSize || "20M"),
-        interval: fileConfig.interval || (fileConfig.datePattern === "YYYY-MM-DD-HH" ? "1h" : "1d"),
-        compress: fileConfig.zippedArchive ? "gzip" : false,
-        maxFiles: parseInt(fileConfig.maxFiles?.replace("d", "") || "14")
-      }
-    );
+    const rotatingStream = createFileDestination(fileConfig);
     const fileStream = createFormattedFilterStream(
       fileConfig.format,
       fileConfig.level,
@@ -1354,7 +1429,8 @@ var FileConfigSchema = zod.z.object({
   interval: zod.z.string().regex(/^\d+[Mdhms]$/).optional(),
   zippedArchive: zod.z.boolean().optional(),
   maxSize: zod.z.string().optional(),
-  maxFiles: zod.z.string().optional()
+  maxFiles: zod.z.string().optional(),
+  onError: zod.z.function().optional()
 });
 var HttpTransportBaseConfigSchema = zod.z.object({
   level: LogLevelSchema.optional(),