feat(data_classes): add KinesisFirehoseEvent

aws_lambda_powertools/utilities/data_classes/__init__.py

@@ -13,6 +13,7 @@
 from .event_bridge_event import EventBridgeEvent
 from .event_source import event_source
 from .kafka_event import KafkaEvent
+from .kinesis_firehose_event import KinesisFirehoseEvent
 from .kinesis_stream_event import KinesisStreamEvent
 from .lambda_function_url_event import LambdaFunctionUrlEvent
 from .s3_event import S3Event
@@ -32,6 +33,7 @@
     "DynamoDBStreamEvent",
     "EventBridgeEvent",
     "KafkaEvent",
+    "KinesisFirehoseEvent",
     "KinesisStreamEvent",
     "LambdaFunctionUrlEvent",
     "S3Event",

aws_lambda_powertools/utilities/data_classes/kinesis_firehose_event.py

@@ -0,0 +1,113 @@
+import base64
+import json
+from typing import Iterator, Optional
+
+from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
+
+
+class KinesisFirehoseRecordMetadata(DictWrapper):
+    @property
+    def _metadata(self) -> dict:
+        """Optional: metadata associated with this record; present only when Kinesis Stream is source"""
+        return self["kinesisRecordMetadata"]  # could raise KeyError
+
+    @property
+    def shard_id(self) -> Optional[str]:
+        """Kinesis stream shard ID; present only when Kinesis Stream is source"""
+        return self._metadata.get("shardId")
+
+    @property
+    def partition_key(self) -> Optional[str]:
+        """Kinesis stream partition key; present only when Kinesis Stream is source"""
+        return self._metadata.get("partitionKey")
+
+    @property
+    def approximate_arrival_timestamp(self) -> Optional[str]:
+        """Kinesis stream approximate arrival ISO timestamp; present only when Kinesis Stream is source"""
+        return self._metadata.get("approximateArrivalTimestamp")
+
+    @property
+    def sequence_number(self) -> Optional[str]:
+        """Kinesis stream sequence number; present only when Kinesis Stream is source"""
+        return self._metadata.get("sequenceNumber")
+
+    @property
+    def subsequence_number(self) -> Optional[str]:
+        """Kinesis stream sub-sequence number; present only when Kinesis Stream is source
+
+        Note: this will only be present for Kinesis streams using record aggregation
+        """
+        return self._metadata.get("subsequenceNumber")
+
+
+class KinesisFirehoseRecord(DictWrapper):
+    @property
+    def approximate_arrival_timestamp(self) -> float:
+        """The approximate time that the record was inserted into the delivery stream"""
+        return float(self["approximateArrivalTimestamp"])
+
+    @property
+    def record_id(self) -> str:
+        """Record ID; uniquely identifies this record within the current batch"""
+        return self["recordId"]
+
+    @property
+    def data(self) -> str:
+        """The data blob, base64-encoded"""
+        return self["data"]
+
+    @property
+    def metadata(self) -> KinesisFirehoseRecordMetadata:
+        """Optional: metadata associated with this record; present only when Kinesis Stream is source"""
+        return KinesisFirehoseRecordMetadata(self._data)
+
+    @property
+    def data_as_bytes(self) -> bytes:
+        """Decoded base64-encoded data as bytes"""
+        return base64.b64decode(self.data)
+
+    @property
+    def data_as_text(self) -> str:
+        """Decoded base64-encoded data as text"""
+        return self.data_as_bytes.decode("utf-8")
+
+    @property
+    def data_as_json(self) -> dict:
+        """Decoded base64-encoded data loaded to json"""
+        if self._json_data is None:
+            self._json_data = json.loads(self.data_as_text)
+        return self._json_data
+
+
+class KinesisFirehoseEvent(DictWrapper):
+    """Kinesis Data Firehose event
+
+    Documentation:
+    --------------
+    - https://docs.aws.amazon.com/lambda/latest/dg/services-kinesisfirehose.html
+    """
+
+    @property
+    def invocation_id(self) -> str:
+        """Unique ID for for Lambda invocation"""
+        return self["invocationId"]
+
+    @property
+    def delivery_stream_arn(self) -> str:
+        """ARN of the Firehose Data Firehose Delivery Stream"""
+        return self["deliveryStreamArn"]
+
+    @property
+    def source_kinesis_stream_arn(self) -> Optional[str]:
+        """ARN of the Kinesis Stream; present only when Kinesis Stream is source"""
+        return self.get("sourceKinesisStreamArn")
+
+    @property
+    def region(self) -> str:
+        """AWS region where the event originated eg: us-east-1"""
+        return self["region"]
+
+    @property
+    def records(self) -> Iterator[KinesisFirehoseRecord]:
+        for record in self["records"]:
+            yield KinesisFirehoseRecord(record)

docs/utilities/data_classes.md

@@ -76,6 +76,7 @@ Event Source | Data_class
 [DynamoDB streams](#dynamodb-streams) | `DynamoDBStreamEvent`, `DynamoDBRecordEventName`
 [EventBridge](#eventbridge) | `EventBridgeEvent`
 [Kafka](#kafka) | `KafkaEvent`
+[Kinesis Firehose Delivery Stream](#kinesis-firehose-delivery-stream) | `KinesisFirehoseEvent`
 [Kinesis Data Stream](#kinesis-streams) | `KinesisStreamEvent`
 [Lambda Function URL](#lambda-function-url) | `LambdaFunctionUrlEvent`
 [Rabbit MQ](#rabbit-mq) | `RabbitMQEvent`
@@ -892,6 +893,20 @@ or plain text, depending on the original payload.
         do_something_with(data)
     ```
 
+### Kinesis Firehose delivery stream
+
+Kinesis Firehose Data Transformation can use a Lambda Function to modify the records
+inline, and re-emit them back to the Delivery Stream.
+
+Similar to Kinesis Data Streams, the events contain base64 encoded data. You can use the helper
+function to access the data either as json or plain text, depending on the original payload.
+
+=== "app.py"
+
+    ```python
+    --8<-- "examples/event_sources/src/kinesis_firehose_delivery_stream.py"
+    ```
+
 ### Lambda Function URL
 
 === "app.py"

examples/event_sources/src/kinesis_firehose_delivery_stream.py

@@ -0,0 +1,25 @@
+import base64
+import json
+
+from aws_lambda_powertools.utilities.data_classes import KinesisFirehoseEvent, event_source
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+@event_source(data_class=KinesisFirehoseEvent)
+def lambda_handler(event: KinesisFirehoseEvent, context: LambdaContext):
+    result = []
+
+    for record in event.records:
+        # if data was delivered as json; caches loaded value
+        data = record.data_as_json
+
+        processed_record = {
+            "recordId": record.record_id,
+            "data": base64.b64encode(json.dumps(data).encode("utf-8")),
+            "result": "Ok",
+        }
+
+        result.append(processed_record)
+
+    # return transformed records
+    return {"records": result}

tests/events/kinesisFirehoseEvent.json

@@ -0,0 +1,31 @@
+{
+  "invocationId": "2b4d1ad9-2f48-94bd-a088-767c317e994a",
+  "deliveryStreamArn": "arn:aws:firehose:us-east-2:123456789012:deliverystream/delivery-stream-name",
+  "region": "us-east-2",
+  "records": [
+    {
+      "data": "SGVsbG8gV29ybGQ=",
+      "recordId": "record1",
+      "approximateArrivalTimestamp": 1510772160000,
+      "kinesisRecordMetadata": {
+        "shardId": "shardId-000000000000",
+        "partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c317a",
+        "approximateArrivalTimestamp": "2012-04-23T18:25:43.511Z",
+        "sequenceNumber": "49546986683135544286507457936321625675700192471156785154",
+        "subsequenceNumber": ""
+      }
+    },
+    {
+      "data": "eyJIZWxsbyI6ICJXb3JsZCJ9",
+      "recordId": "record2",
+      "approximateArrivalTimestamp": 151077216000,
+      "kinesisRecordMetadata": {
+        "shardId": "shardId-000000000001",
+        "partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c318a",
+        "approximateArrivalTimestamp": "2012-04-23T19:25:43.511Z",
+        "sequenceNumber": "49546986683135544286507457936321625675700192471156785155",
+        "subsequenceNumber": ""
+      }
+    }
+  ]
+}

tests/functional/test_data_classes.py

@@ -18,6 +18,7 @@
     CodePipelineJobEvent,
     EventBridgeEvent,
     KafkaEvent,
+    KinesisFirehoseEvent,
     KinesisStreamEvent,
     S3Event,
     SESEvent,
@@ -1201,6 +1202,30 @@ def test_kafka_self_managed_event():
     assert record.get_header_value("HeaderKey", case_sensitive=False) == b"headerValue"
 
 
+def test_kinesis_firehose_event():
+    event = KinesisFirehoseEvent(load_event("kinesisFirehoseEvent.json"))
+
+    assert event.region == "us-east-2"
+    assert event.invocation_id == "2b4d1ad9-2f48-94bd-a088-767c317e994a"
+    assert event.delivery_stream_arn == "arn:aws:firehose:us-east-2:123456789012:deliverystream/delivery-stream-name"
+    assert event.source_kinesis_stream_arn is None
+
+    records = list(event.records)
+    assert len(records) == 2
+    record_01, record_02 = records[:]
+
+    assert record_01.approximate_arrival_timestamp == 1510772160000
+    assert record_01.record_id == "record1"
+    assert record_01.data == "SGVsbG8gV29ybGQ="
+    assert record_01.data_as_bytes == b"Hello World"
+    assert record_01.data_as_text == "Hello World"
+
+    assert record_02.data == "eyJIZWxsbyI6ICJXb3JsZCJ9"
+    assert record_02.data_as_bytes == b'{"Hello": "World"}'
+    assert record_02.data_as_text == '{"Hello": "World"}'
+    assert record_02.data_as_json == {"Hello": "World"}
+
+
 def test_kinesis_stream_event():
     event = KinesisStreamEvent(load_event("kinesisStreamEvent.json"))