localstack-core 4.11.2.dev14__py3-none-any.whl → 4.12.1.dev25__py3-none-any.whl

localstack/services/cloudformation/scaffolding/__main__.py

@@ -10,6 +10,7 @@ from functools import reduce
 from pathlib import Path
 from typing import Any, Literal, TypedDict, TypeVar
 
+import boto3
 import click
 from jinja2 import Environment, FileSystemLoader
 from yaml import safe_dump
@@ -140,14 +141,76 @@ class SchemaProvider:
             ) from e
 
 
+class LiveSchemaProvider:
+    """
+    Provides CloudFormation resource schemas by fetching them from the live AWS CloudFormation service, rather than
+    a local zip file.
+    """
+
+    def __init__(self, cfn_client):
+        self.cfn_client = cfn_client
+
+    def available_schemas(self, pattern: str) -> list[str]:
+        """
+        Return the names of available CloudFormation resource types. `pattern` should be something like
+        AWS::S3::Bucket or AWS::S3::*, depending on whether you want all resources for a service or a specific one.
+        The result is a list of matching resource type names (e.g. [AWS::S3::Bucket, AWS::S3::Object, ...])
+        """
+
+        is_wildcard = pattern.endswith("*")
+        pattern = pattern[:-1] if is_wildcard else pattern
+        matching_names = []
+
+        params = {
+            "Visibility": "PUBLIC",
+            "Type": "RESOURCE",
+            "DeprecatedStatus": "LIVE",
+            "Filters": {"Category": "AWS_TYPES", "TypeNamePrefix": pattern},
+        }
+        next_token: str | None = None
+
+        # Note: pagination is necessary since list_types requires multiple calls even to get a single result.
+        while True:
+            if next_token:
+                params["NextToken"] = next_token
+            response = self.cfn_client.list_types(**params)
+
+            # collect any matching type names (if wildcard, all; else exact match only)
+            matching_names.extend(
+                [
+                    type_summary["TypeName"]
+                    for type_summary in response.get("TypeSummaries", [])
+                    if (is_wildcard or type_summary["TypeName"] == pattern)
+                ]
+            )
+
+            next_token = response.get("NextToken")
+            if not next_token:
+                break
+
+        return matching_names
+
+    def schema(self, type_name: ResourceName) -> ResourceSchema:
+        """
+        Given a CloudFormation ResourceName (representing something like "AWS::S3::Bucket"), return the resource
+        schema as dict.
+        """
+        response = self.cfn_client.describe_type(
+            Type="RESOURCE",
+            TypeName=type_name.full_name,
+        )
+        schema_str = response.get("Schema")
+        if not schema_str:
+            raise click.ClickException(
+                f"Could not fetch schema for CloudFormation resource type: {type_name}"
+            )
+        return json.loads(schema_str)
+
+
 LOCALSTACK_ROOT_DIR = Path(__file__).parent.joinpath("../../../../..").resolve()
 LOCALSTACK_PRO_ROOT_DIR = LOCALSTACK_ROOT_DIR.joinpath("../localstack-pro").resolve()
-TESTS_ROOT_DIR = LOCALSTACK_ROOT_DIR.joinpath(
-    "tests/aws/services/cloudformation/resource_providers"
-)
-TESTS_PRO_ROOT_DIR = LOCALSTACK_PRO_ROOT_DIR.joinpath(
-    "localstack-pro-core/tests/aws/services/cloudformation/resource_providers"
-)
+TESTS_ROOT_DIR = LOCALSTACK_ROOT_DIR.joinpath("tests/aws/services")
+TESTS_PRO_ROOT_DIR = LOCALSTACK_PRO_ROOT_DIR.joinpath("localstack-pro-core/tests/aws/services")
 
 assert LOCALSTACK_ROOT_DIR.is_dir(), f"{LOCALSTACK_ROOT_DIR} does not exist"
 assert LOCALSTACK_PRO_ROOT_DIR.is_dir(), f"{LOCALSTACK_PRO_ROOT_DIR} does not exist"
@@ -193,7 +256,7 @@ def template_path(
     output_path = (
         tests_root_dir(pro)
         .joinpath(
-            f"{resource_name.python_compatible_service_name.lower()}/{resource_name.path_compatible_full_name()}/templates/{stub}"
+            f"{resource_name.python_compatible_service_name.lower()}/resource_providers/templates/{stub}"
         )
         .resolve()
     )
@@ -202,7 +265,7 @@ def template_path(
         test_path = (
             root_dir(pro)
             .joinpath(
-                f"tests/aws/cloudformation/resource_providers/{resource_name.python_compatible_service_name.lower()}/{resource_name.path_compatible_full_name()}"
+                f"tests/aws/{resource_name.python_compatible_service_name.lower()}/resource_providers/templates"
             )
             .resolve()
         )
@@ -276,7 +339,7 @@ class TemplateRenderer:
         # e.g. .../resource_providers/aws_iam_role/test_X.py vs. .../resource_providers/iam/test_X.py
         # add extra parameters
         tests_output_path = root_dir(self.pro).joinpath(
-            f"tests/aws/cloudformation/resource_providers/{resource_name.python_compatible_service_name.lower()}/{resource_name.full_name.lower()}"
+            f"tests/aws/{resource_name.python_compatible_service_name.lower()}/resource_providers/templates"
         )
         match file_type:
             case FileType.getatt_test:
@@ -284,7 +347,9 @@ class TemplateRenderer:
                 kwargs["service"] = resource_name.service.lower()
                 kwargs["resource"] = resource_name.resource.lower()
                 kwargs["template_path"] = str(
-                    template_path(resource_name, FileType.attribute_template, tests_output_path)
+                    template_path(
+                        resource_name, FileType.attribute_template, tests_output_path, pro=self.pro
+                    )
                 )
             case FileType.provider:
                 property_ir = generate_ir_for_type(
@@ -318,17 +383,25 @@ class TemplateRenderer:
                 kwargs["pro"] = self.pro
             case FileType.integration_test:
                 kwargs["black_box_template_path"] = str(
-                    template_path(resource_name, FileType.minimal_template, tests_output_path)
+                    template_path(
+                        resource_name, FileType.minimal_template, tests_output_path, pro=self.pro
+                    )
                 )
                 kwargs["update_template_path"] = str(
                     template_path(
                         resource_name,
                         FileType.update_without_replacement_template,
                         tests_output_path,
+                        pro=self.pro,
                     )
                 )
                 kwargs["autogenerated_template_path"] = str(
-                    template_path(resource_name, FileType.autogenerated_template, tests_output_path)
+                    template_path(
+                        resource_name,
+                        FileType.autogenerated_template,
+                        tests_output_path,
+                        pro=self.pro,
+                    )
                 )
             # case FileType.cloudcontrol_test:
             case FileType.parity_test:
@@ -531,20 +604,24 @@ class FileWriter:
             ),
             FileType.integration_test: tests_root_dir(self.pro).joinpath(
                 self.resource_name.python_compatible_service_name.lower(),
+                "resource_providers",
                 self.resource_name.path_compatible_full_name(),
                 "test_basic.py",
             ),
             FileType.getatt_test: tests_root_dir(self.pro).joinpath(
                 self.resource_name.python_compatible_service_name.lower(),
+                "resource_providers",
                 self.resource_name.path_compatible_full_name(),
                 "test_exploration.py",
             ),
             # FileType.cloudcontrol_test: tests_root_dir(self.pro).joinpath(
             #     self.resource_name.python_compatible_service_name.lower(),
+            #     "resource_providers",
             #     f"test_aws_{self.resource_name.service.lower()}_{self.resource_name.resource.lower()}_cloudcontrol.py",
             # ),
             FileType.parity_test: tests_root_dir(self.pro).joinpath(
                 self.resource_name.python_compatible_service_name.lower(),
+                "resource_providers",
                 self.resource_name.path_compatible_full_name(),
                 "test_parity.py",
             ),
@@ -558,7 +635,9 @@ class FileWriter:
             FileType.autogenerated_template,
         ]
         for template_type in templates:
-            self.destination_files[template_type] = template_path(self.resource_name, template_type)
+            self.destination_files[template_type] = template_path(
+                self.resource_name, template_type, pro=self.pro
+            )
 
     def write(self, file_type: FileType, contents: str):
         file_destination = self.destination_files[file_type]
@@ -763,21 +842,14 @@ def generate(
     console = Console()
     console.rule(title=resource_type)
 
-    schema_provider = SchemaProvider(
-        zipfile_path=Path(__file__).parent.joinpath("CloudformationSchema.zip")
-    )
+    schema_provider = LiveSchemaProvider(boto3.client("cloudformation"))
 
     template_root = Path(__file__).parent.joinpath("templates")
     env = Environment(
         loader=FileSystemLoader(template_root),
     )
 
-    parts = resource_type.rpartition("::")
-    if parts[-1] == "*":
-        # generate all resource types for that service
-        matching_resources = [x for x in schema_provider.schemas.keys() if x.startswith(parts[0])]
-    else:
-        matching_resources = [resource_type]
+    matching_resources = schema_provider.available_schemas(resource_type)
 
     for matching_resource in matching_resources:
         console.rule(title=matching_resource)

localstack/services/cloudformation/v2/provider.py

@@ -103,6 +103,9 @@ from localstack.services.cloudformation.engine.v2.change_set_model_transform imp
 from localstack.services.cloudformation.engine.v2.change_set_model_validator import (
     ChangeSetModelValidator,
 )
+from localstack.services.cloudformation.engine.v2.change_set_resource_support_checker import (
+    ChangeSetResourceSupportChecker,
+)
 from localstack.services.cloudformation.engine.validations import ValidationError
 from localstack.services.cloudformation.provider import (
     ARN_CHANGESET_REGEX,
@@ -222,6 +225,12 @@ def find_stack_instance(stack_set: StackSet, account: str, region: str) -> Stack
 
 class CloudformationProviderV2(CloudformationProvider, ServiceLifecycleHook):
     def on_before_start(self):
+        # TODO: make sure to bring `_validate_config` from the base class when removing it
+        # as this ensures we have a valid CFN_NO_WAIT_ITERATIONS value
+        super().on_before_start()
+        self._log_create_issue_info()
+
+    def _log_create_issue_info(self):
         base = "https://github.com/localstack/localstack/issues/new"
         query_args = {
             "template": "bug-report.yml",
@@ -417,6 +426,38 @@ class CloudformationProviderV2(CloudformationProvider, ServiceLifecycleHook):
                 update_model.node_template.change_type = ChangeType.MODIFIED
         change_set.processed_template = transformed_after_template
 
+        if not config.CFN_IGNORE_UNSUPPORTED_RESOURCE_TYPES:
+            support_visitor = ChangeSetResourceSupportChecker()
+            support_visitor.visit(change_set.update_model.node_template)
+            failure_messages = support_visitor.failure_messages
+            if failure_messages:
+                reason_suffix = ", ".join(failure_messages)
+                status_reason = f"{ChangeSetResourceSupportChecker.TITLE_MESSAGE} {reason_suffix}"
+
+                change_set.status_reason = status_reason
+                change_set.set_change_set_status(ChangeSetStatus.FAILED)
+                failure_transitions = {
+                    ChangeSetType.CREATE: (
+                        StackStatus.ROLLBACK_IN_PROGRESS,
+                        StackStatus.CREATE_FAILED,
+                    ),
+                    ChangeSetType.UPDATE: (
+                        StackStatus.UPDATE_ROLLBACK_IN_PROGRESS,
+                        StackStatus.UPDATE_ROLLBACK_FAILED,
+                    ),
+                    ChangeSetType.IMPORT: (
+                        StackStatus.IMPORT_ROLLBACK_IN_PROGRESS,
+                        StackStatus.IMPORT_ROLLBACK_FAILED,
+                    ),
+                }
+                transitions = failure_transitions.get(change_set.change_set_type)
+                if transitions:
+                    first_status, *remaining_statuses = transitions
+                    change_set.stack.set_stack_status(first_status, status_reason)
+                    for status in remaining_statuses:
+                        change_set.stack.set_stack_status(status)
+                return
+
     @handler("CreateChangeSet", expand=False)
     def create_change_set(
         self, context: RequestContext, request: CreateChangeSetInput

localstack/services/cloudwatch/models.py

@@ -1,6 +1,12 @@
 import datetime
 
-from localstack.aws.api.cloudwatch import CompositeAlarm, DashboardBody, MetricAlarm, StateValue
+from localstack.aws.api.cloudwatch import (
+    AlarmHistoryItem,
+    CompositeAlarm,
+    DashboardBody,
+    MetricAlarm,
+    StateValue,
+)
 from localstack.services.stores import (
     AccountRegionBundle,
     BaseStore,
@@ -72,6 +78,8 @@ class LocalStackDashboard:
     dashboard_name: str
     dashboard_arn: str
     dashboard_body: DashboardBody
+    last_modified: datetime.datetime
+    size: int
 
     def __init__(
         self, account_id: str, region: str, dashboard_name: str, dashboard_body: DashboardBody
@@ -99,7 +107,7 @@ class CloudWatchStore(BaseStore):
 
     # Contains all the Alarm Histories. Per documentation, an alarm history is retained even if the alarm is deleted,
     # making it necessary to save this at store level
-    histories: list[dict] = LocalAttribute(default=list)
+    histories: list[AlarmHistoryItem] = LocalAttribute(default=list)
 
     dashboards: dict[str, LocalStackDashboard] = LocalAttribute(default=dict)
 

localstack/services/cloudwatch/provider_v2.py

@@ -9,6 +9,7 @@ from localstack.aws.api import CommonServiceException, RequestContext, handler
 from localstack.aws.api.cloudwatch import (
     AccountId,
     ActionPrefix,
+    AlarmHistoryItem,
     AlarmName,
     AlarmNamePrefix,
     AlarmNames,
@@ -276,7 +277,7 @@ class CloudwatchProvider(CloudwatchApi, ServiceLifecycleHook):
             # Paginate
             timestamp_value_dicts = [
                 {
-                    "Timestamp": timestamp,
+                    "Timestamp": datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC),
                     "Value": float(value),
                 }
                 for timestamp, value in zip(timestamps, values, strict=False)
@@ -760,7 +761,7 @@ class CloudwatchProvider(CloudwatchApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         alarm: LocalStackAlarm,
-        state_value: str,
+        state_value: StateValue,
         state_reason: str,
         state_reason_data: dict = None,
     ):
@@ -780,18 +781,17 @@ class CloudwatchProvider(CloudwatchApi, ServiceLifecycleHook):
                 "stateReasonData": state_reason_data,
             },
         }
-        store.histories.append(
-            {
-                "Timestamp": timestamp_millis(alarm.alarm["StateUpdatedTimestamp"]),
-                "HistoryItemType": HistoryItemType.StateUpdate,
-                "AlarmName": alarm.alarm["AlarmName"],
-                "HistoryData": json.dumps(history_data),
-                "HistorySummary": f"Alarm updated from {old_state} to {state_value}",
-                "AlarmType": "MetricAlarm"
-                if isinstance(alarm, LocalStackMetricAlarm)
-                else "CompositeAlarm",
-            }
+        alarm_history_item = AlarmHistoryItem(
+            Timestamp=alarm.alarm["StateUpdatedTimestamp"],
+            HistoryItemType=HistoryItemType.StateUpdate,
+            AlarmName=alarm.alarm["AlarmName"],
+            HistoryData=json.dumps(history_data),
+            HistorySummary=f"Alarm updated from {old_state} to {state_value}",
+            AlarmType="MetricAlarm"
+            if isinstance(alarm, LocalStackMetricAlarm)
+            else "CompositeAlarm",
         )
+        store.histories.append(alarm_history_item)
         alarm.alarm["StateValue"] = state_value
         alarm.alarm["StateReason"] = state_reason
         if state_reason_data:
@@ -837,15 +837,10 @@ class CloudwatchProvider(CloudwatchApi, ServiceLifecycleHook):
         if alarm_name:
             history = [h for h in history if h["AlarmName"] == alarm_name]
 
-        def _get_timestamp(input: dict):
-            if timestamp_string := input.get("Timestamp"):
-                return datetime.datetime.fromisoformat(timestamp_string)
-            return None
-
         if start_date:
-            history = [h for h in history if (date := _get_timestamp(h)) and date >= start_date]
+            history = [h for h in history if (date := h.get("Timestamp")) and date >= start_date]
         if end_date:
-            history = [h for h in history if (date := _get_timestamp(h)) and date <= end_date]
+            history = [h for h in history if (date := h.get("Timestamp")) and date <= end_date]
         return DescribeAlarmHistoryOutput(AlarmHistoryItems=history)
 
     def _evaluate_composite_alarms(self, context: RequestContext, triggering_alarm):

localstack/services/kinesis/packages.py

@@ -7,7 +7,7 @@ from localstack.packages import InstallTarget, Package
 from localstack.packages.core import GitHubReleaseInstaller, NodePackageInstaller
 from localstack.packages.java import JavaInstallerMixin, java_package
 
-_KINESIS_MOCK_VERSION = os.environ.get("KINESIS_MOCK_VERSION") or "0.5.1"
+_KINESIS_MOCK_VERSION = os.environ.get("KINESIS_MOCK_VERSION") or "0.5.2"
 
 
 class KinesisMockEngine(StrEnum):

localstack/services/kms/models.py

@@ -232,7 +232,10 @@ class KmsCryptoKey:
 
         if key_spec.startswith("RSA"):
             key_size = RSA_CRYPTO_KEY_LENGTHS.get(key_spec)
-            key = rsa.generate_private_key(public_exponent=65537, key_size=key_size)
+            if key_material:
+                key = crypto_serialization.load_der_private_key(key_material, password=None)
+            else:
+                key = rsa.generate_private_key(public_exponent=65537, key_size=key_size)
         elif key_spec.startswith("ECC"):
             curve = ECC_CURVES.get(key_spec)
             if key_material:
@@ -636,7 +639,8 @@ class KmsKey:
         # https://docs.aws.amazon.com/kms/latest/APIReference/API_TagResource.html
         # "To edit a tag, specify an existing tag key and a new tag value."
         for i, tag in enumerate(tags, start=1):
-            validate_tag(i, tag)
+            if tag.get("TagKey") != TAG_KEY_CUSTOM_KEY_MATERIAL:
+                validate_tag(i, tag)
             self.tags[tag.get("TagKey")] = tag.get("TagValue")
 
     def schedule_key_deletion(self, pending_window_in_days: int) -> None:

localstack/services/lambda_/analytics.py

@@ -14,9 +14,10 @@ function_counter = LabeledCounter(
         "status",
         "runtime",
         "package_type",
-        # only for operation "invoke"
-        "invocation_type",
+        "invocation_type",  # only for operation "invoke", otherwise "n/a"
+        "initialization_type",
     ],
+    schema_version=2,
 )
 
 
@@ -38,6 +39,14 @@ class FunctionStatus(StrEnum):
     invocation_error = "invocation_error"
 
 
+class FunctionInitializationType(StrEnum):
+    # Maps to the Lambda environment variable AWS_LAMBDA_INITIALIZATION_TYPE
+    on_demand = "on-demand"
+    lambda_managed_instances = "lambda-managed-instances"
+    # Only applies to the operation "invoke" because provisioned concurrency is not configured on "create"
+    provisioned_concurrency = "provisioned-concurrency"
+
+
 esm_counter = LabeledCounter(namespace=NAMESPACE, name="esm", labels=["source", "status"])
 
 

localstack/services/lambda_/invocation/event_manager.py

@@ -13,6 +13,7 @@ from botocore.config import Config
 from localstack import config
 from localstack.aws.api.lambda_ import InvocationType, TooManyRequestsException
 from localstack.services.lambda_.analytics import (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -198,22 +199,22 @@ class Poller:
     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
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if function_config.CapacityProviderConfig
+            else FunctionInitializationType.on_demand
+        )
         try:
             sqs_invocation = SQSInvocation.decode(message["Body"])
             invocation = sqs_invocation.invocation
             try:
                 invocation_result = self.version_manager.invoke(invocation=invocation)
-                function_config = self.version_manager.function_version.config
-                function_counter.labels(
-                    operation=FunctionOperation.invoke,
-                    runtime=function_config.runtime or "n/a",
-                    status=FunctionStatus.success,
-                    invocation_type=InvocationType.Event,
-                    package_type=function_config.package_type,
-                ).increment()
+                status = FunctionStatus.success
             except Exception as e:
                 # Reserved concurrency == 0
                 if self.version_manager.function.reserved_concurrent_executions == 0:
@@ -223,6 +224,7 @@ class Poller:
                 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
@@ -240,14 +242,14 @@ class Poller:
                 sqs_client.delete_message(
                     QueueUrl=self.event_queue_url, ReceiptHandle=message["ReceiptHandle"]
                 )
-                # status MUST be set before returning
-                package_type = self.version_manager.function_version.config.package_type
+                assert status, "status MUST be set before returning"
                 function_counter.labels(
                     operation=FunctionOperation.invoke,
                     runtime=runtime or "n/a",
                     status=status,
                     invocation_type=InvocationType.Event,
-                    package_type=package_type,
+                    package_type=function_config.package_type,
+                    initialization_type=initialization_type,
                 ).increment()
 
             # Good summary blogpost: https://haithai91.medium.com/aws-lambdas-retry-behaviors-edff90e1cf1b
@@ -257,6 +259,8 @@ class Poller:
             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

localstack/services/lambda_/invocation/lambda_models.py

@@ -30,6 +30,7 @@ from localstack.aws.api.lambda_ import (
     CodeSigningPolicies,
     Cors,
     DestinationConfig,
+    FunctionScalingConfig,
     FunctionUrlAuthType,
     InstanceRequirements,
     InvocationType,
@@ -625,6 +626,9 @@ class Function:
     provisioned_concurrency_configs: dict[str, ProvisionedConcurrencyConfiguration] = (
         dataclasses.field(default_factory=dict)
     )
+    function_scaling_configs: dict[str, FunctionScalingConfig] = dataclasses.field(
+        default_factory=dict
+    )
 
     lock: threading.RLock = dataclasses.field(default_factory=threading.RLock)
     next_version: int = 1

localstack/services/lambda_/invocation/lambda_service.py

@@ -29,6 +29,7 @@ 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 (
+    FunctionInitializationType,
     FunctionOperation,
     FunctionStatus,
     function_counter,
@@ -313,6 +314,12 @@ class LambdaService:
             raise ResourceNotFoundException(f"Function not found: {invoked_arn}", Type="User")
         runtime = version.config.runtime or "n/a"
         package_type = version.config.package_type
+        # Not considering provisioned concurrency for such early errors
+        initialization_type = (
+            FunctionInitializationType.lambda_managed_instances
+            if version.config.CapacityProviderConfig
+            else FunctionInitializationType.on_demand
+        )
         if version.config.CapacityProviderConfig and qualifier == "$LATEST":
             if function.versions.get("$LATEST.PUBLISHED"):
                 raise InvalidParameterValueException(
@@ -355,6 +362,7 @@ class LambdaService:
                 status=status,
                 invocation_type=invocation_type,
                 package_type=package_type,
+                initialization_type=initialization_type,
             ).increment()
             raise ResourceConflictException(
                 f"The operation cannot be performed at this time. The function is currently in the following state: {state}"
@@ -373,6 +381,7 @@ class LambdaService:
                     status=FunctionStatus.invalid_payload_error,
                     invocation_type=invocation_type,
                     package_type=package_type,
+                    initialization_type=initialization_type,
                 ).increment()
                 # MAYBE: improve parity of detailed exception message (quite cumbersome)
                 raise InvalidRequestContentException(
@@ -417,12 +426,14 @@ class LambdaService:
             if invocation_result.is_error
             else FunctionStatus.success
         )
+        # TODO: handle initialization_type provisioned-concurrency, requires enriching invocation_result
         function_counter.labels(
             operation=FunctionOperation.invoke,
             runtime=runtime,
             status=status,
             invocation_type=invocation_type,
             package_type=package_type,
+            initialization_type=initialization_type,
         ).increment()
         return invocation_result