@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/aws/infra/sqs-queue.js

@@ -0,0 +1,145 @@
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { Duration } from "aws-cdk-lib";
+import { ComparisonOperator, TreatMissingData, } from "aws-cdk-lib/aws-cloudwatch";
+import { SnsAction } from "aws-cdk-lib/aws-cloudwatch-actions";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { InlineCode, Runtime } from "aws-cdk-lib/aws-lambda";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { BlockPublicAccess, Bucket } from "aws-cdk-lib/aws-s3";
+import { Queue, QueueEncryption } from "aws-cdk-lib/aws-sqs";
+import { logger } from "../runtime/dt-logger-default.js";
+import { createLambdaLogGroup } from "./stack/lambda-log-group.js";
+import { MonitoredFunction } from "./stack/monitoredfunction.js";
+const DLQ_LAMBDA_CODE = `
+import type { ObjectCannedACL } from "@aws-sdk/client-s3";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { type NodeJsRuntimeStreamingBlobPayloadInputTypes } from "@smithy/types";
+import { logger } from "./dt-logger-default.mjs";
+
+
+const bucketName = "__bucketName__";
+
+__upload__
+
+exports.handler = async (event) => __handler__
+`;
+/**
+ * Construct for creating SQS-queues.
+ *
+ * If you don't config your own deadLetterQueue, this will create a dlq for you, also a lambda function, a s3 bucket
+ * and an alarm for the queue.  Anything that goes to the dlq will be written into the bucket and the alarm is activated.
+ */
+export class DigitrafficSqsQueue extends Queue {
+    static create(stack, name, props) {
+        const queueName = `${stack.configuration.shortName}-${name}-Queue`;
+        const queueProps = {
+            ...props,
+            encryption: QueueEncryption.KMS_MANAGED,
+            queueName,
+            deadLetterQueue: props.deadLetterQueue ?? {
+                maxReceiveCount: 2,
+                queue: DigitrafficDLQueue.create(stack, name),
+            },
+        };
+        return new DigitrafficSqsQueue(stack, queueName, queueProps);
+    }
+    /**
+     * Create a fifo with given name.  No DLQ created!
+     */
+    static createFifo(stack, name, props) {
+        const queueName = `${stack.configuration.shortName}-${name}-Queue.fifo`;
+        const queueProps = {
+            ...props,
+            encryption: QueueEncryption.KMS_MANAGED,
+            queueName,
+        };
+        return new DigitrafficSqsQueue(stack, queueName, queueProps);
+    }
+}
+export const DigitrafficDLQueue = {
+    create(stack, name) {
+        const dlqName = `${stack.configuration.shortName}-${name}-DLQ`;
+        const dlqFunctionName = `${dlqName}-Function`;
+        const dlq = new DigitrafficSqsQueue(stack, dlqName, {
+            queueName: dlqName,
+            visibilityTimeout: Duration.seconds(60),
+            encryption: QueueEncryption.KMS_MANAGED,
+        });
+        const dlqBucket = new Bucket(stack, `${dlqName}-Bucket`, {
+            blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
+        });
+        const dlqLogGroup = createLambdaLogGroup({
+            stack,
+            functionName: dlqFunctionName,
+        });
+        const lambda = MonitoredFunction.create(stack, dlqFunctionName, {
+            runtime: Runtime.NODEJS_24_X,
+            logGroup: dlqLogGroup,
+            functionName: dlqFunctionName,
+            code: getDlqCode(dlqBucket.bucketName),
+            timeout: Duration.seconds(10),
+            handler: "index.handler",
+            memorySize: 128,
+            reservedConcurrentExecutions: 1,
+        });
+        const statement = new PolicyStatement();
+        statement.addActions("s3:PutObject");
+        statement.addActions("s3:PutObjectAcl");
+        statement.addResources(`${dlqBucket.bucketArn}/*`);
+        lambda.addToRolePolicy(statement);
+        lambda.addEventSource(new SqsEventSource(dlq));
+        addDLQAlarm(stack, dlqName, dlq);
+        return dlq;
+    },
+};
+function addDLQAlarm(stack, dlqName, dlq) {
+    const alarmName = `${dlqName}-Alarm`;
+    dlq
+        .metricNumberOfMessagesReceived({
+        period: Duration.minutes(5),
+    })
+        .createAlarm(stack, alarmName, {
+        alarmName,
+        threshold: 0,
+        evaluationPeriods: 1,
+        treatMissingData: TreatMissingData.NOT_BREACHING,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_THRESHOLD,
+    })
+        .addAlarmAction(new SnsAction(stack.warningTopic));
+}
+function getDlqCode(Bucket) {
+    const functionBody = DLQ_LAMBDA_CODE.replace("__bucketName__", Bucket)
+        .replace("__upload__", uploadToS3.toString())
+        .replace("__handler__", createHandler().toString().substring(23)); // remove function handler() from signature
+    return new InlineCode(functionBody);
+}
+async function uploadToS3(s3, bucketName, body, objectName, cannedAcl, contentType) {
+    const command = new PutObjectCommand({
+        Bucket: bucketName,
+        Key: objectName,
+        Body: body,
+        ACL: cannedAcl,
+        ContentType: contentType,
+    });
+    try {
+        await s3.send(command);
+    }
+    catch (_error) {
+        logger.error({
+            method: "s3.uploadToS3",
+            message: `upload failed to bucket ${bucketName}`,
+        });
+    }
+}
+// bucketName is unused, will be overridden in the actual lambda code below
+const bucketName = "";
+function createHandler() {
+    return async function handler(event) {
+        const millis = Date.now();
+        const s3 = new S3Client({});
+        await Promise.all(event.Records.map((e, idx) => {
+            return uploadToS3(s3, bucketName, e.body, `dlq-${millis}-${idx}.json`);
+        }));
+    };
+}
+//# sourceMappingURL=sqs-queue.js.map

package/dist/aws/infra/stack/dt-function-alarms.d.ts

@@ -0,0 +1,29 @@
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+export interface AlarmProps {
+    readonly threshold?: number;
+    readonly evaluationPeriods: number;
+    readonly datapointsToAlarm: number;
+    readonly comparisonOperator: ComparisonOperator;
+}
+export declare class DtFunctionAlarms {
+    durationAlarm?: AlarmProps;
+    durationWarning?: AlarmProps;
+    errorAlarms?: AlarmProps;
+    throttleAlarm?: AlarmProps;
+    /**
+     * Set throttle alarm.  Undefined disables the alarm.
+     */
+    withThrottleAlarm(throttleAlarm?: AlarmProps): this;
+    /**
+     * Set error alarm.  Undefined disables the alarm.
+     */
+    withErrorAlarm(errorAlarm?: AlarmProps): this;
+    /**
+     * Set duration alarm.  Undefined disables the alarm.
+     */
+    withDurationAlarm(durationAlarmn?: AlarmProps): this;
+    /**
+     * Set duration warning.  Undefined disables the warning.
+     */
+    withDurationWarning(durationWarning?: AlarmProps): this;
+}

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

@@ -0,0 +1,54 @@
+import { ComparisonOperator } from "aws-cdk-lib/aws-cloudwatch";
+export class DtFunctionAlarms {
+    durationAlarm = {
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+    };
+    durationWarning = {
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+    };
+    errorAlarms = {
+        threshold: 1,
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+    };
+    throttleAlarm = {
+        threshold: 1,
+        evaluationPeriods: 1,
+        datapointsToAlarm: 1,
+        comparisonOperator: ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+    };
+    /**
+     * Set throttle alarm.  Undefined disables the alarm.
+     */
+    withThrottleAlarm(throttleAlarm) {
+        this.throttleAlarm = throttleAlarm;
+        return this;
+    }
+    /**
+     * Set error alarm.  Undefined disables the alarm.
+     */
+    withErrorAlarm(errorAlarm) {
+        this.errorAlarms = errorAlarm;
+        return this;
+    }
+    /**
+     * Set duration alarm.  Undefined disables the alarm.
+     */
+    withDurationAlarm(durationAlarmn) {
+        this.durationAlarm = durationAlarmn;
+        return this;
+    }
+    /**
+     * Set duration warning.  Undefined disables the warning.
+     */
+    withDurationWarning(durationWarning) {
+        this.durationWarning = durationWarning;
+        return this;
+    }
+}
+//# sourceMappingURL=dt-function-alarms.js.map

package/dist/aws/infra/stack/dt-function.d.ts

@@ -0,0 +1,124 @@
+import type { Stack } from "aws-cdk-lib";
+import { Duration } from "aws-cdk-lib";
+import type { ISecurityGroup } from "aws-cdk-lib/aws-ec2";
+import type { IRole } from "aws-cdk-lib/aws-iam";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import type { ILayerVersion } from "aws-cdk-lib/aws-lambda";
+import { Architecture, Function as AwsFunction, Code, Runtime } from "aws-cdk-lib/aws-lambda";
+import { DtFunctionAlarms } from "./dt-function-alarms.js";
+import type { LambdaEnvironment } from "./lambda-configs.js";
+import type { DigitrafficStackLike } from "./stack.js";
+export declare class FunctionBuilder {
+    private readonly _stack;
+    private readonly _name;
+    private description?;
+    private runtime;
+    private architecture;
+    private role?;
+    private timeout;
+    private reservedConcurrentExecutions;
+    private memorySize;
+    private functionName;
+    private environment;
+    private vpc?;
+    private alarms;
+    private code;
+    private handler;
+    private readonly layers;
+    private readonly securityGroups;
+    private readonly policyStatements;
+    private readonly allowedActions;
+    private readonly _features;
+    constructor(stack: Stack & DigitrafficStackLike, lambdaName: string);
+    /**
+     * Creates a new builder with defaults, using the lambdaName as a source for the lambda implementation (dist/lambdaName/lambdaName.js).
+     * Database access is given by default.
+     */
+    static create(stack: Stack & DigitrafficStackLike, lambdaName: string): FunctionBuilder;
+    /**
+     * Creates a new builder with defaults, but without database or secret access.
+     */
+    static plain(stack: Stack & DigitrafficStackLike, lambdaName: string): FunctionBuilder;
+    /**
+     * Stack only has one lambda.  Default is that it has multiple lambdas.
+     */
+    singleLambda(): this;
+    /**
+     * Use AssetCode from given path(dist/lambda/${path}).  Default path is lambdaName. Also calls withHandler with the same value.
+     */
+    withAssetCode(path?: string): this;
+    withCode(code: Code): this;
+    /**
+     * Use given handler(${name}.handler) to run the lambda.  Default value is lambdaName.
+     * @param name
+     * @param handlerFunctionName
+     * @returns
+     */
+    withHandler(name: string, handlerFunctionName?: string): this;
+    withDescription(description: string): this;
+    /**
+     * Do not grant database access.  Default is with database access.
+     */
+    withoutDatabaseAccess(): this;
+    /**
+     * Do not grant secret access.  Default is with secret access.
+     */
+    withoutSecretAccess(): this;
+    /**
+     * Add given security groups to the lambda.
+     */
+    withSecurityGroup(...groups: ISecurityGroup[]): this;
+    /**
+     * Set memorySize(in MB) for the lambda.  Default is 128 MB.
+     */
+    withMemorySize(memorySize: number): this;
+    /**
+     * Set runtime for the lambda.  Default is Runtime.NODEJS_24_X.
+     */
+    withRuntime(runtime: Runtime): this;
+    /**
+     * Add Lambda layers.
+     */
+    withLayers(...layers: ILayerVersion[]): this;
+    /**
+     * Set architecture for the lambda.  Default is Architecture.ARM_64.
+     */
+    withArchitecture(architecture: Architecture): this;
+    /**
+     * Set timeout for the lambda.  Default is Duration.seconds(60).
+     */
+    withTimeout(timeout: Duration): this;
+    /**
+     * Set reservedConcurrectExecutions for the lambda.  Default is 2.
+     */
+    withReservedConcurrentExecutions(executions: number): this;
+    /**
+     * Set role for the lambda.  Default is no role.
+     */
+    withRole(role: IRole): this;
+    /**
+     * Set environment for the lambda.  Default environment comes from the DigitrafficStack and
+     * this does not clear it, only adds to the default values.
+     */
+    withEnvironment(environment: LambdaEnvironment): this;
+    /**
+     * Configure alarms for the lambda. By default, all alarms are added.
+     */
+    withAlarms(alarms: DtFunctionAlarms): this;
+    /**
+     * Add a policy statement to the lambda's role.
+     */
+    withRolePolicies(...policies: PolicyStatement[]): this;
+    /**
+     * Add allowed actions to the lambda's role. Creates a policy statement that allows
+     * the specified actions on all resources (*).
+     */
+    withAllowedActions(...actions: string[]): this;
+    private getSecurityGroups;
+    build(): AwsFunction;
+    private attachPolicies;
+    private validateNoWildcardActions;
+    private getEnvironment;
+    private createAlarms;
+    private createAlarm;
+}

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

@@ -0,0 +1,315 @@
+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, LoggingFormat, Runtime, SystemLogLevel, } from "aws-cdk-lib/aws-lambda";
+import { camelCase, startCase } from "es-toolkit";
+import { DatabaseEnvironmentKeys } from "../../../database/database.js";
+import { EnvKeys } from "../../runtime/environment.js";
+import { DtFunctionAlarms } from "./dt-function-alarms.js";
+import { createLambdaLogGroup } from "./lambda-log-group.js";
+export class FunctionBuilder {
+    _stack;
+    _name;
+    description;
+    runtime = Runtime.NODEJS_24_X;
+    architecture = Architecture.ARM_64;
+    role;
+    timeout = Duration.seconds(60);
+    reservedConcurrentExecutions = 2;
+    memorySize = 128;
+    functionName;
+    environment = {};
+    vpc;
+    alarms = new DtFunctionAlarms();
+    // these will be overridden in constructor, but inspection won't see it, so set some default values.
+    code = Code.fromInline("placeholder");
+    handler = "";
+    layers = [];
+    securityGroups = [];
+    policyStatements = [];
+    allowedActions = [];
+    _features = {
+        singleLambda: false,
+        databaseAccess: true,
+        secretAccess: true,
+    };
+    constructor(stack, lambdaName) {
+        this._name = lambdaName;
+        this._stack = stack;
+        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).
+     * Database access is given by default.
+     */
+    static create(stack, lambdaName) {
+        return new FunctionBuilder(stack, lambdaName);
+    }
+    /**
+     * Creates a new builder with defaults, but without database or secret access.
+     */
+    static plain(stack, lambdaName) {
+        return new FunctionBuilder(stack, lambdaName)
+            .withoutDatabaseAccess()
+            .withoutSecretAccess();
+    }
+    /**
+     * Stack only has one lambda.  Default is that it has multiple lambdas.
+     */
+    singleLambda() {
+        this._features.singleLambda = true;
+        return this;
+    }
+    /**
+     * Use AssetCode from given path(dist/lambda/${path}).  Default path is lambdaName. Also calls withHandler with the same value.
+     */
+    withAssetCode(path = this._name) {
+        const lambdaPath = this._features.singleLambda
+            ? `dist/lambda/`
+            : `dist/lambda/${path}`;
+        this.code = new AssetCode(lambdaPath);
+        this.withHandler(path);
+        return this;
+    }
+    withCode(code) {
+        this.code = code;
+        return this;
+    }
+    /**
+     * Use given handler(${name}.handler) to run the lambda.  Default value is lambdaName.
+     * @param name
+     * @param handlerFunctionName
+     * @returns
+     */
+    withHandler(name, handlerFunctionName = "handler") {
+        this.handler = `${name}.${handlerFunctionName}`;
+        return this;
+    }
+    withDescription(description) {
+        this.description = description;
+        return this;
+    }
+    /**
+     * Do not grant database access.  Default is with database access.
+     */
+    withoutDatabaseAccess() {
+        this._features.databaseAccess = false;
+        return this;
+    }
+    /**
+     * Do not grant secret access.  Default is with secret access.
+     */
+    withoutSecretAccess() {
+        this._features.secretAccess = false;
+        return this;
+    }
+    /**
+     * Add given security groups to the lambda.
+     */
+    withSecurityGroup(...groups) {
+        this.securityGroups.push(...groups);
+        return this;
+    }
+    /**
+     * Set memorySize(in MB) for the lambda.  Default is 128 MB.
+     */
+    withMemorySize(memorySize) {
+        this.memorySize = memorySize;
+        return this;
+    }
+    /**
+     * Set runtime for the lambda.  Default is Runtime.NODEJS_24_X.
+     */
+    withRuntime(runtime) {
+        this.runtime = runtime;
+        return this;
+    }
+    /**
+     * Add Lambda layers.
+     */
+    withLayers(...layers) {
+        this.layers.push(...layers);
+        return this;
+    }
+    /**
+     * Set architecture for the lambda.  Default is Architecture.ARM_64.
+     */
+    withArchitecture(architecture) {
+        this.architecture = architecture;
+        return this;
+    }
+    /**
+     * Set timeout for the lambda.  Default is Duration.seconds(60).
+     */
+    withTimeout(timeout) {
+        this.timeout = timeout;
+        return this;
+    }
+    /**
+     * Set reservedConcurrectExecutions for the lambda.  Default is 2.
+     */
+    withReservedConcurrentExecutions(executions) {
+        this.reservedConcurrentExecutions = executions;
+        return this;
+    }
+    /**
+     * Set role for the lambda.  Default is no role.
+     */
+    withRole(role) {
+        this.role = role;
+        return this;
+    }
+    /**
+     * Set environment for the lambda.  Default environment comes from the DigitrafficStack and
+     * this does not clear it, only adds to the default values.
+     */
+    withEnvironment(environment) {
+        this.environment = { ...this.environment, ...environment };
+        return this;
+    }
+    /**
+     * Configure alarms for the lambda. By default, all alarms are added.
+     */
+    withAlarms(alarms) {
+        this.alarms = alarms;
+        return this;
+    }
+    /**
+     * Add a policy statement to the lambda's role.
+     */
+    withRolePolicies(...policies) {
+        this.policyStatements.push(...policies);
+        return this;
+    }
+    /**
+     * Add allowed actions to the lambda's role. Creates a policy statement that allows
+     * the specified actions on all resources (*).
+     */
+    withAllowedActions(...actions) {
+        this.allowedActions.push(...actions);
+        return this;
+    }
+    getSecurityGroups() {
+        if (this._features.databaseAccess) {
+            if (!this._stack.lambdaDbSg) {
+                throw new Error("Lambda db security group no defined");
+            }
+            return [...this.securityGroups, this._stack.lambdaDbSg];
+        }
+        return this.securityGroups;
+    }
+    build() {
+        const logGroup = createLambdaLogGroup({
+            stack: this._stack,
+            functionName: this.functionName,
+        });
+        const vpcSubnets = this._stack.vpc
+            ? {
+                subnets: this._stack.vpc.privateSubnets,
+            }
+            : undefined;
+        const securityGroups = this.getSecurityGroups();
+        const createdFunction = new AwsFunction(this._stack, this.functionName, {
+            vpc: this.vpc,
+            vpcSubnets,
+            loggingFormat: LoggingFormat.JSON,
+            applicationLogLevelV2: ApplicationLogLevel.DEBUG,
+            systemLogLevelV2: SystemLogLevel.INFO,
+            runtime: this.runtime,
+            architecture: this.architecture,
+            code: this.code,
+            handler: this.handler,
+            role: this.role,
+            timeout: this.timeout,
+            logGroup,
+            reservedConcurrentExecutions: this.reservedConcurrentExecutions,
+            memorySize: this.memorySize,
+            functionName: this.functionName,
+            securityGroups,
+            environment: this.getEnvironment(),
+            description: this.description,
+            layers: this.layers.length > 0 ? this.layers : undefined,
+        });
+        if (this._features.secretAccess) {
+            this._stack.grantSecret(createdFunction);
+        }
+        this.attachPolicies(createdFunction);
+        this.createAlarms(createdFunction);
+        return createdFunction;
+    }
+    attachPolicies(lambda) {
+        this.validateNoWildcardActions();
+        for (const policyStatement of this.policyStatements) {
+            lambda.addToRolePolicy(policyStatement);
+        }
+        if (this.allowedActions.length > 0) {
+            lambda.addToRolePolicy(new PolicyStatement({
+                effect: Effect.ALLOW,
+                actions: this.allowedActions,
+                resources: ["*"],
+            }));
+        }
+    }
+    validateNoWildcardActions() {
+        if (this.allowedActions.includes("*")) {
+            throw new Error(`Lambda ${this.functionName} cannot use wildcard action "*" in withAllowedActions. Please specify explicit actions.`);
+        }
+    }
+    getEnvironment() {
+        let environment = {};
+        if (this._features.secretAccess) {
+            environment = {
+                ...environment,
+                [EnvKeys.SECRET_ID]: this._stack.configuration.secretId,
+            };
+        }
+        if (this._features.databaseAccess) {
+            environment = {
+                ...environment,
+                [DatabaseEnvironmentKeys.DB_APPLICATION]: this._stack.configuration.shortName,
+            };
+        }
+        return { ...environment, ...this.environment };
+    }
+    createAlarms(lambda) {
+        const alarmSnsAction = new SnsAction(this._stack.alarmTopic);
+        const warningSnsAction = new SnsAction(this._stack.warningTopic);
+        const trafficType = this._stack.configuration.trafficType;
+        const production = this._stack.configuration.production;
+        if (this.alarms.durationAlarm) {
+            this.createAlarm(lambda, lambda.metricDuration().with({ statistic: "max" }), "Duration", "Duration alarm", `Duration has exceeded ${this.timeout.toSeconds()} seconds`, trafficType, production ? alarmSnsAction : warningSnsAction, this.timeout.toMilliseconds(), this.alarms.durationAlarm);
+        }
+        if (this.alarms.durationWarning) {
+            this.createAlarm(lambda, lambda.metricDuration().with({ statistic: "max" }), "Duration-Warning", "Duration warning", `Duration is 85 % of max ${this.timeout.toSeconds()} seconds`, trafficType, warningSnsAction, this.timeout.toMilliseconds() * 0.85, this.alarms.durationWarning);
+        }
+        if (this.alarms.errorAlarms) {
+            this.createAlarm(lambda, lambda.metricErrors(), "Errors", "Errors alarm", "Invocations did not succeed", trafficType, production ? alarmSnsAction : warningSnsAction, 1, this.alarms.errorAlarms);
+        }
+        if (this.alarms.throttleAlarm) {
+            this.createAlarm(lambda, lambda.metricThrottles(), "Throttles", "Throttles alarm", "Has throttled", trafficType, production ? alarmSnsAction : warningSnsAction, 1, this.alarms.throttleAlarm);
+        }
+    }
+    createAlarm(lambda, metric, alarmId, alarmName, alarmDescription, trafficType, alarmSnsAction, threshold, alarmProps) {
+        metric
+            .createAlarm(this._stack, `${lambda.node.id}-${alarmId}`, {
+            alarmName: `${trafficType ?? ""} ${this._stack.stackName} ${this.functionName} ${alarmName}`.trim(),
+            alarmDescription,
+            threshold: alarmProps.threshold ?? threshold,
+            evaluationPeriods: alarmProps.evaluationPeriods,
+            datapointsToAlarm: alarmProps.datapointsToAlarm,
+            comparisonOperator: alarmProps.comparisonOperator,
+        })
+            .addAlarmAction(alarmSnsAction);
+    }
+}
+//# sourceMappingURL=dt-function.js.map