localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/lambda_/invocation/docker_runtime_executor.py

@@ -5,8 +5,9 @@ import shutil
 import tempfile
 import threading
 from collections import defaultdict
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable, Dict, Literal, Optional
+from typing import Literal
 
 from localstack import config
 from localstack.aws.api.lambda_ import Architecture, PackageType, Runtime
@@ -23,7 +24,6 @@ from localstack.services.lambda_.invocation.runtime_executor import (
     LambdaRuntimeException,
     RuntimeExecutor,
 )
-from localstack.services.lambda_.lambda_debug_mode.ldm import LDM_ENV_VAR_DEBUG_PORT
 from localstack.services.lambda_.lambda_utils import HINT_LOG
 from localstack.services.lambda_.networking import (
     get_all_container_networks_for_lambda,
@@ -146,7 +146,7 @@ class RuntimeImageResolver:
     def __init__(
         self, default_resolve_fn: Callable[[Runtime], str] = get_default_image_for_runtime
     ):
-        self._mapping = dict()
+        self._mapping = {}
         self._default_resolve_fn = default_resolve_fn
 
     def _resolve(self, runtime: Runtime, custom_image_mapping: str = "") -> str:
@@ -275,12 +275,12 @@ class LambdaContainerConfiguration(ContainerConfiguration):
 
 
 class DockerRuntimeExecutor(RuntimeExecutor):
-    ip: Optional[str]
-    executor_endpoint: Optional[ExecutorEndpoint]
+    ip: str | None
+    executor_endpoint: ExecutorEndpoint | None
     container_name: str
 
     def __init__(self, id: str, function_version: FunctionVersion) -> None:
-        super(DockerRuntimeExecutor, self).__init__(id=id, function_version=function_version)
+        super().__init__(id=id, function_version=function_version)
         self.ip = None
         self.executor_endpoint = ExecutorEndpoint(self.id)
         self.container_name = self._generate_container_name()
@@ -376,10 +376,6 @@ class DockerRuntimeExecutor(RuntimeExecutor):
                 container_config.ports = PortMappings()
             container_config.ports.add(config.LAMBDA_INIT_DELVE_PORT, config.LAMBDA_INIT_DELVE_PORT)
 
-        if ldm_debug_port := env_vars.get(LDM_ENV_VAR_DEBUG_PORT):
-            ldm_debug_port = int(ldm_debug_port)
-            container_config.ports.add(ldm_debug_port, ldm_debug_port)
-
         if (
             self.function_version.config.layers
             and not config.LAMBDA_PREBUILD_IMAGES
@@ -460,7 +456,7 @@ class DockerRuntimeExecutor(RuntimeExecutor):
     def _get_networks_for_executor(self) -> list[str]:
         return get_all_container_networks_for_lambda()
 
-    def invoke(self, payload: Dict[str, str]):
+    def invoke(self, payload: dict[str, str]):
         LOG.debug(
             "Sending invoke-payload '%s' to executor '%s'",
             truncate(json.dumps(payload), config.LAMBDA_TRUNCATE_STDOUT),

localstack/services/lambda_/invocation/event_manager.py

@@ -42,7 +42,7 @@ def get_sqs_client(function_version: FunctionVersion, client_config=None):
 # TODO: remove once DLQ handling is refactored following the removal of the legacy lambda provider
 class LegacyInvocationException(Exception):
     def __init__(self, message, log_output=None, result=None):
-        super(LegacyInvocationException, self).__init__(message)
+        super().__init__(message)
         self.log_output = log_output
         self.result = result
 

localstack/services/lambda_/invocation/execution_environment.py

@@ -2,10 +2,10 @@ import logging
 import random
 import string
 import time
+from collections.abc import Callable
 from datetime import date, datetime
 from enum import Enum, auto
 from threading import RLock, Timer
-from typing import Callable, Dict, Optional
 
 from localstack import config
 from localstack.aws.connect import connect_to
@@ -61,8 +61,8 @@ class ExecutionEnvironment:
     status: RuntimeStatus
     initialization_type: InitializationType
     last_returned: datetime
-    startup_timer: Optional[Timer]
-    keepalive_timer: Optional[Timer]
+    startup_timer: Timer | None
+    keepalive_timer: Timer | None
     on_timeout: Callable[[str, str], None]
 
     def __init__(
@@ -91,7 +91,7 @@ class ExecutionEnvironment:
     def get_log_stream_name(self) -> str:
         return f"{date.today():%Y/%m/%d}/[{self.function_version.id.qualifier}]{self.id}"
 
-    def get_environment_variables(self) -> Dict[str, str]:
+    def get_environment_variables(self) -> dict[str, str]:
         """
         Returns the environment variable set for the runtime container
         :return: Dict of environment variables

localstack/services/lambda_/invocation/executor_endpoint.py

@@ -3,18 +3,15 @@ import logging
 import time
 from concurrent.futures import CancelledError, Future
 from http import HTTPStatus
-from typing import Any, Dict, Optional
+from typing import Any
 
 import requests
 from werkzeug import Request
 
 from localstack.http import Response, route
 from localstack.services.edge import ROUTER
+from localstack.services.lambda_ import ldm
 from localstack.services.lambda_.invocation.lambda_models import InvocationResult
-from localstack.services.lambda_.lambda_debug_mode.ldm import (
-    DEFAULT_LAMBDA_DEBUG_MODE_TIMEOUT_SECONDS,
-    LDM,
-)
 from localstack.utils.backoff import ExponentialBackoff
 from localstack.utils.objects import singleton_factory
 from localstack.utils.strings import to_str
@@ -121,8 +118,8 @@ class ExecutorEndpoint(Endpoint):
     def __init__(
         self,
         executor_id: str,
-        container_address: Optional[str] = None,
-        container_port: Optional[int] = INVOCATION_PORT,
+        container_address: str | None = None,
+        container_port: int | None = INVOCATION_PORT,
     ) -> None:
         self.container_address = container_address
         self.container_port = container_port
@@ -143,7 +140,7 @@ class ExecutorEndpoint(Endpoint):
 
     def invocation_logs(self, request: Request, invoke_id: str) -> Response:
         logs = request.json
-        if isinstance(logs, Dict):
+        if isinstance(logs, dict):
             self.logs = logs["logs"]
         else:
             LOG.error("Invalid logs from init! Logs: %s", logs)
@@ -186,7 +183,7 @@ class ExecutorEndpoint(Endpoint):
         if self.invocation_future:
             self.invocation_future.cancel()
 
-    def invoke(self, payload: Dict[str, str]) -> InvocationResult:
+    def invoke(self, payload: dict[str, str]) -> InvocationResult:
         self.invocation_future = Future()
         self.logs = None
         if not self.container_address:
@@ -209,9 +206,9 @@ class ExecutorEndpoint(Endpoint):
         # Note that if timeouts are enforced for the lambda function invoked at this endpoint
         # (this is needs to be configured in the Lambda Debug Mode Config file), the lambda
         # function will continue to enforce the expected timeouts.
-        if LDM.is_enabled():
+        if ldm.IS_LDM_ENABLED:
             # The value is set to a default high value to ensure eventual termination.
-            timeout_seconds = DEFAULT_LAMBDA_DEBUG_MODE_TIMEOUT_SECONDS
+            timeout_seconds = ldm.DEFAULT_LDM_TIMEOUT_SECONDS
         else:
             # Do not wait longer for an invoke than the maximum lambda timeout plus a buffer
             lambda_max_timeout_seconds = 900

localstack/services/lambda_/invocation/internal_sqs_queue.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import Iterable
+from collections.abc import Iterable
 
 from localstack import config
 from localstack.aws.api.sqs import (
@@ -19,13 +19,9 @@ from localstack.aws.api.sqs import (
     String,
     TagMap,
 )
-from localstack.services.sqs.models import SqsQueue, StandardQueue
-from localstack.services.sqs.provider import (
-    QueueUpdateWorker,
-    _create_message_attribute_hash,
-    to_sqs_api_message,
-)
-from localstack.services.sqs.utils import generate_message_id
+from localstack.services.sqs.models import SqsQueue, StandardQueue, to_sqs_api_message
+from localstack.services.sqs.provider import QueueUpdateWorker
+from localstack.services.sqs.utils import create_message_attribute_hash, generate_message_id
 from localstack.utils.objects import singleton_factory
 from localstack.utils.strings import md5
 from localstack.utils.time import now
@@ -189,7 +185,7 @@ class FakeSqsClient:
             MD5OfBody=md5(MessageBody),
             Body=MessageBody,
             Attributes=self._create_message_attributes(MessageSystemAttributes),
-            MD5OfMessageAttributes=_create_message_attribute_hash(MessageAttributes),
+            MD5OfMessageAttributes=create_message_attribute_hash(MessageAttributes),
             MessageAttributes=MessageAttributes,
         )
         queue_item = queue.put(
@@ -204,7 +200,7 @@ class FakeSqsClient:
             "MD5OfMessageBody": message["MD5OfBody"],
             "MD5OfMessageAttributes": message.get("MD5OfMessageAttributes"),
             "SequenceNumber": queue_item.sequence_number,
-            "MD5OfMessageSystemAttributes": _create_message_attribute_hash(MessageSystemAttributes),
+            "MD5OfMessageSystemAttributes": create_message_attribute_hash(MessageSystemAttributes),
         }
 
 

localstack/services/lambda_/invocation/lambda_models.py

@@ -12,8 +12,9 @@ import threading
 from abc import ABCMeta, abstractmethod
 from datetime import datetime
 from pathlib import Path
-from typing import IO, Dict, Literal, Optional, TypedDict
+from typing import IO, Literal, TypedDict
 
+import boto3
 from botocore.exceptions import ClientError
 
 from localstack import config
@@ -40,7 +41,7 @@ from localstack.aws.api.lambda_ import (
     TracingMode,
 )
 from localstack.aws.connect import connect_to
-from localstack.constants import AWS_REGION_US_EAST_1
+from localstack.constants import AWS_REGION_US_EAST_1, INTERNAL_AWS_SECRET_ACCESS_KEY
 from localstack.services.lambda_.api_utils import qualified_lambda_arn, unqualified_lambda_arn
 from localstack.utils.archives import unzip
 from localstack.utils.strings import long_uid, short_uid
@@ -52,8 +53,8 @@ LOG = logging.getLogger(__name__)
 @dataclasses.dataclass(frozen=True)
 class VersionState:
     state: State
-    code: Optional[StateReasonCode] = None
-    reason: Optional[str] = None
+    code: StateReasonCode | None = None
+    reason: str | None = None
 
 
 @dataclasses.dataclass
@@ -66,7 +67,7 @@ class Invocation:
     # = invocation_id
     request_id: str
     trace_context: dict
-    user_agent: Optional[str] = None
+    user_agent: str | None = None
 
 
 InitializationType = Literal["on-demand", "provisioned-concurrency"]
@@ -74,7 +75,7 @@ InitializationType = Literal["on-demand", "provisioned-concurrency"]
 
 class ArchiveCode(metaclass=ABCMeta):
     @abstractmethod
-    def generate_presigned_url(self, endpoint_url: str | None = None):
+    def generate_presigned_url(self, endpoint_url: str):
         """
         Generates a presigned url pointing to the code archive
         """
@@ -168,15 +169,17 @@ class S3Code(ArchiveCode):
         )
         target_file.flush()
 
-    def generate_presigned_url(self, endpoint_url: str | None = None) -> str:
+    def generate_presigned_url(self, endpoint_url: str) -> str:
         """
         Generates a presigned url pointing to the code archive
         """
-        s3_client = connect_to(
+        s3_client = boto3.client(
+            "s3",
             region_name=AWS_REGION_US_EAST_1,
             aws_access_key_id=config.INTERNAL_RESOURCE_ACCOUNT,
+            aws_secret_access_key=INTERNAL_AWS_SECRET_ACCESS_KEY,
             endpoint_url=endpoint_url,
-        ).s3
+        )
         params = {"Bucket": self.s3_bucket, "Key": self.s3_key}
         if self.s3_object_version:
             params["VersionId"] = self.s3_object_version
@@ -257,8 +260,8 @@ class HotReloadingCode(ArchiveCode):
     code_sha256: str = "hot-reloading-hash-not-available"
     code_size: int = 0
 
-    def generate_presigned_url(self, endpoint_url: str | None = None) -> str:
-        return f"Code location: {self.host_path}"
+    def generate_presigned_url(self, endpoint_url: str) -> str:
+        return f"file://{self.host_path}"
 
     def get_unzipped_code_location(self) -> Path:
         path = os.path.expandvars(self.host_path)
@@ -352,11 +355,11 @@ class FunctionUrlConfig:
     url: str  # full URL (e.g. "https://pfn5bdb2dl5mzkbn6eb2oi3xfe0nthdn.lambda-url.eu-west-3.on.aws/")
     auth_type: FunctionUrlAuthType
     creation_time: str  # time
-    last_modified_time: Optional[str] = (
+    last_modified_time: str | None = (
         None  # TODO: check if this is the creation time when initially creating
     )
-    function_qualifier: Optional[str] = "$LATEST"  # only $LATEST or alias name
-    invoke_mode: Optional[InvokeMode] = None
+    function_qualifier: str | None = "$LATEST"  # only $LATEST or alias name
+    invoke_mode: InvokeMode | None = None
 
 
 @dataclasses.dataclass
@@ -374,12 +377,12 @@ class ProvisionedConcurrencyState:
     status: ProvisionedConcurrencyStatusEnum = dataclasses.field(
         default=ProvisionedConcurrencyStatusEnum.IN_PROGRESS
     )
-    status_reason: Optional[str] = None
+    status_reason: str | None = None
 
 
 @dataclasses.dataclass
 class AliasRoutingConfig:
-    version_weights: Dict[str, float]
+    version_weights: dict[str, float]
 
 
 @dataclasses.dataclass(frozen=True)
@@ -431,10 +434,10 @@ class EventInvokeConfig:
     function_name: str
     qualifier: str
 
-    last_modified: Optional[str] = dataclasses.field(compare=False)
-    destination_config: Optional[DestinationConfig] = None
-    maximum_retry_attempts: Optional[int] = None
-    maximum_event_age_in_seconds: Optional[int] = None
+    last_modified: str | None = dataclasses.field(compare=False)
+    destination_config: DestinationConfig | None = None
+    maximum_retry_attempts: int | None = None
+    maximum_event_age_in_seconds: int | None = None
 
 
 # Result Models
@@ -484,7 +487,7 @@ class CodeSigningConfig:
     allowed_publishers: AllowedPublishers
     policies: CodeSigningPolicies
     last_modified: str
-    description: Optional[str] = None
+    description: str | None = None
 
 
 @dataclasses.dataclass
@@ -492,7 +495,7 @@ class LayerPolicyStatement:
     sid: str
     action: str
     principal: str
-    organization_id: Optional[str]
+    organization_id: str | None
 
 
 @dataclasses.dataclass
@@ -551,18 +554,18 @@ class VersionFunctionConfiguration:
     last_modified: str  # ISO string
     state: VersionState
 
-    image: Optional[ImageCode] = None
-    image_config: Optional[ImageConfig] = None
-    runtime_version_config: Optional[RuntimeVersionConfig] = None
-    last_update: Optional[UpdateStatus] = None
+    image: ImageCode | None = None
+    image_config: ImageConfig | None = None
+    runtime_version_config: RuntimeVersionConfig | None = None
+    last_update: UpdateStatus | None = None
     revision_id: str = dataclasses.field(init=False, default_factory=long_uid)
     layers: list[LayerVersion] = dataclasses.field(default_factory=list)
 
-    dead_letter_arn: Optional[str] = None
+    dead_letter_arn: str | None = None
 
     # kms_key_arn: str
     # file_system_configs: FileSystemConfig
-    vpc_config: Optional[VpcConfig] = None
+    vpc_config: VpcConfig | None = None
 
     logging_config: LoggingConfig = dataclasses.field(default_factory=dict)
 
@@ -580,7 +583,7 @@ class FunctionVersion:
 @dataclasses.dataclass
 class Function:
     function_name: str
-    code_signing_config_arn: Optional[str] = None
+    code_signing_config_arn: str | None = None
     aliases: dict[str, VersionAlias] = dataclasses.field(default_factory=dict)
     versions: dict[str, FunctionVersion] = dataclasses.field(default_factory=dict)
     function_url_configs: dict[str, FunctionUrlConfig] = dataclasses.field(
@@ -592,7 +595,7 @@ class Function:
     event_invoke_configs: dict[str, EventInvokeConfig] = dataclasses.field(
         default_factory=dict
     )  # key is $LATEST(?), version or alias
-    reserved_concurrent_executions: Optional[int] = None
+    reserved_concurrent_executions: int | None = None
     recursive_loop: RecursiveLoop = RecursiveLoop.Terminate
     provisioned_concurrency_configs: dict[str, ProvisionedConcurrencyConfiguration] = (
         dataclasses.field(default_factory=dict)

localstack/services/lambda_/invocation/lambda_service.py

@@ -11,7 +11,7 @@ from datetime import datetime
 from hashlib import sha256
 from pathlib import PurePosixPath, PureWindowsPath
 from threading import RLock
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from localstack import config
 from localstack.aws.api.lambda_ import (
@@ -25,6 +25,7 @@ from localstack.aws.api.lambda_ import (
 )
 from localstack.aws.connect import connect_to
 from localstack.constants import AWS_REGION_US_EAST_1
+from localstack.services.lambda_ import hooks as lambda_hooks
 from localstack.services.lambda_.analytics import (
     FunctionOperation,
     FunctionStatus,
@@ -130,6 +131,7 @@ class LambdaService:
         if not version_manager:
             raise ValueError(f"Unable to find version manager for {qualified_arn}")
         self.task_executor.submit(version_manager.stop)
+        lambda_hooks.delete_function_version.run(qualified_arn)
 
     def get_lambda_version_manager(self, function_arn: str) -> LambdaVersionManager:
         """
@@ -185,6 +187,7 @@ class LambdaService:
                 assignment_service=self.assignment_service,
             )
             self.lambda_starting_versions[qualified_arn] = version_manager
+            lambda_hooks.create_function_version.run(function_version.qualified_arn)
         return self.task_executor.submit(self._start_lambda_version, version_manager)
 
     def publish_version(self, function_version: FunctionVersion):
@@ -230,7 +233,7 @@ class LambdaService:
         request_id: str,
         payload: bytes | None,
         trace_context: dict | None = None,
-        user_agent: Optional[str] = None,
+        user_agent: str | None = None,
     ) -> InvocationResult | None:
         """
         Invokes a specific version of a lambda
@@ -475,7 +478,11 @@ class LambdaService:
             ] = new_version_state
 
         except Exception:
-            LOG.exception("Failed to update function version for arn %s", function_arn)
+            LOG.error(
+                "Failed to update function version for arn %s",
+                function_arn,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )
 
     def update_alias(self, old_alias: VersionAlias, new_alias: VersionAlias, function: Function):
         # if pointer changed, need to restart provisioned
@@ -624,7 +631,7 @@ def create_hot_reloading_code(path: str) -> HotReloadingCode:
 def store_s3_bucket_archive(
     archive_bucket: str,
     archive_key: str,
-    archive_version: Optional[str],
+    archive_version: str | None,
     function_name: str,
     region_name: str,
     account_id: str,
@@ -643,7 +650,7 @@ def store_s3_bucket_archive(
     if archive_bucket == config.BUCKET_MARKER_LOCAL:
         hotreload_counter.labels(operation="create").increment()
         return create_hot_reloading_code(path=archive_key)
-    s3_client: "S3Client" = connect_to().s3
+    s3_client: S3Client = connect_to().s3
     kwargs = {"VersionId": archive_version} if archive_version else {}
     try:
         archive_file = s3_client.get_object(Bucket=archive_bucket, Key=archive_key, **kwargs)[

localstack/services/lambda_/invocation/logs.py

@@ -3,7 +3,6 @@ import logging
 import threading
 import time
 from queue import Queue
-from typing import Optional, Union
 
 from localstack.aws.connect import connect_to
 from localstack.utils.aws.client_types import ServicePrincipal
@@ -28,9 +27,9 @@ class LogItem:
 
 
 class LogHandler:
-    log_queue: "Queue[Union[LogItem, ShutdownPill]]"
+    log_queue: "Queue[LogItem | ShutdownPill]"
     role_arn: str
-    _thread: Optional[FuncThread]
+    _thread: FuncThread | None
     _shutdown_event: threading.Event
 
     def __init__(self, role_arn: str, region: str) -> None:

localstack/services/lambda_/invocation/runtime_executor.py

@@ -2,7 +2,7 @@ import dataclasses
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Type, TypedDict
+from typing import TypedDict
 
 from plux import PluginManager
 
@@ -133,12 +133,12 @@ class ChmodPath(TypedDict):
     mode: str
 
 
-EXECUTOR_PLUGIN_MANAGER: PluginManager[Type[RuntimeExecutor]] = PluginManager(
+EXECUTOR_PLUGIN_MANAGER: PluginManager[type[RuntimeExecutor]] = PluginManager(
     RuntimeExecutorPlugin.namespace
 )
 
 
-def get_runtime_executor() -> Type[RuntimeExecutor]:
+def get_runtime_executor() -> type[RuntimeExecutor]:
     plugin_name = config.LAMBDA_RUNTIME_EXECUTOR or "docker"
     if not EXECUTOR_PLUGIN_MANAGER.exists(plugin_name):
         LOG.warning(

localstack/services/lambda_/invocation/version_manager.py

@@ -3,6 +3,7 @@ import logging
 import threading
 import time
 from concurrent.futures import Future
+from concurrent.futures._base import CancelledError
 
 from localstack import config
 from localstack.aws.api.lambda_ import (
@@ -11,6 +12,7 @@ from localstack.aws.api.lambda_ import (
     State,
     StateReasonCode,
 )
+from localstack.services.lambda_ import hooks as lambda_hooks
 from localstack.services.lambda_.invocation.assignment import AssignmentService
 from localstack.services.lambda_.invocation.counting_service import CountingService
 from localstack.services.lambda_.invocation.execution_environment import ExecutionEnvironment
@@ -29,8 +31,8 @@ from localstack.services.lambda_.invocation.metrics import (
     record_cw_metric_invocation,
 )
 from localstack.services.lambda_.invocation.runtime_executor import get_runtime_executor
-from localstack.services.lambda_.lambda_debug_mode.ldm import LDM
-from localstack.utils.strings import long_uid, truncate
+from localstack.services.lambda_.ldm import LDMProvisioner
+from localstack.utils.strings import long_uid, to_bytes, truncate
 from localstack.utils.threads import FuncThread, start_thread
 
 LOG = logging.getLogger(__name__)
@@ -53,6 +55,8 @@ class LambdaVersionManager:
     counting_service: CountingService
     assignment_service: AssignmentService
 
+    ldm_provisioner: LDMProvisioner | None
+
     def __init__(
         self,
         function_arn: str,
@@ -80,6 +84,9 @@ class LambdaVersionManager:
         # https://aws.amazon.com/blogs/compute/coming-soon-expansion-of-aws-lambda-states-to-all-functions/
         self.state = VersionState(state=State.Pending)
 
+        self.ldm_provisioner = None
+        lambda_hooks.inject_ldm_provisioner.run(self)
+
     def start(self) -> VersionState:
         try:
             self.log_handler.start_subscriber()
@@ -194,15 +201,31 @@ class LambdaVersionManager:
 
         # If the environment has debugging enabled, route the invocation there;
         # debug environments bypass Lambda service quotas.
-        if debug_execution_environment := LDM.get_execution_environment(
-            qualified_lambda_arn=self.function_version.qualified_arn,
-            user_agent=invocation.user_agent,
+        if self.ldm_provisioner and (
+            ldm_execution_environment := self.ldm_provisioner.get_execution_environment(
+                qualified_lambda_arn=self.function_version.qualified_arn,
+                user_agent=invocation.user_agent,
+            )
         ):
             try:
-                invocation_result = debug_execution_environment.invoke(invocation)
+                invocation_result = ldm_execution_environment.invoke(invocation)
                 invocation_result.executed_version = self.function_version.id.qualifier
                 self.store_logs(
-                    invocation_result=invocation_result, execution_env=debug_execution_environment
+                    invocation_result=invocation_result, execution_env=ldm_execution_environment
+                )
+            except CancelledError as e:
+                # Timeouts for invocation futures are managed by LDM, a cancelled error here is
+                # aligned with the debug container terminating whilst debugging/invocation.
+                LOG.debug("LDM invocation future encountered a cancelled error: '%s'", e)
+                invocation_result = InvocationResult(
+                    request_id="",
+                    payload=to_bytes(
+                        "The invocation was canceled because the debug configuration "
+                        "was removed or the operation timed out"
+                    ),
+                    is_error=True,
+                    logs="",
+                    executed_version=self.function_version.id.qualifier,
                 )
             except StatusErrorException as e:
                 invocation_result = InvocationResult(
@@ -213,7 +236,7 @@ class LambdaVersionManager:
                     executed_version=self.function_version.id.qualifier,
                 )
             finally:
-                debug_execution_environment.release()
+                ldm_execution_environment.release()
             return invocation_result
 
         with self.counting_service.get_invocation_lease(

localstack/services/lambda_/ldm.py

@@ -0,0 +1,14 @@
+import abc
+
+from localstack.aws.api.lambda_ import Arn
+from localstack.services.lambda_.invocation.execution_environment import ExecutionEnvironment
+
+DEFAULT_LDM_TIMEOUT_SECONDS: int = 3_600
+IS_LDM_ENABLED: bool = False
+
+
+class LDMProvisioner(abc.ABC):
+    @abc.abstractmethod
+    def get_execution_environment(
+        self, qualified_lambda_arn: Arn, user_agent: str | None
+    ) -> ExecutionEnvironment | None: ...

localstack/services/lambda_/packages.py

@@ -4,7 +4,6 @@ import os
 import stat
 from functools import cache
 from pathlib import Path
-from typing import List
 
 from localstack import config
 from localstack.packages import DownloadInstaller, InstallTarget, Package, PackageInstaller
@@ -13,7 +12,7 @@ from localstack.utils.platform import get_arch
 """Customized LocalStack version of the AWS Lambda Runtime Interface Emulator (RIE).
 https://github.com/localstack/lambda-runtime-init/blob/localstack/README-LOCALSTACK.md
 """
-LAMBDA_RUNTIME_DEFAULT_VERSION = "v0.1.34-pre"
+LAMBDA_RUNTIME_DEFAULT_VERSION = "v0.1.36-pre"
 LAMBDA_RUNTIME_VERSION = config.LAMBDA_INIT_RELEASE_VERSION or LAMBDA_RUNTIME_DEFAULT_VERSION
 LAMBDA_RUNTIME_INIT_URL = "https://github.com/localstack/lambda-runtime-init/releases/download/{version}/aws-lambda-rie-{arch}"
 
@@ -35,7 +34,7 @@ class LambdaRuntimePackage(Package):
     def __init__(self, default_version: str = LAMBDA_RUNTIME_VERSION):
         super().__init__(name="Lambda", default_version=default_version)
 
-    def get_versions(self) -> List[str]:
+    def get_versions(self) -> list[str]:
         return [LAMBDA_RUNTIME_VERSION]
 
     def _get_installer(self, version: str) -> PackageInstaller:
@@ -75,7 +74,7 @@ class LambdaJavaPackage(Package):
     def __init__(self):
         super().__init__("LambdaJavaLibs", "0.2.22")
 
-    def get_versions(self) -> List[str]:
+    def get_versions(self) -> list[str]:
         return ["0.2.22", "0.2.21"]
 
     def _get_installer(self, version: str) -> PackageInstaller: