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

package/README.md

@@ -93,6 +93,43 @@ 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
 
+### 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/*`:
+
+```ts
+import {
+  withInvocationSpan,
+  withStageSpan,
+} from '@allthings/cloud-toolkit/tracing'
+
+export const handler = (event: APIGatewayProxyEvent) =>
+  withInvocationSpan(
+    { 'http.request.method': event.httpMethod, 'url.path': event.path },
+    async () => {
+      const config = await withStageSpan('load-config', () => fetch(configUrl))
+      // ...
+      return { statusCode: 200, body: '' }
+    },
+  )
+```
+
+| Function             | Parameters                | Description                                                                                                                                                    |
+| -------------------- | ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `withInvocationSpan` | attributes<br/>run        | Runs the invocation in a SERVER span continuing the X-Ray trace, flushes spans (max 2.5 s) before returning; a `statusCode >= 500` result marks it as an error |
+| `withStageSpan`      | name<br/>run              | Runs a phase of the invocation as a child span                                                                                                                 |
+| `createTracingSdk`   | spanProcessors (optional) | Creates and registers the provider — for tests with an in-memory exporter                                                                                      |
+
+Global `fetch` (undici) and `http`/`https` calls are traced automatically.
+
+Configuration (environment):
+
+- `OTEL_ENABLED=true` — turns tracing on; otherwise every function is a pass-through.
+- Lambda `tracing: Active` — provides `AWS_XRAY_DAEMON_ADDRESS`; spans go there as OTLP over UDP (no layer, no added latency). Without it, spans go via OTLP/HTTP to `OTEL_EXPORTER_OTLP_*` (default `localhost:4318`).
+- `OTEL_SERVICE_NAME` — optional, defaults to `AWS_LAMBDA_FUNCTION_NAME`.
+
+The SDK starts when the module is first imported, so import it before modules that load `http`/`https`.
+
 ## Releasing pre-release versions
 
 This project uses [semantic-release](https://semantic-release.gitbook.io/semantic-release/) with support for pre-release channels via dedicated branches.

package/dist/dynamodb.cjs.js

@@ -8,7 +8,7 @@ const DEFAULT_AWS_CONFIGURATION = {
     region: 'eu-central-2',
 };
 
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/dist/dynamodb.esm.mjs

@@ -6,7 +6,7 @@ const DEFAULT_AWS_CONFIGURATION = {
     region: 'eu-central-2',
 };
 
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/dist/lib.cjs.js

@@ -717,7 +717,7 @@ const DEFAULT_AWS_CONFIGURATION = {
     region: 'eu-central-2',
 };
 
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/dist/lib.esm.mjs

@@ -695,7 +695,7 @@ const DEFAULT_AWS_CONFIGURATION = {
     region: 'eu-central-2',
 };
 
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/dist/src/tracing/index.d.ts

@@ -0,0 +1,2 @@
+export { createOtlpUdpSpanExporter } from './otlpUdpSpanExporter';
+export { createTracingSdk, ITracingSdk, ITracingSdkOptions, TSpanAttributes, withInvocationSpan, withStageSpan, } from './tracing';

package/dist/src/tracing/otlpUdpSpanExporter.d.ts

@@ -0,0 +1,2 @@
+import { SpanExporter } from '@opentelemetry/sdk-trace-node';
+export declare const createOtlpUdpSpanExporter: (endpoint?: string) => SpanExporter;

package/dist/src/tracing/tracing.d.ts

@@ -0,0 +1,13 @@
+import { Tracer } from '@opentelemetry/api';
+import { SpanProcessor } from '@opentelemetry/sdk-trace-node';
+export interface ITracingSdk {
+    forceFlush: () => Promise<void>;
+    tracer: Tracer;
+}
+export interface ITracingSdkOptions {
+    spanProcessors?: SpanProcessor[];
+}
+export type TSpanAttributes = Record<string, number | string | undefined>;
+export declare const createTracingSdk: (options?: ITracingSdkOptions) => ITracingSdk;
+export declare const withInvocationSpan: <Result>(attributes: TSpanAttributes, run: () => Promise<Result>) => Promise<Result>;
+export declare const withStageSpan: <Result>(name: string, run: () => Promise<Result>) => Promise<Result>;

package/dist/tracing.cjs.js

@@ -0,0 +1,173 @@
+'use strict';
+
+var api = require('@opentelemetry/api');
+var core = require('@opentelemetry/core');
+var otlpTransformer = require('@opentelemetry/otlp-transformer');
+var dgram = require('dgram');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var idGeneratorAwsXray = require('@opentelemetry/id-generator-aws-xray');
+var instrumentation = require('@opentelemetry/instrumentation');
+var instrumentationHttp = require('@opentelemetry/instrumentation-http');
+var instrumentationUndici = require('@opentelemetry/instrumentation-undici');
+var propagatorAwsXray = require('@opentelemetry/propagator-aws-xray');
+var resources = require('@opentelemetry/resources');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+
+const DEFAULT_ENDPOINT = '127.0.0.1:2000';
+const PROTOCOL_HEADER = '{"format":"json","version":1}\n';
+const OTEL_TRACES_BINARY_PREFIX = 'T1S';
+const MAX_PORT = 65_535;
+const parseEndpoint = (endpoint) => {
+    const [host, port] = endpoint.split(':');
+    const parsedPort = Number(port);
+    if (!host ||
+        !port ||
+        !Number.isSafeInteger(parsedPort) ||
+        parsedPort < 1 ||
+        parsedPort > MAX_PORT) {
+        throw new Error(`Invalid X-Ray daemon endpoint: ${endpoint}`);
+    }
+    return { host, port: parsedPort };
+};
+const reportFailure = (error, resultCallback) => {
+    api.diag.error('Error sending OTLP/UDP data: %s', error);
+    resultCallback({ code: core.ExportResultCode.FAILED, error });
+};
+const sendMessage = (socket, message, { host, port }, resultCallback) => {
+    try {
+        socket.send(Buffer.from(message, 'utf8'), port, host, (error) => {
+            if (error) {
+                reportFailure(error, resultCallback);
+                return;
+            }
+            resultCallback({ code: core.ExportResultCode.SUCCESS });
+        });
+    }
+    catch (error) {
+        reportFailure(error instanceof Error ? error : new Error(String(error)), resultCallback);
+    }
+};
+const createOtlpUdpSpanExporter = (endpoint = DEFAULT_ENDPOINT) => {
+    const { host, port } = parseEndpoint(endpoint);
+    const socket = dgram.createSocket('udp4');
+    socket.unref();
+    return {
+        export: (spans, resultCallback) => {
+            const serialized = otlpTransformer.ProtobufTraceSerializer.serializeRequest(spans);
+            if (serialized == null) {
+                resultCallback({ code: core.ExportResultCode.SUCCESS });
+                return;
+            }
+            const message = `${PROTOCOL_HEADER}${OTEL_TRACES_BINARY_PREFIX}${Buffer.from(serialized).toString('base64')}`;
+            sendMessage(socket, message, { host, port }, resultCallback);
+        },
+        forceFlush: () => Promise.resolve(),
+        shutdown: () => new Promise((resolve) => {
+            socket.close(() => resolve());
+        }),
+    };
+};
+
+const OTLP_HTTP_EXPORT_TIMEOUT_MS = 2000;
+const FLUSH_BUDGET_MS = 2500;
+const BATCH_DELAY_MS = 200;
+const getServiceName = () => process.env.OTEL_SERVICE_NAME ??
+    process.env.AWS_LAMBDA_FUNCTION_NAME ??
+    'lambda';
+const createSpanExporter = () => process.env.AWS_XRAY_DAEMON_ADDRESS
+    ? createOtlpUdpSpanExporter(process.env.AWS_XRAY_DAEMON_ADDRESS)
+    : new exporterTraceOtlpHttp.OTLPTraceExporter({ timeoutMillis: OTLP_HTTP_EXPORT_TIMEOUT_MS });
+const createTracingSdk = (options = {}) => {
+    const provider = new sdkTraceNode.NodeTracerProvider({
+        idGenerator: new idGeneratorAwsXray.AWSXRayIdGenerator(),
+        resource: resources.resourceFromAttributes({ [semanticConventions.ATTR_SERVICE_NAME]: getServiceName() }),
+        spanProcessors: options.spanProcessors ?? [
+            new sdkTraceNode.BatchSpanProcessor(createSpanExporter(), {
+                scheduledDelayMillis: BATCH_DELAY_MS,
+            }),
+        ],
+    });
+    provider.register({ propagator: new propagatorAwsXray.AWSXRayPropagator() });
+    instrumentation.registerInstrumentations({
+        instrumentations: [new instrumentationUndici.UndiciInstrumentation(), new instrumentationHttp.HttpInstrumentation()],
+    });
+    return {
+        forceFlush: () => provider.forceFlush(),
+        tracer: api.trace.getTracer('@allthings/cloud-toolkit/tracing'),
+    };
+};
+const sdk = process.env.OTEL_ENABLED === 'true' ? createTracingSdk() : undefined;
+const invocationParentContext = () => api.propagation.extract(api.context.active(), {
+    'x-amzn-trace-id': process.env._X_AMZN_TRACE_ID ?? '',
+});
+const finishSpan = (span, error) => {
+    if (error instanceof Error) {
+        span.recordException(error);
+        span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.message });
+    }
+    span.end();
+};
+const logFlushFailure = () => {
+    console.warn('OTel span flush failed');
+};
+const flushWithBudget = (flush) => Promise.race([
+    Promise.resolve().then(flush).catch(logFlushFailure),
+    new Promise((resolve) => {
+        setTimeout(resolve, FLUSH_BUDGET_MS).unref();
+    }),
+]);
+const getStatusCode = (result) => {
+    if (typeof result !== 'object' || result === null) {
+        return undefined;
+    }
+    const { statusCode } = result;
+    return typeof statusCode === 'number' ? statusCode : undefined;
+};
+const withInvocationSpan = async (attributes, run) => {
+    if (!sdk) {
+        return run();
+    }
+    const parent = invocationParentContext();
+    const span = sdk.tracer.startSpan(process.env.AWS_LAMBDA_FUNCTION_NAME ?? 'invocation', { attributes, kind: api.SpanKind.SERVER }, parent);
+    try {
+        const result = await api.context.with(api.trace.setSpan(parent, span), run);
+        const statusCode = getStatusCode(result);
+        if (statusCode !== undefined) {
+            span.setAttribute('http.response.status_code', statusCode);
+        }
+        if (statusCode !== undefined && statusCode >= 500) {
+            span.setStatus({ code: api.SpanStatusCode.ERROR });
+        }
+        finishSpan(span);
+        return result;
+    }
+    catch (error) {
+        finishSpan(span, error);
+        throw error;
+    }
+    finally {
+        await flushWithBudget(sdk.forceFlush);
+    }
+};
+const withStageSpan = async (name, run) => {
+    if (!sdk) {
+        return run();
+    }
+    return sdk.tracer.startActiveSpan(name, async (span) => {
+        try {
+            const result = await run();
+            finishSpan(span);
+            return result;
+        }
+        catch (error) {
+            finishSpan(span, error);
+            throw error;
+        }
+    });
+};
+
+exports.createOtlpUdpSpanExporter = createOtlpUdpSpanExporter;
+exports.createTracingSdk = createTracingSdk;
+exports.withInvocationSpan = withInvocationSpan;
+exports.withStageSpan = withStageSpan;

package/dist/tracing.esm.mjs

@@ -0,0 +1,168 @@
+import { diag, trace, SpanKind, context, SpanStatusCode, propagation } from '@opentelemetry/api';
+import { ExportResultCode } from '@opentelemetry/core';
+import { ProtobufTraceSerializer } from '@opentelemetry/otlp-transformer';
+import dgram from 'dgram';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { AWSXRayIdGenerator } from '@opentelemetry/id-generator-aws-xray';
+import { registerInstrumentations } from '@opentelemetry/instrumentation';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { UndiciInstrumentation } from '@opentelemetry/instrumentation-undici';
+import { AWSXRayPropagator } from '@opentelemetry/propagator-aws-xray';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { NodeTracerProvider, BatchSpanProcessor } from '@opentelemetry/sdk-trace-node';
+import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+
+const DEFAULT_ENDPOINT = '127.0.0.1:2000';
+const PROTOCOL_HEADER = '{"format":"json","version":1}\n';
+const OTEL_TRACES_BINARY_PREFIX = 'T1S';
+const MAX_PORT = 65_535;
+const parseEndpoint = (endpoint) => {
+    const [host, port] = endpoint.split(':');
+    const parsedPort = Number(port);
+    if (!host ||
+        !port ||
+        !Number.isSafeInteger(parsedPort) ||
+        parsedPort < 1 ||
+        parsedPort > MAX_PORT) {
+        throw new Error(`Invalid X-Ray daemon endpoint: ${endpoint}`);
+    }
+    return { host, port: parsedPort };
+};
+const reportFailure = (error, resultCallback) => {
+    diag.error('Error sending OTLP/UDP data: %s', error);
+    resultCallback({ code: ExportResultCode.FAILED, error });
+};
+const sendMessage = (socket, message, { host, port }, resultCallback) => {
+    try {
+        socket.send(Buffer.from(message, 'utf8'), port, host, (error) => {
+            if (error) {
+                reportFailure(error, resultCallback);
+                return;
+            }
+            resultCallback({ code: ExportResultCode.SUCCESS });
+        });
+    }
+    catch (error) {
+        reportFailure(error instanceof Error ? error : new Error(String(error)), resultCallback);
+    }
+};
+const createOtlpUdpSpanExporter = (endpoint = DEFAULT_ENDPOINT) => {
+    const { host, port } = parseEndpoint(endpoint);
+    const socket = dgram.createSocket('udp4');
+    socket.unref();
+    return {
+        export: (spans, resultCallback) => {
+            const serialized = ProtobufTraceSerializer.serializeRequest(spans);
+            if (serialized == null) {
+                resultCallback({ code: ExportResultCode.SUCCESS });
+                return;
+            }
+            const message = `${PROTOCOL_HEADER}${OTEL_TRACES_BINARY_PREFIX}${Buffer.from(serialized).toString('base64')}`;
+            sendMessage(socket, message, { host, port }, resultCallback);
+        },
+        forceFlush: () => Promise.resolve(),
+        shutdown: () => new Promise((resolve) => {
+            socket.close(() => resolve());
+        }),
+    };
+};
+
+const OTLP_HTTP_EXPORT_TIMEOUT_MS = 2000;
+const FLUSH_BUDGET_MS = 2500;
+const BATCH_DELAY_MS = 200;
+const getServiceName = () => process.env.OTEL_SERVICE_NAME ??
+    process.env.AWS_LAMBDA_FUNCTION_NAME ??
+    'lambda';
+const createSpanExporter = () => process.env.AWS_XRAY_DAEMON_ADDRESS
+    ? createOtlpUdpSpanExporter(process.env.AWS_XRAY_DAEMON_ADDRESS)
+    : new OTLPTraceExporter({ timeoutMillis: OTLP_HTTP_EXPORT_TIMEOUT_MS });
+const createTracingSdk = (options = {}) => {
+    const provider = new NodeTracerProvider({
+        idGenerator: new AWSXRayIdGenerator(),
+        resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: getServiceName() }),
+        spanProcessors: options.spanProcessors ?? [
+            new BatchSpanProcessor(createSpanExporter(), {
+                scheduledDelayMillis: BATCH_DELAY_MS,
+            }),
+        ],
+    });
+    provider.register({ propagator: new AWSXRayPropagator() });
+    registerInstrumentations({
+        instrumentations: [new UndiciInstrumentation(), new HttpInstrumentation()],
+    });
+    return {
+        forceFlush: () => provider.forceFlush(),
+        tracer: trace.getTracer('@allthings/cloud-toolkit/tracing'),
+    };
+};
+const sdk = process.env.OTEL_ENABLED === 'true' ? createTracingSdk() : undefined;
+const invocationParentContext = () => propagation.extract(context.active(), {
+    'x-amzn-trace-id': process.env._X_AMZN_TRACE_ID ?? '',
+});
+const finishSpan = (span, error) => {
+    if (error instanceof Error) {
+        span.recordException(error);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+    }
+    span.end();
+};
+const logFlushFailure = () => {
+    console.warn('OTel span flush failed');
+};
+const flushWithBudget = (flush) => Promise.race([
+    Promise.resolve().then(flush).catch(logFlushFailure),
+    new Promise((resolve) => {
+        setTimeout(resolve, FLUSH_BUDGET_MS).unref();
+    }),
+]);
+const getStatusCode = (result) => {
+    if (typeof result !== 'object' || result === null) {
+        return undefined;
+    }
+    const { statusCode } = result;
+    return typeof statusCode === 'number' ? statusCode : undefined;
+};
+const withInvocationSpan = async (attributes, run) => {
+    if (!sdk) {
+        return run();
+    }
+    const parent = invocationParentContext();
+    const span = sdk.tracer.startSpan(process.env.AWS_LAMBDA_FUNCTION_NAME ?? 'invocation', { attributes, kind: SpanKind.SERVER }, parent);
+    try {
+        const result = await context.with(trace.setSpan(parent, span), run);
+        const statusCode = getStatusCode(result);
+        if (statusCode !== undefined) {
+            span.setAttribute('http.response.status_code', statusCode);
+        }
+        if (statusCode !== undefined && statusCode >= 500) {
+            span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+        finishSpan(span);
+        return result;
+    }
+    catch (error) {
+        finishSpan(span, error);
+        throw error;
+    }
+    finally {
+        await flushWithBudget(sdk.forceFlush);
+    }
+};
+const withStageSpan = async (name, run) => {
+    if (!sdk) {
+        return run();
+    }
+    return sdk.tracer.startActiveSpan(name, async (span) => {
+        try {
+            const result = await run();
+            finishSpan(span);
+            return result;
+        }
+        catch (error) {
+            finishSpan(span, error);
+            throw error;
+        }
+    });
+};
+
+export { createOtlpUdpSpanExporter, createTracingSdk, withInvocationSpan, withStageSpan };

package/dist/utils.cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/dist/utils.esm.mjs

@@ -1,4 +1,4 @@
-const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }, (_, count) => list.slice(count * every, count * every + every));
 const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
     const transformed = await transformer(initialValue, iterationCount);
     return (await predicate(transformed, iterationCount))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allthings/cloud-toolkit",
-  "version": "5.3.2",
+  "version": "5.4.0-beta.1",
   "description": "",
   "author": "Allthings GmbH",
   "keywords": [
@@ -17,7 +17,7 @@
     "node": ">=24",
     "npm": ">=10"
   },
-  "packageManager": "yarn@4.18.0",
+  "packageManager": "yarn@4.18.1",
   "main": "dist/lib.cjs.js",
   "module": "dist/lib.esm.mjs",
   "types": "dist/src/index.d.ts",
@@ -67,6 +67,11 @@
       "import": "./dist/sqs.esm.mjs",
       "require": "./dist/sqs.cjs.js"
     },
+    "./tracing": {
+      "types": "./dist/src/tracing/index.d.ts",
+      "import": "./dist/tracing.esm.mjs",
+      "require": "./dist/tracing.cjs.js"
+    },
     "./utils": {
       "types": "./dist/src/utils.d.ts",
       "import": "./dist/utils.esm.mjs",
@@ -74,7 +79,10 @@
     },
     "./package.json": "./package.json"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/tracing.cjs.js",
+    "./dist/tracing.esm.mjs"
+  ],
   "typesVersions": {
     "*": {
       "alagarr": [
@@ -101,6 +109,9 @@
       "sqs": [
         "dist/src/aws/sqs.d.ts"
       ],
+      "tracing": [
+        "dist/src/tracing/index.d.ts"
+      ],
       "utils": [
         "dist/src/utils.d.ts"
       ]
@@ -146,31 +157,44 @@
     "@aws-sdk/client-sqs": "^3.1042.0",
     "@aws-sdk/client-ssm": "^3.1042.0",
     "@aws-sdk/lib-dynamodb": "^3.1042.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/core": "^2.12.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.223.0",
+    "@opentelemetry/id-generator-aws-xray": "^2.1.0",
+    "@opentelemetry/instrumentation": "^0.223.0",
+    "@opentelemetry/instrumentation-http": "^0.223.0",
+    "@opentelemetry/instrumentation-undici": "^0.33.0",
+    "@opentelemetry/otlp-transformer": "^0.223.0",
+    "@opentelemetry/propagator-aws-xray": "^2.2.0",
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-trace-node": "^2.12.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
     "@types/aws-lambda": "^8.10.162",
     "bottleneck": "^2.19.5",
     "nodemailer": "^10.0.0",
     "winston": "^3.19.0"
   },
   "devDependencies": {
-    "@allthings/eslint-config": "5.2.1",
-    "@commitlint/cli": "21.2.2",
-    "@commitlint/config-conventional": "21.2.2",
+    "@allthings/eslint-config": "5.4.2",
+    "@commitlint/cli": "21.2.3",
+    "@commitlint/config-conventional": "21.2.3",
+    "@opentelemetry/sdk-trace-base": "2.12.0",
     "@rollup/plugin-node-resolve": "16.0.3",
-    "@types/node": "24.13.3",
-    "@types/nodemailer": "8.0.1",
-    "@vitest/coverage-v8": "5.0.0",
+    "@types/node": "24.19.1",
+    "@types/nodemailer": "8.0.2",
+    "@vitest/coverage-v8": "5.0.3",
     "aws-sdk-client-mock": "4.1.0",
     "conventional-changelog-conventionalcommits": "9.3.1",
-    "eslint": "10.10.0",
+    "eslint": "10.12.0",
     "husky": "9.1.7",
-    "lint-staged": "17.5.0",
-    "prettier": "3.9.6",
+    "lint-staged": "17.6.0",
+    "prettier": "3.9.9",
     "rimraf": "6.1.3",
-    "rollup": "4.63.1",
+    "rollup": "4.64.0",
     "semantic-release": "25.0.9",
     "typescript": "6.0.3",
-    "vite": "8.2.2",
-    "vitest": "5.0.0"
+    "vite": "8.3.2",
+    "vitest": "5.0.3"
   },
   "prettier": {
     "printWidth": 80,