@allthings/cloud-toolkit 5.4.0 → 5.5.0-beta.1

package/README.md

@@ -93,6 +93,16 @@ negative — so leave it off for anything that has to arrive.
 
 A winston instance will be created with default log levels https://github.com/winstonjs/winston?tab=readme-ov-file#logging
 
+With a `datadogApiKey`, entries are POSTed to the Datadog intake without waiting for the response. In a Lambda, call `flushLogger(logger)` before the handler returns. It waits until those requests are delivered (at most `timeoutMs`, default 1000) and resolves immediately when nothing is in flight. Without it, the runtime freezes with the request open, so the entry arrives on the next invocation or is lost.
+
+```ts
+import { flushLogger, logger } from '@allthings/cloud-toolkit/logger'
+
+const log = logger({ datadogApiKey, deploymentStage, service: 'accounts' })
+// ... handle the request, log.error(...) ...
+await flushLogger(log)
+```
+
 ### tracing
 
 OpenTelemetry tracing for Lambda with the AWS X-Ray backend (replaces the deprecated `aws-xray-sdk-*`). Import it from its own subpath — it is not part of the main entry, so services that don't trace bundle none of `@opentelemetry/*`:

package/dist/lib.cjs.js

@@ -3,6 +3,7 @@
 var querystring = require('querystring');
 var zlib = require('zlib');
 var crypto = require('crypto');
+var https = require('https');
 var winston = require('winston');
 var clientSsm = require('@aws-sdk/client-ssm');
 var clientSesv2 = require('@aws-sdk/client-sesv2');
@@ -1196,6 +1197,29 @@ const sqs = (userConfig) => {
 const btoa = (stringToEncode) => Buffer.from(stringToEncode).toString('base64');
 const atob = (stringToDecode) => Buffer.from(stringToDecode, 'base64').toString('utf8');
 
+const DEFAULT_FLUSH_TIMEOUT_MS = 1000;
+const datadogAgent = new https.Agent({ keepAlive: true });
+const pendingByLogger = new WeakMap();
+const trackRequests = (transport) => {
+    const pending = { count: 0, waiters: new Set() };
+    const send = transport.log?.bind(transport);
+    const settle = () => {
+        pending.count = Math.max(0, pending.count - 1);
+        if (pending.count === 0) {
+            for (const wake of pending.waiters) {
+                wake();
+            }
+            pending.waiters.clear();
+        }
+    };
+    transport.log = (info, next) => {
+        pending.count += 1;
+        send?.(info, next);
+    };
+    transport.on('logged', settle);
+    transport.on('warn', settle);
+    return pending;
+};
 const logger = (config) => {
     const loggerConfig = {
         defaultMeta: {
@@ -1209,22 +1233,42 @@ const logger = (config) => {
         level: config.level || 'info',
     };
     if (config.datadogApiKey) {
-        const httpOptions = {
+        const transport = new winston.transports.Http({
+            agent: datadogAgent,
             host: 'http-intake.logs.datadoghq.eu',
             path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
             port: 443,
             ssl: true,
-        };
-        return winston.createLogger({
+        });
+        const datadogLogger = winston.createLogger({
             ...loggerConfig,
-            transports: [new winston.transports.Http(httpOptions)],
+            transports: [transport],
         });
+        pendingByLogger.set(datadogLogger, trackRequests(transport));
+        return datadogLogger;
     }
     return winston.createLogger({
         ...loggerConfig,
         transports: [new winston.transports.Console({ forceConsole: true })],
     });
 };
+const flushLogger = (loggerToFlush, timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+    const pending = loggerToFlush && pendingByLogger.get(loggerToFlush);
+    if (!pending || pending.count === 0) {
+        return Promise.resolve();
+    }
+    const drained = new Promise((resolve) => {
+        pending.waiters.add(resolve);
+    });
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        timer.unref();
+        void drained.then(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+};
 
 Object.defineProperty(exports, "Logger", {
     enumerable: true,
@@ -1243,6 +1287,7 @@ exports.deepFlatten = deepFlatten;
 exports.dynamodb = dynamodb;
 exports.emailHeaders = emailHeaders;
 exports.flatten = flatten;
+exports.flushLogger = flushLogger;
 exports.lambda = lambda;
 exports.logger = logger;
 exports.parameterStore = parameterStore;

package/dist/lib.esm.mjs

@@ -1,7 +1,8 @@
 import * as querystring from 'querystring';
 import * as zlib from 'zlib';
 import * as crypto from 'crypto';
-import { format, createLogger, transports } from 'winston';
+import { Agent } from 'https';
+import { format, transports, createLogger } from 'winston';
 export { Logger } from 'winston';
 import { SSMClient, GetParametersCommand, GetParameterCommand } from '@aws-sdk/client-ssm';
 import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';
@@ -1174,6 +1175,29 @@ const sqs = (userConfig) => {
 const btoa = (stringToEncode) => Buffer.from(stringToEncode).toString('base64');
 const atob = (stringToDecode) => Buffer.from(stringToDecode, 'base64').toString('utf8');
 
+const DEFAULT_FLUSH_TIMEOUT_MS = 1000;
+const datadogAgent = new Agent({ keepAlive: true });
+const pendingByLogger = new WeakMap();
+const trackRequests = (transport) => {
+    const pending = { count: 0, waiters: new Set() };
+    const send = transport.log?.bind(transport);
+    const settle = () => {
+        pending.count = Math.max(0, pending.count - 1);
+        if (pending.count === 0) {
+            for (const wake of pending.waiters) {
+                wake();
+            }
+            pending.waiters.clear();
+        }
+    };
+    transport.log = (info, next) => {
+        pending.count += 1;
+        send?.(info, next);
+    };
+    transport.on('logged', settle);
+    transport.on('warn', settle);
+    return pending;
+};
 const logger = (config) => {
     const loggerConfig = {
         defaultMeta: {
@@ -1187,21 +1211,41 @@ const logger = (config) => {
         level: config.level || 'info',
     };
     if (config.datadogApiKey) {
-        const httpOptions = {
+        const transport = new transports.Http({
+            agent: datadogAgent,
             host: 'http-intake.logs.datadoghq.eu',
             path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
             port: 443,
             ssl: true,
-        };
-        return createLogger({
+        });
+        const datadogLogger = createLogger({
             ...loggerConfig,
-            transports: [new transports.Http(httpOptions)],
+            transports: [transport],
         });
+        pendingByLogger.set(datadogLogger, trackRequests(transport));
+        return datadogLogger;
     }
     return createLogger({
         ...loggerConfig,
         transports: [new transports.Console({ forceConsole: true })],
     });
 };
+const flushLogger = (loggerToFlush, timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+    const pending = loggerToFlush && pendingByLogger.get(loggerToFlush);
+    if (!pending || pending.count === 0) {
+        return Promise.resolve();
+    }
+    const drained = new Promise((resolve) => {
+        pending.waiters.add(resolve);
+    });
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        timer.unref();
+        void drained.then(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+};
 
-export { AUTO_RESPONSE_SUPPRESSION_HEADERS, ClientError, DEFAULT_CLIENT_CONFIG$1 as DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, DEFAULT_CLIENT_CONFIG as DEFAULT_SES_CLIENT_CONFIG, ServerError, alagarr, asyncReduce, atob, btoa, deepFlatten, dynamodb, emailHeaders, flatten, lambda, logger, parameterStore, partial, ses, splitEvery, sqs, times, until };
+export { AUTO_RESPONSE_SUPPRESSION_HEADERS, ClientError, DEFAULT_CLIENT_CONFIG$1 as DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, DEFAULT_CLIENT_CONFIG as DEFAULT_SES_CLIENT_CONFIG, ServerError, alagarr, asyncReduce, atob, btoa, deepFlatten, dynamodb, emailHeaders, flatten, flushLogger, lambda, logger, parameterStore, partial, ses, splitEvery, sqs, times, until };

package/dist/logger.cjs.js

@@ -1,7 +1,31 @@
 'use strict';
 
+var https = require('https');
 var winston = require('winston');
 
+const DEFAULT_FLUSH_TIMEOUT_MS = 1000;
+const datadogAgent = new https.Agent({ keepAlive: true });
+const pendingByLogger = new WeakMap();
+const trackRequests = (transport) => {
+    const pending = { count: 0, waiters: new Set() };
+    const send = transport.log?.bind(transport);
+    const settle = () => {
+        pending.count = Math.max(0, pending.count - 1);
+        if (pending.count === 0) {
+            for (const wake of pending.waiters) {
+                wake();
+            }
+            pending.waiters.clear();
+        }
+    };
+    transport.log = (info, next) => {
+        pending.count += 1;
+        send?.(info, next);
+    };
+    transport.on('logged', settle);
+    transport.on('warn', settle);
+    return pending;
+};
 const logger = (config) => {
     const loggerConfig = {
         defaultMeta: {
@@ -15,21 +39,42 @@ const logger = (config) => {
         level: config.level || 'info',
     };
     if (config.datadogApiKey) {
-        const httpOptions = {
+        const transport = new winston.transports.Http({
+            agent: datadogAgent,
             host: 'http-intake.logs.datadoghq.eu',
             path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
             port: 443,
             ssl: true,
-        };
-        return winston.createLogger({
+        });
+        const datadogLogger = winston.createLogger({
             ...loggerConfig,
-            transports: [new winston.transports.Http(httpOptions)],
+            transports: [transport],
         });
+        pendingByLogger.set(datadogLogger, trackRequests(transport));
+        return datadogLogger;
     }
     return winston.createLogger({
         ...loggerConfig,
         transports: [new winston.transports.Console({ forceConsole: true })],
     });
 };
+const flushLogger = (loggerToFlush, timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+    const pending = loggerToFlush && pendingByLogger.get(loggerToFlush);
+    if (!pending || pending.count === 0) {
+        return Promise.resolve();
+    }
+    const drained = new Promise((resolve) => {
+        pending.waiters.add(resolve);
+    });
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        timer.unref();
+        void drained.then(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+};
 
+exports.flushLogger = flushLogger;
 exports.logger = logger;

package/dist/logger.esm.mjs

@@ -1,5 +1,29 @@
-import { format, createLogger, transports } from 'winston';
+import { Agent } from 'https';
+import { format, transports, createLogger } from 'winston';
 
+const DEFAULT_FLUSH_TIMEOUT_MS = 1000;
+const datadogAgent = new Agent({ keepAlive: true });
+const pendingByLogger = new WeakMap();
+const trackRequests = (transport) => {
+    const pending = { count: 0, waiters: new Set() };
+    const send = transport.log?.bind(transport);
+    const settle = () => {
+        pending.count = Math.max(0, pending.count - 1);
+        if (pending.count === 0) {
+            for (const wake of pending.waiters) {
+                wake();
+            }
+            pending.waiters.clear();
+        }
+    };
+    transport.log = (info, next) => {
+        pending.count += 1;
+        send?.(info, next);
+    };
+    transport.on('logged', settle);
+    transport.on('warn', settle);
+    return pending;
+};
 const logger = (config) => {
     const loggerConfig = {
         defaultMeta: {
@@ -13,21 +37,41 @@ const logger = (config) => {
         level: config.level || 'info',
     };
     if (config.datadogApiKey) {
-        const httpOptions = {
+        const transport = new transports.Http({
+            agent: datadogAgent,
             host: 'http-intake.logs.datadoghq.eu',
             path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
             port: 443,
             ssl: true,
-        };
-        return createLogger({
+        });
+        const datadogLogger = createLogger({
             ...loggerConfig,
-            transports: [new transports.Http(httpOptions)],
+            transports: [transport],
         });
+        pendingByLogger.set(datadogLogger, trackRequests(transport));
+        return datadogLogger;
     }
     return createLogger({
         ...loggerConfig,
         transports: [new transports.Console({ forceConsole: true })],
     });
 };
+const flushLogger = (loggerToFlush, timeoutMs = DEFAULT_FLUSH_TIMEOUT_MS) => {
+    const pending = loggerToFlush && pendingByLogger.get(loggerToFlush);
+    if (!pending || pending.count === 0) {
+        return Promise.resolve();
+    }
+    const drained = new Promise((resolve) => {
+        pending.waiters.add(resolve);
+    });
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        timer.unref();
+        void drained.then(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+};
 
-export { logger };
+export { flushLogger, logger };

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 export { Alagarr, alagarr, ClientError, HandlerFunction, IInterfaceAlagarrOptions, IInterfaceHeaders, IInterfaceQueryParameters, IInterfaceRequest, IInterfaceResponse, ServerError, } from './alagarr';
 export { AUTO_RESPONSE_SUPPRESSION_HEADERS, DEFAULT_PARAMETER_STORE_CLIENT_CONFIG, DEFAULT_SES_CLIENT_CONFIG, dynamodb, emailHeaders, IDynamoDBConfig, IDynamoDBInstance, IEmailAttachment, IEmailHeaderOptions, IEmailOptions, ILambda, ILambdaInstance, IParameterStore, IParameterStoreInstance, ISES, ISESInstance, ISQS, ISQSInstance, IUnprocessedItems, lambda, parameterStore, ses, sqs, TBatchWriteItems, TDeleteItem, TDeleteQueueItem, TGetItem, TGetQueueItems, TGetQueueUrl, TGetSecret, TGetSecrets, TInvokeLambda, TPutItem, TQueryTable, TScanTable, TSendMail, TSendMessage, TUpdateItem, } from './aws';
 export { atob, btoa } from './base64';
-export { logger } from './logger/logger';
+export { flushLogger, logger } from './logger/logger';
 export { asyncReduce, deepFlatten, flatten, List, partial, splitEvery, times, until, } from './utils';
 export type { APIGatewayEvent, APIGatewayProxyEventV2, Context, } from 'aws-lambda';
 export { Logger } from 'winston';

package/dist/src/logger/logger.d.ts

@@ -7,4 +7,5 @@ interface ILoggerConfig {
     service: string;
 }
 export declare const logger: (config: ILoggerConfig) => Logger;
+export declare const flushLogger: (loggerToFlush: Logger | undefined, timeoutMs?: number) => Promise<void>;
 export type { Logger } from 'winston';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allthings/cloud-toolkit",
-  "version": "5.4.0",
+  "version": "5.5.0-beta.1",
   "description": "",
   "author": "Allthings GmbH",
   "keywords": [
@@ -180,21 +180,21 @@
     "@commitlint/config-conventional": "21.2.3",
     "@opentelemetry/sdk-trace-base": "2.12.0",
     "@rollup/plugin-node-resolve": "16.0.3",
-    "@types/node": "24.19.1",
+    "@types/node": "24.19.2",
     "@types/nodemailer": "8.0.2",
-    "@vitest/coverage-v8": "5.0.3",
+    "@vitest/coverage-v8": "5.0.5",
     "aws-sdk-client-mock": "4.1.0",
     "conventional-changelog-conventionalcommits": "9.3.1",
-    "eslint": "10.12.0",
+    "eslint": "10.13.0",
     "husky": "9.1.7",
     "lint-staged": "17.6.0",
-    "prettier": "3.9.9",
+    "prettier": "3.9.10",
     "rimraf": "6.1.3",
-    "rollup": "4.64.0",
+    "rollup": "4.64.8",
     "semantic-release": "25.0.9",
     "typescript": "6.0.3",
-    "vite": "8.3.2",
-    "vitest": "5.0.3"
+    "vite": "8.3.4",
+    "vitest": "5.0.5"
   },
   "prettier": {
     "printWidth": 80,