blib/lib/Paws/Kinesis.pm

filter: Statementstmt 10.9% 19 / 173 Branchbran 2.9% 1 / 34 Conditioncond 33.3% 1 / 3 MC/DCmcdc 0.0% 0 / 2 Subroutinesub 23.8% 10 / 42 Podpod 84.2% 32 / 38 totaltotal 21.5% 63 / 292 CC 27 SCAR 31.9
CC
27
Cov
10%
DescribeAllStream
56.0
ListAllShards
56.0
ListAllStreamConsumers
56.0
CRAP 24.2
« blib/lib/Paws/SDB.pm ↑ Summary blib/lib/Paws/ElasticBeanstalk.pm »
1 package Paws::Kinesis;
2 1 ▶ use Moose;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 4 ▶ sub service { 'kinesis' }
Subroutine service: called CC=1 SCAR=0.0
Pod undocumented
4 4 ▶ sub signing_name { 'kinesis' }
Subroutine signing_name: called CC=1 SCAR=0.0
Pod undocumented
5 4 ▶ sub version { '2013-12-02' }
Subroutine version: called CC=1 SCAR=0.0
Pod undocumented
6 4 ▶ sub target_prefix { 'Kinesis_20131202' }
Subroutine target_prefix: called CC=1 SCAR=0.0
Pod undocumented
7 4 ▶ sub json_version { "1.1" }
Subroutine json_version: called CC=1 SCAR=0.0
Pod undocumented
8 1 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 4 ▶ has retry => (is => 'ro', isa => 'HashRef', default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
10 4 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 1 });
12 4 ▶ has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
Subroutine __ANON__: called CC=1 SCAR=0.5
13 8 ▶ sub { defined $_[0]->http_status and $_[0]->http_status == 400 and $_[0]->code eq 'LimitExceededException' },
Subroutine __ANON__: called CC=3 SCAR=14.2
Branch: 1 branch
BranchTrueFalseTotal
defined $_[0]->http_status and $_[0]->http_status == 400 and $_[0]->code eq "LimitExceededException" 8 0 8
Condition33%1/3
defined $_[0]->http_status and $_[0]->http_status == 400
!ll&&!rl&&r
008
MC/DC0%0/2
defined $_[0]->http_status and $_[0]->http_status == 400
defined $_[0]->http_status $_[0]->http_status == 400
Truth table33%1/3
A and B
A= defined $_[0]->http_statusB= $_[0]->http_status == 400
ABresult
0X0
100
111
14 4 ] });
15  
16 1 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
17  
18
19 0 ▶ sub AddTagsToStream {
Subroutine AddTagsToStream: not called CC=1 SCAR=6.9
Pod documented
20 0 my $self = shift;
21 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::AddTagsToStream', @_);
22 0 return $self->caller->do_call($self, $call_object);
23 }
24 0 ▶ sub CreateStream {
Subroutine CreateStream: not called CC=1 SCAR=6.9
Pod documented
25 0 my $self = shift;
26 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::CreateStream', @_);
27 0 return $self->caller->do_call($self, $call_object);
28 }
29 0 ▶ sub DecreaseStreamRetentionPeriod {
Subroutine DecreaseStreamRetentionPeriod: not called CC=1 SCAR=6.9
Pod documented
30 0 my $self = shift;
31 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DecreaseStreamRetentionPeriod', @_);
32 0 return $self->caller->do_call($self, $call_object);
33 }
34 0 ▶ sub DeleteStream {
Subroutine DeleteStream: not called CC=1 SCAR=6.9
Pod documented
35 0 my $self = shift;
36 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DeleteStream', @_);
37 0 return $self->caller->do_call($self, $call_object);
38 }
39 0 ▶ sub DeregisterStreamConsumer {
Subroutine DeregisterStreamConsumer: not called CC=1 SCAR=6.9
Pod documented
40 0 my $self = shift;
41 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DeregisterStreamConsumer', @_);
42 0 return $self->caller->do_call($self, $call_object);
43 }
44 0 ▶ sub DescribeLimits {
Subroutine DescribeLimits: not called CC=1 SCAR=6.9
Pod documented
45 0 my $self = shift;
46 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DescribeLimits', @_);
47 0 return $self->caller->do_call($self, $call_object);
48 }
49 0 ▶ sub DescribeStream {
Subroutine DescribeStream: not called CC=1 SCAR=6.9
Pod documented
50 0 my $self = shift;
51 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DescribeStream', @_);
52 0 return $self->caller->do_call($self, $call_object);
53 }
54 0 ▶ sub DescribeStreamConsumer {
Subroutine DescribeStreamConsumer: not called CC=1 SCAR=6.9
Pod documented
55 0 my $self = shift;
56 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DescribeStreamConsumer', @_);
57 0 return $self->caller->do_call($self, $call_object);
58 }
59 0 ▶ sub DescribeStreamSummary {
Subroutine DescribeStreamSummary: not called CC=1 SCAR=6.9
Pod documented
60 0 my $self = shift;
61 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DescribeStreamSummary', @_);
62 0 return $self->caller->do_call($self, $call_object);
63 }
64 0 ▶ sub DisableEnhancedMonitoring {
Subroutine DisableEnhancedMonitoring: not called CC=1 SCAR=6.9
Pod documented
65 0 my $self = shift;
66 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::DisableEnhancedMonitoring', @_);
67 0 return $self->caller->do_call($self, $call_object);
68 }
69 0 ▶ sub EnableEnhancedMonitoring {
Subroutine EnableEnhancedMonitoring: not called CC=1 SCAR=6.9
Pod documented
70 0 my $self = shift;
71 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::EnableEnhancedMonitoring', @_);
72 0 return $self->caller->do_call($self, $call_object);
73 }
74 0 ▶ sub GetRecords {
Subroutine GetRecords: not called CC=1 SCAR=6.9
Pod documented
75 0 my $self = shift;
76 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::GetRecords', @_);
77 0 return $self->caller->do_call($self, $call_object);
78 }
79 0 ▶ sub GetShardIterator {
Subroutine GetShardIterator: not called CC=1 SCAR=6.9
Pod documented
80 0 my $self = shift;
81 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::GetShardIterator', @_);
82 0 return $self->caller->do_call($self, $call_object);
83 }
84 0 ▶ sub IncreaseStreamRetentionPeriod {
Subroutine IncreaseStreamRetentionPeriod: not called CC=1 SCAR=6.9
Pod documented
85 0 my $self = shift;
86 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::IncreaseStreamRetentionPeriod', @_);
87 0 return $self->caller->do_call($self, $call_object);
88 }
89 0 ▶ sub ListShards {
Subroutine ListShards: not called CC=1 SCAR=6.9
Pod documented
90 0 my $self = shift;
91 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::ListShards', @_);
92 0 return $self->caller->do_call($self, $call_object);
93 }
94 0 ▶ sub ListStreamConsumers {
Subroutine ListStreamConsumers: not called CC=1 SCAR=6.9
Pod documented
95 0 my $self = shift;
96 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::ListStreamConsumers', @_);
97 0 return $self->caller->do_call($self, $call_object);
98 }
99 4 ▶ sub ListStreams {
Subroutine ListStreams: called CC=1 SCAR=0.0
Pod documented
100 4 my $self = shift;
101 4 my $call_object = $self->new_with_coercions('Paws::Kinesis::ListStreams', @_);
102 4 return $self->caller->do_call($self, $call_object);
103 }
104 0 ▶ sub ListTagsForStream {
Subroutine ListTagsForStream: not called CC=1 SCAR=6.9
Pod documented
105 0 my $self = shift;
106 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::ListTagsForStream', @_);
107 0 return $self->caller->do_call($self, $call_object);
108 }
109 0 ▶ sub MergeShards {
Subroutine MergeShards: not called CC=1 SCAR=6.9
Pod documented
110 0 my $self = shift;
111 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::MergeShards', @_);
112 0 return $self->caller->do_call($self, $call_object);
113 }
114 0 ▶ sub PutRecord {
Subroutine PutRecord: not called CC=1 SCAR=6.9
Pod documented
115 0 my $self = shift;
116 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::PutRecord', @_);
117 0 return $self->caller->do_call($self, $call_object);
118 }
119 0 ▶ sub PutRecords {
Subroutine PutRecords: not called CC=1 SCAR=6.9
Pod documented
120 0 my $self = shift;
121 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::PutRecords', @_);
122 0 return $self->caller->do_call($self, $call_object);
123 }
124 0 ▶ sub RegisterStreamConsumer {
Subroutine RegisterStreamConsumer: not called CC=1 SCAR=6.9
Pod documented
125 0 my $self = shift;
126 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::RegisterStreamConsumer', @_);
127 0 return $self->caller->do_call($self, $call_object);
128 }
129 0 ▶ sub RemoveTagsFromStream {
Subroutine RemoveTagsFromStream: not called CC=1 SCAR=6.9
Pod documented
130 0 my $self = shift;
131 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::RemoveTagsFromStream', @_);
132 0 return $self->caller->do_call($self, $call_object);
133 }
134 0 ▶ sub SplitShard {
Subroutine SplitShard: not called CC=1 SCAR=6.9
Pod documented
135 0 my $self = shift;
136 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::SplitShard', @_);
137 0 return $self->caller->do_call($self, $call_object);
138 }
139 0 ▶ sub StartStreamEncryption {
Subroutine StartStreamEncryption: not called CC=1 SCAR=6.9
Pod documented
140 0 my $self = shift;
141 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::StartStreamEncryption', @_);
142 0 return $self->caller->do_call($self, $call_object);
143 }
144 0 ▶ sub StopStreamEncryption {
Subroutine StopStreamEncryption: not called CC=1 SCAR=6.9
Pod documented
145 0 my $self = shift;
146 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::StopStreamEncryption', @_);
147 0 return $self->caller->do_call($self, $call_object);
148 }
149 0 ▶ sub SubscribeToShard {
Subroutine SubscribeToShard: not called CC=1 SCAR=6.9
Pod documented
150 0 my $self = shift;
151 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::SubscribeToShard', @_);
152 0 return $self->caller->do_call($self, $call_object);
153 }
154 0 ▶ sub UpdateShardCount {
Subroutine UpdateShardCount: not called CC=1 SCAR=6.9
Pod documented
155 0 my $self = shift;
156 0 my $call_object = $self->new_with_coercions('Paws::Kinesis::UpdateShardCount', @_);
157 0 return $self->caller->do_call($self, $call_object);
158 }
159
160 0 ▶ sub DescribeAllStream {
Subroutine DescribeAllStream: not called CC=7 SCAR=40.3
Pod documented
161 0 my $self = shift;
162  
163 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
164 0 my $result = $self->DescribeStream(@_);
165 0 my $next_result = $result;
166  
167 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
168 0 ▶ while ($next_result->StreamDescription->HasMoreShards) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->StreamDescription->HasMoreShards) 0 0 0
169 0 $next_result = $self->DescribeStream(@_, ExclusiveStartShardId => $next_result->StreamDescription->Shards->[-1]->ShardId);
170 0 push @{ $result->StreamDescription->Shards }, @{ $next_result->StreamDescription->Shards };
171 }
172 0 return $result;
173 } else {
174 0 ▶ while ($result->StreamDescription->HasMoreShards) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->StreamDescription->HasMoreShards) 0 0 0
175 0 $callback->($_ => 'StreamDescription.Shards') foreach (@{ $result->StreamDescription->Shards });
176 0 $result = $self->DescribeStream(@_, ExclusiveStartShardId => $result->StreamDescription->Shards->[-1]->ShardId);
177 }
178 0 $callback->($_ => 'StreamDescription.Shards') foreach (@{ $result->StreamDescription->Shards });
179 }
180  
181 return undef
182 0 }
183 0 ▶ sub ListAllShards {
Subroutine ListAllShards: not called CC=7 SCAR=40.3
Pod documented
184 0 my $self = shift;
185  
186 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
187 0 my $result = $self->ListShards(@_);
188 0 my $next_result = $result;
189  
190 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
191 0 ▶ while ($next_result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextToken) 0 0 0
192 0 $next_result = $self->ListShards(@_, NextToken => $next_result->NextToken);
193 0 push @{ $result->Shards }, @{ $next_result->Shards };
194 }
195 0 return $result;
196 } else {
197 0 ▶ while ($result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextToken) 0 0 0
198 0 $callback->($_ => 'Shards') foreach (@{ $result->Shards });
199 0 $result = $self->ListShards(@_, NextToken => $result->NextToken);
200 }
201 0 $callback->($_ => 'Shards') foreach (@{ $result->Shards });
202 }
203  
204 return undef
205 0 }
206 0 ▶ sub ListAllStreamConsumers {
Subroutine ListAllStreamConsumers: not called CC=7 SCAR=40.3
Pod documented
207 0 my $self = shift;
208  
209 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
210 0 my $result = $self->ListStreamConsumers(@_);
211 0 my $next_result = $result;
212  
213 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
214 0 ▶ while ($next_result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextToken) 0 0 0
215 0 $next_result = $self->ListStreamConsumers(@_, NextToken => $next_result->NextToken);
216 0 push @{ $result->Consumers }, @{ $next_result->Consumers };
217 }
218 0 return $result;
219 } else {
220 0 ▶ while ($result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextToken) 0 0 0
221 0 $callback->($_ => 'Consumers') foreach (@{ $result->Consumers });
222 0 $result = $self->ListStreamConsumers(@_, NextToken => $result->NextToken);
223 }
224 0 $callback->($_ => 'Consumers') foreach (@{ $result->Consumers });
225 }
226  
227 return undef
228 0 }
229 0 ▶ sub ListAllStreams {
Subroutine ListAllStreams: not called CC=7 SCAR=40.3
Pod documented
230 0 my $self = shift;
231  
232 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
233 0 my $result = $self->ListStreams(@_);
234 0 my $next_result = $result;
235  
236 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
237 0 ▶ while ($next_result->HasMoreStreams) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->HasMoreStreams) 0 0 0
238 0 $next_result = $self->ListStreams(@_, ExclusiveStartStreamName => $next_result->StreamNames->[-1]);
239 0 push @{ $result->StreamNames }, @{ $next_result->StreamNames };
240 }
241 0 return $result;
242 } else {
243 0 ▶ while ($result->HasMoreStreams) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->HasMoreStreams) 0 0 0
244 0 $callback->($_ => 'StreamNames') foreach (@{ $result->StreamNames });
245 0 $result = $self->ListStreams(@_, ExclusiveStartStreamName => $result->StreamNames->[-1]);
246 }
247 0 $callback->($_ => 'StreamNames') foreach (@{ $result->StreamNames });
248 }
249  
250 return undef
251 0 }
252  
253  
254 0 ▶ sub operations { qw/AddTagsToStream CreateStream DecreaseStreamRetentionPeriod DeleteStream DeregisterStreamConsumer DescribeLimits DescribeStream DescribeStreamConsumer DescribeStreamSummary DisableEnhancedMonitoring EnableEnhancedMonitoring GetRecords GetShardIterator IncreaseStreamRetentionPeriod ListShards ListStreamConsumers ListStreams ListTagsForStream MergeShards PutRecord PutRecords RegisterStreamConsumer RemoveTagsFromStream SplitShard StartStreamEncryption StopStreamEncryption SubscribeToShard UpdateShardCount / }
Subroutine operations: not called CC=1 SCAR=6.9
Pod undocumented
255  
256 1 1;
257  
258 ### main pod documentation begin ###
259  
260 =head1 NAME
261  
262 Paws::Kinesis - Perl Interface to AWS Amazon Kinesis
263  
264 =head1 SYNOPSIS
265  
266 use Paws;
267  
268 my $obj = Paws->service('Kinesis');
269 my $res = $obj->Method(
270 Arg1 => $val1,
271 Arg2 => [ 'V1', 'V2' ],
272 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
273 # of the arguments type
274 Arg3 => { Att1 => 'Val1' },
275 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
276 # the constructor of the arguments type
277 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
278 );
279  
280 =head1 DESCRIPTION
281  
282 Amazon Kinesis Data Streams Service API Reference
283  
284 Amazon Kinesis Data Streams is a managed service that scales
285 elastically for real-time processing of streaming big data.
286  
287 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/kinesis-2013-12-02>
288  
289  
290 =head1 METHODS
291  
292 =head2 AddTagsToStream
293  
294 =over
295  
296 =item StreamName => Str
297  
298 =item Tags => L<Paws::Kinesis::TagMap>
299  
300  
301 =back
302  
303 Each argument is described in detail in: L<Paws::Kinesis::AddTagsToStream>
304  
305 Returns: nothing
306  
307 Adds or updates tags for the specified Kinesis data stream. Each time
308 you invoke this operation, you can specify up to 10 tags. If you want
309 to add more than 10 tags to your stream, you can invoke this operation
310 multiple times. In total, each stream can have up to 50 tags.
311  
312 If tags have already been assigned to the stream, C<AddTagsToStream>
313 overwrites any existing tags that correspond to the specified tag keys.
314  
315 AddTagsToStream has a limit of five transactions per second per
316 account.
317  
318  
319 =head2 CreateStream
320  
321 =over
322  
323 =item ShardCount => Int
324  
325 =item StreamName => Str
326  
327  
328 =back
329  
330 Each argument is described in detail in: L<Paws::Kinesis::CreateStream>
331  
332 Returns: nothing
333  
334 Creates a Kinesis data stream. A stream captures and transports data
335 records that are continuously emitted from different data sources or
336 I<producers>. Scale-out within a stream is explicitly supported by
337 means of shards, which are uniquely identified groups of data records
338 in a stream.
339  
340 You specify and control the number of shards that a stream is composed
341 of. Each shard can support reads up to five transactions per second, up
342 to a maximum data read total of 2 MiB per second. Each shard can
343 support writes up to 1,000 records per second, up to a maximum data
344 write total of 1 MiB per second. If the amount of data input increases
345 or decreases, you can add or remove shards.
346  
347 The stream name identifies the stream. The name is scoped to the AWS
348 account used by the application. It is also scoped by AWS Region. That
349 is, two streams in two different accounts can have the same name, and
350 two streams in the same account, but in two different Regions, can have
351 the same name.
352  
353 C<CreateStream> is an asynchronous operation. Upon receiving a
354 C<CreateStream> request, Kinesis Data Streams immediately returns and
355 sets the stream status to C<CREATING>. After the stream is created,
356 Kinesis Data Streams sets the stream status to C<ACTIVE>. You should
357 perform read and write operations only on an C<ACTIVE> stream.
358  
359 You receive a C<LimitExceededException> when making a C<CreateStream>
360 request when you try to do one of the following:
361  
362 =over
363  
364 =item *
365  
366 Have more than five streams in the C<CREATING> state at any point in
367 time.
368  
369 =item *
370  
371 Create more shards than are authorized for your account.
372  
373 =back
374  
375 For the default shard limit for an AWS account, see Amazon Kinesis Data
376 Streams Limits
377 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
378 in the I<Amazon Kinesis Data Streams Developer Guide>. To increase this
379 limit, contact AWS Support
380 (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
381  
382 You can use C<DescribeStream> to check the stream status, which is
383 returned in C<StreamStatus>.
384  
385 CreateStream has a limit of five transactions per second per account.
386  
387  
388 =head2 DecreaseStreamRetentionPeriod
389  
390 =over
391  
392 =item RetentionPeriodHours => Int
393  
394 =item StreamName => Str
395  
396  
397 =back
398  
399 Each argument is described in detail in: L<Paws::Kinesis::DecreaseStreamRetentionPeriod>
400  
401 Returns: nothing
402  
403 Decreases the Kinesis data stream's retention period, which is the
404 length of time data records are accessible after they are added to the
405 stream. The minimum value of a stream's retention period is 24 hours.
406  
407 This operation may result in lost data. For example, if the stream's
408 retention period is 48 hours and is decreased to 24 hours, any data
409 already in the stream that is older than 24 hours is inaccessible.
410  
411  
412 =head2 DeleteStream
413  
414 =over
415  
416 =item StreamName => Str
417  
418 =item [EnforceConsumerDeletion => Bool]
419  
420  
421 =back
422  
423 Each argument is described in detail in: L<Paws::Kinesis::DeleteStream>
424  
425 Returns: nothing
426  
427 Deletes a Kinesis data stream and all its shards and data. You must
428 shut down any applications that are operating on the stream before you
429 delete the stream. If an application attempts to operate on a deleted
430 stream, it receives the exception C<ResourceNotFoundException>.
431  
432 If the stream is in the C<ACTIVE> state, you can delete it. After a
433 C<DeleteStream> request, the specified stream is in the C<DELETING>
434 state until Kinesis Data Streams completes the deletion.
435  
436 B<Note:> Kinesis Data Streams might continue to accept data read and
437 write operations, such as PutRecord, PutRecords, and GetRecords, on a
438 stream in the C<DELETING> state until the stream deletion is complete.
439  
440 When you delete a stream, any shards in that stream are also deleted,
441 and any tags are dissociated from the stream.
442  
443 You can use the DescribeStream operation to check the state of the
444 stream, which is returned in C<StreamStatus>.
445  
446 DeleteStream has a limit of five transactions per second per account.
447  
448  
449 =head2 DeregisterStreamConsumer
450  
451 =over
452  
453 =item [ConsumerARN => Str]
454  
455 =item [ConsumerName => Str]
456  
457 =item [StreamARN => Str]
458  
459  
460 =back
461  
462 Each argument is described in detail in: L<Paws::Kinesis::DeregisterStreamConsumer>
463  
464 Returns: nothing
465  
466 To deregister a consumer, provide its ARN. Alternatively, you can
467 provide the ARN of the data stream and the name you gave the consumer
468 when you registered it. You may also provide all three parameters, as
469 long as they don't conflict with each other. If you don't know the name
470 or ARN of the consumer that you want to deregister, you can use the
471 ListStreamConsumers operation to get a list of the descriptions of all
472 the consumers that are currently registered with a given data stream.
473 The description of a consumer contains its name and ARN.
474  
475 This operation has a limit of five transactions per second per stream.
476  
477  
478 =head2 DescribeLimits
479  
480  
481  
482  
483  
484  
485 Each argument is described in detail in: L<Paws::Kinesis::DescribeLimits>
486  
487 Returns: a L<Paws::Kinesis::DescribeLimitsOutput> instance
488  
489 Describes the shard limits and usage for the account.
490  
491 If you update your account limits, the old limits might be returned for
492 a few minutes.
493  
494 This operation has a limit of one transaction per second per account.
495  
496  
497 =head2 DescribeStream
498  
499 =over
500  
501 =item StreamName => Str
502  
503 =item [ExclusiveStartShardId => Str]
504  
505 =item [Limit => Int]
506  
507  
508 =back
509  
510 Each argument is described in detail in: L<Paws::Kinesis::DescribeStream>
511  
512 Returns: a L<Paws::Kinesis::DescribeStreamOutput> instance
513  
514 Describes the specified Kinesis data stream.
515  
516 The information returned includes the stream name, Amazon Resource Name
517 (ARN), creation time, enhanced metric configuration, and shard map. The
518 shard map is an array of shard objects. For each shard object, there is
519 the hash key and sequence number ranges that the shard spans, and the
520 IDs of any earlier shards that played in a role in creating the shard.
521 Every record ingested in the stream is identified by a sequence number,
522 which is assigned when the record is put into the stream.
523  
524 You can limit the number of shards returned by each call. For more
525 information, see Retrieving Shards from a Stream
526 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-retrieve-shards.html)
527 in the I<Amazon Kinesis Data Streams Developer Guide>.
528  
529 There are no guarantees about the chronological order shards returned.
530 To process shards in chronological order, use the ID of the parent
531 shard to track the lineage to the oldest shard.
532  
533 This operation has a limit of 10 transactions per second per account.
534  
535  
536 =head2 DescribeStreamConsumer
537  
538 =over
539  
540 =item [ConsumerARN => Str]
541  
542 =item [ConsumerName => Str]
543  
544 =item [StreamARN => Str]
545  
546  
547 =back
548  
549 Each argument is described in detail in: L<Paws::Kinesis::DescribeStreamConsumer>
550  
551 Returns: a L<Paws::Kinesis::DescribeStreamConsumerOutput> instance
552  
553 To get the description of a registered consumer, provide the ARN of the
554 consumer. Alternatively, you can provide the ARN of the data stream and
555 the name you gave the consumer when you registered it. You may also
556 provide all three parameters, as long as they don't conflict with each
557 other. If you don't know the name or ARN of the consumer that you want
558 to describe, you can use the ListStreamConsumers operation to get a
559 list of the descriptions of all the consumers that are currently
560 registered with a given data stream.
561  
562 This operation has a limit of 20 transactions per second per stream.
563  
564  
565 =head2 DescribeStreamSummary
566  
567 =over
568  
569 =item StreamName => Str
570  
571  
572 =back
573  
574 Each argument is described in detail in: L<Paws::Kinesis::DescribeStreamSummary>
575  
576 Returns: a L<Paws::Kinesis::DescribeStreamSummaryOutput> instance
577  
578 Provides a summarized description of the specified Kinesis data stream
579 without the shard list.
580  
581 The information returned includes the stream name, Amazon Resource Name
582 (ARN), status, record retention period, approximate creation time,
583 monitoring, encryption details, and open shard count.
584  
585 DescribeStreamSummary has a limit of 20 transactions per second per
586 account.
587  
588  
589 =head2 DisableEnhancedMonitoring
590  
591 =over
592  
593 =item ShardLevelMetrics => ArrayRef[Str|Undef]
594  
595 =item StreamName => Str
596  
597  
598 =back
599  
600 Each argument is described in detail in: L<Paws::Kinesis::DisableEnhancedMonitoring>
601  
602 Returns: a L<Paws::Kinesis::EnhancedMonitoringOutput> instance
603  
604 Disables enhanced monitoring.
605  
606  
607 =head2 EnableEnhancedMonitoring
608  
609 =over
610  
611 =item ShardLevelMetrics => ArrayRef[Str|Undef]
612  
613 =item StreamName => Str
614  
615  
616 =back
617  
618 Each argument is described in detail in: L<Paws::Kinesis::EnableEnhancedMonitoring>
619  
620 Returns: a L<Paws::Kinesis::EnhancedMonitoringOutput> instance
621  
622 Enables enhanced Kinesis data stream monitoring for shard-level
623 metrics.
624  
625  
626 =head2 GetRecords
627  
628 =over
629  
630 =item ShardIterator => Str
631  
632 =item [Limit => Int]
633  
634  
635 =back
636  
637 Each argument is described in detail in: L<Paws::Kinesis::GetRecords>
638  
639 Returns: a L<Paws::Kinesis::GetRecordsOutput> instance
640  
641 Gets data records from a Kinesis data stream's shard.
642  
643 Specify a shard iterator using the C<ShardIterator> parameter. The
644 shard iterator specifies the position in the shard from which you want
645 to start reading data records sequentially. If there are no records
646 available in the portion of the shard that the iterator points to,
647 GetRecords returns an empty list. It might take multiple calls to get
648 to a portion of the shard that contains records.
649  
650 You can scale by provisioning multiple shards per stream while
651 considering service limits (for more information, see Amazon Kinesis
652 Data Streams Limits
653 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
654 in the I<Amazon Kinesis Data Streams Developer Guide>). Your
655 application should have one thread per shard, each reading continuously
656 from its stream. To read from a stream continually, call GetRecords in
657 a loop. Use GetShardIterator to get the shard iterator to specify in
658 the first GetRecords call. GetRecords returns a new shard iterator in
659 C<NextShardIterator>. Specify the shard iterator returned in
660 C<NextShardIterator> in subsequent calls to GetRecords. If the shard
661 has been closed, the shard iterator can't return more data and
662 GetRecords returns C<null> in C<NextShardIterator>. You can terminate
663 the loop when the shard is closed, or when the shard iterator reaches
664 the record with the sequence number or other attribute that marks it as
665 the last record to process.
666  
667 Each data record can be up to 1 MiB in size, and each shard can read up
668 to 2 MiB per second. You can ensure that your calls don't exceed the
669 maximum supported size or throughput by using the C<Limit> parameter to
670 specify the maximum number of records that GetRecords can return.
671 Consider your average record size when determining this limit. The
672 maximum number of records that can be returned per call is 10,000.
673  
674 The size of the data returned by GetRecords varies depending on the
675 utilization of the shard. The maximum size of data that GetRecords can
676 return is 10 MiB. If a call returns this amount of data, subsequent
677 calls made within the next 5 seconds throw
678 C<ProvisionedThroughputExceededException>. If there is insufficient
679 provisioned throughput on the stream, subsequent calls made within the
680 next 1 second throw C<ProvisionedThroughputExceededException>.
681 GetRecords doesn't return any data when it throws an exception. For
682 this reason, we recommend that you wait 1 second between calls to
683 GetRecords. However, it's possible that the application will get
684 exceptions for longer than 1 second.
685  
686 To detect whether the application is falling behind in processing, you
687 can use the C<MillisBehindLatest> response attribute. You can also
688 monitor the stream using CloudWatch metrics and other mechanisms (see
689 Monitoring
690 (https://docs.aws.amazon.com/kinesis/latest/dev/monitoring.html) in the
691 I<Amazon Kinesis Data Streams Developer Guide>).
692  
693 Each Amazon Kinesis record includes a value,
694 C<ApproximateArrivalTimestamp>, that is set when a stream successfully
695 receives and stores a record. This is commonly referred to as a
696 server-side time stamp, whereas a client-side time stamp is set when a
697 data producer creates or sends the record to a stream (a data producer
698 is any data source putting data records into a stream, for example with
699 PutRecords). The time stamp has millisecond precision. There are no
700 guarantees about the time stamp accuracy, or that the time stamp is
701 always increasing. For example, records in a shard or across a stream
702 might have time stamps that are out of order.
703  
704 This operation has a limit of five transactions per second per shard.
705  
706  
707 =head2 GetShardIterator
708  
709 =over
710  
711 =item ShardId => Str
712  
713 =item ShardIteratorType => Str
714  
715 =item StreamName => Str
716  
717 =item [StartingSequenceNumber => Str]
718  
719 =item [Timestamp => Str]
720  
721  
722 =back
723  
724 Each argument is described in detail in: L<Paws::Kinesis::GetShardIterator>
725  
726 Returns: a L<Paws::Kinesis::GetShardIteratorOutput> instance
727  
728 Gets an Amazon Kinesis shard iterator. A shard iterator expires 5
729 minutes after it is returned to the requester.
730  
731 A shard iterator specifies the shard position from which to start
732 reading data records sequentially. The position is specified using the
733 sequence number of a data record in a shard. A sequence number is the
734 identifier associated with every record ingested in the stream, and is
735 assigned when a record is put into the stream. Each stream has one or
736 more shards.
737  
738 You must specify the shard iterator type. For example, you can set the
739 C<ShardIteratorType> parameter to read exactly from the position
740 denoted by a specific sequence number by using the
741 C<AT_SEQUENCE_NUMBER> shard iterator type. Alternatively, the parameter
742 can read right after the sequence number by using the
743 C<AFTER_SEQUENCE_NUMBER> shard iterator type, using sequence numbers
744 returned by earlier calls to PutRecord, PutRecords, GetRecords, or
745 DescribeStream. In the request, you can specify the shard iterator type
746 C<AT_TIMESTAMP> to read records from an arbitrary point in time,
747 C<TRIM_HORIZON> to cause C<ShardIterator> to point to the last
748 untrimmed record in the shard in the system (the oldest data record in
749 the shard), or C<LATEST> so that you always read the most recent data
750 in the shard.
751  
752 When you read repeatedly from a stream, use a GetShardIterator request
753 to get the first shard iterator for use in your first GetRecords
754 request and for subsequent reads use the shard iterator returned by the
755 GetRecords request in C<NextShardIterator>. A new shard iterator is
756 returned by every GetRecords request in C<NextShardIterator>, which you
757 use in the C<ShardIterator> parameter of the next GetRecords request.
758  
759 If a GetShardIterator request is made too often, you receive a
760 C<ProvisionedThroughputExceededException>. For more information about
761 throughput limits, see GetRecords, and Streams Limits
762 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
763 in the I<Amazon Kinesis Data Streams Developer Guide>.
764  
765 If the shard is closed, GetShardIterator returns a valid iterator for
766 the last sequence number of the shard. A shard can be closed as a
767 result of using SplitShard or MergeShards.
768  
769 GetShardIterator has a limit of five transactions per second per
770 account per open shard.
771  
772  
773 =head2 IncreaseStreamRetentionPeriod
774  
775 =over
776  
777 =item RetentionPeriodHours => Int
778  
779 =item StreamName => Str
780  
781  
782 =back
783  
784 Each argument is described in detail in: L<Paws::Kinesis::IncreaseStreamRetentionPeriod>
785  
786 Returns: nothing
787  
788 Increases the Kinesis data stream's retention period, which is the
789 length of time data records are accessible after they are added to the
790 stream. The maximum value of a stream's retention period is 168 hours
791 (7 days).
792  
793 If you choose a longer stream retention period, this operation
794 increases the time period during which records that have not yet
795 expired are accessible. However, it does not make previous, expired
796 data (older than the stream's previous retention period) accessible
797 after the operation has been called. For example, if a stream's
798 retention period is set to 24 hours and is increased to 168 hours, any
799 data that is older than 24 hours remains inaccessible to consumer
800 applications.
801  
802  
803 =head2 ListShards
804  
805 =over
806  
807 =item [ExclusiveStartShardId => Str]
808  
809 =item [MaxResults => Int]
810  
811 =item [NextToken => Str]
812  
813 =item [ShardFilter => L<Paws::Kinesis::ShardFilter>]
814  
815 =item [StreamCreationTimestamp => Str]
816  
817 =item [StreamName => Str]
818  
819  
820 =back
821  
822 Each argument is described in detail in: L<Paws::Kinesis::ListShards>
823  
824 Returns: a L<Paws::Kinesis::ListShardsOutput> instance
825  
826 Lists the shards in a stream and provides information about each shard.
827 This operation has a limit of 100 transactions per second per data
828 stream.
829  
830 This API is a new operation that is used by the Amazon Kinesis Client
831 Library (KCL). If you have a fine-grained IAM policy that only allows
832 specific operations, you must update your policy to allow calls to this
833 API. For more information, see Controlling Access to Amazon Kinesis
834 Data Streams Resources Using IAM
835 (https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).
836  
837  
838 =head2 ListStreamConsumers
839  
840 =over
841  
842 =item StreamARN => Str
843  
844 =item [MaxResults => Int]
845  
846 =item [NextToken => Str]
847  
848 =item [StreamCreationTimestamp => Str]
849  
850  
851 =back
852  
853 Each argument is described in detail in: L<Paws::Kinesis::ListStreamConsumers>
854  
855 Returns: a L<Paws::Kinesis::ListStreamConsumersOutput> instance
856  
857 Lists the consumers registered to receive data from a stream using
858 enhanced fan-out, and provides information about each consumer.
859  
860 This operation has a limit of 5 transactions per second per stream.
861  
862  
863 =head2 ListStreams
864  
865 =over
866  
867 =item [ExclusiveStartStreamName => Str]
868  
869 =item [Limit => Int]
870  
871  
872 =back
873  
874 Each argument is described in detail in: L<Paws::Kinesis::ListStreams>
875  
876 Returns: a L<Paws::Kinesis::ListStreamsOutput> instance
877  
878 Lists your Kinesis data streams.
879  
880 The number of streams may be too large to return from a single call to
881 C<ListStreams>. You can limit the number of returned streams using the
882 C<Limit> parameter. If you do not specify a value for the C<Limit>
883 parameter, Kinesis Data Streams uses the default limit, which is
884 currently 10.
885  
886 You can detect if there are more streams available to list by using the
887 C<HasMoreStreams> flag from the returned output. If there are more
888 streams available, you can request more streams by using the name of
889 the last stream returned by the C<ListStreams> request in the
890 C<ExclusiveStartStreamName> parameter in a subsequent request to
891 C<ListStreams>. The group of stream names returned by the subsequent
892 request is then added to the list. You can continue this process until
893 all the stream names have been collected in the list.
894  
895 ListStreams has a limit of five transactions per second per account.
896  
897  
898 =head2 ListTagsForStream
899  
900 =over
901  
902 =item StreamName => Str
903  
904 =item [ExclusiveStartTagKey => Str]
905  
906 =item [Limit => Int]
907  
908  
909 =back
910  
911 Each argument is described in detail in: L<Paws::Kinesis::ListTagsForStream>
912  
913 Returns: a L<Paws::Kinesis::ListTagsForStreamOutput> instance
914  
915 Lists the tags for the specified Kinesis data stream. This operation
916 has a limit of five transactions per second per account.
917  
918  
919 =head2 MergeShards
920  
921 =over
922  
923 =item AdjacentShardToMerge => Str
924  
925 =item ShardToMerge => Str
926  
927 =item StreamName => Str
928  
929  
930 =back
931  
932 Each argument is described in detail in: L<Paws::Kinesis::MergeShards>
933  
934 Returns: nothing
935  
936 Merges two adjacent shards in a Kinesis data stream and combines them
937 into a single shard to reduce the stream's capacity to ingest and
938 transport data. Two shards are considered adjacent if the union of the
939 hash key ranges for the two shards form a contiguous set with no gaps.
940 For example, if you have two shards, one with a hash key range of
941 276...381 and the other with a hash key range of 382...454, then you
942 could merge these two shards into a single shard that would have a hash
943 key range of 276...454. After the merge, the single child shard
944 receives data for all hash key values covered by the two parent shards.
945  
946 C<MergeShards> is called when there is a need to reduce the overall
947 capacity of a stream because of excess capacity that is not being used.
948 You must specify the shard to be merged and the adjacent shard for a
949 stream. For more information about merging shards, see Merge Two Shards
950 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-merge.html)
951 in the I<Amazon Kinesis Data Streams Developer Guide>.
952  
953 If the stream is in the C<ACTIVE> state, you can call C<MergeShards>.
954 If a stream is in the C<CREATING>, C<UPDATING>, or C<DELETING> state,
955 C<MergeShards> returns a C<ResourceInUseException>. If the specified
956 stream does not exist, C<MergeShards> returns a
957 C<ResourceNotFoundException>.
958  
959 You can use DescribeStream to check the state of the stream, which is
960 returned in C<StreamStatus>.
961  
962 C<MergeShards> is an asynchronous operation. Upon receiving a
963 C<MergeShards> request, Amazon Kinesis Data Streams immediately returns
964 a response and sets the C<StreamStatus> to C<UPDATING>. After the
965 operation is completed, Kinesis Data Streams sets the C<StreamStatus>
966 to C<ACTIVE>. Read and write operations continue to work while the
967 stream is in the C<UPDATING> state.
968  
969 You use DescribeStream to determine the shard IDs that are specified in
970 the C<MergeShards> request.
971  
972 If you try to operate on too many streams in parallel using
973 CreateStream, DeleteStream, C<MergeShards>, or SplitShard, you receive
974 a C<LimitExceededException>.
975  
976 C<MergeShards> has a limit of five transactions per second per account.
977  
978  
979 =head2 PutRecord
980  
981 =over
982  
983 =item Data => Str
984  
985 =item PartitionKey => Str
986  
987 =item StreamName => Str
988  
989 =item [ExplicitHashKey => Str]
990  
991 =item [SequenceNumberForOrdering => Str]
992  
993  
994 =back
995  
996 Each argument is described in detail in: L<Paws::Kinesis::PutRecord>
997  
998 Returns: a L<Paws::Kinesis::PutRecordOutput> instance
999  
1000 Writes a single data record into an Amazon Kinesis data stream. Call
1001 C<PutRecord> to send data into the stream for real-time ingestion and
1002 subsequent processing, one record at a time. Each shard can support
1003 writes up to 1,000 records per second, up to a maximum data write total
1004 of 1 MiB per second.
1005  
1006 You must specify the name of the stream that captures, stores, and
1007 transports the data; a partition key; and the data blob itself.
1008  
1009 The data blob can be any type of data; for example, a segment from a
1010 log file, geographic/location data, website clickstream data, and so
1011 on.
1012  
1013 The partition key is used by Kinesis Data Streams to distribute data
1014 across shards. Kinesis Data Streams segregates the data records that
1015 belong to a stream into multiple shards, using the partition key
1016 associated with each data record to determine the shard to which a
1017 given data record belongs.
1018  
1019 Partition keys are Unicode strings, with a maximum length limit of 256
1020 characters for each key. An MD5 hash function is used to map partition
1021 keys to 128-bit integer values and to map associated data records to
1022 shards using the hash key ranges of the shards. You can override
1023 hashing the partition key to determine the shard by explicitly
1024 specifying a hash value using the C<ExplicitHashKey> parameter. For
1025 more information, see Adding Data to a Stream
1026 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
1027 in the I<Amazon Kinesis Data Streams Developer Guide>.
1028  
1029 C<PutRecord> returns the shard ID of where the data record was placed
1030 and the sequence number that was assigned to the data record.
1031  
1032 Sequence numbers increase over time and are specific to a shard within
1033 a stream, not across all shards within a stream. To guarantee strictly
1034 increasing ordering, write serially to a shard and use the
1035 C<SequenceNumberForOrdering> parameter. For more information, see
1036 Adding Data to a Stream
1037 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
1038 in the I<Amazon Kinesis Data Streams Developer Guide>.
1039  
1040 After you write a record to a stream, you cannot modify that record or
1041 its order within the stream.
1042  
1043 If a C<PutRecord> request cannot be processed because of insufficient
1044 provisioned throughput on the shard involved in the request,
1045 C<PutRecord> throws C<ProvisionedThroughputExceededException>.
1046  
1047 By default, data records are accessible for 24 hours from the time that
1048 they are added to a stream. You can use IncreaseStreamRetentionPeriod
1049 or DecreaseStreamRetentionPeriod to modify this retention period.
1050  
1051  
1052 =head2 PutRecords
1053  
1054 =over
1055  
1056 =item Records => ArrayRef[L<Paws::Kinesis::PutRecordsRequestEntry>]
1057  
1058 =item StreamName => Str
1059  
1060  
1061 =back
1062  
1063 Each argument is described in detail in: L<Paws::Kinesis::PutRecords>
1064  
1065 Returns: a L<Paws::Kinesis::PutRecordsOutput> instance
1066  
1067 Writes multiple data records into a Kinesis data stream in a single
1068 call (also referred to as a C<PutRecords> request). Use this operation
1069 to send data into the stream for data ingestion and processing.
1070  
1071 Each C<PutRecords> request can support up to 500 records. Each record
1072 in the request can be as large as 1 MiB, up to a limit of 5 MiB for the
1073 entire request, including partition keys. Each shard can support writes
1074 up to 1,000 records per second, up to a maximum data write total of 1
1075 MiB per second.
1076  
1077 You must specify the name of the stream that captures, stores, and
1078 transports the data; and an array of request C<Records>, with each
1079 record in the array requiring a partition key and data blob. The record
1080 size limit applies to the total size of the partition key and data
1081 blob.
1082  
1083 The data blob can be any type of data; for example, a segment from a
1084 log file, geographic/location data, website clickstream data, and so
1085 on.
1086  
1087 The partition key is used by Kinesis Data Streams as input to a hash
1088 function that maps the partition key and associated data to a specific
1089 shard. An MD5 hash function is used to map partition keys to 128-bit
1090 integer values and to map associated data records to shards. As a
1091 result of this hashing mechanism, all data records with the same
1092 partition key map to the same shard within the stream. For more
1093 information, see Adding Data to a Stream
1094 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-add-data-to-stream)
1095 in the I<Amazon Kinesis Data Streams Developer Guide>.
1096  
1097 Each record in the C<Records> array may include an optional parameter,
1098 C<ExplicitHashKey>, which overrides the partition key to shard mapping.
1099 This parameter allows a data producer to determine explicitly the shard
1100 where the record is stored. For more information, see Adding Multiple
1101 Records with PutRecords
1102 (https://docs.aws.amazon.com/kinesis/latest/dev/developing-producers-with-sdk.html#kinesis-using-sdk-java-putrecords)
1103 in the I<Amazon Kinesis Data Streams Developer Guide>.
1104  
1105 The C<PutRecords> response includes an array of response C<Records>.
1106 Each record in the response array directly correlates with a record in
1107 the request array using natural ordering, from the top to the bottom of
1108 the request and response. The response C<Records> array always includes
1109 the same number of records as the request array.
1110  
1111 The response C<Records> array includes both successfully and
1112 unsuccessfully processed records. Kinesis Data Streams attempts to
1113 process all records in each C<PutRecords> request. A single record
1114 failure does not stop the processing of subsequent records. As a
1115 result, PutRecords doesn't guarantee the ordering of records. If you
1116 need to read records in the same order they are written to the stream,
1117 use PutRecord instead of C<PutRecords>, and write to the same shard.
1118  
1119 A successfully processed record includes C<ShardId> and
1120 C<SequenceNumber> values. The C<ShardId> parameter identifies the shard
1121 in the stream where the record is stored. The C<SequenceNumber>
1122 parameter is an identifier assigned to the put record, unique to all
1123 records in the stream.
1124  
1125 An unsuccessfully processed record includes C<ErrorCode> and
1126 C<ErrorMessage> values. C<ErrorCode> reflects the type of error and can
1127 be one of the following values:
1128 C<ProvisionedThroughputExceededException> or C<InternalFailure>.
1129 C<ErrorMessage> provides more detailed information about the
1130 C<ProvisionedThroughputExceededException> exception including the
1131 account ID, stream name, and shard ID of the record that was throttled.
1132 For more information about partially successful responses, see Adding
1133 Multiple Records with PutRecords
1134 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-add-data-to-stream.html#kinesis-using-sdk-java-putrecords)
1135 in the I<Amazon Kinesis Data Streams Developer Guide>.
1136  
1137 After you write a record to a stream, you cannot modify that record or
1138 its order within the stream.
1139  
1140 By default, data records are accessible for 24 hours from the time that
1141 they are added to a stream. You can use IncreaseStreamRetentionPeriod
1142 or DecreaseStreamRetentionPeriod to modify this retention period.
1143  
1144  
1145 =head2 RegisterStreamConsumer
1146  
1147 =over
1148  
1149 =item ConsumerName => Str
1150  
1151 =item StreamARN => Str
1152  
1153  
1154 =back
1155  
1156 Each argument is described in detail in: L<Paws::Kinesis::RegisterStreamConsumer>
1157  
1158 Returns: a L<Paws::Kinesis::RegisterStreamConsumerOutput> instance
1159  
1160 Registers a consumer with a Kinesis data stream. When you use this
1161 operation, the consumer you register can then call SubscribeToShard to
1162 receive data from the stream using enhanced fan-out, at a rate of up to
1163 2 MiB per second for every shard you subscribe to. This rate is
1164 unaffected by the total number of consumers that read from the same
1165 stream.
1166  
1167 You can register up to 20 consumers per stream. A given consumer can
1168 only be registered with one stream at a time.
1169  
1170 For an example of how to use this operations, see Enhanced Fan-Out
1171 Using the Kinesis Data Streams API.
1172  
1173 The use of this operation has a limit of five transactions per second
1174 per account. Also, only 5 consumers can be created simultaneously. In
1175 other words, you cannot have more than 5 consumers in a C<CREATING>
1176 status at the same time. Registering a 6th consumer while there are 5
1177 in a C<CREATING> status results in a C<LimitExceededException>.
1178  
1179  
1180 =head2 RemoveTagsFromStream
1181  
1182 =over
1183  
1184 =item StreamName => Str
1185  
1186 =item TagKeys => ArrayRef[Str|Undef]
1187  
1188  
1189 =back
1190  
1191 Each argument is described in detail in: L<Paws::Kinesis::RemoveTagsFromStream>
1192  
1193 Returns: nothing
1194  
1195 Removes tags from the specified Kinesis data stream. Removed tags are
1196 deleted and cannot be recovered after this operation successfully
1197 completes.
1198  
1199 If you specify a tag that does not exist, it is ignored.
1200  
1201 RemoveTagsFromStream has a limit of five transactions per second per
1202 account.
1203  
1204  
1205 =head2 SplitShard
1206  
1207 =over
1208  
1209 =item NewStartingHashKey => Str
1210  
1211 =item ShardToSplit => Str
1212  
1213 =item StreamName => Str
1214  
1215  
1216 =back
1217  
1218 Each argument is described in detail in: L<Paws::Kinesis::SplitShard>
1219  
1220 Returns: nothing
1221  
1222 Splits a shard into two new shards in the Kinesis data stream, to
1223 increase the stream's capacity to ingest and transport data.
1224 C<SplitShard> is called when there is a need to increase the overall
1225 capacity of a stream because of an expected increase in the volume of
1226 data records being ingested.
1227  
1228 You can also use C<SplitShard> when a shard appears to be approaching
1229 its maximum utilization; for example, the producers sending data into
1230 the specific shard are suddenly sending more than previously
1231 anticipated. You can also call C<SplitShard> to increase stream
1232 capacity, so that more Kinesis Data Streams applications can
1233 simultaneously read data from the stream for real-time processing.
1234  
1235 You must specify the shard to be split and the new hash key, which is
1236 the position in the shard where the shard gets split in two. In many
1237 cases, the new hash key might be the average of the beginning and
1238 ending hash key, but it can be any hash key value in the range being
1239 mapped into the shard. For more information, see Split a Shard
1240 (https://docs.aws.amazon.com/kinesis/latest/dev/kinesis-using-sdk-java-resharding-split.html)
1241 in the I<Amazon Kinesis Data Streams Developer Guide>.
1242  
1243 You can use DescribeStream to determine the shard ID and hash key
1244 values for the C<ShardToSplit> and C<NewStartingHashKey> parameters
1245 that are specified in the C<SplitShard> request.
1246  
1247 C<SplitShard> is an asynchronous operation. Upon receiving a
1248 C<SplitShard> request, Kinesis Data Streams immediately returns a
1249 response and sets the stream status to C<UPDATING>. After the operation
1250 is completed, Kinesis Data Streams sets the stream status to C<ACTIVE>.
1251 Read and write operations continue to work while the stream is in the
1252 C<UPDATING> state.
1253  
1254 You can use C<DescribeStream> to check the status of the stream, which
1255 is returned in C<StreamStatus>. If the stream is in the C<ACTIVE>
1256 state, you can call C<SplitShard>. If a stream is in C<CREATING> or
1257 C<UPDATING> or C<DELETING> states, C<DescribeStream> returns a
1258 C<ResourceInUseException>.
1259  
1260 If the specified stream does not exist, C<DescribeStream> returns a
1261 C<ResourceNotFoundException>. If you try to create more shards than are
1262 authorized for your account, you receive a C<LimitExceededException>.
1263  
1264 For the default shard limit for an AWS account, see Kinesis Data
1265 Streams Limits
1266 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
1267 in the I<Amazon Kinesis Data Streams Developer Guide>. To increase this
1268 limit, contact AWS Support
1269 (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
1270  
1271 If you try to operate on too many streams simultaneously using
1272 CreateStream, DeleteStream, MergeShards, and/or SplitShard, you receive
1273 a C<LimitExceededException>.
1274  
1275 C<SplitShard> has a limit of five transactions per second per account.
1276  
1277  
1278 =head2 StartStreamEncryption
1279  
1280 =over
1281  
1282 =item EncryptionType => Str
1283  
1284 =item KeyId => Str
1285  
1286 =item StreamName => Str
1287  
1288  
1289 =back
1290  
1291 Each argument is described in detail in: L<Paws::Kinesis::StartStreamEncryption>
1292  
1293 Returns: nothing
1294  
1295 Enables or updates server-side encryption using an AWS KMS key for a
1296 specified stream.
1297  
1298 Starting encryption is an asynchronous operation. Upon receiving the
1299 request, Kinesis Data Streams returns immediately and sets the status
1300 of the stream to C<UPDATING>. After the update is complete, Kinesis
1301 Data Streams sets the status of the stream back to C<ACTIVE>. Updating
1302 or applying encryption normally takes a few seconds to complete, but it
1303 can take minutes. You can continue to read and write data to your
1304 stream while its status is C<UPDATING>. Once the status of the stream
1305 is C<ACTIVE>, encryption begins for records written to the stream.
1306  
1307 API Limits: You can successfully apply a new AWS KMS key for
1308 server-side encryption 25 times in a rolling 24-hour period.
1309  
1310 Note: It can take up to 5 seconds after the stream is in an C<ACTIVE>
1311 status before all records written to the stream are encrypted. After
1312 you enable encryption, you can verify that encryption is applied by
1313 inspecting the API response from C<PutRecord> or C<PutRecords>.
1314  
1315  
1316 =head2 StopStreamEncryption
1317  
1318 =over
1319  
1320 =item EncryptionType => Str
1321  
1322 =item KeyId => Str
1323  
1324 =item StreamName => Str
1325  
1326  
1327 =back
1328  
1329 Each argument is described in detail in: L<Paws::Kinesis::StopStreamEncryption>
1330  
1331 Returns: nothing
1332  
1333 Disables server-side encryption for a specified stream.
1334  
1335 Stopping encryption is an asynchronous operation. Upon receiving the
1336 request, Kinesis Data Streams returns immediately and sets the status
1337 of the stream to C<UPDATING>. After the update is complete, Kinesis
1338 Data Streams sets the status of the stream back to C<ACTIVE>. Stopping
1339 encryption normally takes a few seconds to complete, but it can take
1340 minutes. You can continue to read and write data to your stream while
1341 its status is C<UPDATING>. Once the status of the stream is C<ACTIVE>,
1342 records written to the stream are no longer encrypted by Kinesis Data
1343 Streams.
1344  
1345 API Limits: You can successfully disable server-side encryption 25
1346 times in a rolling 24-hour period.
1347  
1348 Note: It can take up to 5 seconds after the stream is in an C<ACTIVE>
1349 status before all records written to the stream are no longer subject
1350 to encryption. After you disabled encryption, you can verify that
1351 encryption is not applied by inspecting the API response from
1352 C<PutRecord> or C<PutRecords>.
1353  
1354  
1355 =head2 SubscribeToShard
1356  
1357 =over
1358  
1359 =item ConsumerARN => Str
1360  
1361 =item ShardId => Str
1362  
1363 =item StartingPosition => L<Paws::Kinesis::StartingPosition>
1364  
1365  
1366 =back
1367  
1368 Each argument is described in detail in: L<Paws::Kinesis::SubscribeToShard>
1369  
1370 Returns: a L<Paws::Kinesis::SubscribeToShardOutput> instance
1371  
1372 This operation establishes an HTTP/2 connection between the consumer
1373 you specify in the C<ConsumerARN> parameter and the shard you specify
1374 in the C<ShardId> parameter. After the connection is successfully
1375 established, Kinesis Data Streams pushes records from the shard to the
1376 consumer over this connection. Before you call this operation, call
1377 RegisterStreamConsumer to register the consumer with Kinesis Data
1378 Streams.
1379  
1380 When the C<SubscribeToShard> call succeeds, your consumer starts
1381 receiving events of type SubscribeToShardEvent over the HTTP/2
1382 connection for up to 5 minutes, after which time you need to call
1383 C<SubscribeToShard> again to renew the subscription if you want to
1384 continue to receive records.
1385  
1386 You can make one call to C<SubscribeToShard> per second per registered
1387 consumer per shard. For example, if you have a 4000 shard stream and
1388 two registered stream consumers, you can make one C<SubscribeToShard>
1389 request per second for each combination of shard and registered
1390 consumer, allowing you to subscribe both consumers to all 4000 shards
1391 in one second.
1392  
1393 If you call C<SubscribeToShard> again with the same C<ConsumerARN> and
1394 C<ShardId> within 5 seconds of a successful call, you'll get a
1395 C<ResourceInUseException>. If you call C<SubscribeToShard> 5 seconds or
1396 more after a successful call, the first connection will expire and the
1397 second call will take over the subscription.
1398  
1399 For an example of how to use this operations, see Enhanced Fan-Out
1400 Using the Kinesis Data Streams API.
1401  
1402  
1403 =head2 UpdateShardCount
1404  
1405 =over
1406  
1407 =item ScalingType => Str
1408  
1409 =item StreamName => Str
1410  
1411 =item TargetShardCount => Int
1412  
1413  
1414 =back
1415  
1416 Each argument is described in detail in: L<Paws::Kinesis::UpdateShardCount>
1417  
1418 Returns: a L<Paws::Kinesis::UpdateShardCountOutput> instance
1419  
1420 Updates the shard count of the specified stream to the specified number
1421 of shards.
1422  
1423 Updating the shard count is an asynchronous operation. Upon receiving
1424 the request, Kinesis Data Streams returns immediately and sets the
1425 status of the stream to C<UPDATING>. After the update is complete,
1426 Kinesis Data Streams sets the status of the stream back to C<ACTIVE>.
1427 Depending on the size of the stream, the scaling action could take a
1428 few minutes to complete. You can continue to read and write data to
1429 your stream while its status is C<UPDATING>.
1430  
1431 To update the shard count, Kinesis Data Streams performs splits or
1432 merges on individual shards. This can cause short-lived shards to be
1433 created, in addition to the final shards. These short-lived shards
1434 count towards your total shard limit for your account in the Region.
1435  
1436 When using this operation, we recommend that you specify a target shard
1437 count that is a multiple of 25% (25%, 50%, 75%, 100%). You can specify
1438 any target value within your shard limit. However, if you specify a
1439 target that isn't a multiple of 25%, the scaling action might take
1440 longer to complete.
1441  
1442 This operation has the following default limits. By default, you cannot
1443 do the following:
1444  
1445 =over
1446  
1447 =item *
1448  
1449 Scale more than ten times per rolling 24-hour period per stream
1450  
1451 =item *
1452  
1453 Scale up to more than double your current shard count for a stream
1454  
1455 =item *
1456  
1457 Scale down below half your current shard count for a stream
1458  
1459 =item *
1460  
1461 Scale up to more than 500 shards in a stream
1462  
1463 =item *
1464  
1465 Scale a stream with more than 500 shards down unless the result is less
1466 than 500 shards
1467  
1468 =item *
1469  
1470 Scale up to more than the shard limit for your account
1471  
1472 =back
1473  
1474 For the default limits for an AWS account, see Streams Limits
1475 (https://docs.aws.amazon.com/kinesis/latest/dev/service-sizes-and-limits.html)
1476 in the I<Amazon Kinesis Data Streams Developer Guide>. To request an
1477 increase in the call rate limit, the shard limit for this API, or your
1478 overall shard limit, use the limits form
1479 (https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase&limitType=service-code-kinesis).
1480  
1481  
1482  
1483  
1484 =head1 PAGINATORS
1485  
1486 Paginator methods are helpers that repetively call methods that return partial results
1487  
1488 =head2 DescribeAllStream(sub { },StreamName => Str, [ExclusiveStartShardId => Str, Limit => Int])
1489  
1490 =head2 DescribeAllStream(StreamName => Str, [ExclusiveStartShardId => Str, Limit => Int])
1491  
1492  
1493 If passed a sub as first parameter, it will call the sub for each element found in :
1494  
1495 - StreamDescription.Shards, passing the object as the first parameter, and the string 'StreamDescription.Shards' as the second parameter
1496  
1497 If not, it will return a a L<Paws::Kinesis::DescribeStreamOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1498  
1499  
1500 =head2 ListAllShards(sub { },[ExclusiveStartShardId => Str, MaxResults => Int, NextToken => Str, ShardFilter => L<Paws::Kinesis::ShardFilter>, StreamCreationTimestamp => Str, StreamName => Str])
1501  
1502 =head2 ListAllShards([ExclusiveStartShardId => Str, MaxResults => Int, NextToken => Str, ShardFilter => L<Paws::Kinesis::ShardFilter>, StreamCreationTimestamp => Str, StreamName => Str])
1503  
1504  
1505 If passed a sub as first parameter, it will call the sub for each element found in :
1506  
1507 - Shards, passing the object as the first parameter, and the string 'Shards' as the second parameter
1508  
1509 If not, it will return a a L<Paws::Kinesis::ListShardsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1510  
1511  
1512 =head2 ListAllStreamConsumers(sub { },StreamARN => Str, [MaxResults => Int, NextToken => Str, StreamCreationTimestamp => Str])
1513  
1514 =head2 ListAllStreamConsumers(StreamARN => Str, [MaxResults => Int, NextToken => Str, StreamCreationTimestamp => Str])
1515  
1516  
1517 If passed a sub as first parameter, it will call the sub for each element found in :
1518  
1519 - Consumers, passing the object as the first parameter, and the string 'Consumers' as the second parameter
1520  
1521 If not, it will return a a L<Paws::Kinesis::ListStreamConsumersOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1522  
1523  
1524 =head2 ListAllStreams(sub { },[ExclusiveStartStreamName => Str, Limit => Int])
1525  
1526 =head2 ListAllStreams([ExclusiveStartStreamName => Str, Limit => Int])
1527  
1528  
1529 If passed a sub as first parameter, it will call the sub for each element found in :
1530  
1531 - StreamNames, passing the object as the first parameter, and the string 'StreamNames' as the second parameter
1532  
1533 If not, it will return a a L<Paws::Kinesis::ListStreamsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1534  
1535  
1536  
1537  
1538  
1539 =head1 SEE ALSO
1540  
1541 This service class forms part of L<Paws>
1542  
1543 =head1 BUGS and CONTRIBUTIONS
1544  
1545 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1546  
1547 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1548  
1549 =cut
1550  
« blib/lib/Paws/SDB.pm ↑ Summary blib/lib/Paws/ElasticBeanstalk.pm »