localstack-core 4.14.1.dev59__tar.gz → 4.14.1.dev63__tar.gz

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localstack-core
-Version: 4.14.1.dev59
+Version: 4.14.1.dev63
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 License-Expression: Apache-2.0

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/aws/connect.py

@@ -15,7 +15,7 @@ from collections.abc import Callable
 from functools import lru_cache, partial
 from random import choice
 from socket import socket
-from typing import Any, Generic, TypedDict, TypeVar
+from typing import Any, Generic, Self, TypedDict, TypeVar
 
 import dns.message
 import dns.query
@@ -149,14 +149,17 @@ INTERNAL_REQUEST_PARAMS_HEADER = "x-localstack-data"
 
 class InternalRequestParameters(TypedDict):
     """
-    LocalStack Data Transfer Object.
+    LocalStack Data Transfer Object (DTO).
 
-    This is sent with every internal request and contains any additional information
-    LocalStack might need for the purpose of policy enforcement. It is serialised
+    This is sent for internal requests and contains any additional information
+    LocalStack might need (e.g., IAM policy enforcement). The DTO is serialised
     into text and sent in the request header.
 
     Attributes can be added as needed. The keys should roughly correspond to:
     https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html
+
+    Recommendation: Typed LocalStack-internal metadata go here and other headers such as the
+    AWS X-Amzn-Trace-Id go into .custom_headers(...).
     """
 
     source_arn: str | None
@@ -183,16 +186,27 @@ T = TypeVar("T")
 
 
 class MetadataRequestInjector(Generic[T]):
-    def __init__(self, client: T, params: dict[str, str] | None = None):
+    def __init__(
+        self,
+        client: T,
+        params: dict[str, str] | None = None,
+        custom_headers: dict[str, str] | None = None,
+    ):
         self._client = client
         self._params = params
+        self._custom_headers = custom_headers
 
     def __getattr__(self, item):
         target = getattr(self._client, item)
         if not isinstance(target, Callable):
             return target
-        if self._params:
-            return partial(target, **self._params)
+        if self._params or self._custom_headers:
+            kwargs = {}
+            if self._params:
+                kwargs = self._params
+            if self._custom_headers:
+                kwargs["_CustomHeaders"] = self._custom_headers
+            return partial(target, **kwargs)
         else:
             return target
 
@@ -201,24 +215,24 @@ class MetadataRequestInjector(Generic[T]):
         source_arn: str | None = None,
         service_principal: str | None = None,
         trace_visibility: TraceVisibility | None = None,
-    ) -> T:
+    ) -> T | Self:
         """
-        Returns a new client instance preset with the given request metadata.
-        Identical to providing _ServicePrincipal, _SourceArn or _TraceVisibilty directly as operation arguments but typing
-        compatible.
+        Returns a new client instance preset with the given request metadata or Self for chaining.
+        Identical to providing _ServicePrincipal, _SourceArn, or _TraceVisibilty
+        directly as operation arguments but typing compatible.
 
         Raw example: lambda_client.invoke(FunctionName="fn", _SourceArn="...")
         Injector example: lambda_client.request_metadata(source_arn="...").invoke(FunctionName="fn")
-        Cannot be called on objects where the parameters are already set.
 
-        :param source_arn: Arn on which behalf the calls of this client shall be made
-        :param service_principal: Service principal on which behalf the calls of this client shall be made
+        Can be called on an already-configured injector to layer additional parameters on top of
+        the existing ones (later values win on conflict).
+
+        :param source_arn: ARN of the resource on whose behalf the call is made
+        :param service_principal: Service principal making the call
         :param trace_visibility: Visibility of this call, for tracing purposes
-        :return: A new version of the MetadataRequestInjector
+        :return: A new MetadataRequestInjector with the merged parameters
         """
-        if self._params is not None:
-            raise TypeError("Request_data cannot be called on it's own return value")
-        params = {}
+        params = dict(self._params) if self._params else {}
         if source_arn:
             params["_SourceArn"] = source_arn
         if service_principal:
@@ -227,6 +241,21 @@ class MetadataRequestInjector(Generic[T]):
             params["_TraceVisibility"] = trace_visibility.value
         return MetadataRequestInjector(client=self._client, params=params)
 
+    def custom_headers(self, custom_headers: dict[str, str]) -> T | Self:
+        """
+        Returns a new client instance preset with the given request metadata or Self for chaining.
+        Identical to providing _CustomHeaders directly as operation arguments but typing compatible.
+
+        Injector example: lambda_client.custom_headers({"X-Amzn-Trace-Id": "Root=1-67891233-abcdef012345678912345678"})
+                                       .invoke(FunctionName="fn")
+        Chaining .custom_headers().custom_headers() merges the dicts.
+        """
+        merged = dict(self._custom_headers) if self._custom_headers else {}
+        merged.update(custom_headers)
+        return MetadataRequestInjector(
+            client=self._client, params=self._params, custom_headers=merged
+        )
+
 
 #
 # Factory
@@ -813,12 +842,20 @@ def _handler_create_request_parameters(params: dict[str, Any], context: dict[str
             dto[member] = params.pop(parameter)
 
     context["_localstack"] = dto
+    if headers := params.pop("_CustomHeaders", None):
+        context["_custom_headers"] = headers
 
 
 def _handler_inject_dto_header(params: dict[str, Any], context: dict[str, Any], **kwargs):
     """
     Retrieve the data transfer object from the Boto context dict and serialise
     it as part of the request headers.
+
+    Custom headers (if any) are applied directly to the outgoing HTTP request on the sender
+    side and are not forwarded in the serialised DTO, since the receiving service already
+    sees them as regular HTTP headers.
     """
     if (dto := context.pop("_localstack", None)) is not None:
         params["headers"][INTERNAL_REQUEST_PARAMS_HEADER] = dump_dto(dto)
+        if custom_headers := context.pop("_custom_headers", None):
+            params["headers"].update(custom_headers)

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/aws/handlers/tracing.py

@@ -9,6 +9,8 @@ class TraceContextParser(Handler):
     A handler that parses trace context headers, including:
     * AWS X-Ray trace header: https://docs.aws.amazon.com/xray/latest/devguide/xray-concepts.html#xray-concepts-tracingheader
       X-Amzn-Trace-Id: Root=1-5759e988-bd862e3fe1be46a994272793;Sampled=1;Lineage=a87bd80c:1|68fd508a:5|c512fbe3:2
+    * AWS request id header: https://http.dev/x-amz-request-id
+      X-Amz-Request-Id: 6479de2e-44d0-47c9-ac32-4d720d411eb1
     """
 
     def __call__(self, chain: HandlerChain, context: RequestContext, response: Response):
@@ -21,3 +23,8 @@ class TraceContextParser(Handler):
         context.trace_context["aws_trace_header"] = aws_trace_header
         # NOTE: X-Ray sampling might require service-specific decisions:
         #  https://docs.aws.amazon.com/xray/latest/devguide/xray-console-sampling.html
+
+        # Allows retaining a request id for cross-service calls. For example, Lambda event invokes must retain the same
+        # AWS request id for retries and this mechanism enables LocalStack-internal lambda.Invoke calls to do that.
+        if request_id := context.request.headers.get("X-Amz-Request-Id"):
+            context.request_id = request_id

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/services/lambda_/invocation/event_manager.py

@@ -7,11 +7,13 @@ import time
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from math import ceil
+from typing import TYPE_CHECKING
 
 from botocore.config import Config
 
 from localstack import config
 from localstack.aws.api.lambda_ import InvocationType, TooManyRequestsException
+from localstack.aws.connect import MetadataRequestInjector, connect_to
 from localstack.services.lambda_.analytics import (
     FunctionInitializationType,
     FunctionOperation,
@@ -23,7 +25,6 @@ from localstack.services.lambda_.invocation.lambda_models import (
     EventInvokeConfig,
     FunctionVersion,
     Invocation,
-    InvocationResult,
 )
 from localstack.services.lambda_.invocation.version_manager import LambdaVersionManager
 from localstack.utils.aws import dead_letter_queue
@@ -33,6 +34,10 @@ from localstack.utils.threads import FuncThread
 from localstack.utils.time import timestamp_millis
 from localstack.utils.xray.trace_header import TraceHeader
 
+if TYPE_CHECKING:
+    from mypy_boto3_lambda import LambdaClient
+
+
 LOG = logging.getLogger(__name__)
 
 
@@ -40,14 +45,6 @@ def get_sqs_client(function_version: FunctionVersion, client_config=None):
     return get_fake_sqs_client()
 
 
-# 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().__init__(message)
-        self.log_output = log_output
-        self.result = result
-
-
 @dataclasses.dataclass
 class SQSInvocation:
     invocation: Invocation
@@ -119,7 +116,6 @@ def has_enough_time_for_retry(
     )
 
 
-# TODO: optimize this client configuration. Do we need to consider client caching here?
 CLIENT_CONFIG = Config(
     connect_timeout=5,
     read_timeout=10,
@@ -132,6 +128,7 @@ class Poller:
     event_queue_url: str
     _shutdown_event: threading.Event
     invoker_pool: ThreadPoolExecutor
+    lambda_client: "LambdaClient | MetadataRequestInjector[LambdaClient]"
 
     def __init__(self, version_manager: LambdaVersionManager, event_queue_url: str):
         self.version_manager = version_manager
@@ -142,6 +139,10 @@ class Poller:
         self.invoker_pool = ThreadPoolExecutor(
             thread_name_prefix=f"lambda-invoker-{function_id.function_name}:{function_id.qualifier}"
         )
+        # Root client for LocalStack-internal requests bypassing IAM enforcement
+        self.lambda_client = connect_to(
+            aws_access_key_id=function_id.account, region_name=function_id.region
+        ).lambda_
 
     def run(self, *args, **kwargs):
         sqs_client = get_sqs_client(
@@ -153,7 +154,7 @@ class Poller:
                 response = sqs_client.receive_message(
                     QueueUrl=self.event_queue_url,
                     # TODO: consider replacing with short polling instead of long polling to prevent keeping connections open
-                    # however, we had some serious performance issues when tried out, so those have to be investigated first
+                    #  however, we had some serious performance issues when tried out, so those have to be investigated first
                     WaitTimeSeconds=2,
                     # Related: SQS event source mapping batches up to 10 messages:
                     # https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html
@@ -197,13 +198,11 @@ class Poller:
         self.invoker_pool.shutdown(cancel_futures=True, wait=False)
 
     def handle_message(self, message: dict) -> None:
-        failure_cause = None
         qualifier = self.version_manager.function_version.id.qualifier
         function_config = self.version_manager.function_version.config
         event_invoke_config = self.version_manager.function.event_invoke_configs.get(qualifier)
-        runtime = None
-        status = None
-        # TODO: handle initialization_type provisioned-concurrency, which requires enriching invocation_result
+        runtime = function_config.runtime
+        # TODO: consider ignoring this one for async/event invoke now that we perform a lambda.Invoke
         initialization_type = (
             FunctionInitializationType.lambda_managed_instances
             if function_config.capacity_provider_config
@@ -212,31 +211,32 @@ class Poller:
         try:
             sqs_invocation = SQSInvocation.decode(message["Body"])
             invocation = sqs_invocation.invocation
+
+            invoke_response = None
+            response_payload = None
+            status = None
+            invoke_succeeded = False
+
             try:
-                invocation_result = self.version_manager.invoke(invocation=invocation)
+                aws_trace_header = invocation.trace_context["aws_trace_header"]
+                invoke_response = self.lambda_client.custom_headers(
+                    {
+                        "X-Amzn-Trace-Id": aws_trace_header.to_header_str(),
+                        "X-Amz-Request-Id": invocation.request_id,
+                    }
+                ).invoke(
+                    FunctionName=invocation.invoked_arn,
+                    Payload=invocation.payload,
+                    InvocationType=InvocationType.RequestResponse,
+                )
+                # Read the stream because the payload can be used multiple times (e.g., DLQ + failure destination)
+                response_payload = (
+                    json.load(invoke_response["Payload"]) if invoke_response["Payload"] else {}
+                )
                 status = FunctionStatus.success
+                invoke_succeeded = True
             except Exception as e:
-                # Reserved concurrency == 0
-                if self.version_manager.function.reserved_concurrent_executions == 0:
-                    failure_cause = "ZeroReservedConcurrency"
-                    status = FunctionStatus.zero_reserved_concurrency_error
-                # Maximum event age expired (lookahead for next retry)
-                elif not has_enough_time_for_retry(sqs_invocation, event_invoke_config):
-                    failure_cause = "EventAgeExceeded"
-                    status = FunctionStatus.event_age_exceeded_error
-
-                if failure_cause:
-                    invocation_result = InvocationResult(
-                        is_error=True, request_id=invocation.request_id, payload=None, logs=None
-                    )
-                    self.process_failure_destination(
-                        sqs_invocation, invocation_result, event_invoke_config, failure_cause
-                    )
-                    self.process_dead_letter_queue(sqs_invocation, invocation_result)
-                    return
-                # 3) Otherwise, retry without increasing counter
-                status = self.process_throttles_and_system_errors(sqs_invocation, e)
-                return
+                status = self._handle_invoke_exception(sqs_invocation, e, event_invoke_config)
             finally:
                 sqs_client = get_sqs_client(self.version_manager.function_version)
                 sqs_client.delete_message(
@@ -252,62 +252,107 @@ class Poller:
                     initialization_type=initialization_type,
                 ).increment()
 
-            # Good summary blogpost: https://haithai91.medium.com/aws-lambdas-retry-behaviors-edff90e1cf1b
-            # Asynchronous invocation handling: https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html
-            # https://aws.amazon.com/blogs/compute/introducing-new-asynchronous-invocation-metrics-for-aws-lambda/
-            max_retry_attempts = 2
-            if event_invoke_config and event_invoke_config.maximum_retry_attempts is not None:
-                max_retry_attempts = event_invoke_config.maximum_retry_attempts
-
-            assert invocation_result, "Invocation result MUST exist if we are not returning before"
-
-            # An invocation error either leads to a terminal failure or to a scheduled retry
-            if invocation_result.is_error:  # invocation error
-                failure_cause = None
-                # Reserved concurrency == 0
-                if self.version_manager.function.reserved_concurrent_executions == 0:
-                    failure_cause = "ZeroReservedConcurrency"
-                # Maximum retries exhausted
-                elif sqs_invocation.retries >= max_retry_attempts:
-                    failure_cause = "RetriesExhausted"
-                # TODO: test what happens if max event age expired before it gets scheduled the first time?!
-                # Maximum event age expired (lookahead for next retry)
-                elif not has_enough_time_for_retry(sqs_invocation, event_invoke_config):
-                    failure_cause = "EventAgeExceeded"
-
-                if failure_cause:  # handle failure destination and DLQ
-                    self.process_failure_destination(
-                        sqs_invocation, invocation_result, event_invoke_config, failure_cause
+            if invoke_succeeded:
+                # Good summary blogpost: https://haithai91.medium.com/aws-lambdas-retry-behaviors-edff90e1cf1b
+                # Asynchronous invocation handling: https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html
+                # https://aws.amazon.com/blogs/compute/introducing-new-asynchronous-invocation-metrics-for-aws-lambda/
+                max_retry_attempts = 2
+                if event_invoke_config and event_invoke_config.maximum_retry_attempts is not None:
+                    max_retry_attempts = event_invoke_config.maximum_retry_attempts
+
+                # An invocation error either leads to a terminal failure or to a scheduled retry
+                if "FunctionError" in invoke_response:
+                    self._handle_function_error(
+                        sqs_invocation, response_payload, event_invoke_config, max_retry_attempts
                     )
-                    self.process_dead_letter_queue(sqs_invocation, invocation_result)
-                    return
-                else:  # schedule retry
-                    sqs_invocation.retries += 1
-                    # Assumption: We assume that the internal exception retries counter is reset after
-                    #  an invocation that does not throw an exception
-                    sqs_invocation.exception_retries = 0
-                    # LAMBDA_RETRY_BASE_DELAY_SECONDS has a limit of 300s because the maximum SQS DelaySeconds
-                    # is 15 minutes (900s) and the maximum retry count is 3. SQS quota for "Message timer":
-                    # https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html
-                    delay_seconds = sqs_invocation.retries * config.LAMBDA_RETRY_BASE_DELAY_SECONDS
-                    # TODO: max SQS message size limit could break parity with AWS because
-                    #  our SQSInvocation contains additional fields! 256kb is max for both Lambda payload + SQS
-                    # TODO: write test with max SQS message size
-                    sqs_client.send_message(
-                        QueueUrl=self.event_queue_url,
-                        MessageBody=sqs_invocation.encode(),
-                        DelaySeconds=delay_seconds,
+                else:
+                    self.process_success_destination(
+                        sqs_invocation, response_payload, event_invoke_config
                     )
-                    return
-            else:  # invocation success
-                self.process_success_destination(
-                    sqs_invocation, invocation_result, event_invoke_config
-                )
         except Exception as e:
             LOG.error(
                 "Error handling lambda invoke %s", e, exc_info=LOG.isEnabledFor(logging.DEBUG)
             )
 
+    def _handle_invoke_exception(
+        self,
+        sqs_invocation: SQSInvocation,
+        error: Exception,
+        event_invoke_config: EventInvokeConfig | None,
+    ) -> str:
+        """Handle an exception raised during function invocation and return the resulting status."""
+        # Reserved concurrency == 0
+        if (
+            isinstance(error, self.lambda_client.exceptions.TooManyRequestsException)
+            and self.version_manager.function.reserved_concurrent_executions == 0
+        ):
+            failure_cause = "ZeroReservedConcurrency"
+            status = FunctionStatus.zero_reserved_concurrency_error
+        # Maximum event age expired (lookahead for next retry)
+        elif not has_enough_time_for_retry(sqs_invocation, event_invoke_config):
+            failure_cause = "EventAgeExceeded"
+            status = FunctionStatus.event_age_exceeded_error
+        else:
+            failure_cause = None
+            status = None
+
+        if failure_cause:
+            self.process_failure_destination(
+                sqs_invocation, None, event_invoke_config, failure_cause
+            )
+            self.process_dead_letter_queue(sqs_invocation, None)
+            assert status, "status MUST be set in case of failure"
+            return status
+
+        # Otherwise, retry without increasing counter (throttles or system errors)
+        return self.process_throttles_and_system_errors(sqs_invocation, error)
+
+    def _handle_function_error(
+        self,
+        sqs_invocation: SQSInvocation,
+        response_payload: dict,
+        event_invoke_config: EventInvokeConfig | None,
+        max_retry_attempts: int,
+    ) -> None:
+        """Handle a FunctionError in the invoke response: either terminal failure or scheduled retry."""
+        # Reserved concurrency == 0
+        if self.version_manager.function.reserved_concurrent_executions == 0:
+            failure_cause = "ZeroReservedConcurrency"
+        # Maximum retries exhausted
+        elif sqs_invocation.retries >= max_retry_attempts:
+            failure_cause = "RetriesExhausted"
+        # TODO: test what happens if max event age expired before it gets scheduled the first time?!
+        # Maximum event age expired (lookahead for next retry)
+        elif not has_enough_time_for_retry(sqs_invocation, event_invoke_config):
+            failure_cause = "EventAgeExceeded"
+        else:
+            failure_cause = None
+
+        if failure_cause:
+            self.process_failure_destination(
+                sqs_invocation, response_payload, event_invoke_config, failure_cause
+            )
+            self.process_dead_letter_queue(sqs_invocation, response_payload)
+        else:
+            # Schedule retry
+            sqs_invocation.retries += 1
+            # Assumption: We assume that the internal exception retries counter is reset after
+            #  an invocation that does not throw an exception
+            sqs_invocation.exception_retries = 0
+            # LAMBDA_RETRY_BASE_DELAY_SECONDS has a limit of 300s because the maximum SQS DelaySeconds
+            # is 15 minutes (900s) and the maximum retry count is 3. SQS quota for "Message timer":
+            # https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/quotas-messages.html
+            delay_seconds = sqs_invocation.retries * config.LAMBDA_RETRY_BASE_DELAY_SECONDS
+            # TODO: max SQS message size limit could break parity with AWS because
+            #  our SQSInvocation contains additional fields! 256kb is max for both Lambda payload + SQS
+            # TODO: write test with max SQS message size
+            sqs_client = get_sqs_client(self.version_manager.function_version)
+            sqs_client.send_message(
+                QueueUrl=self.event_queue_url,
+                MessageBody=sqs_invocation.encode(),
+                DelaySeconds=delay_seconds,
+            )
+
     def process_throttles_and_system_errors(
         self, sqs_invocation: SQSInvocation, error: Exception
     ) -> str:
@@ -346,7 +391,7 @@ class Poller:
     def process_success_destination(
         self,
         sqs_invocation: SQSInvocation,
-        invocation_result: InvocationResult,
+        response_payload: dict,
         event_invoke_config: EventInvokeConfig | None,
     ) -> None:
         if event_invoke_config is None:
@@ -363,7 +408,7 @@ class Poller:
             "version": "1.0",
             "timestamp": timestamp_millis(),
             "requestContext": {
-                "requestId": invocation_result.request_id,
+                "requestId": sqs_invocation.invocation.request_id,
                 "functionArn": self.version_manager.function_version.qualified_arn,
                 "condition": "Success",
                 "approximateInvokeCount": sqs_invocation.retries + 1,
@@ -373,7 +418,8 @@ class Poller:
                 "statusCode": 200,
                 "executedVersion": self.version_manager.function_version.id.qualifier,
             },
-            "responsePayload": json.loads(to_str(invocation_result.payload or {})),
+            # TODO: test None or empty string similar to test_invocation_type_no_return_payload
+            "responsePayload": response_payload,
         }
 
         target_arn = event_invoke_config.destination_config["OnSuccess"]["Destination"]
@@ -393,7 +439,7 @@ class Poller:
     def process_failure_destination(
         self,
         sqs_invocation: SQSInvocation,
-        invocation_result: InvocationResult,
+        response_payload: dict,
         event_invoke_config: EventInvokeConfig | None,
         failure_cause: str,
     ):
@@ -415,7 +461,7 @@ class Poller:
             "version": "1.0",
             "timestamp": timestamp_millis(),
             "requestContext": {
-                "requestId": invocation_result.request_id,
+                "requestId": sqs_invocation.invocation.request_id,
                 "functionArn": self.version_manager.function_version.qualified_arn,
                 "condition": failure_cause,
                 "approximateInvokeCount": approximate_invoke_count,
@@ -428,7 +474,7 @@ class Poller:
                 "executedVersion": self.version_manager.function_version.id.qualifier,
                 "functionError": "Unhandled",
             }
-            destination_payload["responsePayload"] = json.loads(to_str(invocation_result.payload))
+            destination_payload["responsePayload"] = response_payload
 
         target_arn = event_invoke_config.destination_config["OnFailure"]["Destination"]
         try:
@@ -447,26 +493,23 @@ class Poller:
     def process_dead_letter_queue(
         self,
         sqs_invocation: SQSInvocation,
-        invocation_result: InvocationResult,
+        response_payload: dict,
     ):
         LOG.debug("Handling dead letter queue for %s", self.version_manager.function_arn)
         try:
-            dead_letter_queue._send_to_dead_letter_queue(
+            dead_letter_queue.send_to_dead_letter_queue(
                 source_arn=self.version_manager.function_arn,
                 dlq_arn=self.version_manager.function_version.config.dead_letter_arn,
                 event=json.loads(to_str(sqs_invocation.invocation.payload)),
-                # TODO: Refactor DLQ handling by removing the invocation exception from the legacy lambda provider
-                # TODO: Check message. Possibly remove because it is not used in the DLQ message?!
-                error=LegacyInvocationException(
-                    message="hi", result=to_str(invocation_result.payload)
-                ),
+                error_message=response_payload.get("errorMessage"),
                 role=self.version_manager.function_version.config.role,
             )
         except Exception as e:
-            LOG.warning(
+            LOG.error(
                 "Error sending invocation result to DLQ %s: %s",
                 self.version_manager.function_version.config.dead_letter_arn,
                 e,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
 
 

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/services/sns/publisher.py

@@ -447,7 +447,7 @@ class SqsBatchTopicPublisher(SqsTopicPublisher):
                     sns_error_to_dead_letter_queue(
                         sns_subscriber=subscriber,
                         message=failure_data["entry"]["MessageBody"],
-                        error=failed_msg["Code"],
+                        error_message=failed_msg["Code"],
                         **kwargs,
                     )
 

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/testing/pytest/fixtures.py

@@ -1531,6 +1531,12 @@ def create_echo_http_server(aws_client, create_lambda_function):
             Principal="*",
             FunctionUrlAuthType="NONE",
         )
+        aws_client.lambda_.add_permission(
+            FunctionName=func_name,
+            StatementId="invokePermission",
+            Action="lambda:InvokeFunction",
+            Principal="*",
+        )
         return url_response["FunctionUrl"]
 
     yield _create_echo_http_server

{localstack_core-4.14.1.dev59 → localstack_core-4.14.1.dev63}/localstack-core/localstack/utils/aws/dead_letter_queue.py

@@ -12,32 +12,36 @@ LOG = logging.getLogger(__name__)
 def sns_error_to_dead_letter_queue(
     sns_subscriber: dict,
     message: str,
-    error: str,
+    error_message: str,
     **kwargs,
 ):
     policy = json.loads(sns_subscriber.get("RedrivePolicy") or "{}")
     target_arn = policy.get("deadLetterTargetArn")
     if not target_arn:
-        return
+        return None
     if not_supported := (
         set(kwargs) - {"MessageAttributes", "MessageGroupId", "MessageDeduplicationId"}
     ):
         LOG.warning(
             "Not publishing to the DLQ - invalid arguments passed to the DLQ '%s'", not_supported
         )
-        return
+        return None
     event = {
         "message": message,
         **kwargs,
     }
-    return _send_to_dead_letter_queue(sns_subscriber["SubscriptionArn"], target_arn, event, error)
+    return send_to_dead_letter_queue(
+        sns_subscriber["SubscriptionArn"], target_arn, event, error_message
+    )
 
 
-def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: dict, error, role: str = None):
+def send_to_dead_letter_queue(
+    source_arn: str, dlq_arn: str, event: dict, error_message: str, role: str = None
+):
     if not dlq_arn:
-        return
+        return None
     LOG.info("Sending failed execution %s to dead letter queue %s", source_arn, dlq_arn)
-    messages = _prepare_messages_to_dlq(source_arn, event, error)
+    messages = _prepare_messages_to_dlq(source_arn, event, error_message)
     source_service = arns.extract_service_from_arn(source_arn)
     region = arns.extract_region_from_arn(dlq_arn)
     if role:
@@ -79,15 +83,15 @@ def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: dict, error
     return dlq_arn
 
 
-def _prepare_messages_to_dlq(source_arn: str, event: dict, error) -> list[dict]:
+def _prepare_messages_to_dlq(source_arn: str, event: dict, error_message: str) -> list[dict]:
     messages = []
     custom_attrs = {
         "RequestID": {"DataType": "String", "StringValue": str(uuid.uuid4())},
         "ErrorCode": {"DataType": "String", "StringValue": "200"},
-        "ErrorMessage": {"DataType": "String", "StringValue": str(error)},
+        "ErrorMessage": {"DataType": "String", "StringValue": error_message},
     }
     if ":sqs:" in source_arn:
-        custom_attrs["ErrorMessage"]["StringValue"] = str(error.result)
+        custom_attrs["ErrorMessage"]["StringValue"] = error_message
         for record in event.get("Records", []):
             msg_attrs = message_attributes_to_upper(record.get("messageAttributes"))
             message_attrs = {**msg_attrs, **custom_attrs}
@@ -109,13 +113,7 @@ def _prepare_messages_to_dlq(source_arn: str, event: dict, error) -> list[dict]:
 
     elif ":lambda:" in source_arn:
         custom_attrs["ErrorCode"]["DataType"] = "Number"
-        # not sure about what type of error can come here
-        try:
-            error_message = json.loads(error.result)["errorMessage"]
-            custom_attrs["ErrorMessage"]["StringValue"] = error_message
-        except (ValueError, KeyError):
-            # using old behaviour
-            custom_attrs["ErrorMessage"]["StringValue"] = str(error)
+        custom_attrs["ErrorMessage"]["StringValue"] = error_message
 
         messages.append(
             {