@logtape/cloudwatch-logs 1.4.0-dev.408 → 1.4.0-dev.413

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/cloudwatch-logs",
-  "version": "1.4.0-dev.408+3fd750bb",
+  "version": "1.4.0-dev.413+1097da33",
   "description": "AWS CloudWatch Logs sink for LogTape",
   "keywords": [
     "logging",
@@ -45,8 +45,11 @@
     "./package.json": "./package.json"
   },
   "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
-    "@logtape/logtape": "^1.4.0-dev.408+3fd750bb"
+    "@logtape/logtape": "^1.4.0-dev.413+1097da33"
   },
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.0.0"

package/deno.json

@@ -1,36 +0,0 @@
-{
-  "name": "@logtape/cloudwatch-logs",
-  "version": "1.4.0-dev.408+3fd750bb",
-  "license": "MIT",
-  "exports": "./src/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/src/mod.ts

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

package/src/sink.integration.test.ts

@@ -1,451 +0,0 @@
-import { suite } from "@alinea/suite";
-import {
-  CloudWatchLogsClient,
-  CreateLogGroupCommand,
-  CreateLogStreamCommand,
-  DeleteLogGroupCommand,
-  GetLogEventsCommand,
-} from "@aws-sdk/client-cloudwatch-logs";
-import "@dotenvx/dotenvx/config";
-import type { LogRecord } from "@logtape/logtape";
-import { jsonLinesFormatter } from "@logtape/logtape";
-import { assertEquals, assertInstanceOf } from "@std/assert";
-import process from "node:process";
-import { getCloudWatchLogsSink } from "./sink.ts";
-
-type Describe = (name: string, run: () => void | Promise<void>) => void;
-
-let test: Describe & { skip?: Describe } = suite(import.meta);
-
-// Skip integration tests unless AWS credentials are provided
-// Also skip on Bun due to AWS SDK response parsing issues
-const skipIntegrationTests = !process.env.AWS_ACCESS_KEY_ID ||
-  !process.env.AWS_SECRET_ACCESS_KEY ||
-  !process.env.AWS_REGION ||
-  ("Bun" in globalThis);
-
-if (skipIntegrationTests) {
-  if ("Bun" in globalThis) {
-    console.warn(
-      "⚠️  Skipping CloudWatch Logs integration tests on Bun runtime due to AWS SDK response parsing issues.",
-    );
-  } else {
-    console.warn(
-      "⚠️  Skipping CloudWatch Logs integration tests. " +
-        "Set AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_REGION " +
-        "environment variables to run integration tests.",
-    );
-  }
-  test = test.skip!;
-}
-
-const testLogGroupName = `/logtape/integration-test-${Date.now()}`;
-const testLogStreamName = `test-stream-${Date.now()}`;
-
-test("Integration: CloudWatch Logs sink with real AWS service", async () => {
-  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 {
-    // Create log group and stream for testing
-    try {
-      await client.send(
-        new CreateLogGroupCommand({ logGroupName: testLogGroupName }),
-      );
-    } catch (error) {
-      // Log group might already exist, ignore ResourceAlreadyExistsException
-      if (
-        !(error instanceof Error) ||
-        !("name" in error) ||
-        error.name !== "ResourceAlreadyExistsException"
-      ) {
-        throw error;
-      }
-    }
-
-    await client.send(
-      new CreateLogStreamCommand({
-        logGroupName: testLogGroupName,
-        logStreamName: testLogStreamName,
-      }),
-    );
-
-    const sink = getCloudWatchLogsSink({
-      client,
-      logGroupName: testLogGroupName,
-      logStreamName: testLogStreamName,
-      batchSize: 1,
-      flushInterval: 0,
-    });
-
-    // Create a fixed log record to avoid timestamp flakiness
-    const fixedTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const testLogRecord: LogRecord = {
-      category: ["integration", "test"],
-      level: "info",
-      message: [
-        "Integration test message at ",
-        new Date(fixedTimestamp).toISOString(),
-      ],
-      rawMessage: "Integration test message at {timestamp}",
-      timestamp: fixedTimestamp,
-      properties: { testId: "integration-001" },
-    };
-
-    // Send log record
-    sink(testLogRecord);
-    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: testLogGroupName,
-      logStreamName: testLogStreamName,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${response.events?.length ?? 0} events in CloudWatch Logs`,
-    );
-    if (response.events?.length === 0) {
-      console.log(
-        "No 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,
-      'Integration 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: testLogGroupName }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup test log group:", error);
-    }
-  }
-});
-
-test("Integration: CloudWatch Logs sink with batch processing", async () => {
-  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,
-    },
-  });
-
-  const batchTestLogGroupName = `/logtape/batch-test-${Date.now()}`;
-  const batchTestLogStreamName = `batch-test-stream-${Date.now()}`;
-
-  try {
-    // Create log group and stream for testing
-    await client.send(
-      new CreateLogGroupCommand({ logGroupName: batchTestLogGroupName }),
-    );
-
-    await client.send(
-      new CreateLogStreamCommand({
-        logGroupName: batchTestLogGroupName,
-        logStreamName: batchTestLogStreamName,
-      }),
-    );
-
-    const sink = getCloudWatchLogsSink({
-      client,
-      logGroupName: batchTestLogGroupName,
-      logStreamName: batchTestLogStreamName,
-      batchSize: 3,
-      flushInterval: 100,
-    });
-
-    // Send multiple log records with fixed timestamps
-    const baseTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const logRecords = Array.from({ length: 5 }, (_, i) => ({
-      category: ["batch", "test"],
-      level: "info" as const,
-      message: [
-        `Batch test message ${i + 1} at `,
-        new Date(baseTimestamp + i * 1000).toISOString(),
-      ],
-      rawMessage: `Batch test message ${i + 1} at {timestamp}`,
-      timestamp: baseTimestamp + i * 1000,
-      properties: { batchId: "batch-001", index: i },
-    }));
-
-    logRecords.forEach((record) => sink(record));
-    await sink[Symbol.asyncDispose]();
-
-    // Wait longer for AWS to process the log events
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    // Verify all log events were received by CloudWatch Logs
-    const getEventsCommand = new GetLogEventsCommand({
-      logGroupName: batchTestLogGroupName,
-      logStreamName: batchTestLogStreamName,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${response.events?.length ?? 0} batch events in CloudWatch Logs`,
-    );
-    if ((response.events?.length ?? 0) === 0) {
-      console.log(
-        "No batch 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, 5);
-
-    // Verify messages are in order and contain expected patterns
-    response.events?.forEach((event, i) => {
-      const expectedPattern = `Batch test message ${
-        i + 1
-      } at "2023-01-01T00:0${i}:0${i}.000Z"`;
-      assertEquals(event.message, expectedPattern);
-    });
-  } finally {
-    // Always cleanup - delete log group (this also deletes log streams)
-    try {
-      await client.send(
-        new DeleteLogGroupCommand({ logGroupName: batchTestLogGroupName }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup batch test log group:", error);
-    }
-  }
-});
-
-test("Integration: CloudWatch Logs sink with credentials from options", async () => {
-  const credentialsTestLogGroupName = `/logtape/credentials-test-${Date.now()}`;
-  const credentialsTestLogStreamName = `credentials-test-stream-${Date.now()}`;
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: credentialsTestLogGroupName,
-    logStreamName: credentialsTestLogStreamName,
-    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,
-    },
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  // Verify sink is created successfully
-  assertInstanceOf(sink, Function);
-  assertInstanceOf(sink[Symbol.asyncDispose], Function);
-
-  // 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 {
-    // Create log group and stream for testing
-    await client.send(
-      new CreateLogGroupCommand({ logGroupName: credentialsTestLogGroupName }),
-    );
-
-    await client.send(
-      new CreateLogStreamCommand({
-        logGroupName: credentialsTestLogGroupName,
-        logStreamName: credentialsTestLogStreamName,
-      }),
-    );
-
-    // Send log record with fixed timestamp
-    const fixedTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const credentialsTestLogRecord: LogRecord = {
-      category: ["credentials", "test"],
-      level: "info",
-      message: [
-        "Credentials test message at ",
-        new Date(fixedTimestamp).toISOString(),
-      ],
-      rawMessage: "Credentials test message at {timestamp}",
-      timestamp: fixedTimestamp,
-      properties: { testId: "credentials-001" },
-    };
-
-    sink(credentialsTestLogRecord);
-    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: credentialsTestLogGroupName,
-      logStreamName: credentialsTestLogStreamName,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${
-        response.events?.length ?? 0
-      } credentials events in CloudWatch Logs`,
-    );
-    if (response.events?.length === 0) {
-      console.log(
-        "No credentials 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,
-      'Credentials 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: credentialsTestLogGroupName,
-        }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup credentials test log group:", error);
-    }
-  }
-});
-
-test("Integration: CloudWatch Logs sink with JSON Lines formatter", async () => {
-  const structuredTestLogGroupName = `/logtape/structured-test-${Date.now()}`;
-  const structuredTestLogStreamName = `structured-test-stream-${Date.now()}`;
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: structuredTestLogGroupName,
-    logStreamName: structuredTestLogStreamName,
-    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,
-    },
-    batchSize: 1,
-    flushInterval: 0,
-    formatter: jsonLinesFormatter,
-  });
-
-  // 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 {
-    // Create log group and stream for testing
-    await client.send(
-      new CreateLogGroupCommand({ logGroupName: structuredTestLogGroupName }),
-    );
-
-    await client.send(
-      new CreateLogStreamCommand({
-        logGroupName: structuredTestLogGroupName,
-        logStreamName: structuredTestLogStreamName,
-      }),
-    );
-
-    // Send structured log record with fixed timestamp
-    const fixedTimestamp = 1672531200000; // 2023-01-01T00:00:00.000Z
-    const structuredLogRecord: LogRecord = {
-      category: ["api", "auth"],
-      level: "warning",
-      message: ["Failed login attempt for user ", {
-        email: "test@example.com",
-        id: 456,
-      }],
-      rawMessage: "Failed login attempt for user {user}",
-      timestamp: fixedTimestamp,
-      properties: {
-        ip: "192.168.1.1",
-        userAgent: "TestAgent/1.0",
-        attempts: 3,
-      },
-    };
-
-    sink(structuredLogRecord);
-    await sink[Symbol.asyncDispose]();
-
-    // Wait longer for AWS to process the log event
-    await new Promise((resolve) => setTimeout(resolve, 5000));
-
-    // Verify the structured log event was received by CloudWatch Logs
-    const getEventsCommand = new GetLogEventsCommand({
-      logGroupName: structuredTestLogGroupName,
-      logStreamName: structuredTestLogStreamName,
-    });
-
-    const response = await client.send(getEventsCommand);
-    console.log(
-      `Found ${
-        response.events?.length ?? 0
-      } structured events in CloudWatch Logs`,
-    );
-    if (response.events?.length === 0) {
-      console.log(
-        "No structured 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);
-
-    // Parse the JSON log message
-    const logMessage = response.events?.[0].message;
-    const parsedLog = JSON.parse(logMessage!);
-
-    // Verify structured fields are present (jsonLinesFormatter format)
-    assertEquals(parsedLog.level, "WARN"); // jsonLinesFormatter uses uppercase
-    assertEquals(parsedLog.logger, "api.auth"); // category becomes logger
-    assertEquals(
-      parsedLog.message,
-      'Failed login attempt for user {"email":"test@example.com","id":456}',
-    ); // pre-formatted message
-    assertEquals(parsedLog.properties.ip, "192.168.1.1");
-    assertEquals(parsedLog.properties.userAgent, "TestAgent/1.0");
-    assertEquals(parsedLog.properties.attempts, 3);
-    assertEquals(parsedLog["@timestamp"], "2023-01-01T00:00:00.000Z"); // Fixed timestamp
-  } finally {
-    // Always cleanup - delete log group (this also deletes log streams)
-    try {
-      await client.send(
-        new DeleteLogGroupCommand({ logGroupName: structuredTestLogGroupName }),
-      );
-    } catch (error) {
-      console.warn("Failed to cleanup structured test log group:", error);
-    }
-  }
-});

package/src/sink.test.ts

@@ -1,331 +0,0 @@
-import { suite } from "@alinea/suite";
-import {
-  CloudWatchLogsClient,
-  PutLogEventsCommand,
-} from "@aws-sdk/client-cloudwatch-logs";
-import type { LogRecord } from "@logtape/logtape";
-import { jsonLinesFormatter } from "@logtape/logtape";
-import { assertEquals, assertInstanceOf } from "@std/assert";
-import { mockClient } from "aws-sdk-client-mock";
-import { getCloudWatchLogsSink } from "./sink.ts";
-
-const test = suite(import.meta);
-
-const mockLogRecord: LogRecord = {
-  category: ["test"],
-  level: "info",
-  message: ["Hello, ", "world", "!"],
-  rawMessage: "Hello, {name}!",
-  timestamp: Date.now(),
-  properties: {},
-};
-
-test("getCloudWatchLogsSink() creates a working sink", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    region: "us-east-1",
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-  const call = cwlMock.commandCalls(PutLogEventsCommand)[0];
-  assertEquals(call.args[0].input.logGroupName, "/test/log-group");
-  assertEquals(call.args[0].input.logStreamName, "test-stream");
-  assertEquals(call.args[0].input.logEvents?.length, 1);
-  assertEquals(call.args[0].input.logEvents?.[0].message, 'Hello, "world"!');
-});
-
-test("getCloudWatchLogsSink() batches multiple log events", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 3,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  sink(mockLogRecord);
-  sink(mockLogRecord);
-
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-  const call = cwlMock.commandCalls(PutLogEventsCommand)[0];
-  assertEquals(call.args[0].input.logEvents?.length, 3);
-});
-
-test("getCloudWatchLogsSink() flushes when batch size is reached", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 2,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  sink(mockLogRecord); // Should flush here
-  sink(mockLogRecord); // Should be in next batch
-
-  await sink[Symbol.asyncDispose](); // Should flush remaining
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 2);
-  assertEquals(
-    cwlMock.commandCalls(PutLogEventsCommand)[0].args[0].input.logEvents
-      ?.length,
-    2,
-  );
-  assertEquals(
-    cwlMock.commandCalls(PutLogEventsCommand)[1].args[0].input.logEvents
-      ?.length,
-    1,
-  );
-});
-
-test("getCloudWatchLogsSink() with custom client", async () => {
-  const client = new CloudWatchLogsClient({ region: "us-west-2" });
-  const cwlMock = mockClient(client);
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    client,
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-});
-
-test("getCloudWatchLogsSink() handles credentials", () => {
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    region: "eu-west-1",
-    credentials: {
-      accessKeyId: "test-key",
-      secretAccessKey: "test-secret",
-    },
-  });
-
-  assertInstanceOf(sink, Function);
-  assertInstanceOf(sink[Symbol.asyncDispose], Function);
-});
-
-test("getCloudWatchLogsSink() handles errors gracefully", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).rejects(new Error("Permanent failure"));
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 1,
-    flushInterval: 0,
-    maxRetries: 0, // No retries
-    retryDelay: 10,
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  // Should attempt once and fail gracefully
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-});
-
-test("getCloudWatchLogsSink() handles large message batches", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  // Create a message that will exceed 1MB when combined with overhead
-  const largeMessage = "x".repeat(600000); // ~600KB message
-  const largeLogRecord: LogRecord = {
-    category: ["test"],
-    level: "info",
-    message: [largeMessage],
-    rawMessage: largeMessage,
-    timestamp: Date.now(),
-    properties: {},
-  };
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 10,
-    flushInterval: 0,
-  });
-
-  // Add two large messages - should exceed 1MB limit
-  sink(largeLogRecord);
-  sink(largeLogRecord);
-
-  await sink[Symbol.asyncDispose]();
-
-  const calls = cwlMock.commandCalls(PutLogEventsCommand);
-  // Should either flush immediately due to size or flush remaining on dispose
-  assertEquals(calls.length >= 1, true);
-});
-
-test("getCloudWatchLogsSink() formats complex log messages", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const complexLogRecord: LogRecord = {
-    category: ["app", "module"],
-    level: "error",
-    message: ["User ", { id: 123, name: "John" }, " failed to login"],
-    rawMessage: "User {user} failed to login",
-    timestamp: Date.now(),
-    properties: { error: "Invalid password" },
-  };
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 1,
-    flushInterval: 0,
-  });
-
-  sink(complexLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  const call = cwlMock.commandCalls(PutLogEventsCommand)[0];
-  assertEquals(
-    call.args[0].input.logEvents?.[0].message,
-    'User {"id":123,"name":"John"} failed to login',
-  );
-});
-
-test("getCloudWatchLogsSink() respects batch size limits", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 50000, // Should be clamped to 10000
-    flushInterval: 0,
-  });
-
-  // Verify the sink works (batch size should be internally limited)
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-});
-
-test("getCloudWatchLogsSink() flushes remaining events on disposal", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 10,
-    flushInterval: 0,
-  });
-
-  sink(mockLogRecord);
-  sink(mockLogRecord);
-
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-  assertEquals(
-    cwlMock.commandCalls(PutLogEventsCommand)[0].args[0].input.logEvents
-      ?.length,
-    2,
-  );
-});
-
-test("getCloudWatchLogsSink() supports JSON Lines formatter", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 1,
-    flushInterval: 0,
-    formatter: jsonLinesFormatter,
-  });
-
-  const structuredLogRecord: LogRecord = {
-    category: ["app", "database"],
-    level: "error",
-    message: ["User ", { id: 123, name: "John" }, " failed to connect"],
-    rawMessage: "User {user} failed to connect",
-    timestamp: 1672531200000, // Fixed timestamp for testing
-    properties: { error: "Connection timeout", retries: 3 },
-  };
-
-  sink(structuredLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-  const call = cwlMock.commandCalls(PutLogEventsCommand)[0];
-  const logMessage = call.args[0].input.logEvents?.[0].message;
-
-  // Parse the JSON message to verify structure
-  const parsedMessage = JSON.parse(logMessage!);
-
-  // Check what fields are actually present in jsonLinesFormatter output
-  assertEquals(parsedMessage["@timestamp"], "2023-01-01T00:00:00.000Z");
-  assertEquals(parsedMessage.level, "ERROR"); // jsonLinesFormatter uses uppercase
-  assertEquals(parsedMessage.logger, "app.database"); // category becomes logger
-  assertEquals(
-    parsedMessage.message,
-    'User {"id":123,"name":"John"} failed to connect',
-  ); // pre-formatted message
-  assertEquals(parsedMessage.properties.error, "Connection timeout");
-  assertEquals(parsedMessage.properties.retries, 3);
-});
-
-test("getCloudWatchLogsSink() uses default text formatter when no formatter provided", async () => {
-  const cwlMock = mockClient(CloudWatchLogsClient);
-  cwlMock.reset();
-  cwlMock.on(PutLogEventsCommand).resolves({});
-
-  const sink = getCloudWatchLogsSink({
-    logGroupName: "/test/log-group",
-    logStreamName: "test-stream",
-    batchSize: 1,
-    flushInterval: 0,
-    // No formatter specified - should use default
-  });
-
-  sink(mockLogRecord);
-  await sink[Symbol.asyncDispose]();
-
-  assertEquals(cwlMock.commandCalls(PutLogEventsCommand).length, 1);
-  const call = cwlMock.commandCalls(PutLogEventsCommand)[0];
-  const logMessage = call.args[0].input.logEvents?.[0].message;
-
-  // Should be plain text, not JSON
-  assertEquals(logMessage, 'Hello, "world"!');
-});

package/src/sink.ts

@@ -1,167 +0,0 @@
-import {
-  CloudWatchLogsClient,
-  type InputLogEvent,
-  PutLogEventsCommand,
-} from "@aws-sdk/client-cloudwatch-logs";
-import {
-  getLogger,
-  type LogRecord,
-  type Sink,
-  type TextFormatter,
-} from "@logtape/logtape";
-import type { CloudWatchLogsSinkOptions } from "./types.ts";
-
-// AWS CloudWatch Logs PutLogEvents API limits
-// See: https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html
-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
-
-/**
- * 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
- */
-export function getCloudWatchLogsSink(
-  options: CloudWatchLogsSinkOptions,
-): Sink & AsyncDisposable {
-  const client = options.client ??
-    new CloudWatchLogsClient({
-      region: options.region ?? "us-east-1",
-      credentials: options.credentials,
-    });
-
-  const batchSize = Math.min(
-    Math.max(options.batchSize ?? 1000, 1),
-    MAX_BATCH_SIZE_EVENTS,
-  );
-  const flushInterval = options.flushInterval ?? 1000;
-  const maxRetries = Math.max(options.maxRetries ?? 3, 0);
-  const retryDelay = Math.max(options.retryDelay ?? 100, 0);
-
-  // Default formatter that formats message parts into a simple string
-  const defaultFormatter: TextFormatter = (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: InputLogEvent[] = [];
-  let currentBatchSize = 0;
-  let flushTimer: ReturnType<typeof setTimeout> | null = null;
-  let disposed = false;
-
-  function scheduleFlush(): void {
-    if (flushInterval <= 0 || flushTimer !== null) return;
-
-    flushTimer = setTimeout(() => {
-      flushTimer = null;
-      if (logEvents.length > 0) {
-        void flushEvents();
-      }
-    }, flushInterval);
-  }
-
-  async function flushEvents(): Promise<void> {
-    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: InputLogEvent[],
-    remainingRetries: number,
-  ): Promise<void> {
-    try {
-      const command = new PutLogEventsCommand({
-        logGroupName: options.logGroupName,
-        logStreamName: options.logStreamName,
-        logEvents: events,
-      });
-
-      await client.send(command);
-    } catch (error) {
-      if (remainingRetries > 0) {
-        // Calculate exponential backoff: base, base*2, base*4, etc.
-        const attemptNumber = maxRetries - remainingRetries;
-        const delay = retryDelay * Math.pow(2, attemptNumber);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        await sendEventsWithRetry(events, remainingRetries - 1);
-      } else {
-        // Log to meta logger to avoid crashing the application
-        const metaLogger = getLogger(["logtape", "meta", "cloudwatch-logs"]);
-        metaLogger.error(
-          "Failed to send log events to CloudWatch Logs after {maxRetries} retries: {error}",
-          { maxRetries, error },
-        );
-      }
-    }
-  }
-
-  function formatLogMessage(record: LogRecord): string {
-    return formatter(record);
-  }
-
-  const sink: Sink & AsyncDisposable = (record: LogRecord) => {
-    if (disposed) return;
-
-    // Skip meta logger logs to prevent infinite loops
-    if (
-      record.category[0] === "logtape" &&
-      record.category[1] === "meta" &&
-      record.category[2] === "cloudwatch-logs"
-    ) {
-      return;
-    }
-
-    const message = formatLogMessage(record);
-    const messageBytes = new TextEncoder().encode(message).length;
-    const eventSize = messageBytes + OVERHEAD_PER_EVENT;
-
-    const logEvent: InputLogEvent = {
-      timestamp: record.timestamp,
-      message,
-    };
-
-    logEvents.push(logEvent);
-    currentBatchSize += eventSize;
-
-    const shouldFlushBySize = currentBatchSize > MAX_BATCH_SIZE_BYTES;
-    const shouldFlushByCount = logEvents.length >= batchSize;
-
-    if (shouldFlushBySize || shouldFlushByCount) {
-      void flushEvents();
-    } else {
-      scheduleFlush();
-    }
-  };
-
-  sink[Symbol.asyncDispose] = async () => {
-    if (flushTimer !== null) {
-      clearTimeout(flushTimer);
-      flushTimer = null;
-    }
-    await flushEvents();
-    disposed = true;
-  };
-
-  return sink;
-}

package/src/types.ts

@@ -1,78 +0,0 @@
-import type { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
-import type { TextFormatter } from "@logtape/logtape";
-
-/**
- * Options for configuring the CloudWatch Logs sink.
- * @since 1.0.0
- */
-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 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;
-}

package/tsdown.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: ["src/mod.ts"],
-  dts: {
-    sourcemap: true,
-  },
-  format: ["esm", "cjs"],
-  platform: "neutral",
-  unbundle: true,
-});