{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.CloudWatch.ListMetrics
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- List the specified metrics. You can use the returned metrics with
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html GetMetricData>
-- or
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html GetMetricStatistics>
-- to get statistical data.
--
-- Up to 500 results are returned for any one call. To retrieve additional
-- results, use the returned token with subsequent calls.
--
-- After you create a metric, allow up to 15 minutes for the metric to
-- appear. To see metric statistics sooner, use
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html GetMetricData>
-- or
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html GetMetricStatistics>.
--
-- If you are using CloudWatch cross-account observability, you can use
-- this operation in a monitoring account and view metrics from the linked
-- source accounts. For more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Unified-Cross-Account.html CloudWatch cross-account observability>.
--
-- @ListMetrics@ doesn\'t return information about metrics if those metrics
-- haven\'t reported data in the past two weeks. To retrieve those metrics,
-- use
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html GetMetricData>
-- or
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html GetMetricStatistics>.
--
-- This operation returns paginated results.
module Amazonka.CloudWatch.ListMetrics
  ( -- * Creating a Request
    ListMetrics (..),
    newListMetrics,

    -- * Request Lenses
    listMetrics_dimensions,
    listMetrics_includeLinkedAccounts,
    listMetrics_metricName,
    listMetrics_namespace,
    listMetrics_nextToken,
    listMetrics_owningAccount,
    listMetrics_recentlyActive,

    -- * Destructuring the Response
    ListMetricsResponse (..),
    newListMetricsResponse,

    -- * Response Lenses
    listMetricsResponse_metrics,
    listMetricsResponse_nextToken,
    listMetricsResponse_owningAccounts,
    listMetricsResponse_httpStatus,
  )
where

import Amazonka.CloudWatch.Types
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newListMetrics' smart constructor.
data ListMetrics = ListMetrics'
  { -- | The dimensions to filter against. Only the dimensions that match exactly
    -- will be returned.
    ListMetrics -> Maybe [DimensionFilter]
dimensions :: Prelude.Maybe [DimensionFilter],
    -- | If you are using this operation in a monitoring account, specify @true@
    -- to include metrics from source accounts in the returned data.
    --
    -- The default is @false@.
    ListMetrics -> Maybe Bool
includeLinkedAccounts :: Prelude.Maybe Prelude.Bool,
    -- | The name of the metric to filter against. Only the metrics with names
    -- that match exactly will be returned.
    ListMetrics -> Maybe Text
metricName :: Prelude.Maybe Prelude.Text,
    -- | The metric namespace to filter against. Only the namespace that matches
    -- exactly will be returned.
    ListMetrics -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | The token returned by a previous call to indicate that there is more
    -- data available.
    ListMetrics -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | When you use this operation in a monitoring account, use this field to
    -- return metrics only from one source account. To do so, specify that
    -- source account ID in this field, and also specify @true@ for
    -- @IncludeLinkedAccounts@.
    ListMetrics -> Maybe Text
owningAccount :: Prelude.Maybe Prelude.Text,
    -- | To filter the results to show only metrics that have had data points
    -- published in the past three hours, specify this parameter with a value
    -- of @PT3H@. This is the only valid value for this parameter.
    --
    -- The results that are returned are an approximation of the value you
    -- specify. There is a low probability that the returned results include
    -- metrics with last published data as much as 40 minutes more than the
    -- specified time interval.
    ListMetrics -> Maybe RecentlyActive
recentlyActive :: Prelude.Maybe RecentlyActive
  }
  deriving (ListMetrics -> ListMetrics -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListMetrics -> ListMetrics -> Bool
$c/= :: ListMetrics -> ListMetrics -> Bool
== :: ListMetrics -> ListMetrics -> Bool
$c== :: ListMetrics -> ListMetrics -> Bool
Prelude.Eq, ReadPrec [ListMetrics]
ReadPrec ListMetrics
Int -> ReadS ListMetrics
ReadS [ListMetrics]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListMetrics]
$creadListPrec :: ReadPrec [ListMetrics]
readPrec :: ReadPrec ListMetrics
$creadPrec :: ReadPrec ListMetrics
readList :: ReadS [ListMetrics]
$creadList :: ReadS [ListMetrics]
readsPrec :: Int -> ReadS ListMetrics
$creadsPrec :: Int -> ReadS ListMetrics
Prelude.Read, Int -> ListMetrics -> ShowS
[ListMetrics] -> ShowS
ListMetrics -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListMetrics] -> ShowS
$cshowList :: [ListMetrics] -> ShowS
show :: ListMetrics -> String
$cshow :: ListMetrics -> String
showsPrec :: Int -> ListMetrics -> ShowS
$cshowsPrec :: Int -> ListMetrics -> ShowS
Prelude.Show, forall x. Rep ListMetrics x -> ListMetrics
forall x. ListMetrics -> Rep ListMetrics x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListMetrics x -> ListMetrics
$cfrom :: forall x. ListMetrics -> Rep ListMetrics x
Prelude.Generic)

-- |
-- Create a value of 'ListMetrics' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'dimensions', 'listMetrics_dimensions' - The dimensions to filter against. Only the dimensions that match exactly
-- will be returned.
--
-- 'includeLinkedAccounts', 'listMetrics_includeLinkedAccounts' - If you are using this operation in a monitoring account, specify @true@
-- to include metrics from source accounts in the returned data.
--
-- The default is @false@.
--
-- 'metricName', 'listMetrics_metricName' - The name of the metric to filter against. Only the metrics with names
-- that match exactly will be returned.
--
-- 'namespace', 'listMetrics_namespace' - The metric namespace to filter against. Only the namespace that matches
-- exactly will be returned.
--
-- 'nextToken', 'listMetrics_nextToken' - The token returned by a previous call to indicate that there is more
-- data available.
--
-- 'owningAccount', 'listMetrics_owningAccount' - When you use this operation in a monitoring account, use this field to
-- return metrics only from one source account. To do so, specify that
-- source account ID in this field, and also specify @true@ for
-- @IncludeLinkedAccounts@.
--
-- 'recentlyActive', 'listMetrics_recentlyActive' - To filter the results to show only metrics that have had data points
-- published in the past three hours, specify this parameter with a value
-- of @PT3H@. This is the only valid value for this parameter.
--
-- The results that are returned are an approximation of the value you
-- specify. There is a low probability that the returned results include
-- metrics with last published data as much as 40 minutes more than the
-- specified time interval.
newListMetrics ::
  ListMetrics
newListMetrics :: ListMetrics
newListMetrics =
  ListMetrics'
    { $sel:dimensions:ListMetrics' :: Maybe [DimensionFilter]
dimensions = forall a. Maybe a
Prelude.Nothing,
      $sel:includeLinkedAccounts:ListMetrics' :: Maybe Bool
includeLinkedAccounts = forall a. Maybe a
Prelude.Nothing,
      $sel:metricName:ListMetrics' :: Maybe Text
metricName = forall a. Maybe a
Prelude.Nothing,
      $sel:namespace:ListMetrics' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListMetrics' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:owningAccount:ListMetrics' :: Maybe Text
owningAccount = forall a. Maybe a
Prelude.Nothing,
      $sel:recentlyActive:ListMetrics' :: Maybe RecentlyActive
recentlyActive = forall a. Maybe a
Prelude.Nothing
    }

-- | The dimensions to filter against. Only the dimensions that match exactly
-- will be returned.
listMetrics_dimensions :: Lens.Lens' ListMetrics (Prelude.Maybe [DimensionFilter])
listMetrics_dimensions :: Lens' ListMetrics (Maybe [DimensionFilter])
listMetrics_dimensions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe [DimensionFilter]
dimensions :: Maybe [DimensionFilter]
$sel:dimensions:ListMetrics' :: ListMetrics -> Maybe [DimensionFilter]
dimensions} -> Maybe [DimensionFilter]
dimensions) (\s :: ListMetrics
s@ListMetrics' {} Maybe [DimensionFilter]
a -> ListMetrics
s {$sel:dimensions:ListMetrics' :: Maybe [DimensionFilter]
dimensions = Maybe [DimensionFilter]
a} :: ListMetrics) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | If you are using this operation in a monitoring account, specify @true@
-- to include metrics from source accounts in the returned data.
--
-- The default is @false@.
listMetrics_includeLinkedAccounts :: Lens.Lens' ListMetrics (Prelude.Maybe Prelude.Bool)
listMetrics_includeLinkedAccounts :: Lens' ListMetrics (Maybe Bool)
listMetrics_includeLinkedAccounts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe Bool
includeLinkedAccounts :: Maybe Bool
$sel:includeLinkedAccounts:ListMetrics' :: ListMetrics -> Maybe Bool
includeLinkedAccounts} -> Maybe Bool
includeLinkedAccounts) (\s :: ListMetrics
s@ListMetrics' {} Maybe Bool
a -> ListMetrics
s {$sel:includeLinkedAccounts:ListMetrics' :: Maybe Bool
includeLinkedAccounts = Maybe Bool
a} :: ListMetrics)

-- | The name of the metric to filter against. Only the metrics with names
-- that match exactly will be returned.
listMetrics_metricName :: Lens.Lens' ListMetrics (Prelude.Maybe Prelude.Text)
listMetrics_metricName :: Lens' ListMetrics (Maybe Text)
listMetrics_metricName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe Text
metricName :: Maybe Text
$sel:metricName:ListMetrics' :: ListMetrics -> Maybe Text
metricName} -> Maybe Text
metricName) (\s :: ListMetrics
s@ListMetrics' {} Maybe Text
a -> ListMetrics
s {$sel:metricName:ListMetrics' :: Maybe Text
metricName = Maybe Text
a} :: ListMetrics)

-- | The metric namespace to filter against. Only the namespace that matches
-- exactly will be returned.
listMetrics_namespace :: Lens.Lens' ListMetrics (Prelude.Maybe Prelude.Text)
listMetrics_namespace :: Lens' ListMetrics (Maybe Text)
listMetrics_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe Text
namespace :: Maybe Text
$sel:namespace:ListMetrics' :: ListMetrics -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: ListMetrics
s@ListMetrics' {} Maybe Text
a -> ListMetrics
s {$sel:namespace:ListMetrics' :: Maybe Text
namespace = Maybe Text
a} :: ListMetrics)

-- | The token returned by a previous call to indicate that there is more
-- data available.
listMetrics_nextToken :: Lens.Lens' ListMetrics (Prelude.Maybe Prelude.Text)
listMetrics_nextToken :: Lens' ListMetrics (Maybe Text)
listMetrics_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListMetrics' :: ListMetrics -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListMetrics
s@ListMetrics' {} Maybe Text
a -> ListMetrics
s {$sel:nextToken:ListMetrics' :: Maybe Text
nextToken = Maybe Text
a} :: ListMetrics)

-- | When you use this operation in a monitoring account, use this field to
-- return metrics only from one source account. To do so, specify that
-- source account ID in this field, and also specify @true@ for
-- @IncludeLinkedAccounts@.
listMetrics_owningAccount :: Lens.Lens' ListMetrics (Prelude.Maybe Prelude.Text)
listMetrics_owningAccount :: Lens' ListMetrics (Maybe Text)
listMetrics_owningAccount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe Text
owningAccount :: Maybe Text
$sel:owningAccount:ListMetrics' :: ListMetrics -> Maybe Text
owningAccount} -> Maybe Text
owningAccount) (\s :: ListMetrics
s@ListMetrics' {} Maybe Text
a -> ListMetrics
s {$sel:owningAccount:ListMetrics' :: Maybe Text
owningAccount = Maybe Text
a} :: ListMetrics)

-- | To filter the results to show only metrics that have had data points
-- published in the past three hours, specify this parameter with a value
-- of @PT3H@. This is the only valid value for this parameter.
--
-- The results that are returned are an approximation of the value you
-- specify. There is a low probability that the returned results include
-- metrics with last published data as much as 40 minutes more than the
-- specified time interval.
listMetrics_recentlyActive :: Lens.Lens' ListMetrics (Prelude.Maybe RecentlyActive)
listMetrics_recentlyActive :: Lens' ListMetrics (Maybe RecentlyActive)
listMetrics_recentlyActive = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetrics' {Maybe RecentlyActive
recentlyActive :: Maybe RecentlyActive
$sel:recentlyActive:ListMetrics' :: ListMetrics -> Maybe RecentlyActive
recentlyActive} -> Maybe RecentlyActive
recentlyActive) (\s :: ListMetrics
s@ListMetrics' {} Maybe RecentlyActive
a -> ListMetrics
s {$sel:recentlyActive:ListMetrics' :: Maybe RecentlyActive
recentlyActive = Maybe RecentlyActive
a} :: ListMetrics)

instance Core.AWSPager ListMetrics where
  page :: ListMetrics -> AWSResponse ListMetrics -> Maybe ListMetrics
page ListMetrics
rq AWSResponse ListMetrics
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListMetrics
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListMetricsResponse (Maybe Text)
listMetricsResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListMetrics
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListMetricsResponse (Maybe [Metric])
listMetricsResponse_metrics
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListMetrics
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListMetricsResponse (Maybe [Text])
listMetricsResponse_owningAccounts
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListMetrics
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListMetrics (Maybe Text)
listMetrics_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListMetrics
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListMetricsResponse (Maybe Text)
listMetricsResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListMetrics where
  type AWSResponse ListMetrics = ListMetricsResponse
  request :: (Service -> Service) -> ListMetrics -> Request ListMetrics
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListMetrics
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListMetrics)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"ListMetricsResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe [Metric]
-> Maybe Text -> Maybe [Text] -> Int -> ListMetricsResponse
ListMetricsResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Metrics"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"NextToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"OwningAccounts"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListMetrics where
  hashWithSalt :: Int -> ListMetrics -> Int
hashWithSalt Int
_salt ListMetrics' {Maybe Bool
Maybe [DimensionFilter]
Maybe Text
Maybe RecentlyActive
recentlyActive :: Maybe RecentlyActive
owningAccount :: Maybe Text
nextToken :: Maybe Text
namespace :: Maybe Text
metricName :: Maybe Text
includeLinkedAccounts :: Maybe Bool
dimensions :: Maybe [DimensionFilter]
$sel:recentlyActive:ListMetrics' :: ListMetrics -> Maybe RecentlyActive
$sel:owningAccount:ListMetrics' :: ListMetrics -> Maybe Text
$sel:nextToken:ListMetrics' :: ListMetrics -> Maybe Text
$sel:namespace:ListMetrics' :: ListMetrics -> Maybe Text
$sel:metricName:ListMetrics' :: ListMetrics -> Maybe Text
$sel:includeLinkedAccounts:ListMetrics' :: ListMetrics -> Maybe Bool
$sel:dimensions:ListMetrics' :: ListMetrics -> Maybe [DimensionFilter]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [DimensionFilter]
dimensions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
includeLinkedAccounts
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
metricName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
namespace
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
owningAccount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RecentlyActive
recentlyActive

instance Prelude.NFData ListMetrics where
  rnf :: ListMetrics -> ()
rnf ListMetrics' {Maybe Bool
Maybe [DimensionFilter]
Maybe Text
Maybe RecentlyActive
recentlyActive :: Maybe RecentlyActive
owningAccount :: Maybe Text
nextToken :: Maybe Text
namespace :: Maybe Text
metricName :: Maybe Text
includeLinkedAccounts :: Maybe Bool
dimensions :: Maybe [DimensionFilter]
$sel:recentlyActive:ListMetrics' :: ListMetrics -> Maybe RecentlyActive
$sel:owningAccount:ListMetrics' :: ListMetrics -> Maybe Text
$sel:nextToken:ListMetrics' :: ListMetrics -> Maybe Text
$sel:namespace:ListMetrics' :: ListMetrics -> Maybe Text
$sel:metricName:ListMetrics' :: ListMetrics -> Maybe Text
$sel:includeLinkedAccounts:ListMetrics' :: ListMetrics -> Maybe Bool
$sel:dimensions:ListMetrics' :: ListMetrics -> Maybe [DimensionFilter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [DimensionFilter]
dimensions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
includeLinkedAccounts
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
metricName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
namespace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
owningAccount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RecentlyActive
recentlyActive

instance Data.ToHeaders ListMetrics where
  toHeaders :: ListMetrics -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToPath ListMetrics where
  toPath :: ListMetrics -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery ListMetrics where
  toQuery :: ListMetrics -> QueryString
toQuery ListMetrics' {Maybe Bool
Maybe [DimensionFilter]
Maybe Text
Maybe RecentlyActive
recentlyActive :: Maybe RecentlyActive
owningAccount :: Maybe Text
nextToken :: Maybe Text
namespace :: Maybe Text
metricName :: Maybe Text
includeLinkedAccounts :: Maybe Bool
dimensions :: Maybe [DimensionFilter]
$sel:recentlyActive:ListMetrics' :: ListMetrics -> Maybe RecentlyActive
$sel:owningAccount:ListMetrics' :: ListMetrics -> Maybe Text
$sel:nextToken:ListMetrics' :: ListMetrics -> Maybe Text
$sel:namespace:ListMetrics' :: ListMetrics -> Maybe Text
$sel:metricName:ListMetrics' :: ListMetrics -> Maybe Text
$sel:includeLinkedAccounts:ListMetrics' :: ListMetrics -> Maybe Bool
$sel:dimensions:ListMetrics' :: ListMetrics -> Maybe [DimensionFilter]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ListMetrics" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2010-08-01" :: Prelude.ByteString),
        ByteString
"Dimensions"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            (forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [DimensionFilter]
dimensions),
        ByteString
"IncludeLinkedAccounts"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
includeLinkedAccounts,
        ByteString
"MetricName" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
metricName,
        ByteString
"Namespace" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
namespace,
        ByteString
"NextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"OwningAccount" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
owningAccount,
        ByteString
"RecentlyActive" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe RecentlyActive
recentlyActive
      ]

-- | /See:/ 'newListMetricsResponse' smart constructor.
data ListMetricsResponse = ListMetricsResponse'
  { -- | The metrics that match your request.
    ListMetricsResponse -> Maybe [Metric]
metrics :: Prelude.Maybe [Metric],
    -- | The token that marks the start of the next batch of returned results.
    ListMetricsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | If you are using this operation in a monitoring account, this array
    -- contains the account IDs of the source accounts where the metrics in the
    -- returned data are from.
    --
    -- This field is a 1:1 mapping between each metric that is returned and the
    -- ID of the owning account.
    ListMetricsResponse -> Maybe [Text]
owningAccounts :: Prelude.Maybe [Prelude.Text],
    -- | The response's http status code.
    ListMetricsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListMetricsResponse -> ListMetricsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListMetricsResponse -> ListMetricsResponse -> Bool
$c/= :: ListMetricsResponse -> ListMetricsResponse -> Bool
== :: ListMetricsResponse -> ListMetricsResponse -> Bool
$c== :: ListMetricsResponse -> ListMetricsResponse -> Bool
Prelude.Eq, ReadPrec [ListMetricsResponse]
ReadPrec ListMetricsResponse
Int -> ReadS ListMetricsResponse
ReadS [ListMetricsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListMetricsResponse]
$creadListPrec :: ReadPrec [ListMetricsResponse]
readPrec :: ReadPrec ListMetricsResponse
$creadPrec :: ReadPrec ListMetricsResponse
readList :: ReadS [ListMetricsResponse]
$creadList :: ReadS [ListMetricsResponse]
readsPrec :: Int -> ReadS ListMetricsResponse
$creadsPrec :: Int -> ReadS ListMetricsResponse
Prelude.Read, Int -> ListMetricsResponse -> ShowS
[ListMetricsResponse] -> ShowS
ListMetricsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListMetricsResponse] -> ShowS
$cshowList :: [ListMetricsResponse] -> ShowS
show :: ListMetricsResponse -> String
$cshow :: ListMetricsResponse -> String
showsPrec :: Int -> ListMetricsResponse -> ShowS
$cshowsPrec :: Int -> ListMetricsResponse -> ShowS
Prelude.Show, forall x. Rep ListMetricsResponse x -> ListMetricsResponse
forall x. ListMetricsResponse -> Rep ListMetricsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListMetricsResponse x -> ListMetricsResponse
$cfrom :: forall x. ListMetricsResponse -> Rep ListMetricsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListMetricsResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'metrics', 'listMetricsResponse_metrics' - The metrics that match your request.
--
-- 'nextToken', 'listMetricsResponse_nextToken' - The token that marks the start of the next batch of returned results.
--
-- 'owningAccounts', 'listMetricsResponse_owningAccounts' - If you are using this operation in a monitoring account, this array
-- contains the account IDs of the source accounts where the metrics in the
-- returned data are from.
--
-- This field is a 1:1 mapping between each metric that is returned and the
-- ID of the owning account.
--
-- 'httpStatus', 'listMetricsResponse_httpStatus' - The response's http status code.
newListMetricsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListMetricsResponse
newListMetricsResponse :: Int -> ListMetricsResponse
newListMetricsResponse Int
pHttpStatus_ =
  ListMetricsResponse'
    { $sel:metrics:ListMetricsResponse' :: Maybe [Metric]
metrics = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListMetricsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:owningAccounts:ListMetricsResponse' :: Maybe [Text]
owningAccounts = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListMetricsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The metrics that match your request.
listMetricsResponse_metrics :: Lens.Lens' ListMetricsResponse (Prelude.Maybe [Metric])
listMetricsResponse_metrics :: Lens' ListMetricsResponse (Maybe [Metric])
listMetricsResponse_metrics = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetricsResponse' {Maybe [Metric]
metrics :: Maybe [Metric]
$sel:metrics:ListMetricsResponse' :: ListMetricsResponse -> Maybe [Metric]
metrics} -> Maybe [Metric]
metrics) (\s :: ListMetricsResponse
s@ListMetricsResponse' {} Maybe [Metric]
a -> ListMetricsResponse
s {$sel:metrics:ListMetricsResponse' :: Maybe [Metric]
metrics = Maybe [Metric]
a} :: ListMetricsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The token that marks the start of the next batch of returned results.
listMetricsResponse_nextToken :: Lens.Lens' ListMetricsResponse (Prelude.Maybe Prelude.Text)
listMetricsResponse_nextToken :: Lens' ListMetricsResponse (Maybe Text)
listMetricsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetricsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListMetricsResponse' :: ListMetricsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListMetricsResponse
s@ListMetricsResponse' {} Maybe Text
a -> ListMetricsResponse
s {$sel:nextToken:ListMetricsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListMetricsResponse)

-- | If you are using this operation in a monitoring account, this array
-- contains the account IDs of the source accounts where the metrics in the
-- returned data are from.
--
-- This field is a 1:1 mapping between each metric that is returned and the
-- ID of the owning account.
listMetricsResponse_owningAccounts :: Lens.Lens' ListMetricsResponse (Prelude.Maybe [Prelude.Text])
listMetricsResponse_owningAccounts :: Lens' ListMetricsResponse (Maybe [Text])
listMetricsResponse_owningAccounts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetricsResponse' {Maybe [Text]
owningAccounts :: Maybe [Text]
$sel:owningAccounts:ListMetricsResponse' :: ListMetricsResponse -> Maybe [Text]
owningAccounts} -> Maybe [Text]
owningAccounts) (\s :: ListMetricsResponse
s@ListMetricsResponse' {} Maybe [Text]
a -> ListMetricsResponse
s {$sel:owningAccounts:ListMetricsResponse' :: Maybe [Text]
owningAccounts = Maybe [Text]
a} :: ListMetricsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The response's http status code.
listMetricsResponse_httpStatus :: Lens.Lens' ListMetricsResponse Prelude.Int
listMetricsResponse_httpStatus :: Lens' ListMetricsResponse Int
listMetricsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMetricsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListMetricsResponse' :: ListMetricsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListMetricsResponse
s@ListMetricsResponse' {} Int
a -> ListMetricsResponse
s {$sel:httpStatus:ListMetricsResponse' :: Int
httpStatus = Int
a} :: ListMetricsResponse)

instance Prelude.NFData ListMetricsResponse where
  rnf :: ListMetricsResponse -> ()
rnf ListMetricsResponse' {Int
Maybe [Text]
Maybe [Metric]
Maybe Text
httpStatus :: Int
owningAccounts :: Maybe [Text]
nextToken :: Maybe Text
metrics :: Maybe [Metric]
$sel:httpStatus:ListMetricsResponse' :: ListMetricsResponse -> Int
$sel:owningAccounts:ListMetricsResponse' :: ListMetricsResponse -> Maybe [Text]
$sel:nextToken:ListMetricsResponse' :: ListMetricsResponse -> Maybe Text
$sel:metrics:ListMetricsResponse' :: ListMetricsResponse -> Maybe [Metric]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Metric]
metrics
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
owningAccounts
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus