@digitraffic/common 2026.9.4-1 → 2026.9.4-2

package/dist/aws/infra/stack/dt-function.js

@@ -2,9 +2,8 @@ import { basename } from "node:path";
 import { Duration } from "aws-cdk-lib";
 import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
 import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
-import { ApplicationLogLevel, Architecture, AssetCode, Function as AwsFunction, Code, LayerVersion, LoggingFormat, Runtime, SystemLogLevel, Tracing, } from "aws-cdk-lib/aws-lambda";
-import { ManagedPolicy } from "aws-cdk-lib/aws-iam";
-import { camelCase, startCase } from "es-toolkit";
+import { ApplicationLogLevel, Architecture, AssetCode, Function as AwsFunction, Code, LoggingFormat, Runtime, SystemLogLevel, } from "aws-cdk-lib/aws-lambda";
+import { camelCase, kebabCase, startCase } from "es-toolkit";
 import { DatabaseEnvironmentKeys } from "../../../database/database.js";
 import { EnvKeys } from "../../runtime/environment.js";
 import { DtFunctionAlarms } from "./dt-function-alarms.js";
@@ -22,6 +21,7 @@ export class FunctionBuilder {
     functionName;
     environment = {};
     vpc;
+    storageSize;
     alarms = new DtFunctionAlarms();
     // these will be overridden in constructor, but inspection won't see it, so set some default values.
     code = Code.fromInline("placeholder");
@@ -30,7 +30,6 @@ export class FunctionBuilder {
     securityGroups = [];
     policyStatements = [];
     allowedActions = [];
-    _adotTracing = false;
     _features = {
         databaseAccess: true,
         secretAccess: true,
@@ -41,13 +40,7 @@ export class FunctionBuilder {
         this.functionName = `${stack.configuration.shortName}-${startCase(camelCase(lambdaName)).replace(/\s/g, "")}`;
         this.environment = {};
         this.vpc = stack.vpc;
-        // this calls withHandler as well but with full path
         this.withAssetCode(lambdaName);
-        // Remove path from lambda to get module name.
-        // e.g. for lambdaName "api/charging-network/v1/operators",
-        // moduleName becomes "operators" and handler becomes "operators.handler"
-        const moduleName = basename(lambdaName);
-        this.withHandler(moduleName);
     }
     /**
      * Creates a new builder with defaults, using the lambdaName as a source for the lambda implementation (dist/lambdaName/lambdaName.js).
@@ -65,11 +58,22 @@ export class FunctionBuilder {
             .withoutSecretAccess();
     }
     /**
-     * Use AssetCode from given path(dist/lambda/${path}).  Default path is lambdaName. Also calls withHandler with the same value.
+     * Sets the Lambda deployment package to the directory `dist/lambda/${path}` and configures
+     * the handler to `basename(path).handler`.
+     * @param path - subdirectory under `dist/lambda/` that contains the compiled Lambda code.
+     *   The handler module name is derived from `basename(path)` (e.g. `"locations.handler"`).
+     *   Defaults to `lambdaName`.
+     *   Example: `"dump/locations"` → asset dir `dist/lambda/dump/locations/`, handler `locations.handler`.
+     * @param exclude - optional glob patterns to exclude from the asset bundle.
+     *   Patterns are relative to the asset root (`dist/lambda/${path}/`) — do NOT use a leading slash.
+     *   Use `**` to match files recursively.
+     *   Example: `["datex2-36", "datex2-37", "statuses"]` excludes sibling lambda subdirectories
+     *   that would otherwise be bundled into this lambda's deployment package.
      */
-    withAssetCode(path = this._name) {
-        this.code = new AssetCode(`dist/lambda/${path}`);
-        this.withHandler(path);
+    withAssetCode(path = this._name, exclude) {
+        this.code = new AssetCode(`dist/lambda/${path}`, exclude ? { exclude } : undefined);
+        const moduleName = basename(path);
+        this.withHandler(moduleName);
         return this;
     }
     withCode(code) {
@@ -126,19 +130,17 @@ export class FunctionBuilder {
         return this;
     }
     /**
-     * Add Lambda layers.
+     * Set storage size for the lambda.  Defaults to AWS default (512MB).
      */
-    withLayers(...layers) {
-        this.layers.push(...layers);
+    withStorageSize(storageSize) {
+        this.storageSize = storageSize;
         return this;
     }
     /**
-     * Enable ADOT (AWS Distro for OpenTelemetry) tracing for this Lambda.
-     * Adds the ADOT Lambda layer, enables X-Ray active tracing,
-     * sets required environment variables, and attaches IAM permissions.
+     * Add Lambda layers.
      */
-    withAdotTracing() {
-        this._adotTracing = true;
+    withLayers(...layers) {
+        this.layers.push(...layers);
         return this;
     }
     /**
@@ -219,7 +221,6 @@ export class FunctionBuilder {
             }
             : undefined;
         const securityGroups = this.getSecurityGroups();
-        const layers = this.getLayers();
         const createdFunction = new AwsFunction(this._stack, this.functionName, {
             vpc: this.vpc,
             vpcSubnets,
@@ -239,15 +240,12 @@ export class FunctionBuilder {
             securityGroups,
             environment: this.getEnvironment(),
             description: this.description,
-            layers: layers.length > 0 ? layers : undefined,
-            tracing: this._adotTracing ? Tracing.ACTIVE : undefined,
+            layers: this.layers.length > 0 ? this.layers : undefined,
+            ephemeralStorageSize: this.storageSize,
         });
         if (this._features.secretAccess) {
             this._stack.grantSecret(createdFunction);
         }
-        if (this._adotTracing) {
-            createdFunction.role?.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName("CloudWatchLambdaApplicationSignalsExecutionRolePolicy"));
-        }
         this.attachPolicies(createdFunction);
         this.createAlarms(createdFunction);
         return createdFunction;
@@ -270,37 +268,22 @@ export class FunctionBuilder {
             throw new Error(`Lambda ${this.functionName} cannot use wildcard action "*" in withAllowedActions. Please specify explicit actions.`);
         }
     }
-    getLayers() {
-        const layers = [...this.layers];
-        if (this._adotTracing) {
-            const layerName = this.runtime.name.startsWith("python")
-                ? "AWSOpenTelemetryDistroPython"
-                : "AWSOpenTelemetryDistroJs";
-            layers.push(LayerVersion.fromLayerVersionArn(this._stack, `${this.functionName}-AdotLayer`, `arn:aws:lambda:eu-west-1:615299751070:layer:${layerName}:1`));
-        }
-        return layers;
-    }
     getEnvironment() {
-        let environment = {};
-        if (this._features.secretAccess) {
+        let environment = {
+            [EnvKeys.APP_NAME]: `${this._stack.configuration.trafficType.toLowerCase()}-${kebabCase(this._stack.configuration.shortName)}`,
+        };
+        if (this._features.secretAccess && this._stack.configuration.secretId) {
             environment = {
                 ...environment,
                 [EnvKeys.SECRET_ID]: this._stack.configuration.secretId,
             };
         }
-        if (this._features.databaseAccess) {
+        if (this._features.databaseAccess && this._stack.configuration.shortName) {
             environment = {
                 ...environment,
                 [DatabaseEnvironmentKeys.DB_APPLICATION]: this._stack.configuration.shortName,
             };
         }
-        if (this._adotTracing) {
-            environment = {
-                ...environment,
-                AWS_LAMBDA_EXEC_WRAPPER: "/opt/otel-instrument",
-                OTEL_AWS_APPLICATION_SIGNALS_ENABLED: "false",
-            };
-        }
         return { ...environment, ...this.environment };
     }
     createAlarms(lambda) {

package/dist/aws/infra/stack/stack-checking-aspect.js

@@ -4,8 +4,7 @@ import { CfnFunction, Runtime } from "aws-cdk-lib/aws-lambda";
 import { LogRetention } from "aws-cdk-lib/aws-logs";
 import { CfnBucket } from "aws-cdk-lib/aws-s3";
 import { CfnQueue } from "aws-cdk-lib/aws-sqs";
-import { kebabCase } from "change-case";
-import { snakeCase } from "es-toolkit";
+import { kebabCase, snakeCase } from "es-toolkit";
 import { DigitrafficStack, SOLUTION_KEY } from "./stack.js";
 const MAX_CONCURRENCY_LIMIT = 100;
 const ALLOWED_RUNTIMES = [

package/dist/aws/infra/stack/stack.d.ts

@@ -20,6 +20,8 @@ export interface StackConfiguration {
     readonly lambdaDbSgId?: string;
     readonly privateSubnetIds?: string[];
     readonly availabilityZones?: string[];
+    readonly dbWriterHost?: string;
+    readonly dbReaderHost?: string;
     readonly trafficType: TrafficType;
     readonly production: boolean;
     readonly stackProps: StackProps;

package/dist/aws/infra/stack/stack.js

@@ -3,6 +3,8 @@ import { SecurityGroup, Vpc } from "aws-cdk-lib/aws-ec2";
 import { Secret } from "aws-cdk-lib/aws-secretsmanager";
 import { Topic } from "aws-cdk-lib/aws-sns";
 import { StringParameter } from "aws-cdk-lib/aws-ssm";
+import { kebabCase } from "es-toolkit";
+import { EnvKeys } from "../../runtime/environment.js";
 import { StackCheckingAspect } from "./stack-checking-aspect.js";
 const SSM_ROOT = "/digitraffic";
 export const SOLUTION_KEY = "Solution";
@@ -46,14 +48,13 @@ export class DigitrafficStack extends Stack {
         return this.createDefaultLambdaEnvironment(this.configuration.shortName);
     }
     createDefaultLambdaEnvironment(dbApplication) {
-        return this.configuration.secretId
-            ? {
-                SECRET_ID: this.configuration.secretId,
-                DB_APPLICATION: dbApplication,
-            }
-            : {
-                DB_APPLICATION: dbApplication,
-            };
+        return {
+            [EnvKeys.APP_NAME]: `${this.configuration.trafficType.toLowerCase()}-${kebabCase(this.configuration.shortName)}`,
+            DB_APPLICATION: dbApplication,
+            ...(this.configuration.secretId
+                ? { [EnvKeys.SECRET_ID]: this.configuration.secretId }
+                : {}),
+        };
     }
     getSecret() {
         if (this.secret === undefined) {

package/dist/aws/runtime/dt-logger.d.ts

@@ -61,6 +61,7 @@ export interface LoggableType extends CustomParams {
  * * the actual message (as json or as string)
  */
 export declare class DtLogger {
+    readonly appName?: string;
     readonly lambdaName?: string;
     readonly runtime?: string;
     readonly writeStream: Writable;

package/dist/aws/runtime/dt-logger.js

@@ -1,5 +1,6 @@
 import { lowerFirst, mapKeys } from "es-toolkit";
 import { getEnvVariableOrElse } from "../../utils/utils.js";
+import { EnvKeys } from "./environment.js";
 /**
  * Helper class for json-logging.
  *
@@ -10,6 +11,7 @@ import { getEnvVariableOrElse } from "../../utils/utils.js";
  * * the actual message (as json or as string)
  */
 export class DtLogger {
+    appName;
     lambdaName;
     runtime;
     writeStream;
@@ -19,6 +21,7 @@ export class DtLogger {
      * @param {LoggerConfiguration?} [config] - Accepts configuration options @see {@link LoggerConfiguration}
      */
     constructor(config) {
+        this.appName = getEnvVariableOrElse(EnvKeys.APP_NAME, undefined);
         this.lambdaName =
             config?.lambdaName ??
                 getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "unknown lambda name");
@@ -38,6 +41,7 @@ export class DtLogger {
         const logMessage = {
             message,
             level: "DEBUG",
+            app: this.appName,
             lambdaName: this.lambdaName,
             runtime: this.runtime,
         };
@@ -112,6 +116,7 @@ export class DtLogger {
             ...messageFields,
             error,
             stack,
+            app: this.appName,
             lambdaName: this.lambdaName,
             runtime: this.runtime,
         };

package/dist/aws/runtime/environment.d.ts

@@ -1,4 +1,5 @@
 export declare enum EnvKeys {
+    APP_NAME = "APP_NAME",
     AWS_REGION = "AWS_REGION",
     SECRET_ID = "SECRET_ID",
     SECRET_OVERRIDE_AWS_REGION = "SECRET_OVERRIDE_AWS_REGION"

package/dist/aws/runtime/environment.js

@@ -1,5 +1,6 @@
 export var EnvKeys;
 (function (EnvKeys) {
+    EnvKeys["APP_NAME"] = "APP_NAME";
     EnvKeys["AWS_REGION"] = "AWS_REGION";
     EnvKeys["SECRET_ID"] = "SECRET_ID";
     EnvKeys["SECRET_OVERRIDE_AWS_REGION"] = "SECRET_OVERRIDE_AWS_REGION";

package/dist/aws/runtime/secrets/proxy-holder.d.ts

@@ -1,9 +1,14 @@
+import type { RdsProxySecret } from "./dbsecret.js";
+import { SecretHolder } from "./secret-holder.js";
 /**
  * Holds credentials for RDS Proxy access.
  */
 export declare class ProxyHolder {
     private readonly secretHolder;
-    constructor(secretId: string);
+    private constructor();
+    /** Creates a new instance of ProxyHolder from given SecretHolder. */
+    static create(secretHolder: SecretHolder<RdsProxySecret>): ProxyHolder;
+    /** Creates a new instance of ProxyHolder with a new default SecretHolder(using env variable SECRET_ID). */
     static create(): ProxyHolder;
     setCredentials(): Promise<void>;
 }

package/dist/aws/runtime/secrets/proxy-holder.js

@@ -8,11 +8,13 @@ const RDS_PROXY_SECRET_KEYS = Object.values(RdsProxySecretKey);
  */
 export class ProxyHolder {
     secretHolder;
-    constructor(secretId) {
-        this.secretHolder = new SecretHolder(secretId, "", RDS_PROXY_SECRET_KEYS);
+    constructor(secretHolder) {
+        this.secretHolder = secretHolder;
     }
-    static create() {
-        return new ProxyHolder(getEnvVariable("SECRET_ID"));
+    static create(secretHolder) {
+        const holder = secretHolder ??
+            new SecretHolder(getEnvVariable("SECRET_ID"), "", RDS_PROXY_SECRET_KEYS);
+        return new ProxyHolder(holder);
     }
     async setCredentials() {
         const secret = await this.secretHolder.get();

package/dist/aws/runtime/secrets/rds-holder.d.ts

@@ -1,9 +1,12 @@
+import type { RdsSecret } from "./dbsecret.js";
+import { SecretHolder } from "./secret-holder.js";
 /**
  * Holds credentials for RDS access.
  */
 export declare class RdsHolder {
     private readonly secretHolder;
-    constructor(secretId: string);
+    private constructor();
+    static create(rdsHolder: SecretHolder<RdsSecret>): RdsHolder;
     static create(): RdsHolder;
     setCredentials(): Promise<void>;
 }

package/dist/aws/runtime/secrets/rds-holder.js

@@ -8,11 +8,13 @@ const RDS_SECRET_KEYS = Object.values(RdsSecretKey);
  */
 export class RdsHolder {
     secretHolder;
-    constructor(secretId) {
-        this.secretHolder = new SecretHolder(secretId, "", RDS_SECRET_KEYS);
+    constructor(secretHolder) {
+        this.secretHolder = secretHolder;
     }
-    static create() {
-        return new RdsHolder(getEnvVariable("SECRET_ID"));
+    static create(secretHolder) {
+        const holder = secretHolder ??
+            new SecretHolder(getEnvVariable("SECRET_ID"), "", RDS_SECRET_KEYS);
+        return new RdsHolder(holder);
     }
     async setCredentials() {
         const secret = await this.secretHolder.get();

package/dist/database/database.d.ts

@@ -1,4 +1,4 @@
-import { type IDatabase, type ITask } from "pg-promise";
+import type { IDatabase, ITask } from "pg-promise";
 export declare enum DatabaseEnvironmentKeys {
     DB_USER = "DB_USER",
     DB_PASS = "DB_PASS",

package/dist/database/database.js

@@ -1,4 +1,4 @@
-import pgpImport, {} from "pg-promise";
+import pgpImport from "pg-promise";
 import { logger } from "../aws/runtime/dt-logger-default.js";
 import { logException } from "../utils/logging.js";
 import { getEnvVariable, getEnvVariableOrElse } from "../utils/utils.js";

package/dist/utils/lead-time-logging.d.ts

@@ -0,0 +1,10 @@
+import type { CustomParams } from "../aws/runtime/dt-logger.js";
+export interface LeadTimeLogging {
+    readonly target: string;
+    readonly leadTimeMs?: number;
+    readonly processTimeMs?: number;
+    readonly extraFields?: CustomParams;
+}
+export type LeadTimeType = "lead-time" | "process-time" | "mqtt-time";
+export declare function logLeadTime(name: LeadTimeType, target: string, tookMs: number, extraFields?: CustomParams): void;
+export declare function logLeadTimes(ptl: LeadTimeLogging): void;

package/dist/utils/lead-time-logging.js

@@ -0,0 +1,33 @@
+import { logger } from "../aws/runtime/dt-logger-default.js";
+export function logLeadTime(name, target, tookMs, extraFields) {
+    const method = "LeadTimeLogging.logLeadTime";
+    try {
+        logger.info({
+            ...(extraFields ?? {}),
+            method,
+            customLeadTime: true,
+            customName: name,
+            customTarget: target,
+            tookMs,
+        });
+    }
+    catch (error) {
+        logger.error({
+            method,
+            message: "Error logging lead time",
+            error,
+        });
+    }
+}
+function isSafe(value) {
+    return Number.isSafeInteger(value);
+}
+export function logLeadTimes(ptl) {
+    if (isSafe(ptl.leadTimeMs)) {
+        logLeadTime("lead-time", ptl.target, ptl.leadTimeMs, ptl.extraFields);
+    }
+    if (isSafe(ptl.processTimeMs)) {
+        logLeadTime("process-time", ptl.target, ptl.processTimeMs, ptl.extraFields);
+    }
+}
+//# sourceMappingURL=lead-time-logging.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2026.9.4-1",
+  "version": "2026.9.4-2",
   "private": false,
   "description": "",
   "repository": {