{-# LANGUAGE OverloadedStrings #-}
-- we infect all the other modules with instances from
-- this module, so they don't appear orphaned.
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Network.Datadog.Internal
( prependMaybe
, prependBool
, datadogHttp
, decodeDatadog
, baseRequest
, defaultMonitorOptions
, DatadogCredentials(..)
, module Network.Datadog.Lens
, module Network.Datadog.Types
) where

import Control.Arrow (first)
import Control.Exception
import Control.Lens hiding ((.=), cons)

import Data.Aeson hiding (Error, Series, Success)
import Data.Aeson.Types (modifyFailure, typeMismatch)
import Data.Maybe
import Data.Text (Text, append, cons, findIndex, pack, splitAt)
import Data.Text.Encoding (encodeUtf8)
import Data.Text.Lazy (unpack)
import Data.Text.Lazy.Encoding (decodeUtf8)
import Data.Time.Clock
import Data.Time.Clock.POSIX
import Data.Vector ((!?))
import qualified Data.Aeson.KeyMap as KM
import qualified Data.ByteString.Lazy as LBS (ByteString, empty)
import qualified Data.DList as D
import qualified Data.HashMap.Strict as HM

import Network.HTTP.Client hiding (host)
import Network.HTTP.Types

import Network.Datadog.Lens
import Network.Datadog.Types
import Prelude hiding (splitAt)

prependMaybe :: (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe :: (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe a -> b
f = ([b] -> [b]) -> (a -> [b] -> [b]) -> Maybe a -> [b] -> [b]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [b] -> [b]
forall a. a -> a
id ((:) (b -> [b] -> [b]) -> (a -> b) -> a -> [b] -> [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)


prependBool :: Bool -> b -> [b] -> [b]
prependBool :: Bool -> b -> [b] -> [b]
prependBool Bool
p b
a = if Bool
p then (b
a b -> [b] -> [b]
forall a. a -> [a] -> [a]
:) else [b] -> [b]
forall a. a -> a
id


datadogHttp :: Environment-> String -> [(String, String)] -> StdMethod -> Maybe LBS.ByteString -> IO LBS.ByteString
datadogHttp :: Environment
-> String
-> [(String, String)]
-> StdMethod
-> Maybe ByteString
-> IO ByteString
datadogHttp (Environment Keys
keys String
baseUrl Manager
manager) String
endpoint [(String, String)]
q StdMethod
httpMethod Maybe ByteString
content = do
  Request
initReq <- String -> IO Request
forall (m :: * -> *). MonadThrow m => String -> m Request
parseUrlThrow (String -> IO Request) -> String -> IO Request
forall a b. (a -> b) -> a -> b
$ String
baseUrl String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
endpoint
  let body :: RequestBody
body = ByteString -> RequestBody
RequestBodyLBS (ByteString -> RequestBody) -> ByteString -> RequestBody
forall a b. (a -> b) -> a -> b
$ ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
fromMaybe ByteString
LBS.empty Maybe ByteString
content
      headers :: [(HeaderName, ByteString)]
headers = [(HeaderName
"Content-type", ByteString
"application/json") | Maybe ByteString -> Bool
forall a. Maybe a -> Bool
isJust Maybe ByteString
content]
      apiQuery :: [(String, String)]
apiQuery = [(String
"api_key", Keys -> String
apiKey Keys
keys)
                 ,(String
"application_key", Keys -> String
appKey Keys
keys)]
      fullQuery :: [(ByteString, Maybe ByteString)]
fullQuery = ((String, String) -> (ByteString, Maybe ByteString))
-> [(String, String)] -> [(ByteString, Maybe ByteString)]
forall a b. (a -> b) -> [a] -> [b]
map (\(String
a,String
b) -> (Text -> ByteString
encodeUtf8 (String -> Text
pack String
a), ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just (Text -> ByteString
encodeUtf8 (String -> Text
pack String
b)))) ([(String, String)] -> [(ByteString, Maybe ByteString)])
-> [(String, String)] -> [(ByteString, Maybe ByteString)]
forall a b. (a -> b) -> a -> b
$
                  [(String, String)]
apiQuery [(String, String)] -> [(String, String)] -> [(String, String)]
forall a. [a] -> [a] -> [a]
++ [(String, String)]
q
      request :: Request
request = [(ByteString, Maybe ByteString)] -> Request -> Request
setQueryString [(ByteString, Maybe ByteString)]
fullQuery (Request -> Request) -> Request -> Request
forall a b. (a -> b) -> a -> b
$
                Request
initReq { method :: ByteString
method = StdMethod -> ByteString
renderStdMethod StdMethod
httpMethod
                        , requestBody :: RequestBody
requestBody = RequestBody
body
                        , requestHeaders :: [(HeaderName, ByteString)]
requestHeaders = [(HeaderName, ByteString)]
headers
                        }
  Response ByteString -> ByteString
forall body. Response body -> body
responseBody (Response ByteString -> ByteString)
-> IO (Response ByteString) -> IO ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Request -> Manager -> IO (Response ByteString)
httpLbs Request
request Manager
manager


decodeDatadog :: FromJSON a => String -> LBS.ByteString -> IO a
decodeDatadog :: String -> ByteString -> IO a
decodeDatadog String
funcname ByteString
body = (String -> IO a) -> (a -> IO a) -> Either String a -> IO a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (AssertionFailed -> IO a
forall e a. Exception e => e -> IO a
throwIO (AssertionFailed -> IO a)
-> (String -> AssertionFailed) -> String -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> AssertionFailed
AssertionFailed (String -> AssertionFailed)
-> (String -> String) -> String -> AssertionFailed
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
failstring) a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String a -> IO a) -> Either String a -> IO a
forall a b. (a -> b) -> a -> b
$
                              ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
eitherDecode ByteString
body
  where failstring :: String -> String
failstring String
e = String
"Datadog Library decoding failure in \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
funcname String -> String -> String
forall a. [a] -> [a] -> [a]
++
                       String
"\": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
unpack (ByteString -> Text
decodeUtf8 ByteString
body)

baseRequest :: Request
baseRequest :: Request
baseRequest = Maybe Request -> Request
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Request -> Request) -> Maybe Request -> Request
forall a b. (a -> b) -> a -> b
$ String -> Maybe Request
forall (m :: * -> *). MonadThrow m => String -> m Request
parseUrlThrow String
"https://api.datadoghq.com"

class DatadogCredentials s where
  signRequest :: s -> Request -> Request

instance DatadogCredentials Write where
  signRequest :: Write -> Request -> Request
signRequest (Write ByteString
k) = [(ByteString, Maybe ByteString)] -> Request -> Request
setQueryString [(ByteString
"api_key", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
k)]

instance DatadogCredentials ReadWrite where
  signRequest :: ReadWrite -> Request -> Request
signRequest (ReadWrite ByteString
w ByteString
r) = [(ByteString, Maybe ByteString)] -> Request -> Request
setQueryString [(ByteString
"api_key", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
w), (ByteString
"application_key", ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
r)]

instance ToJSON DowntimeSpec where
  toJSON :: DowntimeSpec -> Value
toJSON DowntimeSpec
ds = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
              (UTCTime -> Pair) -> Maybe UTCTime -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\UTCTime
a -> Key
"start" Key -> Integer -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (POSIXTime -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
ceiling (UTCTime -> POSIXTime
utcTimeToPOSIXSeconds UTCTime
a) :: Integer)) (DowntimeSpec
ds DowntimeSpec
-> Getting (Maybe UTCTime) DowntimeSpec (Maybe UTCTime)
-> Maybe UTCTime
forall s a. s -> Getting a s a -> a
^. Getting (Maybe UTCTime) DowntimeSpec (Maybe UTCTime)
forall s a. HasStart s a => Lens' s a
start) ([Pair] -> [Pair]) -> [Pair] -> [Pair]
forall a b. (a -> b) -> a -> b
$
              (UTCTime -> Pair) -> Maybe UTCTime -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\UTCTime
a -> Key
"end" Key -> Integer -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (POSIXTime -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor (UTCTime -> POSIXTime
utcTimeToPOSIXSeconds UTCTime
a) :: Integer)) (DowntimeSpec
ds DowntimeSpec
-> Getting (Maybe UTCTime) DowntimeSpec (Maybe UTCTime)
-> Maybe UTCTime
forall s a. s -> Getting a s a -> a
^. Getting (Maybe UTCTime) DowntimeSpec (Maybe UTCTime)
forall s a. HasEnd s a => Lens' s a
end)
              [Key
"scope" Key -> Tag -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (DowntimeSpec
ds DowntimeSpec -> Getting Tag DowntimeSpec Tag -> Tag
forall s a. s -> Getting a s a -> a
^. Getting Tag DowntimeSpec Tag
forall s a. HasScope s a => Lens' s a
scope)]

instance FromJSON DowntimeSpec where
  parseJSON :: Value -> Parser DowntimeSpec
parseJSON (Object Object
v) = (String -> String) -> Parser DowntimeSpec -> Parser DowntimeSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"DowntimeSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser DowntimeSpec -> Parser DowntimeSpec)
-> Parser DowntimeSpec -> Parser DowntimeSpec
forall a b. (a -> b) -> a -> b
$
                         Maybe UTCTime -> Maybe UTCTime -> Maybe Text -> Tag -> DowntimeSpec
DowntimeSpec (Maybe UTCTime
 -> Maybe UTCTime -> Maybe Text -> Tag -> DowntimeSpec)
-> Parser (Maybe UTCTime)
-> Parser (Maybe UTCTime -> Maybe Text -> Tag -> DowntimeSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         (Parser (Maybe UTCTime)
-> (Value -> Parser (Maybe UTCTime))
-> Maybe Value
-> Parser (Maybe UTCTime)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe UTCTime -> Parser (Maybe UTCTime)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UTCTime
forall a. Maybe a
Nothing) (String
-> (Scientific -> Parser (Maybe UTCTime))
-> Value
-> Parser (Maybe UTCTime)
forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"Integer" (\Scientific
t -> Maybe UTCTime -> Parser (Maybe UTCTime)
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just (POSIXTime -> UTCTime
posixSecondsToUTCTime (Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Scientific -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor Scientific
t :: Integer)))))) (Maybe Value -> Parser (Maybe UTCTime))
-> Parser (Maybe Value) -> Parser (Maybe UTCTime)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Object
v Object -> Key -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"start")) Parser (Maybe UTCTime -> Maybe Text -> Tag -> DowntimeSpec)
-> Parser (Maybe UTCTime)
-> Parser (Maybe Text -> Tag -> DowntimeSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         (Parser (Maybe UTCTime)
-> (Value -> Parser (Maybe UTCTime))
-> Maybe Value
-> Parser (Maybe UTCTime)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe UTCTime -> Parser (Maybe UTCTime)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UTCTime
forall a. Maybe a
Nothing) (String
-> (Scientific -> Parser (Maybe UTCTime))
-> Value
-> Parser (Maybe UTCTime)
forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"Integer" (\Scientific
t -> Maybe UTCTime -> Parser (Maybe UTCTime)
forall (m :: * -> *) a. Monad m => a -> m a
return (UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just (POSIXTime -> UTCTime
posixSecondsToUTCTime (Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Scientific -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor Scientific
t :: Integer)))))) (Maybe Value -> Parser (Maybe UTCTime))
-> Parser (Maybe Value) -> Parser (Maybe UTCTime)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Object
v Object -> Key -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"end")) Parser (Maybe Text -> Tag -> DowntimeSpec)
-> Parser (Maybe Text) -> Parser (Tag -> DowntimeSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"message" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing Parser (Tag -> DowntimeSpec) -> Parser Tag -> Parser DowntimeSpec
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         (String -> (Array -> Parser Tag) -> Value -> Parser Tag
forall a. String -> (Array -> Parser a) -> Value -> Parser a
withArray String
"Text" (\Array
t -> Parser Tag -> (Value -> Parser Tag) -> Maybe Value -> Parser Tag
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Parser Tag
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"\"scope\" Array is too short") Value -> Parser Tag
forall a. FromJSON a => Value -> Parser a
parseJSON (Array
t Array -> Int -> Maybe Value
forall a. Vector a -> Int -> Maybe a
!? Int
0)) (Value -> Parser Tag) -> Parser Value -> Parser Tag
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
v Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"scope")
  parseJSON Value
a = (String -> String) -> Parser DowntimeSpec -> Parser DowntimeSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"DowntimeSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser DowntimeSpec -> Parser DowntimeSpec)
-> Parser DowntimeSpec -> Parser DowntimeSpec
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser DowntimeSpec
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON Tag where
  toJSON :: Tag -> Value
toJSON (KeyValueTag Text
k Text
v) = Text -> Value
Data.Aeson.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ Text
k Text -> Text -> Text
`append` (Char
':' Char -> Text -> Text
`cons` Text
v)
  toJSON (LabelTag Text
t) = Text -> Value
Data.Aeson.String Text
t

instance FromJSON Tag where
  parseJSON :: Value -> Parser Tag
parseJSON (String Text
s) = Tag -> Parser Tag
forall (m :: * -> *) a. Monad m => a -> m a
return (Tag -> Parser Tag) -> Tag -> Parser Tag
forall a b. (a -> b) -> a -> b
$
                         Tag -> (Int -> Tag) -> Maybe Int -> Tag
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Text -> Tag
LabelTag Text
s) (\Int
i -> (Text -> Text -> Tag) -> (Text, Text) -> Tag
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> Text -> Tag
KeyValueTag (Int -> Text -> (Text, Text)
splitAt Int
i Text
s)) (Maybe Int -> Tag) -> Maybe Int -> Tag
forall a b. (a -> b) -> a -> b
$
                         (Char -> Bool) -> Text -> Maybe Int
findIndex (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
':') Text
s
  parseJSON Value
a = (String -> String) -> Parser Tag -> Parser Tag
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Tag: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Tag -> Parser Tag) -> Parser Tag -> Parser Tag
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser Tag
forall a. String -> Value -> Parser a
typeMismatch String
"String" Value
a

instance ToJSON CheckStatus where
  toJSON :: CheckStatus -> Value
toJSON CheckStatus
CheckOk = Scientific -> Value
Number Scientific
0
  toJSON CheckStatus
CheckWarning = Scientific -> Value
Number Scientific
1
  toJSON CheckStatus
CheckCritical = Scientific -> Value
Number Scientific
2
  toJSON CheckStatus
CheckUnknown = Scientific -> Value
Number Scientific
3

instance FromJSON CheckStatus where
  parseJSON :: Value -> Parser CheckStatus
parseJSON (Number Scientific
0) = CheckStatus -> Parser CheckStatus
forall (m :: * -> *) a. Monad m => a -> m a
return CheckStatus
CheckOk
  parseJSON (Number Scientific
1) = CheckStatus -> Parser CheckStatus
forall (m :: * -> *) a. Monad m => a -> m a
return CheckStatus
CheckWarning
  parseJSON (Number Scientific
2) = CheckStatus -> Parser CheckStatus
forall (m :: * -> *) a. Monad m => a -> m a
return CheckStatus
CheckCritical
  parseJSON (Number Scientific
3) = CheckStatus -> Parser CheckStatus
forall (m :: * -> *) a. Monad m => a -> m a
return CheckStatus
CheckUnknown
  parseJSON (Number Scientific
n) = String -> Parser CheckStatus
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser CheckStatus) -> String -> Parser CheckStatus
forall a b. (a -> b) -> a -> b
$ String
"CheckStatus: Number \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Scientific -> String
forall a. Show a => a -> String
show Scientific
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\" is not a valid CheckStatus"
  parseJSON Value
a = (String -> String) -> Parser CheckStatus -> Parser CheckStatus
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorType: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser CheckStatus -> Parser CheckStatus)
-> Parser CheckStatus -> Parser CheckStatus
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser CheckStatus
forall a. String -> Value -> Parser a
typeMismatch String
"Number" Value
a

instance ToJSON CheckResult where
  toJSON :: CheckResult -> Value
toJSON CheckResult
cr = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
              (UTCTime -> Pair) -> Maybe UTCTime -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\UTCTime
a -> Key
"timestamp" Key -> Integer -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (POSIXTime -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor (UTCTime -> POSIXTime
utcTimeToPOSIXSeconds UTCTime
a) :: Integer)) (CheckResult
cr CheckResult
-> Getting (Maybe UTCTime) CheckResult (Maybe UTCTime)
-> Maybe UTCTime
forall s a. s -> Getting a s a -> a
^. Getting (Maybe UTCTime) CheckResult (Maybe UTCTime)
forall s a. HasTimestamp s a => Lens' s a
timestamp) ([Pair] -> [Pair]) -> [Pair] -> [Pair]
forall a b. (a -> b) -> a -> b
$
              (Text -> Pair) -> Maybe Text -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\Text
a -> Key
"message" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
a) (CheckResult
cr CheckResult
-> Getting (Maybe Text) CheckResult (Maybe Text) -> Maybe Text
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Text) CheckResult (Maybe Text)
forall s a. HasMessage s a => Lens' s a
message)
              [Key
"check" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (CheckResult
cr CheckResult -> Getting Text CheckResult Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text CheckResult Text
forall s a. HasCheck s a => Lens' s a
check)
              ,Key
"host_name" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (CheckResult
cr CheckResult -> Getting Text CheckResult Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text CheckResult Text
forall s a. HasHostName s a => Lens' s a
hostName)
              ,Key
"status" Key -> CheckStatus -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (CheckResult
cr CheckResult
-> Getting CheckStatus CheckResult CheckStatus -> CheckStatus
forall s a. s -> Getting a s a -> a
^. Getting CheckStatus CheckResult CheckStatus
forall s a. HasStatus s a => Lens' s a
status)
              ,Key
"tags" Key -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (CheckResult
cr CheckResult -> Getting [Tag] CheckResult [Tag] -> [Tag]
forall s a. s -> Getting a s a -> a
^. Getting [Tag] CheckResult [Tag]
forall s a. HasTags s a => Lens' s a
tags)
              ]

instance FromJSON CheckResult where
  parseJSON :: Value -> Parser CheckResult
parseJSON (Object Object
v) = (String -> String) -> Parser CheckResult -> Parser CheckResult
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"CheckResult: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser CheckResult -> Parser CheckResult)
-> Parser CheckResult -> Parser CheckResult
forall a b. (a -> b) -> a -> b
$
                         Text
-> Text
-> CheckStatus
-> Maybe UTCTime
-> Maybe Text
-> [Tag]
-> CheckResult
CheckResult (Text
 -> Text
 -> CheckStatus
 -> Maybe UTCTime
 -> Maybe Text
 -> [Tag]
 -> CheckResult)
-> Parser Text
-> Parser
     (Text
      -> CheckStatus
      -> Maybe UTCTime
      -> Maybe Text
      -> [Tag]
      -> CheckResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"check" Parser
  (Text
   -> CheckStatus
   -> Maybe UTCTime
   -> Maybe Text
   -> [Tag]
   -> CheckResult)
-> Parser Text
-> Parser
     (CheckStatus
      -> Maybe UTCTime -> Maybe Text -> [Tag] -> CheckResult)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"host_name" Parser
  (CheckStatus
   -> Maybe UTCTime -> Maybe Text -> [Tag] -> CheckResult)
-> Parser CheckStatus
-> Parser (Maybe UTCTime -> Maybe Text -> [Tag] -> CheckResult)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser CheckStatus
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status" Parser (Maybe UTCTime -> Maybe Text -> [Tag] -> CheckResult)
-> Parser (Maybe UTCTime)
-> Parser (Maybe Text -> [Tag] -> CheckResult)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe UTCTime))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"timestamp" Parser (Maybe (Maybe UTCTime))
-> Maybe UTCTime -> Parser (Maybe UTCTime)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe UTCTime
forall a. Maybe a
Nothing Parser (Maybe Text -> [Tag] -> CheckResult)
-> Parser (Maybe Text) -> Parser ([Tag] -> CheckResult)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"message" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing Parser ([Tag] -> CheckResult) -> Parser [Tag] -> Parser CheckResult
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe [Tag])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tags" Parser (Maybe [Tag]) -> [Tag] -> Parser [Tag]
forall a. Parser (Maybe a) -> a -> Parser a
.!= []
  parseJSON Value
a = (String -> String) -> Parser CheckResult -> Parser CheckResult
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"CheckResult: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser CheckResult -> Parser CheckResult)
-> Parser CheckResult -> Parser CheckResult
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser CheckResult
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON Downtime where
  toJSON :: Downtime -> Value
toJSON Downtime
downtime = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
forall v. Key -> v -> KeyMap v -> KeyMap v
KM.insert Key
"id" (Int -> Value
forall a. ToJSON a => a -> Value
toJSON (Int -> Value) -> Int -> Value
forall a b. (a -> b) -> a -> b
$ Downtime
downtime Downtime -> Getting Int Downtime Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int Downtime Int
forall s a. HasId' s a => Lens' s a
id') Object
basemap
    where (Object Object
basemap) = DowntimeSpec -> Value
forall a. ToJSON a => a -> Value
toJSON (Downtime
downtime Downtime
-> Getting DowntimeSpec Downtime DowntimeSpec -> DowntimeSpec
forall s a. s -> Getting a s a -> a
^. Getting DowntimeSpec Downtime DowntimeSpec
forall s a. HasSpec s a => Lens' s a
spec)

instance FromJSON Downtime where
  parseJSON :: Value -> Parser Downtime
parseJSON (Object Object
v) = (String -> String) -> Parser Downtime -> Parser Downtime
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Downtime: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Downtime -> Parser Downtime)
-> Parser Downtime -> Parser Downtime
forall a b. (a -> b) -> a -> b
$
                         Int -> DowntimeSpec -> Downtime
Downtime (Int -> DowntimeSpec -> Downtime)
-> Parser Int -> Parser (DowntimeSpec -> Downtime)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id" Parser (DowntimeSpec -> Downtime)
-> Parser DowntimeSpec -> Parser Downtime
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser DowntimeSpec
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
  parseJSON Value
a = (String -> String) -> Parser Downtime -> Parser Downtime
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Downtime: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Downtime -> Parser Downtime)
-> Parser Downtime -> Parser Downtime
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser Downtime
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON EventPriority where
  toJSON :: EventPriority -> Value
toJSON EventPriority
NormalPriority = Text -> Value
Data.Aeson.String Text
"normal"
  toJSON EventPriority
LowPriority = Text -> Value
Data.Aeson.String Text
"low"

instance FromJSON EventPriority where
  parseJSON :: Value -> Parser EventPriority
parseJSON (Data.Aeson.String Text
"normal") = EventPriority -> Parser EventPriority
forall (m :: * -> *) a. Monad m => a -> m a
return EventPriority
NormalPriority
  parseJSON (Data.Aeson.String Text
"low") = EventPriority -> Parser EventPriority
forall (m :: * -> *) a. Monad m => a -> m a
return EventPriority
LowPriority
  parseJSON (Data.Aeson.String Text
s) = String -> Parser EventPriority
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser EventPriority) -> String -> Parser EventPriority
forall a b. (a -> b) -> a -> b
$ String
"EventPriority: String " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" is not a valid EventPriority"
  parseJSON Value
a = (String -> String) -> Parser EventPriority -> Parser EventPriority
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"EventPriority: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser EventPriority -> Parser EventPriority)
-> Parser EventPriority -> Parser EventPriority
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser EventPriority
forall a. String -> Value -> Parser a
typeMismatch String
"String" Value
a

instance ToJSON AlertType where
  toJSON :: AlertType -> Value
toJSON AlertType
Error = Text -> Value
Data.Aeson.String Text
"error"
  toJSON AlertType
Warning = Text -> Value
Data.Aeson.String Text
"warning"
  toJSON AlertType
Info = Text -> Value
Data.Aeson.String Text
"info"
  toJSON AlertType
Success = Text -> Value
Data.Aeson.String Text
"success"

instance FromJSON AlertType where
  parseJSON :: Value -> Parser AlertType
parseJSON (Data.Aeson.String Text
"error") = AlertType -> Parser AlertType
forall (m :: * -> *) a. Monad m => a -> m a
return AlertType
Error
  parseJSON (Data.Aeson.String Text
"warning") = AlertType -> Parser AlertType
forall (m :: * -> *) a. Monad m => a -> m a
return AlertType
Warning
  parseJSON (Data.Aeson.String Text
"info") = AlertType -> Parser AlertType
forall (m :: * -> *) a. Monad m => a -> m a
return AlertType
Info
  parseJSON (Data.Aeson.String Text
"success") = AlertType -> Parser AlertType
forall (m :: * -> *) a. Monad m => a -> m a
return AlertType
Success
  parseJSON (Data.Aeson.String Text
s) = String -> Parser AlertType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser AlertType) -> String -> Parser AlertType
forall a b. (a -> b) -> a -> b
$ String
"AlertType: String " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" is not a valid AlertType"
  parseJSON Value
a = (String -> String) -> Parser AlertType -> Parser AlertType
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"AlertType: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser AlertType -> Parser AlertType)
-> Parser AlertType -> Parser AlertType
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser AlertType
forall a. String -> Value -> Parser a
typeMismatch String
"String" Value
a

instance ToJSON SourceType where
  toJSON :: SourceType -> Value
toJSON SourceType
Nagios = Text -> Value
Data.Aeson.String Text
"nagios"
  toJSON SourceType
Hudson = Text -> Value
Data.Aeson.String Text
"hudson"
  toJSON SourceType
Jenkins = Text -> Value
Data.Aeson.String Text
"jenkins"
  toJSON SourceType
User = Text -> Value
Data.Aeson.String Text
"user"
  toJSON SourceType
MyApps = Text -> Value
Data.Aeson.String Text
"my apps"
  toJSON SourceType
Feed = Text -> Value
Data.Aeson.String Text
"feed"
  toJSON SourceType
Chef = Text -> Value
Data.Aeson.String Text
"chef"
  toJSON SourceType
Puppet = Text -> Value
Data.Aeson.String Text
"puppet"
  toJSON SourceType
Git = Text -> Value
Data.Aeson.String Text
"git"
  toJSON SourceType
BitBucket = Text -> Value
Data.Aeson.String Text
"bitbucket"
  toJSON SourceType
Fabric = Text -> Value
Data.Aeson.String Text
"fabric"
  toJSON SourceType
Capistrano = Text -> Value
Data.Aeson.String Text
"capistrano"

instance FromJSON SourceType where
  parseJSON :: Value -> Parser SourceType
parseJSON (Data.Aeson.String Text
"nagios") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Nagios
  parseJSON (Data.Aeson.String Text
"hudson") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Hudson
  parseJSON (Data.Aeson.String Text
"jenkins") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Jenkins
  parseJSON (Data.Aeson.String Text
"user") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
User
  parseJSON (Data.Aeson.String Text
"my apps") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
MyApps
  parseJSON (Data.Aeson.String Text
"feed") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Feed
  parseJSON (Data.Aeson.String Text
"chef") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Chef
  parseJSON (Data.Aeson.String Text
"puppet") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Puppet
  parseJSON (Data.Aeson.String Text
"git") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Git
  parseJSON (Data.Aeson.String Text
"bitbucket") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
BitBucket
  parseJSON (Data.Aeson.String Text
"fabric") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Fabric
  parseJSON (Data.Aeson.String Text
"capistrano") = SourceType -> Parser SourceType
forall (m :: * -> *) a. Monad m => a -> m a
return SourceType
Capistrano
  parseJSON (Data.Aeson.String Text
s) = String -> Parser SourceType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser SourceType) -> String -> Parser SourceType
forall a b. (a -> b) -> a -> b
$ String
"SourceType: String " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" is not a valid SourceType"
  parseJSON Value
a = (String -> String) -> Parser SourceType -> Parser SourceType
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"SourceType: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser SourceType -> Parser SourceType)
-> Parser SourceType -> Parser SourceType
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser SourceType
forall a. String -> Value -> Parser a
typeMismatch String
"String" Value
a

instance ToJSON EventSpec where
  toJSON :: EventSpec -> Value
toJSON EventSpec
ed = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
              (Text -> Pair) -> Maybe Text -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\Text
a -> Key
"host" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
a) (EventSpec
ed EventSpec
-> Getting (Maybe Text) EventSpec (Maybe Text) -> Maybe Text
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Text) EventSpec (Maybe Text)
forall s a. HasHost s a => Lens' s a
host) ([Pair] -> [Pair]) -> [Pair] -> [Pair]
forall a b. (a -> b) -> a -> b
$
              (SourceType -> Pair) -> Maybe SourceType -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (\SourceType
a -> Key
"source_type_name" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Text
pack (SourceType -> String
forall a. Show a => a -> String
show SourceType
a)) (EventSpec
ed EventSpec
-> Getting (Maybe SourceType) EventSpec (Maybe SourceType)
-> Maybe SourceType
forall s a. s -> Getting a s a -> a
^. Getting (Maybe SourceType) EventSpec (Maybe SourceType)
forall s a. HasSourceType s a => Lens' s a
sourceType)
              [Key
"title" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (EventSpec
ed EventSpec -> Getting Text EventSpec Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text EventSpec Text
forall s a. HasTitle s a => Lens' s a
title)
              ,Key
"text" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (EventSpec
ed EventSpec -> Getting Text EventSpec Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text EventSpec Text
forall s a. HasText s a => Lens' s a
text)
              ,Key
"date_happened" Key -> Integer -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (POSIXTime -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor (UTCTime -> POSIXTime
utcTimeToPOSIXSeconds (EventSpec
ed EventSpec -> Getting UTCTime EventSpec UTCTime -> UTCTime
forall s a. s -> Getting a s a -> a
^. Getting UTCTime EventSpec UTCTime
forall s a. HasDateHappened s a => Lens' s a
dateHappened)) :: Integer)
              ,Key
"priority" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Text
pack (EventPriority -> String
forall a. Show a => a -> String
show (EventSpec
ed EventSpec
-> Getting EventPriority EventSpec EventPriority -> EventPriority
forall s a. s -> Getting a s a -> a
^. Getting EventPriority EventSpec EventPriority
forall s a. HasPriority s a => Lens' s a
priority))
              ,Key
"alert_type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Text
pack (AlertType -> String
forall a. Show a => a -> String
show (EventSpec
ed EventSpec -> Getting AlertType EventSpec AlertType -> AlertType
forall s a. s -> Getting a s a -> a
^. Getting AlertType EventSpec AlertType
forall s a. HasAlertType s a => Lens' s a
alertType))
              ,Key
"tags" Key -> [Tag] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (EventSpec
ed EventSpec -> Getting [Tag] EventSpec [Tag] -> [Tag]
forall s a. s -> Getting a s a -> a
^. Getting [Tag] EventSpec [Tag]
forall s a. HasTags s a => Lens' s a
tags)
              ]

instance FromJSON EventSpec where
  parseJSON :: Value -> Parser EventSpec
parseJSON (Object Object
v) = (String -> String) -> Parser EventSpec -> Parser EventSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"EventSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser EventSpec -> Parser EventSpec)
-> Parser EventSpec -> Parser EventSpec
forall a b. (a -> b) -> a -> b
$
                         Text
-> Text
-> UTCTime
-> EventPriority
-> Maybe Text
-> [Tag]
-> AlertType
-> Maybe SourceType
-> EventSpec
EventSpec (Text
 -> Text
 -> UTCTime
 -> EventPriority
 -> Maybe Text
 -> [Tag]
 -> AlertType
 -> Maybe SourceType
 -> EventSpec)
-> Parser Text
-> Parser
     (Text
      -> UTCTime
      -> EventPriority
      -> Maybe Text
      -> [Tag]
      -> AlertType
      -> Maybe SourceType
      -> EventSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"title" Parser
  (Text
   -> UTCTime
   -> EventPriority
   -> Maybe Text
   -> [Tag]
   -> AlertType
   -> Maybe SourceType
   -> EventSpec)
-> Parser Text
-> Parser
     (UTCTime
      -> EventPriority
      -> Maybe Text
      -> [Tag]
      -> AlertType
      -> Maybe SourceType
      -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"text" Parser
  (UTCTime
   -> EventPriority
   -> Maybe Text
   -> [Tag]
   -> AlertType
   -> Maybe SourceType
   -> EventSpec)
-> Parser UTCTime
-> Parser
     (EventPriority
      -> Maybe Text
      -> [Tag]
      -> AlertType
      -> Maybe SourceType
      -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         (String -> (Scientific -> Parser UTCTime) -> Value -> Parser UTCTime
forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"Integer" (\Scientific
t -> UTCTime -> Parser UTCTime
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXTime -> UTCTime
posixSecondsToUTCTime (Integer -> POSIXTime
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Scientific -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
floor Scientific
t :: Integer)))) (Value -> Parser UTCTime) -> Parser Value -> Parser UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
v Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"date_happened") Parser
  (EventPriority
   -> Maybe Text
   -> [Tag]
   -> AlertType
   -> Maybe SourceType
   -> EventSpec)
-> Parser EventPriority
-> Parser
     (Maybe Text -> [Tag] -> AlertType -> Maybe SourceType -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser EventPriority
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"priority" Parser
  (Maybe Text -> [Tag] -> AlertType -> Maybe SourceType -> EventSpec)
-> Parser (Maybe Text)
-> Parser ([Tag] -> AlertType -> Maybe SourceType -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"host" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing Parser ([Tag] -> AlertType -> Maybe SourceType -> EventSpec)
-> Parser [Tag]
-> Parser (AlertType -> Maybe SourceType -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe [Tag])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tags" Parser (Maybe [Tag]) -> [Tag] -> Parser [Tag]
forall a. Parser (Maybe a) -> a -> Parser a
.!= [] Parser (AlertType -> Maybe SourceType -> EventSpec)
-> Parser AlertType -> Parser (Maybe SourceType -> EventSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe AlertType)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"alert_type" Parser (Maybe AlertType) -> AlertType -> Parser AlertType
forall a. Parser (Maybe a) -> a -> Parser a
.!= AlertType
Info Parser (Maybe SourceType -> EventSpec)
-> Parser (Maybe SourceType) -> Parser EventSpec
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe SourceType))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"source_type" Parser (Maybe (Maybe SourceType))
-> Maybe SourceType -> Parser (Maybe SourceType)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe SourceType
forall a. Maybe a
Nothing
  parseJSON Value
a = (String -> String) -> Parser EventSpec -> Parser EventSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"EventSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser EventSpec -> Parser EventSpec)
-> Parser EventSpec -> Parser EventSpec
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser EventSpec
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON Event where
  toJSON :: Event -> Value
toJSON Event
event = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
forall v. Key -> v -> KeyMap v -> KeyMap v
KM.insert Key
"id" (Int -> Value
forall a. ToJSON a => a -> Value
toJSON (Event
event Event -> Getting Int Event Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int Event Int
forall s a. HasId' s a => Lens' s a
id')) Object
basemap
    where (Object Object
basemap) = EventSpec -> Value
forall a. ToJSON a => a -> Value
toJSON (Event
event Event -> Getting EventSpec Event EventSpec -> EventSpec
forall s a. s -> Getting a s a -> a
^. Getting EventSpec Event EventSpec
forall s a. HasDetails s a => Lens' s a
details)

instance FromJSON Event where
  parseJSON :: Value -> Parser Event
parseJSON (Object Object
v) = (String -> String) -> Parser Event -> Parser Event
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Event: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Event -> Parser Event) -> Parser Event -> Parser Event
forall a b. (a -> b) -> a -> b
$
                         Int -> EventSpec -> Event
Event (Int -> EventSpec -> Event)
-> Parser Int -> Parser (EventSpec -> Event)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id" Parser (EventSpec -> Event) -> Parser EventSpec -> Parser Event
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser EventSpec
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
  parseJSON Value
a = (String -> String) -> Parser Event -> Parser Event
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Event: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Event -> Parser Event) -> Parser Event -> Parser Event
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser Event
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a


instance FromJSON WrappedEvent where
  parseJSON :: Value -> Parser WrappedEvent
parseJSON (Object Object
v) = (String -> String) -> Parser WrappedEvent -> Parser WrappedEvent
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"WrappedEvent: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser WrappedEvent -> Parser WrappedEvent)
-> Parser WrappedEvent -> Parser WrappedEvent
forall a b. (a -> b) -> a -> b
$
                         Event -> WrappedEvent
WrappedEvent (Event -> WrappedEvent) -> Parser Event -> Parser WrappedEvent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Event
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event"
  parseJSON Value
a = (String -> String) -> Parser WrappedEvent -> Parser WrappedEvent
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"WrappedEvent: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser WrappedEvent -> Parser WrappedEvent)
-> Parser WrappedEvent -> Parser WrappedEvent
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser WrappedEvent
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a


instance FromJSON WrappedEvents where
  parseJSON :: Value -> Parser WrappedEvents
parseJSON (Object Object
v) = (String -> String) -> Parser WrappedEvents -> Parser WrappedEvents
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"WrappedEvents: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser WrappedEvents -> Parser WrappedEvents)
-> Parser WrappedEvents -> Parser WrappedEvents
forall a b. (a -> b) -> a -> b
$
                         [Event] -> WrappedEvents
WrappedEvents ([Event] -> WrappedEvents)
-> Parser [Event] -> Parser WrappedEvents
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser [Event]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"events"
  parseJSON Value
a = (String -> String) -> Parser WrappedEvents -> Parser WrappedEvents
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"WrappedEvents: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser WrappedEvents -> Parser WrappedEvents)
-> Parser WrappedEvents -> Parser WrappedEvents
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser WrappedEvents
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON Series where
  toJSON :: Series -> Value
toJSON Series
s = [Pair] -> Value
object [ Key
"series" Key -> [Metric] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= DList Metric -> [Metric]
forall a. DList a -> [a]
D.toList (Series -> DList Metric
fromSeries Series
s) ]

instance ToJSON Timestamp where
  toJSON :: Timestamp -> Value
toJSON = Int -> Value
forall a. ToJSON a => a -> Value
toJSON (Int -> Value) -> (Timestamp -> Int) -> Timestamp -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (POSIXTime -> Int
forall a b. (RealFrac a, Integral b) => a -> b
round :: NominalDiffTime -> Int) (POSIXTime -> Int) -> (Timestamp -> POSIXTime) -> Timestamp -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Timestamp -> POSIXTime
fromTimestamp

instance ToJSON MetricPoints where
  toJSON :: MetricPoints -> Value
toJSON (Gauge   [(POSIXTime, Float)]
ps) = [(Timestamp, Float)] -> Value
forall a. ToJSON a => a -> Value
toJSON ([(Timestamp, Float)] -> Value) -> [(Timestamp, Float)] -> Value
forall a b. (a -> b) -> a -> b
$ ((POSIXTime, Float) -> (Timestamp, Float))
-> [(POSIXTime, Float)] -> [(Timestamp, Float)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((POSIXTime -> Timestamp)
-> (POSIXTime, Float) -> (Timestamp, Float)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first POSIXTime -> Timestamp
Timestamp) [(POSIXTime, Float)]
ps
  toJSON (Counter [(POSIXTime, Int64)]
ps) = [(Timestamp, Int64)] -> Value
forall a. ToJSON a => a -> Value
toJSON ([(Timestamp, Int64)] -> Value) -> [(Timestamp, Int64)] -> Value
forall a b. (a -> b) -> a -> b
$ ((POSIXTime, Int64) -> (Timestamp, Int64))
-> [(POSIXTime, Int64)] -> [(Timestamp, Int64)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((POSIXTime -> Timestamp)
-> (POSIXTime, Int64) -> (Timestamp, Int64)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first POSIXTime -> Timestamp
Timestamp) [(POSIXTime, Int64)]
ps

instance ToJSON Metric where
  toJSON :: Metric -> Value
toJSON Metric
m = [Pair] -> Value
object [Pair]
ks
    where
      f :: [Pair] -> [Pair]
f = ([Pair] -> [Pair])
-> (Text -> [Pair] -> [Pair]) -> Maybe Text -> [Pair] -> [Pair]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Pair] -> [Pair]
forall a. a -> a
id (\Text
x [Pair]
y -> (Key
"host" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
x) Pair -> [Pair] -> [Pair]
forall a. a -> [a] -> [a]
: [Pair]
y) (Maybe Text -> [Pair] -> [Pair]) -> Maybe Text -> [Pair] -> [Pair]
forall a b. (a -> b) -> a -> b
$ Metric -> Maybe Text
metricHost Metric
m
      ks :: [Pair]
ks = [Pair] -> [Pair]
f [ Key
"metric" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Metric -> Text
metricName Metric
m
             , Key
"points" Key -> MetricPoints -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Metric -> MetricPoints
metricPoints Metric
m
             , Key
"tags"   Key -> [Text] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Metric -> [Text]
metricTags Metric
m
             , Key
"type"   Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= case Metric -> MetricPoints
metricPoints Metric
m of
                 Gauge [(POSIXTime, Float)]
_   -> Text
"gauge"   :: Text
                 Counter [(POSIXTime, Int64)]
_ -> Text
"counter" :: Text
             ]

instance ToJSON MonitorType where
  toJSON :: MonitorType -> Value
toJSON MonitorType
MetricAlert = Text -> Value
Data.Aeson.String Text
"metric alert"
  toJSON MonitorType
ServiceCheck = Text -> Value
Data.Aeson.String Text
"service check"
  toJSON MonitorType
EventAlert = Text -> Value
Data.Aeson.String Text
"event alert"

instance FromJSON MonitorType where
  parseJSON :: Value -> Parser MonitorType
parseJSON (Data.Aeson.String Text
"metric alert") = MonitorType -> Parser MonitorType
forall (m :: * -> *) a. Monad m => a -> m a
return MonitorType
MetricAlert
  -- TODO figure out what "query alert" actually is
  parseJSON (Data.Aeson.String Text
"query alert") = MonitorType -> Parser MonitorType
forall (m :: * -> *) a. Monad m => a -> m a
return MonitorType
MetricAlert
  parseJSON (Data.Aeson.String Text
"service check") = MonitorType -> Parser MonitorType
forall (m :: * -> *) a. Monad m => a -> m a
return MonitorType
ServiceCheck
  parseJSON (Data.Aeson.String Text
"event alert") = MonitorType -> Parser MonitorType
forall (m :: * -> *) a. Monad m => a -> m a
return MonitorType
EventAlert
  parseJSON (Data.Aeson.String Text
s) = String -> Parser MonitorType
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser MonitorType) -> String -> Parser MonitorType
forall a b. (a -> b) -> a -> b
$ String
"MonitorType: String " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" is not a valid MonitorType"
  parseJSON Value
a = (String -> String) -> Parser MonitorType -> Parser MonitorType
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorType: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser MonitorType -> Parser MonitorType)
-> Parser MonitorType -> Parser MonitorType
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser MonitorType
forall a. String -> Value -> Parser a
typeMismatch String
"String" Value
a

instance ToJSON MonitorOptions where
  toJSON :: MonitorOptions -> Value
toJSON MonitorOptions
opts = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ [Pair] -> Object
forall v. [(Key, v)] -> KeyMap v
KM.fromList [ (Key
"silenced", HashMap Text (Maybe Integer) -> Value
forall a. ToJSON a => a -> Value
toJSON (MonitorOptions
opts MonitorOptions
-> Getting
     (HashMap Text (Maybe Integer))
     MonitorOptions
     (HashMap Text (Maybe Integer))
-> HashMap Text (Maybe Integer)
forall s a. s -> Getting a s a -> a
^. Getting
  (HashMap Text (Maybe Integer))
  MonitorOptions
  (HashMap Text (Maybe Integer))
forall s a. HasSilenced s a => Lens' s a
silenced))
                                     , (Key
"notify_no_data", Bool -> Value
Bool (MonitorOptions
opts MonitorOptions -> Getting Bool MonitorOptions Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool MonitorOptions Bool
forall s a. HasNotifyNoData s a => Lens' s a
notifyNoData))
                                     , (Key
"no_data_timeframe", Value -> (Integer -> Value) -> Maybe Integer -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Value
Null (Scientific -> Value
Number (Scientific -> Value)
-> (Integer -> Scientific) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (MonitorOptions
opts MonitorOptions
-> Getting (Maybe Integer) MonitorOptions (Maybe Integer)
-> Maybe Integer
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Integer) MonitorOptions (Maybe Integer)
forall s a. HasNoDataTimeframe s a => Lens' s a
noDataTimeframe))
                                     , (Key
"timeout_h", Value -> (Integer -> Value) -> Maybe Integer -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Value
Null (Scientific -> Value
Number (Scientific -> Value)
-> (Integer -> Scientific) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (MonitorOptions
opts MonitorOptions
-> Getting (Maybe Integer) MonitorOptions (Maybe Integer)
-> Maybe Integer
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Integer) MonitorOptions (Maybe Integer)
forall s a. HasTimeoutH s a => Lens' s a
timeoutH))
                                     , (Key
"renotify_interval", Value -> (Integer -> Value) -> Maybe Integer -> Value
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Value
Null (Scientific -> Value
Number (Scientific -> Value)
-> (Integer -> Scientific) -> Integer -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Scientific
forall a b. (Integral a, Num b) => a -> b
fromIntegral) (MonitorOptions
opts MonitorOptions
-> Getting (Maybe Integer) MonitorOptions (Maybe Integer)
-> Maybe Integer
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Integer) MonitorOptions (Maybe Integer)
forall s a. HasRenotifyInterval s a => Lens' s a
renotifyInterval))
                                     , (Key
"escalation_message", Text -> Value
Data.Aeson.String (MonitorOptions
opts MonitorOptions -> Getting Text MonitorOptions Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text MonitorOptions Text
forall s a. HasEscalationMessage s a => Lens' s a
escalationMessage))
                                     , (Key
"notify_audit", Bool -> Value
Bool (MonitorOptions
opts MonitorOptions -> Getting Bool MonitorOptions Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool MonitorOptions Bool
forall s a. HasNotifyAudit s a => Lens' s a
notifyAudit))
                                     ]

instance FromJSON MonitorOptions where
  parseJSON :: Value -> Parser MonitorOptions
parseJSON (Object Object
v) = (String -> String)
-> Parser MonitorOptions -> Parser MonitorOptions
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorOptions: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser MonitorOptions -> Parser MonitorOptions)
-> Parser MonitorOptions -> Parser MonitorOptions
forall a b. (a -> b) -> a -> b
$
                         HashMap Text (Maybe Integer)
-> Bool
-> Maybe Integer
-> Maybe Integer
-> Maybe Integer
-> Text
-> Bool
-> MonitorOptions
MonitorOptions (HashMap Text (Maybe Integer)
 -> Bool
 -> Maybe Integer
 -> Maybe Integer
 -> Maybe Integer
 -> Text
 -> Bool
 -> MonitorOptions)
-> Parser (HashMap Text (Maybe Integer))
-> Parser
     (Bool
      -> Maybe Integer
      -> Maybe Integer
      -> Maybe Integer
      -> Text
      -> Bool
      -> MonitorOptions)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         Object
v Object -> Key -> Parser (Maybe (HashMap Text (Maybe Integer)))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"silenced" Parser (Maybe (HashMap Text (Maybe Integer)))
-> HashMap Text (Maybe Integer)
-> Parser (HashMap Text (Maybe Integer))
forall a. Parser (Maybe a) -> a -> Parser a
.!= HashMap Text (Maybe Integer)
forall k v. HashMap k v
HM.empty Parser
  (Bool
   -> Maybe Integer
   -> Maybe Integer
   -> Maybe Integer
   -> Text
   -> Bool
   -> MonitorOptions)
-> Parser Bool
-> Parser
     (Maybe Integer
      -> Maybe Integer
      -> Maybe Integer
      -> Text
      -> Bool
      -> MonitorOptions)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"notify_no_data" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False Parser
  (Maybe Integer
   -> Maybe Integer
   -> Maybe Integer
   -> Text
   -> Bool
   -> MonitorOptions)
-> Parser (Maybe Integer)
-> Parser
     (Maybe Integer -> Maybe Integer -> Text -> Bool -> MonitorOptions)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Integer))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"no_data_timeframe" Parser (Maybe (Maybe Integer))
-> Maybe Integer -> Parser (Maybe Integer)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Integer
forall a. Maybe a
Nothing Parser
  (Maybe Integer -> Maybe Integer -> Text -> Bool -> MonitorOptions)
-> Parser (Maybe Integer)
-> Parser (Maybe Integer -> Text -> Bool -> MonitorOptions)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Integer))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"timeout_h" Parser (Maybe (Maybe Integer))
-> Maybe Integer -> Parser (Maybe Integer)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Integer
forall a. Maybe a
Nothing Parser (Maybe Integer -> Text -> Bool -> MonitorOptions)
-> Parser (Maybe Integer)
-> Parser (Text -> Bool -> MonitorOptions)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Integer))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"renotify_interval" Parser (Maybe (Maybe Integer))
-> Maybe Integer -> Parser (Maybe Integer)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Integer
forall a. Maybe a
Nothing Parser (Text -> Bool -> MonitorOptions)
-> Parser Text -> Parser (Bool -> MonitorOptions)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"escalation_message" Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
"" Parser (Bool -> MonitorOptions)
-> Parser Bool -> Parser MonitorOptions
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"notify_audit" Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
  parseJSON Value
a = (String -> String)
-> Parser MonitorOptions -> Parser MonitorOptions
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorOptions: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser MonitorOptions -> Parser MonitorOptions)
-> Parser MonitorOptions -> Parser MonitorOptions
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser MonitorOptions
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON MonitorSpec where
  toJSON :: MonitorSpec -> Value
toJSON MonitorSpec
ms = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
forall v. Key -> v -> KeyMap v -> KeyMap v
KM.insert Key
"options" (MonitorOptions -> Value
forall a. ToJSON a => a -> Value
toJSON (MonitorSpec
ms MonitorSpec
-> Getting MonitorOptions MonitorSpec MonitorOptions
-> MonitorOptions
forall s a. s -> Getting a s a -> a
^. Getting MonitorOptions MonitorSpec MonitorOptions
forall s a. HasOptions s a => Lens' s a
options)) Object
hmap
    where (Object Object
hmap) = [Pair] -> Value
object ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$
                          (Text -> Pair) -> Maybe Text -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (Key
"name" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.=) (MonitorSpec
ms MonitorSpec
-> Getting (Maybe Text) MonitorSpec (Maybe Text) -> Maybe Text
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Text) MonitorSpec (Maybe Text)
forall s a. HasName s a => Lens' s a
name) ([Pair] -> [Pair]) -> [Pair] -> [Pair]
forall a b. (a -> b) -> a -> b
$
                          (Text -> Pair) -> Maybe Text -> [Pair] -> [Pair]
forall a b. (a -> b) -> Maybe a -> [b] -> [b]
prependMaybe (Key
"message" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.=) (MonitorSpec
ms MonitorSpec
-> Getting (Maybe Text) MonitorSpec (Maybe Text) -> Maybe Text
forall s a. s -> Getting a s a -> a
^. Getting (Maybe Text) MonitorSpec (Maybe Text)
forall s a. HasMessage s a => Lens' s a
message)
                          [ Key
"type" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Text
pack (MonitorType -> String
forall a. Show a => a -> String
show (MonitorSpec
ms MonitorSpec
-> Getting MonitorType MonitorSpec MonitorType -> MonitorType
forall s a. s -> Getting a s a -> a
^. Getting MonitorType MonitorSpec MonitorType
forall s a. HasType' s a => Lens' s a
type'))
                          , Key
"query" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= (MonitorSpec
ms MonitorSpec -> Getting Text MonitorSpec Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text MonitorSpec Text
forall s a. HasQuery s a => Lens' s a
query)
                          ]

-- | Creates the most basic specification required by a monitor, containing the
-- type of monitor and the query string used to detect the monitor's state.
--
-- Generates a set of "default" Monitor options, which specify as little
-- optional configuration as possible.  This includes:
--
--   * No silencing of any part of the monitor
--   * No notification when data related to the monitor is missing
--   * No alert timeout after the monitor is triggeredn
--   * No renotification when the monitor is triggered
--   * No notification when the monitor is modified
--
-- In production situations, it is /not safe/ to rely on this documented
-- default behaviour for critical setitngs; use the helper functions to
-- introspect the MonitorOptions instance provided by this function. This also
-- protects against future modifications to this API.
defaultMonitorOptions :: MonitorOptions
defaultMonitorOptions :: MonitorOptions
defaultMonitorOptions = MonitorOptions :: HashMap Text (Maybe Integer)
-> Bool
-> Maybe Integer
-> Maybe Integer
-> Maybe Integer
-> Text
-> Bool
-> MonitorOptions
MonitorOptions { monitorOptionsSilenced :: HashMap Text (Maybe Integer)
monitorOptionsSilenced = HashMap Text (Maybe Integer)
forall k v. HashMap k v
HM.empty
                                       , monitorOptionsNotifyNoData :: Bool
monitorOptionsNotifyNoData = Bool
False
                                       , monitorOptionsNoDataTimeframe :: Maybe Integer
monitorOptionsNoDataTimeframe = Maybe Integer
forall a. Maybe a
Nothing
                                       , monitorOptionsTimeoutH :: Maybe Integer
monitorOptionsTimeoutH = Maybe Integer
forall a. Maybe a
Nothing
                                       , monitorOptionsRenotifyInterval :: Maybe Integer
monitorOptionsRenotifyInterval = Maybe Integer
forall a. Maybe a
Nothing
                                       , monitorOptionsEscalationMessage :: Text
monitorOptionsEscalationMessage = Text
""
                                       , monitorOptionsNotifyAudit :: Bool
monitorOptionsNotifyAudit = Bool
False
                                       }

instance FromJSON MonitorSpec where
  parseJSON :: Value -> Parser MonitorSpec
parseJSON (Object Object
v) = (String -> String) -> Parser MonitorSpec -> Parser MonitorSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser MonitorSpec -> Parser MonitorSpec)
-> Parser MonitorSpec -> Parser MonitorSpec
forall a b. (a -> b) -> a -> b
$
                         MonitorType
-> Text
-> Maybe Text
-> Maybe Text
-> MonitorOptions
-> MonitorSpec
MonitorSpec (MonitorType
 -> Text
 -> Maybe Text
 -> Maybe Text
 -> MonitorOptions
 -> MonitorSpec)
-> Parser MonitorType
-> Parser
     (Text -> Maybe Text -> Maybe Text -> MonitorOptions -> MonitorSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         Object
v Object -> Key -> Parser MonitorType
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type" Parser
  (Text -> Maybe Text -> Maybe Text -> MonitorOptions -> MonitorSpec)
-> Parser Text
-> Parser
     (Maybe Text -> Maybe Text -> MonitorOptions -> MonitorSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"query" Parser (Maybe Text -> Maybe Text -> MonitorOptions -> MonitorSpec)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> MonitorOptions -> MonitorSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing Parser (Maybe Text -> MonitorOptions -> MonitorSpec)
-> Parser (Maybe Text) -> Parser (MonitorOptions -> MonitorSpec)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe (Maybe Text))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"message" Parser (Maybe (Maybe Text)) -> Maybe Text -> Parser (Maybe Text)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Maybe Text
forall a. Maybe a
Nothing Parser (MonitorOptions -> MonitorSpec)
-> Parser MonitorOptions -> Parser MonitorSpec
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                         Object
v Object -> Key -> Parser (Maybe MonitorOptions)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"options" Parser (Maybe MonitorOptions)
-> MonitorOptions -> Parser MonitorOptions
forall a. Parser (Maybe a) -> a -> Parser a
.!= MonitorOptions
defaultMonitorOptions
  parseJSON Value
a = (String -> String) -> Parser MonitorSpec -> Parser MonitorSpec
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"MonitorSpec: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser MonitorSpec -> Parser MonitorSpec)
-> Parser MonitorSpec -> Parser MonitorSpec
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser MonitorSpec
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a

instance ToJSON Monitor where
  toJSON :: Monitor -> Value
toJSON Monitor
monitor = Object -> Value
Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ Key -> Value -> Object -> Object
forall v. Key -> v -> KeyMap v -> KeyMap v
KM.insert Key
"id" (Int -> Value
forall a. ToJSON a => a -> Value
toJSON (Monitor
monitor Monitor -> Getting Int Monitor Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int Monitor Int
forall s a. HasId' s a => Lens' s a
id')) Object
basemap
    where (Object Object
basemap) = MonitorSpec -> Value
forall a. ToJSON a => a -> Value
toJSON (Monitor
monitor Monitor -> Getting MonitorSpec Monitor MonitorSpec -> MonitorSpec
forall s a. s -> Getting a s a -> a
^. Getting MonitorSpec Monitor MonitorSpec
forall s a. HasSpec s a => Lens' s a
spec)

instance FromJSON Monitor where
  parseJSON :: Value -> Parser Monitor
parseJSON (Object Object
v) = (String -> String) -> Parser Monitor -> Parser Monitor
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Monitor: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ) (Parser Monitor -> Parser Monitor)
-> Parser Monitor -> Parser Monitor
forall a b. (a -> b) -> a -> b
$
                         Int -> MonitorSpec -> Monitor
Monitor (Int -> MonitorSpec -> Monitor)
-> Parser Int -> Parser (MonitorSpec -> Monitor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id" Parser (MonitorSpec -> Monitor)
-> Parser MonitorSpec -> Parser Monitor
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser MonitorSpec
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
  parseJSON Value
a = (String -> String) -> Parser Monitor -> Parser Monitor
forall a. (String -> String) -> Parser a -> Parser a
modifyFailure (String
"Monitor: " String -> String -> String
forall a. [a] -> [a] -> [a]
++) (Parser Monitor -> Parser Monitor)
-> Parser Monitor -> Parser Monitor
forall a b. (a -> b) -> a -> b
$ String -> Value -> Parser Monitor
forall a. String -> Value -> Parser a
typeMismatch String
"Object" Value
a