@extk/logger-cloudwatch 0.1.0

package/README.md

@@ -0,0 +1,97 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/badge/extk%E2%9A%A1-expressive-blue?style=for-the-badge&labelColor=1a1a2e&color=4361ee">
+    <img alt="extk/expressive logo" src="https://img.shields.io/badge/extk%E2%9A%A1-expressive-blue?style=for-the-badge&labelColor=f0f0f0&color=4361ee">
+  </picture>
+</p>
+
+# @extk/logger-cloudwatch
+
+Opinionated winston loggers with AWS CloudWatch support.
+
+## Install
+
+```sh
+npm install @extk/logger-cloudwatch
+```
+
+## Loggers
+
+### `getCloudwatchLogger(opts)`
+
+Streams JSON logs to AWS CloudWatch. Each process gets its own log stream named `YYYY-MM-DD/pid-<pid>`. Creates the log group if it doesn't exist.
+
+```ts
+import { getCloudwatchLogger } from '@extk/logger-cloudwatch';
+
+const logger = getCloudwatchLogger({
+    aws: {
+        region: 'us-east-1',
+        logGroup: '/my-app/production',
+        credentials: {
+            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        },
+    },
+});
+
+logger.info('Request handled', { userId: 123 });
+```
+
+Optionally attach a context function to merge fields into every log entry:
+
+```ts
+const logger = getCloudwatchLogger({
+    aws: { ... },
+    contextFn: (info) => {
+        info['service'] = 'payments';
+        return info;
+    },
+});
+```
+
+| Option            | Description |
+|-------------------|-------------|
+| `aws.region`      | AWS region |
+| `aws.logGroup`    | CloudWatch log group name |
+| `aws.credentials` | `accessKeyId` + `secretAccessKey` |
+| `contextFn`       | Optional transform to add fields to every entry |
+
+### `getConsoleLogger()`
+
+Logs to stdout. Intended for development or simple services.
+
+```ts
+import { getConsoleLogger } from '@extk/logger-cloudwatch';
+
+const logger = getConsoleLogger();
+logger.info('Server started');
+```
+
+### `getFileLogger(name?)`
+
+Writes to `./logs/<name>.log`. Cached — calling with the same name returns the same instance.
+
+```ts
+import { getFileLogger } from '@extk/logger-cloudwatch';
+
+const logger = getFileLogger('app');
+logger.error(new Error('Something went wrong'));
+```
+
+| Option | Default |
+|--------|---------|
+| `name` | `'app'` |
+| Output | `./logs/<name>.log` |
+| Level  | `debug` |
+
+## Log format
+
+Console and file loggers use a human-readable format:
+
+```
+DD/MM/YYYY HH:mm:ss[LEVEL]: message
+DD/MM/YYYY HH:mm:ss[ERROR]: Error: something\n    at ...  ← stack trace for errors
+```
+
+CloudWatch receives structured JSON with `timestamp`, `level`, `message`, and any extra fields.

package/dist/index.d.mts

@@ -0,0 +1,19 @@
+import winston from 'winston';
+
+declare const getFileLogger: (name?: string) => winston.Logger;
+declare const getConsoleLogger: () => winston.Logger;
+
+type options = {
+    aws: {
+        region: string;
+        logGroup: string;
+        credentials: {
+            accessKeyId: string;
+            secretAccessKey: string;
+        };
+    };
+    contextFn?: winston.Logform.TransformFunction;
+};
+declare const getCloudwatchLogger: (opts: options) => winston.Logger;
+
+export { getCloudwatchLogger, getConsoleLogger, getFileLogger };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import winston from 'winston';
+
+declare const getFileLogger: (name?: string) => winston.Logger;
+declare const getConsoleLogger: () => winston.Logger;
+
+type options = {
+    aws: {
+        region: string;
+        logGroup: string;
+        credentials: {
+            accessKeyId: string;
+            secretAccessKey: string;
+        };
+    };
+    contextFn?: winston.Logform.TransformFunction;
+};
+declare const getCloudwatchLogger: (opts: options) => winston.Logger;
+
+export { getCloudwatchLogger, getConsoleLogger, getFileLogger };

package/dist/index.js

@@ -0,0 +1,116 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getCloudwatchLogger: () => getCloudwatchLogger,
+  getConsoleLogger: () => getConsoleLogger,
+  getFileLogger: () => getFileLogger
+});
+module.exports = __toCommonJS(index_exports);
+var import_winston3 = __toESM(require("winston"));
+var import_winston_cloudwatch = __toESM(require("winston-cloudwatch"));
+
+// ../../shared/src/loggers.ts
+var import_winston2 = __toESM(require("winston"));
+
+// ../../shared/src/common.ts
+var import_winston = __toESM(require("winston"));
+var defaultStringFormat = import_winston.default.format.combine(
+  import_winston.default.format.timestamp({ format: "DD/MM/YYYY HH:mm:ss" }),
+  import_winston.default.format.splat(),
+  import_winston.default.format.errors({ stack: true }),
+  import_winston.default.format.printf(({ level, message, timestamp, stack }) => `${timestamp}[${level.toUpperCase()}]: ${stack || message}`)
+);
+var consoleTransport = new import_winston.default.transports.Console({
+  handleExceptions: true
+});
+
+// ../../shared/src/loggers.ts
+var createFileLogger = (filename) => import_winston2.default.createLogger({
+  format: defaultStringFormat,
+  transports: [
+    new import_winston2.default.transports.File({
+      filename: `./logs/${filename}.log`,
+      handleExceptions: true,
+      level: "debug"
+    })
+  ]
+});
+var loggerRegistry = {};
+var getFileLogger = (name = "app") => {
+  if (!loggerRegistry[name]) {
+    loggerRegistry[name] = createFileLogger(name.toString());
+  }
+  return loggerRegistry[name];
+};
+var consoleLogger;
+var getConsoleLogger = () => {
+  if (!consoleLogger) {
+    consoleLogger = import_winston2.default.createLogger({
+      format: defaultStringFormat,
+      transports: [consoleTransport]
+    });
+  }
+  return consoleLogger;
+};
+
+// src/index.ts
+var getCloudwatchLogger = (opts) => {
+  const formats = [
+    import_winston3.default.format.timestamp(),
+    import_winston3.default.format.splat(),
+    import_winston3.default.format.errors({ stack: true })
+  ];
+  if (opts.contextFn) {
+    formats.push(import_winston3.default.format(opts.contextFn)());
+  }
+  return import_winston3.default.createLogger({
+    exitOnError: false,
+    format: import_winston3.default.format.combine(...formats),
+    transports: [
+      new import_winston_cloudwatch.default({
+        logGroupName: opts.aws.logGroup,
+        logStreamName: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}/pid-${process.pid}`,
+        awsRegion: opts.aws.region,
+        awsAccessKeyId: opts.aws.credentials.accessKeyId,
+        awsSecretKey: opts.aws.credentials.secretAccessKey,
+        jsonMessage: true,
+        ensureLogGroup: true
+      })
+    ]
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCloudwatchLogger,
+  getConsoleLogger,
+  getFileLogger
+});

package/dist/index.mjs

@@ -0,0 +1,79 @@
+// src/index.ts
+import winston3 from "winston";
+import WinstonCloudWatch from "winston-cloudwatch";
+
+// ../../shared/src/loggers.ts
+import winston2 from "winston";
+
+// ../../shared/src/common.ts
+import winston from "winston";
+var defaultStringFormat = winston.format.combine(
+  winston.format.timestamp({ format: "DD/MM/YYYY HH:mm:ss" }),
+  winston.format.splat(),
+  winston.format.errors({ stack: true }),
+  winston.format.printf(({ level, message, timestamp, stack }) => `${timestamp}[${level.toUpperCase()}]: ${stack || message}`)
+);
+var consoleTransport = new winston.transports.Console({
+  handleExceptions: true
+});
+
+// ../../shared/src/loggers.ts
+var createFileLogger = (filename) => winston2.createLogger({
+  format: defaultStringFormat,
+  transports: [
+    new winston2.transports.File({
+      filename: `./logs/${filename}.log`,
+      handleExceptions: true,
+      level: "debug"
+    })
+  ]
+});
+var loggerRegistry = {};
+var getFileLogger = (name = "app") => {
+  if (!loggerRegistry[name]) {
+    loggerRegistry[name] = createFileLogger(name.toString());
+  }
+  return loggerRegistry[name];
+};
+var consoleLogger;
+var getConsoleLogger = () => {
+  if (!consoleLogger) {
+    consoleLogger = winston2.createLogger({
+      format: defaultStringFormat,
+      transports: [consoleTransport]
+    });
+  }
+  return consoleLogger;
+};
+
+// src/index.ts
+var getCloudwatchLogger = (opts) => {
+  const formats = [
+    winston3.format.timestamp(),
+    winston3.format.splat(),
+    winston3.format.errors({ stack: true })
+  ];
+  if (opts.contextFn) {
+    formats.push(winston3.format(opts.contextFn)());
+  }
+  return winston3.createLogger({
+    exitOnError: false,
+    format: winston3.format.combine(...formats),
+    transports: [
+      new WinstonCloudWatch({
+        logGroupName: opts.aws.logGroup,
+        logStreamName: `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}/pid-${process.pid}`,
+        awsRegion: opts.aws.region,
+        awsAccessKeyId: opts.aws.credentials.accessKeyId,
+        awsSecretKey: opts.aws.credentials.secretAccessKey,
+        jsonMessage: true,
+        ensureLogGroup: true
+      })
+    ]
+  });
+};
+export {
+  getCloudwatchLogger,
+  getConsoleLogger,
+  getFileLogger
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "@extk/logger-cloudwatch",
+    "version": "0.1.0",
+    "type": "commonjs",
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js"
+        }
+    },
+    "engines": {
+        "node": ">=22.0.0"
+    },
+    "scripts": {
+        "build": "tsup",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "winston": "^3.11.0",
+        "winston-cloudwatch": "^6.3.0"
+    },
+    "license": "ISC",
+    "description": "AWS CloudWatch logger",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/sergeytangyan/extk-logger",
+        "directory": "packages/cloudwatch"
+    }
+}