@logtape/cloudwatch-logs 1.0.0-dev.211

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,132 @@
+@logtape/cloudwatch-logs: LogTape AWS CloudWatch Logs Sink
+==========================================================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+[![GitHub Actions][GitHub Actions badge]][GitHub Actions]
+
+This package provides an [AWS CloudWatch Logs] sink for [LogTape]. It allows you to
+send your LogTape logs directly to AWS CloudWatch Logs with intelligent batching
+and error handling.
+
+[JSR]: https://jsr.io/@logtape/cloudwatch-logs
+[JSR badge]: https://jsr.io/badges/@logtape/cloudwatch-logs
+[npm]: https://www.npmjs.com/package/@logtape/cloudwatch-logs
+[npm badge]: https://img.shields.io/npm/v/@logtape/cloudwatch-logs?logo=npm
+[GitHub Actions]: https://github.com/dahlia/logtape/actions/workflows/main.yaml
+[GitHub Actions badge]: https://github.com/dahlia/logtape/actions/workflows/main.yaml/badge.svg
+[AWS CloudWatch Logs]: https://aws.amazon.com/cloudwatch/
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+The package is available on [JSR] and [npm].
+
+~~~~ bash
+deno add jsr:@logtape/cloudwatch-logs  # for Deno
+npm  add     @logtape/cloudwatch-logs  # for npm
+pnpm add     @logtape/cloudwatch-logs  # for pnpm
+yarn add     @logtape/cloudwatch-logs  # for Yarn
+bun  add     @logtape/cloudwatch-logs  # for Bun
+~~~~
+
+
+Usage
+-----
+
+The quickest way to get started is to use the `getCloudWatchLogsSink()` function
+with your log group and stream names:
+
+~~~~ typescript
+import { configure } from "@logtape/logtape";
+import { getCloudWatchLogsSink } from "@logtape/cloudwatch-logs";
+
+await configure({
+  sinks: {
+    cloudwatch: getCloudWatchLogsSink({
+      logGroupName: "/aws/lambda/my-function",
+      logStreamName: "my-stream",
+      region: "us-east-1",
+    }),
+  },
+  loggers: [
+    { category: [], sinks: ["cloudwatch"], lowestLevel: "info" },
+  ],
+});
+~~~~
+
+You can also pass an existing CloudWatch Logs client:
+
+~~~~ typescript
+import { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
+import { configure } from "@logtape/logtape";
+import { getCloudWatchLogsSink } from "@logtape/cloudwatch-logs";
+
+const client = new CloudWatchLogsClient({ region: "us-east-1" });
+
+await configure({
+  sinks: {
+    cloudwatch: getCloudWatchLogsSink({
+      client,
+      logGroupName: "/aws/lambda/my-function",
+      logStreamName: "my-stream",
+    }),
+  },
+  loggers: [
+    { category: [], sinks: ["cloudwatch"], lowestLevel: "info" },
+  ],
+});
+~~~~
+
+
+Testing
+-------
+
+The package includes both unit tests and integration tests. Unit tests use
+mocked AWS SDK calls and can be run without AWS credentials:
+
+~~~~ bash
+deno task test
+~~~~
+
+Integration tests require real AWS credentials and will create temporary log
+groups and streams in your AWS account:
+
+~~~~ bash
+export AWS_ACCESS_KEY_ID="your-access-key"
+export AWS_SECRET_ACCESS_KEY="your-secret-key"
+export AWS_REGION="us-east-1"
+deno task test
+~~~~
+
+Integration tests will automatically skip if AWS credentials are not provided.
+
+> [!WARNING]
+> Integration tests may incur small AWS charges for CloudWatch Logs usage.
+> Test resources are automatically cleaned up after each test.
+
+
+Required IAM permissions
+------------------------
+
+To use this sink, your AWS credentials need the following CloudWatch Logs
+permissions:
+
+~~~~ json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "logs:CreateLogGroup",
+        "logs:CreateLogStream",
+        "logs:PutLogEvents"
+      ],
+      "Resource": "arn:aws:logs:*:*:*"
+    }
+  ]
+}
+~~~~

package/deno.json

@@ -0,0 +1,36 @@
+{
+  "name": "@logtape/cloudwatch-logs",
+  "version": "1.0.0-dev.211+7d3e5fdb",
+  "license": "MIT",
+  "exports": "./mod.ts",
+  "exclude": [
+    "./dist/"
+  ],
+  "imports": {
+    "@aws-sdk/client-cloudwatch-logs": "npm:@aws-sdk/client-cloudwatch-logs@^3.0.0",
+    "@dotenvx/dotenvx": "npm:@dotenvx/dotenvx@^1.44.2"
+  },
+  "tasks": {
+    "build": "pnpm build",
+    "test": "deno test --allow-read --allow-net --allow-sys --allow-env",
+    "test:node": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "node --experimental-transform-types --test"
+    },
+    "test:bun": {
+      "dependencies": [
+        "build"
+      ],
+      "command": "bun test --timeout=10000"
+    },
+    "test-all": {
+      "dependencies": [
+        "test",
+        "test:node",
+        "test:bun"
+      ]
+    }
+  }
+}

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,3 @@
+const require_sink = require('./sink.cjs');
+
+exports.getCloudWatchLogsSink = require_sink.getCloudWatchLogsSink;

package/dist/mod.d.cts

@@ -0,0 +1,3 @@
+import { CloudWatchLogsSinkOptions } from "./types.cjs";
+import { getCloudWatchLogsSink } from "./sink.cjs";
+export { CloudWatchLogsSinkOptions, getCloudWatchLogsSink };

package/dist/mod.d.ts

@@ -0,0 +1,3 @@
+import { CloudWatchLogsSinkOptions } from "./types.js";
+import { getCloudWatchLogsSink } from "./sink.js";
+export { CloudWatchLogsSinkOptions, getCloudWatchLogsSink };

package/dist/mod.js

@@ -0,0 +1,3 @@
+import { getCloudWatchLogsSink } from "./sink.js";
+
+export { getCloudWatchLogsSink };

package/dist/sink.cjs

@@ -0,0 +1,98 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __aws_sdk_client_cloudwatch_logs = require_rolldown_runtime.__toESM(require("@aws-sdk/client-cloudwatch-logs"));
+
+//#region sink.ts
+/**
+* Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
+*
+* @param options Configuration options for the CloudWatch Logs sink.
+* @returns A sink that sends log records to CloudWatch Logs.
+* @since 1.0.0
+*/
+function getCloudWatchLogsSink(options) {
+	const client = options.client ?? new __aws_sdk_client_cloudwatch_logs.CloudWatchLogsClient({
+		region: options.region ?? "us-east-1",
+		credentials: options.credentials
+	});
+	const batchSize = Math.min(Math.max(options.batchSize ?? 1e3, 1), 1e4);
+	const flushInterval = options.flushInterval ?? 1e3;
+	const maxRetries = Math.max(options.maxRetries ?? 3, 0);
+	const retryDelay = Math.max(options.retryDelay ?? 100, 0);
+	const defaultFormatter = (record) => {
+		let result = "";
+		for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) result += record.message[i];
+		else result += JSON.stringify(record.message[i]);
+		return result;
+	};
+	const formatter = options.formatter ?? defaultFormatter;
+	const logEvents = [];
+	let currentBatchSize = 0;
+	let flushTimer = null;
+	let disposed = false;
+	const OVERHEAD_PER_EVENT = 26;
+	const MAX_BATCH_SIZE_BYTES = 1048576;
+	function scheduleFlush() {
+		if (flushInterval <= 0 || flushTimer !== null) return;
+		flushTimer = setTimeout(() => {
+			flushTimer = null;
+			if (logEvents.length > 0) flushEvents();
+		}, flushInterval);
+	}
+	async function flushEvents() {
+		if (logEvents.length === 0 || disposed) return;
+		const events = logEvents.splice(0);
+		currentBatchSize = 0;
+		if (flushTimer !== null) {
+			clearTimeout(flushTimer);
+			flushTimer = null;
+		}
+		await sendEventsWithRetry(events, maxRetries);
+	}
+	async function sendEventsWithRetry(events, remainingRetries) {
+		try {
+			const command = new __aws_sdk_client_cloudwatch_logs.PutLogEventsCommand({
+				logGroupName: options.logGroupName,
+				logStreamName: options.logStreamName,
+				logEvents: events
+			});
+			await client.send(command);
+		} catch (error) {
+			if (remainingRetries > 0) {
+				const delay = retryDelay * Math.pow(2, maxRetries - remainingRetries);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				await sendEventsWithRetry(events, remainingRetries - 1);
+			} else console.error("Failed to send log events to CloudWatch Logs:", error);
+		}
+	}
+	function formatLogMessage(record) {
+		return formatter(record);
+	}
+	const sink = (record) => {
+		if (disposed) return;
+		const message = formatLogMessage(record);
+		const messageBytes = new TextEncoder().encode(message).length;
+		const eventSize = messageBytes + OVERHEAD_PER_EVENT;
+		const logEvent = {
+			timestamp: record.timestamp,
+			message
+		};
+		logEvents.push(logEvent);
+		currentBatchSize += eventSize;
+		const shouldFlushBySize = currentBatchSize > MAX_BATCH_SIZE_BYTES;
+		const shouldFlushByCount = logEvents.length >= batchSize;
+		if (shouldFlushBySize || shouldFlushByCount) flushEvents();
+		else scheduleFlush();
+	};
+	sink[Symbol.asyncDispose] = async () => {
+		if (flushTimer !== null) {
+			clearTimeout(flushTimer);
+			flushTimer = null;
+		}
+		await flushEvents();
+		disposed = true;
+	};
+	return sink;
+}
+
+//#endregion
+exports.getCloudWatchLogsSink = getCloudWatchLogsSink;

package/dist/sink.d.cts

@@ -0,0 +1,18 @@
+import { CloudWatchLogsSinkOptions } from "./types.cjs";
+import { Sink } from "@logtape/logtape";
+
+//#region sink.d.ts
+
+/**
+ * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
+ *
+ * @param options Configuration options for the CloudWatch Logs sink.
+ * @returns A sink that sends log records to CloudWatch Logs.
+ * @since 1.0.0
+ */
+declare function getCloudWatchLogsSink(options: CloudWatchLogsSinkOptions): Sink & AsyncDisposable;
+//# sourceMappingURL=sink.d.ts.map
+
+//#endregion
+export { getCloudWatchLogsSink };
+//# sourceMappingURL=sink.d.cts.map

package/dist/sink.d.cts.map

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

package/dist/sink.d.ts

@@ -0,0 +1,18 @@
+import { CloudWatchLogsSinkOptions } from "./types.js";
+import { Sink } from "@logtape/logtape";
+
+//#region sink.d.ts
+
+/**
+ * Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
+ *
+ * @param options Configuration options for the CloudWatch Logs sink.
+ * @returns A sink that sends log records to CloudWatch Logs.
+ * @since 1.0.0
+ */
+declare function getCloudWatchLogsSink(options: CloudWatchLogsSinkOptions): Sink & AsyncDisposable;
+//# sourceMappingURL=sink.d.ts.map
+
+//#endregion
+export { getCloudWatchLogsSink };
+//# sourceMappingURL=sink.d.ts.map

package/dist/sink.d.ts.map

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

package/dist/sink.js

@@ -0,0 +1,98 @@
+import { CloudWatchLogsClient, PutLogEventsCommand } from "@aws-sdk/client-cloudwatch-logs";
+
+//#region sink.ts
+/**
+* Gets a CloudWatch Logs sink that sends log records to AWS CloudWatch Logs.
+*
+* @param options Configuration options for the CloudWatch Logs sink.
+* @returns A sink that sends log records to CloudWatch Logs.
+* @since 1.0.0
+*/
+function getCloudWatchLogsSink(options) {
+	const client = options.client ?? new CloudWatchLogsClient({
+		region: options.region ?? "us-east-1",
+		credentials: options.credentials
+	});
+	const batchSize = Math.min(Math.max(options.batchSize ?? 1e3, 1), 1e4);
+	const flushInterval = options.flushInterval ?? 1e3;
+	const maxRetries = Math.max(options.maxRetries ?? 3, 0);
+	const retryDelay = Math.max(options.retryDelay ?? 100, 0);
+	const defaultFormatter = (record) => {
+		let result = "";
+		for (let i = 0; i < record.message.length; i++) if (i % 2 === 0) result += record.message[i];
+		else result += JSON.stringify(record.message[i]);
+		return result;
+	};
+	const formatter = options.formatter ?? defaultFormatter;
+	const logEvents = [];
+	let currentBatchSize = 0;
+	let flushTimer = null;
+	let disposed = false;
+	const OVERHEAD_PER_EVENT = 26;
+	const MAX_BATCH_SIZE_BYTES = 1048576;
+	function scheduleFlush() {
+		if (flushInterval <= 0 || flushTimer !== null) return;
+		flushTimer = setTimeout(() => {
+			flushTimer = null;
+			if (logEvents.length > 0) flushEvents();
+		}, flushInterval);
+	}
+	async function flushEvents() {
+		if (logEvents.length === 0 || disposed) return;
+		const events = logEvents.splice(0);
+		currentBatchSize = 0;
+		if (flushTimer !== null) {
+			clearTimeout(flushTimer);
+			flushTimer = null;
+		}
+		await sendEventsWithRetry(events, maxRetries);
+	}
+	async function sendEventsWithRetry(events, remainingRetries) {
+		try {
+			const command = new PutLogEventsCommand({
+				logGroupName: options.logGroupName,
+				logStreamName: options.logStreamName,
+				logEvents: events
+			});
+			await client.send(command);
+		} catch (error) {
+			if (remainingRetries > 0) {
+				const delay = retryDelay * Math.pow(2, maxRetries - remainingRetries);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				await sendEventsWithRetry(events, remainingRetries - 1);
+			} else console.error("Failed to send log events to CloudWatch Logs:", error);
+		}
+	}
+	function formatLogMessage(record) {
+		return formatter(record);
+	}
+	const sink = (record) => {
+		if (disposed) return;
+		const message = formatLogMessage(record);
+		const messageBytes = new TextEncoder().encode(message).length;
+		const eventSize = messageBytes + OVERHEAD_PER_EVENT;
+		const logEvent = {
+			timestamp: record.timestamp,
+			message
+		};
+		logEvents.push(logEvent);
+		currentBatchSize += eventSize;
+		const shouldFlushBySize = currentBatchSize > MAX_BATCH_SIZE_BYTES;
+		const shouldFlushByCount = logEvents.length >= batchSize;
+		if (shouldFlushBySize || shouldFlushByCount) flushEvents();
+		else scheduleFlush();
+	};
+	sink[Symbol.asyncDispose] = async () => {
+		if (flushTimer !== null) {
+			clearTimeout(flushTimer);
+			flushTimer = null;
+		}
+		await flushEvents();
+		disposed = true;
+	};
+	return sink;
+}
+
+//#endregion
+export { getCloudWatchLogsSink };
+//# sourceMappingURL=sink.js.map

package/dist/sink.js.map

@@ -0,0 +1 @@
+{"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 type { LogRecord, Sink, TextFormatter } from \"@logtape/logtape\";\nimport type { CloudWatchLogsSinkOptions } from \"./types.ts\";\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(Math.max(options.batchSize ?? 1000, 1), 10000);\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  const OVERHEAD_PER_EVENT = 26; // AWS overhead per log event\n  const MAX_BATCH_SIZE_BYTES = 1048576; // 1 MiB\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        const delay = retryDelay * Math.pow(2, maxRetries - remainingRetries);\n        await new Promise((resolve) => setTimeout(resolve, delay));\n        await sendEventsWithRetry(events, remainingRetries - 1);\n      } else {\n        console.error(\"Failed to send log events to CloudWatch Logs:\", error);\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    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,SAAgB,sBACdA,SACwB;CACxB,MAAM,SAAS,QAAQ,UACrB,IAAI,qBAAqB;EACvB,QAAQ,QAAQ,UAAU;EAC1B,aAAa,QAAQ;CACtB;CAEH,MAAM,YAAY,KAAK,IAAI,KAAK,IAAI,QAAQ,aAAa,KAAM,EAAE,EAAE,IAAM;CACzE,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,MAAM,qBAAqB;CAC3B,MAAM,uBAAuB;CAE7B,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;IACxB,MAAM,QAAQ,aAAa,KAAK,IAAI,GAAG,aAAa,iBAAiB;AACrE,UAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,MAAM;AACzD,UAAM,oBAAoB,QAAQ,mBAAmB,EAAE;GACxD,MACC,SAAQ,MAAM,iDAAiD,MAAM;EAExE;CACF;CAED,SAAS,iBAAiBC,QAA2B;AACnD,SAAO,UAAU,OAAO;CACzB;CAED,MAAMC,OAA+B,CAACD,WAAsB;AAC1D,MAAI,SAAU;EAEd,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

@@ -0,0 +1,75 @@
+import { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
+import { TextFormatter } from "@logtape/logtape";
+
+//#region types.d.ts
+
+/**
+ * Options for configuring the CloudWatch Logs sink.
+ * @since 1.0.0
+ */
+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 stream within the log group.
+   */
+  readonly logStreamName: string;
+  /**
+   * The AWS region to use when creating a new client.
+   * Ignored if `client` is provided.
+   * @default "us-east-1"
+   */
+  readonly region?: 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;
+  };
+  /**
+   * Maximum number of log events to batch before sending to CloudWatch.
+   * Must be between 1 and 10,000.
+   * @default 1000
+   */
+  readonly batchSize?: 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;
+  /**
+   * Maximum number of retry attempts for failed requests.
+   * @default 3
+   */
+  readonly maxRetries?: number;
+  /**
+   * Initial delay in milliseconds for exponential backoff retry strategy.
+   * @default 100
+   */
+  readonly retryDelay?: 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;
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+export { CloudWatchLogsSinkOptions };
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,75 @@
+import { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
+import { TextFormatter } from "@logtape/logtape";
+
+//#region types.d.ts
+
+/**
+ * Options for configuring the CloudWatch Logs sink.
+ * @since 1.0.0
+ */
+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 stream within the log group.
+   */
+  readonly logStreamName: string;
+  /**
+   * The AWS region to use when creating a new client.
+   * Ignored if `client` is provided.
+   * @default "us-east-1"
+   */
+  readonly region?: 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;
+  };
+  /**
+   * Maximum number of log events to batch before sending to CloudWatch.
+   * Must be between 1 and 10,000.
+   * @default 1000
+   */
+  readonly batchSize?: 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;
+  /**
+   * Maximum number of retry attempts for failed requests.
+   * @default 3
+   */
+  readonly maxRetries?: number;
+  /**
+   * Initial delay in milliseconds for exponential backoff retry strategy.
+   * @default 100
+   */
+  readonly retryDelay?: 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;
+}
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+export { CloudWatchLogsSinkOptions };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"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/mod.ts

@@ -0,0 +1,2 @@
+export type { CloudWatchLogsSinkOptions } from "./types.ts";
+export { getCloudWatchLogsSink } from "./sink.ts";