rename KenisisDataStream to KenisisEvent

Author: amirkaws

docs/snippets/batch/templates/kinesis.yaml

@@ -22,7 +22,7 @@ Resources:
     Type: AWS::Serverless::Function
     Properties:
       CodeUri: ./src/HelloWorld/
-      Handler: HelloWorld::HelloWorld.Function::KinesisDataStreamHandlerUsingAttribute
+      Handler: HelloWorld::HelloWorld.Function::KinesisEventHandlerUsingAttribute
       Policies:
         # Lambda Destinations require additional permissions
         # to send failure records to DLQ from Kinesis/DynamoDB

docs/utilities/batch-processing.md

@@ -237,12 +237,12 @@ Processing batches from Kinesis using Lambda handler decorator works in three st
 1. Decorate your handler with **`BatchProcessor`** attribute
 2. Create a class that implements **`IKinesisEventRecordHandler`** interface and the HandleAsync method.
 3. Pass the type of that class to  **`RecordHandler`** property of the **`BatchProcessor`** attribute
-4. Return **`BatchItemFailuresResponse`** from Lambda handler using **`KinesisDataStreamBatchProcessor.Result.BatchItemFailuresResponse`**
+4. Return **`BatchItemFailuresResponse`** from Lambda handler using **`KinesisEventBatchProcessor.Result.BatchItemFailuresResponse`**
 
 === "Function.cs"
 
     ```csharp hl_lines="1 7 12 17 20"
-	internal class CustomKinesisDataStreamRecordHandler : IKinesisEventRecordHandler // (1)!
+	internal class CustomKinesisEventRecordHandler : IKinesisEventRecordHandler // (1)!
 	{
 		public async Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventRecord record, CancellationToken cancellationToken)
 		{
@@ -258,10 +258,10 @@ Processing batches from Kinesis using Lambda handler decorator works in three st
 	}
 
 
-	[BatchProcessor(RecordHandler = typeof(CustomKinesisDataStreamRecordHandler))]
+	[BatchProcessor(RecordHandler = typeof(CustomKinesisEventRecordHandler))]
 	public BatchItemFailuresResponse HandlerUsingAttribute(KinesisEvent _)
 	{
-		return KinesisDataStreamBatchProcessor.Result.BatchItemFailuresResponse; // (4)!
+		return KinesisEventBatchProcessor.Result.BatchItemFailuresResponse; // (4)!
 	}
 
     ```
@@ -729,7 +729,7 @@ sequenceDiagram
 
 You can use Batch processing without using the decorator.
 
-Calling the **`ProcessAsync`** method on the Instance of the static BatchProcessor (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisDataStreamBatchProcessor`)
+Calling the **`ProcessAsync`** method on the Instance of the static BatchProcessor (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisEventBatchProcessor`)
 
 === "Function.cs"
 
@@ -750,7 +750,7 @@ Calling the **`ProcessAsync`** method on the Instance of the static BatchProcess
 
     ```
 
-To make the handler testable you can use Dependency Injection to resolve the BatchProcessor (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisDataStreamBatchProcessor`) instance and then call the **`ProcessAsync`** method.
+To make the handler testable you can use Dependency Injection to resolve the BatchProcessor (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisEventBatchProcessor`) instance and then call the **`ProcessAsync`** method.
 
 === "GetRequiredService inside the method"
 
@@ -840,7 +840,7 @@ You can also set `POWERTOOLS_BATCH_MAX_DEGREE_OF_PARALLELISM` Environment Variab
 
 You might want to bring custom logic to the existing `BatchProcessor` to slightly override how we handle successes and failures.
 
-For these scenarios, you can create a class that inherits from `BatchProcessor` (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisDataStreamBatchProcessor`) and quickly override `ProcessAsync` and `HandleRecordFailureAsync` methods:
+For these scenarios, you can create a class that inherits from `BatchProcessor` (`SqsBatchProcessor`, `DynamoDbStreamBatchProcessor`, `KinesisEventBatchProcessor`) and quickly override `ProcessAsync` and `HandleRecordFailureAsync` methods:
 
 * **`ProcessAsync()`** – Keeps track of successful batch records
 * **`HandleRecordFailureAsync()`** – Keeps track of failed batch records

examples/BatchProcessing/src/HelloWorld/Function.cs

@@ -49,11 +49,11 @@ public BatchItemFailuresResponse DynamoDbStreamHandlerUsingAttribute(DynamoDBEve
         return DynamoDbStreamBatchProcessor.Result.BatchItemFailuresResponse;
     }
 
-    [BatchProcessor(RecordHandler = typeof(CustomKinesisDataStreamRecordHandler))]
+    [BatchProcessor(RecordHandler = typeof(CustomKinesisEventRecordHandler))]
     [Logging(LogEvent = true)]
-    public BatchItemFailuresResponse KinesisDataStreamHandlerUsingAttribute(KinesisEvent _)
+    public BatchItemFailuresResponse KinesisEventHandlerUsingAttribute(KinesisEvent _)
     {
-        return KinesisDataStreamBatchProcessor.Result.BatchItemFailuresResponse;
+        return KinesisEventBatchProcessor.Result.BatchItemFailuresResponse;
     }
 
     [BatchProcessor(RecordHandler = typeof(CustomSqsRecordHandler))]

…/CustomKinesisDataStreamRecordHandler.cs …nesis/CustomKinesisEventRecordHandler.csexamples/BatchProcessing/src/HelloWorld/Kinesis/CustomKinesisDataStreamRecordHandler.cs renamed to examples/BatchProcessing/src/HelloWorld/Kinesis/CustomKinesisEventRecordHandler.cs examples/BatchProcessing/src/HelloWorld/Kinesis/CustomKinesisDataStreamRecordHandler.cs renamed to examples/BatchProcessing/src/HelloWorld/Kinesis/CustomKinesisEventRecordHandler.cs

@@ -24,7 +24,7 @@
 using HelloWorld.Data;
 
 namespace HelloWorld.Kinesis;
-internal class CustomKinesisDataStreamRecordHandler : IKinesisEventRecordHandler
+internal class CustomKinesisEventRecordHandler : IKinesisEventRecordHandler
 {
     public async Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventRecord record, CancellationToken cancellationToken)
     {

examples/BatchProcessing/template.yaml

@@ -127,13 +127,13 @@ Resources:
 
   # --------------
   # Batch Processing for Kinesis Data Streams
-  SampleKinesisDataStreamBatchProcessorFunction:
+  SampleKinesisEventBatchProcessorFunction:
     Type: AWS::Serverless::Function
     Properties:
       FunctionName: powertools-dotnet-sample-batch-processor-kinesis-data-stream
       Runtime: dotnet6
       CodeUri: ./src/HelloWorld/
-      Handler: HelloWorld::HelloWorld.Function::KinesisDataStreamHandlerUsingAttribute
+      Handler: HelloWorld::HelloWorld.Function::KinesisEventHandlerUsingAttribute
       MemorySize: 256
       # ReservedConcurrentExecutions: 1
       Policies:

examples/BatchProcessing/test/HelloWorld.Test/FunctionTest.cs

@@ -213,7 +213,7 @@ public Task TestKinesis()
 
             // Act
             var function = new Function();
-            var response = function.KinesisDataStreamHandlerUsingAttribute(request);
+            var response = function.KinesisEventHandlerUsingAttribute(request);
 
             foreach (var failure in response.BatchItemFailures)
             {

libraries/src/AWS.Lambda.Powertools.BatchProcessing/BatchProcessorAttribute.cs

@@ -251,7 +251,7 @@ private IBatchProcessingAspectHandler CreateAspectHandler(IReadOnlyList<object>
         return eventType switch
         {
             BatchEventType.DynamoDbStream => CreateBatchProcessingAspectHandler(() => DynamoDbStreamBatchProcessor.Instance),
-            BatchEventType.KinesisDataStream => CreateBatchProcessingAspectHandler(() => KinesisDataStreamBatchProcessor.Instance),
+            BatchEventType.KinesisDataStream => CreateBatchProcessingAspectHandler(() => KinesisEventBatchProcessor.Instance),
             BatchEventType.Sqs => CreateBatchProcessingAspectHandler(() => SqsBatchProcessor.Instance),
             _ => throw new ArgumentOutOfRangeException(nameof(eventType), eventType, "Unsupported event type.")
         };

…nesis/KinesisDataStreamBatchProcessor.cs …ng/Kinesis/KinesisEventBatchProcessor.cslibraries/src/AWS.Lambda.Powertools.BatchProcessing/Kinesis/KinesisDataStreamBatchProcessor.cs renamed to libraries/src/AWS.Lambda.Powertools.BatchProcessing/Kinesis/KinesisEventBatchProcessor.cs libraries/src/AWS.Lambda.Powertools.BatchProcessing/Kinesis/KinesisDataStreamBatchProcessor.cs renamed to libraries/src/AWS.Lambda.Powertools.BatchProcessing/Kinesis/KinesisEventBatchProcessor.cs

@@ -22,24 +22,24 @@ namespace AWS.Lambda.Powertools.BatchProcessing.Kinesis;
 /// <summary>
 /// The default batch processor for Kinesis Data Stream events.
 /// </summary>
-public class KinesisDataStreamBatchProcessor : BatchProcessor<KinesisEvent, KinesisEvent.KinesisEventRecord>
+public class KinesisEventBatchProcessor : BatchProcessor<KinesisEvent, KinesisEvent.KinesisEventRecord>
 {
     /// <summary>
     /// The singleton instance of the batch processor.
     /// </summary>
-    private static KinesisDataStreamBatchProcessor _instance;
+    private static KinesisEventBatchProcessor _instance;
 
     /// <summary>
     /// The singleton instance of the batch processor.
     /// </summary>
-    public static KinesisDataStreamBatchProcessor Instance =>
-        _instance ??= new KinesisDataStreamBatchProcessor(PowertoolsConfigurations.Instance);
+    public static KinesisEventBatchProcessor Instance =>
+        _instance ??= new KinesisEventBatchProcessor(PowertoolsConfigurations.Instance);
 
     /// <summary>
     /// This is the default constructor
     /// </summary>
     /// <param name="powertoolsConfigurations"></param>
-    public KinesisDataStreamBatchProcessor(IPowertoolsConfigurations powertoolsConfigurations) : base(powertoolsConfigurations)
+    public KinesisEventBatchProcessor(IPowertoolsConfigurations powertoolsConfigurations) : base(powertoolsConfigurations)
     {
         _instance = this;
     }
@@ -48,7 +48,7 @@ public KinesisDataStreamBatchProcessor(IPowertoolsConfigurations powertoolsConfi
     /// Need default constructor for when consumers create a custom batch processor
     /// </summary>
     // ReSharper disable once MemberCanBePrivate.Global
-    protected KinesisDataStreamBatchProcessor() : this(PowertoolsConfigurations.Instance)
+    protected KinesisEventBatchProcessor() : this(PowertoolsConfigurations.Instance)
     {
     }
 

libraries/tests/AWS.Lambda.Powertools.BatchProcessing.Tests/Handlers/Kinesis/Custom/CustomKinesisBatchProcessors.cs

@@ -25,7 +25,7 @@
 
 namespace AWS.Lambda.Powertools.BatchProcessing.Tests.Handlers.Kinesis.Custom;
 
-internal class CustomKinesisDataStreamBatchProcessor : KinesisDataStreamBatchProcessor
+internal class CustomKinesisEventBatchProcessor : KinesisEventBatchProcessor
 {
     public override async Task<ProcessingResult<KinesisEvent.KinesisEventRecord>> ProcessAsync(KinesisEvent @event,
         IRecordHandler<KinesisEvent.KinesisEventRecord> recordHandler, ProcessingOptions processingOptions)
@@ -125,14 +125,14 @@ protected override async Task HandleRecordFailureAsync(KinesisEvent.KinesisEvent
     }
 }
 
-internal class CustomKinesisDataStreamBatchProcessorProvider : IBatchProcessorProvider<KinesisEvent, KinesisEvent.KinesisEventRecord>
+internal class CustomKinesisEventBatchProcessorProvider : IBatchProcessorProvider<KinesisEvent, KinesisEvent.KinesisEventRecord>
 {
     public IBatchProcessor<KinesisEvent, KinesisEvent.KinesisEventRecord> Create()
     {
-        return Services.Provider.GetRequiredService<CustomKinesisDataStreamBatchProcessor>();
+        return Services.Provider.GetRequiredService<CustomKinesisEventBatchProcessor>();
     }
 }
 
-public class BadCustomKinesisDataStreamRecordProcessor
+public class BadCustomKinesisEventRecordProcessor
 {
 }

libraries/tests/AWS.Lambda.Powertools.BatchProcessing.Tests/Handlers/Kinesis/Custom/CustomKinesisHandlers.cs

@@ -22,7 +22,7 @@
 
 namespace AWS.Lambda.Powertools.BatchProcessing.Tests.Handlers.Kinesis.Custom;
 
-internal class CustomKinesisDataStreamRecordHandler : IKinesisEventRecordHandler
+internal class CustomKinesisEventRecordHandler : IKinesisEventRecordHandler
 {
     public async Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventRecord record,
         CancellationToken cancellationToken)
@@ -38,7 +38,7 @@ public async Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventReco
     }
 }
 
-internal class CustomFailKinesisDataStreamRecordHandler : IKinesisEventRecordHandler
+internal class CustomFailKinesisEventRecordHandler : IKinesisEventRecordHandler
 {
     public Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventRecord record,
         CancellationToken cancellationToken)
@@ -47,6 +47,6 @@ public Task<RecordHandlerResult> HandleAsync(KinesisEvent.KinesisEventRecord rec
     }
 }
 
-public class BadCustomKinesisRecordHandler
+public class BadCustomKinesisEventRecordHandler
 {
 }