{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
module Network.AWS.CloudWatchLogs.GetLogEvents
(
getLogEvents
, GetLogEvents
, gleStartTime
, gleStartFromHead
, gleNextToken
, gleEndTime
, gleLimit
, gleLogGroupName
, gleLogStreamName
, getLogEventsResponse
, GetLogEventsResponse
, glersNextBackwardToken
, glersNextForwardToken
, glersEvents
, glersResponseStatus
) where
import Network.AWS.CloudWatchLogs.Types
import Network.AWS.CloudWatchLogs.Types.Product
import Network.AWS.Lens
import Network.AWS.Prelude
import Network.AWS.Request
import Network.AWS.Response
data GetLogEvents = GetLogEvents'
{ _gleStartTime :: !(Maybe Nat)
, _gleStartFromHead :: !(Maybe Bool)
, _gleNextToken :: !(Maybe Text)
, _gleEndTime :: !(Maybe Nat)
, _gleLimit :: !(Maybe Nat)
, _gleLogGroupName :: !Text
, _gleLogStreamName :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
getLogEvents
:: Text
-> Text
-> GetLogEvents
getLogEvents pLogGroupName_ pLogStreamName_ =
GetLogEvents'
{ _gleStartTime = Nothing
, _gleStartFromHead = Nothing
, _gleNextToken = Nothing
, _gleEndTime = Nothing
, _gleLimit = Nothing
, _gleLogGroupName = pLogGroupName_
, _gleLogStreamName = pLogStreamName_
}
gleStartTime :: Lens' GetLogEvents (Maybe Natural)
gleStartTime = lens _gleStartTime (\ s a -> s{_gleStartTime = a}) . mapping _Nat;
gleStartFromHead :: Lens' GetLogEvents (Maybe Bool)
gleStartFromHead = lens _gleStartFromHead (\ s a -> s{_gleStartFromHead = a});
gleNextToken :: Lens' GetLogEvents (Maybe Text)
gleNextToken = lens _gleNextToken (\ s a -> s{_gleNextToken = a});
gleEndTime :: Lens' GetLogEvents (Maybe Natural)
gleEndTime = lens _gleEndTime (\ s a -> s{_gleEndTime = a}) . mapping _Nat;
gleLimit :: Lens' GetLogEvents (Maybe Natural)
gleLimit = lens _gleLimit (\ s a -> s{_gleLimit = a}) . mapping _Nat;
gleLogGroupName :: Lens' GetLogEvents Text
gleLogGroupName = lens _gleLogGroupName (\ s a -> s{_gleLogGroupName = a});
gleLogStreamName :: Lens' GetLogEvents Text
gleLogStreamName = lens _gleLogStreamName (\ s a -> s{_gleLogStreamName = a});
instance AWSRequest GetLogEvents where
type Rs GetLogEvents = GetLogEventsResponse
request = postJSON cloudWatchLogs
response
= receiveJSON
(\ s h x ->
GetLogEventsResponse' <$>
(x .?> "nextBackwardToken") <*>
(x .?> "nextForwardToken")
<*> (x .?> "events" .!@ mempty)
<*> (pure (fromEnum s)))
instance Hashable GetLogEvents
instance NFData GetLogEvents
instance ToHeaders GetLogEvents where
toHeaders
= const
(mconcat
["X-Amz-Target" =#
("Logs_20140328.GetLogEvents" :: ByteString),
"Content-Type" =#
("application/x-amz-json-1.1" :: ByteString)])
instance ToJSON GetLogEvents where
toJSON GetLogEvents'{..}
= object
(catMaybes
[("startTime" .=) <$> _gleStartTime,
("startFromHead" .=) <$> _gleStartFromHead,
("nextToken" .=) <$> _gleNextToken,
("endTime" .=) <$> _gleEndTime,
("limit" .=) <$> _gleLimit,
Just ("logGroupName" .= _gleLogGroupName),
Just ("logStreamName" .= _gleLogStreamName)])
instance ToPath GetLogEvents where
toPath = const "/"
instance ToQuery GetLogEvents where
toQuery = const mempty
data GetLogEventsResponse = GetLogEventsResponse'
{ _glersNextBackwardToken :: !(Maybe Text)
, _glersNextForwardToken :: !(Maybe Text)
, _glersEvents :: !(Maybe [OutputLogEvent])
, _glersResponseStatus :: !Int
} deriving (Eq,Read,Show,Data,Typeable,Generic)
getLogEventsResponse
:: Int
-> GetLogEventsResponse
getLogEventsResponse pResponseStatus_ =
GetLogEventsResponse'
{ _glersNextBackwardToken = Nothing
, _glersNextForwardToken = Nothing
, _glersEvents = Nothing
, _glersResponseStatus = pResponseStatus_
}
glersNextBackwardToken :: Lens' GetLogEventsResponse (Maybe Text)
glersNextBackwardToken = lens _glersNextBackwardToken (\ s a -> s{_glersNextBackwardToken = a});
glersNextForwardToken :: Lens' GetLogEventsResponse (Maybe Text)
glersNextForwardToken = lens _glersNextForwardToken (\ s a -> s{_glersNextForwardToken = a});
glersEvents :: Lens' GetLogEventsResponse [OutputLogEvent]
glersEvents = lens _glersEvents (\ s a -> s{_glersEvents = a}) . _Default . _Coerce;
glersResponseStatus :: Lens' GetLogEventsResponse Int
glersResponseStatus = lens _glersResponseStatus (\ s a -> s{_glersResponseStatus = a});
instance NFData GetLogEventsResponse