File Coverage

blib/lib/Paws/CloudWatch.pm
Criterion Covered Total %
statement 19 109 17.4
branch 0 12 0.0
condition n/a
subroutine 7 24 29.1
pod 18 22 81.8
total 44 167 26.3


line stmt bran cond sub pod time code
1             package Paws::CloudWatch;
2 1     1   2008 use Moose;
  1     2   2  
  1         7  
  2         7146  
  2         3  
  2         15  
3 15     15 0 52 sub service { 'monitoring' }
4 0     0 0 0 sub version { '2010-08-01' }
5 0     0 0 0 sub flattened_arrays { 0 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse';
14              
15            
16             sub DeleteAlarms {
17 0     0 1 0 my $self = shift;
18 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DeleteAlarms', @_);
19 0         0 return $self->caller->do_call($self, $call_object);
20             }
21             sub DeleteDashboards {
22 0     0 1 0 my $self = shift;
23 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DeleteDashboards', @_);
24 0         0 return $self->caller->do_call($self, $call_object);
25             }
26             sub DescribeAlarmHistory {
27 1     1 1 343 my $self = shift;
28 1         7 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DescribeAlarmHistory', @_);
29 1         808 return $self->caller->do_call($self, $call_object);
30             }
31             sub DescribeAlarms {
32 1     1 1 343 my $self = shift;
33 1         7 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DescribeAlarms', @_);
34 1         805 return $self->caller->do_call($self, $call_object);
35             }
36             sub DescribeAlarmsForMetric {
37 0     0 1 0 my $self = shift;
38 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DescribeAlarmsForMetric', @_);
39 0         0 return $self->caller->do_call($self, $call_object);
40             }
41             sub DisableAlarmActions {
42 0     0 1 0 my $self = shift;
43 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::DisableAlarmActions', @_);
44 0         0 return $self->caller->do_call($self, $call_object);
45             }
46             sub EnableAlarmActions {
47 0     0 1 0 my $self = shift;
48 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::EnableAlarmActions', @_);
49 0         0 return $self->caller->do_call($self, $call_object);
50             }
51             sub GetDashboard {
52 0     0 1 0 my $self = shift;
53 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::GetDashboard', @_);
54 0         0 return $self->caller->do_call($self, $call_object);
55             }
56             sub GetMetricStatistics {
57 1     1 1 723 my $self = shift;
58 1         6 my $call_object = $self->new_with_coercions('Paws::CloudWatch::GetMetricStatistics', @_);
59 1         1872 return $self->caller->do_call($self, $call_object);
60             }
61             sub ListDashboards {
62 0     0 1 0 my $self = shift;
63 0         0 my $call_object = $self->new_with_coercions('Paws::CloudWatch::ListDashboards', @_);
64 0         0 return $self->caller->do_call($self, $call_object);
65             }
66             sub ListMetrics {
67 2     2 1 549 my $self = shift;
68 2         10 my $call_object = $self->new_with_coercions('Paws::CloudWatch::ListMetrics', @_);
69 2         1186 return $self->caller->do_call($self, $call_object);
70             }
71             sub PutDashboard {
72 0     0 1   my $self = shift;
73 0           my $call_object = $self->new_with_coercions('Paws::CloudWatch::PutDashboard', @_);
74 0           return $self->caller->do_call($self, $call_object);
75             }
76             sub PutMetricAlarm {
77 0     0 1   my $self = shift;
78 0           my $call_object = $self->new_with_coercions('Paws::CloudWatch::PutMetricAlarm', @_);
79 0           return $self->caller->do_call($self, $call_object);
80             }
81             sub PutMetricData {
82 0     0 1   my $self = shift;
83 0           my $call_object = $self->new_with_coercions('Paws::CloudWatch::PutMetricData', @_);
84 0           return $self->caller->do_call($self, $call_object);
85             }
86             sub SetAlarmState {
87 0     0 1   my $self = shift;
88 0           my $call_object = $self->new_with_coercions('Paws::CloudWatch::SetAlarmState', @_);
89 0           return $self->caller->do_call($self, $call_object);
90             }
91            
92             sub DescribeAllAlarmHistory {
93 0     0 1   my $self = shift;
94              
95 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
96 0           my $result = $self->DescribeAlarmHistory(@_);
97 0           my $next_result = $result;
98              
99 0 0         if (not defined $callback) {
100 0           while ($next_result->NextToken) {
101 0           $next_result = $self->DescribeAlarmHistory(@_, NextToken => $next_result->NextToken);
102 0           push @{ $result->AlarmHistoryItems }, @{ $next_result->AlarmHistoryItems };
  0            
  0            
103             }
104 0           return $result;
105             } else {
106 0           while ($result->NextToken) {
107 0           $callback->($_ => 'AlarmHistoryItems') foreach (@{ $result->AlarmHistoryItems });
  0            
108 0           $result = $self->DescribeAlarmHistory(@_, NextToken => $result->NextToken);
109             }
110 0           $callback->($_ => 'AlarmHistoryItems') foreach (@{ $result->AlarmHistoryItems });
  0            
111             }
112              
113             return undef
114 0           }
115             sub DescribeAllAlarms {
116 0     0 1   my $self = shift;
117              
118 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
119 0           my $result = $self->DescribeAlarms(@_);
120 0           my $next_result = $result;
121              
122 0 0         if (not defined $callback) {
123 0           while ($next_result->NextToken) {
124 0           $next_result = $self->DescribeAlarms(@_, NextToken => $next_result->NextToken);
125 0           push @{ $result->MetricAlarms }, @{ $next_result->MetricAlarms };
  0            
  0            
126             }
127 0           return $result;
128             } else {
129 0           while ($result->NextToken) {
130 0           $callback->($_ => 'MetricAlarms') foreach (@{ $result->MetricAlarms });
  0            
131 0           $result = $self->DescribeAlarms(@_, NextToken => $result->NextToken);
132             }
133 0           $callback->($_ => 'MetricAlarms') foreach (@{ $result->MetricAlarms });
  0            
134             }
135              
136             return undef
137 0           }
138             sub ListAllMetrics {
139 0     0 1   my $self = shift;
140              
141 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
142 0           my $result = $self->ListMetrics(@_);
143 0           my $next_result = $result;
144              
145 0 0         if (not defined $callback) {
146 0           while ($next_result->NextToken) {
147 0           $next_result = $self->ListMetrics(@_, NextToken => $next_result->NextToken);
148 0           push @{ $result->Metrics }, @{ $next_result->Metrics };
  0            
  0            
149             }
150 0           return $result;
151             } else {
152 0           while ($result->NextToken) {
153 0           $callback->($_ => 'Metrics') foreach (@{ $result->Metrics });
  0            
154 0           $result = $self->ListMetrics(@_, NextToken => $result->NextToken);
155             }
156 0           $callback->($_ => 'Metrics') foreach (@{ $result->Metrics });
  0            
157             }
158              
159             return undef
160 0           }
161              
162              
163 0     0 0   sub operations { qw/DeleteAlarms DeleteDashboards DescribeAlarmHistory DescribeAlarms DescribeAlarmsForMetric DisableAlarmActions EnableAlarmActions GetDashboard GetMetricStatistics ListDashboards ListMetrics PutDashboard PutMetricAlarm PutMetricData SetAlarmState / }
164              
165             1;
166              
167             ### main pod documentation begin ###
168              
169             =head1 NAME
170              
171             Paws::CloudWatch - Perl Interface to AWS Amazon CloudWatch
172              
173             =head1 SYNOPSIS
174              
175             use Paws;
176              
177             my $obj = Paws->service('CloudWatch');
178             my $res = $obj->Method(
179             Arg1 => $val1,
180             Arg2 => [ 'V1', 'V2' ],
181             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
182             # of the arguments type
183             Arg3 => { Att1 => 'Val1' },
184             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
185             # the constructor of the arguments type
186             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
187             );
188              
189             =head1 DESCRIPTION
190              
191             Amazon CloudWatch monitors your Amazon Web Services (AWS) resources and
192             the applications you run on AWS in real time. You can use CloudWatch to
193             collect and track metrics, which are the variables you want to measure
194             for your resources and applications.
195              
196             CloudWatch alarms send notifications or automatically change the
197             resources you are monitoring based on rules that you define. For
198             example, you can monitor the CPU usage and disk reads and writes of
199             your Amazon EC2 instances. Then, use this data to determine whether you
200             should launch additional instances to handle increased load. You can
201             also use this data to stop under-used instances to save money.
202              
203             In addition to monitoring the built-in metrics that come with AWS, you
204             can monitor your own custom metrics. With CloudWatch, you gain
205             system-wide visibility into resource utilization, application
206             performance, and operational health.
207              
208             =head1 METHODS
209              
210             =head2 DeleteAlarms(AlarmNames => ArrayRef[Str|Undef])
211              
212             Each argument is described in detail in: L<Paws::CloudWatch::DeleteAlarms>
213              
214             Returns: nothing
215              
216             Deletes the specified alarms. In the event of an error, no alarms are
217             deleted.
218              
219              
220             =head2 DeleteDashboards([DashboardNames => ArrayRef[Str|Undef]])
221              
222             Each argument is described in detail in: L<Paws::CloudWatch::DeleteDashboards>
223              
224             Returns: a L<Paws::CloudWatch::DeleteDashboardsOutput> instance
225              
226             Deletes all dashboards that you specify. You may specify up to 100
227             dashboards to delete. If there is an error during this call, no
228             dashboards are deleted.
229              
230              
231             =head2 DescribeAlarmHistory([AlarmName => Str, EndDate => Str, HistoryItemType => Str, MaxRecords => Int, NextToken => Str, StartDate => Str])
232              
233             Each argument is described in detail in: L<Paws::CloudWatch::DescribeAlarmHistory>
234              
235             Returns: a L<Paws::CloudWatch::DescribeAlarmHistoryOutput> instance
236              
237             Retrieves the history for the specified alarm. You can filter the
238             results by date range or item type. If an alarm name is not specified,
239             the histories for all alarms are returned.
240              
241             CloudWatch retains the history of an alarm even if you delete the
242             alarm.
243              
244              
245             =head2 DescribeAlarms([ActionPrefix => Str, AlarmNamePrefix => Str, AlarmNames => ArrayRef[Str|Undef], MaxRecords => Int, NextToken => Str, StateValue => Str])
246              
247             Each argument is described in detail in: L<Paws::CloudWatch::DescribeAlarms>
248              
249             Returns: a L<Paws::CloudWatch::DescribeAlarmsOutput> instance
250              
251             Retrieves the specified alarms. If no alarms are specified, all alarms
252             are returned. Alarms can be retrieved by using only a prefix for the
253             alarm name, the alarm state, or a prefix for any action.
254              
255              
256             =head2 DescribeAlarmsForMetric(MetricName => Str, Namespace => Str, [Dimensions => ArrayRef[L<Paws::CloudWatch::Dimension>], ExtendedStatistic => Str, Period => Int, Statistic => Str, Unit => Str])
257              
258             Each argument is described in detail in: L<Paws::CloudWatch::DescribeAlarmsForMetric>
259              
260             Returns: a L<Paws::CloudWatch::DescribeAlarmsForMetricOutput> instance
261              
262             Retrieves the alarms for the specified metric. To filter the results,
263             specify a statistic, period, or unit.
264              
265              
266             =head2 DisableAlarmActions(AlarmNames => ArrayRef[Str|Undef])
267              
268             Each argument is described in detail in: L<Paws::CloudWatch::DisableAlarmActions>
269              
270             Returns: nothing
271              
272             Disables the actions for the specified alarms. When an alarm's actions
273             are disabled, the alarm actions do not execute when the alarm state
274             changes.
275              
276              
277             =head2 EnableAlarmActions(AlarmNames => ArrayRef[Str|Undef])
278              
279             Each argument is described in detail in: L<Paws::CloudWatch::EnableAlarmActions>
280              
281             Returns: nothing
282              
283             Enables the actions for the specified alarms.
284              
285              
286             =head2 GetDashboard([DashboardName => Str])
287              
288             Each argument is described in detail in: L<Paws::CloudWatch::GetDashboard>
289              
290             Returns: a L<Paws::CloudWatch::GetDashboardOutput> instance
291              
292             Displays the details of the dashboard that you specify.
293              
294             To copy an existing dashboard, use C<GetDashboard>, and then use the
295             data returned within C<DashboardBody> as the template for the new
296             dashboard when you call C<PutDashboard> to create the copy.
297              
298              
299             =head2 GetMetricStatistics(EndTime => Str, MetricName => Str, Namespace => Str, Period => Int, StartTime => Str, [Dimensions => ArrayRef[L<Paws::CloudWatch::Dimension>], ExtendedStatistics => ArrayRef[Str|Undef], Statistics => ArrayRef[Str|Undef], Unit => Str])
300              
301             Each argument is described in detail in: L<Paws::CloudWatch::GetMetricStatistics>
302              
303             Returns: a L<Paws::CloudWatch::GetMetricStatisticsOutput> instance
304              
305             Gets statistics for the specified metric.
306              
307             The maximum number of data points returned from a single call is 1,440.
308             If you request more than 1,440 data points, CloudWatch returns an
309             error. To reduce the number of data points, you can narrow the
310             specified time range and make multiple requests across adjacent time
311             ranges, or you can increase the specified period. Data points are not
312             returned in chronological order.
313              
314             CloudWatch aggregates data points based on the length of the period
315             that you specify. For example, if you request statistics with a
316             one-hour period, CloudWatch aggregates all data points with time stamps
317             that fall within each one-hour period. Therefore, the number of values
318             aggregated by CloudWatch is larger than the number of data points
319             returned.
320              
321             CloudWatch needs raw data points to calculate percentile statistics. If
322             you publish data using a statistic set instead, you can only retrieve
323             percentile statistics for this data if one of the following conditions
324             is true:
325              
326             =over
327              
328             =item *
329              
330             The SampleCount value of the statistic set is 1.
331              
332             =item *
333              
334             The Min and the Max values of the statistic set are equal.
335              
336             =back
337              
338             Amazon CloudWatch retains metric data as follows:
339              
340             =over
341              
342             =item *
343              
344             Data points with a period of less than 60 seconds are available for 3
345             hours. These data points are high-resolution metrics and are available
346             only for custom metrics that have been defined with a
347             C<StorageResolution> of 1.
348              
349             =item *
350              
351             Data points with a period of 60 seconds (1-minute) are available for 15
352             days.
353              
354             =item *
355              
356             Data points with a period of 300 seconds (5-minute) are available for
357             63 days.
358              
359             =item *
360              
361             Data points with a period of 3600 seconds (1 hour) are available for
362             455 days (15 months).
363              
364             =back
365              
366             Data points that are initially published with a shorter period are
367             aggregated together for long-term storage. For example, if you collect
368             data using a period of 1 minute, the data remains available for 15 days
369             with 1-minute resolution. After 15 days, this data is still available,
370             but is aggregated and retrievable only with a resolution of 5 minutes.
371             After 63 days, the data is further aggregated and is available with a
372             resolution of 1 hour.
373              
374             CloudWatch started retaining 5-minute and 1-hour metric data as of July
375             9, 2016.
376              
377             For information about metrics and dimensions supported by AWS services,
378             see the Amazon CloudWatch Metrics and Dimensions Reference in the
379             I<Amazon CloudWatch User Guide>.
380              
381              
382             =head2 ListDashboards([DashboardNamePrefix => Str, NextToken => Str])
383              
384             Each argument is described in detail in: L<Paws::CloudWatch::ListDashboards>
385              
386             Returns: a L<Paws::CloudWatch::ListDashboardsOutput> instance
387              
388             Returns a list of the dashboards for your account. If you include
389             C<DashboardNamePrefix>, only those dashboards with names starting with
390             the prefix are listed. Otherwise, all dashboards in your account are
391             listed.
392              
393              
394             =head2 ListMetrics([Dimensions => ArrayRef[L<Paws::CloudWatch::DimensionFilter>], MetricName => Str, Namespace => Str, NextToken => Str])
395              
396             Each argument is described in detail in: L<Paws::CloudWatch::ListMetrics>
397              
398             Returns: a L<Paws::CloudWatch::ListMetricsOutput> instance
399              
400             List the specified metrics. You can use the returned metrics with
401             GetMetricStatistics to obtain statistical data.
402              
403             Up to 500 results are returned for any one call. To retrieve additional
404             results, use the returned token with subsequent calls.
405              
406             After you create a metric, allow up to fifteen minutes before the
407             metric appears. Statistics about the metric, however, are available
408             sooner using GetMetricStatistics.
409              
410              
411             =head2 PutDashboard([DashboardBody => Str, DashboardName => Str])
412              
413             Each argument is described in detail in: L<Paws::CloudWatch::PutDashboard>
414              
415             Returns: a L<Paws::CloudWatch::PutDashboardOutput> instance
416              
417             Creates a dashboard if it does not already exist, or updates an
418             existing dashboard. If you update a dashboard, the entire contents are
419             replaced with what you specify here.
420              
421             You can have up to 500 dashboards per account. All dashboards in your
422             account are global, not region-specific.
423              
424             A simple way to create a dashboard using C<PutDashboard> is to copy an
425             existing dashboard. To copy an existing dashboard using the console,
426             you can load the dashboard and then use the View/edit source command in
427             the Actions menu to display the JSON block for that dashboard. Another
428             way to copy a dashboard is to use C<GetDashboard>, and then use the
429             data returned within C<DashboardBody> as the template for the new
430             dashboard when you call C<PutDashboard>.
431              
432             When you create a dashboard with C<PutDashboard>, a good practice is to
433             add a text widget at the top of the dashboard with a message that the
434             dashboard was created by script and should not be changed in the
435             console. This message could also point console users to the location of
436             the C<DashboardBody> script or the CloudFormation template used to
437             create the dashboard.
438              
439              
440             =head2 PutMetricAlarm(AlarmName => Str, ComparisonOperator => Str, EvaluationPeriods => Int, MetricName => Str, Namespace => Str, Period => Int, Threshold => Num, [ActionsEnabled => Bool, AlarmActions => ArrayRef[Str|Undef], AlarmDescription => Str, Dimensions => ArrayRef[L<Paws::CloudWatch::Dimension>], EvaluateLowSampleCountPercentile => Str, ExtendedStatistic => Str, InsufficientDataActions => ArrayRef[Str|Undef], OKActions => ArrayRef[Str|Undef], Statistic => Str, TreatMissingData => Str, Unit => Str])
441              
442             Each argument is described in detail in: L<Paws::CloudWatch::PutMetricAlarm>
443              
444             Returns: nothing
445              
446             Creates or updates an alarm and associates it with the specified
447             metric. Optionally, this operation can associate one or more Amazon SNS
448             resources with the alarm.
449              
450             When this operation creates an alarm, the alarm state is immediately
451             set to C<INSUFFICIENT_DATA>. The alarm is evaluated and its state is
452             set appropriately. Any actions associated with the state are then
453             executed.
454              
455             When you update an existing alarm, its state is left unchanged, but the
456             update completely overwrites the previous configuration of the alarm.
457              
458             If you are an IAM user, you must have Amazon EC2 permissions for some
459             operations:
460              
461             =over
462              
463             =item *
464              
465             C<ec2:DescribeInstanceStatus> and C<ec2:DescribeInstances> for all
466             alarms on EC2 instance status metrics
467              
468             =item *
469              
470             C<ec2:StopInstances> for alarms with stop actions
471              
472             =item *
473              
474             C<ec2:TerminateInstances> for alarms with terminate actions
475              
476             =item *
477              
478             C<ec2:DescribeInstanceRecoveryAttribute> and C<ec2:RecoverInstances>
479             for alarms with recover actions
480              
481             =back
482              
483             If you have read/write permissions for Amazon CloudWatch but not for
484             Amazon EC2, you can still create an alarm, but the stop or terminate
485             actions are not performed. However, if you are later granted the
486             required permissions, the alarm actions that you created earlier are
487             performed.
488              
489             If you are using an IAM role (for example, an EC2 instance profile),
490             you cannot stop or terminate the instance using alarm actions. However,
491             you can still see the alarm state and perform any other actions such as
492             Amazon SNS notifications or Auto Scaling policies.
493              
494             If you are using temporary security credentials granted using AWS STS,
495             you cannot stop or terminate an EC2 instance using alarm actions.
496              
497             You must create at least one stop, terminate, or reboot alarm using
498             either the Amazon EC2 or CloudWatch consoles to create the
499             B<EC2ActionsAccess> IAM role. After this IAM role is created, you can
500             create stop, terminate, or reboot alarms using a command-line interface
501             or API.
502              
503              
504             =head2 PutMetricData(MetricData => ArrayRef[L<Paws::CloudWatch::MetricDatum>], Namespace => Str)
505              
506             Each argument is described in detail in: L<Paws::CloudWatch::PutMetricData>
507              
508             Returns: nothing
509              
510             Publishes metric data points to Amazon CloudWatch. CloudWatch
511             associates the data points with the specified metric. If the specified
512             metric does not exist, CloudWatch creates the metric. When CloudWatch
513             creates a metric, it can take up to fifteen minutes for the metric to
514             appear in calls to ListMetrics.
515              
516             Each C<PutMetricData> request is limited to 40 KB in size for HTTP POST
517             requests.
518              
519             Although the C<Value> parameter accepts numbers of type C<Double>,
520             CloudWatch rejects values that are either too small or too large.
521             Values must be in the range of 8.515920e-109 to 1.174271e+108 (Base 10)
522             or 2e-360 to 2e360 (Base 2). In addition, special values (for example,
523             NaN, +Infinity, -Infinity) are not supported.
524              
525             You can use up to 10 dimensions per metric to further clarify what data
526             the metric collects. For more information about specifying dimensions,
527             see Publishing Metrics in the I<Amazon CloudWatch User Guide>.
528              
529             Data points with time stamps from 24 hours ago or longer can take at
530             least 48 hours to become available for GetMetricStatistics from the
531             time they are submitted.
532              
533             CloudWatch needs raw data points to calculate percentile statistics. If
534             you publish data using a statistic set instead, you can only retrieve
535             percentile statistics for this data if one of the following conditions
536             is true:
537              
538             =over
539              
540             =item *
541              
542             The SampleCount value of the statistic set is 1
543              
544             =item *
545              
546             The Min and the Max values of the statistic set are equal
547              
548             =back
549              
550              
551              
552             =head2 SetAlarmState(AlarmName => Str, StateReason => Str, StateValue => Str, [StateReasonData => Str])
553              
554             Each argument is described in detail in: L<Paws::CloudWatch::SetAlarmState>
555              
556             Returns: nothing
557              
558             Temporarily sets the state of an alarm for testing purposes. When the
559             updated state differs from the previous value, the action configured
560             for the appropriate state is invoked. For example, if your alarm is
561             configured to send an Amazon SNS message when an alarm is triggered,
562             temporarily changing the alarm state to C<ALARM> sends an SNS message.
563             The alarm returns to its actual state (often within seconds). Because
564             the alarm state change happens quickly, it is typically only visible in
565             the alarm's B<History> tab in the Amazon CloudWatch console or through
566             DescribeAlarmHistory.
567              
568              
569              
570              
571             =head1 PAGINATORS
572              
573             Paginator methods are helpers that repetively call methods that return partial results
574              
575             =head2 DescribeAllAlarmHistory(sub { },[AlarmName => Str, EndDate => Str, HistoryItemType => Str, MaxRecords => Int, NextToken => Str, StartDate => Str])
576              
577             =head2 DescribeAllAlarmHistory([AlarmName => Str, EndDate => Str, HistoryItemType => Str, MaxRecords => Int, NextToken => Str, StartDate => Str])
578              
579              
580             If passed a sub as first parameter, it will call the sub for each element found in :
581              
582             - AlarmHistoryItems, passing the object as the first parameter, and the string 'AlarmHistoryItems' as the second parameter
583              
584             If not, it will return a a L<Paws::CloudWatch::DescribeAlarmHistoryOutput> 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.
585              
586              
587             =head2 DescribeAllAlarms(sub { },[ActionPrefix => Str, AlarmNamePrefix => Str, AlarmNames => ArrayRef[Str|Undef], MaxRecords => Int, NextToken => Str, StateValue => Str])
588              
589             =head2 DescribeAllAlarms([ActionPrefix => Str, AlarmNamePrefix => Str, AlarmNames => ArrayRef[Str|Undef], MaxRecords => Int, NextToken => Str, StateValue => Str])
590              
591              
592             If passed a sub as first parameter, it will call the sub for each element found in :
593              
594             - MetricAlarms, passing the object as the first parameter, and the string 'MetricAlarms' as the second parameter
595              
596             If not, it will return a a L<Paws::CloudWatch::DescribeAlarmsOutput> 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.
597              
598              
599             =head2 ListAllMetrics(sub { },[Dimensions => ArrayRef[L<Paws::CloudWatch::DimensionFilter>], MetricName => Str, Namespace => Str, NextToken => Str])
600              
601             =head2 ListAllMetrics([Dimensions => ArrayRef[L<Paws::CloudWatch::DimensionFilter>], MetricName => Str, Namespace => Str, NextToken => Str])
602              
603              
604             If passed a sub as first parameter, it will call the sub for each element found in :
605              
606             - Metrics, passing the object as the first parameter, and the string 'Metrics' as the second parameter
607              
608             If not, it will return a a L<Paws::CloudWatch::ListMetricsOutput> 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.
609              
610              
611              
612              
613              
614             =head1 SEE ALSO
615              
616             This service class forms part of L<Paws>
617              
618             =head1 BUGS and CONTRIBUTIONS
619              
620             The source code is located here: https://github.com/pplu/aws-sdk-perl
621              
622             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
623              
624             =cut
625