@logtape/cloudwatch-logs 1.1.0-dev.311 → 1.1.0-dev.315

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/cloudwatch-logs",
-  "version": "1.1.0-dev.311+6cacf678",
+  "version": "1.1.0-dev.315+fc46f65c",
   "license": "MIT",
   "exports": "./mod.ts",
   "exclude": [

package/dist/sink.cjs

@@ -7,53 +7,6 @@ const MAX_BATCH_SIZE_EVENTS = 1e4;
 const MAX_BATCH_SIZE_BYTES = 1048576;
 const OVERHEAD_PER_EVENT = 26;
 /**
-* Resolves the log stream name from template.
-* @param logStreamNameTemplate Template for generating stream names
-* @returns Resolved log stream name
-*/
-function resolveLogStreamName(logStreamNameTemplate) {
-	const now = /* @__PURE__ */ new Date();
-	const year = now.getFullYear().toString();
-	const month = (now.getMonth() + 1).toString().padStart(2, "0");
-	const day = now.getDate().toString().padStart(2, "0");
-	const timestamp = now.getTime().toString();
-	return logStreamNameTemplate.replace(/\{YYYY\}/g, year).replace(/\{MM\}/g, month).replace(/\{DD\}/g, day).replace(/\{YYYY-MM-DD\}/g, `${year}-${month}-${day}`).replace(/\{timestamp\}/g, timestamp);
-}
-/**
-* Ensures that the log stream exists, creating it if necessary.
-* @param client CloudWatch Logs client
-* @param logGroupName Log group name
-* @param logStreamName Log stream name
-* @param createdStreams Set to track already created streams
-*/
-async function ensureLogStreamExists(client, logGroupName, logStreamName, createdStreams) {
-	const streamKey = `${logGroupName}/${logStreamName}`;
-	if (createdStreams.has(streamKey)) return;
-	try {
-		const command = new __aws_sdk_client_cloudwatch_logs.CreateLogStreamCommand({
-			logGroupName,
-			logStreamName
-		});
-		await client.send(command);
-		createdStreams.add(streamKey);
-	} catch (error) {
-		if (error instanceof __aws_sdk_client_cloudwatch_logs.ResourceAlreadyExistsException) createdStreams.add(streamKey);
-		else {
-			const metaLogger = (0, __logtape_logtape.getLogger)([
-				"logtape",
-				"meta",
-				"cloudwatch-logs"
-			]);
-			metaLogger.error("Failed to create log stream {logStreamName} in group {logGroupName}: {error}", {
-				logStreamName,
-				logGroupName,
-				error
-			});
-			throw error;
-		}
-	}
-}
-/**
 * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
 *
 * @param options Configuration options for the CloudWatch Logs sink.
@@ -69,8 +22,6 @@ function getCloudWatchLogsSink(options) {
 	const flushInterval = options.flushInterval ?? 1e3;
 	const maxRetries = Math.max(options.maxRetries ?? 3, 0);
 	const retryDelay = Math.max(options.retryDelay ?? 100, 0);
-	const logStreamName = options.autoCreateLogStream && "logStreamNameTemplate" in options ? resolveLogStreamName(options.logStreamNameTemplate) : options.logStreamName;
-	const createdStreams = /* @__PURE__ */ new Set();
 	const defaultFormatter = (record) => {
 		let result = "";
 		for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) result += record.message[i];
@@ -82,7 +33,6 @@ function getCloudWatchLogsSink(options) {
 	let currentBatchSize = 0;
 	let flushTimer = null;
 	let disposed = false;
-	let flushPromise = null;
 	function scheduleFlush() {
 		if (flushInterval <= 0 || flushTimer !== null) return;
 		flushTimer = setTimeout(() => {
@@ -91,16 +41,6 @@ function getCloudWatchLogsSink(options) {
 		}, flushInterval);
 	}
 	async function flushEvents() {
-		if (logEvents.length === 0 || disposed) return;
-		if (flushPromise !== null) {
-			await flushPromise;
-			return;
-		}
-		flushPromise = doFlush();
-		await flushPromise;
-		flushPromise = null;
-	}
-	async function doFlush() {
 		if (logEvents.length === 0 || disposed) return;
 		const events = logEvents.splice(0);
 		currentBatchSize = 0;
@@ -108,14 +48,13 @@ function getCloudWatchLogsSink(options) {
 			clearTimeout(flushTimer);
 			flushTimer = null;
 		}
-		if (options.autoCreateLogStream) await ensureLogStreamExists(client, options.logGroupName, logStreamName, createdStreams);
 		await sendEventsWithRetry(events, maxRetries);
 	}
 	async function sendEventsWithRetry(events, remainingRetries) {
 		try {
 			const command = new __aws_sdk_client_cloudwatch_logs.PutLogEventsCommand({
 				logGroupName: options.logGroupName,
-				logStreamName,
+				logStreamName: options.logStreamName,
 				logEvents: events
 			});
 			await client.send(command);

package/dist/sink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;AA+FA;;;;;AAEyB,iBAFT,qBAAA,CAES,OAAA,EADd,yBACc,CAAA,EAAtB,IAAsB,GAAf,eAAe"}
+{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;AAEyB,iBAFT,qBAAA,CAES,OAAA,EADd,yBACc,CAAA,EAAtB,IAAsB,GAAf,eAAe"}

package/dist/sink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;AA+FA;;;;;AAEyB,iBAFT,qBAAA,CAES,OAAA,EADd,yBACc,CAAA,EAAtB,IAAsB,GAAf,eAAe"}
+{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;AA0BA;;;;;AAEyB,iBAFT,qBAAA,CAES,OAAA,EADd,yBACc,CAAA,EAAtB,IAAsB,GAAf,eAAe"}

package/dist/sink.js

@@ -1,4 +1,4 @@
-import { CloudWatchLogsClient, CreateLogStreamCommand, PutLogEventsCommand, ResourceAlreadyExistsException } from "@aws-sdk/client-cloudwatch-logs";
+import { CloudWatchLogsClient, PutLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs";
 import { getLogger } from "@logtape/logtape";
 
 //#region sink.ts
@@ -6,53 +6,6 @@ const MAX_BATCH_SIZE_EVENTS = 1e4;
 const MAX_BATCH_SIZE_BYTES = 1048576;
 const OVERHEAD_PER_EVENT = 26;
 /**
-* Resolves the log stream name from template.
-* @param logStreamNameTemplate Template for generating stream names
-* @returns Resolved log stream name
-*/
-function resolveLogStreamName(logStreamNameTemplate) {
-	const now = /* @__PURE__ */ new Date();
-	const year = now.getFullYear().toString();
-	const month = (now.getMonth() + 1).toString().padStart(2, "0");
-	const day = now.getDate().toString().padStart(2, "0");
-	const timestamp = now.getTime().toString();
-	return logStreamNameTemplate.replace(/\{YYYY\}/g, year).replace(/\{MM\}/g, month).replace(/\{DD\}/g, day).replace(/\{YYYY-MM-DD\}/g, `${year}-${month}-${day}`).replace(/\{timestamp\}/g, timestamp);
-}
-/**
-* Ensures that the log stream exists, creating it if necessary.
-* @param client CloudWatch Logs client
-* @param logGroupName Log group name
-* @param logStreamName Log stream name
-* @param createdStreams Set to track already created streams
-*/
-async function ensureLogStreamExists(client, logGroupName, logStreamName, createdStreams) {
-	const streamKey = `${logGroupName}/${logStreamName}`;
-	if (createdStreams.has(streamKey)) return;
-	try {
-		const command = new CreateLogStreamCommand({
-			logGroupName,
-			logStreamName
-		});
-		await client.send(command);
-		createdStreams.add(streamKey);
-	} catch (error) {
-		if (error instanceof ResourceAlreadyExistsException) createdStreams.add(streamKey);
-		else {
-			const metaLogger = getLogger([
-				"logtape",
-				"meta",
-				"cloudwatch-logs"
-			]);
-			metaLogger.error("Failed to create log stream {logStreamName} in group {logGroupName}: {error}", {
-				logStreamName,
-				logGroupName,
-				error
-			});
-			throw error;
-		}
-	}
-}
-/**
 * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
 *
 * @param options Configuration options for the CloudWatch Logs sink.
@@ -68,8 +21,6 @@ function getCloudWatchLogsSink(options) {
 	const flushInterval = options.flushInterval ?? 1e3;
 	const maxRetries = Math.max(options.maxRetries ?? 3, 0);
 	const retryDelay = Math.max(options.retryDelay ?? 100, 0);
-	const logStreamName = options.autoCreateLogStream && "logStreamNameTemplate" in options ? resolveLogStreamName(options.logStreamNameTemplate) : options.logStreamName;
-	const createdStreams = /* @__PURE__ */ new Set();
 	const defaultFormatter = (record) => {
 		let result = "";
 		for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) result += record.message[i];
@@ -81,7 +32,6 @@ function getCloudWatchLogsSink(options) {
 	let currentBatchSize = 0;
 	let flushTimer = null;
 	let disposed = false;
-	let flushPromise = null;
 	function scheduleFlush() {
 		if (flushInterval <= 0 || flushTimer !== null) return;
 		flushTimer = setTimeout(() => {
@@ -90,16 +40,6 @@ function getCloudWatchLogsSink(options) {
 		}, flushInterval);
 	}
 	async function flushEvents() {
-		if (logEvents.length === 0 || disposed) return;
-		if (flushPromise !== null) {
-			await flushPromise;
-			return;
-		}
-		flushPromise = doFlush();
-		await flushPromise;
-		flushPromise = null;
-	}
-	async function doFlush() {
 		if (logEvents.length === 0 || disposed) return;
 		const events = logEvents.splice(0);
 		currentBatchSize = 0;
@@ -107,14 +47,13 @@ function getCloudWatchLogsSink(options) {
 			clearTimeout(flushTimer);
 			flushTimer = null;
 		}
-		if (options.autoCreateLogStream) await ensureLogStreamExists(client, options.logGroupName, logStreamName, createdStreams);
 		await sendEventsWithRetry(events, maxRetries);
 	}
 	async function sendEventsWithRetry(events, remainingRetries) {
 		try {
 			const command = new PutLogEventsCommand({
 				logGroupName: options.logGroupName,
-				logStreamName,
+				logStreamName: options.logStreamName,
 				logEvents: events
 			});
 			await client.send(command);

package/dist/sink.js.map

@@ -1 +1 @@
-{"version":3,"file":"sink.js","names":["logStreamNameTemplate: string","client: CloudWatchLogsClient","logGroupName: string","logStreamName: string","createdStreams: Set<string>","options: CloudWatchLogsSinkOptions","defaultFormatter: TextFormatter","logEvents: InputLogEvent[]","flushTimer: ReturnType<typeof setTimeout> | null","flushPromise: Promise<void> | null","events: InputLogEvent[]","remainingRetries: number","record: LogRecord","sink: Sink & AsyncDisposable","logEvent: InputLogEvent"],"sources":["../sink.ts"],"sourcesContent":["import {\n  CloudWatchLogsClient,\n  CreateLogStreamCommand,\n  type InputLogEvent,\n  PutLogEventsCommand,\n  ResourceAlreadyExistsException,\n} from \"@aws-sdk/client-cloudwatch-logs\";\nimport {\n  getLogger,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport type { CloudWatchLogsSinkOptions } from \"./types.ts\";\n\n// AWS CloudWatch Logs PutLogEvents API limits\n// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html\nconst MAX_BATCH_SIZE_EVENTS = 10000; // Maximum 10,000 events per batch\nconst MAX_BATCH_SIZE_BYTES = 1048576; // Maximum batch size: 1 MiB (1,048,576 bytes)\nconst OVERHEAD_PER_EVENT = 26; // AWS overhead per log event: 26 bytes per event\n\n/**\n * Resolves the log stream name from template.\n * @param logStreamNameTemplate Template for generating stream names\n * @returns Resolved log stream name\n */\nfunction resolveLogStreamName(\n  logStreamNameTemplate: string,\n): string {\n  const now = new Date();\n  const year = now.getFullYear().toString();\n  const month = (now.getMonth() + 1).toString().padStart(2, \"0\");\n  const day = now.getDate().toString().padStart(2, \"0\");\n  const timestamp = now.getTime().toString();\n\n  return logStreamNameTemplate\n    .replace(/\\{YYYY\\}/g, year)\n    .replace(/\\{MM\\}/g, month)\n    .replace(/\\{DD\\}/g, day)\n    .replace(/\\{YYYY-MM-DD\\}/g, `${year}-${month}-${day}`)\n    .replace(/\\{timestamp\\}/g, timestamp);\n}\n\n/**\n * Ensures that the log stream exists, creating it if necessary.\n * @param client CloudWatch Logs client\n * @param logGroupName Log group name\n * @param logStreamName Log stream name\n * @param createdStreams Set to track already created streams\n */\nasync function ensureLogStreamExists(\n  client: CloudWatchLogsClient,\n  logGroupName: string,\n  logStreamName: string,\n  createdStreams: Set<string>,\n): Promise<void> {\n  const streamKey = `${logGroupName}/${logStreamName}`;\n\n  // If we've already created this stream, skip\n  if (createdStreams.has(streamKey)) {\n    return;\n  }\n\n  try {\n    const command = new CreateLogStreamCommand({\n      logGroupName,\n      logStreamName,\n    });\n\n    await client.send(command);\n    createdStreams.add(streamKey);\n  } catch (error) {\n    if (error instanceof ResourceAlreadyExistsException) {\n      // Stream already exists, this is fine\n      createdStreams.add(streamKey);\n    } else {\n      // Log stream creation failure to meta logger\n      const metaLogger = getLogger([\"logtape\", \"meta\", \"cloudwatch-logs\"]);\n      metaLogger.error(\n        \"Failed to create log stream {logStreamName} in group {logGroupName}: {error}\",\n        { logStreamName, logGroupName, error },\n      );\n      // Re-throw other errors\n      throw error;\n    }\n  }\n}\n\n/**\n * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.\n *\n * @param options Configuration options for the CloudWatch Logs sink.\n * @returns A sink that sends log records to CloudWatch Logs.\n * @since 1.0.0\n */\nexport function getCloudWatchLogsSink(\n  options: CloudWatchLogsSinkOptions,\n): Sink & AsyncDisposable {\n  const client = options.client ??\n    new CloudWatchLogsClient({\n      region: options.region ?? \"us-east-1\",\n      credentials: options.credentials,\n    });\n\n  const batchSize = Math.min(\n    Math.max(options.batchSize ?? 1000, 1),\n    MAX_BATCH_SIZE_EVENTS,\n  );\n  const flushInterval = options.flushInterval ?? 1000;\n  const maxRetries = Math.max(options.maxRetries ?? 3, 0);\n  const retryDelay = Math.max(options.retryDelay ?? 100, 0);\n\n  // Resolve the log stream name\n  const logStreamName =\n    options.autoCreateLogStream && \"logStreamNameTemplate\" in options\n      ? resolveLogStreamName(options.logStreamNameTemplate)\n      : options.logStreamName;\n\n  // Track created streams to avoid redundant API calls\n  const createdStreams = new Set<string>();\n\n  // Default formatter that formats message parts into a simple string\n  const defaultFormatter: TextFormatter = (record) => {\n    let result = \"\";\n    for (let i = 0; i < record.message.length; i++) {\n      if (i % 2 === 0) {\n        result += record.message[i];\n      } else {\n        result += JSON.stringify(record.message[i]);\n      }\n    }\n    return result;\n  };\n\n  const formatter = options.formatter ?? defaultFormatter;\n\n  const logEvents: InputLogEvent[] = [];\n  let currentBatchSize = 0;\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n  let flushPromise: Promise<void> | null = null;\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      if (logEvents.length > 0) {\n        void flushEvents();\n      }\n    }, flushInterval);\n  }\n\n  async function flushEvents(): Promise<void> {\n    if (logEvents.length === 0 || disposed) return;\n\n    // If there's already a flush in progress, wait for it\n    if (flushPromise !== null) {\n      await flushPromise;\n      return;\n    }\n\n    // Start a new flush operation\n    flushPromise = doFlush();\n    await flushPromise;\n    flushPromise = null;\n  }\n\n  async function doFlush(): Promise<void> {\n    if (logEvents.length === 0 || disposed) return;\n\n    const events = logEvents.splice(0);\n    currentBatchSize = 0;\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n\n    // Auto-create log stream if enabled (only once per stream)\n    if (options.autoCreateLogStream) {\n      await ensureLogStreamExists(\n        client,\n        options.logGroupName,\n        logStreamName,\n        createdStreams,\n      );\n    }\n\n    await sendEventsWithRetry(events, maxRetries);\n  }\n\n  async function sendEventsWithRetry(\n    events: InputLogEvent[],\n    remainingRetries: number,\n  ): Promise<void> {\n    try {\n      const command = new PutLogEventsCommand({\n        logGroupName: options.logGroupName,\n        logStreamName: logStreamName,\n        logEvents: events,\n      });\n\n      await client.send(command);\n    } catch (error) {\n      if (remainingRetries > 0) {\n        // Calculate exponential backoff: base, base*2, base*4, etc.\n        const attemptNumber = maxRetries - remainingRetries;\n        const delay = retryDelay * Math.pow(2, attemptNumber);\n        await new Promise((resolve) => setTimeout(resolve, delay));\n        await sendEventsWithRetry(events, remainingRetries - 1);\n      } else {\n        // Log to meta logger to avoid crashing the application\n        const metaLogger = getLogger([\"logtape\", \"meta\", \"cloudwatch-logs\"]);\n        metaLogger.error(\n          \"Failed to send log events to CloudWatch Logs after {maxRetries} retries: {error}\",\n          { maxRetries, error },\n        );\n      }\n    }\n  }\n\n  function formatLogMessage(record: LogRecord): string {\n    return formatter(record);\n  }\n\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Skip meta logger logs to prevent infinite loops\n    if (\n      record.category[0] === \"logtape\" &&\n      record.category[1] === \"meta\" &&\n      record.category[2] === \"cloudwatch-logs\"\n    ) {\n      return;\n    }\n\n    const message = formatLogMessage(record);\n    const messageBytes = new TextEncoder().encode(message).length;\n    const eventSize = messageBytes + OVERHEAD_PER_EVENT;\n\n    const logEvent: InputLogEvent = {\n      timestamp: record.timestamp,\n      message,\n    };\n\n    logEvents.push(logEvent);\n    currentBatchSize += eventSize;\n\n    const shouldFlushBySize = currentBatchSize > MAX_BATCH_SIZE_BYTES;\n    const shouldFlushByCount = logEvents.length >= batchSize;\n\n    if (shouldFlushBySize || shouldFlushByCount) {\n      void flushEvents();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  sink[Symbol.asyncDispose] = async () => {\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    await flushEvents();\n    disposed = true;\n  };\n\n  return sink;\n}\n"],"mappings":"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"}
+{"version":3,"file":"sink.js","names":["options: CloudWatchLogsSinkOptions","defaultFormatter: TextFormatter","logEvents: InputLogEvent[]","flushTimer: ReturnType<typeof setTimeout> | null","events: InputLogEvent[]","remainingRetries: number","record: LogRecord","sink: Sink & AsyncDisposable","logEvent: InputLogEvent"],"sources":["../sink.ts"],"sourcesContent":["import {\n  CloudWatchLogsClient,\n  type InputLogEvent,\n  PutLogEventsCommand,\n} from \"@aws-sdk/client-cloudwatch-logs\";\nimport {\n  getLogger,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport type { CloudWatchLogsSinkOptions } from \"./types.ts\";\n\n// AWS CloudWatch Logs PutLogEvents API limits\n// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html\nconst MAX_BATCH_SIZE_EVENTS = 10000; // Maximum 10,000 events per batch\nconst MAX_BATCH_SIZE_BYTES = 1048576; // Maximum batch size: 1 MiB (1,048,576 bytes)\nconst OVERHEAD_PER_EVENT = 26; // AWS overhead per log event: 26 bytes per event\n\n/**\n * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.\n *\n * @param options Configuration options for the CloudWatch Logs sink.\n * @returns A sink that sends log records to CloudWatch Logs.\n * @since 1.0.0\n */\nexport function getCloudWatchLogsSink(\n  options: CloudWatchLogsSinkOptions,\n): Sink & AsyncDisposable {\n  const client = options.client ??\n    new CloudWatchLogsClient({\n      region: options.region ?? \"us-east-1\",\n      credentials: options.credentials,\n    });\n\n  const batchSize = Math.min(\n    Math.max(options.batchSize ?? 1000, 1),\n    MAX_BATCH_SIZE_EVENTS,\n  );\n  const flushInterval = options.flushInterval ?? 1000;\n  const maxRetries = Math.max(options.maxRetries ?? 3, 0);\n  const retryDelay = Math.max(options.retryDelay ?? 100, 0);\n\n  // Default formatter that formats message parts into a simple string\n  const defaultFormatter: TextFormatter = (record) => {\n    let result = \"\";\n    for (let i = 0; i < record.message.length; i++) {\n      if (i % 2 === 0) {\n        result += record.message[i];\n      } else {\n        result += JSON.stringify(record.message[i]);\n      }\n    }\n    return result;\n  };\n\n  const formatter = options.formatter ?? defaultFormatter;\n\n  const logEvents: InputLogEvent[] = [];\n  let currentBatchSize = 0;\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      if (logEvents.length > 0) {\n        void flushEvents();\n      }\n    }, flushInterval);\n  }\n\n  async function flushEvents(): Promise<void> {\n    if (logEvents.length === 0 || disposed) return;\n\n    const events = logEvents.splice(0);\n    currentBatchSize = 0;\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n\n    await sendEventsWithRetry(events, maxRetries);\n  }\n\n  async function sendEventsWithRetry(\n    events: InputLogEvent[],\n    remainingRetries: number,\n  ): Promise<void> {\n    try {\n      const command = new PutLogEventsCommand({\n        logGroupName: options.logGroupName,\n        logStreamName: options.logStreamName,\n        logEvents: events,\n      });\n\n      await client.send(command);\n    } catch (error) {\n      if (remainingRetries > 0) {\n        // Calculate exponential backoff: base, base*2, base*4, etc.\n        const attemptNumber = maxRetries - remainingRetries;\n        const delay = retryDelay * Math.pow(2, attemptNumber);\n        await new Promise((resolve) => setTimeout(resolve, delay));\n        await sendEventsWithRetry(events, remainingRetries - 1);\n      } else {\n        // Log to meta logger to avoid crashing the application\n        const metaLogger = getLogger([\"logtape\", \"meta\", \"cloudwatch-logs\"]);\n        metaLogger.error(\n          \"Failed to send log events to CloudWatch Logs after {maxRetries} retries: {error}\",\n          { maxRetries, error },\n        );\n      }\n    }\n  }\n\n  function formatLogMessage(record: LogRecord): string {\n    return formatter(record);\n  }\n\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Skip meta logger logs to prevent infinite loops\n    if (\n      record.category[0] === \"logtape\" &&\n      record.category[1] === \"meta\" &&\n      record.category[2] === \"cloudwatch-logs\"\n    ) {\n      return;\n    }\n\n    const message = formatLogMessage(record);\n    const messageBytes = new TextEncoder().encode(message).length;\n    const eventSize = messageBytes + OVERHEAD_PER_EVENT;\n\n    const logEvent: InputLogEvent = {\n      timestamp: record.timestamp,\n      message,\n    };\n\n    logEvents.push(logEvent);\n    currentBatchSize += eventSize;\n\n    const shouldFlushBySize = currentBatchSize > MAX_BATCH_SIZE_BYTES;\n    const shouldFlushByCount = logEvents.length >= batchSize;\n\n    if (shouldFlushBySize || shouldFlushByCount) {\n      void flushEvents();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  sink[Symbol.asyncDispose] = async () => {\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    await flushEvents();\n    disposed = true;\n  };\n\n  return sink;\n}\n"],"mappings":";;;;AAeA,MAAM,wBAAwB;AAC9B,MAAM,uBAAuB;AAC7B,MAAM,qBAAqB;;;;;;;;AAS3B,SAAgB,sBACdA,SACwB;CACxB,MAAM,SAAS,QAAQ,UACrB,IAAI,qBAAqB;EACvB,QAAQ,QAAQ,UAAU;EAC1B,aAAa,QAAQ;CACtB;CAEH,MAAM,YAAY,KAAK,IACrB,KAAK,IAAI,QAAQ,aAAa,KAAM,EAAE,EACtC,sBACD;CACD,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,aAAa,KAAK,IAAI,QAAQ,cAAc,GAAG,EAAE;CACvD,MAAM,aAAa,KAAK,IAAI,QAAQ,cAAc,KAAK,EAAE;CAGzD,MAAMC,mBAAkC,CAAC,WAAW;EAClD,IAAI,SAAS;AACb,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,QAAQ,IACzC,KAAI,IAAI,MAAM,EACZ,WAAU,OAAO,QAAQ;MAEzB,WAAU,KAAK,UAAU,OAAO,QAAQ,GAAG;AAG/C,SAAO;CACR;CAED,MAAM,YAAY,QAAQ,aAAa;CAEvC,MAAMC,YAA6B,CAAE;CACrC,IAAI,mBAAmB;CACvB,IAAIC,aAAmD;CACvD,IAAI,WAAW;CAEf,SAAS,gBAAsB;AAC7B,MAAI,iBAAiB,KAAK,eAAe,KAAM;AAE/C,eAAa,WAAW,MAAM;AAC5B,gBAAa;AACb,OAAI,UAAU,SAAS,EACrB,CAAK,aAAa;EAErB,GAAE,cAAc;CAClB;CAED,eAAe,cAA6B;AAC1C,MAAI,UAAU,WAAW,KAAK,SAAU;EAExC,MAAM,SAAS,UAAU,OAAO,EAAE;AAClC,qBAAmB;AAEnB,MAAI,eAAe,MAAM;AACvB,gBAAa,WAAW;AACxB,gBAAa;EACd;AAED,QAAM,oBAAoB,QAAQ,WAAW;CAC9C;CAED,eAAe,oBACbC,QACAC,kBACe;AACf,MAAI;GACF,MAAM,UAAU,IAAI,oBAAoB;IACtC,cAAc,QAAQ;IACtB,eAAe,QAAQ;IACvB,WAAW;GACZ;AAED,SAAM,OAAO,KAAK,QAAQ;EAC3B,SAAQ,OAAO;AACd,OAAI,mBAAmB,GAAG;IAExB,MAAM,gBAAgB,aAAa;IACnC,MAAM,QAAQ,aAAa,KAAK,IAAI,GAAG,cAAc;AACrD,UAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,MAAM;AACzD,UAAM,oBAAoB,QAAQ,mBAAmB,EAAE;GACxD,OAAM;IAEL,MAAM,aAAa,UAAU;KAAC;KAAW;KAAQ;IAAkB,EAAC;AACpE,eAAW,MACT,oFACA;KAAE;KAAY;IAAO,EACtB;GACF;EACF;CACF;CAED,SAAS,iBAAiBC,QAA2B;AACnD,SAAO,UAAU,OAAO;CACzB;CAED,MAAMC,OAA+B,CAACD,WAAsB;AAC1D,MAAI,SAAU;AAGd,MACE,OAAO,SAAS,OAAO,aACvB,OAAO,SAAS,OAAO,UACvB,OAAO,SAAS,OAAO,kBAEvB;EAGF,MAAM,UAAU,iBAAiB,OAAO;EACxC,MAAM,eAAe,IAAI,cAAc,OAAO,QAAQ,CAAC;EACvD,MAAM,YAAY,eAAe;EAEjC,MAAME,WAA0B;GAC9B,WAAW,OAAO;GAClB;EACD;AAED,YAAU,KAAK,SAAS;AACxB,sBAAoB;EAEpB,MAAM,oBAAoB,mBAAmB;EAC7C,MAAM,qBAAqB,UAAU,UAAU;AAE/C,MAAI,qBAAqB,mBACvB,CAAK,aAAa;MAElB,gBAAe;CAElB;AAED,MAAK,OAAO,gBAAgB,YAAY;AACtC,MAAI,eAAe,MAAM;AACvB,gBAAa,WAAW;AACxB,gBAAa;EACd;AACD,QAAM,aAAa;AACnB,aAAW;CACZ;AAED,QAAO;AACR"}

package/dist/types.d.cts

@@ -7,7 +7,7 @@ import { TextFormatter } from "@logtape/logtape";
  * Options for configuring the CloudWatch Logs sink.
  * @since 1.0.0
  */
-type CloudWatchLogsSinkOptions = {
+interface CloudWatchLogsSinkOptions {
   /**
    * An existing CloudWatch Logs client instance.
    * If provided, the client will be used directly and other connection
@@ -18,6 +18,10 @@ type CloudWatchLogsSinkOptions = {
    * The name of the log group to send log events to.
    */
   readonly logGroupName: string;
+  /**
+   * The name of the log stream within the log group.
+   */
+  readonly logStreamName: string;
   /**
    * The AWS region to use when creating a new client.
    * Ignored if `client` is provided.
@@ -64,53 +68,7 @@ type CloudWatchLogsSinkOptions = {
    * @since 1.0.0
    */
   readonly formatter?: TextFormatter;
-} & ({
-  /**
-   * Whether to automatically create the log stream if it doesn't exist.
-   * When enabled, the sink will attempt to create the specified log stream
-   * before sending log events. If the stream already exists, the creation
-   * attempt will be safely ignored.
-   * @default false
-   * @since 1.1.0
-   */
-  readonly autoCreateLogStream?: false;
-  /**
-   * The name of the log stream within the log group.
-   * Required unless `logStreamNameTemplate` is provided.
-   */
-  readonly logStreamName: string;
-} | {
-  /**
-   * Whether to automatically create the log stream if it doesn't exist.
-   * When enabled, the sink will attempt to create the specified log stream
-   * before sending log events. If the stream already exists, the creation
-   * attempt will be safely ignored.
-   * @default false
-   * @since 1.1.0
-   */
-  readonly autoCreateLogStream: true;
-} & ({
-  /**
-   * The name of the log stream within the log group.
-   * Required unless `logStreamNameTemplate` is provided.
-   */
-  readonly logStreamName: string;
-} | {
-  /**
-   * Template for generating dynamic log stream names.
-   * Supports the following placeholders:
-   * - `{YYYY}`: 4-digit year
-   * - `{MM}`: 2-digit month (01-12)
-   * - `{DD}`: 2-digit day (01-31)
-   * - `{YYYY-MM-DD}`: Date in YYYY-MM-DD format
-   * - `{timestamp}`: Unix timestamp in milliseconds
-   *
-   * If provided, this will be used instead of `logStreamName`.
-   * Only used when `autoCreateLogStream` is true.
-   * @since 1.1.0
-   */
-  readonly logStreamNameTemplate: string;
-}));
+}
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { CloudWatchLogsSinkOptions };

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;AAOsB,KAPV,yBAAA,GAOU;EAAoB;AA0DJ;;;;oBA1DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0DG"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;AAMoB,UANH,yBAAA,CAMG;EAAoB;AA+DJ;;;;oBA/DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+DG"}

package/dist/types.d.ts

@@ -7,7 +7,7 @@ import { TextFormatter } from "@logtape/logtape";
  * Options for configuring the CloudWatch Logs sink.
  * @since 1.0.0
  */
-type CloudWatchLogsSinkOptions = {
+interface CloudWatchLogsSinkOptions {
   /**
    * An existing CloudWatch Logs client instance.
    * If provided, the client will be used directly and other connection
@@ -18,6 +18,10 @@ type CloudWatchLogsSinkOptions = {
    * The name of the log group to send log events to.
    */
   readonly logGroupName: string;
+  /**
+   * The name of the log stream within the log group.
+   */
+  readonly logStreamName: string;
   /**
    * The AWS region to use when creating a new client.
    * Ignored if `client` is provided.
@@ -64,53 +68,7 @@ type CloudWatchLogsSinkOptions = {
    * @since 1.0.0
    */
   readonly formatter?: TextFormatter;
-} & ({
-  /**
-   * Whether to automatically create the log stream if it doesn't exist.
-   * When enabled, the sink will attempt to create the specified log stream
-   * before sending log events. If the stream already exists, the creation
-   * attempt will be safely ignored.
-   * @default false
-   * @since 1.1.0
-   */
-  readonly autoCreateLogStream?: false;
-  /**
-   * The name of the log stream within the log group.
-   * Required unless `logStreamNameTemplate` is provided.
-   */
-  readonly logStreamName: string;
-} | {
-  /**
-   * Whether to automatically create the log stream if it doesn't exist.
-   * When enabled, the sink will attempt to create the specified log stream
-   * before sending log events. If the stream already exists, the creation
-   * attempt will be safely ignored.
-   * @default false
-   * @since 1.1.0
-   */
-  readonly autoCreateLogStream: true;
-} & ({
-  /**
-   * The name of the log stream within the log group.
-   * Required unless `logStreamNameTemplate` is provided.
-   */
-  readonly logStreamName: string;
-} | {
-  /**
-   * Template for generating dynamic log stream names.
-   * Supports the following placeholders:
-   * - `{YYYY}`: 4-digit year
-   * - `{MM}`: 2-digit month (01-12)
-   * - `{DD}`: 2-digit day (01-31)
-   * - `{YYYY-MM-DD}`: Date in YYYY-MM-DD format
-   * - `{timestamp}`: Unix timestamp in milliseconds
-   *
-   * If provided, this will be used instead of `logStreamName`.
-   * Only used when `autoCreateLogStream` is true.
-   * @since 1.1.0
-   */
-  readonly logStreamNameTemplate: string;
-}));
+}
 //# sourceMappingURL=types.d.ts.map
 //#endregion
 export { CloudWatchLogsSinkOptions };

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;AAOsB,KAPV,yBAAA,GAOU;EAAoB;AA0DJ;;;;oBA1DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA0DG"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;;AAMoB,UANH,yBAAA,CAMG;EAAoB;AA+DJ;;;;oBA/DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+DG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/cloudwatch-logs",
-  "version": "1.1.0-dev.311+6cacf678",
+  "version": "1.1.0-dev.315+fc46f65c",
   "description": "AWS CloudWatch Logs sink for LogTape",
   "keywords": [
     "logging",
@@ -46,7 +46,7 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "@logtape/logtape": "1.1.0-dev.311+6cacf678"
+    "@logtape/logtape": "1.1.0-dev.315+fc46f65c"
   },
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.0.0"

package/sink.integration.test.ts

@@ -4,7 +4,6 @@ import {
   CreateLogGroupCommand,
   CreateLogStreamCommand,
   DeleteLogGroupCommand,
-  DescribeLogStreamsCommand,
   GetLogEventsCommand,
 } from "@aws-sdk/client-cloudwatch-logs";
 import "@dotenvx/dotenvx/config";
@@ -450,213 +449,3 @@ test("Integration: CloudWatch Logs sink with JSON Lines formatter", async () =>
     }
   }
 });
-
-test("Integration: CloudWatch Logs sink with auto-create log stream", async () => {
-  const autoCreateTestLogGroupName = `/logtape/auto-create-test-${Date.now()}`;
-  const autoCreateTestLogStreamName = `auto-create-test-stream-${Date.now()}`;
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: autoCreateTestLogGroupName,
-    logStreamName: autoCreateTestLogStreamName,
-    region: process.env.AWS_REGION,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-      sessionToken: process.env.AWS_SESSION_TOKEN,
-    },
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  // Create a separate client for setup/cleanup
-  const client = new CloudWatchLogsClient({
-    region: process.env.AWS_REGION,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-      sessionToken: process.env.AWS_SESSION_TOKEN,
-    },
-  });
-
-  try {
-    // Only create log group - let sink auto-create the stream
-    await client.send(
-      new CreateLogGroupCommand({ logGroupName: autoCreateTestLogGroupName }),
-    );
-
-    // Send log record with fixed timestamp
-    const fixedTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const autoCreateTestLogRecord: LogRecord = {
-      category: ["auto-create", "test"],
-      level: "info",
-      message: [
-        "Auto-create test message at ",
-        new Date(fixedTimestamp).toISOString(),
-      ],
-      rawMessage: "Auto-create test message at {timestamp}",
-      timestamp: fixedTimestamp,
-      properties: { testId: "auto-create-001" },
-    };
-
-    sink(autoCreateTestLogRecord);
-    await sink[Symbol.asyncDispose]();
-
-    // Wait longer for AWS to process the log event
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    // Verify the log event was received by CloudWatch Logs
-    const getEventsCommand = new GetLogEventsCommand({
-      logGroupName: autoCreateTestLogGroupName,
-      logStreamName: autoCreateTestLogStreamName,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${
-        response.events?.length ?? 0
-      } auto-create events in CloudWatch Logs`,
-    );
-    if (response.events?.length === 0) {
-      console.log(
-        "No auto-create events found. This might be due to CloudWatch Logs propagation delay.",
-      );
-      // Make this test more lenient - just verify the sink worked without errors
-      return;
-    }
-
-    assertEquals(response.events?.length, 1);
-    assertEquals(
-      response.events?.[0].message,
-      'Auto-create test message at "2023-01-01T00:00:00.000Z"',
-    );
-  } finally {
-    // Always cleanup - delete log group (this also deletes log streams)
-    try {
-      await client.send(
-        new DeleteLogGroupCommand({
-          logGroupName: autoCreateTestLogGroupName,
-        }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup auto-create test log group:", error);
-    }
-  }
-});
-
-test("Integration: CloudWatch Logs sink with log stream template", async () => {
-  const templateTestLogGroupName = `/logtape/template-test-${Date.now()}`;
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: templateTestLogGroupName,
-    logStreamNameTemplate: "template-{YYYY-MM-DD}-{timestamp}",
-    region: process.env.AWS_REGION,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-      sessionToken: process.env.AWS_SESSION_TOKEN,
-    },
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  // Create a separate client for setup/cleanup
-  const client = new CloudWatchLogsClient({
-    region: process.env.AWS_REGION,
-    credentials: {
-      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
-      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
-      sessionToken: process.env.AWS_SESSION_TOKEN,
-    },
-  });
-
-  try {
-    // Only create log group - let sink auto-create the stream with template
-    await client.send(
-      new CreateLogGroupCommand({ logGroupName: templateTestLogGroupName }),
-    );
-
-    // Send log record with fixed timestamp
-    const fixedTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const templateTestLogRecord: LogRecord = {
-      category: ["template", "test"],
-      level: "info",
-      message: [
-        "Template test message at ",
-        new Date(fixedTimestamp).toISOString(),
-      ],
-      rawMessage: "Template test message at {timestamp}",
-      timestamp: fixedTimestamp,
-      properties: { testId: "template-001" },
-    };
-
-    sink(templateTestLogRecord);
-    await sink[Symbol.asyncDispose]();
-
-    // Wait longer for AWS to process the log event
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    // Since we don't know the exact generated stream name, list all streams
-    const listStreamsCommand = new DescribeLogStreamsCommand({
-      logGroupName: templateTestLogGroupName,
-    });
-
-    const streamsResponse = await client.send(listStreamsCommand);
-    console.log(
-      `Found ${
-        streamsResponse.logStreams?.length ?? 0
-      } streams in template test log group`,
-    );
-
-    // Find the stream that matches our template pattern
-    const templateStream = streamsResponse.logStreams?.find((stream) =>
-      stream.logStreamName?.match(/template-\d{4}-\d{2}-\d{2}-\d+/)
-    );
-
-    if (!templateStream) {
-      console.log(
-        "No template stream found. This might be due to CloudWatch Logs propagation delay.",
-      );
-      // Make this test more lenient - just verify the sink worked without errors
-      return;
-    }
-
-    // Verify the log event was received in the template-generated stream
-    const getEventsCommand = new GetLogEventsCommand({
-      logGroupName: templateTestLogGroupName,
-      logStreamName: templateStream.logStreamName!,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${
-        response.events?.length ?? 0
-      } template events in stream ${templateStream.logStreamName}`,
-    );
-
-    if (response.events?.length === 0) {
-      console.log(
-        "No template events found. This might be due to CloudWatch Logs propagation delay.",
-      );
-      return;
-    }
-
-    assertEquals(response.events?.length, 1);
-    assertEquals(
-      response.events?.[0].message,
-      'Template test message at "2023-01-01T00:00:00.000Z"',
-    );
-  } finally {
-    // Always cleanup - delete log group (this also deletes log streams)
-    try {
-      await client.send(
-        new DeleteLogGroupCommand({
-          logGroupName: templateTestLogGroupName,
-        }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup template test log group:", error);
-    }
-  }
-});

package/sink.test.ts

@@ -1,9 +1,7 @@
 import { suite } from "@alinea/suite";
 import {
   CloudWatchLogsClient,
-  CreateLogStreamCommand,
   PutLogEventsCommand,
-  ResourceAlreadyExistsException,
 } from "@aws-sdk/client-cloudwatch-logs";
 import type { LogRecord } from "@logtape/logtape";
 import { jsonLinesFormatter } from "@logtape/logtape";
@@ -82,11 +80,7 @@ test("getCloudWatchLogsSink() flushes when batch size is reached", async () => {
   });
 
   sink(mockLogRecord);
-  sink(mockLogRecord); // Should flush here after 2 events
-
-  // Wait a bit to ensure flush happens
-  await new Promise((resolve) => setTimeout(resolve, 10));
-
+  sink(mockLogRecord); // Should flush here
   sink(mockLogRecord); // Should be in next batch
 
   await sink[Symbol.asyncDispose](); // Should flush remaining
@@ -335,210 +329,3 @@ test("getCloudWatchLogsSink() uses default text formatter when no formatter prov
   // Should be plain text, not JSON
   assertEquals(logMessage, 'Hello, "world"!');
 });
-
-// Tests for auto-create log stream functionality
-test("getCloudWatchLogsSink() automatically creates log stream when enabled", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(CreateLogStreamCommand).length, 1);
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-
-  const createCall = cwlMock.commandCalls(CreateLogStreamCommand)[0];
-  assertEquals(createCall.args[0].input.logGroupName, "/test/log-group");
-  assertEquals(createCall.args[0].input.logStreamName, "test-stream");
-});
-
-test("getCloudWatchLogsSink() handles ResourceAlreadyExistsException gracefully", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).rejects(
-    new ResourceAlreadyExistsException({
-      message: "Log stream already exists",
-      $metadata: {},
-    }),
-  );
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "existing-stream",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  // Should still send the log event even though stream creation "failed"
-  assertEquals(cwlMock.commandCalls(CreateLogStreamCommand).length, 1);
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-});
-
-test("getCloudWatchLogsSink() caches created streams to avoid redundant calls", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  // Send multiple log events with delays to ensure separate batches
-  sink(mockLogRecord);
-  await new Promise((resolve) => setTimeout(resolve, 10));
-  sink(mockLogRecord);
-  await new Promise((resolve) => setTimeout(resolve, 10));
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  // Should only create the stream once, but send multiple events
-  assertEquals(cwlMock.commandCalls(CreateLogStreamCommand).length, 1);
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 3);
-});
-
-test("getCloudWatchLogsSink() does not create stream when autoCreateLogStream is false", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    autoCreateLogStream: false,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  // Should not attempt to create stream
-  assertEquals(cwlMock.commandCalls(CreateLogStreamCommand).length, 0);
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-});
-
-test("getCloudWatchLogsSink() supports log stream name template", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamNameTemplate: "app-{YYYY-MM-DD}",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(CreateLogStreamCommand).length, 1);
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-
-  const createCall = cwlMock.commandCalls(CreateLogStreamCommand)[0];
-  const putCall = cwlMock.commandCalls(PutLogEventsCommand)[0];
-
-  // Should use template-generated stream name
-  const streamName = createCall.args[0].input.logStreamName;
-  assertEquals(streamName?.startsWith("app-"), true);
-  assertEquals(streamName?.match(/app-\d{4}-\d{2}-\d{2}/) !== null, true);
-
-  // Both calls should use the same stream name
-  assertEquals(putCall.args[0].input.logStreamName, streamName);
-});
-
-test("getCloudWatchLogsSink() supports timestamp template", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamNameTemplate: "stream-{timestamp}",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  const createCall = cwlMock.commandCalls(CreateLogStreamCommand)[0];
-  const streamName = createCall.args[0].input.logStreamName;
-
-  assertEquals(streamName?.startsWith("stream-"), true);
-  assertEquals(streamName?.match(/stream-\d+/) !== null, true);
-});
-
-test("getCloudWatchLogsSink() supports multiple template placeholders", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamNameTemplate: "app-{YYYY}-{MM}-{DD}-{timestamp}",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  const createCall = cwlMock.commandCalls(CreateLogStreamCommand)[0];
-  const streamName = createCall.args[0].input.logStreamName;
-
-  assertEquals(streamName?.startsWith("app-"), true);
-  assertEquals(streamName?.match(/app-\d{4}-\d{2}-\d{2}-\d+/) !== null, true);
-});
-
-test("getCloudWatchLogsSink() prefers logStreamNameTemplate over logStreamName", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(CreateLogStreamCommand).resolves({});
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "ignored-stream",
-    logStreamNameTemplate: "template-{timestamp}",
-    autoCreateLogStream: true,
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  const createCall = cwlMock.commandCalls(CreateLogStreamCommand)[0];
-  const streamName = createCall.args[0].input.logStreamName;
-
-  // Should use template, not direct name
-  assertEquals(streamName?.startsWith("template-"), true);
-  assertEquals(streamName?.includes("ignored-stream"), false);
-});

package/sink.ts

@@ -1,9 +1,7 @@
 import {
   CloudWatchLogsClient,
-  CreateLogStreamCommand,
   type InputLogEvent,
   PutLogEventsCommand,
-  ResourceAlreadyExistsException,
 } from "@aws-sdk/client-cloudwatch-logs";
 import {
   getLogger,
@@ -19,73 +17,6 @@ const MAX_BATCH_SIZE_EVENTS = 10000; // Maximum 10,000 events per batch
 const MAX_BATCH_SIZE_BYTES = 1048576; // Maximum batch size: 1 MiB (1,048,576 bytes)
 const OVERHEAD_PER_EVENT = 26; // AWS overhead per log event: 26 bytes per event
 
-/**
- * Resolves the log stream name from template.
- * @param logStreamNameTemplate Template for generating stream names
- * @returns Resolved log stream name
- */
-function resolveLogStreamName(
-  logStreamNameTemplate: string,
-): string {
-  const now = new Date();
-  const year = now.getFullYear().toString();
-  const month = (now.getMonth() + 1).toString().padStart(2, "0");
-  const day = now.getDate().toString().padStart(2, "0");
-  const timestamp = now.getTime().toString();
-
-  return logStreamNameTemplate
-    .replace(/\{YYYY\}/g, year)
-    .replace(/\{MM\}/g, month)
-    .replace(/\{DD\}/g, day)
-    .replace(/\{YYYY-MM-DD\}/g, `${year}-${month}-${day}`)
-    .replace(/\{timestamp\}/g, timestamp);
-}
-
-/**
- * Ensures that the log stream exists, creating it if necessary.
- * @param client CloudWatch Logs client
- * @param logGroupName Log group name
- * @param logStreamName Log stream name
- * @param createdStreams Set to track already created streams
- */
-async function ensureLogStreamExists(
-  client: CloudWatchLogsClient,
-  logGroupName: string,
-  logStreamName: string,
-  createdStreams: Set<string>,
-): Promise<void> {
-  const streamKey = `${logGroupName}/${logStreamName}`;
-
-  // If we've already created this stream, skip
-  if (createdStreams.has(streamKey)) {
-    return;
-  }
-
-  try {
-    const command = new CreateLogStreamCommand({
-      logGroupName,
-      logStreamName,
-    });
-
-    await client.send(command);
-    createdStreams.add(streamKey);
-  } catch (error) {
-    if (error instanceof ResourceAlreadyExistsException) {
-      // Stream already exists, this is fine
-      createdStreams.add(streamKey);
-    } else {
-      // Log stream creation failure to meta logger
-      const metaLogger = getLogger(["logtape", "meta", "cloudwatch-logs"]);
-      metaLogger.error(
-        "Failed to create log stream {logStreamName} in group {logGroupName}: {error}",
-        { logStreamName, logGroupName, error },
-      );
-      // Re-throw other errors
-      throw error;
-    }
-  }
-}
-
 /**
  * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
  *
@@ -110,15 +41,6 @@ export function getCloudWatchLogsSink(
   const maxRetries = Math.max(options.maxRetries ?? 3, 0);
   const retryDelay = Math.max(options.retryDelay ?? 100, 0);
 
-  // Resolve the log stream name
-  const logStreamName =
-    options.autoCreateLogStream && "logStreamNameTemplate" in options
-      ? resolveLogStreamName(options.logStreamNameTemplate)
-      : options.logStreamName;
-
-  // Track created streams to avoid redundant API calls
-  const createdStreams = new Set<string>();
-
   // Default formatter that formats message parts into a simple string
   const defaultFormatter: TextFormatter = (record) => {
     let result = "";
@@ -138,7 +60,6 @@ export function getCloudWatchLogsSink(
   let currentBatchSize = 0;
   let flushTimer: ReturnType<typeof setTimeout> | null = null;
   let disposed = false;
-  let flushPromise: Promise<void> | null = null;
 
   function scheduleFlush(): void {
     if (flushInterval <= 0 || flushTimer !== null) return;
@@ -154,21 +75,6 @@ export function getCloudWatchLogsSink(
   async function flushEvents(): Promise<void> {
     if (logEvents.length === 0 || disposed) return;
 
-    // If there's already a flush in progress, wait for it
-    if (flushPromise !== null) {
-      await flushPromise;
-      return;
-    }
-
-    // Start a new flush operation
-    flushPromise = doFlush();
-    await flushPromise;
-    flushPromise = null;
-  }
-
-  async function doFlush(): Promise<void> {
-    if (logEvents.length === 0 || disposed) return;
-
     const events = logEvents.splice(0);
     currentBatchSize = 0;
 
@@ -177,16 +83,6 @@ export function getCloudWatchLogsSink(
       flushTimer = null;
     }
 
-    // Auto-create log stream if enabled (only once per stream)
-    if (options.autoCreateLogStream) {
-      await ensureLogStreamExists(
-        client,
-        options.logGroupName,
-        logStreamName,
-        createdStreams,
-      );
-    }
-
     await sendEventsWithRetry(events, maxRetries);
   }
 
@@ -197,7 +93,7 @@ export function getCloudWatchLogsSink(
     try {
       const command = new PutLogEventsCommand({
         logGroupName: options.logGroupName,
-        logStreamName: logStreamName,
+        logStreamName: options.logStreamName,
         logEvents: events,
       });
 

package/types.ts

@@ -5,122 +5,74 @@ import type { TextFormatter } from "@logtape/logtape";
  * Options for configuring the CloudWatch Logs sink.
  * @since 1.0.0
  */
-export type CloudWatchLogsSinkOptions =
-  & {
-    /**
-     * An existing CloudWatch Logs client instance.
-     * If provided, the client will be used directly and other connection
-     * options (region, credentials) will be ignored.
-     */
-    readonly client?: CloudWatchLogsClient;
+export interface CloudWatchLogsSinkOptions {
+  /**
+   * An existing CloudWatch Logs client instance.
+   * If provided, the client will be used directly and other connection
+   * options (region, credentials) will be ignored.
+   */
+  readonly client?: CloudWatchLogsClient;
 
-    /**
-     * The name of the log group to send log events to.
-     */
-    readonly logGroupName: string;
+  /**
+   * The name of the log group to send log events to.
+   */
+  readonly logGroupName: string;
 
-    /**
-     * The AWS region to use when creating a new client.
-     * Ignored if `client` is provided.
-     * @default "us-east-1"
-     */
-    readonly region?: string;
+  /**
+   * The name of the log stream within the log group.
+   */
+  readonly logStreamName: string;
 
-    /**
-     * AWS credentials to use when creating a new client.
-     * Ignored if `client` is provided.
-     * If not provided, the AWS SDK will use default credential resolution.
-     */
-    readonly credentials?: {
-      readonly accessKeyId: string;
-      readonly secretAccessKey: string;
-      readonly sessionToken?: string;
-    };
+  /**
+   * The AWS region to use when creating a new client.
+   * Ignored if `client` is provided.
+   * @default "us-east-1"
+   */
+  readonly region?: string;
 
-    /**
-     * Maximum number of log events to batch before sending to CloudWatch.
-     * Must be between 1 and 10,000.
-     * @default 1000
-     */
-    readonly batchSize?: number;
+  /**
+   * AWS credentials to use when creating a new client.
+   * Ignored if `client` is provided.
+   * If not provided, the AWS SDK will use default credential resolution.
+   */
+  readonly credentials?: {
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly sessionToken?: string;
+  };
 
-    /**
-     * Maximum time in milliseconds to wait before flushing buffered log events.
-     * Set to 0 or negative to disable time-based flushing.
-     * @default 1000
-     */
-    readonly flushInterval?: number;
+  /**
+   * Maximum number of log events to batch before sending to CloudWatch.
+   * Must be between 1 and 10,000.
+   * @default 1000
+   */
+  readonly batchSize?: number;
 
-    /**
-     * Maximum number of retry attempts for failed requests.
-     * @default 3
-     */
-    readonly maxRetries?: number;
+  /**
+   * Maximum time in milliseconds to wait before flushing buffered log events.
+   * Set to 0 or negative to disable time-based flushing.
+   * @default 1000
+   */
+  readonly flushInterval?: number;
 
-    /**
-     * Initial delay in milliseconds for exponential backoff retry strategy.
-     * @default 100
-     */
-    readonly retryDelay?: number;
+  /**
+   * Maximum number of retry attempts for failed requests.
+   * @default 3
+   */
+  readonly maxRetries?: number;
 
-    /**
-     * Text formatter to use for formatting log records before sending to CloudWatch Logs.
-     * If not provided, defaults to a simple text formatter.
-     * Use `jsonLinesFormatter()` from "@logtape/logtape" for JSON structured logging
-     * to enable powerful CloudWatch Logs Insights querying capabilities.
-     * @since 1.0.0
-     */
-    readonly formatter?: TextFormatter;
-  }
-  & (
-    | {
-      /**
-       * Whether to automatically create the log stream if it doesn't exist.
-       * When enabled, the sink will attempt to create the specified log stream
-       * before sending log events. If the stream already exists, the creation
-       * attempt will be safely ignored.
-       * @default false
-       * @since 1.1.0
-       */
-      readonly autoCreateLogStream?: false;
+  /**
+   * Initial delay in milliseconds for exponential backoff retry strategy.
+   * @default 100
+   */
+  readonly retryDelay?: number;
 
-      /**
-       * The name of the log stream within the log group.
-       * Required unless `logStreamNameTemplate` is provided.
-       */
-      readonly logStreamName: string;
-    }
-    | {
-      /**
-       * Whether to automatically create the log stream if it doesn't exist.
-       * When enabled, the sink will attempt to create the specified log stream
-       * before sending log events. If the stream already exists, the creation
-       * attempt will be safely ignored.
-       * @default false
-       * @since 1.1.0
-       */
-      readonly autoCreateLogStream: true;
-    }
-      & ({
-        /**
-         * The name of the log stream within the log group.
-         * Required unless `logStreamNameTemplate` is provided.
-         */
-        readonly logStreamName: string;
-      } | {
-        /**
-         * Template for generating dynamic log stream names.
-         * Supports the following placeholders:
-         * - `{YYYY}`: 4-digit year
-         * - `{MM}`: 2-digit month (01-12)
-         * - `{DD}`: 2-digit day (01-31)
-         * - `{YYYY-MM-DD}`: Date in YYYY-MM-DD format
-         * - `{timestamp}`: Unix timestamp in milliseconds
-         *
-         * If provided, this will be used instead of `logStreamName`.
-         * Only used when `autoCreateLogStream` is true.
-         * @since 1.1.0
-         */
-        readonly logStreamNameTemplate: string;
-      })
-  );
+  /**
+   * Text formatter to use for formatting log records before sending to CloudWatch Logs.
+   * If not provided, defaults to a simple text formatter.
+   * Use `jsonLinesFormatter()` from "@logtape/logtape" for JSON structured logging
+   * to enable powerful CloudWatch Logs Insights querying capabilities.
+   * @since 1.0.0
+   */
+  readonly formatter?: TextFormatter;
+}