@digitraffic/common 2026.8.31-2 → 2026.9.4-1

package/dist/__test__/imports.test.js

@@ -1,92 +1,314 @@
 import { expect, test } from "vitest";
-const IMPORT_TEST_TIMEOUT_MS = 15_000;
-function expectImportOk(name, path) {
-    test(name, async () => {
-        await expect(import(path)).resolves.toBeDefined();
-    }, IMPORT_TEST_TIMEOUT_MS);
-}
-expectImportOk("index import ok?", "../index.js");
-expectImportOk("database import ok?", "../database/database.js");
-expectImportOk("models import ok?", "../database/models.js");
-expectImportOk("lastUpdated import ok?", "../database/last-updated.js");
-expectImportOk("urn import ok?", "../types/urn.js");
-expectImportOk("utilTypes import ok?", "../types/util-types.js");
-expectImportOk("either import ok?", "../types/either.js");
-expectImportOk("validator import ok?", "../types/validator.js");
-expectImportOk("nullable import ok?", "../types/nullable.js");
-expectImportOk("asyncTimeoutError import ok?", "../types/async-timeout-error.js");
-expectImportOk("inputError import ok?", "../types/input-error.js");
-expectImportOk("httpError import ok?", "../types/http-error.js");
-expectImportOk("language import ok?", "../types/language.js");
-expectImportOk("traffictype import ok?", "../types/traffictype.js");
-expectImportOk("testutils import ok?", "../__test__/testutils.js");
-expectImportOk("dbTestutils import ok?", "../__test__/db-testutils.js");
-expectImportOk("asserter import ok?", "../__test__/asserter.js");
-expectImportOk("rtz import ok?", "../marine/rtz.js");
-expectImportOk("idUtils import ok?", "../marine/id_utils.js");
-expectImportOk("apiModel import ok?", "../utils/api-model.js");
-expectImportOk("logging import ok?", "../utils/logging.js");
-expectImportOk("base64 import ok?", "../utils/base64.js");
-expectImportOk("dateUtils import ok?", "../utils/date-utils.js");
-expectImportOk("geojsonTypes import ok?", "../utils/geojson-types.js");
-expectImportOk("slack import ok?", "../utils/slack.js");
-expectImportOk("stopWatch import ok?", "../utils/stop-watch.js");
-expectImportOk("utils import ok?", "../utils/utils.js");
-expectImportOk("retry import ok?", "../utils/retry.js");
-expectImportOk("geometry import ok?", "../utils/geometry.js");
-expectImportOk("sqsIntegration import ok?", "../aws/infra/sqs-integration.js");
-expectImportOk("networkStack import ok?", "../aws/infra/stacks/network-stack.js");
-expectImportOk("dbStack import ok?", "../aws/infra/stacks/db-stack.js");
-expectImportOk("dbProxyStack import ok?", "../aws/infra/stacks/db-proxy-stack.js");
-expectImportOk("intraStackConfiguration import ok?", "../aws/infra/stacks/intra-stack-configuration.js");
-expectImportOk("dbDnsStack import ok?", "../aws/infra/stacks/db-dns-stack.js");
-expectImportOk("documentation import ok?", "../aws/infra/documentation.js");
-expectImportOk("usagePlans import ok?", "../aws/infra/usage-plans.js");
-expectImportOk("scheduler import ok?", "../aws/infra/scheduler.js");
-expectImportOk("importUtil import ok?", "../aws/infra/import-util.js");
-expectImportOk("sqsQueue import ok?", "../aws/infra/sqs-queue.js");
-expectImportOk("response import ok?", "../aws/infra/api/response.js");
-expectImportOk("staticIntegration import ok?", "../aws/infra/api/static-integration.js");
-expectImportOk("responses import ok?", "../aws/infra/api/responses.js");
-expectImportOk("handlerFactory import ok?", "../aws/infra/api/handler-factory.js");
-expectImportOk("integration import ok?", "../aws/infra/api/integration.js");
-expectImportOk("stackCheckingAspect import ok?", "../aws/infra/stack/stack-checking-aspect.js");
-expectImportOk("restApis import ok?", "../aws/infra/stack/rest-api.js");
-expectImportOk("lambdaConfigs import ok?", "../aws/infra/stack/lambda-configs.js");
-expectImportOk("monitoredfunction import ok?", "../aws/infra/stack/monitoredfunction.js");
-expectImportOk("subscription import ok?", "../aws/infra/stack/subscription.js");
-expectImportOk("parameters import ok?", "../aws/infra/stack/parameters.js");
-expectImportOk("stack import ok?", "../aws/infra/stack/stack.js");
-expectImportOk("securityRule import ok?", "../aws/infra/security-rule.js");
-expectImportOk("canary import ok?", "../aws/infra/canaries/canary.js");
-expectImportOk("databaseCanary import ok?", "../aws/infra/canaries/database-canary.js");
-expectImportOk("canaryAlarm import ok?", "../aws/infra/canaries/canary-alarm.js");
-expectImportOk("canaryRole import ok?", "../aws/infra/canaries/canary-role.js");
-expectImportOk("urlCanary import ok?", "../aws/infra/canaries/url-canary.js");
-expectImportOk("canaryParameters import ok?", "../aws/infra/canaries/canary-parameters.js");
-expectImportOk("canaryKeys import ok?", "../aws/infra/canaries/canary-keys.js");
-expectImportOk("lambda-proxy-types import ok?", "../aws/types/lambda-proxy-types.js");
-expectImportOk("tags import ok?", "../aws/types/tags.js");
-expectImportOk("mediatypes import ok?", "../aws/types/mediatypes.js");
-expectImportOk("modelWithReference import ok?", "../aws/types/model-with-reference.js");
-expectImportOk("errors import ok?", "../aws/types/errors.js");
-expectImportOk("lambdaResponse import ok?", "../aws/types/lambda-response.js");
-expectImportOk("dtLoggerDefault import ok?", "../aws/runtime/dt-logger-default.js");
-expectImportOk("secret import ok?", "../aws/runtime/secrets/secret.js");
-expectImportOk("proxyHolder import ok?", "../aws/runtime/secrets/proxy-holder.js");
-expectImportOk("dbsecret import ok?", "../aws/runtime/secrets/dbsecret.js");
-expectImportOk("rdsHolder import ok?", "../aws/runtime/secrets/rds-holder.js");
-expectImportOk("secretHolder import ok?", "../aws/runtime/secrets/secret-holder.js");
-expectImportOk("dtLogger import ok?", "../aws/runtime/dt-logger.js");
-expectImportOk("s3 import ok?", "../aws/runtime/s3.js");
+test("index import ok?", () => {
+    const index = import("../index.js");
+    return expect(index).resolves.toBeDefined();
+});
+test("database import ok?", () => {
+    const database = import("../database/database.js");
+    return expect(database).resolves.toBeDefined();
+});
+test("models import ok?", () => {
+    const models = import("../database/models.js");
+    return expect(models).resolves.toBeDefined();
+});
+test("lastUpdated import ok?", () => {
+    const lastUpdated = import("../database/last-updated.js");
+    return expect(lastUpdated).resolves.toBeDefined();
+});
+test("urn import ok?", () => {
+    const urn = import("../types/urn.js");
+    return expect(urn).resolves.toBeDefined();
+});
+test("utilTypes import ok?", () => {
+    const utilTypes = import("../types/util-types.js");
+    return expect(utilTypes).resolves.toBeDefined();
+});
+test("either import ok?", () => {
+    const either = import("../types/either.js");
+    return expect(either).resolves.toBeDefined();
+});
+test("validator import ok?", () => {
+    const validator = import("../types/validator.js");
+    return expect(validator).resolves.toBeDefined();
+});
+test("nullable import ok?", () => {
+    const nullable = import("../types/nullable.js");
+    return expect(nullable).resolves.toBeDefined();
+});
+test("asyncTimeoutError import ok?", () => {
+    const asyncTimeoutError = import("../types/async-timeout-error.js");
+    return expect(asyncTimeoutError).resolves.toBeDefined();
+});
+test("inputError import ok?", () => {
+    const inputError = import("../types/input-error.js");
+    return expect(inputError).resolves.toBeDefined();
+});
+test("httpError import ok?", () => {
+    const httpError = import("../types/http-error.js");
+    return expect(httpError).resolves.toBeDefined();
+});
+test("language import ok?", () => {
+    const language = import("../types/language.js");
+    return expect(language).resolves.toBeDefined();
+});
+test("traffictype import ok?", () => {
+    const traffictype = import("../types/traffictype.js");
+    return expect(traffictype).resolves.toBeDefined();
+});
+test("testutils import ok?", () => {
+    const testutils = import("../__test__/testutils.js");
+    return expect(testutils).resolves.toBeDefined();
+});
+test("dbTestutils import ok?", () => {
+    const dbTestutils = import("../__test__/db-testutils.js");
+    return expect(dbTestutils).resolves.toBeDefined();
+});
+test("asserter import ok?", () => {
+    const asserter = import("../__test__/asserter.js");
+    return expect(asserter).resolves.toBeDefined();
+});
+test("rtz import ok?", () => {
+    const rtz = import("../marine/rtz.js");
+    return expect(rtz).resolves.toBeDefined();
+});
+test("idUtils import ok?", () => {
+    const idUtils = import("../marine/id_utils.js");
+    return expect(idUtils).resolves.toBeDefined();
+});
+test("apiModel import ok?", () => {
+    const apiModel = import("../utils/api-model.js");
+    return expect(apiModel).resolves.toBeDefined();
+});
+test("logging import ok?", () => {
+    const logging = import("../utils/logging.js");
+    return expect(logging).resolves.toBeDefined();
+});
+test("base64 import ok?", () => {
+    const base64 = import("../utils/base64.js");
+    return expect(base64).resolves.toBeDefined();
+});
+test("dateUtils import ok?", () => {
+    const dateUtils = import("../utils/date-utils.js");
+    return expect(dateUtils).resolves.toBeDefined();
+});
+test("geojsonTypes import ok?", () => {
+    const geojsonTypes = import("../utils/geojson-types.js");
+    return expect(geojsonTypes).resolves.toBeDefined();
+});
+test("slack import ok?", () => {
+    const slack = import("../utils/slack.js");
+    return expect(slack).resolves.toBeDefined();
+});
+test("stopWatch import ok?", () => {
+    const stopWatch = import("../utils/stop-watch.js");
+    return expect(stopWatch).resolves.toBeDefined();
+});
+test("utils import ok?", () => {
+    const utils = import("../utils/utils.js");
+    return expect(utils).resolves.toBeDefined();
+});
+test("retry import ok?", () => {
+    const retry = import("../utils/retry.js");
+    return expect(retry).resolves.toBeDefined();
+});
+test("geometry import ok?", () => {
+    const geometry = import("../utils/geometry.js");
+    return expect(geometry).resolves.toBeDefined();
+});
+test("sqsIntegration import ok?", () => {
+    const sqsIntegration = import("../aws/infra/sqs-integration.js");
+    return expect(sqsIntegration).resolves.toBeDefined();
+});
+test("networkStack import ok?", () => {
+    const networkStack = import("../aws/infra/stacks/network-stack.js");
+    return expect(networkStack).resolves.toBeDefined();
+});
+test("dbStack import ok?", () => {
+    const dbStack = import("../aws/infra/stacks/db-stack.js");
+    return expect(dbStack).resolves.toBeDefined();
+});
+test("dbProxyStack import ok?", () => {
+    const dbProxyStack = import("../aws/infra/stacks/db-proxy-stack.js");
+    return expect(dbProxyStack).resolves.toBeDefined();
+});
+test("intraStackConfiguration import ok?", () => {
+    const intraStackConfiguration = import("../aws/infra/stacks/intra-stack-configuration.js");
+    return expect(intraStackConfiguration).resolves.toBeDefined();
+});
+test("dbDnsStack import ok?", () => {
+    const dbDnsStack = import("../aws/infra/stacks/db-dns-stack.js");
+    return expect(dbDnsStack).resolves.toBeDefined();
+});
+test("documentation import ok?", () => {
+    const documentation = import("../aws/infra/documentation.js");
+    return expect(documentation).resolves.toBeDefined();
+});
+test("usagePlans import ok?", () => {
+    const usagePlans = import("../aws/infra/usage-plans.js");
+    return expect(usagePlans).resolves.toBeDefined();
+});
+test("scheduler import ok?", () => {
+    const scheduler = import("../aws/infra/scheduler.js");
+    return expect(scheduler).resolves.toBeDefined();
+});
+test("importUtil import ok?", () => {
+    const importUtil = import("../aws/infra/import-util.js");
+    return expect(importUtil).resolves.toBeDefined();
+});
+test("sqsQueue import ok?", () => {
+    const sqsQueue = import("../aws/infra/sqs-queue.js");
+    return expect(sqsQueue).resolves.toBeDefined();
+});
+test("response import ok?", () => {
+    const response = import("../aws/infra/api/response.js");
+    return expect(response).resolves.toBeDefined();
+});
+test("staticIntegration import ok?", () => {
+    const staticIntegration = import("../aws/infra/api/static-integration.js");
+    return expect(staticIntegration).resolves.toBeDefined();
+});
+test("responses import ok?", () => {
+    const responses = import("../aws/infra/api/responses.js");
+    return expect(responses).resolves.toBeDefined();
+});
+test("handlerFactory import ok?", () => {
+    const handlerFactory = import("../aws/infra/api/handler-factory.js");
+    return expect(handlerFactory).resolves.toBeDefined();
+});
+test("integration import ok?", () => {
+    const integration = import("../aws/infra/api/integration.js");
+    return expect(integration).resolves.toBeDefined();
+});
+test("stackCheckingAspect import ok?", () => {
+    const stackCheckingAspect = import("../aws/infra/stack/stack-checking-aspect.js");
+    return expect(stackCheckingAspect).resolves.toBeDefined();
+});
+test("restApis import ok?", () => {
+    const restApis = import("../aws/infra/stack/rest-api.js");
+    return expect(restApis).resolves.toBeDefined();
+});
+test("lambdaConfigs import ok?", () => {
+    const lambdaConfigs = import("../aws/infra/stack/lambda-configs.js");
+    return expect(lambdaConfigs).resolves.toBeDefined();
+});
+test("monitoredfunction import ok?", () => {
+    const monitoredfunction = import("../aws/infra/stack/monitoredfunction.js");
+    return expect(monitoredfunction).resolves.toBeDefined();
+});
+test("subscription import ok?", () => {
+    const subscription = import("../aws/infra/stack/subscription.js");
+    return expect(subscription).resolves.toBeDefined();
+});
+test("parameters import ok?", () => {
+    const parameters = import("../aws/infra/stack/parameters.js");
+    return expect(parameters).resolves.toBeDefined();
+});
+test("stack import ok?", () => {
+    const stack = import("../aws/infra/stack/stack.js");
+    return expect(stack).resolves.toBeDefined();
+});
+test("securityRule import ok?", () => {
+    const securityRule = import("../aws/infra/security-rule.js");
+    return expect(securityRule).resolves.toBeDefined();
+});
+test("canary import ok?", () => {
+    const canary = import("../aws/infra/canaries/canary.js");
+    return expect(canary).resolves.toBeDefined();
+});
+test("databaseCanary import ok?", () => {
+    const databaseCanary = import("../aws/infra/canaries/database-canary.js");
+    return expect(databaseCanary).resolves.toBeDefined();
+});
+test("canaryAlarm import ok?", () => {
+    const canaryAlarm = import("../aws/infra/canaries/canary-alarm.js");
+    return expect(canaryAlarm).resolves.toBeDefined();
+});
+test("canaryRole import ok?", () => {
+    const canaryRole = import("../aws/infra/canaries/canary-role.js");
+    return expect(canaryRole).resolves.toBeDefined();
+});
+test("urlCanary import ok?", () => {
+    const urlCanary = import("../aws/infra/canaries/url-canary.js");
+    return expect(urlCanary).resolves.toBeDefined();
+});
+test("canaryParameters import ok?", () => {
+    const canaryParameters = import("../aws/infra/canaries/canary-parameters.js");
+    return expect(canaryParameters).resolves.toBeDefined();
+});
+test("canaryKeys import ok?", () => {
+    const canaryKeys = import("../aws/infra/canaries/canary-keys.js");
+    return expect(canaryKeys).resolves.toBeDefined();
+});
+test("lambda-proxy-types import ok?", () => {
+    const proxytypes = import("../aws/types/lambda-proxy-types.js");
+    return expect(proxytypes).resolves.toBeDefined();
+});
+test("tags import ok?", () => {
+    const tags = import("../aws/types/tags.js");
+    return expect(tags).resolves.toBeDefined();
+});
+test("mediatypes import ok?", () => {
+    const mediatypes = import("../aws/types/mediatypes.js");
+    return expect(mediatypes).resolves.toBeDefined();
+});
+test("modelWithReference import ok?", () => {
+    const modelWithReference = import("../aws/types/model-with-reference.js");
+    return expect(modelWithReference).resolves.toBeDefined();
+});
+test("errors import ok?", () => {
+    const errors = import("../aws/types/errors.js");
+    return expect(errors).resolves.toBeDefined();
+});
+test("lambdaResponse import ok?", () => {
+    const lambdaResponse = import("../aws/types/lambda-response.js");
+    return expect(lambdaResponse).resolves.toBeDefined();
+});
+test("dtLoggerDefault import ok?", () => {
+    const dtLoggerDefault = import("../aws/runtime/dt-logger-default.js");
+    return expect(dtLoggerDefault).resolves.toBeDefined();
+});
+test("secret import ok?", () => {
+    const secret = import("../aws/runtime/secrets/secret.js");
+    return expect(secret).resolves.toBeDefined();
+});
+test("proxyHolder import ok?", () => {
+    const proxyHolder = import("../aws/runtime/secrets/proxy-holder.js");
+    return expect(proxyHolder).resolves.toBeDefined();
+});
+test("dbsecret import ok?", () => {
+    const dbsecret = import("../aws/runtime/secrets/dbsecret.js");
+    return expect(dbsecret).resolves.toBeDefined();
+});
+test("rdsHolder import ok?", () => {
+    const rdsHolder = import("../aws/runtime/secrets/rds-holder.js");
+    return expect(rdsHolder).resolves.toBeDefined();
+});
+test("secretHolder import ok?", () => {
+    const secretHolder = import("../aws/runtime/secrets/secret-holder.js");
+    return expect(secretHolder).resolves.toBeDefined();
+});
+test("dtLogger import ok?", () => {
+    const dtLogger = import("../aws/runtime/dt-logger.js");
+    return expect(dtLogger).resolves.toBeDefined();
+});
+test("s3 import ok?", () => {
+    const s3 = import("../aws/runtime/s3.js");
+    return expect(s3).resolves.toBeDefined();
+});
 /*
 temporary disable, enable after sdk v2 is kicked out
 test('apikey import ok?', () => {
   const apikey = import("../aws/runtime/apikey.js");
   return expect(apikey).resolves.toBeDefined();
 });*/
-expectImportOk("environment import ok?", "../aws/runtime/environment.js");
-expectImportOk("digitrafficIntegrationResponse import ok?", "../aws/runtime/digitraffic-integration-response.js");
+test("environment import ok?", () => {
+    const environment = import("../aws/runtime/environment.js");
+    return expect(environment).resolves.toBeDefined();
+});
+test("digitrafficIntegrationResponse import ok?", () => {
+    const digitrafficIntegrationResponse = import("../aws/runtime/digitraffic-integration-response.js");
+    return expect(digitrafficIntegrationResponse).resolves.toBeDefined();
+});
 /*
  * Näitä ei testata, koska ne importtaa synthetics kirjaston, jolle ei ole mitään vastinetta npm:ssä. Lambdaympäristöstä
  * löytyy toi kirjasto.

package/dist/__test__/infra/acl-builder.test.js

@@ -51,24 +51,6 @@ describe("acl-builder tests", () => {
             expect(throttleRule.action.block).toBeDefined();
         }
     });
-    test("anonymous uri-path throttle can exclude a path", () => {
-        const acl = createBuilder()
-            .withThrottleAnonymousUserIpAndUriPath(100, /^\/roadnetwork\//)
-            .build();
-        const rule = acl.rules[0];
-        const statement = rule?.statement;
-        const rateBased = statement.rateBasedStatement;
-        const scopeDown = rateBased.scopeDownStatement;
-        const scopeDownStatement = scopeDown;
-        const andStatement = scopeDownStatement.andStatement;
-        const scopeDownStatements = (andStatement.statements ??
-            []);
-        const excludedStatement = scopeDownStatements[1];
-        const excludedPathStatement = excludedStatement.notStatement;
-        const regexMatchStatement = excludedPathStatement.statement.regexMatchStatement;
-        expect(scopeDownStatements).toHaveLength(2);
-        expect(regexMatchStatement.regexString).toBe("^\\/roadnetwork\\/");
-    });
     test("Cannot define two rules with the same name", () => {
         expect(() => createBuilder()
             .withThrottleAnonymousUserIp(10)

package/dist/__test__/stack/dt-function.test.js

@@ -61,7 +61,6 @@ describe("FunctionBuilder test", () => {
         template.hasResourceProperties("AWS::Lambda::Function", {
             Environment: {
                 Variables: {
-                    [EnvKeys.APP_NAME]: "road-test",
                     [EnvKeys.SECRET_ID]: "testSecret",
                     [TEST_ENV_VAR]: TEST_ENV_VALUE,
                 },
@@ -140,9 +139,11 @@ describe("FunctionBuilder test", () => {
         });
     });
     test("Lambda handler module is resolved from path last element", () => {
-        const template = createTemplate((_builder) => { }, false, "api/feature/v1/get-items");
+        const template = createTemplate((_builder) => { }, false, "api/charging-network/v1/operators");
+        // const lambdas = template.findResources("AWS::Lambda::Function");
+        // console.debug(JSON.stringify(lambdas, null, 2));
         template.hasResourceProperties("AWS::Lambda::Function", {
-            Handler: "get-items.handler",
+            Handler: "operators.handler",
         });
     });
     test("Lambda handler module is same as lambda name", () => {
@@ -335,5 +336,122 @@ describe("FunctionBuilder test", () => {
                 .build();
         }).toThrow('Lambda test-Test cannot use wildcard action "*" in withAllowedActions');
     });
+    describe("withAdotTracing", () => {
+        test("given withAdotTracing is called / when lambda is built / then AWS_LAMBDA_EXEC_WRAPPER is set", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            });
+            // then
+            expectEnvironmentValue(template, "AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument");
+        });
+        test("given withAdotTracing is called / when lambda is built / then OTEL_AWS_APPLICATION_SIGNALS_ENABLED is false", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            });
+            // then
+            expectEnvironmentValue(template, "OTEL_AWS_APPLICATION_SIGNALS_ENABLED", "false");
+        });
+        test("given withAdotTracing is called / when lambda is built / then X-Ray active tracing is enabled", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            });
+            // then
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                TracingConfig: { Mode: "Active" },
+            });
+        });
+        test("given withAdotTracing is called / when lambda is built / then CloudWatch Lambda Application Signals policy is attached", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            });
+            // then — the managed policy ARN contains CloudWatchLambdaApplicationSignalsExecutionRolePolicy
+            const roles = template.findResources("AWS::IAM::Role");
+            const lambdaRoleKey = Object.keys(roles).find((key) => key.includes("ServiceRole"));
+            expect(lambdaRoleKey).toBeDefined();
+            const role = roles[lambdaRoleKey];
+            const managedPolicyArns = JSON.stringify(role["Properties"]?.["ManagedPolicyArns"]);
+            expect(managedPolicyArns).toContain("CloudWatchLambdaApplicationSignalsExecutionRolePolicy");
+        });
+        test("given withAdotTracing on Node.js runtime / when lambda is built / then JS ADOT layer is attached", () => {
+            // given/when — default runtime is NODEJS_24_X
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            });
+            // then
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                Layers: Match.arrayWith([
+                    Match.stringLikeRegexp("AWSOpenTelemetryDistroJs"),
+                ]),
+            });
+        });
+        test("given withAdotTracing on Python runtime / when lambda is built / then Python ADOT layer is attached", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withRuntime(Runtime.PYTHON_3_12).withAdotTracing();
+            });
+            // then
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                Layers: Match.arrayWith([
+                    Match.stringLikeRegexp("AWSOpenTelemetryDistroPython"),
+                ]),
+            });
+        });
+        test("given withAdotTracing is NOT called / when lambda is built / then ADOT env vars are absent", () => {
+            // given/when
+            const template = createTemplate((_builder) => { });
+            // then
+            expectEnvironmentValueMissing(template, "AWS_LAMBDA_EXEC_WRAPPER");
+            expectEnvironmentValueMissing(template, "OTEL_AWS_APPLICATION_SIGNALS_ENABLED");
+        });
+        test("given withAdotTracing is NOT called / when lambda is built / then tracing is not Active", () => {
+            // given/when
+            const template = createTemplate((_builder) => { });
+            // then
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                TracingConfig: Match.absent(),
+            });
+        });
+        test("given withAdotTracing combined with other builder methods / when lambda is built / then all properties are present", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder
+                    .withAdotTracing()
+                    .withMemorySize(512)
+                    .withTimeout(Duration.seconds(30))
+                    .withEnvironment({ CUSTOM_KEY: "custom_value" });
+            });
+            // then — ADOT config present
+            expectEnvironmentValue(template, "AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument");
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                TracingConfig: { Mode: "Active" },
+            });
+            // then — other builder settings also present
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                MemorySize: 512,
+                Timeout: 30,
+            });
+            expectEnvironmentValue(template, "CUSTOM_KEY", "custom_value");
+        });
+        test("given withAdotTracing on plain builder / when lambda is built / then ADOT config is applied without database env vars", () => {
+            // given/when
+            const template = createTemplate((builder) => {
+                builder.withAdotTracing();
+            }, true);
+            // then — ADOT config present
+            expectEnvironmentValue(template, "AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument");
+            template.hasResourceProperties("AWS::Lambda::Function", {
+                TracingConfig: { Mode: "Active" },
+                Layers: Match.arrayWith([
+                    Match.stringLikeRegexp("AWSOpenTelemetryDistroJs"),
+                ]),
+            });
+            // then — no database env vars
+            expectEnvironmentValueMissing(template, "DB_APPLICATION");
+        });
+    });
 });
 //# sourceMappingURL=dt-function.test.js.map

package/dist/aws/infra/acl-builder.d.ts

@@ -32,32 +32,13 @@ export declare class AclBuilder {
      * Allow access only from the given addresses
      */
     withIpWhitelistRule(addresses: string[]): this;
-    /**
-     * Adds a rate-based WAF rule for either blocking or counting requests.
-     *
-     * @param name WAF rule name and CloudWatch metric name.
-     * @param limit Maximum requests allowed in the WAF evaluation window.
-     * @param isHeaderRequired Whether the rule applies when the digitraffic-user header is present.
-     * @param isBasedOnIpAndUriPath Whether requests are aggregated by IP address and URI path.
-     * @param customResponseBodyKey Custom response body key; when provided, matching requests are blocked instead of counted.
-     * @param path Optional URI path pattern that limits which requests are included.
-     * @param excludedPath Optional URI path pattern that excludes matching requests from the rule.
-     */
-    withThrottleRule(name: string, limit: number, isHeaderRequired: boolean, isBasedOnIpAndUriPath: boolean, customResponseBodyKey?: string, path?: RegExp, excludedPath?: RegExp): this;
+    withThrottleRule(name: string, limit: number, isHeaderRequired: boolean, isBasedOnIpAndUriPath: boolean, customResponseBodyKey?: string, path?: RegExp): this;
     withCustomResponseBody(key: string, customResponseBody: CfnWebACL.CustomResponseBodyProperty): this;
     withThrottleDigitrafficUserIp(limit: number | undefined): this;
     withThrottleDigitrafficUserIpAndUriPath(limit: number | undefined): this;
     withThrottleAnonymousUserIp(limit: number | undefined): AclBuilder;
     withThrottleAnonymousUserIpByUriPath(limit: number | undefined, path: RegExp | undefined): AclBuilder;
-    /**
-     * Throttles anonymous requests by IP address and URI path.
-     *
-     * Existing callers that omit `excludedPath` retain the previous behavior.
-     *
-     * @param limit Maximum requests allowed for each IP and URI path combination.
-     * @param excludedPath Optional URI path pattern excluded from this throttle rule.
-     */
-    withThrottleAnonymousUserIpAndUriPath(limit: number | undefined, excludedPath?: RegExp): this;
+    withThrottleAnonymousUserIpAndUriPath(limit: number | undefined): this;
     withCountDigitrafficUserIp(limit: number | undefined): this;
     withCountDigitrafficUserIpAndUriPath(limit: number | undefined): this;
     withCountAnonymousUserIp(limit: number | undefined): this;