@rawnodes/logger 2.10.0 → 2.12.0

package/dist/index.d.mts

@@ -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 {
@@ -313,6 +317,12 @@ interface HttpErrorData {
     url?: string;
     /** HTTP method (GET, POST, etc.) */
     method?: string;
+    /** Request query params */
+    params?: unknown;
+    /** Request body */
+    requestData?: unknown;
+    /** Request headers */
+    requestHeaders?: unknown;
     /** Error code (e.g., ECONNREFUSED, ETIMEDOUT) */
     code?: string;
 }

package/dist/index.d.ts

@@ -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 {
@@ -313,6 +317,12 @@ interface HttpErrorData {
     url?: string;
     /** HTTP method (GET, POST, etc.) */
     method?: string;
+    /** Request query params */
+    params?: unknown;
+    /** Request body */
+    requestData?: unknown;
+    /** Request headers */
+    requestHeaders?: unknown;
     /** Error code (e.g., ECONNREFUSED, ETIMEDOUT) */
     code?: string;
 }

package/dist/index.js

@@ -651,14 +651,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 +701,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 +753,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 +784,14 @@ 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) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === name;
   }
 };
 
@@ -1688,13 +1698,22 @@ function extractAxiosHttpData(error) {
     }
   }
   if (error.config) {
-    const { url, baseURL, method } = error.config;
+    const { url, baseURL, method, params, data, headers } = error.config;
     if (url) {
       httpData.url = baseURL && !url.startsWith("http") ? `${baseURL}${url}` : url;
     }
     if (method) {
       httpData.method = method.toUpperCase();
     }
+    if (params !== void 0) {
+      httpData.params = sanitizeResponseData(params);
+    }
+    if (data !== void 0) {
+      httpData.requestData = sanitizeResponseData(data);
+    }
+    if (headers !== void 0) {
+      httpData.requestHeaders = sanitizeResponseData(headers);
+    }
   }
   return httpData;
 }
@@ -1732,6 +1751,18 @@ function extractGenericHttpData(error) {
       httpData.method = config.method.toUpperCase();
       hasData = true;
     }
+    if (config.params !== void 0) {
+      httpData.params = sanitizeResponseData(config.params);
+      hasData = true;
+    }
+    if (config.data !== void 0) {
+      httpData.requestData = sanitizeResponseData(config.data);
+      hasData = true;
+    }
+    if (config.headers !== void 0) {
+      httpData.requestHeaders = sanitizeResponseData(config.headers);
+      hasData = true;
+    }
   }
   return hasData ? httpData : void 0;
 }