localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/aws/handlers/analytics.py

@@ -60,7 +60,7 @@ class ServiceRequestCounter:
             if context.service_exception:
                 return context.service_exception.code
 
-            response = parse_response(context.operation, response)
+            response = parse_response(context.operation, context.protocol, response)
             return response["Error"]["Code"]
         except Exception:
             if config.DEBUG_ANALYTICS:

localstack/aws/handlers/internal_requests.py

@@ -20,7 +20,12 @@ class InternalRequestParamsEnricher(Handler):
             try:
                 dto = MappingProxyType(load_dto(header))
             except Exception as e:
-                LOG.exception("Error loading request parameters '%s', Error: %s", header, e)
+                LOG.error(
+                    "Error loading request parameters '%s', Error: %s",
+                    header,
+                    e,
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                )
                 return
 
             context.internal_request_params = dto

localstack/aws/handlers/logging.py

@@ -1,6 +1,7 @@
 """Handlers for logging."""
 
 import logging
+import types
 from functools import cached_property
 
 from localstack.aws.api import RequestContext, ServiceException
@@ -21,6 +22,14 @@ class ExceptionLogger(ExceptionHandler):
     def __init__(self, logger=None):
         self.logger = logger or LOG
 
+        try:
+            import moto.core.exceptions
+
+            self._moto_service_exception = moto.core.exceptions.ServiceException
+        except (ModuleNotFoundError, AttributeError):
+            # Moto may not be available in stripped-down versions of LocalStack, like LocalStack S3 image.
+            self._moto_service_exception = types.EllipsisType
+
     def __call__(
         self,
         chain: HandlerChain,
@@ -28,9 +37,10 @@ class ExceptionLogger(ExceptionHandler):
         context: RequestContext,
         response: Response,
     ):
-        if isinstance(exception, ServiceException):
+        if isinstance(exception, (ServiceException, self._moto_service_exception)):
             # We do not want to log an error/stacktrace if the handler is working as expected, but chooses to throw
-            # a service exception
+            # a service exception. It may also throw a Moto ServiceException, which should not be logged either
+            # because ServiceExceptionHandler understands it.
             return
         if self.logger.isEnabledFor(level=logging.DEBUG):
             self.logger.exception("exception during call chain", exc_info=exception)

localstack/aws/handlers/metric_handler.py

@@ -1,9 +1,15 @@
+import csv
 import logging
+import os
+from datetime import datetime
+from pathlib import Path
 
 from localstack import config
 from localstack.aws.api import RequestContext
 from localstack.aws.chain import HandlerChain
+from localstack.constants import ENV_INTERNAL_TEST_STORE_METRICS_PATH
 from localstack.http import Response
+from localstack.utils.strings import short_uid
 
 LOG = logging.getLogger(__name__)
 
@@ -137,6 +143,32 @@ class MetricHandler:
 
     def __init__(self) -> None:
         self.metrics_handler_items = {}
+        self.local_filename = None
+
+        if self.should_store_metric_locally():
+            self.local_filename = self.create_local_file()
+
+    @staticmethod
+    def should_store_metric_locally() -> bool:
+        return config.is_collect_metrics_mode() and config.store_test_metrics_in_local_filesystem()
+
+    @staticmethod
+    def create_local_file():
+        folder = Path(
+            os.environ.get(ENV_INTERNAL_TEST_STORE_METRICS_PATH, "/tmp/localstack-metrics")
+        )
+        if not folder.exists():
+            folder.mkdir(parents=True, exist_ok=True)
+        LOG.debug("Metric reports will be stored in %s", folder)
+        filename = (
+            folder
+            / f"metric-report-raw-data-{datetime.utcnow().strftime('%Y-%m-%d__%H_%M_%S')}-{short_uid()}.csv"
+        )
+        with open(filename, "w") as fd:
+            LOG.debug("Creating new metric data file %s", filename)
+            writer = csv.writer(fd)
+            writer.writerow(Metric.RAW_DATA_HEADER)
+        return filename
 
     def create_metric_handler_item(
         self, chain: HandlerChain, context: RequestContext, response: Response
@@ -194,7 +226,15 @@ class MetricHandler:
         )
         # refrain from adding duplicates
         if metric not in MetricHandler.metric_data:
-            MetricHandler.metric_data.append(metric)
+            self.append_metric(metric)
 
         # cleanup
         del self.metrics_handler_items[context]
+
+    def append_metric(self, metric: Metric):
+        if self.should_store_metric_locally():
+            with open(self.local_filename, "a") as fd:
+                writer = csv.writer(fd)
+                writer.writerow(metric)
+        else:
+            MetricHandler.metric_data.append(metric)

localstack/aws/handlers/service.py

@@ -2,6 +2,7 @@
 
 import logging
 import traceback
+import types
 from collections import defaultdict
 from typing import Any
 
@@ -9,15 +10,15 @@ from botocore.model import OperationModel, ServiceModel
 
 from localstack import config
 from localstack.http import Response
-from localstack.utils.coverage_docs import get_coverage_link_for_service
 
+from ...utils.coverage_docs import get_coverage_link_for_service
 from ..api import CommonServiceException, RequestContext, ServiceException
 from ..api.core import ServiceOperation
 from ..chain import CompositeResponseHandler, ExceptionHandler, Handler, HandlerChain
 from ..client import parse_response, parse_service_exception
 from ..protocol.parser import RequestParser, create_parser
 from ..protocol.serializer import create_serializer
-from ..protocol.service_router import determine_aws_service_model
+from ..protocol.service_router import determine_aws_protocol, determine_aws_service_model
 from ..skeleton import Skeleton, create_skeleton
 
 LOG = logging.getLogger(__name__)
@@ -33,6 +34,8 @@ class ServiceNameParser(Handler):
         # example). If it is already set, we can skip the parsing of the request. It is very important for S3, because
         # parsing the request will consume the data stream and prevent streaming.
         if context.service:
+            if not context.protocol:
+                context.protocol = determine_aws_protocol(context.request, context.service)
             return
 
         service_model = determine_aws_service_model(context.request)
@@ -41,6 +44,7 @@ class ServiceNameParser(Handler):
             return
 
         context.service = service_model
+        context.protocol = determine_aws_protocol(context.request, service_model)
 
 
 class ServiceRequestParser(Handler):
@@ -63,7 +67,7 @@ class ServiceRequestParser(Handler):
         return self.parse_and_enrich(context)
 
     def parse_and_enrich(self, context: RequestContext):
-        parser = create_parser(context.service)
+        parser = create_parser(context.service, context.protocol)
         operation, instance = parser.parse(context.request)
 
         # enrich context
@@ -137,7 +141,7 @@ class ServiceRequestRouter(Handler):
         operation_name = operation.name
         message = f"no handler for operation '{operation_name}' on service '{service_name}'"
         error = CommonServiceException("InternalFailure", message, status_code=501)
-        serializer = create_serializer(context.service)
+        serializer = create_serializer(context.service, context.protocol)
         return serializer.serialize_error_to_response(
             error, operation, context.request.headers, context.request_id
         )
@@ -153,6 +157,15 @@ class ServiceExceptionSerializer(ExceptionHandler):
     def __init__(self):
         self.handle_internal_failures = True
 
+        try:
+            import moto.core.exceptions
+
+            self._moto_service_exception = moto.core.exceptions.ServiceException
+        except (ModuleNotFoundError, AttributeError) as exc:
+            # Moto may not be available in stripped-down versions of LocalStack, like LocalStack S3 image.
+            LOG.debug("Unable to set up Moto ServiceException translation: %s", exc)
+            self._moto_service_exception = types.EllipsisType
+
     def __call__(
         self,
         chain: HandlerChain,
@@ -176,43 +189,48 @@ class ServiceExceptionSerializer(ExceptionHandler):
             action_name = operation.name
             exception_message: str | None = exception.args[0] if exception.args else None
             message = exception_message or get_coverage_link_for_service(service_name, action_name)
-            LOG.info(message)
             error = CommonServiceException("InternalFailure", message, status_code=501)
-            context.service_exception = error
+            LOG.info(message)
+
+        elif isinstance(exception, self._moto_service_exception):
+            # Translate Moto ServiceException to native ServiceException if Moto is available.
+            # This allows handler chain to gracefully handles Moto errors when provider handlers invoke Moto methods directly.
+            error = CommonServiceException(
+                code=exception.code,
+                message=exception.message,
+            )
 
         elif not isinstance(exception, ServiceException):
             if not self.handle_internal_failures:
                 return
 
             if config.INCLUDE_STACK_TRACES_IN_HTTP_RESPONSE:
-                exception = "".join(
+                message = "".join(
                     traceback.format_exception(
                         type(exception), value=exception, tb=exception.__traceback__
                     )
                 )
+            else:
+                message = str(exception)
 
             # wrap exception for serialization
             if operation:
                 operation_name = operation.name
-                msg = "exception while calling %s.%s: %s" % (
-                    service_name,
-                    operation_name,
-                    exception,
-                )
+                msg = f"exception while calling {service_name}.{operation_name}: {message}"
             else:
                 # just use any operation for mocking purposes (the parser needs it to populate the default response)
                 operation = context.service.operation_model(context.service.operation_names[0])
-                msg = "exception while calling %s with unknown operation: %s" % (
-                    service_name,
-                    exception,
-                )
+                msg = f"exception while calling {service_name} with unknown operation: {message}"
 
             status_code = 501 if config.FAIL_FAST else 500
 
-            error = CommonServiceException("InternalError", msg, status_code=status_code)
-            context.service_exception = error
+            error = CommonServiceException(
+                "InternalError", msg, status_code=status_code
+            ).with_traceback(exception.__traceback__)
 
-        serializer = create_serializer(context.service)  # TODO: serializer cache
+        context.service_exception = error
+
+        serializer = create_serializer(context.service, context.protocol)
         return serializer.serialize_error_to_response(
             error, operation, context.request.headers, context.request_id
         )
@@ -255,7 +273,9 @@ class ServiceResponseParser(Handler):
             return
 
         # in this case we need to parse the raw response
-        parsed = parse_response(context.operation, response, include_response_metadata=False)
+        parsed = parse_response(
+            context.operation, context.protocol, response, include_response_metadata=False
+        )
         if service_exception := parse_service_exception(response, parsed):
             context.service_exception = service_exception
         else:

localstack/aws/mocking.py

@@ -224,7 +224,7 @@ custom_arns = {
 def generate_instance(shape: Shape, graph: ShapeGraph) -> Instance | None:
     if shape is None:
         return None
-    raise ValueError("could not generate shape for type %s" % shape.type_name)
+    raise ValueError(f"could not generate shape for type {shape.type_name}")
 
 
 @generate_instance.register
@@ -383,7 +383,7 @@ def _(shape: Shape, graph: ShapeGraph) -> int | float | bool | bytes | date:
     if shape.type_name == "timestamp":
         return datetime.now()
 
-    raise ValueError("unknown type %s" % shape.type_name)
+    raise ValueError(f"unknown type {shape.type_name}")
 
 
 def generate_response(operation: OperationModel):

localstack/aws/patches.py

@@ -20,12 +20,12 @@ def patch_moto_instance_tracker_meta():
         cls = super(InstanceTrackerMeta, meta).__new__(meta, name, bases, dct)
         if name == "BaseModel":
             return cls
-        cls.instances = []
+        cls.instances_tracked = []
         return cls
 
     @patch(BaseModel.__new__, pass_target=False)
     def new_basemodel(cls, *args, **kwargs):
-        # skip cls.instances.append(..) which is done by the original/upstream constructor
+        # skip cls.instances_tracked.append(..) which is done by the original/upstream constructor
         instance = super(BaseModel, cls).__new__(cls)
         return instance